@rsdoctor/sdk 0.0.2-beta.0

package/dist/cjs/sdk/sdk/webpack.js

@@ -0,0 +1,373 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var webpack_exports = {};
+__export(webpack_exports, {
+  DoctorWebpackSDK: () => DoctorWebpackSDK
+});
+module.exports = __toCommonJS(webpack_exports);
+var import_error = require("@rsdoctor/utils/error");
+var import_types = require("@rsdoctor/types");
+var import_build = require("@rsdoctor/utils/build");
+var import_source_map = require("source-map");
+var import_graph = require("@rsdoctor/graph");
+var import_logger = require("@rsdoctor/utils/logger");
+var import_server = require("../server");
+var import_fakeServer = require("../server/fakeServer");
+var import_core = require("./core");
+class DoctorWebpackSDK extends import_core.SDKCore {
+  constructor(options) {
+    super(options);
+    this._summary = { costs: [] };
+    this._configs = [];
+    this._errors = [];
+    this._loader = [];
+    this._resolver = [];
+    this._plugin = {};
+    this._moduleGraph = new import_graph.ModuleGraph();
+    this._chunkGraph = new import_graph.ChunkGraph();
+    this._rawSourceMapCache = /* @__PURE__ */ new Map();
+    this._sourceMap = /* @__PURE__ */ new Map();
+    this.server = options.noServer ? new import_fakeServer.DoctorFakeServer(this, void 0) : new import_server.DoctorServer(this, options.port);
+    this.type = options.type || import_types.SDK.ToDataType.Normal;
+    this.extraConfig = options.config;
+  }
+  async bootstrap() {
+    (0, import_logger.debug)(() => `${Date.now()}`, "[DoctorWebpackSDK][bootstrap start]");
+    this.server && await this.server.bootstrap();
+    await super.bootstrap();
+    (0, import_logger.debug)(
+      () => `${Date.now()} ${this.server.origin}`,
+      "[DoctorWebpackSDK][bootstrap end]"
+    );
+  }
+  async dispose() {
+    (0, import_logger.debug)(() => `${Date.now()}`, "[DoctorWebpackSDK][dispose start]");
+    this.server && await this.server.dispose();
+    await super.dispose();
+    (0, import_logger.debug)(() => `${Date.now()}`, "[DoctorWebpackSDK][dispose end]");
+  }
+  async applyErrorFix(id) {
+    const { _errors: errors } = this;
+    const error = errors.find((err) => err.id === id);
+    if (!error || !error.path || !error.fixData || error.fixData.isFixed) {
+      return;
+    }
+    const { path: filePath, fixData } = error;
+    const sameFileErrors = errors.filter(
+      (item) => item.path === filePath && item !== error
+    );
+    let content = (await import_build.File.fse.readFile(filePath, "utf-8")).toString();
+    const startTxt = content.substring(0, fixData.start);
+    const endTxt = content.substring(fixData.end, content.length);
+    const offset = (fixData.newText ?? "").length - (fixData.end - fixData.start);
+    content = startTxt + fixData.newText + endTxt;
+    for (const other of sameFileErrors) {
+      const { fixData: otherFixData } = other;
+      if (!otherFixData) {
+        continue;
+      }
+      if (otherFixData.start >= fixData.end) {
+        otherFixData.start += offset;
+        otherFixData.end += offset;
+      }
+    }
+    await import_build.File.fse.writeFile(filePath, content);
+  }
+  clear() {
+    this._errors = [];
+    this._loader = [];
+    this._resolver = [];
+    this._plugin = {};
+    this._moduleGraph = new import_graph.ModuleGraph();
+    this._chunkGraph = new import_graph.ChunkGraph();
+  }
+  clearSourceMapCache() {
+    this._rawSourceMapCache = /* @__PURE__ */ new Map();
+    this._sourceMap = /* @__PURE__ */ new Map();
+  }
+  async getSourceMap(file) {
+    const { _sourceMap: sourceMap, _rawSourceMapCache: rawMap } = this;
+    if (sourceMap.has(file)) {
+      return sourceMap.get(file);
+    }
+    const rawData = rawMap.get(file);
+    if (!rawData || rawData.version < 0 || !rawData.sourcesContent?.[0] || !rawData.mappings) {
+      return Promise.resolve(void 0);
+    }
+    try {
+      const result = await new import_source_map.SourceMapConsumer(rawData);
+      sourceMap.set(file, result);
+      return result;
+    } catch (e) {
+      return Promise.resolve(void 0);
+    }
+  }
+  reportSourceMap(data) {
+    this._rawSourceMapCache.set(data.file, data);
+  }
+  reportConfiguration(config) {
+    this._configs.push(config);
+    this.onDataReport();
+  }
+  reportError(errors) {
+    errors.forEach((item) => {
+      this._errors.push(
+        import_error.DevToolError.from(item, {
+          code: this.name
+        })
+      );
+    });
+    this.onDataReport();
+  }
+  reportLoader(data) {
+    data.forEach((item) => {
+      let match = this._loader.find(
+        (e) => e.resource.path === item.resource.path
+      );
+      if (match) {
+        match.loaders.push(...item.loaders);
+      } else {
+        match = item;
+        this._loader.push(item);
+      }
+      match.loaders.sort((a, b) => {
+        if (a.startAt !== b.startAt) {
+          return a.startAt - b.startAt;
+        }
+        if (a.isPitch) {
+          if (b.isPitch) {
+            return a.loaderIndex - b.loaderIndex;
+          }
+          return -1;
+        }
+        if (b.isPitch) {
+          return 1;
+        }
+        return b.loaderIndex - a.loaderIndex;
+      });
+    });
+    this.onDataReport();
+  }
+  reportResolver(data) {
+    data.forEach((item) => this._resolver.push(item));
+    this.onDataReport();
+  }
+  reportPlugin(data) {
+    Object.keys(data).forEach((hook) => {
+      if (!this._plugin[hook]) {
+        this._plugin[hook] = data[hook];
+      } else {
+        data[hook].forEach((item) => {
+          this._plugin[hook].push(item);
+        });
+      }
+    });
+    this.onDataReport();
+  }
+  reportModuleGraph(data) {
+    (0, import_logger.debug)(() => `data size: ${data.size()}`, "[SDK.reportModuleGraph][start]");
+    this._moduleGraph.fromInstance(data);
+    this.createPackageGraph();
+    this.onDataReport();
+    (0, import_logger.debug)(
+      () => `sdk._moduleGraph size: ${this._moduleGraph.size()}`,
+      "[SDK reportModuleGraph][end]"
+    );
+  }
+  reportPackageGraph(data) {
+    (0, import_logger.debug)(() => "[SDK.reportPackageGraph][start]");
+    if (!this._packageGraph) {
+      this._packageGraph = data;
+    }
+    this.onDataReport();
+    (0, import_logger.debug)(
+      () => `sdk._moduleGraph size: ${this._moduleGraph.size()}`,
+      "[SDK reportPackageGraph][end]"
+    );
+  }
+  reportChunkGraph(data) {
+    this._chunkGraph.addAsset(...data.getAssets());
+    this._chunkGraph.addChunk(...data.getChunks());
+    this._chunkGraph.addEntryPoint(...data.getEntryPoints());
+    this.onDataReport();
+  }
+  reportSummaryData(part) {
+    const keys = ["costs"];
+    for (const key of keys) {
+      const v = part[key];
+      if (!v)
+        continue;
+      if (typeof v === "object") {
+        if (Array.isArray(v)) {
+          this._summary[key] = [
+            ...this._summary[key] || [],
+            ...v
+          ];
+        } else {
+          this._summary[key] = {
+            ...this._summary[key] || {},
+            ...v
+          };
+        }
+      } else {
+        this._summary[key] = v;
+      }
+    }
+    this.onDataReport();
+  }
+  reportTileHtml(tileReportHtml) {
+    this._tileReportHtml = tileReportHtml;
+  }
+  createPackageGraph() {
+    (0, import_logger.debug)(
+      () => `sdk._moduleGraph size: ${this._moduleGraph.size()}`,
+      "[SDK.createPackageGraph][start]"
+    );
+    if (!this._packageGraph) {
+      const pkgGraph = import_graph.PackageGraph.fromModuleGraph(
+        this._moduleGraph,
+        this.root,
+        (path) => {
+          try {
+            const exists = import_build.File.fse.existsSync(path);
+            if (exists) {
+              (0, import_logger.debug)(
+                () => `sdk.PackageGraph package.json exists: ${exists}, path: ${path}`,
+                "[SDK.createPackageGraph][load]"
+              );
+              return import_build.File.fse.readJSONSync(path);
+            }
+          } catch (error) {
+            const { message, stack } = error;
+            (0, import_logger.debug)(
+              () => `sdk.createPackageGraph error, path: ${path}, error message: ${stack || message}`,
+              "[SDK.createPackageGraph][error]"
+            );
+          }
+        }
+      );
+      this._packageGraph = pkgGraph;
+      (0, import_logger.debug)(
+        () => `sdk._packageGraph packages: ${this._packageGraph.getPackages().length}`,
+        "[SDK.createPackageGraph][end]"
+      );
+    }
+  }
+  writeStore(options) {
+    (0, import_logger.debug)(() => `sdk.writeStore has run.`, "[SDK.writeStore][end]");
+    return this.saveManifest(this.getStoreData(), options || {});
+  }
+  getStoreData() {
+    const ctx = this;
+    return {
+      get hash() {
+        return ctx.hash;
+      },
+      get root() {
+        return ctx.root;
+      },
+      get envinfo() {
+        return ctx._envinfo;
+      },
+      get pid() {
+        return ctx.pid;
+      },
+      get errors() {
+        return ctx._errors.map((err) => err.toData());
+      },
+      get configs() {
+        return ctx._configs.slice();
+      },
+      get summary() {
+        return { ...ctx._summary };
+      },
+      get resolver() {
+        return ctx._resolver.slice();
+      },
+      get loader() {
+        return ctx._loader.slice();
+      },
+      get moduleGraph() {
+        return ctx._moduleGraph.toData({
+          contextPath: ctx._configs?.[0]?.config?.context || ""
+        });
+      },
+      get chunkGraph() {
+        return ctx._chunkGraph.toData(ctx.type);
+      },
+      get moduleCodeMap() {
+        return ctx._moduleGraph.toCodeData(ctx.type);
+      },
+      get plugin() {
+        return { ...ctx._plugin };
+      },
+      get packageGraph() {
+        return ctx._packageGraph ? ctx._packageGraph.toData() : {
+          packages: [],
+          dependencies: []
+        };
+      },
+      get otherReports() {
+        return { tileReportHtml: ctx._tileReportHtml || "" };
+      }
+    };
+  }
+  getManifestData() {
+    const dataValue = this.getStoreData();
+    const data = {
+      client: {
+        enableRoutes: this.getClientRoutes()
+      },
+      data: Object.keys(dataValue).reduce((t, e) => {
+        const _e = e;
+        if (dataValue[_e] && typeof dataValue[_e] === "object") {
+          t[e] = [
+            `${this.server.origin}${import_types.SDK.ServerAPI.API.LoadDataByKey}/${e}`
+          ];
+        } else {
+          t[e] = dataValue[_e];
+        }
+        return t;
+      }, {}),
+      __LOCAL__SERVER__: true,
+      __SOCKET__URL__: this.server.socketUrl
+    };
+    return data;
+  }
+  getRuleContext(_options) {
+    this.createPackageGraph();
+    return {
+      root: this.root,
+      errors: this._errors.slice(),
+      configs: this._configs.slice(),
+      moduleGraph: this._moduleGraph,
+      chunkGraph: this._chunkGraph,
+      packageGraph: this._packageGraph,
+      loader: this._loader.slice(),
+      otherReports: { tileReportHtml: this._tileReportHtml || "" }
+    };
+  }
+  onDataReport() {
+    this.server.broadcast();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DoctorWebpackSDK
+});

package/dist/cjs/sdk/server/apis/alerts.js

@@ -0,0 +1,52 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+var alerts_exports = {};
+__export(alerts_exports, {
+  AlertsAPI: () => AlertsAPI
+});
+module.exports = __toCommonJS(alerts_exports);
+var import_types = require("@rsdoctor/types");
+var import_base = require("./base");
+var import_router = require("../router");
+class AlertsAPI extends import_base.BaseAPI {
+  async getPackageRelationAlertDetails() {
+    const { req } = this.ctx;
+    const { id, target } = req.body;
+    return this.dataLoader.loadAPI(
+      import_types.SDK.ServerAPI.API.GetPackageRelationAlertDetails,
+      { id, target }
+    );
+  }
+}
+__decorateClass([
+  import_router.Router.post(import_types.SDK.ServerAPI.API.GetPackageRelationAlertDetails)
+], AlertsAPI.prototype, "getPackageRelationAlertDetails", 1);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AlertsAPI
+});

package/dist/cjs/sdk/server/apis/base.js

@@ -0,0 +1,46 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var base_exports = {};
+__export(base_exports, {
+  BaseAPI: () => BaseAPI
+});
+module.exports = __toCommonJS(base_exports);
+var import_common = require("@rsdoctor/utils/common");
+class BaseAPI {
+  constructor(sdk, server) {
+    this.ctx = { sdk, server };
+    this.dataLoader = new import_common.Data.APIDataLoader(this);
+  }
+  async loadManifest() {
+    return this.ctx.sdk.getManifestData();
+  }
+  async loadData(key) {
+    const data = this.ctx.sdk.getStoreData();
+    const sep = ".";
+    let res = data[key];
+    if (key.includes(sep)) {
+      res = key.split(sep).reduce((t, k) => t[k], data);
+    }
+    return res;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseAPI
+});

package/dist/cjs/sdk/server/apis/bundle-diff.js

@@ -0,0 +1,79 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+var bundle_diff_exports = {};
+__export(bundle_diff_exports, {
+  BundleDiffAPI: () => BundleDiffAPI
+});
+module.exports = __toCommonJS(bundle_diff_exports);
+var import_types = require("@rsdoctor/types");
+var import_base = require("./base");
+var import_router = require("../router");
+class BundleDiffAPI extends import_base.BaseAPI {
+  async getBundleDiffSummary() {
+    const { sdk } = this.ctx;
+    const {
+      root,
+      hash,
+      errors,
+      chunkGraph,
+      moduleGraph,
+      packageGraph,
+      configs,
+      moduleCodeMap
+    } = sdk.getStoreData();
+    let outputFilename = "";
+    if (typeof configs?.[0]?.config?.output?.filename === "string") {
+      outputFilename = configs?.[0]?.config?.output?.filename;
+    }
+    return {
+      root,
+      hash,
+      errors,
+      chunkGraph,
+      moduleGraph,
+      packageGraph,
+      outputFilename,
+      moduleCodeMap
+    };
+  }
+  async bundleDiffManifest() {
+    const { sdk } = this.ctx;
+    const data = sdk.getStoreData();
+    return data;
+  }
+}
+__decorateClass([
+  import_router.Router.get(import_types.SDK.ServerAPI.API.GetBundleDiffSummary)
+], BundleDiffAPI.prototype, "getBundleDiffSummary", 1);
+__decorateClass([
+  import_router.Router.get(import_types.SDK.ServerAPI.API.BundleDiffManifest)
+], BundleDiffAPI.prototype, "bundleDiffManifest", 1);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BundleDiffAPI
+});

package/dist/cjs/sdk/server/apis/data.js

@@ -0,0 +1,66 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+var data_exports = {};
+__export(data_exports, {
+  DataAPI: () => DataAPI
+});
+module.exports = __toCommonJS(data_exports);
+var import_types = require("@rsdoctor/types");
+var import_base = require("./base");
+var import_router = require("../router");
+class DataAPI extends import_base.BaseAPI {
+  async loadDataByKey() {
+    const { req } = this.ctx;
+    const { url } = req;
+    let { key } = req.body;
+    if (!key && url) {
+      const uri = new URL(url, "http://127.0.0.1");
+      key = uri.pathname.replace(
+        /^\//,
+        ""
+      );
+    }
+    const data = await this.loadData(key);
+    return data;
+  }
+  async sendMessageToClient() {
+    const { req, server } = this.ctx;
+    const { api, data } = req.body;
+    await server.sendAPIDataToClient(api, data);
+  }
+}
+__decorateClass([
+  import_router.Router.post(import_types.SDK.ServerAPI.API.LoadDataByKey)
+], DataAPI.prototype, "loadDataByKey", 1);
+__decorateClass([
+  import_router.Router.post(import_types.SDK.ServerAPI.API.SendAPIDataToClient)
+], DataAPI.prototype, "sendMessageToClient", 1);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DataAPI
+});

package/dist/cjs/sdk/server/apis/fs.js

@@ -0,0 +1,50 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+var fs_exports = {};
+__export(fs_exports, {
+  FileSystemAPI: () => FileSystemAPI
+});
+module.exports = __toCommonJS(fs_exports);
+var import_types = require("@rsdoctor/types");
+var import_base = require("./base");
+var import_router = require("../router");
+class FileSystemAPI extends import_base.BaseAPI {
+  async applyErrorFix() {
+    const { body } = this.ctx.req;
+    const data = body;
+    await this.ctx.sdk.applyErrorFix(data.id);
+    return "success";
+  }
+}
+__decorateClass([
+  import_router.Router.post(import_types.SDK.ServerAPI.API.ApplyErrorFix)
+], FileSystemAPI.prototype, "applyErrorFix", 1);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FileSystemAPI
+});