From 7aa9f43c6fc9e83f83b8d62888904bf97838c7d5 Mon Sep 17 00:00:00 2001
From: meteorlxy <meteor.lxy@foxmail.com>
Date: Fri, 16 Aug 2024 10:11:34 +0800
Subject: [PATCH] chore: updates

---
 packages/core/src/types/page.ts               |  13 +-
 packages/core/src/types/plugin.ts             |   2 +-
 packages/core/src/types/pluginApi/hooks.ts    |  12 +-
 .../tests/app/resolvePluginObject.spec.ts     |   6 +-
 packages/core/tests/page/createPage.spec.ts   |  23 +-
 .../core/tests/page/inferPagePath.spec.ts     |  60 ++-
 .../core/tests/page/renderPageContent.spec.ts | 205 ++++----
 .../tests/page/resolvePageChunkInfo.spec.ts   |  22 +-
 .../page/resolvePageComponentInfo.spec.ts     |  23 +-
 .../core/tests/page/resolvePageDate.spec.ts   |  10 +-
 .../tests/page/resolvePageFileContent.spec.ts |  58 ++-
 .../tests/page/resolvePageFilePath.spec.ts    |  77 ++-
 .../tests/page/resolvePageHtmlInfo.spec.ts    |  24 +-
 .../core/tests/page/resolvePageLang.spec.ts   |  68 ++-
 .../core/tests/page/resolvePagePath.spec.ts   |  36 +-
 .../tests/page/resolvePagePermalink.spec.ts   | 317 ++++++------
 .../tests/page/resolvePageRouteMeta.spec.ts   |  34 +-
 .../core/tests/page/resolvePageSlug.spec.ts   |  34 +-
 .../tests/pluginApi/createHookQueue.spec.ts   | 466 +++++++++---------
 .../tests/pluginApi/createPluginApi.spec.ts   |  74 ++-
 .../normalizeAliasDefineHook.spec.ts          |  42 +-
 .../normalizeClientFilesHook.spec.ts          |  72 ++-
 .../src/plugins/assetsPlugin/assetsPlugin.ts  |   2 +-
 23 files changed, 832 insertions(+), 848 deletions(-)

diff --git a/packages/core/src/types/page.ts b/packages/core/src/types/page.ts
index 5aadd8d7ae..178fec9782 100644
--- a/packages/core/src/types/page.ts
+++ b/packages/core/src/types/page.ts
@@ -5,11 +5,14 @@ import type { PageBase, PageData, PageFrontmatter } from '@vuepress/shared'
  * Vuepress Page
  */
 export type Page<
-  ExtraPageData extends Record<any, any> = Record<never, never>,
-  ExtraPageFrontmatter extends Record<any, any> = Record<string, unknown>,
-  ExtraPageFields extends Record<any, any> = Record<never, never>,
-> = PageBase<ExtraPageFrontmatter> &
-  ExtraPageFields & {
+  ExtraPageData extends Record<string, unknown> = Record<string, unknown>,
+  ExtraPageFrontmatter extends Record<string, unknown> = Record<
+    string,
+    unknown
+  >,
+  ExtraPageFields extends Record<string, unknown> = Record<string, unknown>,
+> = ExtraPageFields &
+  PageBase<ExtraPageFrontmatter> & {
     /**
      * Data of the page, which will be available in client code
      */
diff --git a/packages/core/src/types/plugin.ts b/packages/core/src/types/plugin.ts
index c7f6bc39ca..ae52a6b334 100644
--- a/packages/core/src/types/plugin.ts
+++ b/packages/core/src/types/plugin.ts
@@ -11,8 +11,8 @@ import type { HooksExposed } from './pluginApi/index.js'
  * A plugin package should have a `Plugin` as the default export
  */
 export type Plugin<T extends PluginObject = PluginObject> =
-  | T
   | PluginFunction<T>
+  | T
 
 /**
  * Vuepress plugin function
diff --git a/packages/core/src/types/pluginApi/hooks.ts b/packages/core/src/types/pluginApi/hooks.ts
index 4e88851256..f2b2388f87 100644
--- a/packages/core/src/types/pluginApi/hooks.ts
+++ b/packages/core/src/types/pluginApi/hooks.ts
@@ -12,11 +12,11 @@ interface Closable {
 export interface Hook<
   Exposed,
   Normalized = Exposed,
-  Result = Normalized extends (...args: any) => infer U
+  Result = Normalized extends (...args: unknown[]) => infer U
     ? U extends Promise<infer V>
       ? V
       : U
-    : void,
+    : never,
 > {
   exposed: Exposed
   normalized: Normalized
@@ -41,9 +41,9 @@ export type ClientConfigFileHook = Hook<
 
 // alias and define hook
 export type AliasDefineHook = Hook<
-  | Record<string, any>
-  | ((app: App, isServer: boolean) => PromiseOrNot<Record<string, any>>),
-  (app: App, isServer: boolean) => Promise<Record<string, any>>
+  | Record<string, unknown>
+  | ((app: App, isServer: boolean) => PromiseOrNot<Record<string, unknown>>),
+  (app: App, isServer: boolean) => Promise<Record<string, unknown>>
 >
 
 /**
@@ -58,7 +58,7 @@ export interface Hooks {
   extendsMarkdown: ExtendsHook<Markdown>
   extendsPageOptions: ExtendsHook<PageOptions>
   extendsPage: ExtendsHook<Page>
-  extendsBundlerOptions: ExtendsHook<any>
+  extendsBundlerOptions: ExtendsHook<Record<string, unknown>>
   clientConfigFile: ClientConfigFileHook
   alias: AliasDefineHook
   define: AliasDefineHook
diff --git a/packages/core/tests/app/resolvePluginObject.spec.ts b/packages/core/tests/app/resolvePluginObject.spec.ts
index 02d2441e81..d359120252 100644
--- a/packages/core/tests/app/resolvePluginObject.spec.ts
+++ b/packages/core/tests/app/resolvePluginObject.spec.ts
@@ -1,12 +1,12 @@
 import { path } from '@vuepress/utils'
 import { describe, expect, it, vi } from 'vitest'
+import type { Bundler, PluginFunction, PluginObject } from '../../src/index.js'
 import { createBaseApp, resolvePluginObject } from '../../src/index.js'
-import type { PluginFunction, PluginObject } from '../../src/index.js'
 
 const app = createBaseApp({
   source: path.resolve(__dirname, 'fake-source'),
   theme: { name: 'test' },
-  bundler: {} as any,
+  bundler: {} as Bundler,
 })
 
 describe('core > app > resolvePluginObject', () => {
@@ -20,7 +20,7 @@ describe('core > app > resolvePluginObject', () => {
   })
 
   it('should work with plugin function', () => {
-    const pluginFunction: PluginFunction = vi.fn((app) => ({
+    const pluginFunction: PluginFunction = vi.fn(() => ({
       name: 'plugin-function',
     }))
 
diff --git a/packages/core/tests/page/createPage.spec.ts b/packages/core/tests/page/createPage.spec.ts
index e2f832b2ab..313fed3876 100644
--- a/packages/core/tests/page/createPage.spec.ts
+++ b/packages/core/tests/page/createPage.spec.ts
@@ -1,18 +1,19 @@
 import { path } from '@vuepress/utils'
 import { beforeAll, describe, expect, it, vi } from 'vitest'
+import type { Bundler } from '../../src/index.js'
 import { createBaseApp, createPage } from '../../src/index.js'
 
-const app = createBaseApp({
-  source: path.resolve(__dirname, 'fake-source'),
-  theme: { name: 'test' },
-  bundler: {} as any,
-})
+describe('should work without plugins', () => {
+  const app = createBaseApp({
+    source: path.resolve(__dirname, 'fake-source'),
+    theme: { name: 'test' },
+    bundler: {} as Bundler,
+  })
 
-beforeAll(async () => {
-  await app.init()
-})
+  beforeAll(async () => {
+    await app.init()
+  })
 
-describe('core > page > createPage', () => {
   it('should throw an error', async () => {
     const consoleError = console.error
     console.error = vi.fn()
@@ -86,12 +87,14 @@ describe('core > page > createPage', () => {
     )
     expect(page.chunkName).toBeTruthy()
   })
+})
 
+describe('should work with plugins', () => {
   it('should be extended by plugin correctly', async () => {
     const app = createBaseApp({
       source: path.resolve(__dirname, 'fake-source'),
       theme: { name: 'test' },
-      bundler: {} as any,
+      bundler: {} as Bundler,
     })
     app.use({
       name: 'foo',
diff --git a/packages/core/tests/page/inferPagePath.spec.ts b/packages/core/tests/page/inferPagePath.spec.ts
index 42eef99279..f65aced2ad 100644
--- a/packages/core/tests/page/inferPagePath.spec.ts
+++ b/packages/core/tests/page/inferPagePath.spec.ts
@@ -51,41 +51,39 @@ const TEST_CASES: [string, ReturnType<typeof inferPagePath>][] = [
   ],
 ]
 
-describe('core > page > inferPagePath', () => {
-  describe('should infer page path according to relative path of page file', () => {
-    TEST_CASES.forEach(([source, expected]) => {
-      it(JSON.stringify(source), () => {
-        expect(
-          inferPagePath({
-            app,
-            filePathRelative: source,
-          }),
-        ).toEqual(expected)
-      })
+describe('should infer page path according to relative path of page file', () => {
+  TEST_CASES.forEach(([source, expected]) => {
+    it(JSON.stringify(source), () => {
+      expect(
+        inferPagePath({
+          app,
+          filePathRelative: source,
+        }),
+      ).toEqual(expected)
     })
   })
+})
 
-  it('should use `/` as the default locale path', () => {
-    expect(
-      inferPagePath({
-        app: appWithoutLocales,
-        filePathRelative: 'en/foo/bar.md',
-      }),
-    ).toEqual({
-      pathInferred: '/en/foo/bar.html',
-      pathLocale: '/',
-    })
+it('should use `/` as the default locale path', () => {
+  expect(
+    inferPagePath({
+      app: appWithoutLocales,
+      filePathRelative: 'en/foo/bar.md',
+    }),
+  ).toEqual({
+    pathInferred: '/en/foo/bar.html',
+    pathLocale: '/',
   })
+})
 
-  it('should handle empty file relative path', () => {
-    expect(
-      inferPagePath({
-        app,
-        filePathRelative: null,
-      }),
-    ).toEqual({
-      pathInferred: null,
-      pathLocale: '/',
-    })
+it('should handle empty file relative path', () => {
+  expect(
+    inferPagePath({
+      app,
+      filePathRelative: null,
+    }),
+  ).toEqual({
+    pathInferred: null,
+    pathLocale: '/',
   })
 })
diff --git a/packages/core/tests/page/renderPageContent.spec.ts b/packages/core/tests/page/renderPageContent.spec.ts
index 055beaf0a1..c4c3e756fd 100644
--- a/packages/core/tests/page/renderPageContent.spec.ts
+++ b/packages/core/tests/page/renderPageContent.spec.ts
@@ -1,155 +1,154 @@
 import { createMarkdown } from '@vuepress/markdown'
 import { path } from '@vuepress/utils'
 import { describe, expect, it } from 'vitest'
+import type { Bundler } from '../../src/index.js'
 import { createBaseApp, renderPageContent } from '../../src/index.js'
 
 const app = createBaseApp({
   source: path.resolve(__dirname, 'fake-source'),
   theme: { name: 'test' },
-  bundler: {} as any,
+  bundler: {} as Bundler,
 })
 app.markdown = createMarkdown()
 
-describe('core > page > renderPageContent', () => {
-  it('should render page content correctly', () => {
-    const resolved = renderPageContent({
-      app,
-      content: `\
+it('should render page content correctly', () => {
+  const resolved = renderPageContent({
+    app,
+    content: `\
 foobar
 <script setup lang="ts">
 const msg = 'msg'
 </script>
 `,
-      filePath: app.dir.source('foo.md'),
-      filePathRelative: 'foo.md',
-      options: {},
-    })
+    filePath: app.dir.source('foo.md'),
+    filePathRelative: 'foo.md',
+    options: {},
+  })
 
-    expect(resolved).toEqual({
-      contentRendered: '<p>foobar</p>\n',
-      deps: [],
-      frontmatter: {},
-      headers: [],
-      links: [],
-      markdownEnv: { excerpt: '' },
-      sfcBlocks: {
-        template: {
-          type: 'template',
-          content: '<template><p>foobar</p>\n</template>',
-          contentStripped: '<p>foobar</p>\n',
-          tagClose: '</template>',
-          tagOpen: '<template>',
-        },
-        script: null,
-        scriptSetup: {
+  expect(resolved).toEqual({
+    contentRendered: '<p>foobar</p>\n',
+    deps: [],
+    frontmatter: {},
+    headers: [],
+    links: [],
+    markdownEnv: { excerpt: '' },
+    sfcBlocks: {
+      template: {
+        type: 'template',
+        content: '<template><p>foobar</p>\n</template>',
+        contentStripped: '<p>foobar</p>\n',
+        tagClose: '</template>',
+        tagOpen: '<template>',
+      },
+      script: null,
+      scriptSetup: {
+        type: 'script',
+        content: `<script setup lang="ts">\nconst msg = 'msg'\n</script>`,
+        contentStripped: `\nconst msg = 'msg'\n`,
+        tagClose: '</script>',
+        tagOpen: '<script setup lang="ts">',
+      },
+      scripts: [
+        {
           type: 'script',
           content: `<script setup lang="ts">\nconst msg = 'msg'\n</script>`,
           contentStripped: `\nconst msg = 'msg'\n`,
           tagClose: '</script>',
           tagOpen: '<script setup lang="ts">',
         },
-        scripts: [
-          {
-            type: 'script',
-            content: `<script setup lang="ts">\nconst msg = 'msg'\n</script>`,
-            contentStripped: `\nconst msg = 'msg'\n`,
-            tagClose: '</script>',
-            tagOpen: '<script setup lang="ts">',
-          },
-        ],
-        styles: [],
-        customBlocks: [],
-      },
-      title: '',
-    })
+      ],
+      styles: [],
+      customBlocks: [],
+    },
+    title: '',
   })
+})
 
-  describe('page title', () => {
-    it('should use title in frontmatter', () => {
-      const resolved = renderPageContent({
-        app,
-        content: '# title in header',
-        filePath: null,
-        filePathRelative: null,
-        options: {
-          frontmatter: {
-            title: 'title in frontmatter',
-          },
+describe('page title', () => {
+  it('should use title in frontmatter', () => {
+    const resolved = renderPageContent({
+      app,
+      content: '# title in header',
+      filePath: null,
+      filePathRelative: null,
+      options: {
+        frontmatter: {
+          title: 'title in frontmatter',
         },
-      })
-
-      expect(resolved.title).toEqual('title in frontmatter')
+      },
     })
 
-    it('should use title in the first h1 header', () => {
-      const resolved = renderPageContent({
-        app,
-        content: '# title in header',
-        filePath: null,
-        filePathRelative: null,
-        options: {},
-      })
+    expect(resolved.title).toEqual('title in frontmatter')
+  })
 
-      expect(resolved.title).toEqual('title in header')
+  it('should use title in the first h1 header', () => {
+    const resolved = renderPageContent({
+      app,
+      content: '# title in header',
+      filePath: null,
+      filePathRelative: null,
+      options: {},
     })
 
-    it('should use empty title', () => {
-      const resolved = renderPageContent({
-        app,
-        content: '',
-        filePath: null,
-        filePathRelative: null,
-        options: {},
-      })
+    expect(resolved.title).toEqual('title in header')
+  })
 
-      expect(resolved.title).toEqual('')
+  it('should use empty title', () => {
+    const resolved = renderPageContent({
+      app,
+      content: '',
+      filePath: null,
+      filePathRelative: null,
+      options: {},
     })
+
+    expect(resolved.title).toEqual('')
   })
+})
 
-  describe('page frontmatter', () => {
-    it('should merge markdown frontmatter and options frontmatter', () => {
-      const resolved = renderPageContent({
-        app,
-        content: `\
+describe('page frontmatter', () => {
+  it('should merge markdown frontmatter and options frontmatter', () => {
+    const resolved = renderPageContent({
+      app,
+      content: `\
 ---
 title: title in markdown frontmatter
 ---
 `,
-        filePath: null,
-        filePathRelative: null,
-        options: {
-          frontmatter: {
-            description: 'description in options frontmatter',
-          },
+      filePath: null,
+      filePathRelative: null,
+      options: {
+        frontmatter: {
+          description: 'description in options frontmatter',
         },
-      })
+      },
+    })
 
-      expect(resolved.frontmatter).toEqual({
-        title: 'title in markdown frontmatter',
-        description: 'description in options frontmatter',
-      })
+    expect(resolved.frontmatter).toEqual({
+      title: 'title in markdown frontmatter',
+      description: 'description in options frontmatter',
     })
+  })
 
-    it('should use fields from markdown frontmatter first', () => {
-      const resolved = renderPageContent({
-        app,
-        content: `\
+  it('should use fields from markdown frontmatter first', () => {
+    const resolved = renderPageContent({
+      app,
+      content: `\
 ---
 title: title in markdown frontmatter
 ---
 `,
-        filePath: null,
-        filePathRelative: null,
-        options: {
-          frontmatter: {
-            title: 'title in options frontmatter',
-          },
+      filePath: null,
+      filePathRelative: null,
+      options: {
+        frontmatter: {
+          title: 'title in options frontmatter',
         },
-      })
+      },
+    })
 
-      expect(resolved.frontmatter).toEqual({
-        title: 'title in markdown frontmatter',
-      })
+    expect(resolved.frontmatter).toEqual({
+      title: 'title in markdown frontmatter',
     })
   })
 })
diff --git a/packages/core/tests/page/resolvePageChunkInfo.spec.ts b/packages/core/tests/page/resolvePageChunkInfo.spec.ts
index 19ec02eb03..738d3c1f05 100644
--- a/packages/core/tests/page/resolvePageChunkInfo.spec.ts
+++ b/packages/core/tests/page/resolvePageChunkInfo.spec.ts
@@ -1,5 +1,5 @@
 import { path, sanitizeFileName } from '@vuepress/utils'
-import { describe, expect, it } from 'vitest'
+import { expect, it } from 'vitest'
 import type { Bundler } from '../../src/index.js'
 import { createBaseApp, resolvePageChunkInfo } from '../../src/index.js'
 
@@ -9,17 +9,15 @@ const app = createBaseApp({
   bundler: {} as Bundler,
 })
 
-describe('core > page > resolvePageChunkInfo', () => {
-  it('should resolve page chunk info correctly', () => {
-    const resolved = resolvePageChunkInfo({
-      app,
-      htmlFilePathRelative: 'foo.html',
-    })
+it('should resolve page chunk info correctly', () => {
+  const resolved = resolvePageChunkInfo({
+    app,
+    htmlFilePathRelative: 'foo.html',
+  })
 
-    expect(resolved).toEqual({
-      chunkFilePath: app.dir.temp('pages/foo.html.js'),
-      chunkFilePathRelative: 'pages/foo.html.js',
-      chunkName: sanitizeFileName('foo.html'),
-    })
+  expect(resolved).toEqual({
+    chunkFilePath: app.dir.temp('pages/foo.html.js'),
+    chunkFilePathRelative: 'pages/foo.html.js',
+    chunkName: sanitizeFileName('foo.html'),
   })
 })
diff --git a/packages/core/tests/page/resolvePageComponentInfo.spec.ts b/packages/core/tests/page/resolvePageComponentInfo.spec.ts
index 15c9b009b9..a1b9c6d997 100644
--- a/packages/core/tests/page/resolvePageComponentInfo.spec.ts
+++ b/packages/core/tests/page/resolvePageComponentInfo.spec.ts
@@ -1,23 +1,22 @@
 import { path } from '@vuepress/utils'
-import { describe, expect, it } from 'vitest'
+import { expect, it } from 'vitest'
+import type { Bundler } from '../../src/index.js'
 import { createBaseApp, resolvePageComponentInfo } from '../../src/index.js'
 
 const app = createBaseApp({
   source: path.resolve(__dirname, 'fake-source'),
   theme: { name: 'test' },
-  bundler: {} as any,
+  bundler: {} as Bundler,
 })
 
-describe('core > page > resolvePageComponentInfo', () => {
-  it('should resolve page component info correctly', async () => {
-    const resolved = await resolvePageComponentInfo({
-      app,
-      htmlFilePathRelative: 'foo.html',
-    })
+it('should resolve page component info correctly', async () => {
+  const resolved = await resolvePageComponentInfo({
+    app,
+    htmlFilePathRelative: 'foo.html',
+  })
 
-    expect(resolved).toEqual({
-      componentFilePath: app.dir.temp('pages/foo.html.vue'),
-      componentFilePathRelative: 'pages/foo.html.vue',
-    })
+  expect(resolved).toEqual({
+    componentFilePath: app.dir.temp('pages/foo.html.vue'),
+    componentFilePathRelative: 'pages/foo.html.vue',
   })
 })
diff --git a/packages/core/tests/page/resolvePageDate.spec.ts b/packages/core/tests/page/resolvePageDate.spec.ts
index 4ea6d358ca..f444ea1bc1 100644
--- a/packages/core/tests/page/resolvePageDate.spec.ts
+++ b/packages/core/tests/page/resolvePageDate.spec.ts
@@ -147,12 +147,10 @@ const TEST_CASES: [
   ],
 ]
 
-describe('core > page > resolvePageDate', () => {
-  describe('should resolve page date correctly', () => {
-    TEST_CASES.forEach(([source, expected]) => {
-      it(`raw: ${JSON.stringify(source)}`, () => {
-        expect(resolvePageDate(...source)).toEqual(expected)
-      })
+describe('should resolve page date correctly', () => {
+  TEST_CASES.forEach(([source, expected]) => {
+    it(`raw: ${JSON.stringify(source)}`, () => {
+      expect(resolvePageDate(...source)).toEqual(expected)
     })
   })
 })
diff --git a/packages/core/tests/page/resolvePageFileContent.spec.ts b/packages/core/tests/page/resolvePageFileContent.spec.ts
index e52569671c..41f92f9132 100644
--- a/packages/core/tests/page/resolvePageFileContent.spec.ts
+++ b/packages/core/tests/page/resolvePageFileContent.spec.ts
@@ -1,41 +1,39 @@
 import { fs, path } from '@vuepress/utils'
-import { describe, expect, it } from 'vitest'
+import { expect, it } from 'vitest'
 import { resolvePageFileContent } from '../../src/index.js'
 
-describe('core > page > resolvePageFileContent', () => {
-  it('should resolve file content correctly from file path', async () => {
-    const filePath = path.resolve(__dirname, '../__fixtures__/pages/foo.md')
-    const resolved = await resolvePageFileContent({ filePath, options: {} })
+it('should resolve file content correctly from file path', async () => {
+  const filePath = path.resolve(__dirname, '../__fixtures__/pages/foo.md')
+  const resolved = await resolvePageFileContent({ filePath, options: {} })
 
-    const expected = (await fs.readFile(filePath)).toString()
-    expect(resolved).toBe(expected)
+  const expected = (await fs.readFile(filePath)).toString()
+  expect(resolved).toBe(expected)
+})
+
+it('should use content from page options', async () => {
+  const content = 'foobar'
+  const resolved = await resolvePageFileContent({
+    filePath: null,
+    options: { content },
   })
+  expect(resolved).toBe(resolved)
+})
 
-  it('should use content from page options', async () => {
-    const content = 'foobar'
-    const resolved = await resolvePageFileContent({
-      filePath: null,
-      options: { content },
-    })
-    expect(resolved).toBe(resolved)
+it('should return empty string if nothing provided', async () => {
+  const resolved = await resolvePageFileContent({
+    filePath: null,
+    options: {},
   })
+  expect(resolved).toBe('')
+})
 
-  it('should return empty string if nothing provided', async () => {
-    const resolved = await resolvePageFileContent({
-      filePath: null,
+it('should throw error if the file does not exist', async () => {
+  try {
+    await resolvePageFileContent({
+      filePath: '404',
       options: {},
     })
-    expect(resolved).toBe('')
-  })
-
-  it('should throw error if the file does not exist', async () => {
-    try {
-      await resolvePageFileContent({
-        filePath: '404',
-        options: {},
-      })
-    } catch (e) {
-      expect(e).not.toBeUndefined()
-    }
-  })
+  } catch (e) {
+    expect(e).not.toBeUndefined()
+  }
 })
diff --git a/packages/core/tests/page/resolvePageFilePath.spec.ts b/packages/core/tests/page/resolvePageFilePath.spec.ts
index 2ba11b1c77..5d43c3ea39 100644
--- a/packages/core/tests/page/resolvePageFilePath.spec.ts
+++ b/packages/core/tests/page/resolvePageFilePath.spec.ts
@@ -1,56 +1,55 @@
 import { path } from '@vuepress/utils'
-import { describe, expect, it, vi } from 'vitest'
+import { expect, it, vi } from 'vitest'
+import type { Bundler } from '../../src/index.js'
 import { createBaseApp, resolvePageFilePath } from '../../src/index.js'
 
 const app = createBaseApp({
   source: path.resolve(__dirname, 'fake-source'),
   theme: { name: 'test' },
-  bundler: {} as any,
+  bundler: {} as Bundler,
 })
 
-describe('core > page > resolvePageFilePath', () => {
-  it('should return null if the filePath is empty', () => {
-    const resolved = resolvePageFilePath({
-      app,
-      options: {},
-    })
-    expect(resolved).toEqual({
-      filePath: null,
-      filePathRelative: null,
-    })
+const ABSOLUTE_FILE_PATH = app.dir.source('file.md')
+const RELATIVE_FILE_PATH = 'file.md'
+
+it('should return null if the filePath is empty', () => {
+  const resolved = resolvePageFilePath({
+    app,
+    options: {},
+  })
+  expect(resolved).toEqual({
+    filePath: null,
+    filePathRelative: null,
+  })
+})
+
+it('should resolve path correctly if filePath is absolute', () => {
+  const resolved = resolvePageFilePath({
+    app,
+    options: {
+      filePath: ABSOLUTE_FILE_PATH,
+    },
   })
+  expect(resolved).toEqual({
+    filePath: ABSOLUTE_FILE_PATH,
+    filePathRelative: RELATIVE_FILE_PATH,
+  })
+})
 
-  const absoluteFilePath = app.dir.source('file.md')
-  const relativeFilePath = 'file.md'
+it('should throw if filePath is relative', () => {
+  const consoleError = console.error
+  console.error = vi.fn()
 
-  it('should resolve path correctly if filePath is absolute', () => {
-    const resolved = resolvePageFilePath({
+  expect(() =>
+    resolvePageFilePath({
       app,
       options: {
-        filePath: absoluteFilePath,
+        filePath: RELATIVE_FILE_PATH,
       },
-    })
-    expect(resolved).toEqual({
-      filePath: absoluteFilePath,
-      filePathRelative: relativeFilePath,
-    })
-  })
+    }),
+  ).toThrow()
 
-  it('should throw if filePath is relative', () => {
-    const consoleError = console.error
-    console.error = vi.fn()
+  expect(console.error).toHaveBeenCalled()
 
-    expect(() =>
-      resolvePageFilePath({
-        app,
-        options: {
-          filePath: relativeFilePath,
-        },
-      }),
-    ).toThrow()
-
-    expect(console.error).toHaveBeenCalled()
-
-    console.error = consoleError
-  })
+  console.error = consoleError
 })
diff --git a/packages/core/tests/page/resolvePageHtmlInfo.spec.ts b/packages/core/tests/page/resolvePageHtmlInfo.spec.ts
index 61f04d5813..3da89ba355 100644
--- a/packages/core/tests/page/resolvePageHtmlInfo.spec.ts
+++ b/packages/core/tests/page/resolvePageHtmlInfo.spec.ts
@@ -20,19 +20,17 @@ const TEST_CASES: [string, string][] = [
   ['/foo/bar/', 'foo/bar/index.html'],
 ]
 
-describe('core > page > resolvePageHtmlInfo', () => {
-  describe('should resolve page html file path correctly', () => {
-    TEST_CASES.forEach(([source, expected]) => {
-      it(JSON.stringify(source), () => {
-        expect(
-          resolvePageHtmlInfo({
-            app,
-            path: source,
-          }),
-        ).toEqual({
-          htmlFilePath: app.dir.dest(expected),
-          htmlFilePathRelative: expected,
-        })
+describe('should resolve page html file path correctly', () => {
+  TEST_CASES.forEach(([source, expected]) => {
+    it(JSON.stringify(source), () => {
+      expect(
+        resolvePageHtmlInfo({
+          app,
+          path: source,
+        }),
+      ).toEqual({
+        htmlFilePath: app.dir.dest(expected),
+        htmlFilePathRelative: expected,
       })
     })
   })
diff --git a/packages/core/tests/page/resolvePageLang.spec.ts b/packages/core/tests/page/resolvePageLang.spec.ts
index 8b50e3e096..c15861e6d7 100644
--- a/packages/core/tests/page/resolvePageLang.spec.ts
+++ b/packages/core/tests/page/resolvePageLang.spec.ts
@@ -1,5 +1,5 @@
 import { path } from '@vuepress/utils'
-import { describe, expect, it } from 'vitest'
+import { expect, it } from 'vitest'
 import type { Bundler } from '../../src/index.js'
 import { createBaseApp, resolvePageLang } from '../../src/index.js'
 
@@ -15,48 +15,46 @@ const app = createBaseApp({
   },
 })
 
-describe('core > page > resolvePageLang', () => {
-  it('should use frontmatter lang', () => {
-    const lang = resolvePageLang({
-      app,
-      frontmatter: {
-        lang: 'frontmatter-lang',
-      },
-      pathLocale: '/',
-    })
-
-    expect(lang).toBe('frontmatter-lang')
+it('should use frontmatter lang', () => {
+  const lang = resolvePageLang({
+    app,
+    frontmatter: {
+      lang: 'frontmatter-lang',
+    },
+    pathLocale: '/',
   })
 
-  it('should use locales lang 1', () => {
-    const lang = resolvePageLang({
-      app,
-      frontmatter: {
-        lang: '',
-      },
-      pathLocale: '/',
-    })
+  expect(lang).toBe('frontmatter-lang')
+})
 
-    expect(lang).toBe('locales-lang')
+it('should use locales lang 1', () => {
+  const lang = resolvePageLang({
+    app,
+    frontmatter: {
+      lang: '',
+    },
+    pathLocale: '/',
   })
 
-  it('should use locales lang 2', () => {
-    const lang = resolvePageLang({
-      app,
-      frontmatter: {},
-      pathLocale: '/',
-    })
+  expect(lang).toBe('locales-lang')
+})
 
-    expect(lang).toBe('locales-lang')
+it('should use locales lang 2', () => {
+  const lang = resolvePageLang({
+    app,
+    frontmatter: {},
+    pathLocale: '/',
   })
 
-  it('should use site lang', () => {
-    const lang = resolvePageLang({
-      app,
-      frontmatter: {},
-      pathLocale: '/foo/',
-    })
+  expect(lang).toBe('locales-lang')
+})
 
-    expect(lang).toBe('site-lang')
+it('should use site lang', () => {
+  const lang = resolvePageLang({
+    app,
+    frontmatter: {},
+    pathLocale: '/foo/',
   })
+
+  expect(lang).toBe('site-lang')
 })
diff --git a/packages/core/tests/page/resolvePagePath.spec.ts b/packages/core/tests/page/resolvePagePath.spec.ts
index 9251721afc..316d8c04e1 100644
--- a/packages/core/tests/page/resolvePagePath.spec.ts
+++ b/packages/core/tests/page/resolvePagePath.spec.ts
@@ -96,28 +96,26 @@ const TEST_CASES: [
   ],
 ]
 
-describe('core > page > resolvePagePath', () => {
-  describe('should resolve page path correctly', () => {
-    TEST_CASES.forEach(([input, expected]) => {
-      it(`input: ${JSON.stringify(input)}`, () => {
-        expect(resolvePagePath(...input)).toEqual(expected)
-      })
+describe('should resolve page path correctly', () => {
+  TEST_CASES.forEach(([input, expected]) => {
+    it(`input: ${JSON.stringify(input)}`, () => {
+      expect(resolvePagePath(...input)).toEqual(expected)
     })
   })
+})
 
-  it('should throw an error', () => {
-    const consoleError = console.error
-    console.error = vi.fn()
+it('should throw an error', () => {
+  const consoleError = console.error
+  console.error = vi.fn()
 
-    expect(() =>
-      resolvePagePath({
-        permalink: null,
-        pathInferred: null,
-        options: {},
-      }),
-    ).toThrow()
-    expect(console.error).toHaveBeenCalled()
+  expect(() =>
+    resolvePagePath({
+      permalink: null,
+      pathInferred: null,
+      options: {},
+    }),
+  ).toThrow()
+  expect(console.error).toHaveBeenCalled()
 
-    console.error = consoleError
-  })
+  console.error = consoleError
 })
diff --git a/packages/core/tests/page/resolvePagePermalink.spec.ts b/packages/core/tests/page/resolvePagePermalink.spec.ts
index 341d98c005..1ecc43d05f 100644
--- a/packages/core/tests/page/resolvePagePermalink.spec.ts
+++ b/packages/core/tests/page/resolvePagePermalink.spec.ts
@@ -1,17 +1,18 @@
 import { path } from '@vuepress/utils'
 import { beforeAll, describe, expect, it } from 'vitest'
+import type { Bundler } from '../../src/index.js'
 import { createBaseApp, resolvePagePermalink } from '../../src/index.js'
 
 const app = createBaseApp({
   source: path.resolve(__dirname, 'fake-source'),
   theme: { name: 'test' },
-  bundler: {} as any,
+  bundler: {} as Bundler,
 })
 
 const appWithPermalinkPattern = createBaseApp({
   source: path.resolve(__dirname, 'fake-source'),
   theme: { name: 'test' },
-  bundler: {} as any,
+  bundler: {} as Bundler,
   permalinkPattern: '/:year/:month/:day/:slug/app',
 })
 
@@ -19,187 +20,185 @@ beforeAll(async () => {
   await app.init()
 })
 
-describe('core > page > resolvePagePermalink', () => {
-  describe('use permalink or pattern', () => {
-    it('should use permalink in frontmatter', () => {
-      const resolved = resolvePagePermalink({
-        app,
-        frontmatter: {
-          permalink: '/frontmatter',
-        },
-        slug: '',
-        date: '',
-        pathInferred: null,
-        pathLocale: '',
-      })
-
-      expect(resolved).toBe('/frontmatter')
+describe('use permalink or pattern', () => {
+  it('should use permalink in frontmatter', () => {
+    const resolved = resolvePagePermalink({
+      app,
+      frontmatter: {
+        permalink: '/frontmatter',
+      },
+      slug: '',
+      date: '',
+      pathInferred: null,
+      pathLocale: '',
     })
 
-    it('should return null', () => {
-      const resolved = resolvePagePermalink({
-        app: appWithPermalinkPattern,
-        frontmatter: {
-          permalink: null,
-        },
-        slug: '',
-        date: '',
-        pathInferred: '/inferred',
-        pathLocale: '',
-      })
-
-      expect(resolved).toBe(null)
+    expect(resolved).toBe('/frontmatter')
+  })
+
+  it('should return null', () => {
+    const resolved = resolvePagePermalink({
+      app: appWithPermalinkPattern,
+      frontmatter: {
+        permalink: null,
+      },
+      slug: '',
+      date: '',
+      pathInferred: '/inferred',
+      pathLocale: '',
     })
 
-    it('should use permalinkPattern in frontmatter', () => {
-      const resolved = resolvePagePermalink({
-        app,
-        frontmatter: {
-          permalinkPattern: '/:year/:month/:day/:slug/frontmatter',
-        },
-        slug: 'foo-bar',
-        date: '2020-10-07',
-        pathInferred: null,
-        pathLocale: '',
-      })
-
-      expect(resolved).toBe('/2020/10/07/foo-bar/frontmatter')
+    expect(resolved).toBe(null)
+  })
+
+  it('should use permalinkPattern in frontmatter', () => {
+    const resolved = resolvePagePermalink({
+      app,
+      frontmatter: {
+        permalinkPattern: '/:year/:month/:day/:slug/frontmatter',
+      },
+      slug: 'foo-bar',
+      date: '2020-10-07',
+      pathInferred: null,
+      pathLocale: '',
     })
 
-    it('should use permalinkPattern in app options', () => {
-      const resolved = resolvePagePermalink({
-        app: appWithPermalinkPattern,
-        frontmatter: {},
-        slug: 'foo-bar',
-        date: '2020-10-07',
-        pathInferred: null,
-        pathLocale: '',
-      })
-
-      expect(resolved).toBe('/2020/10/07/foo-bar/app')
+    expect(resolved).toBe('/2020/10/07/foo-bar/frontmatter')
+  })
+
+  it('should use permalinkPattern in app options', () => {
+    const resolved = resolvePagePermalink({
+      app: appWithPermalinkPattern,
+      frontmatter: {},
+      slug: 'foo-bar',
+      date: '2020-10-07',
+      pathInferred: null,
+      pathLocale: '',
     })
 
-    it('permalinkPattern in frontmatter should have higher priority', () => {
-      const resolved = resolvePagePermalink({
-        app: appWithPermalinkPattern,
-        frontmatter: {
-          permalinkPattern: '/:year/:month/:day/:slug/frontmatter',
-        },
-        slug: 'foo-bar',
-        date: '2020-10-07',
-        pathInferred: null,
-        pathLocale: '',
-      })
-
-      expect(resolved).toBe('/2020/10/07/foo-bar/frontmatter')
+    expect(resolved).toBe('/2020/10/07/foo-bar/app')
+  })
+
+  it('permalinkPattern in frontmatter should have higher priority', () => {
+    const resolved = resolvePagePermalink({
+      app: appWithPermalinkPattern,
+      frontmatter: {
+        permalinkPattern: '/:year/:month/:day/:slug/frontmatter',
+      },
+      slug: 'foo-bar',
+      date: '2020-10-07',
+      pathInferred: null,
+      pathLocale: '',
     })
 
-    it('permalink in frontmatter should have highest priority', () => {
-      const resolved = resolvePagePermalink({
-        app: appWithPermalinkPattern,
-        frontmatter: {
-          permalink: '/frontmatter',
-          permalinkPattern: '/:year/:month/:day/:slug/frontmatter',
-        },
-        slug: 'foo-bar',
-        date: '2020-10-07',
-        pathInferred: null,
-        pathLocale: '',
-      })
-
-      expect(resolved).toBe('/frontmatter')
+    expect(resolved).toBe('/2020/10/07/foo-bar/frontmatter')
+  })
+
+  it('permalink in frontmatter should have highest priority', () => {
+    const resolved = resolvePagePermalink({
+      app: appWithPermalinkPattern,
+      frontmatter: {
+        permalink: '/frontmatter',
+        permalinkPattern: '/:year/:month/:day/:slug/frontmatter',
+      },
+      slug: 'foo-bar',
+      date: '2020-10-07',
+      pathInferred: null,
+      pathLocale: '',
     })
+
+    expect(resolved).toBe('/frontmatter')
   })
+})
 
-  describe('permalink pattern', () => {
-    it('should replace :raw with empty string 1', () => {
-      const resolved = resolvePagePermalink({
-        app,
-        frontmatter: {
-          permalinkPattern: '/:year/:month/:day/:slug/:raw',
-        },
-        slug: 'foo-bar',
-        date: '2020-10-07',
-        pathInferred: null,
-        pathLocale: '',
-      })
-
-      expect(resolved).toBe('/2020/10/07/foo-bar/')
+describe('permalink pattern', () => {
+  it('should replace :raw with empty string 1', () => {
+    const resolved = resolvePagePermalink({
+      app,
+      frontmatter: {
+        permalinkPattern: '/:year/:month/:day/:slug/:raw',
+      },
+      slug: 'foo-bar',
+      date: '2020-10-07',
+      pathInferred: null,
+      pathLocale: '',
     })
 
-    it('should replace :raw with empty string 2', () => {
-      const resolved = resolvePagePermalink({
-        app,
-        frontmatter: {
-          permalinkPattern: '/:year/:month/:day/:slug/:raw',
-        },
-        slug: 'foo-bar',
-        date: '2020-10-07',
-        pathInferred: '',
-        pathLocale: '',
-      })
-
-      expect(resolved).toBe('/2020/10/07/foo-bar/')
+    expect(resolved).toBe('/2020/10/07/foo-bar/')
+  })
+
+  it('should replace :raw with empty string 2', () => {
+    const resolved = resolvePagePermalink({
+      app,
+      frontmatter: {
+        permalinkPattern: '/:year/:month/:day/:slug/:raw',
+      },
+      slug: 'foo-bar',
+      date: '2020-10-07',
+      pathInferred: '',
+      pathLocale: '',
     })
 
-    it('should replace :raw with empty string 3', () => {
-      const resolved = resolvePagePermalink({
-        app,
-        frontmatter: {
-          permalinkPattern: '/:year/:month/:day/:slug/:raw',
-        },
-        slug: 'foo-bar',
-        date: '2020-10-07',
-        pathInferred: '/',
-        pathLocale: '',
-      })
-
-      expect(resolved).toBe('/2020/10/07/foo-bar/')
+    expect(resolved).toBe('/2020/10/07/foo-bar/')
+  })
+
+  it('should replace :raw with empty string 3', () => {
+    const resolved = resolvePagePermalink({
+      app,
+      frontmatter: {
+        permalinkPattern: '/:year/:month/:day/:slug/:raw',
+      },
+      slug: 'foo-bar',
+      date: '2020-10-07',
+      pathInferred: '/',
+      pathLocale: '',
     })
 
-    it('should prefix with locale path', () => {
-      const resolved = resolvePagePermalink({
-        app,
-        frontmatter: {
-          permalinkPattern: '/:year/:month/:day/:slug/:raw',
-        },
-        slug: 'foo-bar',
-        date: '2020-10-07',
-        pathInferred: '/raw.html',
-        pathLocale: '/en/',
-      })
-
-      expect(resolved).toBe('/en/2020/10/07/foo-bar/raw.html')
+    expect(resolved).toBe('/2020/10/07/foo-bar/')
+  })
+
+  it('should prefix with locale path', () => {
+    const resolved = resolvePagePermalink({
+      app,
+      frontmatter: {
+        permalinkPattern: '/:year/:month/:day/:slug/:raw',
+      },
+      slug: 'foo-bar',
+      date: '2020-10-07',
+      pathInferred: '/raw.html',
+      pathLocale: '/en/',
     })
+
+    expect(resolved).toBe('/en/2020/10/07/foo-bar/raw.html')
   })
+})
 
-  describe('should return null', () => {
-    it('from permalinkPattern in frontmatter', () => {
-      const resolved = resolvePagePermalink({
-        app: appWithPermalinkPattern,
-        frontmatter: {
-          permalinkPattern: null,
-        },
-        slug: '',
-        date: '',
-        pathInferred: null,
-        pathLocale: '',
-      })
-
-      expect(resolved).toBe(null)
+describe('should return null', () => {
+  it('from permalinkPattern in frontmatter', () => {
+    const resolved = resolvePagePermalink({
+      app: appWithPermalinkPattern,
+      frontmatter: {
+        permalinkPattern: null,
+      },
+      slug: '',
+      date: '',
+      pathInferred: null,
+      pathLocale: '',
     })
 
-    it('from permalinkPattern in app options', () => {
-      const resolved = resolvePagePermalink({
-        app,
-        frontmatter: {},
-        slug: '',
-        date: '',
-        pathInferred: null,
-        pathLocale: '',
-      })
-
-      expect(resolved).toBe(null)
+    expect(resolved).toBe(null)
+  })
+
+  it('from permalinkPattern in app options', () => {
+    const resolved = resolvePagePermalink({
+      app,
+      frontmatter: {},
+      slug: '',
+      date: '',
+      pathInferred: null,
+      pathLocale: '',
     })
+
+    expect(resolved).toBe(null)
   })
 })
diff --git a/packages/core/tests/page/resolvePageRouteMeta.spec.ts b/packages/core/tests/page/resolvePageRouteMeta.spec.ts
index 033ebebac3..f72dd97284 100644
--- a/packages/core/tests/page/resolvePageRouteMeta.spec.ts
+++ b/packages/core/tests/page/resolvePageRouteMeta.spec.ts
@@ -1,26 +1,24 @@
-import { describe, expect, it } from 'vitest'
+import { expect, it } from 'vitest'
 import { resolvePageRouteMeta } from '../../src/index.js'
 
-describe('core > page > resolvePageRouteMeta', () => {
-  it('should use frontmatter routeMeta', () => {
-    const routeMeta = resolvePageRouteMeta({
-      frontmatter: {
-        routeMeta: {
-          foo: 'foo',
-        },
+it('should use frontmatter routeMeta', () => {
+  const routeMeta = resolvePageRouteMeta({
+    frontmatter: {
+      routeMeta: {
+        foo: 'foo',
       },
-    })
-
-    expect(routeMeta).toEqual({
-      foo: 'foo',
-    })
+    },
   })
 
-  it('should return default value', () => {
-    const routeMeta = resolvePageRouteMeta({
-      frontmatter: {},
-    })
+  expect(routeMeta).toEqual({
+    foo: 'foo',
+  })
+})
 
-    expect(routeMeta).toEqual({})
+it('should return default value', () => {
+  const routeMeta = resolvePageRouteMeta({
+    frontmatter: {},
   })
+
+  expect(routeMeta).toEqual({})
 })
diff --git a/packages/core/tests/page/resolvePageSlug.spec.ts b/packages/core/tests/page/resolvePageSlug.spec.ts
index bb12166cfa..ecafe5aeaa 100644
--- a/packages/core/tests/page/resolvePageSlug.spec.ts
+++ b/packages/core/tests/page/resolvePageSlug.spec.ts
@@ -1,28 +1,26 @@
-import { describe, expect, it } from 'vitest'
+import { expect, it } from 'vitest'
 import { resolvePageSlug } from '../../src/index.js'
 
-describe('core > page > resolvePageSlug', () => {
-  it('should return empty string', () => {
-    const resolved = resolvePageSlug({
-      filePathRelative: null,
-    })
-
-    expect(resolved).toBe('')
+it('should return empty string', () => {
+  const resolved = resolvePageSlug({
+    filePathRelative: null,
   })
 
-  it('should remove extension', () => {
-    const resolved = resolvePageSlug({
-      filePathRelative: 'foo-bar.html',
-    })
+  expect(resolved).toBe('')
+})
 
-    expect(resolved).toBe('foo-bar')
+it('should remove extension', () => {
+  const resolved = resolvePageSlug({
+    filePathRelative: 'foo-bar.html',
   })
 
-  it('should remove date prefix', () => {
-    const resolved = resolvePageSlug({
-      filePathRelative: '2020-10-07-foo-bar.html',
-    })
+  expect(resolved).toBe('foo-bar')
+})
 
-    expect(resolved).toBe('foo-bar')
+it('should remove date prefix', () => {
+  const resolved = resolvePageSlug({
+    filePathRelative: '2020-10-07-foo-bar.html',
   })
+
+  expect(resolved).toBe('foo-bar')
 })
diff --git a/packages/core/tests/pluginApi/createHookQueue.spec.ts b/packages/core/tests/pluginApi/createHookQueue.spec.ts
index 5492a2171b..5593ffd89d 100644
--- a/packages/core/tests/pluginApi/createHookQueue.spec.ts
+++ b/packages/core/tests/pluginApi/createHookQueue.spec.ts
@@ -1,114 +1,51 @@
-import { createMarkdown } from '@vuepress/markdown'
 import type { MarkdownOptions } from '@vuepress/markdown'
+import { createMarkdown } from '@vuepress/markdown'
 import { path } from '@vuepress/utils'
 import { describe, expect, it, vi } from 'vitest'
+import type { Bundler, Hooks, PageOptions } from '../../src/index.js'
 import { createBaseApp, createHookQueue, createPage } from '../../src/index.js'
-import type { Page, PageOptions } from '../../src/index.js'
 
 const app = createBaseApp({
   source: path.resolve(__dirname, 'fake-source'),
   theme: { name: 'test' },
-  bundler: {} as any,
+  bundler: {} as Bundler,
 })
 app.markdown = createMarkdown()
 
-describe('core > pluginApi > createHookQueue', () => {
-  describe('common', () => {
-    const hookNames = [
-      'onInitialized',
-      'onPrepared',
-      'onWatched',
-      'onGenerated',
-      'extendsMarkdownOptions',
-      'extendsMarkdown',
-      'extendsPageOptions',
-      'extendsPage',
-      'extendsBundlerOptions',
-      'clientConfigFile',
-      'alias',
-      'define',
-    ] as const
-
-    hookNames.forEach((hookName) => {
-      const hook = createHookQueue(hookName)
-
-      it('should have correct name', () => {
-        expect(hook.name).toEqual(hookName)
-      })
-
-      it('should throw error from the first item', async () => {
-        const consoleError = console.error
-        console.error = vi.fn()
-
-        const err1 = new Error('err1')
-        const err2 = new Error('err2')
-        const func1 = vi.fn(() => {
-          throw err1
-        })
-        const func2 = vi.fn(() => {
-          throw err2
-        })
-        hook.add({
-          pluginName: 'test1',
-          hook: func1,
-        })
-        hook.add({
-          pluginName: 'test2',
-          hook: func2,
-        })
-        await expect(hook.process(app)).rejects.toThrowError(err1)
-        expect(console.error).toHaveBeenCalled()
-
-        expect(func1).toHaveBeenCalledTimes(1)
-        expect(func1).toHaveBeenCalledWith(app)
-        expect(func2).toHaveBeenCalledTimes(0)
-
-        console.error = consoleError
-      })
+describe('common', () => {
+  const hookNames = [
+    'onInitialized',
+    'onPrepared',
+    'onWatched',
+    'onGenerated',
+    'extendsMarkdownOptions',
+    'extendsMarkdown',
+    'extendsPageOptions',
+    'extendsPage',
+    'extendsBundlerOptions',
+    'clientConfigFile',
+    'alias',
+    'define',
+  ] as const
+
+  hookNames.forEach((hookName) => {
+    const hook = createHookQueue(hookName)
+
+    it('should have correct name', () => {
+      expect(hook.name).toEqual(hookName)
     })
-  })
-
-  describe('lifecycle hooks', () => {
-    const hookNames = [
-      'onInitialized',
-      'onPrepared',
-      'onWatched',
-      'onGenerated',
-    ] as const
-
-    hookNames.forEach((hookName) =>
-      it(`${hookName}`, async () => {
-        const hook = createHookQueue(hookName)
-        const func1 = vi.fn()
-        const func2 = vi.fn()
-        hook.add({
-          pluginName: 'test1',
-          hook: func1,
-        })
-        hook.add({
-          pluginName: 'test2',
-          hook: func2,
-        })
-        await hook.process(app)
-
-        expect(func1).toHaveBeenCalledTimes(1)
-        expect(func1).toHaveBeenCalledWith(app)
-        expect(func2).toHaveBeenCalledTimes(1)
-        expect(func2).toHaveBeenCalledWith(app)
-      }),
-    )
-  })
 
-  describe('extends hooks', () => {
-    it(`extendsMarkdownOptions`, async () => {
-      const hookName = 'extendsMarkdownOptions'
+    it('should throw error from the first item', async () => {
+      const consoleError = console.error
+      console.error = vi.fn()
 
-      const hook = createHookQueue(hookName)
-      const func1 = vi.fn((markdownOptions) => {
-        markdownOptions.emoji = false
+      const err1 = new Error('err1')
+      const err2 = new Error('err2')
+      const func1 = vi.fn(() => {
+        throw err1
       })
-      const func2 = vi.fn((markdownOptions) => {
-        markdownOptions.headers = false
+      const func2 = vi.fn(() => {
+        throw err2
       })
       hook.add({
         pluginName: 'test1',
@@ -118,19 +55,28 @@ describe('core > pluginApi > createHookQueue', () => {
         pluginName: 'test2',
         hook: func2,
       })
-      const markdownOptions: MarkdownOptions = {}
-      await hook.process(markdownOptions, app)
+      await expect(hook.process(app)).rejects.toThrowError(err1)
+      expect(console.error).toHaveBeenCalled()
 
       expect(func1).toHaveBeenCalledTimes(1)
-      expect(func1).toHaveBeenCalledWith(markdownOptions, app)
-      expect(func2).toHaveBeenCalledTimes(1)
-      expect(func2).toHaveBeenCalledWith(markdownOptions, app)
-      expect(markdownOptions).toEqual({ emoji: false, headers: false })
+      expect(func1).toHaveBeenCalledWith(app)
+      expect(func2).toHaveBeenCalledTimes(0)
+
+      console.error = consoleError
     })
+  })
+})
 
-    it(`extendsMarkdown`, async () => {
-      const hookName = 'extendsMarkdown'
+describe('lifecycle hooks', () => {
+  const hookNames = [
+    'onInitialized',
+    'onPrepared',
+    'onWatched',
+    'onGenerated',
+  ] as const
 
+  hookNames.forEach((hookName) => {
+    it(hookName, async () => {
       const hook = createHookQueue(hookName)
       const func1 = vi.fn()
       const func2 = vi.fn()
@@ -142,60 +88,189 @@ describe('core > pluginApi > createHookQueue', () => {
         pluginName: 'test2',
         hook: func2,
       })
-      await hook.process(app.markdown, app)
+      await hook.process(app)
 
       expect(func1).toHaveBeenCalledTimes(1)
-      expect(func1).toHaveBeenCalledWith(app.markdown, app)
+      expect(func1).toHaveBeenCalledWith(app)
       expect(func2).toHaveBeenCalledTimes(1)
-      expect(func2).toHaveBeenCalledWith(app.markdown, app)
+      expect(func2).toHaveBeenCalledWith(app)
     })
+  })
+})
 
-    it(`extendsPageOptions`, async () => {
-      const hookName = 'extendsPageOptions'
+describe('extends hooks', () => {
+  it(`extendsMarkdownOptions`, async () => {
+    const hookName = 'extendsMarkdownOptions'
 
-      const hook = createHookQueue(hookName)
-      const func1 = vi.fn((pageOptions) => {
+    const hook = createHookQueue(hookName)
+    const func1 = vi.fn<Hooks['extendsMarkdownOptions']['normalized']>(
+      (markdownOptions) => {
+        markdownOptions.emoji = false
+      },
+    )
+    const func2 = vi.fn<Hooks['extendsMarkdownOptions']['normalized']>(
+      (markdownOptions) => {
+        markdownOptions.headers = false
+      },
+    )
+    hook.add({
+      pluginName: 'test1',
+      hook: func1,
+    })
+    hook.add({
+      pluginName: 'test2',
+      hook: func2,
+    })
+    const markdownOptions: MarkdownOptions = {}
+    await hook.process(markdownOptions, app)
+
+    expect(func1).toHaveBeenCalledTimes(1)
+    expect(func1).toHaveBeenCalledWith(markdownOptions, app)
+    expect(func2).toHaveBeenCalledTimes(1)
+    expect(func2).toHaveBeenCalledWith(markdownOptions, app)
+    expect(markdownOptions).toEqual({ emoji: false, headers: false })
+  })
+
+  it(`extendsMarkdown`, async () => {
+    const hookName = 'extendsMarkdown'
+
+    const hook = createHookQueue(hookName)
+    const func1 = vi.fn()
+    const func2 = vi.fn()
+    hook.add({
+      pluginName: 'test1',
+      hook: func1,
+    })
+    hook.add({
+      pluginName: 'test2',
+      hook: func2,
+    })
+    await hook.process(app.markdown, app)
+
+    expect(func1).toHaveBeenCalledTimes(1)
+    expect(func1).toHaveBeenCalledWith(app.markdown, app)
+    expect(func2).toHaveBeenCalledTimes(1)
+    expect(func2).toHaveBeenCalledWith(app.markdown, app)
+  })
+
+  it(`extendsPageOptions`, async () => {
+    const hookName = 'extendsPageOptions'
+
+    const hook = createHookQueue(hookName)
+    const func1 = vi.fn<Hooks['extendsPageOptions']['normalized']>(
+      (pageOptions) => {
         pageOptions.content = pageOptions.content ?? 'foo'
-      })
-      const func2 = vi.fn((pageOptions) => {
+      },
+    )
+    const func2 = vi.fn<Hooks['extendsPageOptions']['normalized']>(
+      (pageOptions) => {
         pageOptions.content = pageOptions.content ?? 'nar'
-      })
-      hook.add({
-        pluginName: 'test1',
-        hook: func1,
-      })
-      hook.add({
-        pluginName: 'test2',
-        hook: func2,
-      })
-      const pageOptions: PageOptions = { filePath: 'foo.md' }
-      await hook.process(pageOptions, app)
+      },
+    )
+    hook.add({
+      pluginName: 'test1',
+      hook: func1,
+    })
+    hook.add({
+      pluginName: 'test2',
+      hook: func2,
+    })
+    const pageOptions: PageOptions = { filePath: 'foo.md' }
+    await hook.process(pageOptions, app)
+
+    expect(func1).toHaveBeenCalledTimes(1)
+    expect(func1).toHaveBeenCalledWith(pageOptions, app)
+    expect(func2).toHaveBeenCalledTimes(1)
+    expect(func2).toHaveBeenCalledWith(pageOptions, app)
+    expect(pageOptions).toEqual({ filePath: 'foo.md', content: 'foo' })
+  })
 
-      expect(func1).toHaveBeenCalledTimes(1)
-      expect(func1).toHaveBeenCalledWith(pageOptions, app)
-      expect(func2).toHaveBeenCalledTimes(1)
-      expect(func2).toHaveBeenCalledWith(pageOptions, app)
-      expect(pageOptions).toEqual({ filePath: 'foo.md', content: 'foo' })
+  it(`extendsPage`, async () => {
+    const hookName = 'extendsPage'
+
+    const hook = createHookQueue(hookName)
+    const page = await createPage(app, { path: '/' })
+    const func1 = vi.fn<Hooks['extendsPage']['normalized']>((extendedPage) => {
+      extendedPage.data.extraData = 'foo'
+    })
+    const func2 = vi.fn<Hooks['extendsPage']['normalized']>((extendedPage) => {
+      extendedPage.frontmatter.extraFrontmatter = 'bar'
+    })
+    const func3 = vi.fn<Hooks['extendsPage']['normalized']>((extendedPage) => {
+      extendedPage.extraField = 'baz'
     })
+    hook.add({
+      pluginName: 'test1',
+      hook: func1,
+    })
+    hook.add({
+      pluginName: 'test2',
+      hook: func2,
+    })
+    hook.add({
+      pluginName: 'test3',
+      hook: func3,
+    })
+    await hook.process(page, app)
+
+    expect(func1).toHaveBeenCalledTimes(1)
+    expect(func1).toHaveBeenCalledWith(page, app)
+    expect(func2).toHaveBeenCalledTimes(1)
+    expect(func2).toHaveBeenCalledWith(page, app)
+    expect(page.data.extraData).toEqual('foo')
+    expect(page.frontmatter.extraFrontmatter).toEqual('bar')
+    expect(page.extraField).toEqual('baz')
+  })
+
+  it(`extendsBundlerOptions`, async () => {
+    const hookName = 'extendsBundlerOptions'
 
-    it(`extendsPage`, async () => {
-      const hookName = 'extendsPage'
+    const hook = createHookQueue(hookName)
+    const func1 = vi.fn<Hooks['extendsBundlerOptions']['normalized']>(
+      (bundlerOptions) => {
+        bundlerOptions.foo = 'foo'
+      },
+    )
+    const func2 = vi.fn<Hooks['extendsBundlerOptions']['normalized']>(
+      (bundlerOptions) => {
+        bundlerOptions.bar = 'bar'
+      },
+    )
+    hook.add({
+      pluginName: 'test1',
+      hook: func1,
+    })
+    hook.add({
+      pluginName: 'test2',
+      hook: func2,
+    })
+    const bundlerOptions = {}
+    await hook.process(bundlerOptions, app)
+
+    expect(func1).toHaveBeenCalledTimes(1)
+    expect(func1).toHaveBeenCalledWith(bundlerOptions, app)
+    expect(func2).toHaveBeenCalledTimes(1)
+    expect(func2).toHaveBeenCalledWith(bundlerOptions, app)
+    expect(bundlerOptions).toEqual({ foo: 'foo', bar: 'bar' })
+  })
+})
 
+describe('client config file hook', () => {
+  const hookNames = ['clientConfigFile'] as const
+  const file1 = path.resolve(
+    __dirname,
+    '../__fixtures__/clientConfigs/clientConfig.ts',
+  )
+  const file2 = path.resolve(
+    __dirname,
+    '../__fixtures__/clientConfigs/clientConfig2.ts',
+  )
+
+  hookNames.forEach((hookName) => {
+    it(hookName, async () => {
       const hook = createHookQueue(hookName)
-      const page = (await createPage(app, { path: '/' })) as Page<
-        { extraData: string },
-        { extraFrontmatter: string },
-        { extraField: string }
-      >
-      const func1 = vi.fn((page) => {
-        page.data.extraData = 'foo'
-      })
-      const func2 = vi.fn((page) => {
-        page.frontmatter.extraFrontmatter = 'bar'
-      })
-      const func3 = vi.fn((page) => {
-        page.extraField = 'baz'
-      })
+      const func1 = vi.fn(async () => Promise.resolve(file1))
+      const func2 = vi.fn(async () => Promise.resolve(file2))
       hook.add({
         pluginName: 'test1',
         hook: func1,
@@ -204,31 +279,25 @@ describe('core > pluginApi > createHookQueue', () => {
         pluginName: 'test2',
         hook: func2,
       })
-      hook.add({
-        pluginName: 'test3',
-        hook: func3,
-      })
-      await hook.process(page, app)
+      const result = await hook.process(app)
 
       expect(func1).toHaveBeenCalledTimes(1)
-      expect(func1).toHaveBeenCalledWith(page, app)
+      expect(func1).toHaveBeenCalledWith(app)
       expect(func2).toHaveBeenCalledTimes(1)
-      expect(func2).toHaveBeenCalledWith(page, app)
-      expect(page.data.extraData).toEqual('foo')
-      expect(page.frontmatter.extraFrontmatter).toEqual('bar')
-      expect(page.extraField).toEqual('baz')
+      expect(func2).toHaveBeenCalledWith(app)
+      expect(result).toEqual([file1, file2])
     })
+  })
+})
 
-    it(`extendsBundlerOptions`, async () => {
-      const hookName = 'extendsBundlerOptions'
+describe('bundler hooks', () => {
+  const hookNames = ['alias', 'define'] as const
 
+  hookNames.forEach((hookName) => {
+    it(hookName, async () => {
       const hook = createHookQueue(hookName)
-      const func1 = vi.fn((bundlerOptions) => {
-        bundlerOptions.foo = 'foo'
-      })
-      const func2 = vi.fn((bundlerOptions) => {
-        bundlerOptions.bar = 'bar'
-      })
+      const func1 = vi.fn(async () => Promise.resolve({ foo: 'foo' }))
+      const func2 = vi.fn(async () => Promise.resolve({ bar: 'bar' }))
       hook.add({
         pluginName: 'test1',
         hook: func1,
@@ -237,76 +306,13 @@ describe('core > pluginApi > createHookQueue', () => {
         pluginName: 'test2',
         hook: func2,
       })
-      const markdownOptions: MarkdownOptions = {}
-      await hook.process(markdownOptions, app)
+      const result = await hook.process(app, true)
 
       expect(func1).toHaveBeenCalledTimes(1)
-      expect(func1).toHaveBeenCalledWith(markdownOptions, app)
+      expect(func1).toHaveBeenCalledWith(app, true)
       expect(func2).toHaveBeenCalledTimes(1)
-      expect(func2).toHaveBeenCalledWith(markdownOptions, app)
-      expect(markdownOptions).toEqual({ foo: 'foo', bar: 'bar' })
+      expect(func2).toHaveBeenCalledWith(app, true)
+      expect(result).toEqual([{ foo: 'foo' }, { bar: 'bar' }])
     })
   })
-
-  describe('client config file hook', () => {
-    const hookNames = ['clientConfigFile'] as const
-    const file1 = path.resolve(
-      __dirname,
-      '../__fixtures__/clientConfigs/clientConfig.ts',
-    )
-    const file2 = path.resolve(
-      __dirname,
-      '../__fixtures__/clientConfigs/clientConfig2.ts',
-    )
-
-    hookNames.forEach((hookName) =>
-      it(`${hookName}`, async () => {
-        const hook = createHookQueue(hookName)
-        const func1 = vi.fn(() => Promise.resolve(file1))
-        const func2 = vi.fn(() => Promise.resolve(file2))
-        hook.add({
-          pluginName: 'test1',
-          hook: func1,
-        })
-        hook.add({
-          pluginName: 'test2',
-          hook: func2,
-        })
-        const result = await hook.process(app)
-
-        expect(func1).toHaveBeenCalledTimes(1)
-        expect(func1).toHaveBeenCalledWith(app)
-        expect(func2).toHaveBeenCalledTimes(1)
-        expect(func2).toHaveBeenCalledWith(app)
-        expect(result).toEqual([file1, file2])
-      }),
-    )
-  })
-
-  describe('bundler hooks', () => {
-    const hookNames = ['alias', 'define'] as const
-
-    hookNames.forEach((hookName) =>
-      it(`${hookName}`, async () => {
-        const hook = createHookQueue(hookName)
-        const func1 = vi.fn(() => Promise.resolve({ foo: 'foo' }))
-        const func2 = vi.fn(() => Promise.resolve({ bar: 'bar' }))
-        hook.add({
-          pluginName: 'test1',
-          hook: func1,
-        })
-        hook.add({
-          pluginName: 'test2',
-          hook: func2,
-        })
-        const result = await hook.process(app, true)
-
-        expect(func1).toHaveBeenCalledTimes(1)
-        expect(func1).toHaveBeenCalledWith(app, true)
-        expect(func2).toHaveBeenCalledTimes(1)
-        expect(func2).toHaveBeenCalledWith(app, true)
-        expect(result).toEqual([{ foo: 'foo' }, { bar: 'bar' }])
-      }),
-    )
-  })
 })
diff --git a/packages/core/tests/pluginApi/createPluginApi.spec.ts b/packages/core/tests/pluginApi/createPluginApi.spec.ts
index d7d68e7dec..2c4c828f44 100644
--- a/packages/core/tests/pluginApi/createPluginApi.spec.ts
+++ b/packages/core/tests/pluginApi/createPluginApi.spec.ts
@@ -1,5 +1,5 @@
 import { path } from '@vuepress/utils'
-import { describe, expect, it, vi } from 'vitest'
+import { expect, it, vi } from 'vitest'
 import type { Bundler, HooksName } from '../../src/index.js'
 import { createBaseApp, createPluginApi } from '../../src/index.js'
 
@@ -9,49 +9,47 @@ const app = createBaseApp({
   bundler: {} as Bundler,
 })
 
-describe('core > pluginApi > createPluginApi', () => {
-  it('should have correct hooks', () => {
-    const hookNames: HooksName[] = [
-      'onInitialized',
-      'onPrepared',
-      'onWatched',
-      'onGenerated',
-      'extendsMarkdownOptions',
-      'extendsMarkdown',
-      'extendsPageOptions',
-      'extendsPage',
-      'clientConfigFile',
-      'alias',
-      'define',
-    ]
-
-    const pluginApi = createPluginApi()
-
-    hookNames.forEach((hookName) => {
-      expect(pluginApi.hooks).toHaveProperty(hookName)
-    })
+it('should have correct hooks', () => {
+  const hookNames: HooksName[] = [
+    'onInitialized',
+    'onPrepared',
+    'onWatched',
+    'onGenerated',
+    'extendsMarkdownOptions',
+    'extendsMarkdown',
+    'extendsPageOptions',
+    'extendsPage',
+    'clientConfigFile',
+    'alias',
+    'define',
+  ]
+
+  const pluginApi = createPluginApi()
+
+  hookNames.forEach((hookName) => {
+    expect(pluginApi.hooks).toHaveProperty(hookName)
   })
+})
 
-  it('hooks should only take effect after `registerHooks` is called', async () => {
-    const pluginApi = createPluginApi()
+it('hooks should only take effect after `registerHooks` is called', async () => {
+  const pluginApi = createPluginApi()
 
-    const hookFn = vi.fn()
+  const hookFn = vi.fn()
 
-    pluginApi.plugins.push({
-      name: 'test',
-      onInitialized: hookFn,
-    })
+  pluginApi.plugins.push({
+    name: 'test',
+    onInitialized: hookFn,
+  })
 
-    // before `registerHooks`
-    await pluginApi.hooks.onInitialized.process(app)
+  // before `registerHooks`
+  await pluginApi.hooks.onInitialized.process(app)
 
-    expect(hookFn).toHaveBeenCalledTimes(0)
+  expect(hookFn).toHaveBeenCalledTimes(0)
 
-    // after `registerHooks`
-    pluginApi.registerHooks()
-    await pluginApi.hooks.onInitialized.process(app)
+  // after `registerHooks`
+  pluginApi.registerHooks()
+  await pluginApi.hooks.onInitialized.process(app)
 
-    expect(hookFn).toHaveBeenCalledTimes(1)
-    expect(hookFn).toHaveBeenCalledWith(app)
-  })
+  expect(hookFn).toHaveBeenCalledTimes(1)
+  expect(hookFn).toHaveBeenCalledWith(app)
 })
diff --git a/packages/core/tests/pluginApi/normalizeAliasDefineHook.spec.ts b/packages/core/tests/pluginApi/normalizeAliasDefineHook.spec.ts
index c7c9d05e80..137894ab04 100644
--- a/packages/core/tests/pluginApi/normalizeAliasDefineHook.spec.ts
+++ b/packages/core/tests/pluginApi/normalizeAliasDefineHook.spec.ts
@@ -1,5 +1,5 @@
 import { path } from '@vuepress/utils'
-import { describe, expect, it, vi } from 'vitest'
+import { expect, it, vi } from 'vitest'
 import type { AliasDefineHook, Bundler } from '../../src/index.js'
 import { createBaseApp, normalizeAliasDefineHook } from '../../src/index.js'
 
@@ -9,28 +9,26 @@ const app = createBaseApp({
   bundler: {} as Bundler,
 })
 
-describe('core > pluginApi > normalizeAliasDefineHook', () => {
-  it('should keep function as is', async () => {
-    const rawHook: AliasDefineHook['exposed'] = vi.fn(
-      (_app, isServer: boolean) => ({
-        foo: 'bar',
-        isServer,
-      }),
-    )
-    const normalizedHook = normalizeAliasDefineHook(rawHook)
-    expect(await normalizedHook(app, true)).toEqual({
+it('should keep function as is', async () => {
+  const rawHook: AliasDefineHook['exposed'] = vi.fn(
+    (_app, isServer: boolean) => ({
       foo: 'bar',
-      isServer: true,
-    })
-    expect(rawHook).toHaveBeenCalledTimes(1)
-    expect(rawHook).toHaveBeenCalledWith(app, true)
+      isServer,
+    }),
+  )
+  const normalizedHook = normalizeAliasDefineHook(rawHook)
+  expect(await normalizedHook(app, true)).toEqual({
+    foo: 'bar',
+    isServer: true,
   })
+  expect(rawHook).toHaveBeenCalledTimes(1)
+  expect(rawHook).toHaveBeenCalledWith(app, true)
+})
 
-  it('should wrap object with a function', async () => {
-    const rawHook: AliasDefineHook['exposed'] = {
-      foo: 'bar',
-    }
-    const normalizedHook = normalizeAliasDefineHook(rawHook)
-    expect(await normalizedHook(app, true)).toEqual({ foo: 'bar' })
-  })
+it('should wrap object with a function', async () => {
+  const rawHook: AliasDefineHook['exposed'] = {
+    foo: 'bar',
+  }
+  const normalizedHook = normalizeAliasDefineHook(rawHook)
+  expect(await normalizedHook(app, true)).toEqual({ foo: 'bar' })
 })
diff --git a/packages/core/tests/pluginApi/normalizeClientFilesHook.spec.ts b/packages/core/tests/pluginApi/normalizeClientFilesHook.spec.ts
index 44cd647bc8..6f58e6a346 100644
--- a/packages/core/tests/pluginApi/normalizeClientFilesHook.spec.ts
+++ b/packages/core/tests/pluginApi/normalizeClientFilesHook.spec.ts
@@ -20,50 +20,48 @@ const CLIENT_CONFIG_FILE_NON_EXISTENT = path.resolve(
   '../__fixtures__/clientConfigs/non-existent.ts',
 )
 
-describe('core > pluginApi > normalizeClientConfigFileHook', () => {
-  describe('should keep function as is', () => {
-    it('return value is string', async () => {
-      const rawHook: ClientConfigFileHook['exposed'] = vi.fn(
-        () => CLIENT_CONFIG_FILE,
-      )
-      const normalizedHook = normalizeClientConfigFileHook(rawHook)
-      expect(await normalizedHook(app)).toEqual(CLIENT_CONFIG_FILE)
-      expect(rawHook).toHaveBeenCalledTimes(1)
-      expect(rawHook).toHaveBeenCalledWith(app)
-    })
+describe('should keep function as is', () => {
+  it('return value is string', async () => {
+    const rawHook: ClientConfigFileHook['exposed'] = vi.fn(
+      () => CLIENT_CONFIG_FILE,
+    )
+    const normalizedHook = normalizeClientConfigFileHook(rawHook)
+    expect(await normalizedHook(app)).toEqual(CLIENT_CONFIG_FILE)
+    expect(rawHook).toHaveBeenCalledTimes(1)
+    expect(rawHook).toHaveBeenCalledWith(app)
+  })
 
-    it('should throw an error if file does not exist', async () => {
-      const consoleError = console.error
-      console.error = vi.fn()
+  it('should throw an error if file does not exist', async () => {
+    const consoleError = console.error
+    console.error = vi.fn()
 
-      const rawHook: ClientConfigFileHook['exposed'] =
-        CLIENT_CONFIG_FILE_NON_EXISTENT
-      const normalizedHook = normalizeClientConfigFileHook(rawHook)
-      await expect(normalizedHook(app)).rejects.toThrow()
-      expect(console.error).toHaveBeenCalled()
+    const rawHook: ClientConfigFileHook['exposed'] =
+      CLIENT_CONFIG_FILE_NON_EXISTENT
+    const normalizedHook = normalizeClientConfigFileHook(rawHook)
+    await expect(normalizedHook(app)).rejects.toThrow()
+    expect(console.error).toHaveBeenCalled()
 
-      console.error = consoleError
-    })
+    console.error = consoleError
   })
+})
 
-  describe('should wrap raw value with a function', () => {
-    it('value is string', async () => {
-      const rawHook: ClientConfigFileHook['exposed'] = CLIENT_CONFIG_FILE
-      const normalizedHook = normalizeClientConfigFileHook(rawHook)
-      expect(await normalizedHook(app)).toEqual(CLIENT_CONFIG_FILE)
-    })
+describe('should wrap raw value with a function', () => {
+  it('value is string', async () => {
+    const rawHook: ClientConfigFileHook['exposed'] = CLIENT_CONFIG_FILE
+    const normalizedHook = normalizeClientConfigFileHook(rawHook)
+    expect(await normalizedHook(app)).toEqual(CLIENT_CONFIG_FILE)
+  })
 
-    it('should throw an error if file does not exist', async () => {
-      const consoleError = console.error
-      console.error = vi.fn()
+  it('should throw an error if file does not exist', async () => {
+    const consoleError = console.error
+    console.error = vi.fn()
 
-      const rawHook: ClientConfigFileHook['exposed'] =
-        CLIENT_CONFIG_FILE_NON_EXISTENT
-      const normalizedHook = normalizeClientConfigFileHook(rawHook)
-      await expect(normalizedHook(app)).rejects.toThrow()
-      expect(console.error).toHaveBeenCalled()
+    const rawHook: ClientConfigFileHook['exposed'] =
+      CLIENT_CONFIG_FILE_NON_EXISTENT
+    const normalizedHook = normalizeClientConfigFileHook(rawHook)
+    await expect(normalizedHook(app)).rejects.toThrow()
+    expect(console.error).toHaveBeenCalled()
 
-      console.error = consoleError
-    })
+    console.error = consoleError
   })
 })
diff --git a/packages/markdown/src/plugins/assetsPlugin/assetsPlugin.ts b/packages/markdown/src/plugins/assetsPlugin/assetsPlugin.ts
index 5293f137a2..1434888055 100644
--- a/packages/markdown/src/plugins/assetsPlugin/assetsPlugin.ts
+++ b/packages/markdown/src/plugins/assetsPlugin/assetsPlugin.ts
@@ -70,7 +70,7 @@ export const assetsPlugin: PluginWithOptions<AssetsPluginOptions> = (
               .map((item) =>
                 item.trim().replace(
                   /^([^ ]*?)([ \n].*)?$/,
-                  (_, url, descriptor = '') =>
+                  (__, url: string, descriptor: string | undefined = '') =>
                     `${resolveLink(url.trim(), {
                       env,
                       absolutePathPrependBase,