"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var _chunk5TD4KD7Sjs = require('./chunk-5TD4KD7S.js');

// src/resolve.ts
var _fs = require('fs');
var _promises = require('fs/promises');
var _path = require('path'); var _path2 = _interopRequireDefault(_path);
var RollupResolve = () => {
  const referencedFiles = /* @__PURE__ */ new Map();
  function collectReferencedFile(importer, file) {
    if (!importer)
      return;
    if (!referencedFiles.has(file)) {
      referencedFiles.set(file, /* @__PURE__ */ new Set([importer]));
    } else {
      referencedFiles.get(file).add(importer);
    }
  }
  const resolveCache = /* @__PURE__ */ new Map();
  function withResolveCache(id, importer, result) {
    if (!resolveCache.has(importer)) {
      resolveCache.set(importer, /* @__PURE__ */ new Map([[id, result]]));
      return result;
    }
    resolveCache.get(importer).set(id, result);
    return result;
  }
  const resolve = (ctx) => async (id, importer) => {
    var _a;
    async function tryPkgEntry() {
      var _a2;
      try {
        const pkgPath = (_a2 = await ctx.resolve(`${id}/package.json`, importer)) == null ? void 0 : _a2.id;
        if (!pkgPath)
          return;
        const pkg = JSON.parse(await _promises.readFile.call(void 0, pkgPath, "utf-8"));
        const types = pkg.types || pkg.typings;
        if (!types)
          return;
        const entry = _path2.default.resolve(pkgPath, "..", types);
        return _fs.existsSync.call(void 0, entry) ? entry : void 0;
      } catch (e) {
      }
    }
    const tryResolve = async (id2) => {
      var _a2, _b;
      try {
        return ((_a2 = await ctx.resolve(id2, importer)) == null ? void 0 : _a2.id) || ((_b = await ctx.resolve(`${id2}.d`, importer)) == null ? void 0 : _b.id);
      } catch (e2) {
      }
      return;
    };
    const cached = (_a = resolveCache.get(importer)) == null ? void 0 : _a.get(id);
    if (cached)
      return cached;
    if (!id.startsWith(".")) {
      const entry = await tryPkgEntry();
      if (entry)
        return withResolveCache(id, importer, entry);
    }
    let resolved = await tryResolve(id);
    if (!resolved)
      return;
    if (_fs.existsSync.call(void 0, resolved)) {
      collectReferencedFile(importer, resolved);
      return withResolveCache(id, importer, resolved);
    }
    resolved = await tryResolve(resolved);
    if (resolved && _fs.existsSync.call(void 0, resolved)) {
      collectReferencedFile(importer, resolved);
      return withResolveCache(id, importer, resolved);
    }
  };
  const handleHotUpdate = ({
    file,
    server,
    modules
  }) => {
    const cache = /* @__PURE__ */ new Map();
    function getAffectedModules(file2) {
      if (cache.has(file2))
        return cache.get(file2);
      if (!referencedFiles.has(file2))
        return /* @__PURE__ */ new Set([]);
      const modules2 = /* @__PURE__ */ new Set([]);
      cache.set(file2, modules2);
      for (const importer of referencedFiles.get(file2)) {
        const mods = server.moduleGraph.getModulesByFile(importer);
        if (mods)
          mods.forEach((m) => modules2.add(m));
        getAffectedModules(importer).forEach((m) => modules2.add(m));
      }
      return modules2;
    }
    if (_chunk5TD4KD7Sjs.tsFileCache[file])
      delete _chunk5TD4KD7Sjs.tsFileCache[file];
    const affected = getAffectedModules(file);
    return [...modules, ...affected];
  };
  return {
    resolve,
    handleHotUpdate
  };
};



exports.RollupResolve = RollupResolve;