@tstdl/base 0.85.13 → 0.86.0-beta1

package/utils/clone.js

@@ -1,65 +1,44 @@
-"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);
+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);
 }

package/utils/comparison.js

@@ -1,105 +1,83 @@
-"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 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;
+    };
 }
-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 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;
+    };
 }
-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 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 compareByValueToOrder(order) {
-  return compareByValueSelectionToOrder(order, (item) => item);
+export function compareByValueToOrder(order) {
+    return compareByValueSelectionToOrder(order, (item) => item);
 }
-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");
-    }
-    return compareByValue(indexA, indexB);
-  };
+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 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");
+export 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");
+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');
 }

package/utils/compression.js

@@ -1,129 +1,118 @@
-"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);
+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);
 }
-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)
-  };
+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)
+    };
 }
 async function _compress(buffer, algorithm, options) {
-  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);
-    }
-  });
+    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);
+        }
+    });
 }
-function decompressString(input, encoding, algorithm, options) {
-  const inputBuffer = Buffer.from(input, encoding);
-  return decompress(inputBuffer, algorithm, options);
+export function decompressString(input, encoding, algorithm, options) {
+    const inputBuffer = Buffer.from(input, encoding);
+    return decompress(inputBuffer, algorithm, options);
 }
-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 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 decompressStream(stream, algorithm, options) {
-  const decompressedStream = _decompressStream(stream, algorithm, options);
-  return (0, import_readable_stream_adapter.getReadableStreamFromIterable)(decompressedStream);
+export function decompressStream(stream, algorithm, options) {
+    const decompressedStream = _decompressStream(stream, algorithm, options);
+    return getReadableStreamFromIterable(decompressedStream);
 }
 async function _decompress(buffer, algorithm, options) {
-  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}`);
-    }
-    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);
-    }
-  });
+    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 (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.`);
+    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);
+    }
+    if (supportsReadableStream && (stream instanceof ReadableStream)) {
+        yield* nodeStream.Readable.fromWeb(stream).pipe(decompressor);
+    }
+    throw new NotSupportedError(`Stream type (${stream?.constructor.name ?? (isFunction(stream) ? stream.name : 'unknown type')}) not supported.`);
 }

package/utils/config-parser.js

@@ -1,53 +1,26 @@
-"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 });
+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
 };
-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 boolean(variable, defaultValue) {
+    return string(variable, defaultValue, configValidators.boolean, (value) => ['true', 'yes', '1'].includes(value.toLowerCase()));
 }
-function integer(variable, defaultValue) {
-  return string(variable, defaultValue, configValidators.integer, (value) => parseInt(value, 10));
+export function integer(variable, defaultValue) {
+    return string(variable, defaultValue, configValidators.integer, (value) => parseInt(value, 10));
 }
-function positiveInteger(variable, defaultValue) {
-  return string(variable, defaultValue, configValidators.positiveInteger, (value) => parseInt(value, 10));
+export function positiveInteger(variable, defaultValue) {
+    return string(variable, defaultValue, configValidators.positiveInteger, (value) => parseInt(value, 10));
 }
-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);
+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);
 }