From 68be9c7a5245e4aa4f8d2bd2909720d967aafae6 Mon Sep 17 00:00:00 2001
From: sapphi-red <green@sapphi.red>
Date: Sun, 13 Nov 2022 22:44:44 +0900
Subject: [PATCH] perf: regex perf (super-linear-move)

---
 .eslintrc.cjs                                 |  8 +-
 packages/create-vite/src/index.ts             |  1 +
 packages/plugin-legacy/src/index.ts           | 10 ++-
 packages/plugin-react/src/index.ts            |  1 +
 packages/plugin-vue/src/main.ts               |  7 +-
 packages/vite/src/client/client.ts            | 10 ++-
 packages/vite/src/client/overlay.ts           |  2 +
 packages/vite/src/node/optimizer/scan.ts      |  1 +
 .../src/node/plugins/dynamicImportVars.ts     |  6 +-
 packages/vite/src/node/plugins/ensureWatch.ts |  4 +-
 packages/vite/src/node/plugins/html.ts        | 82 +++++++++++--------
 .../vite/src/node/plugins/importAnalysis.ts   |  1 +
 .../vite/src/node/plugins/importMetaGlob.ts   | 10 ++-
 .../src/node/plugins/workerImportMetaUrl.ts   |  1 +
 packages/vite/src/node/utils.ts               | 36 ++++++--
 15 files changed, 127 insertions(+), 53 deletions(-)

diff --git a/.eslintrc.cjs b/.eslintrc.cjs
index 59a3579c80fc2e..76ceab570323e6 100644
--- a/.eslintrc.cjs
+++ b/.eslintrc.cjs
@@ -107,7 +107,13 @@ module.exports = defineConfig({
       files: ['packages/**'],
       excludedFiles: '**/__tests__/**',
       rules: {
-        'no-restricted-globals': ['error', 'require', '__dirname', '__filename']
+        'no-restricted-globals': [
+          'error',
+          'require',
+          '__dirname',
+          '__filename'
+        ],
+        'regexp/no-super-linear-move': 'error'
       }
     },
     {
diff --git a/packages/create-vite/src/index.ts b/packages/create-vite/src/index.ts
index ce800f3eb23a24..247c807fb55516 100755
--- a/packages/create-vite/src/index.ts
+++ b/packages/create-vite/src/index.ts
@@ -375,6 +375,7 @@ async function init() {
 }
 
 function formatTargetDir(targetDir: string | undefined) {
+  // eslint-disable-next-line regexp/no-super-linear-move -- `targetDir` won't be so long
   return targetDir?.trim().replace(/\/+$/g, '')
 }
 
diff --git a/packages/plugin-legacy/src/index.ts b/packages/plugin-legacy/src/index.ts
index e22898032f854e..a2089ae52e3809 100644
--- a/packages/plugin-legacy/src/index.ts
+++ b/packages/plugin-legacy/src/index.ts
@@ -313,6 +313,7 @@ function viteLegacyPlugin(options: Options = {}): Plugin[] {
             fileName = fileName.replace('[name]', '[name]-legacy')
           } else {
             // entry.js -> entry-legacy.js
+            // eslint-disable-next-line regexp/no-super-linear-move -- fileName won't be so long
             fileName = fileName.replace(/(.+)\.(.+)/, '$1-legacy.$2')
           }
 
@@ -453,7 +454,9 @@ function viteLegacyPlugin(options: Options = {}): Plugin[] {
       }
 
       const tags: HtmlTagDescriptor[] = []
-      const htmlFilename = chunk.facadeModuleId?.replace(/\?.*$/, '')
+      const htmlFilename = chunk.facadeModuleId
+        ? trimQuery(chunk.facadeModuleId)
+        : undefined
 
       // 1. inject modern polyfills
       const modernPolyfillFilename = facadeToModernPolyfillMap.get(
@@ -793,6 +796,11 @@ function wrapIIFEBabelPlugin(): BabelPlugin {
   }
 }
 
+function trimQuery(id: string) {
+  const pos = id.lastIndexOf('?')
+  return pos < 0 ? id : id.slice(0, pos)
+}
+
 export const cspHashes = [
   createHash('sha256').update(safari10NoModuleFix).digest('base64'),
   createHash('sha256').update(systemJSInlineCode).digest('base64'),
diff --git a/packages/plugin-react/src/index.ts b/packages/plugin-react/src/index.ts
index ad54bb909a593b..1b9ae222ead1f4 100644
--- a/packages/plugin-react/src/index.ts
+++ b/packages/plugin-react/src/index.ts
@@ -113,6 +113,7 @@ export default function viteReact(opts: Options = {}): PluginOption[] {
   const importReactRE = /(?:^|\n)import\s+(?:\*\s+as\s+)?React(?:,|\s+)/
 
   // Any extension, including compound ones like '.bs.js'
+  // eslint-disable-next-line regexp/no-super-linear-move -- id won't be so long
   const fileExtensionRE = /\.[^/\s?]+$/
 
   const viteBabel: Plugin = {
diff --git a/packages/plugin-vue/src/main.ts b/packages/plugin-vue/src/main.ts
index 64ad9346d8c783..cb5d27ee7ce07e 100644
--- a/packages/plugin-vue/src/main.ts
+++ b/packages/plugin-vue/src/main.ts
@@ -473,7 +473,12 @@ async function linkSrcToDescriptor(
     (await pluginContext.resolve(src, descriptor.filename))?.id || src
   // #1812 if the src points to a dep file, the resolved id may contain a
   // version query.
-  setSrcDescriptor(srcFile.replace(/\?.*$/, ''), descriptor, scoped)
+  setSrcDescriptor(trimQuery(srcFile), descriptor, scoped)
+}
+
+function trimQuery(id: string) {
+  const pos = id.lastIndexOf('?')
+  return pos < 0 ? id : id.slice(0, pos)
 }
 
 // these are built-in query parameters so should be ignored
diff --git a/packages/vite/src/client/client.ts b/packages/vite/src/client/client.ts
index 4f19efea33d295..00dea034103a33 100644
--- a/packages/vite/src/client/client.ts
+++ b/packages/vite/src/client/client.ts
@@ -593,7 +593,10 @@ export function injectQuery(url: string, queryToInject: string): string {
   }
 
   // can't use pathname from URL since it may be relative like ../
-  const pathname = url.replace(/#.*$/, '').replace(/\?.*$/, '')
+  const pathname = trimEndFromLastOfThatChar(
+    trimEndFromLastOfThatChar(url, '#'),
+    '?'
+  )
   const { search, hash } = new URL(url, 'http://vitejs.dev')
 
   return `${pathname}?${queryToInject}${search ? `&` + search.slice(1) : ''}${
@@ -601,4 +604,9 @@ export function injectQuery(url: string, queryToInject: string): string {
   }`
 }
 
+function trimEndFromLastOfThatChar(input: string, char: string) {
+  const pos = input.lastIndexOf(char)
+  return pos < 0 ? input : input.slice(0, pos)
+}
+
 export { ErrorOverlay }
diff --git a/packages/vite/src/client/overlay.ts b/packages/vite/src/client/overlay.ts
index 57171b7ec13c0b..2c15d3217a6edc 100644
--- a/packages/vite/src/client/overlay.ts
+++ b/packages/vite/src/client/overlay.ts
@@ -127,7 +127,9 @@ code {
 </div>
 `
 
+// eslint-disable-next-line regexp/no-super-linear-move -- won't use to long strings
 const fileRE = /(?:[a-zA-Z]:\\|\/).*?:\d+:\d+/g
+// eslint-disable-next-line regexp/no-super-linear-move -- won't use to long strings
 const codeframeRE = /^(?:>?\s+\d+\s+\|.*|\s+\|\s*\^.*)\r?\n/gm
 
 // Allow `ErrorOverlay` to extend `HTMLElement` even in environments where
diff --git a/packages/vite/src/node/optimizer/scan.ts b/packages/vite/src/node/optimizer/scan.ts
index 662f6050a470a0..46eece2fa9db6d 100644
--- a/packages/vite/src/node/optimizer/scan.ts
+++ b/packages/vite/src/node/optimizer/scan.ts
@@ -40,6 +40,7 @@ const htmlTypesRE = /\.(html|vue|svelte|astro|imba)$/
 // since even missed imports can be caught at runtime, and false positives will
 // simply be ignored.
 export const importsRE =
+  // eslint-disable-next-line regexp/no-super-linear-move -- TODO: FIXME backtracking
   /(?<!\/\/.*)(?<=^|;|\*\/)\s*import(?!\s+type)(?:[\w*{}\n\r\t, ]+from)?\s*("[^"]+"|'[^']+')\s*(?=$|;|\/\/|\/\*)/gm
 
 export async function scanImports(config: ResolvedConfig): Promise<{
diff --git a/packages/vite/src/node/plugins/dynamicImportVars.ts b/packages/vite/src/node/plugins/dynamicImportVars.ts
index 0f32f5ff581920..960ceb58e203da 100644
--- a/packages/vite/src/node/plugins/dynamicImportVars.ts
+++ b/packages/vite/src/node/plugins/dynamicImportVars.ts
@@ -12,7 +12,7 @@ import {
   normalizePath,
   parseRequest,
   removeComments,
-  requestQuerySplitRE,
+  splitRequestWithQuery,
   transformStableResult
 } from '../utils'
 import { toAbsoluteGlob } from './importMetaGlob'
@@ -59,8 +59,8 @@ function parseDynamicImportPattern(
     return null
   }
 
-  const [userPattern] = userPatternQuery.split(requestQuerySplitRE, 2)
-  const [rawPattern] = filename.split(requestQuerySplitRE, 2)
+  const [userPattern] = splitRequestWithQuery(userPatternQuery)
+  const [rawPattern] = splitRequestWithQuery(filename)
 
   if (rawQuery?.raw !== undefined) {
     globParams = { as: 'raw' }
diff --git a/packages/vite/src/node/plugins/ensureWatch.ts b/packages/vite/src/node/plugins/ensureWatch.ts
index 30a6fb3d6df819..f5dc29b671577f 100644
--- a/packages/vite/src/node/plugins/ensureWatch.ts
+++ b/packages/vite/src/node/plugins/ensureWatch.ts
@@ -1,5 +1,5 @@
 import type { Plugin } from '../plugin'
-import { cleanUrl, queryRE } from '../utils'
+import { cleanUrl } from '../utils'
 
 /**
  * plugin to ensure rollup can watch correctly.
@@ -8,7 +8,7 @@ export function ensureWatchPlugin(): Plugin {
   return {
     name: 'vite:ensure-watch',
     load(id) {
-      if (queryRE.test(id)) {
+      if (id.includes('?')) {
         this.addWatchFile(cleanUrl(id))
       }
       return null
diff --git a/packages/vite/src/node/plugins/html.ts b/packages/vite/src/node/plugins/html.ts
index d5c3de1daeac65..e249098ece694c 100644
--- a/packages/vite/src/node/plugins/html.ts
+++ b/packages/vite/src/node/plugins/html.ts
@@ -19,7 +19,8 @@ import {
   isDataUrl,
   isExternalUrl,
   normalizePath,
-  processSrcSet
+  processSrcSet,
+  removeComments
 } from '../utils'
 import type { ResolvedConfig } from '../config'
 import { toOutputFilePathInHtml } from '../build'
@@ -48,9 +49,9 @@ const inlineImportRE =
 const htmlLangRE = /\.(?:html|htm)$/
 
 const importMapRE =
-  /[ \t]*<script[^>]*type\s*=\s*(?:"importmap"|'importmap'|importmap)[^>]*>.*?<\/script>/is
+  /<script[^>]*type\s*=\s*(?:"importmap"|'importmap'|importmap)[^>]*>.*?<\/script>/is
 const moduleScriptRE =
-  /[ \t]*<script[^>]*type\s*=\s*(?:"module"|'module'|module)[^>]*>/i
+  /<script[^>]*type\s*=\s*(?:"module"|'module'|module)[^>]*>/i
 
 export const isHTMLProxy = (id: string): boolean => htmlProxyRE.test(id)
 
@@ -986,11 +987,10 @@ export async function applyHtmlTransforms(
 }
 
 const importRE = /\bimport\s*("[^"]*[^\\]"|'[^']*[^\\]');*/g
-const commentRE = /\/\*[\s\S]*?\*\/|\/\/.*$/gm
 function isEntirelyImport(code: string) {
   // only consider "side-effect" imports, which match <script type=module> semantics exactly
   // the regexes will remove too little in some exotic cases, but false-negatives are alright
-  return !code.replace(importRE, '').replace(commentRE, '').trim().length
+  return !removeComments(code.replace(importRE, '')).trim().length
 }
 
 function getBaseInHTML(urlRelativePath: string, config: ResolvedConfig) {
@@ -1004,14 +1004,14 @@ function getBaseInHTML(urlRelativePath: string, config: ResolvedConfig) {
     : config.base
 }
 
-const headInjectRE = /([ \t]*)<\/head>/i
-const headPrependInjectRE = /([ \t]*)<head[^>]*>/i
+const headInjectRE = /<\/head>/i
+const headPrependInjectRE = /<head[^>]*>/i
 
 const htmlInjectRE = /<\/html>/i
-const htmlPrependInjectRE = /([ \t]*)<html[^>]*>/i
+const htmlPrependInjectRE = /<html[^>]*>/i
 
-const bodyInjectRE = /([ \t]*)<\/body>/i
-const bodyPrependInjectRE = /([ \t]*)<body[^>]*>/i
+const bodyInjectRE = /<\/body>/i
+const bodyPrependInjectRE = /<body[^>]*>/i
 
 const doctypePrependInjectRE = /<!doctype html>/i
 
@@ -1025,32 +1025,43 @@ function injectToHead(
   if (prepend) {
     // inject as the first element of head
     if (headPrependInjectRE.test(html)) {
-      return html.replace(
-        headPrependInjectRE,
-        (match, p1) => `${match}\n${serializeTags(tags, incrementIndent(p1))}`
-      )
+      return html.replace(headPrependInjectRE, (match, offset) => {
+        const indent = getIndent(html, offset)
+        return `${match}\n${serializeTags(tags, incrementIndent(indent))}`
+      })
     }
   } else {
     // inject before head close
     if (headInjectRE.test(html)) {
       // respect indentation of head tag
-      return html.replace(
-        headInjectRE,
-        (match, p1) => `${serializeTags(tags, incrementIndent(p1))}${match}`
-      )
+      return html.replace(headInjectRE, (match, offset) => {
+        const indent = getIndent(html, offset)
+        return `\n${serializeTags(
+          tags,
+          incrementIndent(indent)
+        )}${indent}${match}`
+      })
     }
     // try to inject before the body tag
     if (bodyPrependInjectRE.test(html)) {
-      return html.replace(
-        bodyPrependInjectRE,
-        (match, p1) => `${serializeTags(tags, p1)}\n${match}`
-      )
+      return html.replace(bodyPrependInjectRE, (match, offset) => {
+        const indent = getIndent(html, offset)
+        return `${serializeTags(tags, indent)}\n${match}`
+      })
     }
   }
   // if no head tag is present, we prepend the tag for both prepend and append
   return prependInjectFallback(html, tags)
 }
 
+function getIndent(html: string, pos: number) {
+  let indent = ''
+  for (; pos >= 0 && (html[pos] === ' ' || html[pos] === '\t'); pos--) {
+    indent += html[pos]
+  }
+  return indent
+}
+
 function injectToBody(
   html: string,
   tags: HtmlTagDescriptor[],
@@ -1061,26 +1072,29 @@ function injectToBody(
   if (prepend) {
     // inject after body open
     if (bodyPrependInjectRE.test(html)) {
-      return html.replace(
-        bodyPrependInjectRE,
-        (match, p1) => `${match}\n${serializeTags(tags, incrementIndent(p1))}`
-      )
+      return html.replace(bodyPrependInjectRE, (match, offset) => {
+        const indent = getIndent(html, offset)
+        return `${match}\n${serializeTags(tags, incrementIndent(indent))}`
+      })
     }
     // if no there is no body tag, inject after head or fallback to prepend in html
     if (headInjectRE.test(html)) {
-      return html.replace(
-        headInjectRE,
-        (match, p1) => `${match}\n${serializeTags(tags, p1)}`
-      )
+      return html.replace(headInjectRE, (match, offset) => {
+        const indent = getIndent(html, offset)
+        return `${match}\n${serializeTags(tags, indent)}`
+      })
     }
     return prependInjectFallback(html, tags)
   } else {
     // inject before body close
     if (bodyInjectRE.test(html)) {
-      return html.replace(
-        bodyInjectRE,
-        (match, p1) => `${serializeTags(tags, incrementIndent(p1))}${match}`
-      )
+      return html.replace(bodyInjectRE, (match, offset) => {
+        const indent = getIndent(match, offset)
+        return `\n${serializeTags(
+          tags,
+          incrementIndent(indent)
+        )}${indent}${match}`
+      })
     }
     // if no body tag is present, append to the html tag, or at the end of the file
     if (htmlInjectRE.test(html)) {
diff --git a/packages/vite/src/node/plugins/importAnalysis.ts b/packages/vite/src/node/plugins/importAnalysis.ts
index 9dd0b028226396..34c9044516b55a 100644
--- a/packages/vite/src/node/plugins/importAnalysis.ts
+++ b/packages/vite/src/node/plugins/importAnalysis.ts
@@ -580,6 +580,7 @@ export function importAnalysisPlugin(config: ResolvedConfig): Plugin {
 
           if (!ssr) {
             const url = rawUrl
+              // eslint-disable-next-line regexp/no-super-linear-move -- `rawUrl` won't be so long
               .replace(/\/\*[\s\S]*?\*\/|([^\\:]|^)\/\/.*$/gm, '')
               .trim()
             if (
diff --git a/packages/vite/src/node/plugins/importMetaGlob.ts b/packages/vite/src/node/plugins/importMetaGlob.ts
index f0aac1e8dc98b5..3c5e533249b2ad 100644
--- a/packages/vite/src/node/plugins/importMetaGlob.ts
+++ b/packages/vite/src/node/plugins/importMetaGlob.ts
@@ -139,7 +139,7 @@ export async function parseImportGlob(
       // tailing comma in object or array will make the parser think it's a comma operation
       // we try to parse again removing the comma
       try {
-        const statement = code.slice(start, lastTokenPos).replace(/[,\s]*$/, '')
+        const statement = trimTrailingComma(code.slice(start, lastTokenPos))
         ast = parseExpressionAt(
           ' '.repeat(start) + statement, // to keep the ast position
           start,
@@ -300,6 +300,14 @@ export async function parseImportGlob(
   return (await Promise.all(tasks)).filter(Boolean)
 }
 
+const spaceRE = /^\s*$/
+
+function trimTrailingComma(code: string): string {
+  const pos = code.lastIndexOf(',')
+  const remove = code.slice(pos + 1)
+  return spaceRE.test(remove) ? code.slice(0, pos) : code
+}
+
 const importPrefix = '__vite_glob_'
 
 const { basename, dirname, relative, join } = posix
diff --git a/packages/vite/src/node/plugins/workerImportMetaUrl.ts b/packages/vite/src/node/plugins/workerImportMetaUrl.ts
index 61b9b4750ac06f..cbad0ec9c52f2f 100644
--- a/packages/vite/src/node/plugins/workerImportMetaUrl.ts
+++ b/packages/vite/src/node/plugins/workerImportMetaUrl.ts
@@ -41,6 +41,7 @@ function getWorkerType(raw: string, clean: string, i: number): WorkerType {
   // need to find in comment code
   const workerOptString = raw
     .substring(commaIndex + 1, endIndex)
+    // eslint-disable-next-line regexp/no-super-linear-move -- `raw` won't be so long
     .replace(/\}[\s\S]*,/g, '}') // strip trailing comma for parsing
 
   const hasViteIgnore = ignoreFlagRE.test(workerOptString)
diff --git a/packages/vite/src/node/utils.ts b/packages/vite/src/node/utils.ts
index 3bff9dae7a2cca..cc988d0e36e6eb 100644
--- a/packages/vite/src/node/utils.ts
+++ b/packages/vite/src/node/utils.ts
@@ -78,9 +78,11 @@ export const flattenId = (id: string): string =>
   id
     .replace(/[/:]/g, '_')
     .replace(/\./g, '__')
+    // eslint-disable-next-line regexp/no-super-linear-move -- the input id won't be so long
     .replace(/(\s*>\s*)/g, '___')
 
 export const normalizeId = (id: string): string =>
+  // eslint-disable-next-line regexp/no-super-linear-move -- the input id won't be so long
   id.replace(/(\s*>\s*)/g, ' > ')
 
 //TODO: revisit later to see if the edge case that "compiling using node v12 code to be run in node v16 in the server" is what we intend to support.
@@ -261,11 +263,13 @@ export function ensureVolumeInPath(file: string): string {
   return isWindows ? path.resolve(file) : file
 }
 
-export const queryRE = /\?.*$/s
-export const hashRE = /#.*$/s
+function trimEndFromLastOfThatChar(input: string, char: string) {
+  const pos = input.lastIndexOf(char)
+  return pos < 0 ? input : input.slice(0, pos)
+}
 
 export const cleanUrl = (url: string): string =>
-  url.replace(hashRE, '').replace(queryRE, '')
+  trimEndFromLastOfThatChar(trimEndFromLastOfThatChar(url, '#'), '?')
 
 export const externalRE = /^(https?:)?\/\//
 export const isExternalUrl = (url: string): boolean => externalRE.test(url)
@@ -545,7 +549,7 @@ export function isFileReadable(filename: string): boolean {
   }
 }
 
-const splitFirstDirRE = /(.+?)[\\/](.+)/
+const dirSplitRE = /[\\/]/
 
 /**
  * Delete every file and subdirectory. **The given directory must exist.**
@@ -557,10 +561,11 @@ export function emptyDir(dir: string, skip?: string[]): void {
   if (skip?.length) {
     for (const file of skip) {
       if (path.dirname(file) !== '.') {
-        const matched = file.match(splitFirstDirRE)
-        if (matched) {
+        const pos = file.match(dirSplitRE)?.index
+        if (pos) {
           nested ??= new Map()
-          const [, nestedDir, skipPath] = matched
+          const nestedDir = file.slice(0, pos)
+          const skipPath = file.slice(pos + 1)
           let nestedSkip = nested.get(nestedDir)
           if (!nestedSkip) {
             nestedSkip = []
@@ -911,7 +916,6 @@ export function toUpperCaseDriveLetter(pathName: string): string {
 // Taken from https://stackoverflow.com/a/36328890
 export const multilineCommentsRE = /\/\*[^*]*\*+(?:[^/*][^*]*\*+)*\//g
 export const singlelineCommentsRE = /\/\/.*/g
-export const requestQuerySplitRE = /\?(?!.*[/|}])/
 
 // @ts-expect-error
 export const usingDynamicImport = typeof jest === 'undefined'
@@ -929,8 +933,22 @@ export const dynamicImport = usingDynamicImport
   ? new Function('file', 'return import(file)')
   : _require
 
+const requestQueryRejectCharsRE = /[/|}]/
+
+export function splitRequestWithQuery(id: string): [string, string] {
+  const pos = id.lastIndexOf('?')
+  if (pos < 0) return [id, '']
+
+  const query = id.slice(pos + 1)
+  if (requestQueryRejectCharsRE.test(query)) {
+    return [id, '']
+  }
+
+  return [id.slice(0, pos), query]
+}
+
 export function parseRequest(id: string): Record<string, string> | null {
-  const [_, search] = id.split(requestQuerySplitRE, 2)
+  const [, search] = splitRequestWithQuery(id)
   if (!search) {
     return null
   }