@effect/language-service 0.24.2 → 0.25.1

package/index.js

@@ -56,9 +56,9 @@ var dual = function(arity, body) {
         if (arguments.length >= arity) {
           return body.apply(this, arguments);
         }
-        const args = arguments;
+        const args2 = arguments;
         return function(self) {
-          return body(self, ...args);
+          return body(self, ...args2);
         };
       };
   }
@@ -144,7 +144,6 @@ var getBugErrorMessage = (message) => `BUG: ${message} - please report an issue
 
 // node_modules/.pnpm/effect@3.16.12/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) {
@@ -477,32 +476,32 @@ var redact = (u) => {
 };
 
 // node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/Pipeable.js
-var pipeArguments = (self, args) => {
-  switch (args.length) {
+var pipeArguments = (self, args2) => {
+  switch (args2.length) {
     case 0:
       return self;
     case 1:
-      return args[0](self);
+      return args2[0](self);
     case 2:
-      return args[1](args[0](self));
+      return args2[1](args2[0](self));
     case 3:
-      return args[2](args[1](args[0](self)));
+      return args2[2](args2[1](args2[0](self)));
     case 4:
-      return args[3](args[2](args[1](args[0](self))));
+      return args2[3](args2[2](args2[1](args2[0](self))));
     case 5:
-      return args[4](args[3](args[2](args[1](args[0](self)))));
+      return args2[4](args2[3](args2[2](args2[1](args2[0](self)))));
     case 6:
-      return args[5](args[4](args[3](args[2](args[1](args[0](self))))));
+      return args2[5](args2[4](args2[3](args2[2](args2[1](args2[0](self))))));
     case 7:
-      return args[6](args[5](args[4](args[3](args[2](args[1](args[0](self)))))));
+      return args2[6](args2[5](args2[4](args2[3](args2[2](args2[1](args2[0](self)))))));
     case 8:
-      return args[7](args[6](args[5](args[4](args[3](args[2](args[1](args[0](self))))))));
+      return args2[7](args2[6](args2[5](args2[4](args2[3](args2[2](args2[1](args2[0](self))))))));
     case 9:
-      return args[8](args[7](args[6](args[5](args[4](args[3](args[2](args[1](args[0](self)))))))));
+      return args2[8](args2[7](args2[6](args2[5](args2[4](args2[3](args2[2](args2[1](args2[0](self)))))))));
     default: {
       let ret = self;
-      for (let i = 0, len = args.length; i < len; i++) {
-        ret = args[i](ret);
+      for (let i = 0, len = args2.length; i < len; i++) {
+        ret = args2[i](ret);
       }
       return ret;
     }
@@ -834,181 +833,278 @@ var dedupeWith = /* @__PURE__ */ dual(2, (self, isEquivalent) => {
 var dedupe = (self) => dedupeWith(self, equivalence());
 
 // src/core/Nano.ts
-function makeInternalSuccess(value) {
-  return { _tag: "Right", value };
-}
-function makeInternalDefect(value) {
-  return { _tag: "Defect", value };
-}
+var NanoTag = class {
+  constructor(key) {
+    this.key = key;
+  }
+};
+var Tag = (identifier) => new NanoTag(identifier);
+var evaluate = Symbol.for("Nano.evaluate");
+var contA = Symbol.for("Nano.contA");
+var contE = Symbol.for("Nano.contE");
+var contAll = Symbol.for("Nano.contAll");
+var NanoYield = Symbol.for("Nano.yield");
+var args = Symbol.for("Nano.args");
 var NanoDefectException = class {
   constructor(message) {
     this.message = message;
   }
   _tag = "@effect/language-service/NanoDefectException";
 };
-var NanoTag = class {
-  constructor(key) {
-    this.key = key;
+var PrimitiveProto = {
+  [Symbol.iterator]() {
+    return new SingleShotGen(new YieldWrap(this));
   }
 };
-var Tag = (identifier) => new NanoTag(identifier);
-var contextEmpty = { value: {} };
-function make3(run2) {
-  const nano = {
-    run: run2,
-    [Symbol.iterator]() {
-      return new SingleShotGen(new YieldWrap(this));
-    }
-  };
+var SucceedProto = {
+  ...PrimitiveProto,
+  _tag: "Success",
+  get value() {
+    return this[args];
+  },
+  [evaluate](fiber) {
+    const cont = fiber.getCont(contA);
+    return cont ? cont[contA](this[args], fiber) : fiber.yieldWith(this);
+  }
+};
+var succeed = (value) => {
+  const nano = Object.create(SucceedProto);
+  nano[args] = value;
   return nano;
-}
-var unsafeRun = (fa) => {
-  const program = provideService(internalNanoCache, {})(fa);
-  const result = program.run(contextEmpty);
-  switch (result._tag) {
-    case "Left":
-      return left2(result.value);
-    case "Defect":
-      return left2(new NanoDefectException(result.value));
-    case "Right":
-      return right2(result.value);
-  }
-};
-var run = (fa) => {
+};
+var FailureProto = {
+  ...PrimitiveProto,
+  _tag: "Failure",
+  get value() {
+    return this[args];
+  },
+  [evaluate](fiber) {
+    const cont = fiber.getCont(contE);
+    return cont ? cont[contE](this[args], fiber) : fiber.yieldWith(this);
+  }
+};
+var fail = (error) => {
+  const nano = Object.create(FailureProto);
+  nano[args] = error;
+  return nano;
+};
+var SuspendProto = {
+  ...PrimitiveProto,
+  [evaluate]() {
+    return this[args]();
+  }
+};
+var suspend = (fn2) => {
+  const nano = Object.create(SuspendProto);
+  nano[args] = fn2;
+  return nano;
+};
+var NanoFiber = class {
+  _stack = [];
+  _yielded = void 0;
+  _services = {};
+  _cache = {};
+  runLoop(nano) {
+    let current = nano;
+    while (true) {
+      current = current[evaluate](this);
+      if (current === NanoYield) {
+        return this._yielded;
+      }
+    }
+  }
+  getCont(symbol3) {
+    while (true) {
+      const op = this._stack.pop();
+      if (!op) return void 0;
+      const cont = op[contAll] && op[contAll](this);
+      if (cont) return { [symbol3]: cont };
+      if (op[symbol3]) return op;
+    }
+  }
+  yieldWith(value) {
+    this._yielded = value;
+    return NanoYield;
+  }
+};
+var unsafeRun = (nano) => {
+  const fiber = new NanoFiber();
+  const result = fiber.runLoop(nano);
+  if (result._tag === "Success") {
+    return right2(result.value);
+  }
+  return left2(result.value);
+};
+var run = (nano) => {
   try {
-    return unsafeRun(fa);
+    return unsafeRun(nano);
   } catch (e) {
     return left2(new NanoDefectException(e));
   }
 };
-var succeed = (value) => {
-  const nano = {
-    run: () => ({ _tag: "Right", value }),
-    [Symbol.iterator]() {
-      return new SingleShotGen(new YieldWrap(this));
-    }
-  };
+var OnSuccessProto = {
+  ...PrimitiveProto,
+  [evaluate](fiber) {
+    fiber._stack.push(this);
+    return this[args];
+  }
+};
+var flatMap2 = dual(2, (fa, f) => {
+  const nano = Object.create(OnSuccessProto);
+  nano[args] = fa;
+  nano[contA] = f;
+  return nano;
+});
+var map4 = dual(2, (fa, f) => flatMap2(fa, (_) => succeed(f(_))));
+var SyncProto = {
+  ...PrimitiveProto,
+  [evaluate](fiber) {
+    const value = this[args]();
+    const cont = fiber.getCont(contA);
+    return cont ? cont[contA](value, fiber) : fiber.yieldWith(succeed(value));
+  }
+};
+var sync = (f) => {
+  const nano = Object.create(SyncProto);
+  nano[args] = f;
   return nano;
 };
-var fail = (value) => {
-  const nano = {
-    run: () => ({ _tag: "Left", value }),
-    [Symbol.iterator]() {
-      return new SingleShotGen(new YieldWrap(this));
-    }
-  };
+var void_ = succeed(void 0);
+var FromIteratorProto = {
+  ...PrimitiveProto,
+  [contA](value, fiber) {
+    const state = this[args][0].next(value);
+    if (state.done) return succeed(state.value);
+    fiber._stack.push(this);
+    return yieldWrapGet(state.value);
+  },
+  [evaluate](fiber) {
+    return this[contA](this[args][1], fiber);
+  }
+};
+var unsafeFromIterator = (iterator, initial) => {
+  const nano = Object.create(FromIteratorProto);
+  nano[args] = [iterator, initial];
   return nano;
 };
-var sync = (value) => {
-  const nano = {
-    run: () => ({ _tag: "Right", value: value() }),
-    [Symbol.iterator]() {
-      return new SingleShotGen(new YieldWrap(this));
-    }
-  };
+var gen = (...args2) => suspend(() => unsafeFromIterator(args2[0]()));
+var fn = (_) => (body) => (...args2) => suspend(() => unsafeFromIterator(body(...args2)));
+var MatchProto = {
+  ...PrimitiveProto,
+  [evaluate](fiber) {
+    fiber._stack.push(this);
+    return this[args];
+  }
+};
+var match2 = (fa, opts) => {
+  const nano = Object.create(MatchProto);
+  nano[args] = fa;
+  nano[contA] = opts.onSuccess;
+  nano[contE] = opts.onFailure;
+  return nano;
+};
+var orElse2 = (f) => (fa) => {
+  const nano = Object.create(MatchProto);
+  nano[args] = fa;
+  nano[contE] = f;
   return nano;
 };
-var flatMap2 = dual(2, (fa, f) => make3((ctx) => {
-  const result = fa.run(ctx);
-  if (result._tag !== "Right") return result;
-  return f(result.value).run(ctx);
-}));
-var map4 = dual(2, (fa, f) => make3((ctx) => {
-  const result = fa.run(ctx);
-  if (result._tag !== "Right") return result;
-  return makeInternalSuccess(f(result.value));
-}));
-var orElse2 = (f) => (fa) => make3((ctx) => {
-  const result = fa.run(ctx);
-  if (result._tag === "Left") return f(result.value).run(ctx);
-  return result;
-});
 var firstSuccessOf = (arr) => arr.slice(1).reduce((arr2, fa) => orElse2(() => fa)(arr2), arr[0]);
-var service = (tag) => make3(
-  (ctx) => tag.key in ctx.value ? ctx.value[tag.key] : makeInternalDefect(`Cannot find service ${tag.key}`)
-);
-var provideService = (tag, value) => (fa) => make3((ctx) => {
-  return fa.run({
-    ...ctx,
-    value: {
-      ...ctx.value,
-      [tag.key]: makeInternalSuccess(value)
-    }
-  });
-});
-var gen = (...args) => make3((ctx) => {
-  const iterator = args[0]();
-  let state = iterator.next();
-  while (!state.done) {
-    const current = isGenKind(state.value) ? state.value.value : yieldWrapGet(state.value);
-    const result = current.run(ctx);
-    if (result._tag !== "Right") {
-      return result;
-    }
-    state = iterator.next(result.value);
+var ProvideServiceProto = {
+  ...PrimitiveProto,
+  [evaluate](fiber) {
+    const prevServices = fiber._services;
+    const [fa, tag, value] = this[args];
+    fiber._services = {
+      ...fiber._services,
+      [tag.key]: value
+    };
+    return match2(fa, {
+      onSuccess: (_) => {
+        fiber._services = prevServices;
+        return succeed(_);
+      },
+      onFailure: (_) => {
+        fiber._services = prevServices;
+        return fail(_);
+      }
+    });
   }
-  return makeInternalSuccess(state.value);
-});
-var fn = (_) => (body) => (...args) => make3((ctx) => {
-  const iterator = body(...args);
-  let state = iterator.next();
-  while (!state.done) {
-    const current = isGenKind(state.value) ? state.value.value : yieldWrapGet(state.value);
-    const result = current.run(ctx);
-    if (result._tag !== "Right") {
-      return result;
+};
+var provideService = (tag, value) => (fa) => {
+  const nano = Object.create(ProvideServiceProto);
+  nano[args] = [fa, tag, value];
+  return nano;
+};
+var ServiceProto = {
+  ...PrimitiveProto,
+  [evaluate](fiber) {
+    const tag = this[args];
+    if (tag.key in fiber._services) {
+      const value = fiber._services[tag.key];
+      const cont2 = fiber.getCont(contA);
+      return cont2 ? cont2[contA](value, fiber) : fiber.yieldWith(succeed(value));
     }
-    state = iterator.next(result.value);
+    const cont = fiber.getCont(contE);
+    return cont ? cont[contE](tag, fiber) : fiber.yieldWith(fail(new NanoDefectException(`Service ${tag.key} not found`)));
   }
-  return makeInternalSuccess(state.value);
-});
-var option = (fa) => make3((ctx) => {
-  const result = fa.run(ctx);
-  switch (result._tag) {
-    case "Right":
-      return makeInternalSuccess(some2(result.value));
-    case "Left":
-      return makeInternalSuccess(none2());
-    case "Defect":
-      return result;
+};
+var service = (tag) => {
+  const nano = Object.create(ServiceProto);
+  nano[args] = tag;
+  return nano;
+};
+var CachedProto = {
+  ...PrimitiveProto,
+  [evaluate](fiber) {
+    const [fa, type, key] = this[args];
+    const cache = fiber._cache[type] || /* @__PURE__ */ new WeakMap();
+    fiber._cache[type] = cache;
+    const cached2 = cache.get(key);
+    if (cached2) return cached2;
+    return match2(fa, {
+      onSuccess: (_) => {
+        cache.set(key, succeed(_));
+        return succeed(_);
+      },
+      onFailure: (_) => {
+        cache.set(key, fail(_));
+        return fail(_);
+      }
+    });
   }
-});
-var successUndefined = makeInternalSuccess(void 0);
-var void_ = make3(() => successUndefined);
-var ignore = (fa) => make3((ctx) => {
-  fa.run(ctx);
-  return successUndefined;
-});
-var all = (...args) => make3((ctx) => {
-  const results = [];
-  for (const arg of args) {
-    const result = arg.run(ctx);
-    if (result._tag !== "Right") return result;
-    results.push(result.value);
-  }
-  return makeInternalSuccess(results);
-});
-var internalNanoCache = Tag(
-  "@effect/language-service/internalNanoCache"
-);
-function cachedBy(fa, key, lookupKey) {
-  return (...args) => make3((ctx) => {
-    const cacheObj = ctx.value[internalNanoCache.key];
-    let cache = cacheObj[key];
-    if (!cache) {
-      cache = /* @__PURE__ */ new Map();
-      cacheObj[key] = cache;
-    }
-    const lookup = lookupKey(...args);
-    const cached2 = cache.get(lookup);
-    if (cached2 !== void 0) {
-      return cached2;
-    }
-    const result = fa(...args).run(ctx);
-    cache.set(lookup, result);
-    return result;
-  });
+};
+function cachedBy(fa, type, lookupKey) {
+  return (...p) => {
+    const nano = Object.create(CachedProto);
+    nano[args] = [fa(...p), type, lookupKey(...p)];
+    return nano;
+  };
 }
+var option = (fa) => {
+  const nano = Object.create(MatchProto);
+  nano[args] = fa;
+  nano[contA] = (_) => succeed(some2(_));
+  nano[contE] = (_) => _ instanceof NanoDefectException ? fail(_) : succeed(none2());
+  return nano;
+};
+var ignore = (fa) => {
+  const nano = Object.create(MatchProto);
+  nano[args] = fa;
+  nano[contA] = (_) => void_;
+  nano[contE] = (_) => _ instanceof NanoDefectException ? fail(_) : void_;
+  return nano;
+};
+var all = fn("all")(
+  function* (...args2) {
+    const results = [];
+    for (const fa of args2) {
+      const result = yield* fa;
+      results.push(result);
+    }
+    return results;
+  }
+);
 
 // src/core/TypeScriptApi.ts
 var TypeScriptApi = Tag("TypeScriptApi");
@@ -1568,10 +1664,10 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
     const sectionOverrides = {};
     const skippedRules = [];
     const regex = /@effect-diagnostics(-next-line)?((?:\s[a-zA-Z0-9/]+:(?:off|warning|error|message|suggestion|skip-file))+)?/gm;
-    let match2;
-    while ((match2 = regex.exec(sourceFile.text)) !== null) {
-      const nextLineCaptureGroup = match2[1];
-      const rulesCaptureGroup = match2[2];
+    let match3;
+    while ((match3 = regex.exec(sourceFile.text)) !== null) {
+      const nextLineCaptureGroup = match3[1];
+      const rulesCaptureGroup = match3[2];
       if (rulesCaptureGroup) {
         const trimmedRuleString = rulesCaptureGroup.trim();
         if (trimmedRuleString) {
@@ -1583,7 +1679,7 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
               if (ruleLevel === "skip-file") skippedRules.push(ruleName);
               const isOverrideNextLine = nextLineCaptureGroup && nextLineCaptureGroup.trim().toLowerCase() === "-next-line";
               if (isOverrideNextLine) {
-                const node = findNodeWithLeadingCommentAtPosition(match2.index);
+                const node = findNodeWithLeadingCommentAtPosition(match3.index);
                 if (node) {
                   lineOverrides[ruleName] = lineOverrides[ruleName] || [];
                   lineOverrides[ruleName].unshift({
@@ -1595,7 +1691,7 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
               } else {
                 sectionOverrides[ruleName] = sectionOverrides[ruleName] || [];
                 sectionOverrides[ruleName].unshift({
-                  pos: match2.index,
+                  pos: match3.index,
                   level: ruleLevel
                 });
               }
@@ -1725,93 +1821,6 @@ var contextSelfInClasses = createCompletion({
   })
 });
 
-// src/completions/effectDataClasses.ts
-var effectDataClasses = createCompletion({
-  name: "effectDataClasses",
-  apply: fn("effectDataClasses")(function* (sourceFile, position) {
-    const ts = yield* service(TypeScriptApi);
-    const maybeInfos = yield* option(
-      parseDataForExtendsClassCompletion(sourceFile, position)
-    );
-    if (isNone2(maybeInfos)) return [];
-    const { accessedObject, className, replacementSpan } = maybeInfos.value;
-    const dataName = yield* option(
-      findImportedModuleIdentifierByPackageAndNameOrBarrel(
-        sourceFile,
-        "effect",
-        "Data"
-      )
-    );
-    const effectDataIdentifier = match(dataName, {
-      onNone: () => "Data",
-      onSome: (_) => _.text
-    });
-    if (effectDataIdentifier !== accessedObject.text) return [];
-    const name = className.text;
-    return [{
-      name: `TaggedError("${name}")`,
-      kind: ts.ScriptElementKind.constElement,
-      insertText: `${effectDataIdentifier}.TaggedError("${name}")<{${"${0}"}}>{}`,
-      replacementSpan,
-      isSnippet: true
-    }, {
-      name: `TaggedClass("${name}")`,
-      kind: ts.ScriptElementKind.constElement,
-      insertText: `${effectDataIdentifier}.TaggedClass("${name}")<{${"${0}"}}>{}`,
-      replacementSpan,
-      isSnippet: true
-    }];
-  })
-});
-
-// src/diagnostics/duplicatePackage.ts
-var checkedPackagesCache = /* @__PURE__ */ new Map();
-var programResolvedCacheSize = /* @__PURE__ */ new Map();
-var duplicatePackage = createDiagnostic({
-  name: "duplicatePackage",
-  code: 6,
-  severity: "warning",
-  apply: fn("duplicatePackage.apply")(function* (sourceFile, report) {
-    const program = yield* service(TypeScriptProgram);
-    const options = yield* service(LanguageServicePluginOptions);
-    if (sourceFile.statements.length < 1) return;
-    let resolvedPackages = checkedPackagesCache.get(sourceFile.fileName) || {};
-    const newResolvedModuleSize = hasProperty(program, "resolvedModules") && hasProperty(program.resolvedModules, "size") && isNumber(program.resolvedModules.size) ? program.resolvedModules.size : 0;
-    const oldResolvedSize = programResolvedCacheSize.get(sourceFile.fileName) || -1;
-    if (newResolvedModuleSize !== oldResolvedSize) {
-      const seenPackages = /* @__PURE__ */ new Set();
-      resolvedPackages = {};
-      program.getSourceFiles().map((_) => {
-        const packageInfo = parsePackageContentNameAndVersionFromScope(_);
-        if (!packageInfo) return;
-        const packageNameAndVersion = packageInfo.name + "@" + packageInfo.version;
-        if (seenPackages.has(packageNameAndVersion)) return;
-        seenPackages.add(packageNameAndVersion);
-        if (!(packageInfo.name === "effect" || packageInfo.hasEffectInPeerDependencies)) return;
-        if (options.allowedDuplicatedPackages.indexOf(packageInfo.name) > -1) return;
-        resolvedPackages[packageInfo.name] = resolvedPackages[packageInfo.name] || {};
-        resolvedPackages[packageInfo.name][packageInfo.version] = packageInfo.packageDirectory;
-      });
-      checkedPackagesCache.set(sourceFile.fileName, resolvedPackages);
-      programResolvedCacheSize.set(sourceFile.fileName, newResolvedModuleSize);
-    }
-    for (const packageName of Object.keys(resolvedPackages)) {
-      if (Object.keys(resolvedPackages[packageName]).length > 1) {
-        const versions = Object.keys(resolvedPackages[packageName]);
-        report({
-          node: sourceFile.statements[0],
-          messageText: `Package ${packageName} is referenced multiple times with different versions (${versions.join(", ")}) and may cause unexpected type errors.
-Cleanup your dependencies and your package lockfile to avoid multiple instances of this package and reload the project.
-If this is intended set the LSP config "allowedDuplicatedPackages" to ${JSON.stringify(options.allowedDuplicatedPackages.concat([packageName]))}.
-
-${versions.map((version) => `- found ${version} at ${resolvedPackages[packageName][version]}`).join("\n")}`,
-          fixes: []
-        });
-      }
-    }
-  })
-});
-
 // src/core/TypeCheckerApi.ts
 var TypeCheckerApi = Tag("TypeChecker");
 var TypeCheckerApiCache = Tag("TypeCheckerApiCache");
@@ -2018,11 +2027,23 @@ var expectedAndRealType = fn("TypeCheckerApi.expectedAndRealType")(function* (so
   cache.expectedAndRealType.set(sourceFile, result);
   return result;
 });
+var unrollUnionMembers = (type) => {
+  const result = [];
+  let toTest = [type];
+  while (toTest.length > 0) {
+    const type2 = toTest.pop();
+    if (type2.isUnion()) {
+      toTest = toTest.concat(type2.types);
+    } else {
+      result.push(type2);
+    }
+  }
+  return result;
+};
 var appendToUniqueTypesMap = fn(
   "TypeCheckerApi.appendToUniqueTypesMap"
 )(
-  function* (memory, initialType, excludeNever) {
-    const ts = yield* service(TypeScriptApi);
+  function* (memory, initialType, shouldExclude) {
     const typeChecker = yield* service(TypeCheckerApi);
     const newIndexes = /* @__PURE__ */ new Set();
     const knownIndexes = /* @__PURE__ */ new Set();
@@ -2030,7 +2051,7 @@ var appendToUniqueTypesMap = fn(
     while (toTest.length > 0) {
       const type = toTest.pop();
       if (!type) break;
-      if (excludeNever && type.flags & ts.TypeFlags.Never) {
+      if (yield* shouldExclude(type)) {
         continue;
       }
       if (type.isUnion()) {
@@ -2073,16 +2094,145 @@ function makeResolveExternalModuleName(typeChecker) {
   };
 }
 
+// src/completions/durationInput.ts
+var durationInput = createCompletion({
+  name: "durationInput",
+  apply: fn("durationInput")(function* (sourceFile, position) {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    let isInString = false;
+    const previousToken = ts.findPrecedingToken(position, sourceFile);
+    if (previousToken && ts.isStringTextContainingNode(previousToken)) {
+      const start = previousToken.getStart(sourceFile);
+      const end = previousToken.getEnd();
+      if (start < position && position < end) {
+        isInString = true;
+      }
+      if (position === end) {
+        isInString = !!previousToken.isUnterminated;
+      }
+      if (isInString && ts.isExpression(previousToken)) {
+        const type = typeChecker.getContextualType(previousToken);
+        if (type) {
+          if (!type.isUnion()) return [];
+          for (const member of type.types) {
+            if (member.flags & ts.TypeFlags.TemplateLiteral) {
+              if (hasProperty(member, "texts") && isArray(member.texts) && member.texts.length === 2 && String(member.texts[1]).trim() === "nanos") {
+                return ["nanos", "micros", "millis", "seconds", "minutes", "hours", "days", "weeks"].map(
+                  (name) => ({
+                    name,
+                    kind: ts.ScriptElementKind.string,
+                    insertText: `${"${0}"} ${name}`,
+                    isSnippet: true
+                  })
+                );
+              }
+            }
+          }
+        }
+      }
+    }
+    return [];
+  })
+});
+
+// src/completions/effectDataClasses.ts
+var effectDataClasses = createCompletion({
+  name: "effectDataClasses",
+  apply: fn("effectDataClasses")(function* (sourceFile, position) {
+    const ts = yield* service(TypeScriptApi);
+    const maybeInfos = yield* option(
+      parseDataForExtendsClassCompletion(sourceFile, position)
+    );
+    if (isNone2(maybeInfos)) return [];
+    const { accessedObject, className, replacementSpan } = maybeInfos.value;
+    const dataName = yield* option(
+      findImportedModuleIdentifierByPackageAndNameOrBarrel(
+        sourceFile,
+        "effect",
+        "Data"
+      )
+    );
+    const effectDataIdentifier = match(dataName, {
+      onNone: () => "Data",
+      onSome: (_) => _.text
+    });
+    if (effectDataIdentifier !== accessedObject.text) return [];
+    const name = className.text;
+    return [{
+      name: `TaggedError("${name}")`,
+      kind: ts.ScriptElementKind.constElement,
+      insertText: `${effectDataIdentifier}.TaggedError("${name}")<{${"${0}"}}>{}`,
+      replacementSpan,
+      isSnippet: true
+    }, {
+      name: `TaggedClass("${name}")`,
+      kind: ts.ScriptElementKind.constElement,
+      insertText: `${effectDataIdentifier}.TaggedClass("${name}")<{${"${0}"}}>{}`,
+      replacementSpan,
+      isSnippet: true
+    }];
+  })
+});
+
+// src/diagnostics/duplicatePackage.ts
+var checkedPackagesCache = /* @__PURE__ */ new Map();
+var programResolvedCacheSize = /* @__PURE__ */ new Map();
+var duplicatePackage = createDiagnostic({
+  name: "duplicatePackage",
+  code: 6,
+  severity: "warning",
+  apply: fn("duplicatePackage.apply")(function* (sourceFile, report) {
+    const program = yield* service(TypeScriptProgram);
+    const options = yield* service(LanguageServicePluginOptions);
+    if (sourceFile.statements.length < 1) return;
+    let resolvedPackages = checkedPackagesCache.get(sourceFile.fileName) || {};
+    const newResolvedModuleSize = hasProperty(program, "resolvedModules") && hasProperty(program.resolvedModules, "size") && isNumber(program.resolvedModules.size) ? program.resolvedModules.size : 0;
+    const oldResolvedSize = programResolvedCacheSize.get(sourceFile.fileName) || -1;
+    if (newResolvedModuleSize !== oldResolvedSize) {
+      const seenPackages = /* @__PURE__ */ new Set();
+      resolvedPackages = {};
+      program.getSourceFiles().map((_) => {
+        const packageInfo = parsePackageContentNameAndVersionFromScope(_);
+        if (!packageInfo) return;
+        const packageNameAndVersion = packageInfo.name + "@" + packageInfo.version;
+        if (seenPackages.has(packageNameAndVersion)) return;
+        seenPackages.add(packageNameAndVersion);
+        if (!(packageInfo.name === "effect" || packageInfo.hasEffectInPeerDependencies)) return;
+        if (options.allowedDuplicatedPackages.indexOf(packageInfo.name) > -1) return;
+        resolvedPackages[packageInfo.name] = resolvedPackages[packageInfo.name] || {};
+        resolvedPackages[packageInfo.name][packageInfo.version] = packageInfo.packageDirectory;
+      });
+      checkedPackagesCache.set(sourceFile.fileName, resolvedPackages);
+      programResolvedCacheSize.set(sourceFile.fileName, newResolvedModuleSize);
+    }
+    for (const packageName of Object.keys(resolvedPackages)) {
+      if (Object.keys(resolvedPackages[packageName]).length > 1) {
+        const versions = Object.keys(resolvedPackages[packageName]);
+        report({
+          node: sourceFile.statements[0],
+          messageText: `Package ${packageName} is referenced multiple times with different versions (${versions.join(", ")}) and may cause unexpected type errors.
+Cleanup your dependencies and your package lockfile to avoid multiple instances of this package and reload the project.
+If this is intended set the LSP config "allowedDuplicatedPackages" to ${JSON.stringify(options.allowedDuplicatedPackages.concat([packageName]))}.
+
+${versions.map((version) => `- found ${version} at ${resolvedPackages[packageName][version]}`).join("\n")}`,
+          fixes: []
+        });
+      }
+    }
+  })
+});
+
 // src/core/TypeParser.ts
 var TypeParser = Tag("@effect/language-service/TypeParser");
 var TypeParserIssue = class _TypeParserIssue {
   _tag = "@effect/language-service/TypeParserIssue";
   static issue = fail(new _TypeParserIssue());
 };
-function make4(ts, typeChecker) {
-  function typeParserIssue(_message, _type, _node) {
-    return TypeParserIssue.issue;
-  }
+function typeParserIssue(_message, _type, _node) {
+  return TypeParserIssue.issue;
+}
+function make3(ts, typeChecker) {
   function covariantTypeArgument(type) {
     const signatures = type.getCallSignatures();
     if (signatures.length !== 1) {
@@ -2527,8 +2677,8 @@ function make4(ts, typeChecker) {
         return succeed({ node, subject: node.expression.expression, args: Array.from(node.arguments) });
       }
       if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "pipe" && node.arguments.length > 0) {
-        const [subject, ...args] = node.arguments;
-        return succeed({ node, subject, args });
+        const [subject, ...args2] = node.arguments;
+        return succeed({ node, subject, args: args2 });
       }
       return typeParserIssue("Node is not a pipe call", void 0, node);
     },
@@ -2572,6 +2722,53 @@ function make4(ts, typeChecker) {
   };
 }
 
+// src/diagnostics/effectInVoidSuccess.ts
+var effectInVoidSuccess = createDiagnostic({
+  name: "effectInVoidSuccess",
+  code: 14,
+  severity: "warning",
+  apply: fn("effectInVoidSuccess.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
+    const checkForEffectInVoid = fn("effectInVoidSuccess.checkForEffectInVoid")(function* (node, expectedType, valueNode, realType) {
+      const expectedEffect = yield* typeParser.effectType(expectedType, node);
+      const realEffect = yield* typeParser.effectType(realType, valueNode);
+      if (expectedEffect.A.flags & ts.TypeFlags.Void) {
+        const voidValueTypes = unrollUnionMembers(realEffect.A);
+        const voidedEffect = yield* firstSuccessOf(
+          voidValueTypes.map((_) => map4(typeParser.strictEffectType(_, node), () => _))
+        );
+        return { voidedEffect };
+      }
+      return yield* fail(typeParserIssue("expectedEffect success is not void"));
+    });
+    const entries = yield* expectedAndRealType(sourceFile);
+    for (const [node, expectedType, valueNode, realType] of entries) {
+      if (expectedType !== realType) {
+        yield* pipe(
+          checkForEffectInVoid(
+            node,
+            expectedType,
+            valueNode,
+            realType
+          ),
+          map4(({ voidedEffect }) => {
+            report(
+              {
+                node,
+                messageText: `There is a nested '${typeChecker.typeToString(voidedEffect)}' in the 'void' success channel, beware that this could lead to nested Effect<Effect<...>> that won't be executed.`,
+                fixes: []
+              }
+            );
+          }),
+          ignore
+        );
+      }
+    }
+  })
+});
+
 // src/diagnostics/floatingEffect.ts
 var floatingEffect = createDiagnostic({
   name: "floatingEffect",
@@ -2841,7 +3038,18 @@ var leakingRequirements = createDiagnostic({
             );
             if (effectContextType) {
               effectMembers++;
-              const { allIndexes } = yield* appendToUniqueTypesMap(memory, effectContextType, true);
+              const { allIndexes } = yield* appendToUniqueTypesMap(
+                memory,
+                effectContextType,
+                (type) => {
+                  if (type.flags & ts.TypeFlags.Never) return succeed(true);
+                  return pipe(
+                    typeParser.scopeType(type, atLocation),
+                    map4(() => true),
+                    orElse2(() => succeed(false))
+                  );
+                }
+              );
               if (!sharedRequirementsKeys) {
                 sharedRequirementsKeys = allIndexes;
               } else {
@@ -3394,6 +3602,51 @@ Consider using "scoped" instead to get rid of the scope in the requirements.`,
   })
 });
 
+// src/diagnostics/tryCatchInEffectGen.ts
+var tryCatchInEffectGen = createDiagnostic({
+  name: "tryCatchInEffectGen",
+  code: 12,
+  severity: "suggestion",
+  apply: fn("tryCatchInEffectGen.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeParser = yield* service(TypeParser);
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      ts.forEachChild(node, appendNodeToVisit);
+      if (ts.isTryStatement(node)) {
+        const generatorOrRegularFunction = ts.findAncestor(
+          node,
+          (_) => ts.isFunctionExpression(_) || ts.isFunctionDeclaration(_) || ts.isMethodDeclaration(_) || ts.isArrowFunction(_) || ts.isGetAccessor(_) || ts.isFunctionLike(_)
+        );
+        if (!(generatorOrRegularFunction && "asteriskToken" in generatorOrRegularFunction && generatorOrRegularFunction.asteriskToken)) continue;
+        if (!generatorOrRegularFunction) continue;
+        if (generatorOrRegularFunction && generatorOrRegularFunction.parent) {
+          const effectGenNode = generatorOrRegularFunction.parent;
+          yield* pipe(
+            typeParser.effectGen(effectGenNode),
+            orElse2(() => typeParser.effectFnUntracedGen(effectGenNode)),
+            orElse2(() => typeParser.effectFnGen(effectGenNode)),
+            map4(() => {
+              report({
+                node,
+                messageText: "Avoid using try/catch inside Effect generators. Use Effect's error handling mechanisms instead (e.g., Effect.try, Effect.tryPromise, Effect.catchAll, Effect.catchTag).",
+                fixes: []
+              });
+            }),
+            ignore
+          );
+        }
+      }
+    }
+  })
+});
+
 // src/diagnostics/unnecessaryEffectGen.ts
 var unnecessaryEffectGen = createDiagnostic({
   name: "unnecessaryEffectGen",
@@ -3457,8 +3710,8 @@ var unnecessaryPipe = createDiagnostic({
       if (ts.isCallExpression(node)) {
         yield* pipe(
           typeParser.pipeCall(node),
-          map4(({ args, subject }) => {
-            if (args.length === 0) {
+          map4(({ args: args2, subject }) => {
+            if (args2.length === 0) {
               report({
                 node,
                 messageText: `This pipe call contains no arguments.`,
@@ -3495,8 +3748,10 @@ var diagnostics = [
   unnecessaryPipe,
   genericEffectServices,
   returnEffectInGen,
+  tryCatchInEffectGen,
   importFromBarrel,
-  scopeInLayerEffect
+  scopeInLayerEffect,
+  effectInVoidSuccess
 ];
 
 // src/completions/effectDiagnosticsComment.ts
@@ -3505,9 +3760,9 @@ var effectDiagnosticsComment = createCompletion({
   apply: fn("effectDiagnosticsComment")(function* (sourceFile, position) {
     const ts = yield* service(TypeScriptApi);
     const sourceText = sourceFile.text;
-    const match2 = /(\/\/|\/\*(?:\*?))\s*(@)\s*$/id.exec(sourceText.substring(0, position));
-    if (match2 && match2.indices) {
-      const lastIndex = match2.indices[2][0];
+    const match3 = /(\/\/|\/\*(?:\*?))\s*(@)\s*$/id.exec(sourceText.substring(0, position));
+    if (match3 && match3.indices) {
+      const lastIndex = match3.indices[2][0];
       const replacementSpan = {
         start: lastIndex,
         length: Math.max(0, position - lastIndex)
@@ -3738,7 +3993,8 @@ var completions = [
   genFunctionStar,
   fnFunctionStar,
   effectDataClasses,
-  effectDiagnosticsComment
+  effectDiagnosticsComment,
+  durationInput
 ];
 
 // src/completions/middlewareAutoImports.ts
@@ -5238,7 +5494,7 @@ var read_buf = (strm, buf, start, size) => {
 var longest_match = (s, cur_match) => {
   let chain_length = s.max_chain_length;
   let scan = s.strstart;
-  let match2;
+  let match3;
   let len;
   let best_len = s.prev_length;
   let nice_match = s.nice_match;
@@ -5256,14 +5512,14 @@ var longest_match = (s, cur_match) => {
     nice_match = s.lookahead;
   }
   do {
-    match2 = cur_match;
-    if (_win[match2 + best_len] !== scan_end || _win[match2 + best_len - 1] !== scan_end1 || _win[match2] !== _win[scan] || _win[++match2] !== _win[scan + 1]) {
+    match3 = cur_match;
+    if (_win[match3 + best_len] !== scan_end || _win[match3 + best_len - 1] !== scan_end1 || _win[match3] !== _win[scan] || _win[++match3] !== _win[scan + 1]) {
       continue;
     }
     scan += 2;
-    match2++;
+    match3++;
     do {
-    } while (_win[++scan] === _win[++match2] && _win[++scan] === _win[++match2] && _win[++scan] === _win[++match2] && _win[++scan] === _win[++match2] && _win[++scan] === _win[++match2] && _win[++scan] === _win[++match2] && _win[++scan] === _win[++match2] && _win[++scan] === _win[++match2] && scan < strend);
+    } while (_win[++scan] === _win[++match3] && _win[++scan] === _win[++match3] && _win[++scan] === _win[++match3] && _win[++scan] === _win[++match3] && _win[++scan] === _win[++match3] && _win[++scan] === _win[++match3] && _win[++scan] === _win[++match3] && _win[++scan] === _win[++match3] && scan < strend);
     len = MAX_MATCH - (strend - scan);
     scan = strend - MAX_MATCH;
     if (len > best_len) {
@@ -6964,7 +7220,7 @@ var inflate_table = (type, lens, lens_index, codes, table, table_index, work, op
   let mask;
   let next;
   let base = null;
-  let match2;
+  let match3;
   const count = new Uint16Array(MAXBITS + 1);
   const offs = new Uint16Array(MAXBITS + 1);
   let extra = null;
@@ -7020,15 +7276,15 @@ var inflate_table = (type, lens, lens_index, codes, table, table_index, work, op
   }
   if (type === CODES$1) {
     base = extra = work;
-    match2 = 20;
+    match3 = 20;
   } else if (type === LENS$1) {
     base = lbase;
     extra = lext;
-    match2 = 257;
+    match3 = 257;
   } else {
     base = dbase;
     extra = dext;
-    match2 = 0;
+    match3 = 0;
   }
   huff = 0;
   sym = 0;
@@ -7044,12 +7300,12 @@ var inflate_table = (type, lens, lens_index, codes, table, table_index, work, op
   }
   for (; ; ) {
     here_bits = len - drop;
-    if (work[sym] + 1 < match2) {
+    if (work[sym] + 1 < match3) {
       here_op = 0;
       here_val = work[sym];
-    } else if (work[sym] >= match2) {
-      here_op = extra[work[sym] - match2];
-      here_val = base[work[sym] - match2];
+    } else if (work[sym] >= match3) {
+      here_op = extra[work[sym] - match3];
+      here_val = base[work[sym] - match3];
     } else {
       here_op = 32 + 64;
       here_val = 0;
@@ -8561,10 +8817,10 @@ var GraphNodeLeaf = class {
   _tag = "GraphNodeLeaf";
 };
 var GraphNodeCompoundTransform = class {
-  constructor(id, node, args, rout, rin) {
+  constructor(id, node, args2, rout, rin) {
     this.id = id;
     this.node = node;
-    this.args = args;
+    this.args = args2;
     this.rout = rout;
     this.rin = rin;
   }
@@ -8575,6 +8831,7 @@ function processLayerGraphNode(ctx, node, pipedInGraphNode) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
     const typeParser = yield* service(TypeParser);
+    const excludeNever = (type) => succeed((type.flags & ts.TypeFlags.Never) !== 0);
     const maybePipe = yield* option(typeParser.pipeCall(node));
     if (isSome2(maybePipe)) {
       let graphNode = yield* processLayerGraphNode(ctx, maybePipe.value.subject, void 0);
@@ -8594,12 +8851,12 @@ function processLayerGraphNode(ctx, node, pipedInGraphNode) {
           const { allIndexes: outTypes } = yield* appendToUniqueTypesMap(
             ctx.services,
             maybeLayer.value.ROut,
-            true
+            excludeNever
           );
           const { allIndexes: inTypes } = yield* appendToUniqueTypesMap(
             ctx.services,
             maybeLayer.value.RIn,
-            true
+            excludeNever
           );
           return new GraphNodeCompoundTransform(
             ctx.nextId(),
@@ -8623,12 +8880,12 @@ function processLayerGraphNode(ctx, node, pipedInGraphNode) {
             const { allIndexes: outTypes } = yield* appendToUniqueTypesMap(
               ctx.services,
               maybeLayer.value.ROut,
-              true
+              excludeNever
             );
             const { allIndexes: inTypes } = yield* appendToUniqueTypesMap(
               ctx.services,
               maybeLayer.value.RIn,
-              true
+              excludeNever
             );
             if (ts.isCallExpression(node)) {
               const argNodes = yield* option(
@@ -8673,12 +8930,12 @@ function processLayerGraphNode(ctx, node, pipedInGraphNode) {
         const { allIndexes: outTypes } = yield* appendToUniqueTypesMap(
           ctx.services,
           maybeLayer.value.ROut,
-          true
+          excludeNever
         );
         const { allIndexes: inTypes } = yield* appendToUniqueTypesMap(
           ctx.services,
           maybeLayer.value.RIn,
-          true
+          excludeNever
         );
         return new GraphNodeLeaf(ctx.nextId(), node, outTypes, inTypes);
       }
@@ -9842,13 +10099,13 @@ var makeSchemaGenContext = fn("SchemaGen.makeSchemaGenContext")(function* (sourc
       ts.factory.createIdentifier(effectSchemaIdentifier),
       apiName
     ),
-    createApiCall: (apiName, args) => ts.factory.createCallExpression(
+    createApiCall: (apiName, args2) => ts.factory.createCallExpression(
       ts.factory.createPropertyAccessExpression(
         ts.factory.createIdentifier(effectSchemaIdentifier),
         apiName
       ),
       [],
-      args
+      args2
     ),
     entityNameToDataTypeName: (name) => {
       if (ts.isIdentifier(name)) {
@@ -10414,12 +10671,12 @@ var init = (modules) => {
     const proxy = /* @__PURE__ */ Object.create(null);
     proxy[LSP_INJECTED_URI] = true;
     for (const k of Object.keys(languageService)) {
-      proxy[k] = (...args) => languageService[k].apply(languageService, args);
+      proxy[k] = (...args2) => languageService[k].apply(languageService, args2);
     }
     function runNano(program) {
       return (fa) => pipe(
         fa,
-        provideService(TypeParser, make4(modules.typescript, program.getTypeChecker())),
+        provideService(TypeParser, make3(modules.typescript, program.getTypeChecker())),
         provideService(TypeScriptProgram, program),
         provideService(TypeCheckerApi, program.getTypeChecker()),
         provideService(
@@ -10435,8 +10692,8 @@ var init = (modules) => {
       );
     }
     const effectCodeFixesForFile = /* @__PURE__ */ new Map();
-    proxy.getSemanticDiagnostics = (fileName, ...args) => {
-      const applicableDiagnostics = languageService.getSemanticDiagnostics(fileName, ...args);
+    proxy.getSemanticDiagnostics = (fileName, ...args2) => {
+      const applicableDiagnostics = languageService.getSemanticDiagnostics(fileName, ...args2);
       const program = languageService.getProgram();
       if (languageServicePluginOptions.diagnostics && program) {
         effectCodeFixesForFile.delete(fileName);
@@ -10455,10 +10712,10 @@ var init = (modules) => {
       }
       return applicableDiagnostics;
     };
-    proxy.getSupportedCodeFixes = (...args) => languageService.getSupportedCodeFixes(...args).concat(
+    proxy.getSupportedCodeFixes = (...args2) => languageService.getSupportedCodeFixes(...args2).concat(
       diagnosticsErrorCodes.map((_) => "" + _)
     );
-    proxy.getCodeFixesAtPosition = (fileName, start, end, errorCodes, formatOptions, preferences, ...args) => {
+    proxy.getCodeFixesAtPosition = (fileName, start, end, errorCodes, formatOptions, preferences, ...args2) => {
       const applicableCodeFixes = languageService.getCodeFixesAtPosition(
         fileName,
         start,
@@ -10466,7 +10723,7 @@ var init = (modules) => {
         errorCodes,
         formatOptions,
         preferences,
-        ...args
+        ...args2
       );
       return pipe(
         sync(() => {
@@ -10504,9 +10761,9 @@ var init = (modules) => {
         getOrElse(() => applicableCodeFixes)
       );
     };
-    proxy.getApplicableRefactors = (...args) => {
-      const applicableRefactors = languageService.getApplicableRefactors(...args);
-      const [fileName, positionOrRange] = args;
+    proxy.getApplicableRefactors = (...args2) => {
+      const applicableRefactors = languageService.getApplicableRefactors(...args2);
+      const [fileName, positionOrRange] = args2;
       const program = languageService.getProgram();
       if (program) {
         const sourceFile = program.getSourceFile(fileName);
@@ -10521,7 +10778,7 @@ var init = (modules) => {
       }
       return applicableRefactors;
     };
-    proxy.getEditsForRefactor = (fileName, formatOptions, positionOrRange, refactorName, actionName, preferences, ...args) => {
+    proxy.getEditsForRefactor = (fileName, formatOptions, positionOrRange, refactorName, actionName, preferences, ...args2) => {
       const program = languageService.getProgram();
       if (program) {
         const sourceFile = program.getSourceFile(fileName);
@@ -10564,11 +10821,11 @@ var init = (modules) => {
         refactorName,
         actionName,
         preferences,
-        ...args
+        ...args2
       );
     };
-    proxy.getQuickInfoAtPosition = (fileName, position, ...args) => {
-      const applicableQuickInfo = languageService.getQuickInfoAtPosition(fileName, position, ...args);
+    proxy.getQuickInfoAtPosition = (fileName, position, ...args2) => {
+      const applicableQuickInfo = languageService.getQuickInfoAtPosition(fileName, position, ...args2);
       if (languageServicePluginOptions.quickinfo) {
         const program = languageService.getProgram();
         if (program) {
@@ -10588,13 +10845,13 @@ var init = (modules) => {
       }
       return applicableQuickInfo;
     };
-    proxy.getCompletionsAtPosition = (fileName, position, options, formattingSettings, ...args) => {
+    proxy.getCompletionsAtPosition = (fileName, position, options, formattingSettings, ...args2) => {
       const applicableCompletions = languageService.getCompletionsAtPosition(
         fileName,
         position,
         options,
         formattingSettings,
-        ...args
+        ...args2
       );
       if (languageServicePluginOptions.completions) {
         const program = languageService.getProgram();
@@ -10633,7 +10890,7 @@ var init = (modules) => {
       }
       return applicableCompletions;
     };
-    proxy.getCompletionEntryDetails = (fileName, position, entryName, formatOptions, source, preferences, _data, ...args) => {
+    proxy.getCompletionEntryDetails = (fileName, position, entryName, formatOptions, source, preferences, _data, ...args2) => {
       const applicableCompletionEntryDetails = languageService.getCompletionEntryDetails(
         fileName,
         position,
@@ -10642,7 +10899,7 @@ var init = (modules) => {
         source,
         preferences,
         _data,
-        ...args
+        ...args2
       );
       if (languageServicePluginOptions.completions) {
         const program = languageService.getProgram();
@@ -10666,8 +10923,8 @@ var init = (modules) => {
       }
       return applicableCompletionEntryDetails;
     };
-    proxy.getDefinitionAndBoundSpan = (fileName, position, ...args) => {
-      const applicableDefinition = languageService.getDefinitionAndBoundSpan(fileName, position, ...args);
+    proxy.getDefinitionAndBoundSpan = (fileName, position, ...args2) => {
+      const applicableDefinition = languageService.getDefinitionAndBoundSpan(fileName, position, ...args2);
       if (languageServicePluginOptions.goto) {
         const program = languageService.getProgram();
         if (program) {