@tstdl/base 0.83.27 → 0.83.28

package/pdf/pdf.service.js

@@ -1,9 +1,7 @@
 "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 __export = (target, all) => {
   for (var name in all)
@@ -17,25 +15,17 @@ var __copyProps = (to, from, except, desc) => {
   }
   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 pdf_service_exports = {};
 __export(pdf_service_exports, {
-  PdfFormat: () => PdfFormat,
-  PdfMarginObject: () => PdfMarginObject,
-  PdfRenderOptions: () => PdfRenderOptions,
   PdfService: () => PdfService,
+  PdfServiceRenderOptions: () => PdfServiceRenderOptions,
   PdfTemplate: () => PdfTemplate,
   pdfTemplate: () => pdfTemplate
 });
 module.exports = __toCommonJS(pdf_service_exports);
+var import_browser_service = require("../browser/browser.service.js");
+var import_pdf_options = require("../browser/pdf-options.js");
 var import_container = require("../container/index.js");
 var import_core = require("../core.js");
 var import_disposable = require("../disposable/disposable.js");
@@ -44,12 +34,10 @@ var import_pool = require("../pool/pool.js");
 var import_schema = require("../schema/index.js");
 var import_templates = require("../templates/index.js");
 var import_finalize_stream = require("../utils/stream/finalize-stream.js");
-var import_readable_stream_adapter = require("../utils/stream/readable-stream-adapter.js");
 var import_readable_stream_from_promise = require("../utils/stream/readable-stream-from-promise.js");
 var import_stream_reader = require("../utils/stream/stream-reader.js");
 var import_type_guards = require("../utils/type-guards.js");
 var import_units = require("../utils/units.js");
-var puppeteer = __toESM(require("puppeteer"), 1);
 var __decorate = function(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
@@ -69,56 +57,9 @@ var __param = function(paramIndex, decorator) {
     decorator(target, key, paramIndex);
   };
 };
-var PdfFormat;
-(function(PdfFormat2) {
-  PdfFormat2["Letter"] = "letter";
-  PdfFormat2["Legal"] = "legal";
-  PdfFormat2["Tabloid"] = "tabloid";
-  PdfFormat2["Ledger"] = "ledger";
-  PdfFormat2["A0"] = "a0";
-  PdfFormat2["A1"] = "a1";
-  PdfFormat2["A2"] = "a2";
-  PdfFormat2["A3"] = "a3";
-  PdfFormat2["A4"] = "a4";
-  PdfFormat2["A5"] = "a5";
-  PdfFormat2["A6"] = "a6";
-})(PdfFormat || (PdfFormat = {}));
-class PdfMarginObject {
-  top;
-  bottom;
-  right;
-  left;
-}
-__decorate([
-  (0, import_schema.Optional)([Number, String]),
-  __metadata("design:type", Object)
-], PdfMarginObject.prototype, "top", void 0);
-__decorate([
-  (0, import_schema.Optional)([Number, String]),
-  __metadata("design:type", Object)
-], PdfMarginObject.prototype, "bottom", void 0);
-__decorate([
-  (0, import_schema.Optional)([Number, String]),
-  __metadata("design:type", Object)
-], PdfMarginObject.prototype, "right", void 0);
-__decorate([
-  (0, import_schema.Optional)([Number, String]),
-  __metadata("design:type", Object)
-], PdfMarginObject.prototype, "left", void 0);
-class PdfRenderOptions {
+class PdfServiceRenderOptions extends import_pdf_options.PdfRenderOptions {
   language;
-  omitDefaultBackground;
-  renderBackground;
-  landscape;
-  format;
-  width;
-  height;
-  scale;
-  margin;
-  displayHeaderFooter;
   waitForNetworkIdle;
-  headerTemplate;
-  footerTemplate;
   /**
    * Timeout for closing render context in case something went wrong.
    * @default 60000 (1 minute)
@@ -128,80 +69,30 @@ class PdfRenderOptions {
 __decorate([
   (0, import_schema.Optional)(),
   __metadata("design:type", String)
-], PdfRenderOptions.prototype, "language", void 0);
-__decorate([
-  (0, import_schema.Optional)(),
-  __metadata("design:type", Boolean)
-], PdfRenderOptions.prototype, "omitDefaultBackground", void 0);
-__decorate([
-  (0, import_schema.Optional)(),
-  __metadata("design:type", Boolean)
-], PdfRenderOptions.prototype, "renderBackground", void 0);
+], PdfServiceRenderOptions.prototype, "language", void 0);
 __decorate([
   (0, import_schema.Optional)(),
   __metadata("design:type", Boolean)
-], PdfRenderOptions.prototype, "landscape", void 0);
-__decorate([
-  (0, import_schema.Optional)(),
-  (0, import_schema.Enumeration)(PdfFormat),
-  __metadata("design:type", String)
-], PdfRenderOptions.prototype, "format", void 0);
-__decorate([
-  (0, import_schema.Optional)([String, Number]),
-  __metadata("design:type", Object)
-], PdfRenderOptions.prototype, "width", void 0);
-__decorate([
-  (0, import_schema.Optional)([String, Number]),
-  __metadata("design:type", Object)
-], PdfRenderOptions.prototype, "height", void 0);
+], PdfServiceRenderOptions.prototype, "waitForNetworkIdle", void 0);
 __decorate([
   (0, import_schema.Optional)(),
   __metadata("design:type", Number)
-], PdfRenderOptions.prototype, "scale", void 0);
-__decorate([
-  (0, import_schema.Optional)([String, Number, PdfMarginObject]),
-  __metadata("design:type", Object)
-], PdfRenderOptions.prototype, "margin", void 0);
-__decorate([
-  (0, import_schema.Optional)(),
-  __metadata("design:type", Boolean)
-], PdfRenderOptions.prototype, "displayHeaderFooter", void 0);
-__decorate([
-  (0, import_schema.Optional)(),
-  __metadata("design:type", Boolean)
-], PdfRenderOptions.prototype, "waitForNetworkIdle", void 0);
-__decorate([
-  (0, import_schema.Optional)(),
-  __metadata("design:type", String)
-], PdfRenderOptions.prototype, "headerTemplate", void 0);
-__decorate([
-  (0, import_schema.Optional)(),
-  __metadata("design:type", String)
-], PdfRenderOptions.prototype, "footerTemplate", void 0);
-__decorate([
-  (0, import_schema.Optional)(),
-  __metadata("design:type", Number)
-], PdfRenderOptions.prototype, "timeout", void 0);
+], PdfServiceRenderOptions.prototype, "timeout", void 0);
 class PdfTemplate extends import_templates.Template {
 }
 __decorate([
   (0, import_schema.Optional)(),
   __metadata("design:type", Object)
 ], PdfTemplate.prototype, "options", void 0);
+const browserArguments = ["--font-render-hinting=none", "--disable-web-security", "--disable-features=IsolateOrigins", "--disable-site-isolation-trials"];
 let PdfService = class PdfService2 {
   templateService;
   logger;
   pool;
-  constructor(templateService, logger, options = {}) {
+  constructor(templateService, browserService, logger, options = {}) {
     this.templateService = templateService;
     this.logger = logger;
-    const args = ["--font-render-hinting=none", "--disable-web-security", "--disable-features=IsolateOrigins", "--disable-site-isolation-trials"];
-    const env = {};
-    if ((0, import_type_guards.isDefined)(options.language)) {
-      args.push(`--lang=${options.language}`);
-      env["LANGUAGE"] = options.language;
-    }
-    this.pool = new import_pool.Pool(async () => puppeteer.launch({ headless: true, args, env }), async (browser) => browser.close(), logger);
+    this.pool = new import_pool.Pool(async () => browserService.newBrowser({ headless: true, language: options.language, browserArguments }), async (controller) => controller.close(), logger);
   }
   [import_container.afterResolve]() {
     import_core.disposer.add(this);
@@ -238,8 +129,8 @@ let PdfService = class PdfService2 {
    * @returns pdf stream
    */
   renderUrlStream(url, options) {
-    return this.renderStream(async (page) => {
-      await page.goto(url, { waitUntil: options?.waitForNetworkIdle == true ? "networkidle2" : "load" });
+    return this.renderStream(async (controller) => {
+      await controller.navigate(url, { waitUntil: options?.waitForNetworkIdle == true ? "networkidle2" : "load" });
     }, options);
   }
   /**
@@ -262,8 +153,8 @@ let PdfService = class PdfService2 {
   renderTemplateStream(keyOrTemplate, templateContext, options) {
     return this.renderStream(async (page) => {
       const { fields: { header, body, footer }, options: optionsFromTemplate } = await this.templateService.render(keyOrTemplate, templateContext);
-      await page.setContent(body, { ...optionsFromTemplate, headerTemplate: header, footerTemplate: footer, waitUntil: options?.waitForNetworkIdle == true ? "networkidle2" : "load", ...options });
-      return { ...optionsFromTemplate, headerTemplate: header, footerTemplate: footer, ...options };
+      await page.setContent(body, { timeout: options?.timeout, waitUntil: options?.waitForNetworkIdle == true ? "networkidle2" : "load" });
+      return { ...optionsFromTemplate, headerTemplate: header, footerTemplate: footer };
     }, options);
   }
   /**
@@ -279,67 +170,45 @@ let PdfService = class PdfService2 {
   }
   renderStream(handler, options = {}) {
     return (0, import_readable_stream_from_promise.readableStreamFromPromise)(async () => {
-      const browser = await this.pool.get();
+      const browserController = await this.pool.get();
+      let page;
       try {
-        let page;
+        page = await browserController.newPage();
+      } catch (error) {
+        await this.pool.disposeInstance(browserController);
+        throw error;
+      }
+      if ((0, import_type_guards.isDefined)(options.language)) {
+        await page.setExtraHttpHeaders({ "Accept-Language": options.language });
+      }
+      const optionsFromHandler = await handler(page);
+      const pdfStream = page.renderPdfStream({ ...optionsFromHandler, ...options });
+      const timeoutRef = setTimeout(() => void pdfStream.cancel(new Error("Pdf render timed out.")), options.timeout ?? import_units.millisecondsPerMinute);
+      const close = async () => {
         try {
-          page = await browser.newPage();
+          clearTimeout(timeoutRef);
+          await page.close();
         } catch (error) {
-          await this.pool.disposeInstance(browser);
-          throw error;
+          await this.pool.disposeInstance(browserController);
+          this.logger.error(error);
         }
-        if ((0, import_type_guards.isDefined)(options.language)) {
-          await page.setExtraHTTPHeaders({ "Accept-Language": options.language });
-        }
-        const timeoutRef = setTimeout(() => void page.close().catch((error) => this.logger.error(error)), options.timeout ?? import_units.millisecondsPerMinute);
-        const optionsFromHandler = await handler(page) ?? {};
-        const mergedOptions = { ...optionsFromHandler, ...options };
-        const createPdfOptions = this.convertOptions(mergedOptions);
-        const pdfStream = await page.createPDFStream(createPdfOptions);
-        return (0, import_finalize_stream.finalizeStream)((0, import_readable_stream_adapter.getReadableStreamFromIterable)(pdfStream), async () => {
+      };
+      return (0, import_finalize_stream.finalizeStream)(pdfStream, {
+        beforeDone: close,
+        beforeCancel: close,
+        error: async () => {
           clearTimeout(timeoutRef);
-          try {
-            await page.close();
-          } catch (error) {
-            this.logger.error(error);
-            throw error;
-          } finally {
-            await this.pool.release(browser);
-          }
-        });
-      } catch (error) {
-        await this.pool.release(browser);
-        throw error;
-      }
+          await this.pool.disposeInstance(browserController);
+        }
+      });
     });
   }
-  convertOptions(options) {
-    const margin = (0, import_type_guards.isUndefined)(options.margin) ? void 0 : (0, import_type_guards.isObject)(options.margin) ? options.margin : {
-      top: options.margin,
-      bottom: options.margin,
-      right: options.margin,
-      left: options.margin
-    };
-    return {
-      format: options.format ?? "a4",
-      scale: options.scale,
-      landscape: options.landscape,
-      width: options.width,
-      height: options.height,
-      omitBackground: options.omitDefaultBackground,
-      printBackground: options.renderBackground,
-      margin,
-      displayHeaderFooter: options.displayHeaderFooter ?? ((0, import_type_guards.isDefined)(options.headerTemplate) || (0, import_type_guards.isDefined)(options.footerTemplate)),
-      headerTemplate: options.headerTemplate,
-      footerTemplate: options.footerTemplate
-    };
-  }
 };
 PdfService = __decorate([
   (0, import_container.singleton)(),
-  __param(1, (0, import_container.resolveArg)("PdfService")),
-  __param(2, (0, import_container.injectArg)()),
-  __metadata("design:paramtypes", [import_templates.TemplateService, import_logger.Logger, Object])
+  __param(2, (0, import_container.resolveArg)("PdfService")),
+  __param(3, (0, import_container.injectArg)()),
+  __metadata("design:paramtypes", [import_templates.TemplateService, import_browser_service.BrowserService, import_logger.Logger, Object])
 ], PdfService);
 function pdfTemplate(name, fields, options) {
   return {

package/pool/pool.js

@@ -79,6 +79,9 @@ class Pool {
     return this.get();
   }
   async release(instance) {
+    if (this.freeInstances.includes(instance)) {
+      throw new Error("Instance is free already.");
+    }
     if (!this.usedInstances.has(instance)) {
       throw new Error("Instance is not from this pool.");
     }

package/types.d.ts

@@ -1,4 +1,4 @@
-import type { Except, UnionToIntersection } from 'type-fest';
+import type { Except, OptionalKeysOf, UnionToIntersection } from 'type-fest';
 export type ObjectLiteral = {};
 export type PrimitiveTypeMap = {
     'string': string;
@@ -112,6 +112,9 @@ export type OmitBy<T, V> = Omit<T, {
  * normalize properties of a type that allow `undefined` to make them optional.
  */
 export type Optionalize<T extends object> = OmitBy<T, undefined> & Partial<PickBy<T, undefined>>;
+export type Unoptionalize<T extends object> = Simplify<OmitBy<T, undefined> & {
+    [P in OptionalKeysOf<T>]: T[P] | undefined;
+}>;
 export type SimplifiedOptionalize<T extends object> = Simplify<Optionalize<T>>;
 export type Merge<T1, T2> = SimplifyObject<Except<T1, Extract<keyof T1, keyof T2>> & T2>;
 export type Simplify<T> = T extends BuiltIn ? T : T extends readonly any[] ? SimplifyArray<T> : T extends Record ? SimplifyObject<T> : T;

package/utils/index.d.ts

@@ -44,4 +44,5 @@ export * from './type-guards.js';
 export * from './type-of.js';
 export * from './units.js';
 export * from './url-builder.js';
+export * from './value-or-provider.js';
 export * from './z-base32.js';

package/utils/index.js

@@ -61,4 +61,5 @@ __reExport(utils_exports, require("./type-guards.js"), module.exports);
 __reExport(utils_exports, require("./type-of.js"), module.exports);
 __reExport(utils_exports, require("./units.js"), module.exports);
 __reExport(utils_exports, require("./url-builder.js"), module.exports);
+__reExport(utils_exports, require("./value-or-provider.js"), module.exports);
 __reExport(utils_exports, require("./z-base32.js"), module.exports);

package/utils/stream/finalize-stream.d.ts

@@ -1 +1,22 @@
-export declare function finalizeStream<T>(stream: ReadableStream<T>, finalizer: () => void | PromiseLike<void>): ReadableStream<T>;
+export type ReadableStreamFinalizeEvent = {
+    type: 'done';
+} | {
+    type: 'error';
+    error: any;
+} | {
+    type: 'cancel';
+    reason: any;
+};
+/**
+ * Finalizer is called *after* the specific event occurred.
+ */
+export type StreamFinalizerHandler = (event: ReadableStreamFinalizeEvent) => void | Promise<void>;
+export type FinalizeStreamHandlers = {
+    finalizer?: StreamFinalizerHandler;
+    beforeDone?: () => void | Promise<void>;
+    done?: () => void | Promise<void>;
+    error?: (error: Error) => void | Promise<void>;
+    beforeCancel?: (reason: any) => void | Promise<void>;
+    cancel?: (reason: any) => void | Promise<void>;
+};
+export declare function finalizeStream<T>(stream: ReadableStream<T>, finalizerOrHandlers: StreamFinalizerHandler | FinalizeStreamHandlers): ReadableStream<T>;

package/utils/stream/finalize-stream.js

@@ -21,7 +21,9 @@ __export(finalize_stream_exports, {
   finalizeStream: () => finalizeStream
 });
 module.exports = __toCommonJS(finalize_stream_exports);
-function finalizeStream(stream, finalizer) {
+var import_type_guards = require("../type-guards.js");
+function finalizeStream(stream, finalizerOrHandlers) {
+  const handlers = (0, import_type_guards.isFunction)(finalizerOrHandlers) ? { finalizer: finalizerOrHandlers } : finalizerOrHandlers;
   let reader;
   return new ReadableStream({
     start() {
@@ -32,21 +34,29 @@ function finalizeStream(stream, finalizer) {
       try {
         chunk = await reader.read();
       } catch (error) {
-        await finalizer();
+        await handlers.error?.(error);
+        await handlers.finalizer?.({ type: "error", error });
         throw error;
       }
       if (chunk.done) {
+        await handlers.beforeDone?.();
         controller.close();
-        await finalizer();
+        await handlers.done?.();
+        await handlers.finalizer?.({ type: "done" });
       } else {
         controller.enqueue(chunk.value);
       }
     },
     async cancel(reason) {
       try {
+        await handlers.beforeCancel?.(reason);
         await reader.cancel(reason);
+        await handlers.cancel?.(reason);
+      } catch (error) {
+        await handlers.error?.(error);
+        throw error;
       } finally {
-        await finalizer();
+        await handlers.finalizer?.({ type: "cancel", reason });
       }
     }
   });

package/utils/stream/readable-stream-from-promise.d.ts

@@ -1 +1,2 @@
-export declare function readableStreamFromPromise<T>(executor: () => Promise<ReadableStream<T>>): ReadableStream<T>;
+import type { ValueOrProvider } from '../value-or-provider.js';
+export declare function readableStreamFromPromise<T>(promiseOrProvider: ValueOrProvider<Promise<ReadableStream<T>>>): ReadableStream<T>;

package/utils/stream/readable-stream-from-promise.js

@@ -21,8 +21,9 @@ __export(readable_stream_from_promise_exports, {
   readableStreamFromPromise: () => readableStreamFromPromise
 });
 module.exports = __toCommonJS(readable_stream_from_promise_exports);
-function readableStreamFromPromise(executor) {
+var import_value_or_provider = require("../value-or-provider.js");
+function readableStreamFromPromise(promiseOrProvider) {
   const stream = new TransformStream();
-  executor().then(async (readable) => readable.pipeTo(stream.writable)).catch(async (error) => stream.writable.abort(error));
+  (0, import_value_or_provider.resolveValueOrProvider)(promiseOrProvider).then(async (readable) => readable.pipeTo(stream.writable)).catch(async (error) => stream.writable.abort(error));
   return stream.readable;
 }

package/utils/type-guards.d.ts

@@ -238,3 +238,9 @@ export declare function assertReadableStream<T = any>(value: any, message?: Asse
 export declare function assertNotReadableStream<T>(value: T, message?: AssertionMessage): asserts value is InferIsNotType<T, typeof isReadableStream>;
 export declare function assertReadableStreamPass<T = any>(value: any, message?: AssertionMessage): InferIsType<typeof isReadableStream>;
 export declare function assertNotReadableStreamPass<T>(value: T, message?: AssertionMessage): InferIsNotType<T, typeof isReadableStream>;
+export declare function isError(value: any): value is Error;
+export declare function isNotError<T>(value: T): value is InferIsNotType<T, typeof isError>;
+export declare function assertError(value: any, message?: AssertionMessage): asserts value is InferIsType<typeof isError>;
+export declare function assertNotError<T>(value: T, message?: AssertionMessage): asserts value is InferIsNotType<T, typeof isError>;
+export declare function assertErrorPass(value: any, message?: AssertionMessage): InferIsType<typeof isError>;
+export declare function assertNotErrorPass<T>(value: T, message?: AssertionMessage): InferIsNotType<T, typeof isError>;

package/utils/type-guards.js

@@ -43,6 +43,8 @@ __export(type_guards_exports, {
   assertDatePass: () => assertDatePass,
   assertDefined: () => assertDefined,
   assertDefinedPass: () => assertDefinedPass,
+  assertError: () => assertError,
+  assertErrorPass: () => assertErrorPass,
   assertFloat32Array: () => assertFloat32Array,
   assertFloat32ArrayPass: () => assertFloat32ArrayPass,
   assertFloat64Array: () => assertFloat64Array,
@@ -82,6 +84,8 @@ __export(type_guards_exports, {
   assertNotDataViewPass: () => assertNotDataViewPass,
   assertNotDate: () => assertNotDate,
   assertNotDatePass: () => assertNotDatePass,
+  assertNotError: () => assertNotError,
+  assertNotErrorPass: () => assertNotErrorPass,
   assertNotFloat32Array: () => assertNotFloat32Array,
   assertNotFloat32ArrayPass: () => assertNotFloat32ArrayPass,
   assertNotFloat64Array: () => assertNotFloat64Array,
@@ -188,6 +192,7 @@ __export(type_guards_exports, {
   isDataView: () => isDataView,
   isDate: () => isDate,
   isDefined: () => isDefined,
+  isError: () => isError,
   isFloat32Array: () => isFloat32Array,
   isFloat64Array: () => isFloat64Array,
   isFunction: () => isFunction,
@@ -207,6 +212,7 @@ __export(type_guards_exports, {
   isNotBoolean: () => isNotBoolean,
   isNotDataView: () => isNotDataView,
   isNotDate: () => isNotDate,
+  isNotError: () => isNotError,
   isNotFloat32Array: () => isNotFloat32Array,
   isNotFloat64Array: () => isNotFloat64Array,
   isNotFunction: () => isNotFunction,
@@ -1048,3 +1054,23 @@ function assertNotReadableStreamPass(value, message) {
   assertNotReadableStream(value, message);
   return value;
 }
+function isError(value) {
+  return value instanceof Error;
+}
+function isNotError(value) {
+  return !isError(value);
+}
+function assertError(value, message = "Expected value to be Error.") {
+  assert(isError(value), message);
+}
+function assertNotError(value, message = "Expected value to not be Error.") {
+  assert(isNotError(value), message);
+}
+function assertErrorPass(value, message) {
+  assertError(value, message);
+  return value;
+}
+function assertNotErrorPass(value, message) {
+  assertNotError(value, message);
+  return value;
+}

package/utils/value-or-provider.d.ts

@@ -0,0 +1,2 @@
+export type ValueOrProvider<T> = T extends () => any ? never : T | (() => T);
+export declare function resolveValueOrProvider<T>(valueOrProvider: ValueOrProvider<T>): T;

package/utils/value-or-provider.js

@@ -0,0 +1,30 @@
+"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 value_or_provider_exports = {};
+__export(value_or_provider_exports, {
+  resolveValueOrProvider: () => resolveValueOrProvider
+});
+module.exports = __toCommonJS(value_or_provider_exports);
+var import_type_guards = require("./type-guards.js");
+function resolveValueOrProvider(valueOrProvider) {
+  if ((0, import_type_guards.isFunction)(valueOrProvider)) {
+    return valueOrProvider();
+  }
+  return valueOrProvider;
+}