diff --git a/packages/vite/src/node/optimizer/scan.ts b/packages/vite/src/node/optimizer/scan.ts
index da3b60d47b0453..37b6062a65af36 100644
--- a/packages/vite/src/node/optimizer/scan.ts
+++ b/packages/vite/src/node/optimizer/scan.ts
@@ -189,53 +189,6 @@ async function computeEntries(config: ResolvedConfig) {
   return entries
 }
 
-// async function prepareEsbuildScanner(
-//   config: ResolvedConfig,
-//   entries: string[],
-//   deps: Record<string, string>,
-//   missing: Record<string, string>,
-//   scanContext?: { cancelled: boolean },
-// ): Promise<BuildContext | undefined> {
-//   const container = await createPluginContainer(config)
-
-//   if (scanContext?.cancelled) return
-
-//   const plugin = esbuildScanPlugin(config, container, deps, missing, entries)
-
-//   const { plugins = [], ...esbuildOptions } =
-//     config.optimizeDeps?.esbuildOptions ?? {}
-
-//   // The plugin pipeline automatically loads the closest tsconfig.json.
-//   // But esbuild doesn't support reading tsconfig.json if the plugin has resolved the path (https://github.com/evanw/esbuild/issues/2265).
-//   // Due to syntax incompatibilities between the experimental decorators in TypeScript and TC39 decorators,
-//   // we cannot simply set `"experimentalDecorators": true` or `false`. (https://github.com/vitejs/vite/pull/15206#discussion_r1417414715)
-//   // Therefore, we use the closest tsconfig.json from the root to make it work in most cases.
-//   let tsconfigRaw = esbuildOptions.tsconfigRaw
-//   if (!tsconfigRaw && !esbuildOptions.tsconfig) {
-//     const tsconfigResult = await loadTsconfigJsonForFile(
-//       path.join(config.root, '_dummy.js'),
-//     )
-//     if (tsconfigResult.compilerOptions?.experimentalDecorators) {
-//       tsconfigRaw = { compilerOptions: { experimentalDecorators: true } }
-//     }
-//   }
-
-//   return await esbuild.context({
-//     absWorkingDir: process.cwd(),
-//     write: false,
-//     stdin: {
-//       contents: entries.map((e) => `import ${JSON.stringify(e)}`).join('\n'),
-//       loader: 'js',
-//     },
-//     bundle: true,
-//     format: 'esm',
-//     logLevel: 'silent',
-//     plugins: [...plugins, plugin],
-//     ...esbuildOptions,
-//     tsconfigRaw,
-//   })
-// }
-
 async function prepareRolldownScanner(
   config: ResolvedConfig,
   entries: string[],
@@ -318,392 +271,6 @@ const typeRE = /\btype\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s'">]+))/i
 const langRE = /\blang\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s'">]+))/i
 const contextRE = /\bcontext\s*=\s*(?:"([^"]+)"|'([^']+)'|([^\s'">]+))/i
 
-// function esbuildScanPlugin(
-//   config: ResolvedConfig,
-//   container: PluginContainer,
-//   depImports: Record<string, string>,
-//   missing: Record<string, string>,
-//   entries: string[],
-// ): Plugin {
-//   const seen = new Map<string, string | undefined>()
-
-//   const resolve = async (
-//     id: string,
-//     importer?: string,
-//     options?: ResolveIdOptions,
-//   ) => {
-//     const key = id + (importer && path.dirname(importer))
-//     if (seen.has(key)) {
-//       return seen.get(key)
-//     }
-//     const resolved = await container.resolveId(
-//       id,
-//       importer && normalizePath(importer),
-//       {
-//         ...options,
-//         scan: true,
-//       },
-//     )
-//     const res = resolved?.id
-//     seen.set(key, res)
-//     return res
-//   }
-
-//   const include = config.optimizeDeps?.include
-//   const exclude = [
-//     ...(config.optimizeDeps?.exclude || []),
-//     '@vite/client',
-//     '@vite/env',
-//   ]
-
-//   const isUnlessEntry = (path: string) => !entries.includes(path)
-
-//   const externalUnlessEntry = ({ path }: { path: string }) => ({
-//     path,
-//     external: isUnlessEntry(path),
-//   })
-
-//   const doTransformGlobImport = async (
-//     contents: string,
-//     id: string,
-//     loader: Loader,
-//   ) => {
-//     let transpiledContents
-//     // transpile because `transformGlobImport` only expects js
-//     if (loader !== 'js') {
-//       transpiledContents = (await transform(contents, { loader })).code
-//     } else {
-//       transpiledContents = contents
-//     }
-
-//     const result = await transformGlobImport(
-//       transpiledContents,
-//       id,
-//       config.root,
-//       resolve,
-//     )
-
-//     return result?.s.toString() || transpiledContents
-//   }
-
-//   return {
-//     name: 'vite:dep-scan',
-//     setup(build) {
-//       const scripts: Record<string, OnLoadResult> = {}
-
-//       // external urls
-//       build.onResolve({ filter: externalRE }, ({ path }) => ({
-//         path,
-//         external: true,
-//       }))
-
-//       // data urls
-//       build.onResolve({ filter: dataUrlRE }, ({ path }) => ({
-//         path,
-//         external: true,
-//       }))
-
-//       // local scripts (`<script>` in Svelte and `<script setup>` in Vue)
-//       build.onResolve({ filter: virtualModuleRE }, ({ path }) => {
-//         return {
-//           // strip prefix to get valid filesystem path so esbuild can resolve imports in the file
-//           path: path.replace(virtualModulePrefix, ''),
-//           namespace: 'script',
-//         }
-//       })
-
-//       build.onLoad({ filter: /.*/, namespace: 'script' }, ({ path }) => {
-//         return scripts[path]
-//       })
-
-//       // html types: extract script contents -----------------------------------
-//       build.onResolve({ filter: htmlTypesRE }, async ({ path, importer }) => {
-//         const resolved = await resolve(path, importer)
-//         if (!resolved) return
-//         // It is possible for the scanner to scan html types in node_modules.
-//         // If we can optimize this html type, skip it so it's handled by the
-//         // bare import resolve, and recorded as optimization dep.
-//         if (
-//           isInNodeModules(resolved) &&
-//           isOptimizable(resolved, config.optimizeDeps)
-//         )
-//           return
-//         return {
-//           path: resolved,
-//           namespace: 'html',
-//         }
-//       })
-
-//       const htmlTypeOnLoadCallback: (
-//         args: OnLoadArgs,
-//       ) => Promise<OnLoadResult | null | undefined> = async ({ path: p }) => {
-//         let raw = await fsp.readFile(p, 'utf-8')
-//         // Avoid matching the content of the comment
-//         raw = raw.replace(commentRE, '<!---->')
-//         const isHtml = p.endsWith('.html')
-//         let js = ''
-//         let scriptId = 0
-//         const matches = raw.matchAll(scriptRE)
-//         for (const [, openTag, content] of matches) {
-//           const typeMatch = openTag.match(typeRE)
-//           const type =
-//             typeMatch && (typeMatch[1] || typeMatch[2] || typeMatch[3])
-//           const langMatch = openTag.match(langRE)
-//           const lang =
-//             langMatch && (langMatch[1] || langMatch[2] || langMatch[3])
-//           // skip non type module script
-//           if (isHtml && type !== 'module') {
-//             continue
-//           }
-//           // skip type="application/ld+json" and other non-JS types
-//           if (
-//             type &&
-//             !(
-//               type.includes('javascript') ||
-//               type.includes('ecmascript') ||
-//               type === 'module'
-//             )
-//           ) {
-//             continue
-//           }
-//           let loader: Loader = 'js'
-//           if (lang === 'ts' || lang === 'tsx' || lang === 'jsx') {
-//             loader = lang
-//           } else if (p.endsWith('.astro')) {
-//             loader = 'ts'
-//           }
-//           const srcMatch = openTag.match(srcRE)
-//           if (srcMatch) {
-//             const src = srcMatch[1] || srcMatch[2] || srcMatch[3]
-//             js += `import ${JSON.stringify(src)}\n`
-//           } else if (content.trim()) {
-//             // The reason why virtual modules are needed:
-//             // 1. There can be module scripts (`<script context="module">` in Svelte and `<script>` in Vue)
-//             // or local scripts (`<script>` in Svelte and `<script setup>` in Vue)
-//             // 2. There can be multiple module scripts in html
-//             // We need to handle these separately in case variable names are reused between them
-
-//             // append imports in TS to prevent esbuild from removing them
-//             // since they may be used in the template
-//             const contents =
-//               content +
-//               (loader.startsWith('ts') ? extractImportPaths(content) : '')
-
-//             const key = `${p}?id=${scriptId++}`
-//             if (contents.includes('import.meta.glob')) {
-//               scripts[key] = {
-//                 loader: 'js', // since it is transpiled
-//                 contents: await doTransformGlobImport(contents, p, loader),
-//                 resolveDir: normalizePath(path.dirname(p)),
-//                 pluginData: {
-//                   htmlType: { loader },
-//                 },
-//               }
-//             } else {
-//               scripts[key] = {
-//                 loader,
-//                 contents,
-//                 resolveDir: normalizePath(path.dirname(p)),
-//                 pluginData: {
-//                   htmlType: { loader },
-//                 },
-//               }
-//             }
-
-//             const virtualModulePath = JSON.stringify(virtualModulePrefix + key)
-
-//             const contextMatch = openTag.match(contextRE)
-//             const context =
-//               contextMatch &&
-//               (contextMatch[1] || contextMatch[2] || contextMatch[3])
-
-//             // Especially for Svelte files, exports in <script context="module"> means module exports,
-//             // exports in <script> means component props. To avoid having two same export name from the
-//             // star exports, we need to ignore exports in <script>
-//             if (p.endsWith('.svelte') && context !== 'module') {
-//               js += `import ${virtualModulePath}\n`
-//             } else {
-//               js += `export * from ${virtualModulePath}\n`
-//             }
-//           }
-//         }
-
-//         // This will trigger incorrectly if `export default` is contained
-//         // anywhere in a string. Svelte and Astro files can't have
-//         // `export default` as code so we know if it's encountered it's a
-//         // false positive (e.g. contained in a string)
-//         if (!p.endsWith('.vue') || !js.includes('export default')) {
-//           js += '\nexport default {}'
-//         }
-
-//         return {
-//           loader: 'js',
-//           contents: js,
-//         }
-//       }
-
-//       // extract scripts inside HTML-like files and treat it as a js module
-//       build.onLoad(
-//         { filter: htmlTypesRE, namespace: 'html' },
-//         htmlTypeOnLoadCallback,
-//       )
-//       // the onResolve above will use namespace=html but esbuild doesn't
-//       // call onResolve for glob imports and those will use namespace=file
-//       // https://github.com/evanw/esbuild/issues/3317
-//       build.onLoad(
-//         { filter: htmlTypesRE, namespace: 'file' },
-//         htmlTypeOnLoadCallback,
-//       )
-
-//       // bare imports: record and externalize ----------------------------------
-//       build.onResolve(
-//         {
-//           // avoid matching windows volume
-//           filter: /^[\w@][^:]/,
-//         },
-//         async ({ path: id, importer, pluginData }) => {
-//           if (moduleListContains(exclude, id)) {
-//             return externalUnlessEntry({ path: id })
-//           }
-//           if (depImports[id]) {
-//             return externalUnlessEntry({ path: id })
-//           }
-//           const resolved = await resolve(id, importer, {
-//             custom: {
-//               depScan: { loader: pluginData?.htmlType?.loader },
-//             },
-//           })
-//           if (resolved) {
-//             if (shouldExternalizeDep(resolved, id)) {
-//               return externalUnlessEntry({ path: id })
-//             }
-//             if (isInNodeModules(resolved) || include?.includes(id)) {
-//               // dependency or forced included, externalize and stop crawling
-//               if (isOptimizable(resolved, config.optimizeDeps)) {
-//                 depImports[id] = resolved
-//               }
-//               return externalUnlessEntry({ path: id })
-//             } else if (isScannable(resolved, config.optimizeDeps.extensions)) {
-//               const namespace = htmlTypesRE.test(resolved) ? 'html' : undefined
-//               // linked package, keep crawling
-//               return {
-//                 path: path.resolve(resolved),
-//                 namespace,
-//               }
-//             } else {
-//               return externalUnlessEntry({ path: id })
-//             }
-//           } else {
-//             missing[id] = normalizePath(importer)
-//           }
-//         },
-//       )
-
-//       // Externalized file types -----------------------------------------------
-//       // these are done on raw ids using esbuild's native regex filter so it
-//       // should be faster than doing it in the catch-all via js
-//       // they are done after the bare import resolve because a package name
-//       // may end with these extensions
-//       const setupExternalize = (
-//         filter: RegExp,
-//         doExternalize: (path: string) => boolean,
-//       ) => {
-//         build.onResolve({ filter }, ({ path }) => {
-//           return {
-//             path,
-//             external: doExternalize(path),
-//           }
-//         })
-//       }
-
-//       // css
-//       setupExternalize(CSS_LANGS_RE, isUnlessEntry)
-//       // json & wasm
-//       setupExternalize(/\.(json|json5|wasm)$/, isUnlessEntry)
-//       // known asset types
-//       setupExternalize(
-//         new RegExp(`\\.(${KNOWN_ASSET_TYPES.join('|')})$`),
-//         isUnlessEntry,
-//       )
-//       // known vite query types: ?worker, ?raw
-//       setupExternalize(SPECIAL_QUERY_RE, () => true)
-
-//       // catch all -------------------------------------------------------------
-
-//       build.onResolve(
-//         {
-//           filter: /.*/,
-//         },
-//         async ({ path: id, importer, pluginData }) => {
-//           // use vite resolver to support urls and omitted extensions
-//           const resolved = await resolve(id, importer, {
-//             custom: {
-//               depScan: { loader: pluginData?.htmlType?.loader },
-//             },
-//           })
-//           if (resolved) {
-//             if (
-//               shouldExternalizeDep(resolved, id) ||
-//               !isScannable(resolved, config.optimizeDeps.extensions)
-//             ) {
-//               return externalUnlessEntry({ path: id })
-//             }
-
-//             const namespace = htmlTypesRE.test(resolved) ? 'html' : undefined
-
-//             return {
-//               path: path.resolve(cleanUrl(resolved)),
-//               namespace,
-//             }
-//           } else {
-//             // resolve failed... probably unsupported type
-//             return externalUnlessEntry({ path: id })
-//           }
-//         },
-//       )
-
-//       // for jsx/tsx, we need to access the content and check for
-//       // presence of import.meta.glob, since it results in import relationships
-//       // but isn't crawled by esbuild.
-//       build.onLoad({ filter: JS_TYPES_RE }, async ({ path: id }) => {
-//         let ext = path.extname(id).slice(1)
-//         if (ext === 'mjs') ext = 'js'
-
-//         let contents = await fsp.readFile(id, 'utf-8')
-//         if (ext.endsWith('x') && config.esbuild && config.esbuild.jsxInject) {
-//           contents = config.esbuild.jsxInject + `\n` + contents
-//         }
-
-//         const loader =
-//           config.optimizeDeps?.esbuildOptions?.loader?.[`.${ext}`] ||
-//           (ext as Loader)
-
-//         if (contents.includes('import.meta.glob')) {
-//           return {
-//             loader: 'js', // since it is transpiled,
-//             contents: await doTransformGlobImport(contents, id, loader),
-//           }
-//         }
-
-//         return {
-//           loader,
-//           contents,
-//         }
-//       })
-
-//       // onResolve is not called for glob imports.
-//       // we need to add that here as well until esbuild calls onResolve for glob imports.
-//       // https://github.com/evanw/esbuild/issues/3317
-//       build.onLoad({ filter: /.*/, namespace: 'file' }, () => {
-//         return {
-//           loader: 'js',
-//           contents: 'export default {}',
-//         }
-//       })
-//     },
-//   }
-// }
-
 function rolldownScanPlugin(
   config: ResolvedConfig,
   container: PluginContainer,
@@ -750,105 +317,57 @@ function rolldownScanPlugin(
   const doTransformGlobImport = async (contents: string, id: string) => {
     const result = await transformGlobImport(contents, id, config.root, resolve)
 
-    return result?.s.toString() || transpiledContents
+    return result?.s.toString() || contents
   }
 
-  return {
-    name: 'vite:dep-scan',
-    setup(build) {
-      const scripts: Record<string, OnLoadResult> = {}
-
-      // external urls
-      build.onResolve({ filter: externalRE }, ({ path }) => ({
-        path,
-        external: true,
-      }))
-
-      // data urls
-      build.onResolve({ filter: dataUrlRE }, ({ path }) => ({
-        path,
-        external: true,
-      }))
-
-      // local scripts (`<script>` in Svelte and `<script setup>` in Vue)
-      build.onResolve({ filter: virtualModuleRE }, ({ path }) => {
-        return {
-          // strip prefix to get valid filesystem path so esbuild can resolve imports in the file
-          path: path.replace(virtualModulePrefix, ''),
-          namespace: 'script',
-        }
-      })
-
-      build.onLoad({ filter: /.*/, namespace: 'script' }, ({ path }) => {
-        return scripts[path]
-      })
-
-      // html types: extract script contents -----------------------------------
-      build.onResolve({ filter: htmlTypesRE }, async ({ path, importer }) => {
-        const resolved = await resolve(path, importer)
-        if (!resolved) return
-        // It is possible for the scanner to scan html types in node_modules.
-        // If we can optimize this html type, skip it so it's handled by the
-        // bare import resolve, and recorded as optimization dep.
-        if (
-          isInNodeModules(resolved) &&
-          isOptimizable(resolved, config.optimizeDeps)
+  const htmlTypeOnLoadCallback: (path: string) => Promise<string> = async (
+    p,
+  ) => {
+    let raw = await fsp.readFile(p, 'utf-8')
+    // Avoid matching the content of the comment
+    raw = raw.replace(commentRE, '<!---->')
+    const isHtml = p.endsWith('.html')
+    scriptRE.lastIndex = 0
+    let js = ''
+    let scriptId = 0
+    let match: RegExpExecArray | null
+    while ((match = scriptRE.exec(raw))) {
+      const [, openTag, content] = match
+      const typeMatch = typeRE.exec(openTag)
+      const type = typeMatch && (typeMatch[1] || typeMatch[2] || typeMatch[3])
+      const langMatch = langRE.exec(openTag)
+      const lang = langMatch && (langMatch[1] || langMatch[2] || langMatch[3])
+      // skip non type module script
+      if (isHtml && type !== 'module') {
+        continue
+      }
+      // skip type="application/ld+json" and other non-JS types
+      if (
+        type &&
+        !(
+          type.includes('javascript') ||
+          type.includes('ecmascript') ||
+          type === 'module'
         )
-          return
-        return {
-          path: resolved,
-          namespace: 'html',
-        }
-      })
-
-      const htmlTypeOnLoadCallback: (
-        args: OnLoadArgs,
-      ) => Promise<OnLoadResult | null | undefined> = async ({ path: p }) => {
-        let raw = await fsp.readFile(p, 'utf-8')
-        // Avoid matching the content of the comment
-        raw = raw.replace(commentRE, '<!---->')
-        const isHtml = p.endsWith('.html')
-        let js = ''
-        let scriptId = 0
-        const matches = raw.matchAll(scriptRE)
-        for (const [, openTag, content] of matches) {
-          const typeMatch = openTag.match(typeRE)
-          const type =
-            typeMatch && (typeMatch[1] || typeMatch[2] || typeMatch[3])
-          const langMatch = openTag.match(langRE)
-          const lang =
-            langMatch && (langMatch[1] || langMatch[2] || langMatch[3])
-          // skip non type module script
-          if (isHtml && type !== 'module') {
-            continue
-          }
-          // skip type="application/ld+json" and other non-JS types
-          if (
-            type &&
-            !(
-              type.includes('javascript') ||
-              type.includes('ecmascript') ||
-              type === 'module'
-            )
-          ) {
-            continue
-          }
-          let loader: Loader = 'js'
-          if (lang === 'ts' || lang === 'tsx' || lang === 'jsx') {
-            loader = lang
-          } else if (p.endsWith('.astro')) {
-            loader = 'ts'
-          }
-          const srcMatch = openTag.match(srcRE)
-          if (srcMatch) {
-            const src = srcMatch[1] || srcMatch[2] || srcMatch[3]
-            js += `import ${JSON.stringify(src)}\n`
-          } else if (content.trim()) {
-            // The reason why virtual modules are needed:
-            // 1. There can be module scripts (`<script context="module">` in Svelte and `<script>` in Vue)
-            // or local scripts (`<script>` in Svelte and `<script setup>` in Vue)
-            // 2. There can be multiple module scripts in html
-            // We need to handle these separately in case variable names are reused between them
+      ) {
+        continue
+      }
+      let loader: Loader = 'js'
+      if (lang === 'ts' || lang === 'tsx' || lang === 'jsx') {
+        loader = lang
+      } else if (p.endsWith('.astro')) {
+        loader = 'ts'
+      }
+      const srcMatch = srcRE.exec(openTag)
+      if (srcMatch) {
+        const src = srcMatch[1] || srcMatch[2] || srcMatch[3]
+        js += `import ${JSON.stringify(src)}\n`
+      } else if (content.trim()) {
+        // The reason why virtual modules are needed:
+        // 1. There can be module scripts (`<script context="module">` in Svelte and `<script>` in Vue)
+        // or local scripts (`<script>` in Svelte and `<script setup>` in Vue)
+        // 2. There can be multiple module scripts in html
+        // We need to handle these separately in case variable names are reused between them
 
         // append imports in TS to prevent esbuild from removing them
         // since they may be used in the template
@@ -872,10 +391,10 @@ function rolldownScanPlugin(
 
         const virtualModulePath = JSON.stringify(virtualModulePrefix + key)
 
-            const contextMatch = openTag.match(contextRE)
-            const context =
-              contextMatch &&
-              (contextMatch[1] || contextMatch[2] || contextMatch[3])
+        const contextMatch = contextRE.exec(openTag)
+        const context =
+          contextMatch &&
+          (contextMatch[1] || contextMatch[2] || contextMatch[3])
 
         // Especially for Svelte files, exports in <script context="module"> means module exports,
         // exports in <script> means component props. To avoid having two same export name from the
@@ -1142,4 +661,4 @@ function isScannable(id: string, extensions: string[] | undefined): boolean {
     extensions?.includes(path.extname(id)) ||
     false
   )
-}
+}
\ No newline at end of file