create-berna-stencil 2.0.8 → 2.0.9

package/src/backend/_core/vendor/vlucas/phpdotenv/README.md

@@ -1,370 +0,0 @@
-PHP dotenv
-==========
-
-Loads environment variables from `.env` to `getenv()`, `$_ENV` and `$_SERVER` automagically.
-
-![Banner](https://user-images.githubusercontent.com/2829600/71564012-31105580-2a91-11ea-9ad7-ef1278411b35.png)
-
-<p align="center">
-<a href="LICENSE"><img src="https://img.shields.io/badge/license-BSD%203--Clause-brightgreen.svg?style=flat-square" alt="Software License"></img></a>
-<a href="https://packagist.org/packages/vlucas/phpdotenv"><img src="https://img.shields.io/packagist/dt/vlucas/phpdotenv.svg?style=flat-square" alt="Total Downloads"></img></a>
-<a href="https://github.com/vlucas/phpdotenv/releases"><img src="https://img.shields.io/github/release/vlucas/phpdotenv.svg?style=flat-square" alt="Latest Version"></img></a>
-</p>
-
-<div align="center">
-
-**Special thanks to [our sponsors](https://github.com/sponsors/GrahamCampbell)**
-
-<hr>
-</div>
-
-
-## Why .env?
-
-**You should never store sensitive credentials in your code**. Storing
-[configuration in the environment](https://www.12factor.net/config) is one of
-the tenets of a [twelve-factor app](https://www.12factor.net/). Anything that
-is likely to change between deployment environments – such as database
-credentials or credentials for 3rd party services – should be extracted from
-the code into environment variables.
-
-Basically, a `.env` file is an easy way to load custom configuration variables
-that your application needs without having to modify .htaccess files or
-Apache/nginx virtual hosts. This means you won't have to edit any files outside
-the project, and all the environment variables are always set no matter how you
-run your project - Apache, Nginx, CLI, and even PHP's built-in webserver. It's
-WAY easier than all the other ways you know of to set environment variables,
-and you're going to love it!
-
-* NO editing virtual hosts in Apache or Nginx
-* NO adding `php_value` flags to .htaccess files
-* EASY portability and sharing of required ENV values
-* COMPATIBLE with PHP's built-in web server and CLI runner
-
-PHP dotenv is a PHP version of the original [Ruby
-dotenv](https://github.com/bkeepers/dotenv).
-
-
-## Installation
-
-Installation is super-easy via [Composer](https://getcomposer.org/):
-
-```bash
-$ composer require vlucas/phpdotenv
-```
-
-or add it by hand to your `composer.json` file.
-
-
-## Upgrading
-
-We follow [semantic versioning](https://semver.org/), which means breaking
-changes may occur between major releases. We have upgrading guides available
-for V2 to V3, V3 to V4 and V4 to V5 available [here](UPGRADING.md).
-
-
-## Usage
-
-The `.env` file is generally kept out of version control since it can contain
-sensitive API keys and passwords. A separate `.env.example` file is created
-with all the required environment variables defined except for the sensitive
-ones, which are either user-supplied for their own development environments or
-are communicated elsewhere to project collaborators. The project collaborators
-then independently copy the `.env.example` file to a local `.env` and ensure
-all the settings are correct for their local environment, filling in the secret
-keys or providing their own values when necessary. In this usage, the `.env`
-file should be added to the project's `.gitignore` file so that it will never
-be committed by collaborators.  This usage ensures that no sensitive passwords
-or API keys will ever be in the version control history so there is less risk
-of a security breach, and production values will never have to be shared with
-all project collaborators.
-
-Add your application configuration to a `.env` file in the root of your
-project. **Make sure the `.env` file is added to your `.gitignore` so it is not
-checked-in the code**
-
-```shell
-S3_BUCKET="dotenv"
-SECRET_KEY="souper_seekret_key"
-```
-
-Now create a file named `.env.example` and check this into the project. This
-should have the ENV variables you need to have set, but the values should
-either be blank or filled with dummy data. The idea is to let people know what
-variables are required, but not give them the sensitive production values.
-
-```shell
-S3_BUCKET="devbucket"
-SECRET_KEY="abc123"
-```
-
-You can then load `.env` in your application with:
-
-```php
-$dotenv = Dotenv\Dotenv::createImmutable(__DIR__);
-$dotenv->load();
-```
-
-To suppress the exception that is thrown when there is no `.env` file, you can:
-
-```php
-$dotenv = Dotenv\Dotenv::createImmutable(__DIR__);
-$dotenv->safeLoad();
-```
-
-Optionally you can pass in a filename as the second parameter, if you would
-like to use something other than `.env`:
-
-```php
-$dotenv = Dotenv\Dotenv::createImmutable(__DIR__, 'myconfig');
-$dotenv->load();
-```
-
-All of the defined variables are now available in the `$_ENV` and `$_SERVER`
-super-globals.
-
-```php
-$s3_bucket = $_ENV['S3_BUCKET'];
-$s3_bucket = $_SERVER['S3_BUCKET'];
-```
-
-
-### Putenv and Getenv
-
-Using `getenv()` and `putenv()` is strongly discouraged due to the fact that
-these functions are not thread safe, however it is still possible to instruct
-PHP dotenv to use these functions. Instead of calling
-`Dotenv::createImmutable`, one can call `Dotenv::createUnsafeImmutable`, which
-will add the `PutenvAdapter` behind the scenes. Your environment variables will
-now be available using the `getenv` method, as well as the super-globals:
-
-```php
-$s3_bucket = getenv('S3_BUCKET');
-$s3_bucket = $_ENV['S3_BUCKET'];
-$s3_bucket = $_SERVER['S3_BUCKET'];
-```
-
-
-### Nesting Variables
-
-It's possible to nest an environment variable within another, useful to cut
-down on repetition.
-
-This is done by wrapping an existing environment variable in `${…}` e.g.
-
-```shell
-BASE_DIR="/var/webroot/project-root"
-CACHE_DIR="${BASE_DIR}/cache"
-TMP_DIR="${BASE_DIR}/tmp"
-```
-
-
-### Immutability and Repository Customization
-
-Immutability refers to if Dotenv is allowed to overwrite existing environment
-variables. If you want Dotenv to overwrite existing environment variables,
-use `createMutable` instead of `createImmutable`:
-
-```php
-$dotenv = Dotenv\Dotenv::createMutable(__DIR__);
-$dotenv->load();
-```
-
-Behind the scenes, this is instructing the "repository" to allow immutability
-or not. By default, the repository is configured to allow overwriting existing
-values by default, which is relevant if one is calling the "create" method
-using the `RepositoryBuilder` to construct a more custom repository:
-
-```php
-$repository = Dotenv\Repository\RepositoryBuilder::createWithNoAdapters()
-    ->addAdapter(Dotenv\Repository\Adapter\EnvConstAdapter::class)
-    ->addWriter(Dotenv\Repository\Adapter\PutenvAdapter::class)
-    ->immutable()
-    ->make();
-
-$dotenv = Dotenv\Dotenv::create($repository, __DIR__);
-$dotenv->load();
-```
-
-The above example will write loaded values to `$_ENV` and `putenv`, but when
-interpolating environment variables, we'll only read from `$_ENV`. Moreover, it
-will never replace any variables already set before loading the file.
-
-By means of another example, one can also specify a set of variables to be
-allow listed. That is, only the variables in the allow list will be loaded:
-
-```php
-$repository = Dotenv\Repository\RepositoryBuilder::createWithDefaultAdapters()
-    ->allowList(['FOO', 'BAR'])
-    ->make();
-
-$dotenv = Dotenv\Dotenv::create($repository, __DIR__);
-$dotenv->load();
-```
-
-
-### Requiring Variables to be Set
-
-PHP dotenv has built in validation functionality, including for enforcing the
-presence of an environment variable. This is particularly useful to let people
-know any explicit required variables that your app will not work without.
-
-You can use a single string:
-
-```php
-$dotenv->required('DATABASE_DSN');
-```
-
-Or an array of strings:
-
-```php
-$dotenv->required(['DB_HOST', 'DB_NAME', 'DB_USER', 'DB_PASS']);
-```
-
-If any ENV vars are missing, Dotenv will throw a `RuntimeException` like this:
-
-```
-One or more environment variables failed assertions: DATABASE_DSN is missing
-```
-
-
-### Empty Variables
-
-Beyond simply requiring a variable to be set, you might also need to ensure the
-variable is not empty:
-
-```php
-$dotenv->required('DATABASE_DSN')->notEmpty();
-```
-
-If the environment variable is empty, you'd get an Exception:
-
-```
-One or more environment variables failed assertions: DATABASE_DSN is empty
-```
-
-
-### Integer Variables
-
-You might also need to ensure that the variable is of an integer value. You may
-do the following:
-
-```php
-$dotenv->required('FOO')->isInteger();
-```
-
-If the environment variable is not an integer, you'd get an Exception:
-
-```
-One or more environment variables failed assertions: FOO is not an integer.
-```
-
-One may only want to enforce validation rules when a variable is set. We
-support this too:
-
-```php
-$dotenv->ifPresent('FOO')->isInteger();
-```
-
-
-### Boolean Variables
-
-You may need to ensure a variable is in the form of a boolean, accepting
-"true", "false", "On", "1", "Yes", "Off", "0" and "No". You may do the
-following:
-
-```php
-$dotenv->required('FOO')->isBoolean();
-```
-
-If the environment variable is not a boolean, you'd get an Exception:
-
-```
-One or more environment variables failed assertions: FOO is not a boolean.
-```
-
-Similarly, one may write:
-
-```php
-$dotenv->ifPresent('FOO')->isBoolean();
-```
-
-
-### Allowed Values
-
-It is also possible to define a set of values that your environment variable
-should be. This is especially useful in situations where only a handful of
-options or drivers are actually supported by your code:
-
-```php
-$dotenv->required('SESSION_STORE')->allowedValues(['Filesystem', 'Memcached']);
-```
-
-If the environment variable wasn't in this list of allowed values, you'd get a
-similar Exception:
-
-```
-One or more environment variables failed assertions: SESSION_STORE is not an allowed value.
-```
-
-It is also possible to define a regex that your environment variable should be.
-```php
-$dotenv->required('FOO')->allowedRegexValues('([[:lower:]]{3})');
-```
-
-
-### Comments
-
-You can comment your `.env` file using the `#` character. E.g.
-
-```shell
-# this is a comment
-VAR="value" # comment
-VAR=value # comment
-```
-
-
-### Parsing Without Loading
-
-Sometimes you just wanna parse the file and resolve the nested environment variables, by giving us a string, and have an array returned back to you. While this is already possible, it is a little fiddly, so we have provided a direct way to do this:
-
-```php
-// ['FOO' => 'Bar', 'BAZ' => 'Hello Bar']
-Dotenv\Dotenv::parse("FOO=Bar\nBAZ=\"Hello \${FOO}\"");
-```
-
-This is exactly the same as:
-
-```php
-Dotenv\Dotenv::createArrayBacked(__DIR__)->load();
-```
-
-only, instead of providing the directory to find the file, you have directly provided the file contents.
-
-
-### Usage Notes
-
-When a new developer clones your codebase, they will have an additional
-one-time step to manually copy the `.env.example` file to `.env` and fill-in
-their own values (or get any sensitive values from a project co-worker).
-
-
-### Troubleshooting
-
-In certain server setups (most commonly found in shared hosting), PHP might deactivate superglobals like `$_ENV` or `$_SERVER`. If these variables are not set, review the `variables_order` in the `php.ini` file. See [php.net/manual/en/ini.core.php#ini.variables-order](https://www.php.net/manual/en/ini.core.php#ini.variables-order).
-
-## Security
-
-If you discover a security vulnerability within this package, please send an email to security@tidelift.com. All security vulnerabilities will be promptly addressed. You may view our full security policy [here](https://github.com/vlucas/phpdotenv/security/policy).
-
-
-## License
-
-PHP dotenv is licensed under [The BSD 3-Clause License](LICENSE).
-
-
-## For Enterprise
-
-Available as part of the Tidelift Subscription
-
-The maintainers of `vlucas/phpdotenv` and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. [Learn more.](https://tidelift.com/subscription/pkg/packagist-vlucas-phpdotenv?utm_source=packagist-vlucas-phpdotenv&utm_medium=referral&utm_campaign=enterprise&utm_term=repo)

package/src/backend/_core/vendor/vlucas/phpdotenv/UPGRADING.md

@@ -1,196 +0,0 @@
-# Upgrading Guide
-
-## V5.5 to V5.6
-
-Bumping the minimum required PHP version is not a breaking change, however it is notable. Since version 5.6.0, we now require PHP 7.2.5 or higher. Installation metrics show that for some time, PHP 7.1 has represented only around 0.1% of installs of V5.
-
-Release notes for 5.6.0 are available [here](https://github.com/vlucas/phpdotenv/releases/tag/v5.6.0).
-
-## V4 to V5
-
-### Introduction
-
-Version 5 bumps to PHP 7.1+, and adds some additional parameter typing. There have been some internal changes and refactorings too, but nothing that changes the overall feel and usage of the package. The Dotenv class itself is largely unchanged from V4.
-
-Release notes for 5.0.0 are available [here](https://github.com/vlucas/phpdotenv/releases/tag/v5.0.0).
-
-### Details
-
-1. The `Dotenv\Dotenv::createImmutable` and `Dotenv\Dotenv::createMutable` methods no longer call will result in `getenv` and `putenv` being called. One should instead use `Dotenv\Dotenv::createUnsafeImmutable` and `Dotenv\Dotenv::createUnsafeMutable` methods, if one really needs these functions.
-2. The `Dotenv\Dotenv` constructor has been modified to expect exactly 4 parameters: a store, a parser, a loader, and a repository. This likely won't affect many people, since it is more common to construct this class via the public static create methods. Those methods have not changed.
-3. Scalar typehints have been added to the public interface.
-4. The parser now returns a result type instead of raising an exception. This change is strictly internal, and most users won't notice a difference. The responsibility for raising an exception has simply been shifted up to the caller.
-5. Adapters have been refactored again, with changes to the repositories. In particular, the repository builder has been tweaked. It now expects to be explicitly told if you want to use the default adapters or not, and expects individual readers and writers to be added, one by one. Similar changes have been applied to the store factory. Moreover, the `ApacheAdapter` has been changed so that it behaves much like the other adapters. The old behaviour can be simulated by composing it with the new `ReplacingWriter` (see below). We will no longer include this adapter in our default setup, so that people can enable exactly what they need. Finally, by default, we will no longer be using the `PutenvAdapter`. It can be added, as required.
-6. Variable whitelisting has been replaced with allow listing, and the responsibility has moved from the loader to a new adapter `GuardedWriter`.
-7. The parser has been moved to its own namespace and parses entire files now. This change is expected to have little impact when upgrading. The `Lines` class has also moved to the parser namespace.
-8. The loader now only returns the variables that were actually loaded into the repository, and not all the variables from the file. Moreover, it now expects as input the result of running the new parser (an array of entries), rather than raw file content.
-
-The changes listed in (4) mean that instead of:
-
-```php
-$repository = Dotenv\Repository\RepositoryBuilder::create()
-    ->withReaders([
-        new Dotenv\Repository\Adapter\EnvConstAdapter(),
-    ])
-    ->withWriters([
-        new Dotenv\Repository\Adapter\EnvConstAdapter(),
-        new Dotenv\Repository\Adapter\PutenvAdapter(),
-    ])
-    ->make();
-```
-
-one would now write:
-
-```php
-$repository = Dotenv\Repository\RepositoryBuilder::createWithNoAdapters()
-    ->addAdapter(Dotenv\Repository\Adapter\EnvConstAdapter::class)
-    ->addWriter(Dotenv\Repository\Adapter\PutenvAdapter::class)
-    ->make();
-```
-
-Instead of passing class names, one can also pass actual adapter instances. Note that it is not possible to directly construct any of the adapters. One has to go via their static `create` method which returns an optional. This is to strictly encapsulate the fact that not all adapters are capable of running on all systems, and so those that cannot be run, cannot be created. For example, the apache adapter can only be run within an apache web server context. Passing the class names as in the above example will handle this for you, by adding the adapter only if it can be created (the optional has a value set).
-
-To add an apache environment variable writer that only writes to existing apache environment variables, as was the default in v4, one should do the following:
-
-```php
-$builder = Dotenv\Repository\RepositoryBuilder::createWithDefaultAdapters();
-
-Dotenv\Repository\Adapter\ApacheAdapter::create()->map(function ($adapter) {
-    return new Dotenv\Repository\Adapter\ReplacingWriter($adapter, $adapter);
-})->map([$builder, 'addWriter'])->getOrElse($builder);
-
-$repository = $builder->make();
-```
-
-The use of optionals handles the case where the apache environment functions are not available (such as in a CLI environment).
-
-## V4.0 to V4.1
-
-### Introduction
-
-Version 4.1 is a minor release, and as such, there are no breaking changes. There is, however a deprecation to be noted.
-
-### Details
-
-The `Dotenv\Dotenv` constructor now expects either an array of file paths as the third parameter, or an instance of `Dotenv\Store\StoreInterface`. Passing an array is deprecated, and will be removed in V5.
-
-## V3 to V4
-
-### Introduction
-
-Version 4 sees some refactoring, and support for escaping dollars in values (https://github.com/vlucas/phpdotenv/pull/380). It is no longer possible to change immutability on the fly, and the `Loader` no longer is responsible for tracking immutability. It is now the responsibility of "repositories" to track this. One must explicitly decide if they want (im)mutability when constructing an instance of `Dotenv\Dotenv`.
-
-Release notes for 4.0.0 are available [here](https://github.com/vlucas/phpdotenv/releases/tag/v4.0.0).
-
-### Details
-
-V4 has again changed the way you initialize the `Dotenv` class. If you want immutable loading of environment variables, then replace `Dotenv::create` with `Dotenv::createImmutable`, and if you want mutable loading, replace `Dotenv::create` with `Dotenv::createMutable` and `->overload()` with `->load()`. The `overload` method has been removed in favour of specifying mutability at object construction.
-
-The behaviour when parsing single quoted strings has now changed, to mimic the behaviour of bash. It is no longer possible to escape characters in single quoted strings, and everything is treated literally. As soon as the first single quote character is read, after the initial one, then the variable is treated as ending immediately at that point. When parsing unquoted or double quoted strings, it is now possible to escape dollar signs, to forcefully avoid variable interpolation. Escaping dollars is not mandated, in the sense that if a dollar is present, and not following by variable interpolation syntax, this is allowed, and the dollar will be treated as a literal dollar. Finally, interpolation of variables is now performed right to left, instead of left to right, so it is possible to nest interpolations to allow using the value of a variable as the name of another for further interpolation.
-
-The `getEnvironmentVariableNames` method is no longer available. This is because calls to `load()` (since v3.0.0) return an associative array of what was loaded, so `$dotenv->getEnvironmentVariableNames()` can be replaced with `array_keys($dotenv->load())`.
-
-There have been various internal refactorings. Apart from what has already been mentioned, the only other changes likely to affect developers is:
-
-1. The `Dotenv\Environment` namespace has been moved to `Dotenv\Repository`, the `Dotenv\Environment\Adapter\AdapterInterface` interface has been replaced by `Dotenv\Repository\Adapter\ReaderInterface` and `Dotenv\Repository\Adapter\WriterInterface`.
-2. The `Dotenv\Environment\DotenvFactory` has been (roughly) replaced by `Dotenv\Repository\RepositoryBuilder`, and `Dotenv\Environment\FactoryInterface` has been deleted.
-3. `Dotenv\Environment\AbstractVariables` has been replaced by `Dotenv\Repository\AbstractRepository`, `Dotenv\Environment\DotenvVariables` has been replaced by `Dotenv\Repository\AdapterRepository`, and `Dotenv\Environment\VariablesInterface` has been replaced by `Dotenv\Repository\RepositoryInterface`.
-4. The `Dotenv\Loader` class has been moved to `Dotenv\Loader\Loader`, and now has a different public interface. It no longer expects any parameters at construction, and implements only the new interface `Dotenv\Loader\LoaderInterface`. Its responsibility has changed to purely taking raw env file content, and handing it off to the parser, dealing with variable interpolation, and sending off instructions to the repository to set variables. No longer can it be used as a way to read the environment by callers, and nor does it track immutability.
-5. The `Dotenv\Parser` and `Dotenv\Lines` classes have moved to `Dotenv\Loader\Parser` and `Dotenv\Loader\Lines`, respectively. `Dotenv\Loader\Parser::parse` now return has either `null` or `Dotenv\Loader\Value` objects as values, instead of `string`s. This is to support the new variable interpolation and dollar escaping features.
-6. The `Dotenv\Validator` constructor has changed from `__construct(array $variables, Loader $loader, $required = true)` to `__construct(RepositoryInterface $repository, array $variables, $required = true)`.
-
-The example at the bottom of the below upgrading guide, in V4 now looks like:
-
-```php
-<?php
-
-use Dotenv\Dotenv;
-use Dotenv\Repository\Adapter\EnvConstAdapter;
-use Dotenv\Repository\Adapter\ServerConstAdapter;
-use Dotenv\Repository\RepositoryBuilder;
-
-$adapters = [
-	new EnvConstAdapter(),
-	new ServerConstAdapter(),
-];
-
-$repository = RepositoryBuilder::create()
-    ->withReaders($adapters)
-    ->withWriters($adapters)
-    ->immutable()
-    ->make();
-
-Dotenv::create($repository, $path, null)->load();
-```
-
-Since v3.2.0, it was easily possible to read a file and process variable interpolations, without actually "loading" the variables. This is still possible in v4.0.0. Example code that does this is as follows:
-
-```php
-<?php
-
-use Dotenv\Repository\Adapter\ArrayAdapter;
-use Dotenv\Repository\RepositoryBuilder;
-use Dotenv\Loader\Loader;
-
-$adapters = [new ArrayAdapter()];
-
-$repository = RepositoryBuilder::create()
-    ->withReaders($adapters)
-    ->withWriters($adapters)
-    ->make();
-
-$variables = (new Loader())->load($repository, $content);
-```
-
-Notice, that compared to v3, the loader no longer expects file paths in the constructor. Reading of the files is now managed by the `Dotenv\Dotenv` class. The loader is genuinely just loading the content into the repository.
-
-Finally, we note that the minimum supported version of PHP has increased to 5.5.9, up from 5.4.0 in V3 and 5.3.9 in V2.
-
-## V2 to V3
-
-### Introduction
-
-New in Version 3 is first-class support for multiline variables ([#301](https://github.com/vlucas/phpdotenv/pull/301)) and much more flexibility in terms of which parts of the environment we try to read and modify ([#300](https://github.com/vlucas/phpdotenv/pull/300)). Consequently, you will need to replace any occurrences of `new Dotenv(...)` with `Dotenv::create(...)`, since our new native constructor takes a `Loader` instance now, so that it can be truly customized if required. Finally, one should note that the loader will no longer be trimming values ([#302](https://github.com/vlucas/phpdotenv/pull/302)), moreover `Loader::load()` and its callers now return an associative array of the variables loaded with their values, rather than an array of raw lines from the environment file ([#306](https://github.com/vlucas/phpdotenv/pull/306)).
-
-Release notes for 3.0.0 are available [here](https://github.com/vlucas/phpdotenv/releases/tag/v3.0.0).
-
-### Details
-
-V3 has changed the way you initialize the `Dotenv` class. Consequently, you will need to replace any occurrences of new Dotenv(...) with Dotenv::create(...), since our new native constructor takes a `Loader` instance now.
-
-`Loader::load()` and its callers now return an associative array of the variables loaded with their values.
-
-Value parsing has been modified in the following ways:
-
-1. For unquoted strings, as soon as there's a hash, it's treated as a comment start.
-2. We're being stricter about invalid escape sequences within quoted strings.
-3. We're no longer trimming the parsed values of quoted strings.
-4. Multiline quoted values are now permitted, and will be parsed by V3.
-
-| input value | V2.5.2 | V2.6.1 | V3.3.1 |
-|-|-|-|-|
-| `foo#bar` | `foo#bar` | `foo#bar` | `foo` |
-| `foo # bar` | `foo` | `foo` | `foo` |
-| `"iiiiviiiixiiiiviiii\n"` | silent failure | `iiiviiiixiiiiviiii\n` | fails with invalid escape sequence exception |
-| `"iiiiviiiixiiiiviiii\\n"` | `iiiiviiiixiiiiviiii\n` | `iiiiviiiixiiiiviiii\n` | `iiiiviiiixiiiiviiii\n` |
-| `"foo\"bar"` | `foo"bar` | `foo"bar` | `foo"bar` |
-| `"  foo "` | `foo` with whitespace trimmed | `foo` with whitespace trimmed | `foo` with 2 spaces in front and one after |
-
-In double quoted strings, double quotes and backslashes need escaping with a backslash, and in single quoted strings, single quote and backslashes need escaping with a backslash. In v2.5.2, forgetting an escape can lead to odd results due to the regex running out of stack, but this was fixed in 2.6 and 3.3, with 2.6 allowing you to continue after an unescaped backslash, but 3.3 not.
-
-It's possible to use phpdotenv V3 in a threaded environment, instructing it to not call any functions that are not tread-safe:
-
-```php
-<?php
-
-use Dotenv\Dotenv;
-use Dotenv\Environment\Adapter\EnvConstAdapter;
-use Dotenv\Environment\Adapter\ServerConstAdapter;
-use Dotenv\Environment\DotenvFactory;
-
-$factory = new DotenvFactory([new EnvConstAdapter(), new ServerConstAdapter()]);
-
-Dotenv::create($path, null, $factory)->load();
-```
-
-Finally, we note that the minimum supported version of PHP has increased from 5.3.9 to 5.4.0.