jimpex 10.0.1 → 11.0.0

package/CHANGELOG.md

@@ -1,3 +1,41 @@
+# [11.0.0](https://github.com/homer0/jimpex/compare/10.0.2...11.0.0) (2025-12-08)
+
+
+### Bug Fixes
+
+* add missing extensions for esm ([c08930d](https://github.com/homer0/jimpex/commit/c08930d559f6b656c7fe9aa84b4ab894141439aa))
+* define module exports for the package and set the type to module ([935a9d2](https://github.com/homer0/jimpex/commit/935a9d273f9495f833a0e976e12ffe8d1f4cba3a))
+* drop Node v18 ([46de5f2](https://github.com/homer0/jimpex/commit/46de5f20e185cea701a57de46ed92fb5f8c1c854))
+* import a single obj from spdy ([ee96af3](https://github.com/homer0/jimpex/commit/ee96af3c0a64b4bc1d115a77ef26e635a852a3df))
+* import spdy only when using it ([385b70f](https://github.com/homer0/jimpex/commit/385b70fd14127cbc4510ab2364476d7dad2ba99d))
+* remove unnecessary check ([7530b2b](https://github.com/homer0/jimpex/commit/7530b2b0a16abdddb608c0541a56a765bfc36e35))
+* typo on default value ([9fd84c5](https://github.com/homer0/jimpex/commit/9fd84c5e1ba6ca9908e0e8da45a71b37e8d76206))
+* typo on type name ([c0c3118](https://github.com/homer0/jimpex/commit/c0c311825e9f8895b08b5d8ae09a93111264724c))
+* update dependencies ([8245c8f](https://github.com/homer0/jimpex/commit/8245c8fc11863d27b98652c09b0df9a2345498e3))
+* update regex to cover new stack trace ([c6672ef](https://github.com/homer0/jimpex/commit/c6672ef08c9e4880759fe9a615b5e28419cc0239))
+* use node prefix for importing internals ([ed1df9e](https://github.com/homer0/jimpex/commit/ed1df9e295368a0de417298b38b8fcbd95101492))
+* use the right import path ([7ed1721](https://github.com/homer0/jimpex/commit/7ed1721ddccb170a5ff45e61fee874c040c2d5ad))
+
+
+### BREAKING CHANGES
+
+* The VersionValidator default option for `popup.message`
+was changed from `vesion:conflict` to `version:confict`
+* The type HTTPContructorOptions was renamed to
+HTTPConstructorOptions
+* This package is now esm only
+* Node v18 is not longer supported. Node v20.19 is the minimum
+required version now.
+
+## [10.0.2](https://github.com/homer0/jimpex/compare/10.0.1...10.0.2) (2024-11-09)
+
+
+### Bug Fixes
+
+* add support for Node v22 and set v20 for dev ([743f987](https://github.com/homer0/jimpex/commit/743f987c19a5ef93329a05b633eadf82ed52859d))
+* get rid of unused variable ([09c92b5](https://github.com/homer0/jimpex/commit/09c92b5aadff5fb914c4ebdff8159472a1b04d05))
+* update dependencies ([e7ed985](https://github.com/homer0/jimpex/commit/e7ed9855b12743686f5ba64965f86241e0025db6))
+
 ## [10.0.1](https://github.com/homer0/jimpex/compare/10.0.0...10.0.1) (2024-04-07)
 
 

package/README.md

@@ -96,7 +96,7 @@ app.set('message', 'Hello Pili!');
 app.boot();
 ```
 
-Now, this may look like an unnecessary feature, but if you consider the possiblity of different entry points based on environment, maybe to enable debugging tools on dev, this becomes really useful.
+Now, this may look like an unnecessary feature, but if you consider the possibility of different entry points based on environment, maybe to enable debugging tools on dev, this becomes really useful.
 
 ### ⚙️ Options and configuration
 
@@ -356,7 +356,7 @@ Jimpex already comes with a few built-in service providers ready to be used, and
 
 ##### Configurable services
 
-Since the version of Jimple that Jimpex uses under the hood is [`@homer0/jimple`](https://www.npmjs.com/package/@homer0/jimple), my custom "fork", you can also create "configureable providers":
+Since the version of Jimple that Jimpex uses under the hood is [`@homer0/jimple`](https://www.npmjs.com/package/@homer0/jimple), my custom "fork", you can also create "configurable providers":
 
 ```ts
 // src/my-service.js
@@ -502,7 +502,7 @@ class MyApp extends Jimpex {
 
 #### Controllers with services
 
-If for some reason, your controller needs to register a service that the rest of the container needs to have access to, and you plan to do it on the `controller`/`controllerCreator` callback, you could end up messing with the _lazyness_ of the container: If a middleware or another controller tries to access the service and the controller that registers it is mounted after it, it will get an error as the service _doesn't exist yet_.
+If for some reason, your controller needs to register a service that the rest of the container needs to have access to, and you plan to do it on the `controller`/`controllerCreator` callback, you could end up messing with the _laziness_ of the container: If a middleware or another controller tries to access the service and the controller that registers it is mounted after it, it will get an error as the service _doesn't exist yet_.
 
 A way to solve this issue would be with a `provider`/`providerCreator`, mounting the controller:
 
@@ -623,7 +623,7 @@ Just like the `controllerCreator` wrapper, you can also use the `middlewareCreat
 
 ```ts
 // my-middleware.js
-import { middlwareCreator } from 'jimpex';
+import { middlewareCreator } from 'jimpex';
 
 // Define your middleware function (or class if it gets more complex)
 export const greetingsMiddleware = (message) => (req, res, next) => {
@@ -743,15 +743,13 @@ The configuration for `semantic-release` is on `./releaserc` and the workflow fo
 
 ### Testing
 
-I use [Jest](https://jestjs.io) to test the project.
+I use [Vitest](https://vitest.dev) to test the project.
 
 The configuration file is on `./.jestrc.js`, the tests are on `./tests` and the script that runs it is on `./utils/scripts/test`.
 
 ### Code linting and formatting
 
-For linting, I use [ESlint](https://eslint.org) with [my own custom configuration](https://npmjs.com/package/@homer0/eslint-plugin).
-
-There are two configuration files, `./.eslintrc` for the source and the tooling, and `./tests/.eslintrc`, and there's also a `./.eslintignore` to exclude some files.
+For linting, I use [ESlint](https://eslint.org) with [my own custom configuration](https://npmjs.com/package/@homer0/eslint-plugin). The configuration file is `./eslint.config.js`.
 
 For formatting, I use [Prettier](https://prettier.io) with [my JSDoc plugin](https://npmjs.com/package/@homer0/prettier-plugin-jsdoc) and [my own custom configuration](https://npmjs.com/package/@homer0/prettier-config). The configuration file is `./.prettierrc`.
 
@@ -767,4 +765,4 @@ The configuration file is `./.typedoc.json` and the script that runs it is on `.
 
 A friend, who's also web developer, brought the idea of start using a dependency injection container on Node, and how Jimple was a great tool for it; from the moment I tried Jimple, I could never think of starting another project without it: It not only allows you to implement dependency injection on a simple and clean way, but it also kind of forces you to have a really good organization of your code.
 
-A couple of months after that, the same friend told me that we should do something similar to [Silex](https://github.com/silexphp/Silex), which is based on Pimple, butwith Express. I ran with the idea and... this project is what I think a mix of Jimple and Express would look like. To be clear, **this is not a port of Silex**.
+A couple of months after that, the same friend told me that we should do something similar to [Silex](https://github.com/silexphp/Silex), which is based on Pimple, but with Express. I ran with the idea and... this project is what I think a mix of Jimple and Express would look like. To be clear, **this is not a port of Silex**.

package/dist/app/index.d.ts

@@ -1,4 +1,4 @@
-export { J as Jimpex, j as jimpex } from '../index-C6I3NCC-.js';
+export { J as Jimpex, j as jimpex } from '../index-BlSpNHox.js';
 import '../types/express.js';
 import 'express';
 import '../types/http.js';

package/dist/app/index.js

@@ -1,23 +1,2 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var app_exports = {};
-module.exports = __toCommonJS(app_exports);
-__reExport(app_exports, require("./jimpex"), module.exports);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ...require("./jimpex")
-});
+export * from "./jimpex.js";
 //# sourceMappingURL=index.js.map

package/dist/app/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/app/index.ts"],"sourcesContent":["export * from './jimpex';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,wBAAc,qBAAd;","names":[]}
+{"version":3,"sources":["../../src/app/index.ts"],"sourcesContent":["export * from './jimpex.js';\n"],"mappings":"AAAA,cAAc;","names":[]}

package/dist/app/jimpex.d.ts

@@ -1,6 +1,6 @@
 import '@homer0/jimple';
 import '@homer0/events-hub';
-export { J as Jimpex, j as jimpex } from '../index-C6I3NCC-.js';
+export { J as Jimpex, j as jimpex } from '../index-BlSpNHox.js';
 import 'express';
 import '../types/http.js';
 import '../types/utils.js';

package/dist/app/jimpex.js

@@ -1,109 +1,75 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
-var jimpex_exports = {};
-__export(jimpex_exports, {
-  Jimpex: () => Jimpex,
-  jimpex: () => jimpex
-});
-module.exports = __toCommonJS(jimpex_exports);
-var path = __toESM(require("path"));
-var import_promises = __toESM(require("fs/promises"));
-var import_https = require("https");
-var import_jimple = require("@homer0/jimple");
-var import_deep_assign = require("@homer0/deep-assign");
-var import_simple_logger = require("@homer0/simple-logger");
-var import_env_utils = require("@homer0/env-utils");
-var import_package_info = require("@homer0/package-info");
-var import_path_utils = require("@homer0/path-utils");
-var import_root_file = require("@homer0/root-file");
-var import_ts_async_import = require("@homer0/ts-async-import");
-var import_events_hub = require("@homer0/events-hub");
-var import_simple_config = require("@homer0/simple-config");
-var import_compression = __toESM(require("compression"));
-var import_body_parser = __toESM(require("body-parser"));
-var import_multer = __toESM(require("multer"));
-var import_spdy = require("spdy");
-var import_express = __toESM(require("express"));
-var import_services = require("../services");
-var import_utils = require("../utils");
-class Jimpex extends import_jimple.Jimple {
+import * as path from "node:path";
+import fs from "node:fs/promises";
+import { createServer as createHTTPSServer } from "https";
+import { Jimple } from "@homer0/jimple";
+import { deepAssignWithOverwrite } from "@homer0/deep-assign";
+import { appLoggerProvider } from "@homer0/simple-logger";
+import { envUtilsProvider } from "@homer0/env-utils";
+import { packageInfoProvider } from "@homer0/package-info";
+import { pathUtilsProvider } from "@homer0/path-utils";
+import { rootFileProvider } from "@homer0/root-file";
+import { tsAsyncImport } from "@homer0/ts-async-import";
+import { EventsHub } from "@homer0/events-hub";
+import { simpleConfigProvider } from "@homer0/simple-config";
+import compression from "compression";
+import bodyParser from "body-parser";
+import multer from "multer";
+import express from "express";
+import {
+  commonServicesProvider,
+  httpServicesProvider,
+  utilsServicesProvider
+} from "../services/index.js";
+import {
+  statuses
+} from "../utils/index.js";
+class Jimpex extends Jimple {
+  /**
+   * The customization settings for the application.
+   */
+  _options;
+  /**
+   * The Express application Jimpex uses under the hood.
+   */
+  _express;
+  /**
+   * Since the configuration service has an async initialization, the class uses this flag
+   * internally to validate if the configuration has been initialized or not.
+   */
+  _configReady = false;
+  /**
+   * A reference to the actual HTTP the application will use. This can vary depending on
+   * whether HTTPS, or HTTP2 are enabled. If HTTPS is not enabled, it will be the same as
+   * the `express` property; if HTTPS is enabled, it will be an `https` server; and if
+   * HTTP2 is enabled, it will be an `spdy` server.
+   */
+  _server;
+  /**
+   * The instance of the server that is listening for requests.
+   */
+  _instance;
+  /**
+   * A list of functions that implement controllers and middlewares. When the application
+   * starts, the queue will be processed and those controllers and middlewares will be
+   * added to the server instance. The reason they are not added directly like with a
+   * regular Express implementation is that services on Jimple use lazy loading, and
+   * adding middlewares and controllers as they come could cause errors if they depend on
+   * services that are not yet registered.
+   */
+  _mountQueue = [];
+  /**
+   * A list with all the top routes controlled by the application. Every time a controller
+   * is mounted, its route will be added here.
+   */
+  _controlledRoutes = [];
   /**
    * @param options  Preferences to customize the application.
    * @param config   The default settings for the configuration service. It's a
-   *                 shortcuit for `options.config.default`
+   *                 short-circuit for `options.config.default`
    */
   constructor(options = {}, config = {}) {
     super();
-    /**
-     * The customization settings for the application.
-     */
-    __publicField(this, "_options");
-    /**
-     * The Express application Jimpex uses under the hood.
-     */
-    __publicField(this, "_express");
-    /**
-     * Since the configuration service has an async initialization, the class uses this flag
-     * internally to validate if the configuration has been initialized or not.
-     */
-    __publicField(this, "_configReady", false);
-    /**
-     * A reference to the actuall HTTP the application will use. This can vary depending on
-     * whether HTTPS, or HTTP2 are enabled. If HTTPS is not enabled, it will be the same as
-     * the `express` property; if HTTPS is enabled, it will be an `https` server; and if
-     * HTTP2 is enabled, it will be an `spdy` server.
-     */
-    __publicField(this, "_server");
-    /**
-     * The instance of the server that is listening for requests.
-     */
-    __publicField(this, "_instance");
-    /**
-     * A list of functions that implement controllers and middlewares. When the application
-     * starts, the queue will be processed and those controllers and middlewares will be
-     * added to the server instance. The reason they are not added directly like with a
-     * regular Express implementation is that services on Jimple use lazy loading, and
-     * adding middlewares and controllers as they come could cause errors if they depend on
-     * services that are not yet registered.
-     */
-    __publicField(this, "_mountQueue", []);
-    /**
-     * A list with all the top routes controlled by the application. Every time a controller
-     * is mounted, its route will be added here.
-     */
-    __publicField(this, "_controlledRoutes", []);
-    this._options = (0, import_deep_assign.deepAssignWithOverwrite)(
+    this._options = deepAssignWithOverwrite(
       {
         filesizeLimit: "15MB",
         boot: true,
@@ -143,7 +109,7 @@ class Jimpex extends import_jimple.Jimple {
       options,
       this._initOptions()
     );
-    this._express = (0, import_express.default)();
+    this._express = express();
     this._setupCoreServices();
     this._setupExpress();
     this._configurePath();
@@ -214,8 +180,7 @@ class Jimpex extends import_jimple.Jimple {
    * Stops the server instance.
    */
   stop() {
-    if (!this._instance)
-      return;
+    if (!this._instance) return;
     this._emitEvent("beforeStop", { app: this });
     this._instance.close();
     this._instance = void 0;
@@ -241,8 +206,7 @@ class Jimpex extends import_jimple.Jimple {
     }
     this._mountQueue.push((server) => {
       const connected = useController.connect(this, route);
-      if (!connected)
-        return;
+      if (!connected) return;
       const router = this._reduceWithEvent("controllerWillBeMounted", connected, {
         route,
         controller: useController,
@@ -326,7 +290,7 @@ class Jimpex extends import_jimple.Jimple {
    * The application customization options.
    */
   get options() {
-    return (0, import_deep_assign.deepAssignWithOverwrite)({}, this._options);
+    return deepAssignWithOverwrite({}, this._options);
   }
   /**
    * Gets the events service.
@@ -353,7 +317,7 @@ class Jimpex extends import_jimple.Jimple {
     return this.eventsHub.on(eventName, listener);
   }
   /**
-   * Adds a listener for an application event that will only be execuded once: the first
+   * Adds a listener for an application event that will only be executed once: the first
    * time the event is triggered.
    *
    * @param eventName  The name of the event to listen for.
@@ -366,7 +330,7 @@ class Jimpex extends import_jimple.Jimple {
     return this.eventsHub.once(eventName, listener);
   }
   /**
-   * Based on the application options, it returns wheter the application is healthy or
+   * Based on the application options, it returns whether the application is healthy or
    * not.
    */
   isHealthy() {
@@ -375,7 +339,7 @@ class Jimpex extends import_jimple.Jimple {
   /**
    * This method is like a "lifecycle method", it gets executed on the constructor right
    * before the "boot step". The idea is for the method to be a helper when the
-   * application is defined by subclassing {@link Jimpex}: the application could register
+   * application is defined by sub-classing {@link Jimpex}: the application could register
    * all important services here and the routes on boot, then, if the implementation needs
    * to access or overwrite a something, it can send `boot: false`, access/register what
    * it needs, and then call `boot()`. That would be impossible for an application without
@@ -385,7 +349,7 @@ class Jimpex extends import_jimple.Jimple {
   }
   /**
    * It generates overwrites for the application options when it gets created. This method
-   * is a helper for when the application is defined by subclassing {@link Jimpex}: It's
+   * is a helper for when the application is defined by sub-classing {@link Jimpex}: It's
    * highly probable that if the application needs to change the default options, it would
    * want to do it right from the class, instead of having to do it on every
    * implementation. A way to do it would be overwriting the constructor and calling
@@ -401,23 +365,20 @@ class Jimpex extends import_jimple.Jimple {
    */
   _setupCoreServices() {
     this.register(
-      (0, import_simple_logger.appLoggerProvider)({
+      appLoggerProvider({
         serviceName: "logger"
       })
     );
-    this.register(import_env_utils.envUtilsProvider);
-    this.register(import_package_info.packageInfoProvider);
-    this.register(import_path_utils.pathUtilsProvider);
-    this.register(import_root_file.rootFileProvider);
+    this.register(envUtilsProvider);
+    this.register(packageInfoProvider);
+    this.register(pathUtilsProvider);
+    this.register(rootFileProvider);
     const { services: enabledServices } = this._options;
-    if (enabledServices.common)
-      this.register(import_services.commonServicesProvider);
-    if (enabledServices.http)
-      this.register(import_services.httpServicesProvider);
-    if (enabledServices.utils)
-      this.register(import_services.utilsServicesProvider);
-    this.set("events", () => new import_events_hub.EventsHub());
-    this.set("statuses", () => import_utils.statuses);
+    if (enabledServices.common) this.register(commonServicesProvider);
+    if (enabledServices.http) this.register(httpServicesProvider);
+    if (enabledServices.utils) this.register(utilsServicesProvider);
+    this.set("events", () => new EventsHub());
+    this.set("statuses", () => statuses);
   }
   /**
    * Configures the Express application based on the class options.
@@ -431,30 +392,30 @@ class Jimpex extends import_jimple.Jimple {
       this._express.disable("x-powered-by");
     }
     if (expressOptions.compression) {
-      this._express.use((0, import_compression.default)());
+      this._express.use(compression());
     }
     if (statics.enabled) {
       this._addStaticsFolder(statics.route, statics.folder, statics.onHome);
     }
     if (expressOptions.bodyParser) {
       this._express.use(
-        import_body_parser.default.json({
+        bodyParser.json({
           limit: filesizeLimit
         })
       );
       this._express.use(
-        import_body_parser.default.urlencoded({
+        bodyParser.urlencoded({
           extended: true,
           limit: filesizeLimit
         })
       );
     }
     if (expressOptions.multer) {
-      this._express.use((0, import_multer.default)().any());
+      this._express.use(multer().any());
     }
     this.set(
       "router",
-      this.factory(() => import_express.default.Router())
+      this.factory(() => express.Router())
     );
   }
   /**
@@ -475,7 +436,7 @@ class Jimpex extends import_jimple.Jimple {
     const pathUtils = this.get("pathUtils");
     const staticFolder = pathUtils.joinFrom(location, folder || staticRoute);
     this.mount(`/${staticRoute}`, {
-      connect: () => import_express.default.static(staticFolder),
+      connect: () => express.static(staticFolder),
       controller: true
     });
   }
@@ -483,7 +444,7 @@ class Jimpex extends import_jimple.Jimple {
    * This helper method validates the `path` options in order to register the `app`
    * location in the `pathUtils` service. The `app` location should be the path to where
    * the application executable is located, but due to how ESM works, we can't infer it
-   * from the `module` object, so we need either recieved as the `appPath` setting, or try
+   * from the `module` object, so we need either received as the `appPath` setting, or try
    * to get it from the parent module.
    *
    * @throws If the method should use the path from the parent module, but can't find
@@ -505,7 +466,7 @@ class Jimpex extends import_jimple.Jimple {
       stackList.shift();
       const parentFromStack = stackList.find((line) => !line.includes(__filename));
       if (parentFromStack) {
-        const parentFile = parentFromStack.replace(/^.*?\s\(([^\s]+):\d+:\d+\)/, "$1");
+        const parentFile = parentFromStack.replace(/^.*?\s\(?([^\s]+):\d+:\d+\)?/, "$1");
         if (parentFile !== parentFromStack) {
           foundPath = true;
           pathUtils.addLocation("app", path.dirname(parentFile));
@@ -525,8 +486,7 @@ class Jimpex extends import_jimple.Jimple {
    * This method is called just before starting the application.
    */
   async _setupConfig() {
-    if (this._configReady)
-      return;
+    if (this._configReady) return;
     this._configReady = true;
     const { config: options } = this._options;
     let configsPath = options.path.replace(/\/$/, "");
@@ -539,7 +499,7 @@ class Jimpex extends import_jimple.Jimple {
       options.name
     );
     this.register(
-      (0, import_simple_config.simpleConfigProvider)({
+      simpleConfigProvider({
         name: options.name,
         defaultConfig: options.default,
         defaultConfigFilename,
@@ -559,8 +519,8 @@ class Jimpex extends import_jimple.Jimple {
    * the application so they'll be available for all the services.
    */
   async _loadESMModules() {
-    const { default: nodeFetch } = await (0, import_ts_async_import.tsAsyncImport)("node-fetch");
-    const { default: mime } = await (0, import_ts_async_import.tsAsyncImport)("mime");
+    const { default: nodeFetch } = await tsAsyncImport("node-fetch");
+    const { default: mime } = await tsAsyncImport("mime");
     this.set("node-fetch", () => nodeFetch);
     this.set("mime", () => mime);
   }
@@ -611,9 +571,8 @@ class Jimpex extends import_jimple.Jimple {
     const info = await Promise.all(
       keys.map(async (key) => {
         const filepath = credentialsInfo[key];
-        if (!filepath)
-          return void 0;
-        const file = await import_promises.default.readFile(pathUtils.joinFrom(location, filepath), "utf8");
+        if (!filepath) return void 0;
+        const file = await fs.readFile(pathUtils.joinFrom(location, filepath), "utf8");
         return {
           key,
           file
@@ -635,7 +594,7 @@ class Jimpex extends import_jimple.Jimple {
    * @returns {Server}
    * @throws {Error} If HTTP2 is enabled but HTTPS is not.
    * @throws {Error} If HTTPS is enabled but there's no `https.credentials` object.
-   * @throws {Error} If HTTPS is enabled and no creadentials are found.
+   * @throws {Error} If HTTPS is enabled and no credentials are found.
    * @access protected
    * @ignore
    */
@@ -662,15 +621,15 @@ class Jimpex extends import_jimple.Jimple {
         ...credentials,
         spdy: http2Config.spdy
       };
-      return (0, import_spdy.createServer)(serverOptions, this._express);
+      const spdyModule = await tsAsyncImport("spdy");
+      return spdyModule.default.createServer(serverOptions, this._express);
     }
-    return (0, import_https.createServer)(credentials, this._express);
+    return createHTTPSServer(credentials, this._express);
   }
 }
 const jimpex = (...args) => new Jimpex(...args);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   Jimpex,
   jimpex
-});
+};
 //# sourceMappingURL=jimpex.js.map