A $1 replica of the same object exists in the packaging result of the main out file

[DhtIsCoding]

Two methods refer to the same map object in the code, but the compilation result produces two different maps, I don't know what I did wrong, can anyone help? This is gonna save my life!

work space code ：

const workers = new Map<WorkerName, Worker>()
const workerRequest = new Map<WorkerName, ((value: Worker | PromiseLike<Worker>) => void)[]>()

/**
 * 初始化日志工作线程
 */
function initLoggerWorker() {
  const loggerWorker = new Worker(loggerWorkerPath, {
    name: loggerWorkerToken,
    argv: [app.getPath('logs')]
  })

  loggerWorker.once('message', () => {
    const resolves = workerRequest.get(loggerWorkerToken)

    console.debug('handleRead ready', loggerWorkerToken, workerRequest)

    if (resolves) {
      for (const resolve of resolves) {
        resolve(loggerWorker)
      }

      console.debug('workerRequest.delete')

      // workerRequest.delete(loggerWorkerToken)
    }
  })

  loggerWorker.on('error', (err) => console.error('loggerWorker error', err))
  loggerWorker.on('messageerror', (err) => console.error('loggerWorker messageerror', err))

  workers.set(loggerWorkerToken, loggerWorker)
}

/**
 * 获取初始化后的worker
 * @param workerName worker身份
 * @returns
 */
function getWorker(workerName: WorkerName) {
  return new Promise<Worker>((resolve) => {
    const worker = workers.get(workerName)

    if (worker) {
      resolve(worker)
    } else {
      const resolves = workerRequest.get(workerName)
      console.debug('getWorker unresolve', workerName, resolves?.length)

      if (resolves) {
        resolves.push(resolve)
      } else {
        workerRequest.set(workerName, [resolve])
      }
    }
  })
}

build after :

const workers = /* @__PURE__ */ new Map();
const workerRequest = /* @__PURE__ */ new Map();

.....  orther code  ....

const workers$1 = /* @__PURE__ */ new Map();
const workerRequest$1 = /* @__PURE__ */ new Map();

this my tsconfig.ts :

{
  "compilerOptions": {
    "composite": true,
    "target": "ESNext",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "lib": ["ESNext"],
    "sourceMap": false,
    "strict": true,
    "esModuleInterop": true,
    "resolveJsonModule": true,
    "isolatedModules": true,
    "forceConsistentCasingInFileNames": true,
    "allowSyntheticDefaultImports": true,
    "verbatimModuleSyntax": true,
    "skipLibCheck": true,
    "noUnusedLocals": true,
    "noUnusedParameters": true,
    "noImplicitAny": false,
    "strictNullChecks":true,
    "noEmit": true,
    "noImplicitReturns": true,
    "types": ["electron-vite/node"],
    "paths": {
      "@/*": ["./src/main/*"],
      "@preload/*": ["./src/preload/*"],
    },
  },
  "include": ["electron.vite.config.*", "src/main/**/*", "src/preload/**/*", "types/**/*"],
  "exclude": ["node_modules"]
}

this my electron.vite.config

import { defineConfig, defineViteConfig, externalizeDepsPlugin } from 'electron-vite'

export default defineConfig({
  main: defineViteConfig(({ command, mode }) => {
    return {
      // 默认打包客户端的时候，只打包 index.ts
      plugins: [externalizeDepsPlugin()],
      resolve: {
        alias: {
          '@': './src/main',
          '@preload': './src/preload'
        }
      },
      build: {
        emptyOutDir: true,
        rollupOptions: {
          input: {
            index: 'src/main/index.ts'
          },
          output: {
            format: 'es'
          }
        },
        terserOptions: {
          compress: {
            drop_console: command === 'build',
            drop_debugger: command === 'build'
          }
        }
      }
    }
  }),
  preload: {
    plugins: [externalizeDepsPlugin()]
  }
})