@tstdl/base 0.83.0-beta2 → 0.83.0-beta4

package/utils/clone.js

@@ -1,45 +1,65 @@
-import { supportsStructuredClone } from '../supports.js';
-import { objectEntries } from './object/object.js';
-import { assertObject, isArray, isArrayBuffer, isDataView, isDate, isMap, isPrimitive, isRegExp, isSet, isTypedArray } from './type-guards.js';
-export function clone(object, deep) {
-    if (supportsStructuredClone && deep) {
-        return structuredClone(object);
-    }
-    if (isPrimitive(object)) {
-        return object;
-    }
-    if (isDate(object)) {
-        return new Date(object);
-    }
-    if (isRegExp(object)) {
-        return new RegExp(object.source, object.flags);
-    }
-    if (isSet(object)) {
-        return new Set(object);
-    }
-    if (isMap(object)) {
-        return new Map(object);
-    }
-    if (isArrayBuffer(object)) {
-        return object.slice(0);
-    }
-    if (isTypedArray(object)) {
-        return object.slice();
-    }
-    if (isDataView(object)) {
-        const clonedBuffer = object.buffer.slice(0);
-        return new DataView(clonedBuffer, object.byteOffset, object.byteLength);
-    }
-    if (isArray(object)) {
-        return deep
-            ? object.map((value) => clone(value, true))
-            : [...object];
-    }
-    assertObject(object);
-    if (!deep) {
-        return { ...object };
-    }
-    const entries = objectEntries(object).map(([key, value]) => [key, clone(value, true)]);
-    return Object.fromEntries(entries);
+"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 clone_exports = {};
+__export(clone_exports, {
+  clone: () => clone
+});
+module.exports = __toCommonJS(clone_exports);
+var import_supports = require("../supports.js");
+var import_object = require("./object/object.js");
+var import_type_guards = require("./type-guards.js");
+function clone(object, deep) {
+  if (import_supports.supportsStructuredClone && deep) {
+    return structuredClone(object);
+  }
+  if ((0, import_type_guards.isPrimitive)(object)) {
+    return object;
+  }
+  if ((0, import_type_guards.isDate)(object)) {
+    return new Date(object);
+  }
+  if ((0, import_type_guards.isRegExp)(object)) {
+    return new RegExp(object.source, object.flags);
+  }
+  if ((0, import_type_guards.isSet)(object)) {
+    return new Set(object);
+  }
+  if ((0, import_type_guards.isMap)(object)) {
+    return new Map(object);
+  }
+  if ((0, import_type_guards.isArrayBuffer)(object)) {
+    return object.slice(0);
+  }
+  if ((0, import_type_guards.isTypedArray)(object)) {
+    return object.slice();
+  }
+  if ((0, import_type_guards.isDataView)(object)) {
+    const clonedBuffer = object.buffer.slice(0);
+    return new DataView(clonedBuffer, object.byteOffset, object.byteLength);
+  }
+  if ((0, import_type_guards.isArray)(object)) {
+    return deep ? object.map((value) => clone(value, true)) : [...object];
+  }
+  (0, import_type_guards.assertObject)(object);
+  if (!deep) {
+    return { ...object };
+  }
+  const entries = (0, import_object.objectEntries)(object).map(([key, value]) => [key, clone(value, true)]);
+  return Object.fromEntries(entries);
 }
-//# sourceMappingURL=clone.js.map

package/utils/comparison.js

@@ -1,84 +1,105 @@
-export function compareByValueSelection(...selectors) {
-    return (a, b) => {
-        for (const selector of selectors) {
-            const selectedA = selector(a);
-            const selectedB = selector(b);
-            const comparison = compareByValue(selectedA, selectedB);
-            if (comparison != 0) {
-                return comparison;
-            }
-        }
-        return 0;
-    };
-}
-export function compareByValueSelectionDescending(...selectors) {
-    return (a, b) => {
-        for (const selector of selectors) {
-            const selectedA = selector(a);
-            const selectedB = selector(b);
-            const comparison = compareByValueDescending(selectedA, selectedB);
-            if (comparison != 0) {
-                return comparison;
-            }
-        }
-        return 0;
-    };
+"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 comparison_exports = {};
+__export(comparison_exports, {
+  compareByValue: () => compareByValue,
+  compareByValueDescending: () => compareByValueDescending,
+  compareByValueSelection: () => compareByValueSelection,
+  compareByValueSelectionDescending: () => compareByValueSelectionDescending,
+  compareByValueSelectionOrdered: () => compareByValueSelectionOrdered,
+  compareByValueSelectionToOrder: () => compareByValueSelectionToOrder,
+  compareByValueToOrder: () => compareByValueToOrder
+});
+module.exports = __toCommonJS(comparison_exports);
+function compareByValueSelection(...selectors) {
+  return (a, b) => {
+    for (const selector of selectors) {
+      const selectedA = selector(a);
+      const selectedB = selector(b);
+      const comparison = compareByValue(selectedA, selectedB);
+      if (comparison != 0) {
+        return comparison;
+      }
+    }
+    return 0;
+  };
 }
-export function compareByValueSelectionOrdered(...selectors) {
-    return (a, b) => {
-        for (const [selector, order] of selectors) {
-            const selectedA = selector(a);
-            const selectedB = selector(b);
-            const comparison = (order == 1)
-                ? compareByValue(selectedA, selectedB)
-                : compareByValueDescending(selectedA, selectedB);
-            if (comparison != 0) {
-                return comparison;
-            }
-        }
-        return 0;
-    };
+function compareByValueSelectionDescending(...selectors) {
+  return (a, b) => {
+    for (const selector of selectors) {
+      const selectedA = selector(a);
+      const selectedB = selector(b);
+      const comparison = compareByValueDescending(selectedA, selectedB);
+      if (comparison != 0) {
+        return comparison;
+      }
+    }
+    return 0;
+  };
 }
-export function compareByValueToOrder(order) {
-    return compareByValueSelectionToOrder(order, (item) => item);
+function compareByValueSelectionOrdered(...selectors) {
+  return (a, b) => {
+    for (const [selector, order] of selectors) {
+      const selectedA = selector(a);
+      const selectedB = selector(b);
+      const comparison = order == 1 ? compareByValue(selectedA, selectedB) : compareByValueDescending(selectedA, selectedB);
+      if (comparison != 0) {
+        return comparison;
+      }
+    }
+    return 0;
+  };
 }
-export function compareByValueSelectionToOrder(order, selector) {
-    const indexMapEntries = order.map((orderItem, index) => [orderItem, index]);
-    const indexMap = new Map(indexMapEntries);
-    // eslint-disable-next-line @typescript-eslint/no-shadow
-    return function compareByValueSelectionToOrder(a, b) {
-        const selectedA = selector(a);
-        const selectedB = selector(b);
-        const indexA = indexMap.get(selectedA);
-        const indexB = indexMap.get(selectedB);
-        if (indexA == undefined || indexB == undefined) {
-            throw new Error('value not defined in order');
-        }
-        return compareByValue(indexA, indexB);
-    };
+function compareByValueToOrder(order) {
+  return compareByValueSelectionToOrder(order, (item) => item);
 }
-export function compareByValue(a, b) {
-    if (a === b) {
-        return 0;
-    }
-    else if (a > b) {
-        return 1;
+function compareByValueSelectionToOrder(order, selector) {
+  const indexMapEntries = order.map((orderItem, index) => [orderItem, index]);
+  const indexMap = new Map(indexMapEntries);
+  return function compareByValueSelectionToOrder2(a, b) {
+    const selectedA = selector(a);
+    const selectedB = selector(b);
+    const indexA = indexMap.get(selectedA);
+    const indexB = indexMap.get(selectedB);
+    if (indexA == void 0 || indexB == void 0) {
+      throw new Error("value not defined in order");
     }
-    else if (b > a) {
-        return -1;
-    }
-    throw new Error('objects not comparable');
+    return compareByValue(indexA, indexB);
+  };
 }
-export function compareByValueDescending(a, b) {
-    if (a === b) {
-        return 0;
-    }
-    else if (a > b) {
-        return -1;
-    }
-    else if (b > a) {
-        return 1;
-    }
-    throw new Error('objects not comparable');
+function compareByValue(a, b) {
+  if (a === b) {
+    return 0;
+  } else if (a > b) {
+    return 1;
+  } else if (b > a) {
+    return -1;
+  }
+  throw new Error("objects not comparable");
+}
+function compareByValueDescending(a, b) {
+  if (a === b) {
+    return 0;
+  } else if (a > b) {
+    return -1;
+  } else if (b > a) {
+    return 1;
+  }
+  throw new Error("objects not comparable");
 }
-//# sourceMappingURL=comparison.js.map

package/utils/compression.js

@@ -1,119 +1,129 @@
-import { NotSupportedError } from '../error/not-supported.error.js';
-import { dynamicImport } from '../import.js';
-import { supportsReadableStream } from '../supports.js';
-import { isAsyncIterable } from './async-iterable-helpers/is-async-iterable.js';
-import { encodeBase64, encodeBase64Url } from './base64.js';
-import { decodeText, encodeHex, encodeUtf8 } from './encoding.js';
-import { getReadableStreamFromIterable } from './stream/readable-stream-adapter.js';
-import { isFunction } from './type-guards.js';
-import { zBase32Encode } from './z-base32.js';
-export function compressString(input, algorithm, options) {
-    const inputBuffer = encodeUtf8(input);
-    return compress(inputBuffer, algorithm, options);
+"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 compression_exports = {};
+__export(compression_exports, {
+  compress: () => compress,
+  compressString: () => compressString,
+  decompress: () => decompress,
+  decompressStream: () => decompressStream,
+  decompressString: () => decompressString
+});
+module.exports = __toCommonJS(compression_exports);
+var import_not_supported_error = require("../error/not-supported.error.js");
+var import_import = require("../import.js");
+var import_supports = require("../supports.js");
+var import_is_async_iterable = require("./async-iterable-helpers/is-async-iterable.js");
+var import_base64 = require("./base64.js");
+var import_encoding = require("./encoding.js");
+var import_readable_stream_adapter = require("./stream/readable-stream-adapter.js");
+var import_type_guards = require("./type-guards.js");
+var import_z_base32 = require("./z-base32.js");
+function compressString(input, algorithm, options) {
+  const inputBuffer = (0, import_encoding.encodeUtf8)(input);
+  return compress(inputBuffer, algorithm, options);
 }
-export function compress(buffer, algorithm, options) {
-    const compressedBuffer = _compress(buffer, algorithm, options);
-    return {
-        toBuffer: async () => compressedBuffer,
-        toHex: async () => encodeHex(await compressedBuffer),
-        toBase64: async () => encodeBase64(await compressedBuffer),
-        toBase64Url: async () => encodeBase64Url(await compressedBuffer),
-        toZBase32: async () => zBase32Encode(await compressedBuffer)
-    };
+function compress(buffer, algorithm, options) {
+  const compressedBuffer = _compress(buffer, algorithm, options);
+  return {
+    toBuffer: async () => compressedBuffer,
+    toHex: async () => (0, import_encoding.encodeHex)(await compressedBuffer),
+    toBase64: async () => (0, import_base64.encodeBase64)(await compressedBuffer),
+    toBase64Url: async () => (0, import_base64.encodeBase64Url)(await compressedBuffer),
+    toZBase32: async () => (0, import_z_base32.zBase32Encode)(await compressedBuffer)
+  };
 }
 async function _compress(buffer, algorithm, options) {
-    const zlib = await dynamicImport('zlib');
-    return new Promise((resolve, reject) => {
-        const compressor = algorithm == 'gzip' ? zlib.gzip
-            : algorithm == 'brotli' ? zlib.brotliDecompress
-                : algorithm == 'deflate' ? zlib.deflate
-                    : algorithm == 'deflate-raw' ? zlib.deflateRaw // eslint-disable-line @typescript-eslint/no-unnecessary-condition
-                        : undefined;
-        if (compressor == undefined) {
-            throw new Error(`unsupported algorithm ${algorithm}`);
-        }
-        const callback = (error, result) => {
-            if (error != undefined) {
-                reject(error);
-            }
-            else {
-                resolve(result);
-            }
-        };
-        if (options == undefined) {
-            compressor(buffer, callback);
-        }
-        else {
-            compressor(buffer, options, callback);
-        }
-    });
+  const zlib = await (0, import_import.dynamicImport)("zlib");
+  return new Promise((resolve, reject) => {
+    const compressor = algorithm == "gzip" ? zlib.gzip : algorithm == "brotli" ? zlib.brotliDecompress : algorithm == "deflate" ? zlib.deflate : algorithm == "deflate-raw" ? zlib.deflateRaw : void 0;
+    if (compressor == void 0) {
+      throw new Error(`unsupported algorithm ${algorithm}`);
+    }
+    const callback = (error, result) => {
+      if (error != void 0) {
+        reject(error);
+      } else {
+        resolve(result);
+      }
+    };
+    if (options == void 0) {
+      compressor(buffer, callback);
+    } else {
+      compressor(buffer, options, callback);
+    }
+  });
 }
-export function decompressString(input, encoding, algorithm, options) {
-    const inputBuffer = Buffer.from(input, encoding);
-    return decompress(inputBuffer, algorithm, options);
+function decompressString(input, encoding, algorithm, options) {
+  const inputBuffer = Buffer.from(input, encoding);
+  return decompress(inputBuffer, algorithm, options);
 }
-export function decompress(buffer, algorithm, options) {
-    const decompressedBuffer = _decompress(buffer, algorithm, options);
-    return {
-        toBuffer: async () => decompressedBuffer,
-        toHex: async () => encodeHex(await decompressedBuffer),
-        toBase64: async () => encodeBase64(await decompressedBuffer),
-        toBase64Url: async () => encodeBase64Url(await decompressedBuffer),
-        toZBase32: async () => zBase32Encode(await decompressedBuffer),
-        toUtf8: async () => decodeText(await decompressedBuffer)
-    };
+function decompress(buffer, algorithm, options) {
+  const decompressedBuffer = _decompress(buffer, algorithm, options);
+  return {
+    toBuffer: async () => decompressedBuffer,
+    toHex: async () => (0, import_encoding.encodeHex)(await decompressedBuffer),
+    toBase64: async () => (0, import_base64.encodeBase64)(await decompressedBuffer),
+    toBase64Url: async () => (0, import_base64.encodeBase64Url)(await decompressedBuffer),
+    toZBase32: async () => (0, import_z_base32.zBase32Encode)(await decompressedBuffer),
+    toUtf8: async () => (0, import_encoding.decodeText)(await decompressedBuffer)
+  };
 }
-export function decompressStream(stream, algorithm, options) {
-    const decompressedStream = _decompressStream(stream, algorithm, options);
-    return getReadableStreamFromIterable(decompressedStream);
+function decompressStream(stream, algorithm, options) {
+  const decompressedStream = _decompressStream(stream, algorithm, options);
+  return (0, import_readable_stream_adapter.getReadableStreamFromIterable)(decompressedStream);
 }
 async function _decompress(buffer, algorithm, options) {
-    const zlib = await dynamicImport('zlib');
-    return new Promise((resolve, reject) => {
-        const decompressor = algorithm == 'gzip' ? zlib.gunzip
-            : algorithm == 'brotli' ? zlib.brotliDecompress
-                : algorithm == 'deflate' ? zlib.inflate
-                    : algorithm == 'deflate-raw' ? zlib.inflateRaw // eslint-disable-line @typescript-eslint/no-unnecessary-condition
-                        : undefined;
-        if (decompressor == undefined) {
-            throw new Error(`unsupported algorithm ${algorithm}`);
-        }
-        const callback = (error, result) => {
-            if (error != undefined) {
-                reject(error);
-            }
-            else {
-                resolve(result);
-            }
-        };
-        if (options == undefined) {
-            decompressor(buffer, callback);
-        }
-        else {
-            decompressor(buffer, options, callback);
-        }
-    });
-}
-async function* _decompressStream(stream, algorithm, options) {
-    const zlib = await dynamicImport('zlib');
-    const nodeStream = await dynamicImport('stream');
-    const decompressor = algorithm == 'gzip' ? zlib.createGunzip(options)
-        : algorithm == 'brotli' ? zlib.createBrotliDecompress(options)
-            : algorithm == 'deflate' ? zlib.createInflate(options)
-                : algorithm == 'deflate-raw' ? zlib.createInflateRaw(options) // eslint-disable-line @typescript-eslint/no-unnecessary-condition
-                    : undefined;
-    if (decompressor == undefined) {
-        throw new Error(`unsupported algorithm ${algorithm}`);
-    }
-    if (stream instanceof nodeStream.Stream) {
-        yield* stream.pipe(decompressor);
-    }
-    if (isAsyncIterable(stream)) {
-        yield* nodeStream.Readable.from(stream).pipe(decompressor);
+  const zlib = await (0, import_import.dynamicImport)("zlib");
+  return new Promise((resolve, reject) => {
+    const decompressor = algorithm == "gzip" ? zlib.gunzip : algorithm == "brotli" ? zlib.brotliDecompress : algorithm == "deflate" ? zlib.inflate : algorithm == "deflate-raw" ? zlib.inflateRaw : void 0;
+    if (decompressor == void 0) {
+      throw new Error(`unsupported algorithm ${algorithm}`);
     }
-    if (supportsReadableStream && (stream instanceof ReadableStream)) {
-        yield* nodeStream.Readable.fromWeb(stream).pipe(decompressor);
+    const callback = (error, result) => {
+      if (error != void 0) {
+        reject(error);
+      } else {
+        resolve(result);
+      }
+    };
+    if (options == void 0) {
+      decompressor(buffer, callback);
+    } else {
+      decompressor(buffer, options, callback);
     }
-    throw new NotSupportedError(`Stream type (${stream?.constructor.name ?? (isFunction(stream) ? stream.name : 'unknown type')}) not supported.`);
+  });
+}
+async function* _decompressStream(stream, algorithm, options) {
+  const zlib = await (0, import_import.dynamicImport)("zlib");
+  const nodeStream = await (0, import_import.dynamicImport)("stream");
+  const decompressor = algorithm == "gzip" ? zlib.createGunzip(options) : algorithm == "brotli" ? zlib.createBrotliDecompress(options) : algorithm == "deflate" ? zlib.createInflate(options) : algorithm == "deflate-raw" ? zlib.createInflateRaw(options) : void 0;
+  if (decompressor == void 0) {
+    throw new Error(`unsupported algorithm ${algorithm}`);
+  }
+  if (stream instanceof nodeStream.Stream) {
+    yield* stream.pipe(decompressor);
+  }
+  if ((0, import_is_async_iterable.isAsyncIterable)(stream)) {
+    yield* nodeStream.Readable.from(stream).pipe(decompressor);
+  }
+  if (import_supports.supportsReadableStream && stream instanceof ReadableStream) {
+    yield* nodeStream.Readable.fromWeb(stream).pipe(decompressor);
+  }
+  throw new import_not_supported_error.NotSupportedError(`Stream type (${stream?.constructor.name ?? ((0, import_type_guards.isFunction)(stream) ? stream.name : "unknown type")}) not supported.`);
 }
-//# sourceMappingURL=compression.js.map

package/utils/config-parser.js

@@ -1,27 +1,53 @@
-import { isUndefined } from './type-guards.js';
-export const configValidators = {
-    integer: /^-?\d+$/u,
-    positiveInteger: /^[1-9]\d*$/u,
-    boolean: /true|false|yes|no|0|1/ui
+"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 });
 };
-export function boolean(variable, defaultValue) {
-    return string(variable, defaultValue, configValidators.boolean, (value) => ['true', 'yes', '1'].includes(value.toLowerCase()));
+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 config_parser_exports = {};
+__export(config_parser_exports, {
+  boolean: () => boolean,
+  configValidators: () => configValidators,
+  integer: () => integer,
+  positiveInteger: () => positiveInteger,
+  string: () => string
+});
+module.exports = __toCommonJS(config_parser_exports);
+var import_type_guards = require("./type-guards.js");
+const configValidators = {
+  integer: /^-?\d+$/u,
+  positiveInteger: /^[1-9]\d*$/u,
+  boolean: /true|false|yes|no|0|1/ui
+};
+function boolean(variable, defaultValue) {
+  return string(variable, defaultValue, configValidators.boolean, (value) => ["true", "yes", "1"].includes(value.toLowerCase()));
 }
-export function integer(variable, defaultValue) {
-    return string(variable, defaultValue, configValidators.integer, (value) => parseInt(value, 10));
+function integer(variable, defaultValue) {
+  return string(variable, defaultValue, configValidators.integer, (value) => parseInt(value, 10));
 }
-export function positiveInteger(variable, defaultValue) {
-    return string(variable, defaultValue, configValidators.positiveInteger, (value) => parseInt(value, 10));
+function positiveInteger(variable, defaultValue) {
+  return string(variable, defaultValue, configValidators.positiveInteger, (value) => parseInt(value, 10));
 }
-export function string(variable, defaultValue, validator, transformer = (value) => value) {
-    const environmentValue = process.env[variable];
-    if (isUndefined(environmentValue)) {
-        return defaultValue;
-    }
-    const valid = isUndefined(validator) ? true : validator.test(environmentValue);
-    if (!valid) {
-        throw new Error(`invalid value for ${variable}`);
-    }
-    return transformer(environmentValue);
+function string(variable, defaultValue, validator, transformer = (value) => value) {
+  const environmentValue = process.env[variable];
+  if ((0, import_type_guards.isUndefined)(environmentValue)) {
+    return defaultValue;
+  }
+  const valid = (0, import_type_guards.isUndefined)(validator) ? true : validator.test(environmentValue);
+  if (!valid) {
+    throw new Error(`invalid value for ${variable}`);
+  }
+  return transformer(environmentValue);
 }
-//# sourceMappingURL=config-parser.js.map