@dotenvx/next-env 0.1.0 → 1.74.3

package/node_modules/ansi-colors/types/index.d.ts

@@ -0,0 +1,235 @@
+// Imported from DefinitelyTyped project.
+// TypeScript definitions for ansi-colors
+// Definitions by: Rogier Schouten <https://github.com/rogierschouten>
+// Integrated by: Jordan Mele <https://github.com/Silic0nS0ldier>
+
+interface SymbolsType {
+  /**
+   * `undefined` on windows, `✘` on other platforms.
+   */
+  ballotCross?: "✘";
+  ballotDisabled: "☒";
+  ballotOff: "☐";
+  ballotOn: "☑";
+  bullet: "•";
+  bulletWhite: "◦";
+  /**
+   * `√` on windows, `✔` on other platforms.
+   */
+  check: "√" | "✔";
+  /**
+   * `×` on windows, `✖` on other platforms.
+   */
+  cross: "×" | "✖";
+  /**
+   * `...` on windows, `⋯` on other platforms.
+   */
+  ellipsisLarge: "..." | "⋯";
+  /**
+   * `...` on windows, `…` on other platforms.
+   */
+  ellipsis: "..." | "…";
+  fullBlock: "█";
+  heart: "❤";
+  identicalTo: "≡";
+  info: "i" | "ℹ";
+  line: "─";
+  mark: "※";
+  middot: "·";
+  minus: "－";
+  multiplication: "×";
+  obelus: "÷";
+  pencilDownRight: "✎";
+  pencilRight: "✏";
+  pencilUpRight: "✐";
+  percent: "%";
+  pilcrow2: "❡";
+  pilcrow: "¶";
+  plusMinus: "±";
+  /**
+   * `>` on windows, `▸` on linux, and `❯` on other platforms.
+   */
+  pointer: ">" | "▸" | "❯";
+  /**
+   * `»` on windows, `‣` on linux, and `›` on other platforms.
+   */
+  pointerSmall: "»" | "‣" | "›";
+  question: "?";
+  /**
+   * `undefined` on windows, `？` on other platforms.
+   */
+  questionFull?: "？";
+  /**
+   * `?` on windows, `﹖` on other platforms.
+   */
+  questionSmall: "?" | "﹖";
+  /**
+   * `( )` on windows, `◯` on other platforms.
+   */
+  radioOff: "( )" | "◯";
+  /**
+   * `(*)` on windows, `◉` on other platforms.
+   */
+  radioOn: "(*)" | "◉";
+  section: "§";
+  starsOff: "☆";
+  starsOn: "★";
+  upDownArrow: "↕";
+  /**
+   * `‼` on windows, `⚠` on other platforms.
+   */
+  warning: "‼" | "⚠";
+}
+
+type StyleArrayStructure = [number, number];
+interface StyleArrayProperties {
+  open: string;
+  close: string;
+  closeRe: string;
+}
+
+type StyleType = StyleArrayStructure & StyleArrayProperties;
+
+
+interface StylesType<T> {
+  // modifiers
+  reset: T;
+  bold: T;
+  dim: T;
+  italic: T;
+  underline: T;
+  inverse: T;
+  hidden: T;
+  strikethrough: T;
+
+  // colors
+  black: T;
+  red: T;
+  green: T;
+  yellow: T;
+  blue: T;
+  magenta: T;
+  cyan: T;
+  white: T;
+  gray: T;
+  grey: T;
+
+  // bright colors
+  blackBright: T;
+  redBright: T;
+  greenBright: T;
+  yellowBright: T;
+  blueBright: T;
+  magentaBright: T;
+  cyanBright: T;
+  whiteBright: T;
+
+  // background colors
+  bgBlack: T;
+  bgRed: T;
+  bgGreen: T;
+  bgYellow: T;
+  bgBlue: T;
+  bgMagenta: T;
+  bgCyan: T;
+  bgWhite: T;
+
+  // bright background colors
+  bgBlackBright: T;
+  bgRedBright: T;
+  bgGreenBright: T;
+  bgYellowBright: T;
+  bgBlueBright: T;
+  bgMagentaBright: T;
+  bgCyanBright: T;
+  bgWhiteBright: T;
+}
+
+declare namespace ansiColors {
+  interface StyleFunction extends StylesType<StyleFunction> {
+    (s: string): string;
+  }
+
+  // modifiers
+  const reset: StyleFunction;
+  const bold: StyleFunction;
+  const dim: StyleFunction;
+  const italic: StyleFunction;
+  const underline: StyleFunction;
+  const inverse: StyleFunction;
+  const hidden: StyleFunction;
+  const strikethrough: StyleFunction;
+
+  // colors
+  const black: StyleFunction;
+  const red: StyleFunction;
+  const green: StyleFunction;
+  const yellow: StyleFunction;
+  const blue: StyleFunction;
+  const magenta: StyleFunction;
+  const cyan: StyleFunction;
+  const white: StyleFunction;
+  const gray: StyleFunction;
+  const grey: StyleFunction;
+
+  // bright colors
+  const blackBright: StyleFunction;
+  const redBright: StyleFunction;
+  const greenBright: StyleFunction;
+  const yellowBright: StyleFunction;
+  const blueBright: StyleFunction;
+  const magentaBright: StyleFunction;
+  const cyanBright: StyleFunction;
+  const whiteBright: StyleFunction;
+
+  // background colors
+  const bgBlack: StyleFunction;
+  const bgRed: StyleFunction;
+  const bgGreen: StyleFunction;
+  const bgYellow: StyleFunction;
+  const bgBlue: StyleFunction;
+  const bgMagenta: StyleFunction;
+  const bgCyan: StyleFunction;
+  const bgWhite: StyleFunction;
+
+  // bright background colors
+  const bgBlackBright: StyleFunction;
+  const bgRedBright: StyleFunction;
+  const bgGreenBright: StyleFunction;
+  const bgYellowBright: StyleFunction;
+  const bgBlueBright: StyleFunction;
+  const bgMagentaBright: StyleFunction;
+  const bgCyanBright: StyleFunction;
+  const bgWhiteBright: StyleFunction;
+
+  let enabled: boolean;
+  let visible: boolean;
+  const ansiRegex: RegExp;
+
+  /**
+   * Remove styles from string
+   */
+  function stripColor(s: string): string;
+
+  /**
+   * Remove styles from string
+   */
+  function strip(s: string): string;
+
+  /**
+   * Remove styles from string
+   */
+  function unstyle(s: string): string;
+
+  const styles: StylesType<StyleType>;
+  const symbols: SymbolsType;
+
+  /**
+   * Outputs a string with check-symbol as prefix
+   */
+  function ok(...args: string[]): string;
+
+  function create(): typeof ansiColors;
+}
+
+export = ansiColors;

package/node_modules/ansi-regex/index.d.ts

@@ -0,0 +1,37 @@
+declare namespace ansiRegex {
+	interface Options {
+		/**
+		Match only the first ANSI escape.
+
+		@default false
+		*/
+		onlyFirst: boolean;
+	}
+}
+
+/**
+Regular expression for matching ANSI escape codes.
+
+@example
+```
+import ansiRegex = require('ansi-regex');
+
+ansiRegex().test('\u001B[4mcake\u001B[0m');
+//=> true
+
+ansiRegex().test('cake');
+//=> false
+
+'\u001B[4mcake\u001B[0m'.match(ansiRegex());
+//=> ['\u001B[4m', '\u001B[0m']
+
+'\u001B[4mcake\u001B[0m'.match(ansiRegex({onlyFirst: true}));
+//=> ['\u001B[4m']
+
+'\u001B]8;;https://github.com\u0007click\u001B]8;;\u0007'.match(ansiRegex());
+//=> ['\u001B]8;;https://github.com\u0007', '\u001B]8;;\u0007']
+```
+*/
+declare function ansiRegex(options?: ansiRegex.Options): RegExp;
+
+export = ansiRegex;

package/node_modules/ansi-regex/index.js

@@ -0,0 +1,10 @@
+'use strict';
+
+module.exports = ({onlyFirst = false} = {}) => {
+	const pattern = [
+		'[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)',
+		'(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))'
+	].join('|');
+
+	return new RegExp(pattern, onlyFirst ? undefined : 'g');
+};

package/node_modules/ansi-regex/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/node_modules/ansi-regex/package.json

@@ -0,0 +1,55 @@
+{
+	"name": "ansi-regex",
+	"version": "5.0.1",
+	"description": "Regular expression for matching ANSI escape codes",
+	"license": "MIT",
+	"repository": "chalk/ansi-regex",
+	"author": {
+		"name": "Sindre Sorhus",
+		"email": "sindresorhus@gmail.com",
+		"url": "sindresorhus.com"
+	},
+	"engines": {
+		"node": ">=8"
+	},
+	"scripts": {
+		"test": "xo && ava && tsd",
+		"view-supported": "node fixtures/view-codes.js"
+	},
+	"files": [
+		"index.js",
+		"index.d.ts"
+	],
+	"keywords": [
+		"ansi",
+		"styles",
+		"color",
+		"colour",
+		"colors",
+		"terminal",
+		"console",
+		"cli",
+		"string",
+		"tty",
+		"escape",
+		"formatting",
+		"rgb",
+		"256",
+		"shell",
+		"xterm",
+		"command-line",
+		"text",
+		"regex",
+		"regexp",
+		"re",
+		"match",
+		"test",
+		"find",
+		"pattern"
+	],
+	"devDependencies": {
+		"ava": "^2.4.0",
+		"tsd": "^0.9.0",
+		"xo": "^0.25.3"
+	}
+}

package/node_modules/ansi-regex/readme.md

@@ -0,0 +1,78 @@
+# ansi-regex
+
+> Regular expression for matching [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code)
+
+
+## Install
+
+```
+$ npm install ansi-regex
+```
+
+
+## Usage
+
+```js
+const ansiRegex = require('ansi-regex');
+
+ansiRegex().test('\u001B[4mcake\u001B[0m');
+//=> true
+
+ansiRegex().test('cake');
+//=> false
+
+'\u001B[4mcake\u001B[0m'.match(ansiRegex());
+//=> ['\u001B[4m', '\u001B[0m']
+
+'\u001B[4mcake\u001B[0m'.match(ansiRegex({onlyFirst: true}));
+//=> ['\u001B[4m']
+
+'\u001B]8;;https://github.com\u0007click\u001B]8;;\u0007'.match(ansiRegex());
+//=> ['\u001B]8;;https://github.com\u0007', '\u001B]8;;\u0007']
+```
+
+
+## API
+
+### ansiRegex(options?)
+
+Returns a regex for matching ANSI escape codes.
+
+#### options
+
+Type: `object`
+
+##### onlyFirst
+
+Type: `boolean`<br>
+Default: `false` *(Matches any ANSI escape codes in a string)*
+
+Match only the first ANSI escape.
+
+
+## FAQ
+
+### Why do you test for codes not in the ECMA 48 standard?
+
+Some of the codes we run as a test are codes that we acquired finding various lists of non-standard or manufacturer specific codes. We test for both standard and non-standard codes, as most of them follow the same or similar format and can be safely matched in strings without the risk of removing actual string content. There are a few non-standard control codes that do not follow the traditional format (i.e. they end in numbers) thus forcing us to exclude them from the test because we cannot reliably match them.
+
+On the historical side, those ECMA standards were established in the early 90's whereas the VT100, for example, was designed in the mid/late 70's. At that point in time, control codes were still pretty ungoverned and engineers used them for a multitude of things, namely to activate hardware ports that may have been proprietary. Somewhere else you see a similar 'anarchy' of codes is in the x86 architecture for processors; there are a ton of "interrupts" that can mean different things on certain brands of processors, most of which have been phased out.
+
+
+## Maintainers
+
+- [Sindre Sorhus](https://github.com/sindresorhus)
+- [Josh Junon](https://github.com/qix-)
+
+
+---
+
+<div align="center">
+	<b>
+		<a href="https://tidelift.com/subscription/pkg/npm-ansi-regex?utm_source=npm-ansi-regex&utm_medium=referral&utm_campaign=readme">Get professional support for this package with a Tidelift subscription</a>
+	</b>
+	<br>
+	<sub>
+		Tidelift helps make open source sustainable for maintainers while giving companies<br>assurances about security, maintenance, and licensing for their dependencies.
+	</sub>
+</div>

package/node_modules/atomically/.editorconfig

@@ -0,0 +1,13 @@
+
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_size = 2
+indent_style = space
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.md]
+trim_trailing_whitespace = false

package/node_modules/atomically/.nvmrc

@@ -0,0 +1 @@
+v10.12.0

package/node_modules/atomically/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020-present Fabio Spampinato
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

package/node_modules/atomically/README.md

@@ -0,0 +1,147 @@
+# Atomically
+
+Read and write files atomically and reliably.
+
+## Features
+
+- Overview:
+  - This library is a rewrite of [`write-file-atomic`](https://github.com/npm/write-file-atomic), with some important enhancements on top, you can largely use this as a drop-in replacement.
+  - This library is written in TypeScript, so types aren't an afterthought but come with library.
+  - This library is slightly faster than [`write-file-atomic`](https://github.com/npm/write-file-atomic), and it can be 10x faster, while being essentially just as safe, by using the `fsyncWait` option.
+  - This library has 0 dependencies, so there's less code to vet and the entire thing is roughly 20% smaller than [`write-file-atomic`](https://github.com/npm/write-file-atomic).
+  - This library tries harder to write files on disk than [`write-file-atomic`](https://github.com/npm/write-file-atomic) does, by default retrying some failed operations and handling some more errors.
+- Reliability:
+  - Reads are retried, when appropriate, until they succeed or the timeout is reached.
+  - Writes are atomic, meaning that first a temporary file containing the new content is written, then this file is renamed to the final path, this way it's impossible to get a corrupt/partially-written file.
+  - Writes happening to the same path are queued, ensuring they don't interfere with each other.
+  - Temporary files can be configured to not be purged from disk if the write operation fails, which is useful for when keeping the temporary file is better than just losing data.
+  - Any needed missing parent folder will be created automatically.
+  - Symlinks are resolved automatically.
+  - `ENOSYS` errors on `chmod`/`chown` operations are ignored.
+  - `EINVAL`/`EPERM` errors on `chmod`/`chown` operations, in POSIX systems where the user is not root, are ignored.
+  - `EMFILE`/`ENFILE`/`EAGAIN`/`EBUSY`/`EACCESS`/`EACCS`/`EPERM` errors happening during necessary operations are caught and the operations are retried until they succeed or the timeout is reached.
+  - `ENAMETOOLONG` errors, both appening because of the final path or the temporary path, are attempted to be worked around by smartly truncating paths.
+- Temporary files:
+  - By default they are purged automatically once the write operation is completed or if the process exits (cleanly or not).
+  - By default they are created by appending a `.tmp-[timestamp][randomness]` suffix to destination paths:
+    - The `tmp-` part gives users a hint about the nature of these files, if they happen to see them.
+    - The `[timestamp]` part consists of the 10 least significant digits of a milliseconds-precise timestamp, making it likely that if more than one of these files are kept on disk the user will see them in chronological order.
+    - The `[randomness]` part consists of 6 random hex characters.
+    - If by any chance a collision is found then another suffix is generated.
+- Custom options:
+  - `chown`: it allows you to specify custom group and user ids:
+    - by default the old file's ids are copied over.
+    - if custom ids are provided they will be used.
+    - if `false` the default ids are used.
+  - `encoding`: it allows you to specify the encoding of the file content:
+    - by default when reading no encoding is specified and a raw buffer is returned.
+    - by default when writing `utf8` is used when.
+  - `fsync`: it allows you to control whether the `fsync` syscall is triggered right after writing the file or not:
+    - by default the syscall is triggered immediately after writing the file, increasing the chances that the file will actually be written to disk in case of imminent catastrophic failures, like power outages.
+    - if `false` the syscall won't be triggered.
+  - `fsyncWait`: it allows you to control whether the triggered `fsync` is waited or not:
+    - by default the syscall is waited.
+    - if `false` the syscall will still be triggered but not be waited.
+      - this increases performance 10x in some cases, and at the end of the day often there's no plan B if `fsync` fails anyway.
+  - `mode`: it allows you to specify the mode for the file:
+    - by default the old file's mode is copied over.
+    - if `false` then `0o666` is used.
+  - `schedule`: it's a function that returns a promise that resolves to a disposer function, basically it allows you to provide some custom queueing logic for the writing operation, allowing you to perhaps wire `atomically` with your app's main filesystem job scheduler:
+    - even when a custom `schedule` function is provided write operations will still be queued internally by the library too.
+  - `timeout`: it allows you to specify the amount of maximum milliseconds within which the library will retry some failed operations:
+    - when writing asynchronously by default it will keep retrying for 5000 milliseconds.
+    - when writing synchronously by default it will keep retrying for 100 milliseconds.
+    - if `0` or `-1` no failed operations will be retried.
+    - if another number is provided that will be the timeout interval.
+  - `tmpCreate`: it's a function that will be used to create the custom temporary file path in place of the default one:
+    - even when a custom function is provided the final temporary path will still be truncated if the library thinks that it may lead to `ENAMETOOLONG` errors.
+    - paths by default are truncated in a way that preserves an eventual existing leading dot and trailing extension.
+  - `tmpCreated`: it's a function that will be called with the newly created temporary file path.
+  - `tmpPurge`: it allows you to control whether the temporary file will be purged from the filesystem or not if the write fails:
+    - by default it will be purged.
+    - if `false` it will be kept on disk.
+
+## Install
+
+```sh
+npm install --save atomically
+```
+
+## Usage
+
+This is the shape of the optional options object:
+
+```ts
+type Disposer = () => void;
+
+type ReadOptions = string | {
+  encoding?: string | null,
+  mode?: string | number | false,
+  timeout?: number
+};
+
+type WriteOptions = string | {
+  chown?: { gid: number, uid: number } | false,
+  encoding?: string | null,
+  fsync?: boolean,
+  fsyncWait?: boolean,
+  mode?: string | number | false,
+  schedule?: ( filePath: string ) => Promise<Disposer>,
+  timeout?: number,
+  tmpCreate?: ( filePath: string ) => string,
+  tmpCreated?: ( filePath: string ) => any,
+  tmpPurge?: boolean
+};
+```
+
+This is the shape of the provided functions:
+
+```ts
+function readFile ( filePath: string, options?: ReadOptions ): Promise<Buffer | string>;
+function readFileSync ( filePath: string, options?: ReadOptions ): Buffer | string;
+function writeFile ( filePath: string, data: Buffer | string | undefined, options?: WriteOptions ): Promise<void>;
+function writeFileSync ( filePath: string, data: Buffer | string | undefined, options?: WriteOptions ): void;
+```
+
+This is how to use the library:
+
+```ts
+import {readFile, readFileSync, writeFile, writeFileSync} from 'atomically';
+
+// Asynchronous read with default option
+const buffer = await readFile ( '/foo.txt' );
+
+// Synchronous read assuming the encoding is "utf8"
+const string = readFileSync ( '/foo.txt', 'utf8' );
+
+// Asynchronous write with default options
+await writeFile ( '/foo.txt', 'my_data' );
+
+// Asynchronous write that doesn't prod the old file for a stat object at all
+await writeFile ( '/foo.txt', 'my_data', { chown: false, mode: false } );
+
+// 10x faster asynchronous write that's less resilient against imminent catastrophies
+await writeFile ( '/foo.txt', 'my_data', { fsync: false } );
+
+// 10x faster asynchronous write that's essentially still as resilient against imminent catastrophies
+await writeFile ( '/foo.txt', 'my_data', { fsyncWait: false } );
+
+// Asynchronous write with a custom schedule function
+await writeFile ( '/foo.txt', 'my_data', {
+  schedule: filePath => {
+    return new Promise ( resolve => { // When this returned promise will resolve the write operation will begin
+      MyScheduler.schedule ( filePath, () => { // Hypothetical scheduler function that will eventually tell us to go on with this write operation
+        const disposer = () => {}; // Hypothetical function that contains eventual clean-up logic, it will be called after the write operation has been completed (successfully or not)
+        resolve ( disposer ); // Resolving the promise with a disposer, beginning the write operation
+      })
+    });
+  }
+});
+
+// Synchronous write with default options
+writeFileSync ( '/foo.txt', 'my_data' );
+```
+
+## License
+
+MIT © Fabio Spampinato

package/node_modules/atomically/dist/consts.d.ts

@@ -0,0 +1,13 @@
+declare const DEFAULT_ENCODING = "utf8";
+declare const DEFAULT_FILE_MODE = 438;
+declare const DEFAULT_FOLDER_MODE = 511;
+declare const DEFAULT_READ_OPTIONS: {};
+declare const DEFAULT_WRITE_OPTIONS: {};
+declare const DEFAULT_TIMEOUT_ASYNC = 5000;
+declare const DEFAULT_TIMEOUT_SYNC = 100;
+declare const IS_POSIX = true;
+declare const IS_USER_ROOT: boolean;
+declare const LIMIT_BASENAME_LENGTH = 128;
+declare const LIMIT_FILES_DESCRIPTORS = 10000;
+declare const NOOP: () => void;
+export { DEFAULT_ENCODING, DEFAULT_FILE_MODE, DEFAULT_FOLDER_MODE, DEFAULT_READ_OPTIONS, DEFAULT_WRITE_OPTIONS, DEFAULT_TIMEOUT_ASYNC, DEFAULT_TIMEOUT_SYNC, IS_POSIX, IS_USER_ROOT, LIMIT_BASENAME_LENGTH, LIMIT_FILES_DESCRIPTORS, NOOP };

package/node_modules/atomically/dist/consts.js

@@ -0,0 +1,28 @@
+"use strict";
+/* CONSTS */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NOOP = exports.LIMIT_FILES_DESCRIPTORS = exports.LIMIT_BASENAME_LENGTH = exports.IS_USER_ROOT = exports.IS_POSIX = exports.DEFAULT_TIMEOUT_SYNC = exports.DEFAULT_TIMEOUT_ASYNC = exports.DEFAULT_WRITE_OPTIONS = exports.DEFAULT_READ_OPTIONS = exports.DEFAULT_FOLDER_MODE = exports.DEFAULT_FILE_MODE = exports.DEFAULT_ENCODING = void 0;
+const DEFAULT_ENCODING = 'utf8';
+exports.DEFAULT_ENCODING = DEFAULT_ENCODING;
+const DEFAULT_FILE_MODE = 0o666;
+exports.DEFAULT_FILE_MODE = DEFAULT_FILE_MODE;
+const DEFAULT_FOLDER_MODE = 0o777;
+exports.DEFAULT_FOLDER_MODE = DEFAULT_FOLDER_MODE;
+const DEFAULT_READ_OPTIONS = {};
+exports.DEFAULT_READ_OPTIONS = DEFAULT_READ_OPTIONS;
+const DEFAULT_WRITE_OPTIONS = {};
+exports.DEFAULT_WRITE_OPTIONS = DEFAULT_WRITE_OPTIONS;
+const DEFAULT_TIMEOUT_ASYNC = 5000;
+exports.DEFAULT_TIMEOUT_ASYNC = DEFAULT_TIMEOUT_ASYNC;
+const DEFAULT_TIMEOUT_SYNC = 100;
+exports.DEFAULT_TIMEOUT_SYNC = DEFAULT_TIMEOUT_SYNC;
+const IS_POSIX = !!process.getuid;
+exports.IS_POSIX = IS_POSIX;
+const IS_USER_ROOT = process.getuid ? !process.getuid() : false;
+exports.IS_USER_ROOT = IS_USER_ROOT;
+const LIMIT_BASENAME_LENGTH = 128; //TODO: fetch the real limit from the filesystem //TODO: fetch the whole-path length limit too
+exports.LIMIT_BASENAME_LENGTH = LIMIT_BASENAME_LENGTH;
+const LIMIT_FILES_DESCRIPTORS = 10000; //TODO: fetch the real limit from the filesystem
+exports.LIMIT_FILES_DESCRIPTORS = LIMIT_FILES_DESCRIPTORS;
+const NOOP = () => { };
+exports.NOOP = NOOP;

package/node_modules/atomically/dist/index.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { Callback, Data, Path, ReadOptions, WriteOptions } from './types';
+declare function readFile(filePath: Path, options: string | ReadOptions & {
+    encoding: string;
+}): Promise<string>;
+declare function readFile(filePath: Path, options?: ReadOptions): Promise<Buffer>;
+declare function readFileSync(filePath: Path, options: string | ReadOptions & {
+    encoding: string;
+}): string;
+declare function readFileSync(filePath: Path, options?: ReadOptions): Buffer;
+declare const writeFile: (filePath: Path, data: Data, options?: string | WriteOptions | Callback | undefined, callback?: Callback | undefined) => Promise<void>;
+declare const writeFileSync: (filePath: Path, data: Data, options?: string | WriteOptions) => void;
+export { readFile, readFileSync, writeFile, writeFileSync };