@dotenvx/primitives 0.3.0 → 0.5.0

package/dist/index.cjs

@@ -5390,7 +5390,7 @@ var require_compat = __commonJS({
       const isAEAD = algorithm === "aes-256-gcm" || algorithm === "chacha20-poly1305";
       const authTagLength = isAEAD ? AEAD_TAG_LENGTH : 0;
       const options = isAEAD ? { authTagLength } : void 0;
-      const encrypt = (plainText) => {
+      const encrypt2 = (plainText) => {
         const cipher = (0, node_crypto_1.createCipheriv)(algorithm, key, nonce, options);
         if (isAEAD && AAD !== void 0) {
           cipher.setAAD(AAD);
@@ -5415,7 +5415,7 @@ var require_compat = __commonJS({
         return (0, utils_1.concatBytes)(updated, finalized);
       };
       return {
-        encrypt,
+        encrypt: encrypt2,
         decrypt: decrypt2
       };
     };
@@ -5826,13 +5826,13 @@ var require_dist = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.PublicKey = exports2.PrivateKey = exports2.ECIES_CONFIG = void 0;
-    exports2.encrypt = encrypt;
+    exports2.encrypt = encrypt2;
     exports2.decrypt = decrypt2;
     var utils_1 = require_utils();
     var config_js_1 = require_config();
     var index_js_1 = require_keys();
     var index_js_2 = require_utils4();
-    function encrypt(receiverRawPK, data, config = config_js_1.ECIES_CONFIG) {
+    function encrypt2(receiverRawPK, data, config = config_js_1.ECIES_CONFIG) {
       const curve = config.ellipticCurve;
       const ephemeralSK = new index_js_1.PrivateKey(void 0, curve);
       const receiverPK = receiverRawPK instanceof Uint8Array ? new index_js_1.PublicKey(receiverRawPK, curve) : index_js_1.PublicKey.fromHex(receiverRawPK, curve);
@@ -6002,6 +6002,20 @@ var require_derive = __commonJS({
   }
 });
 
+// src/encrypt.js
+var require_encrypt = __commonJS({
+  "src/encrypt.js"(exports2, module2) {
+    var { encrypt: eciesEncrypt } = require_dist();
+    var { PREFIX } = require_encrypted();
+    function encrypt2(publicKeyHex, value) {
+      const ciphertext = eciesEncrypt(publicKeyHex, Buffer.from(value));
+      const encoded = Buffer.from(ciphertext, "hex").toString("base64");
+      return `${PREFIX}${encoded}`;
+    }
+    module2.exports = encrypt2;
+  }
+});
+
 // src/evaluate.js
 var require_evaluate = __commonJS({
   "src/evaluate.js"(exports2, module2) {
@@ -6081,43 +6095,13 @@ var require_expand = __commonJS({
   }
 });
 
-// src/keyring.js
-var require_keyring = __commonJS({
-  "src/keyring.js"(exports2, module2) {
-    var { PrivateKey } = require_dist();
-    var derive2 = require_derive();
-    function keyring2() {
-      const mem = {};
-      const processEnv = process.env;
-      for (const name in processEnv) {
-        if (name.startsWith("DOTENV_PRIVATE_KEY")) {
-          try {
-            const privateKeyHex = processEnv[name];
-            const publicKeyHex = derive2(privateKeyHex);
-            mem[publicKeyHex] = privateKeyHex;
-          } catch (_e) {
-          }
-        }
-      }
-      return mem;
-    }
-    module2.exports = keyring2;
-  }
-});
-
-// src/parse.js
-var require_parse = __commonJS({
-  "src/parse.js"(exports2, module2) {
-    var decrypt2 = require_decrypt();
-    var keyring2 = require_keyring();
-    var encrypted2 = require_encrypted();
-    var evaluate2 = require_evaluate();
-    var expand2 = require_expand();
-    var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
+// src/scan.js
+var require_scan = __commonJS({
+  "src/scan.js"(exports2, module2) {
     function trimmer(value) {
       return (value || "").trim();
     }
-    function quote(value) {
+    function getQuote(value) {
       const v = trimmer(value);
       const maybeQuote = v[0];
       let q = "";
@@ -6140,16 +6124,93 @@ var require_parse = __commonJS({
       }
       return q;
     }
-    function clean(value, _quote) {
+    function clean(value, quote) {
       let v = trimmer(value);
       v = v.replace(/^(['"`])([\s\S]*)\1$/mg, "$2");
-      if (_quote === '"') {
+      if (quote === '"') {
         v = v.replace(/\\n/g, "\n");
         v = v.replace(/\\r/g, "\r");
         v = v.replace(/\\t/g, "	");
       }
       return v;
     }
+    function scan2(src, transform) {
+      const LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
+      const parsed = {};
+      const lines = (src || "").toString().replace(/\r\n?/mg, "\n");
+      let match;
+      while ((match = LINE.exec(lines)) !== null) {
+        const name = match[1];
+        const raw = match[2];
+        const quote = getQuote(raw);
+        const value = clean(raw, quote);
+        let parsedValue = value;
+        if (typeof transform === "function") {
+          parsedValue = transform({
+            name,
+            value,
+            quote
+          });
+        }
+        parsed[name] = parsedValue;
+      }
+      return {
+        parsed
+      };
+    }
+    module2.exports = scan2;
+  }
+});
+
+// src/keyring.js
+var require_keyring = __commonJS({
+  "src/keyring.js"(exports2, module2) {
+    var fs = require("fs");
+    var derive2 = require_derive();
+    var scan2 = require_scan();
+    function keysFromFile(filepath = ".env.keys") {
+      try {
+        const src = fs.readFileSync(filepath, "utf8");
+        const { parsed } = scan2(src);
+        return parsed;
+      } catch (_e) {
+        return {};
+      }
+    }
+    function keyring2() {
+      const mem = {};
+      const processEnv = process.env;
+      const keysFilepath = ".env.keys";
+      const sources = {
+        ...keysFromFile(keysFilepath),
+        ...processEnv
+        // process.env wins
+      };
+      for (const name in sources) {
+        if (name.startsWith("DOTENV_PRIVATE_KEY")) {
+          try {
+            const privateKeyHex = sources[name];
+            const publicKeyHex = derive2(privateKeyHex);
+            mem[publicKeyHex] = privateKeyHex;
+          } catch (_e) {
+          }
+        }
+      }
+      return mem;
+    }
+    module2.exports = keyring2;
+  }
+});
+
+// src/parse.js
+var require_parse = __commonJS({
+  "src/parse.js"(exports2, module2) {
+    var decrypt2 = require_decrypt();
+    var keyring2 = require_keyring();
+    var encrypted2 = require_encrypted();
+    var evaluate2 = require_evaluate();
+    var expand2 = require_expand();
+    var scan2 = require_scan();
     function resolveEscapeSequences(value) {
       return value.replace(/\\\$/g, "$");
     }
@@ -6160,50 +6221,45 @@ var require_parse = __commonJS({
       function inProcessEnv(name) {
         return Object.prototype.hasOwnProperty.call(processEnv, name);
       }
-      let parsed = {};
       let publicKeyHex;
       let runningParsed = {};
       let literals = {};
-      const lines = (src || "").toString().replace(/\r\n?/mg, "\n");
-      let match;
-      while ((match = LINE.exec(lines)) !== null) {
-        const name = match[1];
-        const value = match[2];
-        const _quote = quote(value);
-        parsed[name] = clean(value, _quote);
+      const { parsed } = scan2(src, ({ name, value, quote }) => {
+        let parsedValue = value;
         if (name.startsWith("DOTENV_PUBLIC_KEY")) {
-          publicKeyHex = parsed[name];
+          publicKeyHex = parsedValue;
         }
         if (!overload && inProcessEnv(name)) {
-          parsed[name] = processEnv[name];
+          parsedValue = processEnv[name];
         }
         try {
-          parsed[name] = decrypt2(ring[publicKeyHex], parsed[name]);
+          parsedValue = decrypt2(ring[publicKeyHex], parsedValue);
         } catch (_e) {
         }
-        const encryptedPrefixed = encrypted2(parsed[name]);
+        const encryptedPrefixed = encrypted2(parsedValue);
         let evaled = false;
-        if (!encryptedPrefixed && _quote !== "'" && (!inProcessEnv(name) || processEnv[name] === parsed[name])) {
-          const priorEvaled = parsed[name];
+        if (!encryptedPrefixed && quote !== "'" && (!inProcessEnv(name) || processEnv[name] === parsedValue)) {
+          const priorEvaled = parsedValue;
           try {
-            parsed[name] = evaluate2(priorEvaled, { processEnv, runningParsed });
+            parsedValue = evaluate2(priorEvaled, { processEnv, runningParsed });
           } catch (_e) {
           }
-          if (priorEvaled !== parsed[name]) {
+          if (priorEvaled !== parsedValue) {
             evaled = true;
           }
         }
-        if (!encryptedPrefixed && !evaled && _quote !== "'" && (!processEnv[name] || overload)) {
-          parsed[name] = resolveEscapeSequences(expand2(parsed[name], { processEnv, runningParsed, literals }));
+        if (!encryptedPrefixed && !evaled && quote !== "'" && (!processEnv[name] || overload)) {
+          parsedValue = resolveEscapeSequences(expand2(parsedValue, { processEnv, runningParsed, literals }));
         }
         if (quote === "'") {
-          literals[name] = parsed[name];
+          literals[name] = parsedValue;
         }
-        runningParsed[name] = parsed[name];
+        runningParsed[name] = parsedValue;
         if (Object.prototype.hasOwnProperty.call(processEnv, name) && !overload) {
         } else {
         }
-      }
+        return parsedValue;
+      });
       return {
         parsed
       };
@@ -6215,17 +6271,21 @@ var require_parse = __commonJS({
 // src/index.js
 var decrypt = require_decrypt();
 var derive = require_derive();
+var encrypt = require_encrypt();
 var encrypted = require_encrypted();
 var evaluate = require_evaluate();
 var expand = require_expand();
 var keyring = require_keyring();
 var parse = require_parse();
+var scan = require_scan();
 module.exports = {
   decrypt,
   derive,
+  encrypt,
   encrypted,
   evaluate,
   expand,
   keyring,
-  parse
+  parse,
+  scan
 };

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.3.0",
+  "version": "0.5.0",
   "name": "@dotenvx/primitives",
   "description": "a secure dotenv–from the creator of `dotenv`",
   "author": "@motdotla",