@modern-js/prod-server 2.8.0 → 2.9.1-alpha.0

package/dist/js/node/libs/render/cache/page-caches/lru.js

@@ -0,0 +1,58 @@
+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 __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(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var lru_exports = {};
+__export(lru_exports, {
+  LRUCaches: () => LRUCaches
+});
+module.exports = __toCommonJS(lru_exports);
+var import_lru_cache = __toESM(require("lru-cache"));
+class LRUCaches {
+  constructor(options) {
+    this.max = options.max;
+    this.caches = new import_lru_cache.default(this.max);
+  }
+  init() {
+    return Promise.resolve();
+  }
+  keys() {
+    return this.caches.keys();
+  }
+  get(key) {
+    return Promise.resolve(this.caches.get(key) || null);
+  }
+  peek(key) {
+    return this.caches.peek(key) || null;
+  }
+  set(key, cache) {
+    this.caches.set(key, cache);
+    return Promise.resolve();
+  }
+  del(key) {
+    this.caches.del(key);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LRUCaches
+});

package/dist/js/node/libs/render/cache/spr.js

@@ -0,0 +1,270 @@
+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 __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(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var spr_exports = {};
+__export(spr_exports, {
+  createCache: () => createCache,
+  destroyCache: () => destroyCache
+});
+module.exports = __toCommonJS(spr_exports);
+var import_crypto = __toESM(require("crypto"));
+var import_lru_cache = __toESM(require("lru-cache"));
+var import_utils = require("@modern-js/utils");
+var import_util = require("./util");
+var import_page_caches = require("./page-caches");
+const MAX_CACHE_EACH_REQ = Number(process.env.ROUTE_CACHE_LIMIT) || 10;
+const MAX_SIZE_EACH_CLUSTER = Number(process.env.CLUSTER_CACHE_LIMIT) || 100;
+const BASE_LEVEL = 0;
+const QUERY_LEVEL = 1;
+const HEADER_LEVEL = 2;
+const QUERY_HEADER_LEVEL = 3;
+class CacheManager {
+  constructor(cacheOptions) {
+    this.find = (() => {
+      {
+        const _this = this;
+        return {
+          [(0, import_util.fname)(BASE_LEVEL)](context, cacheKey) {
+            return _this.md5(cacheKey);
+          },
+          [(0, import_util.fname)(QUERY_LEVEL)](context, cacheKey, data) {
+            const queryFactor = _this.queryFactor(context, data);
+            if (!queryFactor) {
+              return null;
+            }
+            return _this.md5((0, import_util.connectFactor)(cacheKey, queryFactor));
+          },
+          [(0, import_util.fname)(HEADER_LEVEL)](context, cacheKey, data) {
+            const headerFactor = _this.headerFactor(context, data);
+            if (!headerFactor) {
+              return null;
+            }
+            return _this.md5((0, import_util.connectFactor)(cacheKey, headerFactor));
+          },
+          [(0, import_util.fname)(QUERY_HEADER_LEVEL)](context, cacheKey, data) {
+            const queryFactor = _this.queryFactor(context, data);
+            const headerFactor = _this.headerFactor(context, data);
+            if (!queryFactor || !headerFactor) {
+              return null;
+            }
+            return _this.md5((0, import_util.connectFactor)(cacheKey, headerFactor, queryFactor));
+          }
+        };
+      }
+    })();
+    this.cacheOptions = cacheOptions;
+    this.cache = new import_lru_cache.default({
+      max: Math.min(MAX_SIZE_EACH_CLUSTER, 600) * 1024 * 1024,
+      length(n) {
+        const len = n.caches.keys().reduce((total, cur) => {
+          var _a;
+          return total + (((_a = n.caches.peek(cur)) == null ? void 0 : _a.size) || 0);
+        }, 1);
+        return len;
+      }
+    });
+  }
+  md5(content) {
+    const md5 = import_crypto.default.createHash("md5");
+    return md5.update(content).digest("hex");
+  }
+  generateRequestKey(context) {
+    const { pathname, entry } = context;
+    return this.md5(`${pathname}_${entry}`);
+  }
+  replaceValue(value, matcher) {
+    let final = value;
+    Object.keys(matcher).some((replacer) => {
+      const reg = new RegExp(matcher[replacer]);
+      if (reg.test(value)) {
+        final = replacer;
+        return true;
+      }
+      return false;
+    });
+    return final;
+  }
+  factor(keys, obj, matches = {}) {
+    keys.sort();
+    const getValue = (0, import_util.valueFactory)(obj);
+    const factorAry = keys.reduce((ary, key) => {
+      let value = getValue(key) || "";
+      const matcher = matches[key];
+      if (matcher) {
+        value = this.replaceValue(value, matcher);
+      }
+      return ary.concat([key, value]);
+    }, []);
+    return factorAry.join(",");
+  }
+  queryFactor(context, data) {
+    var _a, _b;
+    const queryKeys = (_a = data.includes) == null ? void 0 : _a.query;
+    const queryMatches = (_b = data.matches) == null ? void 0 : _b.query;
+    if (!queryKeys || queryKeys.length === 0) {
+      return null;
+    }
+    const requestQuery = context.query;
+    const queryFactor = this.factor(queryKeys, requestQuery, queryMatches);
+    return queryFactor;
+  }
+  headerFactor(context, data) {
+    var _a, _b;
+    const headerKeys = (_a = data.includes) == null ? void 0 : _a.header;
+    const headerMatches = (_b = data.matches) == null ? void 0 : _b.header;
+    if (!headerKeys || headerKeys.length === 0) {
+      return null;
+    }
+    const requestHeader = context.headers;
+    const headerFactor = this.factor(headerKeys, requestHeader, headerMatches);
+    return headerFactor;
+  }
+  best(context, cacheKey, data) {
+    return __async(this, null, function* () {
+      const { level } = data;
+      const cacheHash = this.find[(0, import_util.fname)(level)](context, cacheKey, data);
+      if (!cacheHash) {
+        return null;
+      }
+      return data.caches.get(cacheHash);
+    });
+  }
+  createCacheContent(config, caches) {
+    return {
+      level: config.level,
+      interval: config.interval,
+      includes: config.includes || null,
+      limit: config.staleLimit,
+      matches: config.matches || null,
+      caches
+    };
+  }
+  get(context) {
+    return __async(this, null, function* () {
+      const cacheKey = this.generateRequestKey(context);
+      const data = this.cache.get(cacheKey);
+      if (!data) {
+        return null;
+      }
+      const dest = yield this.best(context, cacheKey, data);
+      if (!dest) {
+        return null;
+      }
+      const { expireTime, limitTime, html, cacheHash } = dest;
+      const isStale = Date.now() - expireTime > 0;
+      const isGarbage = limitTime ? Date.now() - limitTime > 0 : false;
+      return {
+        content: html || "",
+        contentType: import_utils.mime.contentType("html"),
+        isStale,
+        isGarbage,
+        hash: cacheHash
+      };
+    });
+  }
+  set(context, html, cacheConfig, sync = false) {
+    return __async(this, null, function* () {
+      if (!cacheConfig) {
+        return false;
+      }
+      const cacheKey = this.generateRequestKey(context);
+      let data = this.cache.get(cacheKey);
+      if (!data) {
+        const caches = yield (0, import_page_caches.createPageCaches)(MAX_CACHE_EACH_REQ);
+        data = this.createCacheContent(cacheConfig, caches);
+      }
+      const cacheHash = this.find[(0, import_util.fname)(cacheConfig.level)](
+        context,
+        cacheKey,
+        data
+      );
+      if (!cacheHash) {
+        return false;
+      }
+      const cacheSyncOrAsync = () => __async(this, null, function* () {
+        const next = data;
+        const limit = cacheConfig.staleLimit;
+        const storeHTML = (0, import_util.cacheAddition)(html, cacheHash);
+        const size = storeHTML.length;
+        yield next.caches.set(cacheHash, {
+          expireTime: Date.now() + cacheConfig.interval * 1e3,
+          limitTime: typeof limit === "number" ? Date.now() + limit * 1e3 : null,
+          cacheHash,
+          html: storeHTML,
+          size
+        });
+        this.cache.set(cacheKey, next);
+        return true;
+      });
+      const doCache = (0, import_util.withCoalescedInvoke)(cacheSyncOrAsync).bind(
+        null,
+        (0, import_util.namespaceHash)("stream", cacheHash),
+        []
+      );
+      return (0, import_util.maybeSync)(doCache)(sync);
+    });
+  }
+  del(context, cacheHash) {
+    return __async(this, null, function* () {
+      const cacheKey = this.generateRequestKey(context);
+      const data = this.cache.get(cacheKey);
+      data == null ? void 0 : data.caches.del(cacheHash);
+    });
+  }
+}
+let manager;
+function createCache() {
+  if (manager) {
+    return manager;
+  }
+  manager = new CacheManager({ max: 0 });
+  return manager;
+}
+function destroyCache() {
+  manager = null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createCache,
+  destroyCache
+});

package/dist/js/node/libs/render/cache/type.js

@@ -0,0 +1,15 @@
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var type_exports = {};
+module.exports = __toCommonJS(type_exports);

package/dist/js/node/libs/render/cache/util.js

@@ -0,0 +1,138 @@
+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 __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(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var util_exports = {};
+__export(util_exports, {
+  cacheAddition: () => cacheAddition,
+  connectFactor: () => connectFactor,
+  fname: () => fname,
+  getTime: () => getTime,
+  maybeSync: () => maybeSync,
+  namespaceHash: () => namespaceHash,
+  valueFactory: () => valueFactory,
+  withCoalescedInvoke: () => withCoalescedInvoke
+});
+module.exports = __toCommonJS(util_exports);
+var import_url = __toESM(require("url"));
+function namespaceHash(namespace, hash) {
+  return `${namespace}/${hash}`;
+}
+function fname(lv) {
+  return `f${lv}`;
+}
+function connectFactor(...args) {
+  return args.join("-");
+}
+function valueFactory(obj) {
+  if (obj instanceof import_url.default.URLSearchParams) {
+    return function(key) {
+      return obj.get(key);
+    };
+  } else {
+    return function(key) {
+      const value = obj[key];
+      if (Array.isArray(value)) {
+        return value.join(",");
+      }
+      return value;
+    };
+  }
+}
+function getTime([s, ns]) {
+  return Math.floor(s * 1e3 + ns / 1e6);
+}
+const RE_START_IN_HEAD = /<head>/;
+function cacheAddition(html, hash) {
+  const additionHtml = html.replace(
+    RE_START_IN_HEAD,
+    `<head><meta name="x-moden-spr" content="${hash}">`
+  );
+  return additionHtml;
+}
+const globalInvokeCache = /* @__PURE__ */ new Map();
+function withCoalescedInvoke(func) {
+  return function(key, args) {
+    return __async(this, null, function* () {
+      const entry = globalInvokeCache.get(key);
+      if (entry) {
+        return entry.then((res) => ({
+          isOrigin: false,
+          value: res.value
+        }));
+      }
+      function __wrapper() {
+        return func(...args);
+      }
+      const future = __wrapper().then((res) => {
+        globalInvokeCache.delete(key);
+        return { isOrigin: true, value: res };
+      }).catch((err) => {
+        globalInvokeCache.delete(key);
+        throw err;
+      });
+      globalInvokeCache.set(key, future);
+      return future;
+    });
+  };
+}
+function maybeSync(fn) {
+  return (sync) => {
+    if (sync) {
+      return fn();
+    } else {
+      fn();
+      return Promise.resolve();
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cacheAddition,
+  connectFactor,
+  fname,
+  getTime,
+  maybeSync,
+  namespaceHash,
+  valueFactory,
+  withCoalescedInvoke
+});

package/dist/js/node/libs/render/index.js

@@ -0,0 +1,115 @@
+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 __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(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var render_exports = {};
+__export(render_exports, {
+  createRenderHandler: () => createRenderHandler
+});
+module.exports = __toCommonJS(render_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+var import_constants = require("../../constants");
+var import_static = require("./static");
+var import_reader = require("./reader");
+var ssr = __toESM(require("./ssr"));
+const createRenderHandler = ({
+  distDir,
+  staticGenerate,
+  forceCSR
+}) => function render(_0) {
+  return __async(this, arguments, function* ({
+    ctx,
+    route,
+    runner
+  }) {
+    if (ctx.resHasHandled()) {
+      return null;
+    }
+    const { entryPath, urlPath } = route;
+    const entry = import_path.default.join(distDir, entryPath);
+    if (!route.isSPA) {
+      const result = yield (0, import_static.handleDirectory)(ctx, entry, urlPath);
+      return result;
+    }
+    const templatePath = entry;
+    if (!import_utils.fs.existsSync(templatePath)) {
+      throw new Error(`Could not find template file: ${templatePath}`);
+    }
+    const content = yield (0, import_reader.readFile)(templatePath);
+    if (!content) {
+      return null;
+    }
+    const useCSR = forceCSR && ctx.query.csr;
+    if (route.isSSR && !useCSR) {
+      try {
+        const result = yield ssr.render(
+          ctx,
+          {
+            distDir,
+            entryName: route.entryName,
+            urlPath: route.urlPath,
+            bundle: route.bundle,
+            template: content.toString(),
+            staticGenerate
+          },
+          runner
+        );
+        return result;
+      } catch (err) {
+        ctx.error(
+          import_constants.ERROR_DIGEST.ERENDER,
+          err.stack || err.message
+        );
+        ctx.res.setHeader("x-modern-ssr-fallback", "1");
+      }
+    }
+    return {
+      content,
+      contentType: import_utils.mime.contentType(import_path.default.extname(templatePath))
+    };
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createRenderHandler
+});

package/dist/js/node/libs/render/measure.js

@@ -0,0 +1,90 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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 measure_exports = {};
+__export(measure_exports, {
+  createLogger: () => createLogger,
+  createMetrics: () => createMetrics
+});
+module.exports = __toCommonJS(measure_exports);
+var import_utils = require("../../utils");
+const createMetrics = (context, metrics) => {
+  const { entryName: entry, request } = context;
+  const { pathname = "" } = request || {};
+  const emitTimer = (name, cost, tags = {}) => {
+    metrics.emitTimer(name, cost, __spreadProps(__spreadValues({}, tags), {
+      pathname,
+      entry
+    }));
+  };
+  const emitCounter = (name, counter, tags = {}) => {
+    metrics.emitCounter(name, counter, __spreadProps(__spreadValues({}, tags), {
+      pathname,
+      entry
+    }));
+  };
+  return { emitTimer, emitCounter };
+};
+const createLogger = (serverContext, logger) => {
+  const request = serverContext.request || {};
+  const { headers = {}, pathname = "" } = request;
+  const debug = (message, ...args) => {
+    logger.debug(`SSR Debug - ${message}, req.url = %s`, ...args, pathname);
+  };
+  const info = (message, ...args) => {
+    logger.info(`SSR Info - ${message}, req.url = %s`, ...args, pathname);
+  };
+  const error = (message, e) => {
+    if (!e) {
+      e = message;
+      message = "";
+    }
+    logger.error(
+      `SSR Error - ${message}, error = %s, req.url = %s, req.headers = %o`,
+      e instanceof Error ? e.stack || e.message : e,
+      pathname,
+      (0, import_utils.headersWithoutCookie)(headers)
+    );
+  };
+  return {
+    error,
+    info,
+    debug
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createLogger,
+  createMetrics
+});