@percepta/utils 0.1.8 → 0.1.11

package/dist/utils/zodKeyedTypeUnion.cjs

@@ -0,0 +1,16 @@
+let zod = require("zod");
+//#region src/utils/zodKeyedTypeUnion.ts
+function zodKeyedTypeUnion(schemasByType, typeKey = "type") {
+	/**
+	* There are a lot of casts here because of our fancy generics.
+	* We won't worry about them for now; we'll just use our tests to ensure runtime safety.
+	*/
+	return zod.z.discriminatedUnion(typeKey, Object.entries(schemasByType).map(([type, schema]) => zod.z.object({
+		[typeKey]: zod.z.literal(type),
+		[type]: schema
+	})));
+}
+//#endregion
+exports.zodKeyedTypeUnion = zodKeyedTypeUnion;
+
+//# sourceMappingURL=zodKeyedTypeUnion.cjs.map

package/dist/utils/zodKeyedTypeUnion.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"zodKeyedTypeUnion.cjs","names":["z"],"sources":["../../src/utils/zodKeyedTypeUnion.ts"],"sourcesContent":["import { type KeyedTypeUnion, type ValueForTypeKey } from \"keyed-type-union\";\nimport { z } from \"zod\";\n\ntype SchemasByType<\n  TTypeUnion extends KeyedTypeUnion<Record<string, unknown>, TTypeKey>,\n  TTypeKey extends string = \"type\",\n> = {\n  [TType in TTypeUnion[TTypeKey]]: z.ZodType<\n    ValueForTypeKey<TTypeUnion, TType, TTypeKey>\n  >;\n};\n\n/**\n * Creates a Zod schema for a discriminated union of type-union types.\n * We can use this util alongside keyed-type-union for stricter type union patterns.\n *\n * @param schemasByType A record of type keys to their corresponding Zod schemas.\n * @param typeKey The optional key used to discriminate between the different types in the union.\n * @returns A Zod schema for the discriminated union.\n */\nexport function zodKeyedTypeUnion<\n  TTypeUnion extends KeyedTypeUnion<Record<string, unknown>>,\n>(schemasByType: SchemasByType<TTypeUnion>): z.ZodType<TTypeUnion>;\nexport function zodKeyedTypeUnion<\n  TTypeUnion extends KeyedTypeUnion<Record<string, unknown>, TTypeKey>,\n  TTypeKey extends string,\n>(\n  schemasByType: SchemasByType<TTypeUnion, TTypeKey>,\n  typeKey: TTypeKey,\n): z.ZodType<TTypeUnion>;\nexport function zodKeyedTypeUnion<\n  TTypeUnion extends KeyedTypeUnion<Record<string, unknown>, TTypeKey>,\n  TTypeKey extends string,\n>(\n  schemasByType: SchemasByType<TTypeUnion, TTypeKey>,\n  typeKey: TTypeKey = \"type\" as never,\n): z.ZodType<TTypeUnion> {\n  /**\n   * There are a lot of casts here because of our fancy generics.\n   * We won't worry about them for now; we'll just use our tests to ensure runtime safety.\n   */\n  return z.discriminatedUnion(\n    typeKey,\n    Object.entries(schemasByType).map(([type, schema]) =>\n      z.object({\n        [typeKey]: z.literal(type),\n        [type]: schema as never,\n      }),\n    ) as never,\n  ) as never;\n}\n"],"mappings":";;AA8BA,SAAgB,kBAId,eACA,UAAoB,QACG;;;;;AAKvB,QAAOA,IAAAA,EAAE,mBACP,SACA,OAAO,QAAQ,cAAc,CAAC,KAAK,CAAC,MAAM,YACxCA,IAAAA,EAAE,OAAO;GACN,UAAUA,IAAAA,EAAE,QAAQ,KAAK;GACzB,OAAO;EACT,CAAC,CACH,CACF"}

package/dist/utils/zodKeyedTypeUnion.d.cts

@@ -0,0 +1,18 @@
+import { KeyedTypeUnion, ValueForTypeKey } from "keyed-type-union";
+import { z } from "zod";
+
+//#region src/utils/zodKeyedTypeUnion.d.ts
+type SchemasByType<TTypeUnion extends KeyedTypeUnion<Record<string, unknown>, TTypeKey>, TTypeKey extends string = "type"> = { [TType in TTypeUnion[TTypeKey]]: z.ZodType<ValueForTypeKey<TTypeUnion, TType, TTypeKey>> };
+/**
+ * Creates a Zod schema for a discriminated union of type-union types.
+ * We can use this util alongside keyed-type-union for stricter type union patterns.
+ *
+ * @param schemasByType A record of type keys to their corresponding Zod schemas.
+ * @param typeKey The optional key used to discriminate between the different types in the union.
+ * @returns A Zod schema for the discriminated union.
+ */
+declare function zodKeyedTypeUnion<TTypeUnion extends KeyedTypeUnion<Record<string, unknown>>>(schemasByType: SchemasByType<TTypeUnion>): z.ZodType<TTypeUnion>;
+declare function zodKeyedTypeUnion<TTypeUnion extends KeyedTypeUnion<Record<string, unknown>, TTypeKey>, TTypeKey extends string>(schemasByType: SchemasByType<TTypeUnion, TTypeKey>, typeKey: TTypeKey): z.ZodType<TTypeUnion>;
+//#endregion
+export { zodKeyedTypeUnion };
+//# sourceMappingURL=zodKeyedTypeUnion.d.cts.map

package/dist/utils/zodKeyedTypeUnion.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zodKeyedTypeUnion.d.cts","names":[],"sources":["../../src/utils/zodKeyedTypeUnion.ts"],"mappings":";;;;KAGK,aAAA,oBACgB,cAAA,CAAe,MAAA,mBAAyB,QAAA,mDAGjD,UAAA,CAAW,QAAA,IAAY,CAAA,CAAE,OAAA,CACjC,eAAA,CAAgB,UAAA,EAAY,KAAA,EAAO,QAAA;;;;;;;;;iBAYvB,iBAAA,oBACK,cAAA,CAAe,MAAA,mBAAA,CAClC,aAAA,EAAe,aAAA,CAAc,UAAA,IAAc,CAAA,CAAE,OAAA,CAAQ,UAAA;AAAA,iBACvC,iBAAA,oBACK,cAAA,CAAe,MAAA,mBAAyB,QAAA,2BAAA,CAG3D,aAAA,EAAe,aAAA,CAAc,UAAA,EAAY,QAAA,GACzC,OAAA,EAAS,QAAA,GACR,CAAA,CAAE,OAAA,CAAQ,UAAA"}

package/dist/utils/zodKeyedTypeUnion.d.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import { KeyedTypeUnion, ValueForTypeKey } from "keyed-type-union";
+
+//#region src/utils/zodKeyedTypeUnion.d.ts
+type SchemasByType<TTypeUnion extends KeyedTypeUnion<Record<string, unknown>, TTypeKey>, TTypeKey extends string = "type"> = { [TType in TTypeUnion[TTypeKey]]: z.ZodType<ValueForTypeKey<TTypeUnion, TType, TTypeKey>> };
+/**
+ * Creates a Zod schema for a discriminated union of type-union types.
+ * We can use this util alongside keyed-type-union for stricter type union patterns.
+ *
+ * @param schemasByType A record of type keys to their corresponding Zod schemas.
+ * @param typeKey The optional key used to discriminate between the different types in the union.
+ * @returns A Zod schema for the discriminated union.
+ */
+declare function zodKeyedTypeUnion<TTypeUnion extends KeyedTypeUnion<Record<string, unknown>>>(schemasByType: SchemasByType<TTypeUnion>): z.ZodType<TTypeUnion>;
+declare function zodKeyedTypeUnion<TTypeUnion extends KeyedTypeUnion<Record<string, unknown>, TTypeKey>, TTypeKey extends string>(schemasByType: SchemasByType<TTypeUnion, TTypeKey>, typeKey: TTypeKey): z.ZodType<TTypeUnion>;
+//#endregion
+export { zodKeyedTypeUnion };
+//# sourceMappingURL=zodKeyedTypeUnion.d.ts.map

package/dist/utils/zodKeyedTypeUnion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zodKeyedTypeUnion.d.ts","names":[],"sources":["../../src/utils/zodKeyedTypeUnion.ts"],"mappings":";;;;KAGK,aAAA,oBACgB,cAAA,CAAe,MAAA,mBAAyB,QAAA,mDAGjD,UAAA,CAAW,QAAA,IAAY,CAAA,CAAE,OAAA,CACjC,eAAA,CAAgB,UAAA,EAAY,KAAA,EAAO,QAAA;;;;;;;;;iBAYvB,iBAAA,oBACK,cAAA,CAAe,MAAA,mBAAA,CAClC,aAAA,EAAe,aAAA,CAAc,UAAA,IAAc,CAAA,CAAE,OAAA,CAAQ,UAAA;AAAA,iBACvC,iBAAA,oBACK,cAAA,CAAe,MAAA,mBAAyB,QAAA,2BAAA,CAG3D,aAAA,EAAe,aAAA,CAAc,UAAA,EAAY,QAAA,GACzC,OAAA,EAAS,QAAA,GACR,CAAA,CAAE,OAAA,CAAQ,UAAA"}

package/dist/utils/zodKeyedTypeUnion.js

@@ -0,0 +1,16 @@
+import { z } from "zod";
+//#region src/utils/zodKeyedTypeUnion.ts
+function zodKeyedTypeUnion(schemasByType, typeKey = "type") {
+	/**
+	* There are a lot of casts here because of our fancy generics.
+	* We won't worry about them for now; we'll just use our tests to ensure runtime safety.
+	*/
+	return z.discriminatedUnion(typeKey, Object.entries(schemasByType).map(([type, schema]) => z.object({
+		[typeKey]: z.literal(type),
+		[type]: schema
+	})));
+}
+//#endregion
+export { zodKeyedTypeUnion };
+
+//# sourceMappingURL=zodKeyedTypeUnion.js.map

package/dist/utils/zodKeyedTypeUnion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zodKeyedTypeUnion.js","names":[],"sources":["../../src/utils/zodKeyedTypeUnion.ts"],"sourcesContent":["import { type KeyedTypeUnion, type ValueForTypeKey } from \"keyed-type-union\";\nimport { z } from \"zod\";\n\ntype SchemasByType<\n  TTypeUnion extends KeyedTypeUnion<Record<string, unknown>, TTypeKey>,\n  TTypeKey extends string = \"type\",\n> = {\n  [TType in TTypeUnion[TTypeKey]]: z.ZodType<\n    ValueForTypeKey<TTypeUnion, TType, TTypeKey>\n  >;\n};\n\n/**\n * Creates a Zod schema for a discriminated union of type-union types.\n * We can use this util alongside keyed-type-union for stricter type union patterns.\n *\n * @param schemasByType A record of type keys to their corresponding Zod schemas.\n * @param typeKey The optional key used to discriminate between the different types in the union.\n * @returns A Zod schema for the discriminated union.\n */\nexport function zodKeyedTypeUnion<\n  TTypeUnion extends KeyedTypeUnion<Record<string, unknown>>,\n>(schemasByType: SchemasByType<TTypeUnion>): z.ZodType<TTypeUnion>;\nexport function zodKeyedTypeUnion<\n  TTypeUnion extends KeyedTypeUnion<Record<string, unknown>, TTypeKey>,\n  TTypeKey extends string,\n>(\n  schemasByType: SchemasByType<TTypeUnion, TTypeKey>,\n  typeKey: TTypeKey,\n): z.ZodType<TTypeUnion>;\nexport function zodKeyedTypeUnion<\n  TTypeUnion extends KeyedTypeUnion<Record<string, unknown>, TTypeKey>,\n  TTypeKey extends string,\n>(\n  schemasByType: SchemasByType<TTypeUnion, TTypeKey>,\n  typeKey: TTypeKey = \"type\" as never,\n): z.ZodType<TTypeUnion> {\n  /**\n   * There are a lot of casts here because of our fancy generics.\n   * We won't worry about them for now; we'll just use our tests to ensure runtime safety.\n   */\n  return z.discriminatedUnion(\n    typeKey,\n    Object.entries(schemasByType).map(([type, schema]) =>\n      z.object({\n        [typeKey]: z.literal(type),\n        [type]: schema as never,\n      }),\n    ) as never,\n  ) as never;\n}\n"],"mappings":";;AA8BA,SAAgB,kBAId,eACA,UAAoB,QACG;;;;;AAKvB,QAAO,EAAE,mBACP,SACA,OAAO,QAAQ,cAAc,CAAC,KAAK,CAAC,MAAM,YACxC,EAAE,OAAO;GACN,UAAU,EAAE,QAAQ,KAAK;GACzB,OAAO;EACT,CAAC,CACH,CACF"}

package/package.json

@@ -1,18 +1,32 @@
 {
   "name": "@percepta/utils",
-  "version": "0.1.8",
+  "version": "0.1.11",
   "private": false,
-  "publishConfig": {
-    "access": "public"
-  },
   "description": "Shared utils for Mosaic",
-  "sideEffects": false,
-  "main": "dist/cjs/index.js",
-  "module": "dist/esnext/index.js",
-  "types": "dist/esnext/index.d.ts",
   "files": [
-    "dist/**/*"
+    "dist"
   ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
   "dependencies": {
     "keyed-type-union": "^0.1.0",
     "lodash-es": "^4.17.21",
@@ -20,17 +34,13 @@
   },
   "devDependencies": {
     "@types/lodash-es": "^4.17.12",
-    "@percepta/build": "0.2.2"
-  },
-  "lint-staged": {
-    "**/*.ts": "eslint --fix"
+    "@percepta/build": "0.5.0"
   },
   "scripts": {
-    "build": "build-ts --high-compat",
-    "dev": "pnpm build --watch",
+    "build": "tsdown",
+    "dev": "tsdown --watch",
     "clean": "rimraf dist",
-    "lint": "eslint .",
-    "lint:fix": "eslint . --fix",
-    "test": "jest"
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
   }
 }

package/dist/cjs/config/getEnvConfig.d.ts

@@ -1,164 +0,0 @@
-import { z } from "zod";
-export declare const BASE_ENV_SCHEMA: z.ZodObject<{
-    NODE_ENV: z.ZodDefault<z.ZodEnum<{
-        development: "development";
-        production: "production";
-        test: "test";
-    }>>;
-    LOG_LEVEL: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodEnum<{
-        debug: "debug";
-        info: "info";
-        warn: "warn";
-        error: "error";
-    }>>>;
-}, z.core.$strip>;
-export type BaseEnvConfig = z.infer<typeof BASE_ENV_SCHEMA>;
-export declare function createEnvConfig<TExtension extends z.ZodRawShape>(extensionSchema: z.ZodObject<TExtension>): {
-    getEnvConfig: () => z.core.$InferObjectOutput<(("NODE_ENV" | "LOG_LEVEL") & keyof TExtension extends never ? {
-        NODE_ENV: z.ZodDefault<z.ZodEnum<{
-            development: "development";
-            production: "production";
-            test: "test";
-        }>>;
-        LOG_LEVEL: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodEnum<{
-            debug: "debug";
-            info: "info";
-            warn: "warn";
-            error: "error";
-        }>>>;
-    } & TExtension : ({
-        NODE_ENV: z.ZodDefault<z.ZodEnum<{
-            development: "development";
-            production: "production";
-            test: "test";
-        }>>;
-        LOG_LEVEL: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodEnum<{
-            debug: "debug";
-            info: "info";
-            warn: "warn";
-            error: "error";
-        }>>>;
-    } extends infer T_2 extends z.core.util.SomeObject ? { [K in keyof T_2 as K extends keyof TExtension ? never : K]: {
-        NODE_ENV: z.ZodDefault<z.ZodEnum<{
-            development: "development";
-            production: "production";
-            test: "test";
-        }>>;
-        LOG_LEVEL: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodEnum<{
-            debug: "debug";
-            info: "info";
-            warn: "warn";
-            error: "error";
-        }>>>;
-    }[K]; } : never) & { [K_1 in keyof TExtension]: TExtension[K_1]; }) extends infer T ? { [k in keyof T]: (("NODE_ENV" | "LOG_LEVEL") & keyof TExtension extends never ? {
-        NODE_ENV: z.ZodDefault<z.ZodEnum<{
-            development: "development";
-            production: "production";
-            test: "test";
-        }>>;
-        LOG_LEVEL: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodEnum<{
-            debug: "debug";
-            info: "info";
-            warn: "warn";
-            error: "error";
-        }>>>;
-    } & TExtension : ({
-        NODE_ENV: z.ZodDefault<z.ZodEnum<{
-            development: "development";
-            production: "production";
-            test: "test";
-        }>>;
-        LOG_LEVEL: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodEnum<{
-            debug: "debug";
-            info: "info";
-            warn: "warn";
-            error: "error";
-        }>>>;
-    } extends infer T_1 extends z.core.util.SomeObject ? { [K in keyof T_1 as K extends keyof TExtension ? never : K]: {
-        NODE_ENV: z.ZodDefault<z.ZodEnum<{
-            development: "development";
-            production: "production";
-            test: "test";
-        }>>;
-        LOG_LEVEL: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodEnum<{
-            debug: "debug";
-            info: "info";
-            warn: "warn";
-            error: "error";
-        }>>>;
-    }[K]; } : never) & { [K_1 in keyof TExtension]: TExtension[K_1]; })[k]; } : never, {}>;
-    schema: z.ZodObject<(("NODE_ENV" | "LOG_LEVEL") & keyof TExtension extends never ? {
-        NODE_ENV: z.ZodDefault<z.ZodEnum<{
-            development: "development";
-            production: "production";
-            test: "test";
-        }>>;
-        LOG_LEVEL: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodEnum<{
-            debug: "debug";
-            info: "info";
-            warn: "warn";
-            error: "error";
-        }>>>;
-    } & TExtension : ({
-        NODE_ENV: z.ZodDefault<z.ZodEnum<{
-            development: "development";
-            production: "production";
-            test: "test";
-        }>>;
-        LOG_LEVEL: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodEnum<{
-            debug: "debug";
-            info: "info";
-            warn: "warn";
-            error: "error";
-        }>>>;
-    } extends infer T_2 extends z.core.util.SomeObject ? { [K in keyof T_2 as K extends keyof TExtension ? never : K]: {
-        NODE_ENV: z.ZodDefault<z.ZodEnum<{
-            development: "development";
-            production: "production";
-            test: "test";
-        }>>;
-        LOG_LEVEL: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodEnum<{
-            debug: "debug";
-            info: "info";
-            warn: "warn";
-            error: "error";
-        }>>>;
-    }[K]; } : never) & { [K_1 in keyof TExtension]: TExtension[K_1]; }) extends infer T ? { [k in keyof T]: (("NODE_ENV" | "LOG_LEVEL") & keyof TExtension extends never ? {
-        NODE_ENV: z.ZodDefault<z.ZodEnum<{
-            development: "development";
-            production: "production";
-            test: "test";
-        }>>;
-        LOG_LEVEL: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodEnum<{
-            debug: "debug";
-            info: "info";
-            warn: "warn";
-            error: "error";
-        }>>>;
-    } & TExtension : ({
-        NODE_ENV: z.ZodDefault<z.ZodEnum<{
-            development: "development";
-            production: "production";
-            test: "test";
-        }>>;
-        LOG_LEVEL: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodEnum<{
-            debug: "debug";
-            info: "info";
-            warn: "warn";
-            error: "error";
-        }>>>;
-    } extends infer T_1 extends z.core.util.SomeObject ? { [K in keyof T_1 as K extends keyof TExtension ? never : K]: {
-        NODE_ENV: z.ZodDefault<z.ZodEnum<{
-            development: "development";
-            production: "production";
-            test: "test";
-        }>>;
-        LOG_LEVEL: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodEnum<{
-            debug: "debug";
-            info: "info";
-            warn: "warn";
-            error: "error";
-        }>>>;
-    }[K]; } : never) & { [K_1 in keyof TExtension]: TExtension[K_1]; })[k]; } : never, z.core.$strip>;
-};
-//# sourceMappingURL=getEnvConfig.d.ts.map

package/dist/cjs/config/getEnvConfig.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getEnvConfig.d.ts","sourceRoot":"","sources":["../../../src/config/getEnvConfig.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,eAAe;;;;;;;;;;;;iBAS1B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAG5D,wBAAgB,eAAe,CAAC,UAAU,SAAS,CAAC,CAAC,WAAW,EAC9D,eAAe,EAAE,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAezC"}

package/dist/cjs/config/getEnvConfig.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BASE_ENV_SCHEMA = void 0;
-exports.createEnvConfig = createEnvConfig;
-// @percepta/config/src/createEnvConfig.ts
-const zod_1 = require("zod");
-// Base schema that all apps get
-exports.BASE_ENV_SCHEMA = zod_1.z.object({
-    NODE_ENV: zod_1.z
-        .enum(["development", "production", "test"])
-        .default("development"),
-    LOG_LEVEL: zod_1.z
-        .string()
-        .toLowerCase()
-        .pipe(zod_1.z.enum(["debug", "info", "warn", "error"]))
-        .default("info"),
-});
-// Factory that creates a configured getEnvConfig
-function createEnvConfig(extensionSchema) {
-    const schema = exports.BASE_ENV_SCHEMA.extend(extensionSchema.shape);
-    let _cached;
-    function getEnvConfig() {
-        if (_cached == null) {
-            _cached = schema.parse(process.env);
-        }
-        return _cached;
-    }
-    return { getEnvConfig, schema };
-}
-//# sourceMappingURL=getEnvConfig.js.map

package/dist/cjs/config/getEnvConfig.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getEnvConfig.js","sourceRoot":"","sources":["../../../src/config/getEnvConfig.ts"],"names":[],"mappings":";;;AAkBA,0CAgBC;AAlCD,0CAA0C;AAC1C,6BAAwB;AAExB,gCAAgC;AACnB,QAAA,eAAe,GAAG,OAAC,CAAC,MAAM,CAAC;IACtC,QAAQ,EAAE,OAAC;SACR,IAAI,CAAC,CAAC,aAAa,EAAE,YAAY,EAAE,MAAM,CAAC,CAAC;SAC3C,OAAO,CAAC,aAAa,CAAC;IACzB,SAAS,EAAE,OAAC;SACT,MAAM,EAAE;SACR,WAAW,EAAE;SACb,IAAI,CAAC,OAAC,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;SAChD,OAAO,CAAC,MAAM,CAAC;CACnB,CAAC,CAAC;AAIH,iDAAiD;AACjD,SAAgB,eAAe,CAC7B,eAAwC;IAExC,MAAM,MAAM,GAAG,uBAAe,CAAC,MAAM,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;IAG7D,IAAI,OAA2B,CAAC;IAEhC,SAAS,YAAY;QACnB,IAAI,OAAO,IAAI,IAAI,EAAE,CAAC;YACpB,OAAO,GAAG,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QACtC,CAAC;QACD,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,CAAC;AAClC,CAAC"}

package/dist/cjs/config/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./getEnvConfig";
-//# sourceMappingURL=index.d.ts.map

package/dist/cjs/config/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/config/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC"}

package/dist/cjs/config/index.js

@@ -1,18 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./getEnvConfig"), exports);
-//# sourceMappingURL=index.js.map

package/dist/cjs/config/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/config/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,iDAA+B"}

package/dist/cjs/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./utils";
-export * from "./config";
-//# sourceMappingURL=index.d.ts.map

package/dist/cjs/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC"}

package/dist/cjs/index.js

@@ -1,19 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./utils"), exports);
-__exportStar(require("./config"), exports);
-//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,0CAAwB;AACxB,2CAAyB"}