{"id":19972367,"url":"https://github.com/linhntaim/dotenv-conversion","last_synced_at":"2025-07-03T05:03:07.390Z","repository":{"id":36471151,"uuid":"226706489","full_name":"linhntaim/dotenv-conversion","owner":"linhntaim","description":"An extension for dotenv is to help  converting environment variables to anything more useful than strings.","archived":false,"fork":false,"pushed_at":"2023-11-03T11:41:51.000Z","size":843,"stargazers_count":3,"open_issues_count":0,"forks_count":0,"subscribers_count":1,"default_branch":"master","last_synced_at":"2025-06-17T00:02:57.992Z","etag":null,"topics":["automatic-conversion","conversion","convert","customizable","dotenv","dotenv-conversion","env","enviroment-variables","node","node-js","node-package","nodejs","npm"],"latest_commit_sha":null,"homepage":"","language":"JavaScript","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/linhntaim.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null}},"created_at":"2019-12-08T17:40:37.000Z","updated_at":"2023-10-10T10:53:42.000Z","dependencies_parsed_at":"2024-01-23T00:16:49.335Z","dependency_job_id":"ecc31a50-8b6a-45ba-a940-eedaac7ed9ec","html_url":"https://github.com/linhntaim/dotenv-conversion","commit_stats":{"total_commits":85,"total_committers":4,"mean_commits":21.25,"dds":0.4,"last_synced_commit":"0cf38f8fb21b8f63fecbc58d38021c30366580a4"},"previous_names":[],"tags_count":22,"template":false,"template_full_name":null,"purl":"pkg:github/linhntaim/dotenv-conversion","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/linhntaim%2Fdotenv-conversion","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/linhntaim%2Fdotenv-conversion/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/linhntaim%2Fdotenv-conversion/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/linhntaim%2Fdotenv-conversion/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/linhntaim","download_url":"https://codeload.github.com/linhntaim/dotenv-conversion/tar.gz/refs/heads/master","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/linhntaim%2Fdotenv-conversion/sbom","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":262352621,"owners_count":23297689,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["automatic-conversion","conversion","convert","customizable","dotenv","dotenv-conversion","env","enviroment-variables","node","node-js","node-package","nodejs","npm"],"created_at":"2024-11-13T03:07:48.315Z","updated_at":"2025-07-03T05:03:07.337Z","avatar_url":"https://github.com/linhntaim.png","language":"JavaScript","funding_links":[],"categories":[],"sub_categories":[],"readme":"# dotenv-conversion\n\n[![NPM version](https://img.shields.io/npm/v/dotenv-conversion.svg?style=flat-square)](https://www.npmjs.com/package/dotenv-conversion)\n[![Github Actions](https://img.shields.io/github/actions/workflow/status/linhntaim/dotenv-conversion/build.yml?style=flat-square)](https://github.com/linhntaim/dotenv-conversion/actions/workflows/build.yml)\n[![Coveralls](https://img.shields.io/coveralls/github/linhntaim/dotenv-conversion?style=flat-square)](https://coveralls.io/github/linhntaim/dotenv-conversion)\n[![License](https://img.shields.io/npm/l/dotenv-conversion?style=flat-square)](https://github.com/linhntaim/dotenv-conversion/blob/master/LICENSE)\n\n`dotenv-conversion` adds variable conversion on top of `dotenv`. If you find yourself\nneeding to convert/transform environment variables to anything more useful than strings,\nthen `dotenv-conversion` is your tool.\n\n---\n\n- [Installation](#installation)\n- [Usage](#usage)\n- [Preload](#preload)\n    - [With `dotenv`](#with-dotenv)\n    - [With `dotenv-flow`](#with-dotenv-flow)\n- [Features](#features)\n    - [Auto-Conversion](#auto-conversion)\n    - [Conversion Methods](#conversion-methods)\n        - [Built-in Methods](#built-in-methods)\n        - [Custom Methods](#custom-methods)\n        - [Method Aliases](#method-aliases)\n        - [The special built-in method `auto`](#the-special-built-in-method-auto)\n    - [Custom Conversion for a Specific Variable](#custom-conversion-for-a-specific-variable)\n    - [Prevent Variables from Conversion](#prevent-variables-from-conversion)\n    - [Ignore `process.env`](#ignore-processenv)\n- [Documentation](#documentation)\n    - [`convert`](#convert)\n        - [Options](#options)\n\n---\n\n## Installation\n\n```bash\nnpm install dotenv-conversion --save\n```\n\n## Usage\n\n- Standalone:\n\n```javascript\nconst dotenvConversion = require('dotenv-conversion')\n/* or ES6 */\n// import dotenvConversion from 'dotenv-conversion'\n\nconst options = {\n    parsed: {\n        DEBUG: 'false',\n    },\n    // rememeber to set this option to false if usage is `standalone`\n    fromDotEnv: false,\n}\nconst {parsed} = dotenvConversion.convert(options)\nconsole.log(parsed.DEBUG) // (boolean) false\nconsole.log(process.env.DEBUG) // (string) 'false' \n```\n\n- Integrate with [`dotenv`](https://www.npmjs.com/package/dotenv):\n\n```dotenv\n# .env file\nDEBUG=false\n```\n\n```javascript\nconst dotenv = require('dotenv')\nconst dotenvConversion = require('dotenv-conversion')\n/* or ES6 */\n// import dotenv from 'dotenv'\n// import dotenvConversion from 'dotenv-conversion'\n\nconst config = dotenv.config()\nconst {parsed} = dotenvConversion.convert(config)\nconsole.log(parsed.DEBUG)       // (boolean) false\nconsole.log(process.env.DEBUG)  // (string) 'false'\n```\n\n- ... and [`dotenv-expand`](https://www.npmjs.com/package/dotenv-expand):\n\n```dotenv\n# .env file\nDEBUG_LEVEL=0\nDEBUG=boolean:$DEBUG_LEVEL\n\nEXPONENTIAL=2\nNUMBER=1e$EXPONENTIAL\n```\n\n```javascript\nconst dotenv = require('dotenv')\nconst dotenvExpand = require('dotenv-expand')\nconst dotenvConversion = require('dotenv-conversion')\n/* or ES6 */\n// import dotenv from 'dotenv'\n// import dotenvExpand from 'dotenv-expand'\n// import dotenvConversion from 'dotenv-conversion'\n\nconst config = dotenv.config()\nconst {parsed} = dotenvConversion.convert(dotenvExpand.expand(config))\nconsole.log(parsed.DEBUG_LEVEL)         // (number) 0 \nconsole.log(parsed.DEBUG)               // (boolean) false\nconsole.log(parsed.EXPONENTIAL)         // (number) 2\nconsole.log(parsed.NUMBER)              // (number) 100\nconsole.log(process.env.DEBUG_LEVEL)    // (string) '0'\nconsole.log(process.env.DEBUG)          // (string) 'false'\nconsole.log(process.env.EXPONENTIAL)    // (string) '2'\nconsole.log(process.env.NUMBER)         // (string) '100'\n```\n\n- Or integrate with [`dotenv-flow`](https://www.npmjs.com/package/dotenv-flow):\n\n```dotenv\n# .env.test file\nDEBUG_LEVEL=0\nDEBUG=boolean:$DEBUG_LEVEL\n\nEXPONENTIAL=2\nNUMBER=1e$EXPONENTIAL\n```\n\n```javascript\nconst dotenvFlow = require('dotenv-flow')\nconst dotenvExpand = require('dotenv-expand')\nconst dotenvConversion = require('dotenv-conversion')\n/* or ES6 */\n// import dotenvFlow from 'dotenv-flow'\n// import dotenvExpand from 'dotenv-expand'\n// import dotenvConversion from 'dotenv-conversion'\n\n// load variables from .env.test file\nprocess.env.NODE_ENV = 'test'\n\nconst config = dotenvFlow.config()\nconst {parsed} = dotenvConversion.convert(dotenvExpand.expand(config))\nconsole.log(parsed.DEBUG_LEVEL)         // (number) 0 \nconsole.log(parsed.DEBUG)               // (boolean) false\nconsole.log(parsed.EXPONENTIAL)         // (number) 2\nconsole.log(parsed.NUMBER)              // (number) 100\nconsole.log(process.env.DEBUG_LEVEL)    // (string) '0'\nconsole.log(process.env.DEBUG)          // (string) 'false'\nconsole.log(process.env.EXPONENTIAL)    // (string) '2'\nconsole.log(process.env.NUMBER)         // (string) '100'\n```\n\n## Preload\n\n### With `dotenv`\n\nYou can use the `--require` (`-r`) [command line option](https://nodejs.org/api/cli.html#cli_r_require_module)\nto preload `dotenv` and `dotenv-conversion` (and even `dotenv-expand`).\nBy doing this, you do not need to require and load `dotenv` or `dotenv-conversion`\n(or `dotenv-expand`) in your application code.\nThis is the preferred approach when using `import` instead of `require`.\n\n```bash\n# dotenv + dotenv-conversion\n$ node -r dotenv-conversion/config your_script.js\n\n# dotenv + dotenv-expand + dotenv-conversion\n$ node -r dotenv-conversion/config-expand your_script.js\n```\n\nThe configuration options below are supported as command line arguments\nin the format `dotenv_config_\u003coption\u003e=\u003cvalue\u003e`.\n\n```bash\n# dotenv + dotenv-conversion\n$ node -r dotenv-conversion/config your_script.js dotenv_config_path=/custom/path/to/your/env/vars\n\n# dotenv + dotenv-expand + dotenv-conversion\n$ node -r dotenv-conversion/config-expand your_script.js dotenv_config_path=/custom/path/to/your/env/vars\n```\n\nAdditionally, you can use environment variables to set configuration options.\nCommand line arguments will precede these.\n\n```bash\n# dotenv + dotenv-conversion\n$ DOTENV_CONFIG_\u003cOPTION\u003e=\u003cvalue\u003e node -r dotenv-conversion/config your_script.js\n\n# dotenv + dotenv-expand + dotenv-conversion\n$ DOTENV_CONFIG_\u003cOPTION\u003e=\u003cvalue\u003e node -r dotenv-conversion/config-expand your_script.js\n```\n\n```bash\n# dotenv + dotenv-conversion\n$ DOTENV_CONFIG_ENCODING=latin1 node -r dotenv-conversion/config your_script.js dotenv_config_path=/custom/path/to/.env\n\n# dotenv + dotenv-expand + dotenv-conversion\n$ DOTENV_CONFIG_ENCODING=latin1 node -r dotenv-conversion/config-expand your_script.js dotenv_config_path=/custom/path/to/.env\n```\n\nAfter preload, you can retrieve converted variables via `global.dotenvConversion.parsed`:\n\n```dotenv\n# .env file\nDEBUG_LEVEL=0\nDEBUG=boolean:$DEBUG_LEVEL\n\nEXPONENTIAL=2\nNUMBER=1e$EXPONENTIAL\n```\n\n```javascript\n// index.js file\nconst {parsed} = global.dotenvConversion\nconsole.log(parsed.DEBUG_LEVEL)         // (number) 0 \nconsole.log(parsed.DEBUG)               // (boolean) false\nconsole.log(parsed.EXPONENTIAL)         // (number) 2\nconsole.log(parsed.NUMBER)              // (number) 100\nconsole.log(process.env.DEBUG_LEVEL)    // (string) '0'\nconsole.log(process.env.DEBUG)          // (string) 'false'\nconsole.log(process.env.EXPONENTIAL)    // (string) '2'\nconsole.log(process.env.NUMBER)         // (string) '100'\n```\n\n```bash\n# dotenv + dotenv-expand + dotenv-conversion\n$ node -r dotenv-conversion/config-expand index.js\n```\n\nConsole output:\n\n```\n0\nfalse\n2\n100\n0\nfalse\n2\n100\n```\n\n### With `dotenv-flow`\n\nAlternatively, you can preload `dotenv-flow` and `dotenv-conversion` (and `dotenv-expand`).\n\n```bash\n# dotenv-flow + dotenv-conversion\n$ node -r dotenv-conversion/config-flow your_script.js\n\n# dotenv-flow + dotenv-expand + dotenv-conversion\n$ node -r dotenv-conversion/config-flow-expand your_script.js\n```\n\nRemember to set the environment variable `NODE_ENV` before preloading when you need to\nload `NODE_ENV`-specific `.env` file.\n\n```bash\n# dotenv-flow + dotenv-conversion\n$ NODE_ENV=\u003cvalue\u003e node -r dotenv-conversion/config-flow your_script.js\n\n# dotenv-flow + dotenv-expand + dotenv-conversion\n$ NODE_ENV=\u003cvalue\u003e node -r dotenv-conversion/config-flow-expand your_script.js\n```\n\n```bash\n# dotenv-flow + dotenv-conversion\n$ NODE_ENV=production node -r dotenv-conversion/config-flow your_script.js\n\n# dotenv-flow + dotenv-expand + dotenv-conversion\n$ NODE_ENV=production node -r dotenv-conversion/config-flow-expand your_script.js\n```\n\nAfter preload, you can also retrieve converted variables via `global.dotenvConversion.parsed`.\n\n## Features\n\n### Auto-Conversion\n\nBy default, environment variables will be converted automatically based on its string value.\n\nCurrently, auto-conversion supports\n`null`, `undefined`, `boolean`, `number`, `bigint`, `symbol`, `array`, `object` as follows:\n\n- **null**\n\nValues to be converted to null: `null`, `Null`, `NULL`.\n\n*Spaces will be trimmed.*\n\n```dotenv\n# .env file\nVARIABLE_1=null\nVARIABLE_2=\" null \"\n```\n\n```javascript\nconst dotenv = require('dotenv')\nconst dotenvConversion = require('dotenv-conversion')\n/* or ES6 */\n// import dotenv from 'dotenv'\n// import dotenvConversion from 'dotenv-conversion'\n\nconst config = dotenv.config()\nconst {parsed} = dotenvConversion.convert(config)\nconsole.log(parsed.VARIABLE_1)          // (object) null \nconsole.log(parsed.VARIABLE_2)          // (object) null\nconsole.log(process.env.VARIABLE_1)     // (string) 'null'\nconsole.log(process.env.VARIABLE_2)     // (string) 'null'\n```\n\n- **undefined**\n\nValues to be converted to undefined: `undefined`, `UNDEFINED`.\n\n*Spaces will be trimmed.*\n\n```dotenv\n# .env file\nVARIABLE_1=undefined\nVARIABLE_2=\" undefined \"\n```\n\n```javascript\nconst dotenv = require('dotenv')\nconst dotenvConversion = require('dotenv-conversion')\n/* or ES6 */\n// import dotenv from 'dotenv'\n// import dotenvConversion from 'dotenv-conversion'\n\nconst config = dotenv.config()\nconst {parsed} = dotenvConversion.convert(config)\nconsole.log(parsed.VARIABLE_1)          // (undefined) undefined \nconsole.log(parsed.VARIABLE_2)          // (undefined) undefined\nconsole.log(process.env.VARIABLE_1)     // (string) 'undefined'\nconsole.log(process.env.VARIABLE_2)     // (string) 'undefined'\n```\n\n- **boolean**\n\nValues to be converted to true: `true`, `True`, `TRUE`, `yes`, `Yes`, `YES`,\n`ok`, `Ok`, `OK`.\n\nValues to be converted to false: `false`, `False`, `FALSE`, `no`, `No`, `NO`,\n`not`, `Not`, `NOT`, `none`, `None`, `NONE`.\n\n*Spaces will be trimmed.*\n\n```dotenv\n# .env file\nVARIABLE_1=true\nVARIABLE_2=false\nVARIABLE_3=\" yes \"\nVARIABLE_4=\" no \"\n```\n\n```javascript\nconst dotenv = require('dotenv')\nconst dotenvConversion = require('dotenv-conversion')\n/* or ES6 */\n// import dotenv from 'dotenv'\n// import dotenvConversion from 'dotenv-conversion'\n\nconst config = dotenv.config()\nconst {parsed} = dotenvConversion.convert(config)\nconsole.log(parsed.VARIABLE_1)          // (boolean) true \nconsole.log(parsed.VARIABLE_2)          // (boolean) false\nconsole.log(parsed.VARIABLE_3)          // (boolean) true\nconsole.log(parsed.VARIABLE_4)          // (boolean) false\nconsole.log(process.env.VARIABLE_1)     // (string) 'true'\nconsole.log(process.env.VARIABLE_2)     // (string) 'false'\nconsole.log(process.env.VARIABLE_3)     // (string) 'true'\nconsole.log(process.env.VARIABLE_4)     // (string) 'false'\n```\n\n- **number**\n\nValues to be converted to number: `NaN`, `±Infinity`\nand any string in valid number format (e.g. `±5`, `±5.`, `±.5`, `±4.5`, `±4.5e±123`, ...).\nBinary (e.g. `±0b1010`), octal (e.g. `±0o12`) and hexadecimal (e.g. `±0xa`) number format\nare also supported.\n\n*Spaces will be trimmed.*\n\n```dotenv\n# .env file\nVARIABLE_1=NaN\nVARIABLE_2=Infinity\nVARIABLE_3=-Infinity\nVARIABLE_4=5\nVARIABLE_5=5.\nVARIABLE_6=.5\nVARIABLE_7=4.5\nVARIABLE_8=4.5e+1\nVARIABLE_9=4.5e+123\nVARIABLE_10=-5\nVARIABLE_11=-5.\nVARIABLE_12=-.5\nVARIABLE_13=-4.5\nVARIABLE_14=-4.5e-1\nVARIABLE_15=-4.5e-123\nVARIABLE_16=4.5E123\nVARIABLE_17=\" NaN \"\nVARIABLE_18=\" Infinity \"\nVARIABLE_19=\" 4.5e+123 \"\nVARIABLE_20=0b1010\nVARIABLE_21=-0B1010\nVARIABLE_22=0o12\nVARIABLE_23=-0O12\nVARIABLE_24=0xa\nVARIABLE_25=-0XA\n```\n\n```javascript\nconst dotenv = require('dotenv')\nconst dotenvConversion = require('dotenv-conversion')\n/* or ES6 */\n// import dotenv from 'dotenv'\n// import dotenvConversion from 'dotenv-conversion'\n\nconst config = dotenv.config()\nconst {parsed} = dotenvConversion.convert(config)\nconsole.log(parsed.VARIABLE_1)          // (number) NaN \nconsole.log(parsed.VARIABLE_2)          // (number) Infinity\nconsole.log(parsed.VARIABLE_3)          // (number) -Infinity\nconsole.log(parsed.VARIABLE_4)          // (number) 5\nconsole.log(parsed.VARIABLE_5)          // (number) 5\nconsole.log(parsed.VARIABLE_6)          // (number) 0.5\nconsole.log(parsed.VARIABLE_7)          // (number) 4.5\nconsole.log(parsed.VARIABLE_8)          // (number) 45\nconsole.log(parsed.VARIABLE_9)          // (number) 4.5e+123\nconsole.log(parsed.VARIABLE_10)         // (number) -5\nconsole.log(parsed.VARIABLE_11)         // (number) -5 \nconsole.log(parsed.VARIABLE_12)         // (number) -0.5\nconsole.log(parsed.VARIABLE_13)         // (number) -4.5\nconsole.log(parsed.VARIABLE_14)         // (number) -0.45\nconsole.log(parsed.VARIABLE_15)         // (number) -4.5e-123\nconsole.log(parsed.VARIABLE_16)         // (number) 4.5e+123\nconsole.log(parsed.VARIABLE_17)         // (number) NaN\nconsole.log(parsed.VARIABLE_18)         // (number) Infinity\nconsole.log(parsed.VARIABLE_19)         // (number) 4.5e+123\nconsole.log(parsed.VARIABLE_20)         // (number) 10\nconsole.log(parsed.VARIABLE_21)         // (number) -10\nconsole.log(parsed.VARIABLE_22)         // (number) 10\nconsole.log(parsed.VARIABLE_23)         // (number) -10\nconsole.log(parsed.VARIABLE_24)         // (number) 10\nconsole.log(parsed.VARIABLE_25)         // (number) -10\nconsole.log(process.env.VARIABLE_1)     // (string) 'NaN'\nconsole.log(process.env.VARIABLE_2)     // (string) 'Infinity'\nconsole.log(process.env.VARIABLE_3)     // (string) '-Infinity'\nconsole.log(process.env.VARIABLE_4)     // (string) '5'\nconsole.log(process.env.VARIABLE_5)     // (string) '5'\nconsole.log(process.env.VARIABLE_6)     // (string) '0.5'\nconsole.log(process.env.VARIABLE_7)     // (string) '4.5'\nconsole.log(process.env.VARIABLE_8)     // (string) '45'\nconsole.log(process.env.VARIABLE_9)     // (string) '4.5e+123'\nconsole.log(process.env.VARIABLE_10)    // (string) '-5'\nconsole.log(process.env.VARIABLE_11)    // (string) '-5'\nconsole.log(process.env.VARIABLE_12)    // (string) '-0.5'\nconsole.log(process.env.VARIABLE_13)    // (string) '-4.5'\nconsole.log(process.env.VARIABLE_14)    // (string) '-0.45'\nconsole.log(process.env.VARIABLE_15)    // (string) '-4.5e-123'\nconsole.log(process.env.VARIABLE_16)    // (string) '4.5e+123'\nconsole.log(process.env.VARIABLE_17)    // (string) 'NaN'\nconsole.log(process.env.VARIABLE_18)    // (string) 'Infinity'\nconsole.log(process.env.VARIABLE_19)    // (string) '4.5e+123'\nconsole.log(process.env.VARIABLE_20)    // (string) '10'\nconsole.log(process.env.VARIABLE_21)    // (string) '-10'\nconsole.log(process.env.VARIABLE_22)    // (string) '10'\nconsole.log(process.env.VARIABLE_23)    // (string) '-10'\nconsole.log(process.env.VARIABLE_24)    // (string) '10'\nconsole.log(process.env.VARIABLE_25)    // (string) '-10'\n```\n\n***Note:* You can disable the support for binary, octal or hexadecimal number format \nby setting the option [`binaryNumber`](#binarynumber), \n[`octalNumber`](#octalnumber) or [`hexadecimalNumber`](#hexadecimalnumber) to false. \n\n- **bigint**\n\nValues to be converted to bigint must match the format: `${value}n`;\n`value` must be an `integer` in decimal (e.g. `±10`), binary (e.g. `±0b1010`),\noctal (e.g. `±0o12`) or hexadecimal (e.g. `±0xa`) number syntax.\n\n*Spaces will be trimmed.*\n\n```dotenv\n# .env file\nVARIABLE_1=5n\nVARIABLE_2=-5n\nVARIABLE_3=\" 5n \"\nVARIABLE_4=0b1010n\nVARIABLE_5=-0B1010n\nVARIABLE_6=0o12n\nVARIABLE_7=-0O12n\nVARIABLE_8=0xan\nVARIABLE_9=-0XAn\n```\n\n```javascript\nconst dotenv = require('dotenv')\nconst dotenvConversion = require('dotenv-conversion')\n/* or ES6 */\n// import dotenv from 'dotenv'\n// import dotenvConversion from 'dotenv-conversion'\n\nconst config = dotenv.config()\nconst {parsed} = dotenvConversion.convert(config)\nconsole.log(parsed.VARIABLE_1)          // (bigint) 5n \nconsole.log(parsed.VARIABLE_2)          // (bigint) -5n\nconsole.log(parsed.VARIABLE_3)          // (bigint) 5n\nconsole.log(parsed.VARIABLE_4)          // (bigint) 10n\nconsole.log(parsed.VARIABLE_5)          // (bigint) 10n\nconsole.log(parsed.VARIABLE_6)          // (bigint) 10n\nconsole.log(parsed.VARIABLE_7)          // (bigint) 10n\nconsole.log(parsed.VARIABLE_8)          // (bigint) 10n\nconsole.log(parsed.VARIABLE_9)          // (bigint) 10n\nconsole.log(process.env.VARIABLE_1)     // (string) '5n'\nconsole.log(process.env.VARIABLE_2)     // (string) '-5n'\nconsole.log(process.env.VARIABLE_3)     // (string) '5n'\nconsole.log(process.env.VARIABLE_4)     // (string) '10n'\nconsole.log(process.env.VARIABLE_5)     // (string) '10n'\nconsole.log(process.env.VARIABLE_6)     // (string) '10n'\nconsole.log(process.env.VARIABLE_7)     // (string) '10n'\nconsole.log(process.env.VARIABLE_8)     // (string) '10n'\nconsole.log(process.env.VARIABLE_9)     // (string) '10n'\n```\n\n***Note:* You can disable the support for binary, octal or hexadecimal bigint format\nby setting the option [`binaryBigInt`](#binarybigint),\n[`octalBigInt`](#octalbigint) or [`hexadecimalBigInt`](#hexadecimalbigint) to false.\n\n- **symbol**\n\nValues to be converted to symbol must match the format: `Symbol(${string})`.\n\n*Spaces will be trimmed.*\n\n```dotenv\n# .env file\nVARIABLE_1=Symbol()\nVARIABLE_2=Symbol(a)\nVARIABLE_3=\" Symbol(a) \"\n```\n\n```javascript\nconst dotenv = require('dotenv')\nconst dotenvConversion = require('dotenv-conversion')\n/* or ES6 */\n// import dotenv from 'dotenv'\n// import dotenvConversion from 'dotenv-conversion'\n\nconst config = dotenv.config()\nconst {parsed} = dotenvConversion.convert(config)\nconsole.log(parsed.VARIABLE_1)          // (symbol) Symbol()\nconsole.log(parsed.VARIABLE_2)          // (symbol) Symbol(a)\nconsole.log(parsed.VARIABLE_3)          // (symbol) Symbol(a)\nconsole.log(process.env.VARIABLE_1)     // (string) 'Symbol(a)'\nconsole.log(process.env.VARIABLE_2)     // (string) 'Symbol(a)'\n```\n\n- **array**\n\nValues to be converted to array must match the format:\na string contains `${value}` separated by commas;\nthe `value` could be `null`,`boolean`, `number`, `\"string\"`, `[..array..]` or `{..object..}`;\nand all could be wrapped or not wrapped by `[` and `]` (*must*, when the string is empty).\n\n*Special case:* Values that have only a string enclosed by double quotes\nalso match the above format.\n\n*Spaces will be trimmed.*\n\n```dotenv\n# .env file\nVARIABLE_1=[null,true,1,\"a\",[-1,2.1,3e1,4.5e123],{\"x\":\"y\"}]\nVARIABLE_2=null,true,1,\"a\",[-1,2.1,3e1,4.5e123],{\"x\":\"y\"}\nVARIABLE_3=\" [null, true, 1, \\\" x y \\\"] \"\nVARIABLE_4=\" null, true, 1, \\\" x y \\\" \"\nVARIABLE_5=\" [ ] \"\nVARIABLE_6=\"\\\"a\\\"\" # Special case\n```\n\n```javascript\nconst dotenv = require('dotenv')\nconst dotenvConversion = require('dotenv-conversion')\n/* or ES6 */\n// import dotenv from 'dotenv'\n// import dotenvConversion from 'dotenv-conversion'\n\nconst config = dotenv.config()\nconst {parsed} = dotenvConversion.convert(config)\nconsole.log(parsed.VARIABLE_1)          // (array) [null, true, 1, \"a\", [-1, 2.1, 30, 4.5e+123], {\"x\": \"y\"}] \nconsole.log(parsed.VARIABLE_2)          // (array) [null, true, 1, \"a\", [-1, 2.1, 30, 4.5e+123], {\"x\": \"y\"}]\nconsole.log(parsed.VARIABLE_3)          // (array) [null, true, 1, \" x y \"]\nconsole.log(parsed.VARIABLE_4)          // (array) [null, true, 1, \" x y \"]\nconsole.log(parsed.VARIABLE_5)          // (array) []\nconsole.log(parsed.VARIABLE_6)          // (array) [\"a\"] // Special case\nconsole.log(process.env.VARIABLE_1)     // (string) '[null,true,1,\"a\",[-1,2.1,30,4.5e+123],{\"x\":\"y\"}]'\nconsole.log(process.env.VARIABLE_2)     // (string) '[null,true,1,\"a\",[-1,2.1,30,4.5e+123],{\"x\":\"y\"}]'\nconsole.log(process.env.VARIABLE_3)     // (string) '[null,true,1,\" x y \"]'\nconsole.log(process.env.VARIABLE_4)     // (string) '[null,true,1,\" x y \"]'\nconsole.log(process.env.VARIABLE_5)     // (string) '[]'\nconsole.log(process.env.VARIABLE_6)     // (string) '[\"a\"]' // Special case\n```\n\n- **object**\n\nValues to be converted to object must match the format:\na string contains `${key}:${value}` separated by commas;\nthe `key` must be `\"string\"` and\nthe `value` could be `null`,`boolean`, `number`, `\"string\"`, `[..array..]` or `{..object..}`;\nand all could be wrapped or not wrapped by `{` and `}` (*must*, when the string is empty).\n\n*Spaces will be trimmed.*\n\n```dotenv\n# .env file\nVARIABLE_1={\"a\":null,\"b\":true,\"c\":1,\"d\":\"x\",\"e\":[-1,2.1,3e1,4.5e123],\"f\":{\"y\":\"z\"}}\nVARIABLE_2=\"\\\"a\\\":null,\\\"b\\\":true,\\\"c\\\":1,\\\"d\\\":\\\"x\\\",\\\"e\\\":[-1,2.1,3e1,4.5e123],\\\"f\\\":{\\\"y\\\":\\\"z\\\"}\"\nVARIABLE_3=\" [\\\"a\\\": null, \\\"b\\\": true, \\\"c\\\": 1, \\\"d\\\": \\\" x y \\\"] \"\nVARIABLE_4=\" \\\"a\\\": null, \\\"b\\\": true, \\\"c\\\": 1, \\\"d\\\": \\\" x y \\\" \"\nVARIABLE_5=\" { } \"\n```\n\n```javascript\nconst dotenv = require('dotenv')\nconst dotenvConversion = require('dotenv-conversion')\n/* or ES6 */\n// import dotenv from 'dotenv'\n// import dotenvConversion from 'dotenv-conversion'\n\nconst config = dotenv.config()\nconst {parsed} = dotenvConversion.convert(config)\nconsole.log(parsed.VARIABLE_1)          // (object) {\"a\": null, \"b\": true, \"c\": 1, \"d\": \"x\", \"e\": [-1, 2.1, 30, 4.5e+123], \"f\": {\"x\": \"y\"}} \nconsole.log(parsed.VARIABLE_2)          // (object) {\"a\": null, \"b\": true, \"c\": 1, \"d\": \"x\", \"e\": [-1, 2.1, 30, 4.5e+123], \"f\": {\"x\": \"y\"}} \nconsole.log(parsed.VARIABLE_3)          // (object) {\"a\": null, \"b\": true, \"c\": 1, \"d\": \" x y \"}\nconsole.log(parsed.VARIABLE_4)          // (object) {\"a\": null, \"b\": true, \"c\": 1, \"d\": \" x y \"}\nconsole.log(parsed.VARIABLE_5)          // (object) {}\nconsole.log(process.env.VARIABLE_1)     // (string) '{\"a\":null,\"b\":true,\"c\":1,\"d\":\"x\",\"e\":[-1,2.1,30,4.5e+123],\"f\":{\"y\":\"z\"}}'\nconsole.log(process.env.VARIABLE_2)     // (string) '{\"a\":null,\"b\":true,\"c\":1,\"d\":\"x\",\"e\":[-1,2.1,30,4.5e+123],\"f\":{\"y\":\"z\"}}'\nconsole.log(process.env.VARIABLE_3)     // (string) '{\"a\":null,\"b\":true,\"c\":1,\"d\":\" x y \"}'\nconsole.log(process.env.VARIABLE_4)     // (string) '{\"a\":null,\"b\":true,\"c\":1,\"d\":\" x y \"}'\nconsole.log(process.env.VARIABLE_5)     // (string) '{}'\n```\n\n### Conversion Methods\n\n[Auto-Conversion](#auto-conversion) also looks for the conversion method indicated by a variable\nwhen it cannot convert that variable to anything but a string,\nand uses the method to make the conversion.\n\nHow a variable indicates its conversion method:\n\n- Standalone:\n\n```javascript\nconst options = {\n    parsed: {\n        '${VARIABLE_1}': '${method}:${value}',\n        '${VARIABLE_2}': ' ${method}: ${value} ',\n    },\n    fromDotEnv: false,\n}\n\n// Example:\nconst options = {\n    parsed: {\n        BOOLEAN: 'boolean:1',\n        NUMBER: ' number: true ',\n    },\n    fromDotEnv: false,\n}\n\n// Unaccepted (no conversion):\nconst options = {\n    parsed: {\n        NOT_BOOLEAN: 'boolean :1',\n        NOT_NUMBER: ' number : true ',\n    },\n    fromDotEnv: false,\n}\n```\n\n- Within `.env` files:\n\n```dotenv\n${VARIABLE_1}=${method}:${value}\n${VARIABLE_2}=\" ${method}: ${value} \"\n\n# Example:\nBOOLEAN=boolean:1\nNUMBER=\" number: true \"\n\n# Unaccepted (no conversion):\nNOT_BOOLEAN=\"boolean :1\"\nNOT_NUMBER=\" number : true \"\n```\n\n***Note:* `method` is case-sensitive.\n\n#### Built-in Methods\n\nHere are built-in conversion methods (`boolean`, `number`, `bigint`, `string`, `symbol`, `array`, `object`)\nthat can be used now:\n\n- **boolean**\n\nThis method is to convert any value to `true` or `false`.\n\n```dotenv\n# .env file\nVARIABLE_1=\"boolean:\"                   # \u003cempty\u003e\nVARIABLE_2=\"boolean:false\"              # or: false, False, FALSE\nVARIABLE_3=\"boolean:no\"                 # or: no, No, NO\nVARIABLE_4=\"boolean:not\"                # or: not, Not, NOT\nVARIABLE_5=\"boolean:none\"               # or: none, None, NONE\nVARIABLE_6=\"boolean:null\"               # or: null, Null, NULL\nVARIABLE_7=\"boolean:undefined\"          # or: undefined, UNDEFINED\nVARIABLE_8=boolean:NaN\nVARIABLE_9=boolean:0\nVARIABLE_10=boolean:0.0e+0\nVARIABLE_11=boolean:0n\nVARIABLE_12=boolean:[]\nVARIABLE_13=boolean:{}\nVARIABLE_14=\"boolean:anything else\"\n```\n\n```javascript\nconst dotenv = require('dotenv')\nconst dotenvConversion = require('dotenv-conversion')\n/* or ES6 */\n// import dotenv from 'dotenv'\n// import dotenvConversion from 'dotenv-conversion'\n\nconst config = dotenv.config()\nconst {parsed} = dotenvConversion.convert(config)\nconsole.log(parsed.VARIABLE_1)          // (boolean) false \nconsole.log(parsed.VARIABLE_2)          // (boolean) false\nconsole.log(parsed.VARIABLE_3)          // (boolean) false\nconsole.log(parsed.VARIABLE_4)          // (boolean) false\nconsole.log(parsed.VARIABLE_5)          // (boolean) false\nconsole.log(parsed.VARIABLE_6)          // (boolean) false\nconsole.log(parsed.VARIABLE_7)          // (boolean) false\nconsole.log(parsed.VARIABLE_8)          // (boolean) false\nconsole.log(parsed.VARIABLE_9)          // (boolean) false\nconsole.log(parsed.VARIABLE_10)         // (boolean) false\nconsole.log(parsed.VARIABLE_11)         // (boolean) false\nconsole.log(parsed.VARIABLE_12)         // (boolean) false\nconsole.log(parsed.VARIABLE_13)         // (boolean) false\nconsole.log(parsed.VARIABLE_14)         // (boolean) true\nconsole.log(process.env.VARIABLE_1)     // (string) 'false'\nconsole.log(process.env.VARIABLE_2)     // (string) 'false'\nconsole.log(process.env.VARIABLE_3)     // (string) 'false'\nconsole.log(process.env.VARIABLE_4)     // (string) 'false'\nconsole.log(process.env.VARIABLE_5)     // (string) 'false'\nconsole.log(process.env.VARIABLE_6)     // (string) 'false'\nconsole.log(process.env.VARIABLE_7)     // (string) 'false'\nconsole.log(process.env.VARIABLE_8)     // (string) 'false'\nconsole.log(process.env.VARIABLE_9)     // (string) 'false'\nconsole.log(process.env.VARIABLE_10)    // (string) 'false'\nconsole.log(process.env.VARIABLE_11)    // (string) 'false'\nconsole.log(process.env.VARIABLE_12)    // (string) 'false'\nconsole.log(process.env.VARIABLE_13)    // (string) 'false'\nconsole.log(process.env.VARIABLE_14)    // (string) 'true'\n```\n\n- **number**\n\nThis method is to convert any value to number.\n\n```dotenv\n# .env file\nVARIABLE_1=\"number:\"            # \u003cempty\u003e\nVARIABLE_2=\"number:true\"        # or: True, TRUE\nVARIABLE_3=\"number:yes\"         # or: Yes, YES\nVARIABLE_4=\"number:ok\"          # or: Ok, OK\nVARIABLE_5=\"number:false\"       # or: False, FALSE\nVARIABLE_6=\"number:no\"          # or: No, NO\nVARIABLE_7=\"number:not\"         # or: Not, NOT\nVARIABLE_8=\"number:none\"        # or: None, NONE\nVARIABLE_9=\"number:null\"        # or: Null, NULL\nVARIABLE_10=\"number:undefined\"  # or: UNDEFINED\nVARIABLE_11=number:NaN\nVARIABLE_12=\"number:Infinity\"   # or: +Infinity\nVARIABLE_13=number:-Infinity\nVARIABLE_14=number:4.5e1\nVARIABLE_15=number:-4.5e-1\nVARIABLE_16=number:4.5e123\nVARIABLE_17=number:123string\nVARIABLE_18=number:string\nVARIABLE_19=number:[]\nVARIABLE_20=number:{}\nVARIABLE_21=number:0b1010\nVARIABLE_22=number:0b1010string\nVARIABLE_23=number:0o12\nVARIABLE_24=number:0o12string\nVARIABLE_25=number:0xa\nVARIABLE_26=number:0xastring\n```\n\n```javascript\nconst dotenv = require('dotenv')\nconst dotenvConversion = require('dotenv-conversion')\n/* or ES6 */\n// import dotenv from 'dotenv'\n// import dotenvConversion from 'dotenv-conversion'\n\nconst config = dotenv.config()\nconst {parsed} = dotenvConversion.convert(config)\nconsole.log(parsed.VARIABLE_1)          // (number) 0 \nconsole.log(parsed.VARIABLE_2)          // (number) 1\nconsole.log(parsed.VARIABLE_3)          // (number) 1\nconsole.log(parsed.VARIABLE_4)          // (number) 1\nconsole.log(parsed.VARIABLE_5)          // (number) 0\nconsole.log(parsed.VARIABLE_6)          // (number) 0\nconsole.log(parsed.VARIABLE_7)          // (number) 0\nconsole.log(parsed.VARIABLE_8)          // (number) 0\nconsole.log(parsed.VARIABLE_9)          // (number) 0\nconsole.log(parsed.VARIABLE_10)         // (number) NaN\nconsole.log(parsed.VARIABLE_11)         // (number) NaN\nconsole.log(parsed.VARIABLE_12)         // (number) Infinity\nconsole.log(parsed.VARIABLE_13)         // (number) -Infinity\nconsole.log(parsed.VARIABLE_14)         // (number) 45\nconsole.log(parsed.VARIABLE_15)         // (number) -0.45\nconsole.log(parsed.VARIABLE_16)         // (number) 4.5e+123\nconsole.log(parsed.VARIABLE_17)         // (number) 123\nconsole.log(parsed.VARIABLE_18)         // (number) 0\nconsole.log(parsed.VARIABLE_19)         // (number) 0\nconsole.log(parsed.VARIABLE_20)         // (number) 0\nconsole.log(parsed.VARIABLE_21)         // (number) 10\nconsole.log(parsed.VARIABLE_22)         // (number) 0\nconsole.log(parsed.VARIABLE_23)         // (number) 10\nconsole.log(parsed.VARIABLE_24)         // (number) 0\nconsole.log(parsed.VARIABLE_25)         // (number) 10\nconsole.log(parsed.VARIABLE_26)         // (number) 0\nconsole.log(process.env.VARIABLE_1)     // (string) '0'\nconsole.log(process.env.VARIABLE_2)     // (string) '1'\nconsole.log(process.env.VARIABLE_3)     // (string) '1'\nconsole.log(process.env.VARIABLE_4)     // (string) '1'\nconsole.log(process.env.VARIABLE_5)     // (string) '0'\nconsole.log(process.env.VARIABLE_6)     // (string) '0'\nconsole.log(process.env.VARIABLE_7)     // (string) '0'\nconsole.log(process.env.VARIABLE_8)     // (string) '0'\nconsole.log(process.env.VARIABLE_9)     // (string) '0'\nconsole.log(process.env.VARIABLE_10)    // (string) 'NaN'\nconsole.log(process.env.VARIABLE_11)    // (string) 'NaN'\nconsole.log(process.env.VARIABLE_12)    // (string) 'Infinity'\nconsole.log(process.env.VARIABLE_13)    // (string) '-Infinity'\nconsole.log(process.env.VARIABLE_14)    // (string) '45'\nconsole.log(process.env.VARIABLE_15)    // (string) '-0.45'\nconsole.log(process.env.VARIABLE_16)    // (string) '4.5e+123'\nconsole.log(process.env.VARIABLE_17)    // (string) '123'\nconsole.log(process.env.VARIABLE_18)    // (string) '0'\nconsole.log(process.env.VARIABLE_19)    // (string) '0'\nconsole.log(process.env.VARIABLE_20)    // (string) '0'\nconsole.log(process.env.VARIABLE_21)    // (string) '10'\nconsole.log(process.env.VARIABLE_22)    // (string) '0'\nconsole.log(process.env.VARIABLE_23)    // (string) '10'\nconsole.log(process.env.VARIABLE_24)    // (string) '0'\nconsole.log(process.env.VARIABLE_25)    // (string) '10'\nconsole.log(process.env.VARIABLE_26)    // (string) '0'\n```\n\n***Note:* You can disable the conversion for binary, octal or hexadecimal number format\nby setting the option [`binaryNumber`](#binarynumber),\n[`octalNumber`](#octalnumber) or [`hexadecimalNumber`](#hexadecimalnumber) to false.\n\n- **bigint**\n\nThis method is to convert any value to bigint.\n\n```dotenv\n# .env file\nVARIABLE_1=\"bigint:\"            # \u003cempty\u003e\nVARIABLE_2=\"bigint:true\"        # or: True, TRUE\nVARIABLE_3=\"bigint:yes\"         # or: Yes, YES\nVARIABLE_4=\"bigint:ok\"          # or: Ok, OK\nVARIABLE_5=\"bigint:false\"       # or: False, FALSE\nVARIABLE_6=\"bigint:no\"          # or: No, NO\nVARIABLE_7=\"bigint:not\"         # or: Not, NOT\nVARIABLE_8=\"bigint:none\"        # or: None, NONE\nVARIABLE_9=\"bigint:null\"        # or: Null, NULL\nVARIABLE_10=\"bigint:undefined\"  # or: UNDEFINED\nVARIABLE_11=bigint:NaN\nVARIABLE_12=\"bigint:Infinity\"   # or: +Infinity\nVARIABLE_13=bigint:-Infinity\nVARIABLE_14=bigint:4\nVARIABLE_15=bigint:-4.5\nVARIABLE_16=bigint:4.5e1\nVARIABLE_17=bigint:4.5e10\nVARIABLE_18=bigint:4.5e-123\nVARIABLE_19=bigint:123string\nVARIABLE_20=bigint:string\nVARIABLE_21=bigint:[]\nVARIABLE_22=bigint:{}\nVARIABLE_23=bigint:0b1010\nVARIABLE_24=bigint:0b1010string\nVARIABLE_25=bigint:0o12\nVARIABLE_26=bigint:0o12string\nVARIABLE_27=bigint:0xa\nVARIABLE_28=bigint:0xastring\n```\n\n```javascript\nconst dotenv = require('dotenv')\nconst dotenvConversion = require('dotenv-conversion')\n/* or ES6 */\n// import dotenv from 'dotenv'\n// import dotenvConversion from 'dotenv-conversion'\n\nconst config = dotenv.config()\nconst {parsed} = dotenvConversion.convert(config)\nconsole.log(parsed.VARIABLE_1)          // (bigint) 0n\nconsole.log(parsed.VARIABLE_2)          // (bigint) 1n\nconsole.log(parsed.VARIABLE_3)          // (bigint) 1n\nconsole.log(parsed.VARIABLE_4)          // (bigint) 1n\nconsole.log(parsed.VARIABLE_5)          // (bigint) 0n\nconsole.log(parsed.VARIABLE_6)          // (bigint) 0n\nconsole.log(parsed.VARIABLE_7)          // (bigint) 0n\nconsole.log(parsed.VARIABLE_8)          // (bigint) 0n\nconsole.log(parsed.VARIABLE_9)          // (bigint) 0n\nconsole.log(parsed.VARIABLE_10)         // (bigint) 0n\nconsole.log(parsed.VARIABLE_11)         // (bigint) 0n\nconsole.log(parsed.VARIABLE_12)         // (bigint) 1n\nconsole.log(parsed.VARIABLE_13)         // (bigint) -1n\nconsole.log(parsed.VARIABLE_14)         // (bigint) 4n\nconsole.log(parsed.VARIABLE_15)         // (bigint) -4n\nconsole.log(parsed.VARIABLE_16)         // (bigint) 45n\nconsole.log(parsed.VARIABLE_17)         // (bigint) 45000000000n\nconsole.log(parsed.VARIABLE_18)         // (bigint) 0n\nconsole.log(parsed.VARIABLE_19)         // (bigint) 123n\nconsole.log(parsed.VARIABLE_20)         // (bigint) 0n\nconsole.log(parsed.VARIABLE_21)         // (bigint) 0n\nconsole.log(parsed.VARIABLE_22)         // (bigint) 0n\nconsole.log(parsed.VARIABLE_23)         // (bigint) 10n\nconsole.log(parsed.VARIABLE_24)         // (bigint) 0n\nconsole.log(parsed.VARIABLE_25)         // (bigint) 10n\nconsole.log(parsed.VARIABLE_26)         // (bigint) 0n\nconsole.log(parsed.VARIABLE_27)         // (bigint) 10n\nconsole.log(parsed.VARIABLE_28)         // (bigint) 0n\nconsole.log(process.env.VARIABLE_1)     // (string) '0n'\nconsole.log(process.env.VARIABLE_2)     // (string) '1n'\nconsole.log(process.env.VARIABLE_3)     // (string) '1n'\nconsole.log(process.env.VARIABLE_4)     // (string) '1n'\nconsole.log(process.env.VARIABLE_5)     // (string) '0n'\nconsole.log(process.env.VARIABLE_6)     // (string) '0n'\nconsole.log(process.env.VARIABLE_7)     // (string) '0n'\nconsole.log(process.env.VARIABLE_8)     // (string) '0n'\nconsole.log(process.env.VARIABLE_9)     // (string) '0n'\nconsole.log(process.env.VARIABLE_10)    // (string) '0n'\nconsole.log(process.env.VARIABLE_11)    // (string) '0n'\nconsole.log(process.env.VARIABLE_12)    // (string) '1n'\nconsole.log(process.env.VARIABLE_13)    // (string) '-1n'\nconsole.log(process.env.VARIABLE_14)    // (string) '4n'\nconsole.log(process.env.VARIABLE_15)    // (string) '-4n'\nconsole.log(process.env.VARIABLE_16)    // (string) '45n'\nconsole.log(process.env.VARIABLE_17)    // (string) '45000000000n'\nconsole.log(process.env.VARIABLE_18)    // (string) '0n'\nconsole.log(process.env.VARIABLE_19)    // (string) '123n'\nconsole.log(process.env.VARIABLE_20)    // (string) '0n'\nconsole.log(process.env.VARIABLE_21)    // (string) '0n'\nconsole.log(process.env.VARIABLE_22)    // (string) '0n'\nconsole.log(process.env.VARIABLE_23)    // (string) '10n'\nconsole.log(process.env.VARIABLE_24)    // (string) '0n'\nconsole.log(process.env.VARIABLE_25)    // (string) '10n'\nconsole.log(process.env.VARIABLE_26)    // (string) '0n'\nconsole.log(process.env.VARIABLE_27)    // (string) '10n'\nconsole.log(process.env.VARIABLE_28)    // (string) '0n'\n```\n\n***Note:* You can disable the conversion for binary, octal or hexadecimal bigint format\nby setting the option [`binaryBigInt`](#binarybigint),\n[`octalBigInt`](#octalbigint) or [`hexadecimalBigInt`](#hexadecimalbigint) to false.\n\n- **string**\n\nThis method is to keep any value as it is.\n\n```dotenv\n# .env file\nVARIABLE_1=string:true\nVARIABLE_2=string:4.5e1\nVARIABLE_3=\" string: anything \"\n```\n\n```javascript\nconst dotenv = require('dotenv')\nconst dotenvConversion = require('dotenv-conversion')\n/* or ES6 */\n// import dotenv from 'dotenv'\n// import dotenvConversion from 'dotenv-conversion'\n\nconst config = dotenv.config()\nconst {parsed} = dotenvConversion.convert(config)\nconsole.log(parsed.VARIABLE_1)          // (string) 'true'\nconsole.log(parsed.VARIABLE_2)          // (string) '4.5e1'\nconsole.log(parsed.VARIABLE_3)          // (string) ' anything '\nconsole.log(process.env.VARIABLE_1)     // (string) 'true'\nconsole.log(process.env.VARIABLE_2)     // (string) '4.5e1'\nconsole.log(process.env.VARIABLE_3)     // (string) ' anything '\n```\n\n***Note:* [Auto-Conversion](#auto-conversion) will use the conversion method `string` for all variables\nthat it cannot convert to anything but a string.\nSo, `VARIABLE=text` is also the same as `VARIABLE=string:text`.\n\n- **symbol**\n\nThis method is to convert any value to symbol.\n\n```dotenv\n# .env file\nVARIABLE_1=\"symbol:\"\nVARIABLE_2=\"symbol: \"\nVARIABLE_3=\"symbol:a\"\nVARIABLE_4=\"symbol: a \"\nVARIABLE_5=\"symbol:Symbol()\"\nVARIABLE_6=\"symbol:Symbol( )\"\nVARIABLE_7=\"symbol:Symbol(a)\"\nVARIABLE_8=\"symbol:Symbol( a )\"\n```\n\n```javascript\nconst dotenv = require('dotenv')\nconst dotenvConversion = require('dotenv-conversion')\n/* or ES6 */\n// import dotenv from 'dotenv'\n// import dotenvConversion from 'dotenv-conversion'\n\nconst config = dotenv.config()\nconst {parsed} = dotenvConversion.convert(config)\nconsole.log(parsed.VARIABLE_1)          // (symbol) Symbol()\nconsole.log(parsed.VARIABLE_2)          // (symbol) Symbol(\" \")\nconsole.log(parsed.VARIABLE_3)          // (symbol) Symbol(\"a\")\nconsole.log(parsed.VARIABLE_4)          // (symbol) Symbol(\" a \")\nconsole.log(parsed.VARIABLE_5)          // (symbol) Symbol()\nconsole.log(parsed.VARIABLE_6)          // (symbol) Symbol(\" \")\nconsole.log(parsed.VARIABLE_7)          // (symbol) Symbol(\"a\")\nconsole.log(parsed.VARIABLE_8)          // (symbol) Symbol(\" a \")\nconsole.log(process.env.VARIABLE_1)     // (string) 'Symbol()'\nconsole.log(process.env.VARIABLE_2)     // (string) 'Symbol( )'\nconsole.log(process.env.VARIABLE_3)     // (string) 'Symbol(a)'\nconsole.log(process.env.VARIABLE_4)     // (string) 'Symbol( a )'\nconsole.log(process.env.VARIABLE_5)     // (string) 'Symbol()'\nconsole.log(process.env.VARIABLE_6)     // (string) 'Symbol( )'\nconsole.log(process.env.VARIABLE_7)     // (string) 'Symbol(a)'\nconsole.log(process.env.VARIABLE_8)     // (string) 'Symbol( a )'\n```\n\n- **array**\n\nThis method is to convert the value to array.\n\nIf the value cannot be converted, it will be returned itself.\n\n```dotenv\n# .env file\nVARIABLE_1=\"array:\" # \u003cempty\u003e\nVARIABLE_2=\"array: [ ] \"\nVARIABLE_3=array:[null,true,1,\"x\",[-1,2.1,3e1,4.5e123],{\"y\":\"z\"}]\nVARIABLE_4=array:null,true,1,\"x\",[-1,2.1,3e1,4.5e123],{\"y\":\"z\"}\nVARIABLE_5=\"array: 1, 2, 3\"\nVARIABLE_6=\"array: \\\"a\\\", \\\"b\\\", \\\"c\\\"\"\nVARIABLE_7=\"array: a, b, c\"\n```\n\n```javascript\nconst dotenv = require('dotenv')\nconst dotenvConversion = require('dotenv-conversion')\n/* or ES6 */\n// import dotenv from 'dotenv'\n// import dotenvConversion from 'dotenv-conversion'\n\nconst config = dotenv.config()\nconst {parsed} = dotenvConversion.convert(config)\nconsole.log(parsed.VARIABLE_1)          // (array) []\nconsole.log(parsed.VARIABLE_2)          // (array) []\nconsole.log(parsed.VARIABLE_3)          // (array) [null, true, 1, \"x\", [-1, 2.1, 30, 4.5e+123], {\"y\": \"z\"}]\nconsole.log(parsed.VARIABLE_4)          // (array) [null, true, 1, \"x\", [-1, 2.1, 30, 4.5e+123], {\"y\": \"z\"}]\nconsole.log(parsed.VARIABLE_5)          // (array) [1, 2, 3]\nconsole.log(parsed.VARIABLE_6)          // (array) [\"a\", \"b\", \"c\"]\nconsole.log(parsed.VARIABLE_7)          // (string) ' a, b, c'\nconsole.log(process.env.VARIABLE_1)     // (string) '[]'\nconsole.log(process.env.VARIABLE_2)     // (string) '[]'\nconsole.log(process.env.VARIABLE_3)     // (string) '[null,true,1,\"x\",[-1,2.1,30,4.5e+123],{\"y\":\"z\"}]'\nconsole.log(process.env.VARIABLE_4)     // (string) '[null,true,1,\"x\",[-1,2.1,30,4.5e+123],{\"y\":\"z\"}]'\nconsole.log(process.env.VARIABLE_5)     // (string) '[1,2,3]'\nconsole.log(process.env.VARIABLE_6)     // (string) '[\"a\",\"b\",\"c\"]'\nconsole.log(process.env.VARIABLE_7)     // (string) ' a, b, c'\n```\n\n- **object**\n\nThis method is to convert any value to object.\n\nIf the value cannot be converted, it will be returned itself.\n\n```dotenv\n# .env file\nVARIABLE_1=\"object:\" # \u003cempty\u003e\nVARIABLE_2=\"object: { } \"\nVARIABLE_3=object:{\"a\":null,\"b\":true,\"c\":1,\"d\":\"x\",\"e\":[-1,2.1,3e1,4.5e123],\"f\":{\"y\":\"z\"}}\nVARIABLE_4=object:\"a\":null,\"b\":true,\"c\":1,\"d\":\"x\",\"e\":[-1,2.1,3e1,4.5e123],\"f\":{\"y\":\"z\"}\nVARIABLE_5=\"object: \\\"a\\\": 1, \\\"b\\\": 2, \\\"c\\\": 3\"\nVARIABLE_6=\"object: \\\"a\\\": \\\"x\\\", \\\"b\\\": \\\"y\\\", \\\"c\\\": \\\"z\\\"\"\nVARIABLE_7=\"object: a: 1, b: 2, c: 3\"\nVARIABLE_8=\"object: \\\"a\\\": x, \\\"b\\\": y, \\\"c\\\": z\"\n```\n\n```javascript\nconst dotenv = require('dotenv')\nconst dotenvConversion = require('dotenv-conversion')\n/* or ES6 */\n// import dotenv from 'dotenv'\n// import dotenvConversion from 'dotenv-conversion'\n\nconst config = dotenv.config()\nconst {parsed} = dotenvConversion.convert(config)\nconsole.log(parsed.VARIABLE_1)          // (object) {}\nconsole.log(parsed.VARIABLE_2)          // (object) {}\nconsole.log(parsed.VARIABLE_3)          // (object) {\"a\": null, \"b\": true, \"c\": 1, \"d\": \"x\", \"e\": [-1, 2.1, 30, 4.5e+123], \"f\": {\"y\": \"z\"}}\nconsole.log(parsed.VARIABLE_4)          // (object) {\"a\": null, \"b\": true, \"c\": 1, \"d\": \"x\", \"e\": [-1, 2.1, 30, 4.5e+123], \"f\": {\"y\": \"z\"}}\nconsole.log(parsed.VARIABLE_5)          // (object) {\"a\": 1, \"b\": 2, \"c\": 3}\nconsole.log(parsed.VARIABLE_6)          // (object) {\"a\": \"x\", \"b\": \"y\", \"c\": \"z\"}\nconsole.log(parsed.VARIABLE_7)          // (string) ' a: 1, b: 2, c: 3'\nconsole.log(parsed.VARIABLE_7)          // (string) ' \"a\": x, \"b\": y, \"c\": z'\nconsole.log(process.env.VARIABLE_1)     // (string) '{}'\nconsole.log(process.env.VARIABLE_2)     // (string) '{}'\nconsole.log(process.env.VARIABLE_3)     // (string) '{\"a\": null,\"b\":true,\"c\":1,\"d\":\"x\",\"e\":[-1,2.1,30,4.5e+123],\"f\":{\"y\":\"z\"}}'\nconsole.log(process.env.VARIABLE_4)     // (string) '{\"a\": null,\"b\":true,\"c\":1,\"d\":\"x\",\"e\":[-1,2.1,30,4.5e+123],\"f\":{\"y\":\"z\"}}'\nconsole.log(process.env.VARIABLE_5)     // (string) '{\"a\":1,\"b\":2,\"c\":3}'\nconsole.log(process.env.VARIABLE_6)     // (string) '{\"a\":\"x\",\"b\":\"y\",\"c\":\"z\"}'\nconsole.log(process.env.VARIABLE_7)     // (string) ' a: 1, b: 2, c: 3'\nconsole.log(process.env.VARIABLE_8)     // (string) ' \"a\": x, \"b\": y, \"c\": z'\n```\n\n#### Custom Methods\n\nHere you can extend the `dotenv-conversion` by defining your own custom conversion methods.\n\n- Add new conversion method:\n\n```dotenv\n# .env file\nVARIABLE_1=custom:agree\nVARIABLE_2=custom:disagree\nVARIABLE_3=custom2:yes\nVARIABLE_4=custom2:agree\nVARIABLE_5=custom2:disagree\nVARIABLE_6=no_custom:yes\n```\n\n```javascript\nconst dotenv = require('dotenv')\nconst dotenvConversion = require('dotenv-conversion')\n/* or ES6 */\n// import dotenv from 'dotenv'\n// import dotenvConversion from 'dotenv-conversion'\n\nconst config = dotenv.config()\n\n// Define new conversion methods named `custom` and `custom2`\nconfig.methods = {\n    // brand new method\n    custom(value) {\n        return value === 'agree' ? true : false\n    },\n    // or want to reuse methods via `this`\n    custom2(value, ...params) {\n        // reuse built-in method\n        // When reusing any conversion method, \n        // make sure you pass all available params of the method to it\n        if (this.boolean(value, ...params)) {\n            return true\n        }\n        // reuse custom method\n        return this.custom(value)\n    },\n}\n\nconst {parsed} = dotenvConversion.convert(config)\nconsole.log(parsed.VARIABLE_1)          // (boolean) true\nconsole.log(parsed.VARIABLE_2)          // (boolean) false\nconsole.log(parsed.VARIABLE_3)          // (boolean) true\nconsole.log(parsed.VARIABLE_4)          // (boolean) true\nconsole.log(parsed.VARIABLE_5)          // (boolean) false\nconsole.log(parsed.VARIABLE_6)          // (string) 'no_custom:yes'\nconsole.log(process.env.VARIABLE_1)     // (string) 'true'\nconsole.log(process.env.VARIABLE_2)     // (string) 'false'\nconsole.log(process.env.VARIABLE_3)     // (string) 'true'\nconsole.log(process.env.VARIABLE_4)     // (string) 'true'\nconsole.log(process.env.VARIABLE_5)     // (string) 'false'\nconsole.log(process.env.VARIABLE_6)     // (string) 'no_custom:yes'\n```\n\n- Override built-in conversion methods:\n\n```dotenv\n# .env file\nVARIABLE_1=text\nVARIABLE_2=string:text\nVARIABLE_3=boolean:yes\nVARIABLE_4=boolean:true\n```\n\n```javascript\nconst dotenv = require('dotenv')\nconst dotenvConversion = require('dotenv-conversion')\n/* or ES6 */\n// import dotenv from 'dotenv'\n// import dotenvConversion from 'dotenv-conversion'\n\nconst config = dotenv.config()\n\n// Override built-int methods `string` and `boolean`\nconfig.methods = {\n    string(value) {\n        return value.toUpperCase()\n    },\n    boolean(value) {\n        return value === 'yes' ? true : false\n    },\n}\n\nconst {parsed} = dotenvConversion.convert(config)\nconsole.log(parsed.VARIABLE_1)          // (string) 'TEXT'\nconsole.log(parsed.VARIABLE_2)          // (string) 'TEXT'\nconsole.log(parsed.VARIABLE_3)          // (boolean) true\nconsole.log(parsed.VARIABLE_4)          // (boolean) false\nconsole.log(process.env.VARIABLE_1)     // (string) 'TEXT'\nconsole.log(process.env.VARIABLE_2)     // (string) 'TEXT'\nconsole.log(process.env.VARIABLE_3)     // (string) 'true'\nconsole.log(process.env.VARIABLE_4)     // (string) 'false'\n```\n\n***Note:* A conversion method always has 3 params in order: `value`, `name` and `config`.\n\n```dotenv\n# .env file\nVARIABLE=text\n```\n\n```javascript\nconst dotenv = require('dotenv')\nconst dotenvConversion = require('dotenv-conversion')\n/* or ES6 */\n// import dotenv from 'dotenv'\n// import dotenvConversion from 'dotenv-conversion'\n\nconst dotenvConfig = dotenv.config()\n\n// Override built-int methods `string`\ndotenvConfig.methods = {\n    string(value, name, config) {\n        console.log('value:', value)\n        console.log('name:', name)\n        console.log('config:', config)\n        return value\n    },\n}\n\nconst {parsed} = dotenvConversion.convert(dotenvConfig)\n\n/* CONSOLE OUTPUT:\nvalue: text\nname: VARIABLE\nconfig: {\n    parsed: { ... },\n    methods: { ... },\n    ...\n}\n*/\n```\n\n#### Method Aliases\n\nWhen you don't like the (long) method name, but you don't want to change it directly\nas well as you don't want to define a new method with a better name (and reuse the old method),\nhere is the feature for you.\n\n```dotenv\n# .env file\nVARIABLE_1=b:yes\nVARIABLE_2=uppercase:text\nVARIABLE_3=U:text\n```\n\n```javascript\nconst dotenv = require('dotenv')\nconst dotenvConversion = require('dotenv-conversion')\n/* or ES6 */\n// import dotenv from 'dotenv'\n// import dotenvConversion from 'dotenv-conversion'\n\nconst config = dotenv.config()\n\n// (optional) Define new custom conversion method name `uppercase`\nconfig.methods = {\n    uppercase(value) {\n        return value.toUpperCase()\n    },\n}\n\n// Define the method aliases\nconfig.methodAliases = {\n    // Alias to the built-in method `boolean`\n    b: 'boolean',\n    // (optional) Alias to the brand new method `uppercase`\n    U: 'uppercase',\n}\n\nconst {parsed} = dotenvConversion.convert(config)\nconsole.log(parsed.VARIABLE_1)          // (boolean) true\nconsole.log(parsed.VARIABLE_2)          // (string) 'TEXT'\nconsole.log(parsed.VARIABLE_3)          // (string) 'TEXT'\nconsole.log(process.env.VARIABLE_1)     // (string) 'true'\nconsole.log(process.env.VARIABLE_2)     // (string) 'TEXT'\nconsole.log(process.env.VARIABLE_3)     // (string) 'TEXT'\n```\n\nThere are also built-in aliases which are ready to use:\n\n- `bool` =\u003e `boolean`\n- `num` =\u003e `number`\n- `big` =\u003e `bigint`\n- `str` =\u003e `string`\n- `arr` =\u003e `array`\n- `obj` =\u003e `object`\n\n```dotenv\n# .env file\nVARIABLE_1=bool:yes\nVARIABLE_2=num:4.5e123\n```\n\n```javascript\nconst dotenv = require('dotenv')\nconst dotenvConversion = require('dotenv-conversion')\n/* or ES6 */\n// import dotenv from 'dotenv'\n// import dotenvConversion from 'dotenv-conversion'\n\nconst config = dotenv.config()\nconst {parsed} = dotenvConversion.convert(config)\nconsole.log(parsed.VARIABLE_1)          // (boolean) true\nconsole.log(parsed.VARIABLE_2)          // (number) 4.5e+123\nconsole.log(process.env.VARIABLE_1)     // (string) 'true'\nconsole.log(process.env.VARIABLE_2)     // (string) '4.5e+123'\n```\n\n***Note:*\n\n- You cannot override existing aliases.\n- Alias named by existing methods is not allowed\n- Alias to other alias is not allowed.\n\n```dotenv\n# .env file\nVARIABLE_1=customBool:yes\nVARIABLE_2=customString:text\nVARIABLE_3=bool:yes\nVARIABLE_4=string:text\nVARIABLE_5=b:yes\nVARIABLE_6=cb:yes\nVARIABLE_7=cs:text\nVARIABLE_8=bl:yes\n```\n\n```javascript\nconst dotenv = require('dotenv')\nconst dotenvConversion = require('dotenv-conversion')\n/* or ES6 */\n// import dotenv from 'dotenv'\n// import dotenvConversion from 'dotenv-conversion'\n\nconst config = dotenv.config()\n\n// New custom methods\nconfig.methods = {\n    customBool(value) {\n        return `CUSTOM_BOOL:${value}`\n    },\n    customString(value) {\n        return `CUSTOM_STRING:${value}`\n    },\n}\n\nconfig.methodAliases = {\n    // Not allowed aliases:\n    // - Override the existing alias `bool`,\n    //   expect the custom method `customBool` instead of the method `boolean` to work\n    bool: 'customBool',\n    // - Alias named by the existing method `string`, \n    //   expects the custom method `customString` to work\n    string: 'customString',\n    // - Alias to the existing alias `bool`, \n    //   expects the method `boolean` to work\n    b: 'bool',\n\n    // Fixing not allowed aliases\n    cb: 'customBool',\n    cs: 'customString',\n    bl: 'boolean',\n}\n\nconst {parsed} = dotenvConversion.convert(config)\nconsole.log(parsed.VARIABLE_1)          // (string) 'CUSTOM_BOOL:yes'\nconsole.log(parsed.VARIABLE_2)          // (string) 'CUSTOM_STRING:text'\nconsole.log(parsed.VARIABLE_3)          // (boolean) true       // wrong expect: 'CUSTOM_BOOL:yes'\nconsole.log(parsed.VARIABLE_4)          // (string) 'text'      // wrong expect: 'CUSTOM_STRING:text'\nconsole.log(parsed.VARIABLE_5)          // (string) 'b:yes'     // wrong expect: true\nconsole.log(parsed.VARIABLE_6)          // (string) 'CUSTOM_BOOL:yes'\nconsole.log(parsed.VARIABLE_7)          // (string) 'CUSTOM_STRING:text'\nconsole.log(parsed.VARIABLE_8)          // (boolean) true\nconsole.log(process.env.VARIABLE_1)     // (string) 'CUSTOM_BOOL:yes'\nconsole.log(process.env.VARIABLE_2)     // (string) 'CUSTOM_STRING:text'\nconsole.log(process.env.VARIABLE_3)     // (string) 'true'\nconsole.log(process.env.VARIABLE_4)     // (string) 'text'\nconsole.log(process.env.VARIABLE_5)     // (string) 'b:yes'\nconsole.log(process.env.VARIABLE_6)     // (string) 'CUSTOM_BOOL:yes'\nconsole.log(process.env.VARIABLE_7)     // (string) 'CUSTOM_STRING:text'\nconsole.log(process.env.VARIABLE_8)     // (string) 'true'\n```\n\n*** *Only alphanumeric (a-z, A-Z, 0-9), underscore (_) and dot (.) characters are allowed in naming the conversion\nmethods and aliases.*\n\n#### The special built-in method `auto`\n\nThe [Auto-Conversion](#auto-conversion) uses the built-in conversion method `auto`\nfor its automated execution.\n\nLogically, you can override it. But certainly, it is **HIGHLY NOT RECOMMENDED**,\nunless you want to change the whole auto-conversion process.\n\n```dotenv\n# .env file\nVARIABLE_1=text\nVARIABLE_2=true\nVARIABLE_3=123.5\nVARIABLE_4=boolean:yes\n```\n\n```javascript\nconst dotenv = require('dotenv')\nconst dotenvConversion = require('dotenv-conversion')\n/* or ES6 */\n// import dotenv from 'dotenv'\n// import dotenvConversion from 'dotenv-conversion'\n\nconst config = dotenv.config()\n\n// Override the conversion method `auto`\nconfig.methods = {\n    auto(value) {\n        return 'overridden'\n    },\n}\n\nconst {parsed} = dotenvConversion.convert(config)\nconsole.log(parsed.VARIABLE_1)          // (string) 'overridden'\nconsole.log(parsed.VARIABLE_2)          // (string) 'overridden'\nconsole.log(parsed.VARIABLE_3)          // (string) 'overridden'\nconsole.log(parsed.VARIABLE_4)          // (string) 'overridden'\nconsole.log(process.env.VARIABLE_1)     // (string) 'overridden'\nconsole.log(process.env.VARIABLE_2)     // (string) 'overridden'\nconsole.log(process.env.VARIABLE_3)     // (string) 'overridden'\nconsole.log(process.env.VARIABLE_4)     // (string) 'overridden'\n```\n\n***Note:* The override will affect only the [Auto-Conversion](#auto-conversion) feature.\n\nBesides, you need to avoid these worthless actions:\n\n- Defining [aliases](#method-aliases) to the `auto`.\n- Defining [custom conversions](#custom-conversion-for-a-specific-variable) that point to the `auto`.\n- Using `auto` like other methods to indicate conversion:\n    - Standalone: `{AUTO_BOOLEAN: \"auto:true\"}`, or\n    - Within `.env` files: `AUTO_BOOLEAN=auto:true`.\n\nThe reuse of the method `auto` could be an option if you know what to do:\n\n```dotenv\n# .env file\nSTATE=state:stop\n\nRUNNING_VALUE=true\nSTOPPED_VALUE_1={\"reason\":\"reason1\"}\nSTOPPED_VALUE_2={\"reason\":\"reason2\",\"code\":123}\n```\n\n```javascript\nconst dotenv = require('dotenv')\nconst dotenvConversion = require('dotenv-conversion')\n/* or ES6 */\n// import dotenv from 'dotenv'\n// import dotenvConversion from 'dotenv-conversion'\n\nconst config = dotenv.config()\n\nconst originEnv = {...config.parsed}\n// Define custom method `state` to replace current value with the value coming from \n// other environment variables which need to convert automatically.\nconfig.methods = {\n    state(value, ...params) {\n        switch (value) {\n            case 'running':\n                value = originEnv.RUNNING_VALUE\n                break\n            case 'stop2':\n                value = originEnv.STOPPED_VALUE_2\n                break\n            case 'stop1':\n            default:\n                value = originEnv.STOPPED_VALUE_1\n                break\n        }\n        // When reusing any conversion method, \n        // make sure you pass all available params of the method to it\n        return this.auto(value, ...params)\n    },\n}\n\nconst {parsed} = dotenvConversion.convert(config)\nconsole.log(parsed.STATE)          // (object) {\"reason\": \"reason1\"}\nconsole.log(process.env.STATE)     // (string) '{\"reason\":\"reason1\"}'\n```\n\n### Custom Conversion for a Specific Variable\n\nCustom conversion for a specific variable could be a function or\na string refers to a conversion method or alias as follows:\n\n```dotenv\n# .env file\nVARIABLE_1=agree\nVARIABLE_2=agree\nVARIABLE_3=agree\nVARIABLE_4=0\nVARIABLE_5=0\nVARIABLE_6=0\nVARIABLE_7=0\nVARIABLE_8=boolean:true\n```\n\n```javascript\nconst dotenv = require('dotenv')\nconst dotenvConversion = require('dotenv-conversion')\n/* or ES6 */\n// import dotenv from 'dotenv'\n// import dotenvConversion from 'dotenv-conversion'\n\nconst config = dotenv.config()\n\n// Define custom conversion for specific variables\nconfig.specs = {\n    // Custom conversion for `VARIABLE_2`\n    VARIABLE_2(value) {\n        return value === 'agree' ? true : false\n    },\n\n    // Custom conversion for `VARIABLE_3`\n    VARIABLE_3(value) {\n        // reuse custom conversion\n        return this.VARIABLE_2(value)\n    },\n\n    // Custom conversion for `VARIABLE_5\n    VARIABLE_5(value, ...params) {\n        // reuse conversion method\n        // When reusing any conversion method, \n        // make sure you pass all available params of the method to it\n        return config.methods.boolean(value, ...params)\n    },\n\n    // Custom conversion for `VARIABLE_6`\n    VARIABLE_6: 'boolean', // use the conversion method `boolean`\n\n    // Custom conversion for `VARIABLE_7`\n    VARIABLE_7: 'bool', // use the conversion method alias `bool` -\u003e `boolean`\n\n    // Custom conversion for `VARIABLE_8`\n    VARIABLE_8: 'anything-else', // the conversion method `string` will be used by default\n}\n\nconst {parsed} = dotenvConversion.convert(config)\nconsole.log(parsed.VARIABLE_1)          // (string) 'agree'\nconsole.log(parsed.VARIABLE_2)          // (boolean) true\nconsole.log(parsed.VARIABLE_3)          // (boolean) true\nconsole.log(parsed.VARIABLE_4)          // (number) 0\nconsole.log(parsed.VARIABLE_5)          // (boolean) false\nconsole.log(parsed.VARIABLE_6)          // (boolean) false\nconsole.log(parsed.VARIABLE_7)          // (boolean) false\nconsole.log(parsed.VARIABLE_8)          // (string) 'boolean:true'\nconsole.log(process.env.VARIABLE_1)     // (string) 'agree'\nconsole.log(process.env.VARIABLE_2)     // (string) 'true'\nconsole.log(process.env.VARIABLE_3)     // (string) 'true'\nconsole.log(process.env.VARIABLE_4)     // (string) '0'\nconsole.log(process.env.VARIABLE_5)     // (string) 'false'\nconsole.log(process.env.VARIABLE_6)     // (string) 'false'\nconsole.log(process.env.VARIABLE_7)     // (string) 'false'\nconsole.log(process.env.VARIABLE_8)     // (string) 'boolean:true'\n```\n\n***Note:* The function used in custom conversion also has 3 params in order\nlike the conversion methods: `value`, `name` and `config`.\nSee the note at the end of [Custom Methods](#custom-methods).\n\n### Prevent Variables from Conversion\n\n```dotenv\n# .env file\nVARIABLE_1=boolean:true\nVARIABLE_2=object:{\"foo\":\"bar\"}\nVARIABLE_3=boolean:true\nVARIABLE_4=object:{\"foo\":\"bar\"}\n```\n\n```javascript\nconst dotenv = require('dotenv')\nconst dotenvConversion = require('dotenv-conversion')\n/* or ES6 */\n// import dotenv from 'dotenv'\n// import dotenvConversion from 'dotenv-conversion'\n\nconst config = dotenv.config()\n\n// Declare variables that should be excluded in any conversion\nconfig.prevents = ['VARIABLE_3', 'VARIABLE_4']\n\nconst {parsed} = dotenvConversion.convert(config)\nconsole.log(parsed.VARIABLE_1)          // (boolean) true\nconsole.log(parsed.VARIABLE_2)          // (object) {\"foo\": \"bar\"}\nconsole.log(parsed.VARIABLE_3)          // (string) 'bool:true'\nconsole.log(parsed.VARIABLE_4)          // (string) 'object:{\"foo\":\"bar\"}'\nconsole.log(process.env.VARIABLE_1)     // (string) 'true'\nconsole.log(process.env.VARIABLE_2)     // (string) '{\"foo\":\"bar\"}'\nconsole.log(process.env.VARIABLE_3)     // (string) 'bool:true'\nconsole.log(process.env.VARIABLE_4)     // (string) 'object:{\"foo\":\"bar\"}'\n```\n\n### Ignore `process.env`\n\nBy default, after conversion, the variables will also be saved into `process.env` with their values kept in string\nformat.\nIf you want to ignore this execution, please do as follows:\n\n- Standalone:\n\n```javascript\nconst dotenvConversion = require('dotenv-conversion')\n/* or ES6 */\n// import dotenv from 'dotenv'\n// import dotenvConversion from 'dotenv-conversion'\n\nconst options = {\n    parsed: {\n        VARIABLE: 'yes',\n    },\n    fromDotEnv: false,\n}\n\n// Ignore process.env\noptions.ignoreProcessEnv = true\n\nconst {parsed} = dotenvConversion.convert(options)\nconsole.log(parsed.VARIABLE)        // (boolean) true\nconsole.log(process.env.VARIABLE)   // (undefined) undefined // if not ignore, value will be 'true'\n```\n\n- With `dotenv`:\n\n```dotenv\n# .env file\nVARIABLE=yes\n```\n\n```javascript\nconst dotenv = require('dotenv')\nconst dotenvConversion = require('dotenv-conversion')\n/* or ES6 */\n// import dotenv from 'dotenv'\n// import dotenvConversion from 'dotenv-conversion'\n\nconst config = dotenv.config()\n\n// Ignore process.env\nconfig.ignoreProcessEnv = true\n\nconst {parsed} = dotenvConversion.convert(config)\nconsole.log(parsed.VARIABLE)        // (boolean) true\nconsole.log(process.env.VARIABLE)   // (string) 'yes' // if not ignore, value will be 'true'\n```\n\n## Documentation\n\n`dotenv-conversion` exposes only 1 function:\n\n- `convert`\n\n### `convert`\n\n`convert` function will convert environment variables inside the `parsed` option.\nIts return value is the options used in conversion with the `parsed` option\nnow containing the converted environment variables.\n\n```javascript\nconst dotenvConversion = require('dotenv-conversion')\n/* or ES6 */\n// import dotenvConversion from 'dotenv-conversion'\n\nconst options = {\n    parsed: {\n        // ... environment variables\n    },\n    fromDotEnv: false, // if usage is `standalone`\n}\nconst result = dotenvConversion.convert(options)\nconsole.log(result)\n\n/* CONSOLE OUTPUT:\n{\n    parsed: {\n        // ... converted environment variables\n    },\n    fromDotEnv: false,\n    // ... other options\n}\n*/\n```\n\n#### Options\n\n##### `parsed`\n\n*Type:* `object`.\n\nThis option contains environment variables before and after converting.\n\n##### `fromDotEnv`\n\n*Type:* `boolean`. *Default:* `true`.\n\nIf using with `dotenv` or `dotenv-flow`, please do not set this option,\nor set it to `true`. Otherwise, remember to set it to `false`.\n\nSee [usage](#usage).\n\nThis option is due to an [issue of `dotenv`](https://github.com/motdotla/dotenv/issues/521)\nthat has not been resolved yet. When it is `true`, `dotenv-conversion` will apply its own fix.\n\n##### `ignoreProcessEnv`\n\n*Type:* `boolean`. *Default:* `false`.\n\nIf this option is set to `false`, the environment variables' values\nafter converting will be written back to `process.env`.\nIf this option is set to `true`, they won't.\n\nSee [this feature](#ignore-processenv).\n\n##### `binaryNumber`\n\n*Type:* `boolean`. *Default:* `true`.\n\nIf this option is set to `false`, the string in binary number format\nwill not be converted to number.\n\n##### `octalNumber`\n\n*Type:* `boolean`. *Default:* `true`.\n\nIf this option is set to `false`, the string in octal number format\nwill not be converted to number.\n\n##### `hexadecimalNumber`\n\n*Type:* `boolean`. *Default:* `true`.\n\nIf this option is set to `false`, the string in hexadecimal number format\nwill not be converted to number.\n\n##### `binaryBigInt`\n\n*Type:* `boolean`. *Default:* `true`.\n\nIf this option is set to `false`, the string in binary bigint format\nwill not be converted to bigint.\n\n##### `octalBigInt`\n\n*Type:* `boolean`. *Default:* `true`.\n\nIf this option is set to `false`, the string in octal bigint format\nwill not be converted to bigint.\n\n##### `hexadecimalBigInt`\n\n*Type:* `boolean`. *Default:* `true`.\n\nIf this option is set to `false`, the string in hexadecimal bigint format\nwill not be converted to bigint.\n\n##### `prevents`\n\n*Type:* `array`. *Default:* `[]`.\n\nList of environment variables which won't be converted.\n\nSee [this feature](#prevent-variables-from-conversion).\n\n##### `specs`\n\n*Type:* `object`. *Default:* `{}`.\n\nContains custom conversions for specific environment variables.\n\nSee [this feature](#custom-conversion-for-a-specific-variable).\n\n##### `methods`\n\n*Type:* `object`. *Default:* `{}`.\n\nContains custom conversion methods.\n\nSee [this feature](#custom-methods).\n\n##### `methodAliases`\n\n*Type:* `object`. *Default:* `{}`.\n\nContains conversion method aliases.\n\nSee [this feature](#method-aliases).\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Flinhntaim%2Fdotenv-conversion","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Flinhntaim%2Fdotenv-conversion","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Flinhntaim%2Fdotenv-conversion/lists"}