diff --git a/.github/workflows/deno.yml b/.github/workflows/deno.yml
index 11d2cdd..9afaea4 100644
--- a/.github/workflows/deno.yml
+++ b/.github/workflows/deno.yml
@@ -1,7 +1,7 @@
 name: deno
 
 env:
-  DENO_VERSION: 1.x
+  DENO_VERSION: 2.x
   DENOPS_PATH: "./"
 
 on:
@@ -46,3 +46,14 @@ jobs:
         run: |
           grep -rl Deno.test denops| xargs deno test --unstable -A
         timeout-minutes: 5
+
+  deno-test-publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: denoland/setup-deno@main
+        with:
+          deno-version: ${{ env.DENO_VERSION }}
+
+      - name: Test Publish
+        run: deno task test:publish
diff --git a/.github/workflows/jsr.yml b/.github/workflows/jsr.yml
index 2de3f3a..be42ca4 100644
--- a/.github/workflows/jsr.yml
+++ b/.github/workflows/jsr.yml
@@ -1,7 +1,7 @@
 name: jsr
 
 env:
-  DENO_VERSION: 1.x
+  DENO_VERSION: 2.x
 
 on:
   push:
@@ -19,9 +19,9 @@ jobs:
       - uses: actions/checkout@v4
         with:
           fetch-depth: 0
-      - uses: denoland/setup-deno@v1
+      - uses: denoland/setup-deno@v2
         with:
           deno-version: ${{ env.DENO_VERSION }}
       - name: Publish
         run: |
-          deno run -A jsr:@david/publish-on-tag@0.1.3
+          deno run -A jsr:@david/publish-on-tag@0.2.0
diff --git a/README.md b/README.md
index cf7b8fb..5c2fb0e 100644
--- a/README.md
+++ b/README.md
@@ -31,7 +31,7 @@ see "FAQ" section in [help](doc/dpp.txt).
 
 ## Install
 
-**Note:** Dpp.vim requires Vim 9.1.0448+ or Neovim 0.10.0+. See
+**NOTE:** It requires Vim 9.1.0448+ or Neovim 0.10.0+. See
 [requirements](#requirements) if you aren't sure whether you have this.
 
 NOTE: To install plugins from remote, you need to install
@@ -39,7 +39,7 @@ NOTE: To install plugins from remote, you need to install
 
 ### Requirements
 
-Please install both Deno 1.45+ and "denops.vim" v7.0+.
+Please install both Deno 2.3.0+ and "denops.vim" v8.0+.
 
 - <https://deno.land/>
 - <https://github.com/vim-denops/denops.vim>
diff --git a/autoload/dpp/denops.vim b/autoload/dpp/denops.vim
index 5fed7bf..365cb74 100644
--- a/autoload/dpp/denops.vim
+++ b/autoload/dpp/denops.vim
@@ -41,8 +41,8 @@ function s:init() abort
     return
   endif
 
-  if !has('patch-9.1.0448') && !has('nvim-0.10')
-    call dpp#util#_error('dpp.vim requires Vim 9.1.0448+ or Neovim 0.10+.')
+  if !has('patch-9.1.1646') && !has('nvim-0.11')
+    call dpp#util#_error('dpp.vim requires Vim 9.1.1646+ or Neovim 0.11+.')
     return 1
   endif
 
@@ -91,7 +91,7 @@ function s:notify(method, args) abort
   endif
 endfunction
 
-const s:root_dir = '<sfile>:h:h:h'->expand()
+const s:root_dir = '<script>:h:h:h'->expand()
 const s:sep = has('win32') ? '\' : '/'
 function s:register() abort
   call denops#plugin#load(
diff --git a/deno.jsonc b/deno.jsonc
index 255ed00..6b8b557 100644
--- a/deno.jsonc
+++ b/deno.jsonc
@@ -1,28 +1,16 @@
 {
-  "name": "@shougo/dpp-vim",
-  "version": "0.0.0",
-  "exports": {
-    "./config": "./denops/dpp/base/config.ts",
-    "./dpp": "./denops/dpp/base/dpp.ts",
-    "./ext": "./denops/dpp/base/ext.ts",
-    "./protocol": "./denops/dpp/base/protocol.ts",
-    "./types": "./denops/dpp/types.ts",
-    "./utils": "./denops/dpp/utils.ts"
-  },
-  "publish": {
-    "include": [
-      "denops/dpp/**/*.ts"
-    ]
-  },
-  "imports": {
-  },
-  "lock": false,
   "tasks": {
+    "cache": "deno install --reload",
     "check": "deno check denops/**/*.ts",
+    "fmt": "deno fmt denops",
     "lint": "deno lint denops",
     "lint-fix": "deno lint --fix denops",
-    "fmt": "deno fmt denops",
     "test": "deno test -A --doc --parallel --shuffle denops/**/*.ts",
-    "upgrade": "deno run -A jsr:@molt/cli **/*.ts --write"
-  }
+    "test:publish": "deno publish --dry-run --allow-dirty --set-version 0.0.0",
+    "update": "deno outdated --recursive",
+    "upgrade": "deno outdated --recursive --update"
+  },
+  "workspace": [
+    "./denops/dpp"
+  ]
 }
diff --git a/denops/dpp/app.ts b/denops/dpp/app.ts
index 142069c..1209f79 100644
--- a/denops/dpp/app.ts
+++ b/denops/dpp/app.ts
@@ -11,15 +11,14 @@ import type { BaseExt } from "./base/ext.ts";
 import type { BaseProtocol, Protocol } from "./base/protocol.ts";
 import { Loader } from "./loader.ts";
 import { extAction } from "./ext.ts";
-import { isDenoCacheIssueError } from "./utils.ts";
+import { importPlugin, isDenoCacheIssueError } from "./utils.ts";
 
-import type { Denops, Entrypoint } from "jsr:@denops/std@~7.6.0";
-import * as vars from "jsr:@denops/std@~7.6.0/variable";
+import type { Denops, Entrypoint } from "@denops/std";
+import * as vars from "@denops/std/variable";
 
-import { Lock } from "jsr:@core/asyncutil@~1.2.0/lock";
-import { ensure } from "jsr:@core/unknownutil@~4.3.0/ensure";
-import { is } from "jsr:@core/unknownutil@~4.3.0/is";
-import { toFileUrl } from "jsr:@std/path@~1.1.0/to-file-url";
+import { Lock } from "@core/asyncutil/lock";
+import { ensure } from "@core/unknownutil/ensure";
+import { is } from "@core/unknownutil/is";
 
 export const main: Entrypoint = (denops: Denops) => {
   const loader = new Loader();
@@ -100,13 +99,9 @@ export const main: Entrypoint = (denops: Denops) => {
 
       await lock.lock(async () => {
         try {
-          // NOTE: Import module with fragment so that reload works properly.
-          // https://github.com/vim-denops/denops.vim/issues/227
-          const mod = await import(
-            `${toFileUrl(configPath).href}#${performance.now()}`
-          );
-
-          const obj = new mod.Config();
+          const mod = await importPlugin(configPath);
+          // deno-lint-ignore no-explicit-any
+          const obj = new (mod as any).Config();
 
           //console.log(`${Date.now() - startTime} ms`);
           const configReturn = await obj.config({
diff --git a/denops/dpp/base/config.ts b/denops/dpp/base/config.ts
index e80d56b..a55f716 100644
--- a/denops/dpp/base/config.ts
+++ b/denops/dpp/base/config.ts
@@ -2,7 +2,7 @@ import type { ContextBuilder } from "../types.ts";
 import type { Plugin } from "../types.ts";
 import type { Dpp } from "./dpp.ts";
 
-import type { Denops } from "jsr:@denops/std@~7.6.0";
+import type { Denops } from "@denops/std";
 
 export type ConfigArguments = {
   contextBuilder: ContextBuilder;
diff --git a/denops/dpp/base/dpp.ts b/denops/dpp/base/dpp.ts
index 334965e..968f4dd 100644
--- a/denops/dpp/base/dpp.ts
+++ b/denops/dpp/base/dpp.ts
@@ -10,7 +10,7 @@ import type {
 import type { BaseExt } from "./ext.ts";
 import type { Protocol } from "./protocol.ts";
 
-import type { Denops } from "jsr:@denops/std@~7.6.0";
+import type { Denops } from "@denops/std";
 
 export interface Dpp {
   extAction(
diff --git a/denops/dpp/base/ext.ts b/denops/dpp/base/ext.ts
index 8b04116..7bbca89 100644
--- a/denops/dpp/base/ext.ts
+++ b/denops/dpp/base/ext.ts
@@ -8,7 +8,7 @@ import type {
 } from "../types.ts";
 import type { Protocol } from "./protocol.ts";
 
-import type { Denops } from "jsr:@denops/std@~7.6.0";
+import type { Denops } from "@denops/std";
 
 export type OnInitArguments<Params extends BaseParams> = {
   denops: Denops;
diff --git a/denops/dpp/base/protocol.ts b/denops/dpp/base/protocol.ts
index 7f444a4..ae1135f 100644
--- a/denops/dpp/base/protocol.ts
+++ b/denops/dpp/base/protocol.ts
@@ -1,6 +1,6 @@
 import type { BaseParams, Plugin, ProtocolOptions } from "../types.ts";
 
-import type { Denops } from "jsr:@denops/std@~7.6.0";
+import type { Denops } from "@denops/std";
 
 export type OnInitArguments<Params extends BaseParams> = {
   denops: Denops;
diff --git a/denops/dpp/context.ts b/denops/dpp/context.ts
index 93893cd..317a3c4 100644
--- a/denops/dpp/context.ts
+++ b/denops/dpp/context.ts
@@ -8,7 +8,7 @@ import type {
 } from "./types.ts";
 import { printError } from "./utils.ts";
 
-import type { Denops } from "jsr:@denops/std@~7.6.0";
+import type { Denops } from "@denops/std";
 
 // where
 // T: Object
diff --git a/denops/dpp/deno.json b/denops/dpp/deno.json
new file mode 100644
index 0000000..9dcbc85
--- /dev/null
+++ b/denops/dpp/deno.json
@@ -0,0 +1,25 @@
+{
+  "name": "@shougo/dpp-vim",
+  "exports": {
+    "./config": "./base/config.ts",
+    "./dpp": "./base/dpp.ts",
+    "./ext": "./base/ext.ts",
+    "./protocol": "./base/protocol.ts",
+    "./types": "./types.ts",
+    "./utils": "./utils.ts"
+  },
+  "publish": {
+    "include": [
+      "**/*.ts"
+    ]
+  },
+  "imports": {
+    "@core/asyncutil": "jsr:@core/asyncutil@~1.2.0",
+    "@core/unknownutil": "jsr:@core/unknownutil@~4.3.0",
+    "@denops/std": "jsr:@denops/std@~8.0.0",
+    "@lambdalisue/import-map-importer": "jsr:@lambdalisue/import-map-importer@~0.5.1",
+    "@std/assert": "jsr:@std/assert@~1.0.7",
+    "@std/async": "jsr:@std/async@~1.0.7",
+    "@std/path": "jsr:@std/path@~1.1.0"
+  }
+}
diff --git a/denops/dpp/dpp.ts b/denops/dpp/dpp.ts
index 570b222..d992ec3 100644
--- a/denops/dpp/dpp.ts
+++ b/denops/dpp/dpp.ts
@@ -25,15 +25,15 @@ import {
   safeStat,
 } from "./utils.ts";
 
-import type { Denops } from "jsr:@denops/std@~7.6.0";
-import * as fn from "jsr:@denops/std@~7.6.0/function";
-import * as vars from "jsr:@denops/std@~7.6.0/variable";
+import type { Denops } from "@denops/std";
+import * as fn from "@denops/std/function";
+import * as vars from "@denops/std/variable";
 
-import { dirname } from "jsr:@std/path@~1.1.0/dirname";
-import { extname } from "jsr:@std/path@~1.1.0/extname";
-import { join } from "jsr:@std/path@~1.1.0/join";
-import { assertEquals } from "jsr:@std/assert@~1.0.2/equals";
-import { is } from "jsr:@core/unknownutil@~4.3.0/is";
+import { dirname } from "@std/path/dirname";
+import { extname } from "@std/path/extname";
+import { join } from "@std/path/join";
+import { assertEquals } from "@std/assert/equals";
+import { is } from "@core/unknownutil/is";
 
 export class DppImpl implements Dpp {
   #loader: Loader;
@@ -163,19 +163,11 @@ export class DppImpl implements Dpp {
 
       if (basePlugin.hooks_file) {
         for (const hooksFile of convert2List(basePlugin.hooks_file)) {
-          const hooksFilePath = await denops.call(
-            "dpp#util#_expand",
-            hooksFile,
-          ) as string;
-          const hooksFileLines = (await Deno.readTextFile(hooksFilePath)).split(
-            /\r?\n/,
-          );
-
           basePlugin = {
             ...basePlugin,
             ...parseHooksFile(
               options.hooksFileMarker,
-              hooksFileLines,
+              await readHooksFile(denops, hooksFile),
             ),
           };
         }
diff --git a/denops/dpp/ext.ts b/denops/dpp/ext.ts
index a63543a..75b5315 100644
--- a/denops/dpp/ext.ts
+++ b/denops/dpp/ext.ts
@@ -22,8 +22,8 @@ import { type BaseProtocol, defaultProtocolOptions } from "./base/protocol.ts";
 import type { Protocol } from "./base/protocol.ts";
 import { printError } from "./utils.ts";
 
-import type { Denops } from "jsr:@denops/std@~7.6.0";
-import * as fn from "jsr:@denops/std@~7.6.0/function";
+import type { Denops } from "@denops/std";
+import * as fn from "@denops/std/function";
 
 export async function getProtocols(
   denops: Denops,
diff --git a/denops/dpp/loader.ts b/denops/dpp/loader.ts
index bbfb9e8..a386488 100644
--- a/denops/dpp/loader.ts
+++ b/denops/dpp/loader.ts
@@ -1,22 +1,37 @@
 import type { BaseParams, DppExtType, ExtName, ProtocolName } from "./types.ts";
 import type { BaseExt } from "./base/ext.ts";
 import type { BaseProtocol } from "./base/protocol.ts";
-import { isDenoCacheIssueError } from "./utils.ts";
-
-import type { Denops } from "jsr:@denops/std@~7.6.0";
-import * as op from "jsr:@denops/std@~7.6.0/option";
-import * as fn from "jsr:@denops/std@~7.6.0/function";
-
-import { basename } from "jsr:@std/path@~1.1.0/basename";
-import { parse } from "jsr:@std/path@~1.1.0/parse";
-import { toFileUrl } from "jsr:@std/path@~1.1.0/to-file-url";
-import { Lock } from "jsr:@core/asyncutil@~1.2.0/lock";
+import { importPlugin, isDenoCacheIssueError } from "./utils.ts";
+
+import type { Denops } from "@denops/std";
+import * as op from "@denops/std/option";
+import * as fn from "@denops/std/function";
+
+import { basename } from "@std/path/basename";
+import { dirname } from "@std/path/dirname";
+import { join } from "@std/path/join";
+import { parse } from "@std/path/parse";
+import { Lock } from "@core/asyncutil/lock";
+
+type Mod = {
+  // deno-lint-ignore no-explicit-any
+  mod: any;
+  path: string;
+};
 
 type Ext = {
   ext: Record<string, BaseExt<BaseParams>>;
   protocol: Record<string, BaseProtocol<BaseParams>>;
 };
 
+const PLUGIN_PREFIX = "@dpp";
+
+// Pattern for directories where auto-loadable extensions are placed by type
+const TYPE_DIR_PATTERN = `denops/${PLUGIN_PREFIX}-*s`;
+
+// Structured extension module entry point file.
+const EXT_ENTRY_POINT_FILE = "main.ts";
+
 export class Loader {
   #exts: Ext = {
     ext: {},
@@ -24,7 +39,7 @@ export class Loader {
   };
   #checkPaths: Record<string, boolean> = {};
   #registerLock = new Lock(0);
-  #cachedPaths: Record<string, string> = {};
+  #cachedPaths = new Map<string, string>();
   #prevRuntimepath = "";
 
   async autoload(
@@ -34,27 +49,27 @@ export class Loader {
   ): Promise<boolean> {
     const runtimepath = await op.runtimepath.getGlobal(denops);
     if (runtimepath !== this.#prevRuntimepath) {
-      this.#cachedPaths = await globpath(
-        denops,
-        "denops/@dpp-*s",
-      );
-      this.#prevRuntimepath = runtimepath;
+      const cachedPaths = await createPathCache(denops, runtimepath);
+
+      // NOTE: glob may be invalid.
+      if (cachedPaths.size > 0) {
+        this.#cachedPaths = cachedPaths;
+        this.#prevRuntimepath = runtimepath;
+      }
     }
 
-    const key = `@dpp-${type}s/${name}`;
+    const key = `${PLUGIN_PREFIX}-${type}s/${name}`;
+    const path = this.#cachedPaths.get(key);
 
-    if (!this.#cachedPaths[key]) {
+    if (!path) {
       return this.#prevRuntimepath === "";
     }
 
-    await this.registerPath(type, this.#cachedPaths[key]);
-
-    // NOTE: this.#prevRuntimepath may be true if initialized.
-    // NOTE: If not found, it returns false, .
-    return this.#prevRuntimepath === "" || this.#cachedPaths[key] !== undefined;
+    await this.registerPath(type, path);
+    return true;
   }
 
-  async registerPath(type: DppExtType, path: string) {
+  async registerPath(type: DppExtType, path: string): Promise<void> {
     await this.#registerLock.lock(async () => {
       try {
         await this.#register(type, path);
@@ -122,14 +137,30 @@ export class Loader {
     }
 
     const name = parse(path).name;
-    const mod = await import(toFileUrl(path).href);
+    const mod: Mod = {
+      mod: undefined,
+      path,
+    };
+
+    // NOTE: We intentionally use Deno.stat instead of safeStat here. We expect
+    // errors to be thrown when paths don't exist or are inaccessible.
+    const fileInfo = await Deno.stat(path);
+
+    if (fileInfo.isDirectory) {
+      // Load structured extension module
+      const entryPoint = join(path, EXT_ENTRY_POINT_FILE);
+      mod.mod = await importPlugin(entryPoint);
+    } else {
+      // Load single-file extension module
+      mod.mod = await importPlugin(path);
+    }
 
     const typeExt = this.#exts[type];
     let add;
     switch (type) {
       case "ext":
         add = (name: string) => {
-          const ext = new mod.Ext();
+          const ext = new mod.mod.Ext();
           ext.name = name;
           ext.path = path;
           typeExt[name] = ext;
@@ -137,7 +168,7 @@ export class Loader {
         break;
       case "protocol":
         add = (name: string) => {
-          const ext = new mod.Protocol();
+          const ext = new mod.mod.Protocol();
           ext.name = name;
           ext.path = path;
           typeExt[name] = ext;
@@ -151,31 +182,52 @@ export class Loader {
   }
 }
 
-async function globpath(
+async function createPathCache(
   denops: Denops,
-  search: string,
-): Promise<Record<string, string>> {
-  const runtimepath = await op.runtimepath.getGlobal(denops);
-
-  const paths: Record<string, string> = {};
-  const glob = await fn.globpath(
+  runtimepath: string,
+): Promise<Map<string, string>> {
+  const extFileGlob = await globpath(
     denops,
     runtimepath,
-    search + "/*.ts",
-    1,
-    1,
+    `${TYPE_DIR_PATTERN}/*.ts`,
+  );
+  const extDirEntryPointGlob = await globpath(
+    denops,
+    runtimepath,
+    `${TYPE_DIR_PATTERN}/*/${EXT_ENTRY_POINT_FILE}`,
   );
 
-  for (const path of glob) {
-    // Skip already added name.
-    const parsed = parse(path);
-    const key = `${basename(parsed.dir)}/${parsed.name}`;
-    if (key in paths) {
-      continue;
-    }
-
-    paths[key] = path;
-  }
+  // Create key paths for both single-file and directory entry points.
+  // Prioritize the first occurrence key in keyPaths.
+  const keyPaths: Readonly<[key: string, path: string]>[] = [
+    //   1. `{name}.ts`
+    ...extFileGlob.map((extFile) => {
+      const { name, dir: typeDir } = parse(extFile);
+      const typeDirName = basename(typeDir);
+      const key = `${typeDirName}/${name}`;
+      return [key, extFile] as const;
+    }),
+    //   2. `{name}/main.ts`
+    ...extDirEntryPointGlob.map((entryPoint) => {
+      const extDir = dirname(entryPoint);
+      const { base: name, dir: typeDir } = parse(extDir);
+      const typeDirName = basename(typeDir);
+      const key = `${typeDirName}/${name}`;
+      return [key, extDir] as const;
+    }),
+  ];
+
+  // Remove duplicate keys.
+  // Note that `Map` prioritizes the later value, so need to reversed.
+  const cache = new Map(keyPaths.toReversed());
+
+  return cache;
+}
 
-  return paths;
+async function globpath(
+  denops: Denops,
+  path: string,
+  pattern: string,
+): Promise<string[]> {
+  return await fn.globpath(denops, path, pattern, 1, 1) as unknown as string[];
 }
diff --git a/denops/dpp/types.ts b/denops/dpp/types.ts
index b514203..9bd5ef7 100644
--- a/denops/dpp/types.ts
+++ b/denops/dpp/types.ts
@@ -1,4 +1,4 @@
-import type { Denops } from "jsr:@denops/std@~7.6.0";
+import type { Denops } from "@denops/std";
 
 export type DppExtType = "ext" | "protocol";
 
diff --git a/denops/dpp/utils.ts b/denops/dpp/utils.ts
index fb25e96..0683c4e 100644
--- a/denops/dpp/utils.ts
+++ b/denops/dpp/utils.ts
@@ -1,9 +1,17 @@
 import type { Plugin } from "./types.ts";
 
-import type { Denops } from "jsr:@denops/std@~7.6.0";
-
-import { join } from "jsr:@std/path@~1.1.0/join";
-import { assertEquals } from "jsr:@std/assert@~1.0.2/equals";
+import type { Denops } from "@denops/std";
+
+import {
+  type ImportMap,
+  ImportMapImporter,
+  loadImportMap,
+} from "@lambdalisue/import-map-importer";
+import { assertEquals } from "@std/assert/equals";
+import { toFileUrl } from "@std/path/to-file-url";
+import { fromFileUrl } from "@std/path/from-file-url";
+import { join } from "@std/path/join";
+import { dirname } from "@std/path/dirname";
 
 export async function printError(
   denops: Denops,
@@ -229,6 +237,53 @@ export function mergeFtplugins(
   }
 }
 
+export async function tryLoadImportMap(
+  script: string,
+): Promise<ImportMap | undefined> {
+  if (script.startsWith("http://") || script.startsWith("https://")) {
+    // We cannot load import maps for remote scripts
+    return undefined;
+  }
+  const PATTERNS = [
+    "deno.json",
+    "deno.jsonc",
+    "import_map.json",
+    "import_map.jsonc",
+  ];
+  // Convert file URL to path for file operations
+  const scriptPath = script.startsWith("file://")
+    ? fromFileUrl(new URL(script))
+    : script;
+  const parentDir = dirname(scriptPath);
+  for (const pattern of PATTERNS) {
+    const importMapPath = join(parentDir, pattern);
+    try {
+      return await loadImportMap(importMapPath);
+    } catch (err: unknown) {
+      if (err instanceof Deno.errors.NotFound) {
+        // Ignore NotFound errors and try the next pattern
+        continue;
+      }
+      throw err; // Rethrow other errors
+    }
+  }
+  return undefined;
+}
+
+export async function importPlugin(path: string): Promise<unknown> {
+  // Import module with fragment so that reload works properly
+  // https://github.com/vim-denops/denops.vim/issues/227
+  const suffix = performance.now();
+  const url = toFileUrl(path).href;
+  const importMap = await tryLoadImportMap(path);
+  if (importMap) {
+    const importer = new ImportMapImporter(importMap);
+    return await importer.import(`${url}#${suffix}`);
+  } else {
+    return await import(`${url}#${suffix}`);
+  }
+}
+
 Deno.test("parseHooksFile", () => {
   assertEquals(
     parseHooksFile("{{{,}}}", [
diff --git a/doc/dpp.txt b/doc/dpp.txt
index 659086d..e250630 100644
--- a/doc/dpp.txt
+++ b/doc/dpp.txt
@@ -44,10 +44,9 @@ managers.
 ==============================================================================
 INSTALL                                                          *dpp-install*
 
-NOTE: dpp.vim requires Vim 9.1.0448+ or Neovim (0.10.0+) (latest is
-recommended).
+Note: It requires Vim 9.1.1646+ or Neovim (0.11.0+).
 
-Please install both Deno 1.45+ and "denops.vim" v7.0+.
+Please install both Deno 2.3.0+ and "denops.vim" v8.0+.
 
 https://deno.land/
 https://github.com/vim-denops/denops.vim
@@ -189,6 +188,8 @@ dpp#make_state({base-path}, {config-path}[, {name}[, {extra-args}]])
 		NOTE: It must be called after |DenopsReady|.
 		NOTE: It saves your 'runtimepath' completely, you must not
 		call it after change 'runtimepath' dynamically.
+		NOTE: Import maps from "deno.json[c]" or "import_map.json[c]"
+		file in the same directory will also be loaded.
 
 		The TypeScript configuration script must returns following
 		object.