@jigging/jig 0.1.0-alpha.2 → 0.1.0-alpha.21

package/libexec/authoring/node_modules/tar/dist/commonjs/options.d.ts

@@ -0,0 +1,604 @@
+import { type GzipOptions, type ZlibOptions } from 'minizlib';
+import { type Stats } from 'node:fs';
+import { type ReadEntry } from './read-entry.js';
+import { type WarnData } from './warn-method.js';
+import type { WriteEntry } from './write-entry.js';
+/**
+ * The options that can be provided to tar commands.
+ *
+ * Note that some of these are only relevant for certain commands, since
+ * they are specific to reading or writing.
+ *
+ * Aliases are provided in the {@link TarOptionsWithAliases} type.
+ */
+export interface TarOptions {
+    /**
+     * Perform all I/O operations synchronously. If the stream is ended
+     * immediately, then it will be processed entirely synchronously.
+     */
+    sync?: boolean;
+    /**
+     * The tar file to be read and/or written. When this is set, a stream
+     * is not returned. Asynchronous commands will return a promise indicating
+     * when the operation is completed, and synchronous commands will return
+     * immediately.
+     */
+    file?: string;
+    /**
+     * Treat warnings as crash-worthy errors. Defaults false.
+     */
+    strict?: boolean;
+    /**
+     * The effective current working directory for this tar command
+     */
+    cwd?: string;
+    /**
+     * When creating a tar archive, this can be used to compress it as well.
+     * Set to `true` to use the default gzip options, or customize them as
+     * needed.
+     *
+     * When reading, if this is unset, then the compression status will be
+     * inferred from the archive data. This is generally best, unless you are
+     * sure of the compression settings in use to create the archive, and want to
+     * fail if the archive doesn't match expectations.
+     */
+    gzip?: boolean | GzipOptions;
+    /**
+     * When creating archives, preserve absolute and `..` paths in the archive,
+     * rather than sanitizing them under the cwd.
+     *
+     * When extracting, allow absolute paths, paths containing `..`, and
+     * extracting through symbolic links. By default, the root `/` is stripped
+     * from absolute paths (eg, turning `/x/y/z` into `x/y/z`), paths containing
+     * `..` are not extracted, and any file whose location would be modified by a
+     * symbolic link is not extracted.
+     *
+     * **WARNING** This is almost always unsafe, and must NEVER be used on
+     * archives from untrusted sources, such as user input, and every entry must
+     * be validated to ensure it is safe to write. Even if the input is not
+     * malicious, mistakes can cause a lot of damage!
+     */
+    preservePaths?: boolean;
+    /**
+     * When extracting, do not set the `mtime` value for extracted entries to
+     * match the `mtime` in the archive.
+     *
+     * When creating archives, do not store the `mtime` value in the entry. Note
+     * that this prevents properly using other mtime-based features (such as
+     * `tar.update` or the `newer` option) with the resulting archive.
+     */
+    noMtime?: boolean;
+    /**
+     * Set to `true` or an object with settings for `zlib.BrotliCompress()` to
+     * create a brotli-compressed archive
+     *
+     * When extracting, this will cause the archive to be treated as a
+     * brotli-compressed file if set to `true` or a ZlibOptions object.
+     *
+     * If set `false`, then brotli options will not be used.
+     *
+     * If this, the `gzip`, and `zstd` options are left `undefined`, then tar
+     * will attempt to infer the brotli compression status, but can only do so
+     * based on the filename. If the filename ends in `.tbr` or `.tar.br`, and
+     * the first 512 bytes are not a valid tar header, then brotli decompression
+     * will be attempted.
+     */
+    brotli?: boolean | ZlibOptions;
+    /**
+     * Set to `true` or an object with settings for `zstd.compress()` to
+     * create a zstd-compressed archive
+     *
+     * When extracting, this will cause the archive to be treated as a
+     * zstd-compressed file if set to `true` or a ZlibOptions object.
+     *
+     * If set `false`, then zstd options will not be used.
+     *
+     * If this, the `gzip`, and `brotli` options are left `undefined`, then tar
+     * will attempt to infer the zstd compression status, but can only do so
+     * based on the filename. If the filename ends in `.tzst` or `.tar.zst`, and
+     * the first 512 bytes are not a valid tar header, then zstd decompression
+     * will be attempted.
+     */
+    zstd?: boolean | ZlibOptions;
+    /**
+     * A function that is called with `(path, stat)` when creating an archive, or
+     * `(path, entry)` when extracting. Return true to process the file/entry, or
+     * false to exclude it.
+     */
+    filter?: (path: string, entry: Stats | ReadEntry) => boolean;
+    /**
+     * A function that gets called for any warning encountered.
+     *
+     * Note: if `strict` is set, then the warning will throw, and this method
+     * will not be called.
+     */
+    onwarn?: (code: string, message: string, data: WarnData) => unknown;
+    /**
+     * The maximum allowed ratio of decompressed bytes to compressed bytes when
+     * reading gzip, brotli, or zstd-compressed archives.
+     *
+     * This defaults to `1000` and aborts extraction or parsing when exceeded.
+     * Set to `Infinity` to disable the limit.
+     */
+    maxDecompressionRatio?: number;
+    /**
+     * When extracting, unlink files before creating them. Without this option,
+     * tar overwrites existing files, which preserves existing hardlinks. With
+     * this option, existing hardlinks will be broken, as will any symlink that
+     * would affect the location of an extracted file.
+     */
+    unlink?: boolean;
+    /**
+     * When extracting, strip the specified number of path portions from the
+     * entry path. For example, with `{strip: 2}`, the entry `a/b/c/d` would be
+     * extracted to `{cwd}/c/d`.
+     *
+     * Any entry whose entire path is stripped will be excluded.
+     */
+    strip?: number;
+    /**
+     * When extracting, keep the existing file on disk if it's newer than the
+     * file in the archive.
+     */
+    newer?: boolean;
+    /**
+     * When extracting, do not overwrite existing files at all.
+     */
+    keep?: boolean;
+    /**
+     * When extracting, set the `uid` and `gid` of extracted entries to the `uid`
+     * and `gid` fields in the archive. Defaults to true when run as root, and
+     * false otherwise.
+     *
+     * If false, then files and directories will be set with the owner and group
+     * of the user running the process. This is similar to `-p` in `tar(1)`, but
+     * ACLs and other system-specific data is never unpacked in this
+     * implementation, and modes are set by default already.
+     */
+    preserveOwner?: boolean;
+    /**
+     * The maximum depth of subfolders to extract into. This defaults to 1024.
+     * Anything deeper than the limit will raise a warning and skip the entry.
+     * Set to `Infinity` to remove the limitation.
+     */
+    maxDepth?: number;
+    /**
+     * When extracting, force all created files and directories, and all
+     * implicitly created directories, to be owned by the specified user id,
+     * regardless of the `uid` field in the archive.
+     *
+     * Cannot be used along with `preserveOwner`. Requires also setting the `gid`
+     * option.
+     */
+    uid?: number;
+    /**
+     * When extracting, force all created files and directories, and all
+     * implicitly created directories, to be owned by the specified group id,
+     * regardless of the `gid` field in the archive.
+     *
+     * Cannot be used along with `preserveOwner`. Requires also setting the `uid`
+     * option.
+     */
+    gid?: number;
+    /**
+     * When extracting, provide a function that takes an `entry` object, and
+     * returns a stream, or any falsey value. If a stream is provided, then that
+     * stream's data will be written instead of the contents of the archive
+     * entry. If a falsey value is provided, then the entry is written to disk as
+     * normal.
+     *
+     * To exclude items from extraction, use the `filter` option.
+     *
+     * Note that using an asynchronous stream type with the `transform` option
+     * will cause undefined behavior in synchronous extractions.
+     * [MiniPass](http://npm.im/minipass)-based streams are designed for this use
+     * case.
+     */
+    transform?: (entry: ReadEntry) => ReadEntry | null | undefined | false | 0 | '';
+    /**
+     * Call `chmod()` to ensure that extracted files match the entry's mode
+     * field. Without this field set, all mode fields in archive entries are a
+     * best effort attempt only.
+     *
+     * Setting this necessitates a call to the deprecated `process.umask()`
+     * method to determine the default umask value, unless a `processUmask`
+     * config is provided as well.
+     *
+     * If not set, tar will attempt to create file system entries with whatever
+     * mode is provided, and let the implicit process `umask` apply normally, but
+     * if a file already exists to be written to, then its existing mode will not
+     * be modified.
+     *
+     * When setting `chmod: true`, it is highly recommend to set the
+     * {@link TarOptions#processUmask} option as well, to avoid the call to the
+     * deprecated (and thread-unsafe) `process.umask()` method.
+     */
+    chmod?: boolean;
+    /**
+     * When setting the {@link TarOptions#chmod} option to `true`, you may
+     * provide a value here to avoid having to call the deprecated and
+     * thread-unsafe `process.umask()` method.
+     *
+     * This has no effect with `chmod` is not set to true, as mode values are not
+     * set explicitly anyway. If `chmod` is set to `true`, and a value is not
+     * provided here, then `process.umask()` must be called, which will result in
+     * deprecation warnings.
+     *
+     * The most common values for this are `0o22` (resulting in directories
+     * created with mode `0o755` and files with `0o644` by default) and `0o2`
+     * (resulting in directores created with mode `0o775` and files `0o664`, so
+     * they are group-writable).
+     */
+    processUmask?: number;
+    /**
+     * When parsing/listing archives, `entry` streams are by default resumed
+     * (set into "flowing" mode) immediately after the call to `onReadEntry()`.
+     * Set `noResume: true` to suppress this behavior.
+     *
+     * Note that when this is set, the stream will never complete until the
+     * data is consumed somehow.
+     *
+     * Set automatically in extract operations, since the entry is piped to
+     * a file system entry right away. Only relevant when parsing.
+     */
+    noResume?: boolean;
+    /**
+     * When creating, updating, or replacing within archives, this method will
+     * be called with each WriteEntry that is created.
+     */
+    onWriteEntry?: (entry: WriteEntry) => unknown;
+    /**
+     * When extracting or listing archives, this method will be called with
+     * each entry that is not excluded by a `filter`.
+     *
+     * Important when listing archives synchronously from a file, because there
+     * is otherwise no way to interact with the data!
+     */
+    onReadEntry?: (entry: ReadEntry) => unknown;
+    /**
+     * Pack the targets of symbolic links rather than the link itself.
+     */
+    follow?: boolean;
+    /**
+     * When creating archives, omit any metadata that is system-specific:
+     * `ctime`, `atime`, `uid`, `gid`, `uname`, `gname`, `dev`, `ino`, and
+     * `nlink`. Note that `mtime` is still included, because this is necessary
+     * for other time-based operations such as `tar.update`. Additionally, `mode`
+     * is set to a "reasonable default" for mose unix systems, based on an
+     * effective `umask` of `0o22`.
+     *
+     * This also defaults the `portable` option in the gzip configs when creating
+     * a compressed archive, in order to produce deterministic archives that are
+     * not operating-system specific.
+     */
+    portable?: boolean;
+    /**
+     * When creating archives, do not recursively archive the contents of
+     * directories. By default, archiving a directory archives all of its
+     * contents as well.
+     */
+    noDirRecurse?: boolean;
+    /**
+     * Suppress Pax extended headers when creating archives. Note that this means
+     * long paths and linkpaths will be truncated, and large or negative numeric
+     * values may be interpreted incorrectly.
+     */
+    noPax?: boolean;
+    /**
+     * Set to a `Date` object to force a specific `mtime` value for everything
+     * written to an archive.
+     *
+     * This is useful when creating archives that are intended to be
+     * deterministic based on their contents, irrespective of the file's last
+     * modification time.
+     *
+     * Overridden by `noMtime`.
+     */
+    mtime?: Date;
+    /**
+     * A path portion to prefix onto the entries added to an archive.
+     */
+    prefix?: string;
+    /**
+     * The mode to set on any created file archive, defaults to 0o666
+     * masked by the process umask, often resulting in 0o644.
+     *
+     * This does *not* affect the mode fields of individual entries, or the
+     * mode status of extracted entries on the filesystem.
+     */
+    mode?: number;
+    /**
+     * A cache of mtime values, to avoid having to stat the same file repeatedly.
+     *
+     * @internal
+     */
+    mtimeCache?: Map<string, Date>;
+    /**
+     * maximum buffer size for `fs.read()` operations.
+     *
+     * @internal
+     */
+    maxReadSize?: number;
+    /**
+     * Filter modes of entries being unpacked, like `process.umask()`
+     *
+     * @internal
+     */
+    umask?: number;
+    /**
+     * Default mode for directories. Used for all implicitly created directories,
+     * and any directories in the archive that do not have a mode field.
+     *
+     * @internal
+     */
+    dmode?: number;
+    /**
+     * default mode for files
+     *
+     * @internal
+     */
+    fmode?: number;
+    /**
+     * Map that tracks which directories already exist, for extraction
+     *
+     * @internal
+     */
+    dirCache?: Map<string, boolean>;
+    /**
+     * maximum supported size of meta entries. Defaults to 1MB
+     *
+     * @internal
+     */
+    maxMetaEntrySize?: number;
+    /**
+     * A Map object containing the device and inode value for any file whose
+     * `nlink` value is greater than 1, to identify hard links when creating
+     * archives.
+     *
+     * @internal
+     */
+    linkCache?: Map<LinkCacheKey, string>;
+    /**
+     * A map object containing the results of `fs.readdir()` calls.
+     *
+     * @internal
+     */
+    readdirCache?: Map<string, string[]>;
+    /**
+     * A cache of all `lstat` results, for use in creating archives.
+     *
+     * @internal
+     */
+    statCache?: Map<string, Stats>;
+    /**
+     * Number of concurrent jobs to run when creating archives.
+     *
+     * Defaults to 4.
+     *
+     * @internal
+     */
+    jobs?: number;
+    /**
+     * Automatically set to true on Windows systems.
+     *
+     * When extracting, causes behavior where filenames containing `<|>?:`
+     * characters are converted to windows-compatible escape sequences in the
+     * created filesystem entries.
+     *
+     * When packing, causes behavior where paths replace `\` with `/`, and
+     * filenames containing the windows-compatible escaped forms of `<|>?:` are
+     * converted to actual `<|>?:` characters in the archive.
+     *
+     * @internal
+     */
+    win32?: boolean;
+    /**
+     * For `WriteEntry` objects, the absolute path to the entry on the
+     * filesystem. By default, this is `resolve(cwd, entry.path)`, but it can be
+     * overridden explicitly.
+     *
+     * @internal
+     */
+    absolute?: string;
+    /**
+     * Used with Parser stream interface, to attach and take over when the
+     * stream is completely parsed. If this is set, then the prefinish,
+     * finish, and end events will not fire, and are the responsibility of
+     * the ondone method to emit properly.
+     *
+     * @internal
+     */
+    ondone?: () => void;
+    /**
+     * Mostly for testing, but potentially useful in some cases.
+     * Forcibly trigger a chown on every entry, no matter what.
+     */
+    forceChown?: boolean;
+    /**
+     * ambiguous deprecated name for {@link onReadEntry}
+     *
+     * @deprecated
+     */
+    onentry?: (entry: ReadEntry) => unknown;
+}
+export type TarOptionsSync = TarOptions & {
+    sync: true;
+};
+export type TarOptionsAsync = TarOptions & {
+    sync?: false;
+};
+export type TarOptionsFile = TarOptions & {
+    file: string;
+};
+export type TarOptionsNoFile = TarOptions & {
+    file?: undefined;
+};
+export type TarOptionsSyncFile = TarOptionsSync & TarOptionsFile;
+export type TarOptionsAsyncFile = TarOptionsAsync & TarOptionsFile;
+export type TarOptionsSyncNoFile = TarOptionsSync & TarOptionsNoFile;
+export type TarOptionsAsyncNoFile = TarOptionsAsync & TarOptionsNoFile;
+export type LinkCacheKey = `${number}:${number}`;
+export interface TarOptionsWithAliases extends TarOptions {
+    /**
+     * The effective current working directory for this tar command
+     */
+    C?: TarOptions['cwd'];
+    /**
+     * The tar file to be read and/or written. When this is set, a stream
+     * is not returned. Asynchronous commands will return a promise indicating
+     * when the operation is completed, and synchronous commands will return
+     * immediately.
+     */
+    f?: TarOptions['file'];
+    /**
+     * When creating a tar archive, this can be used to compress it as well.
+     * Set to `true` to use the default gzip options, or customize them as
+     * needed.
+     *
+     * When reading, if this is unset, then the compression status will be
+     * inferred from the archive data. This is generally best, unless you are
+     * sure of the compression settings in use to create the archive, and want to
+     * fail if the archive doesn't match expectations.
+     */
+    z?: TarOptions['gzip'];
+    /**
+     * When creating archives, preserve absolute and `..` paths in the archive,
+     * rather than sanitizing them under the cwd.
+     *
+     * When extracting, allow absolute paths, paths containing `..`, and
+     * extracting through symbolic links. By default, the root `/` is stripped
+     * from absolute paths (eg, turning `/x/y/z` into `x/y/z`), paths containing
+     * `..` are not extracted, and any file whose location would be modified by a
+     * symbolic link is not extracted.
+     *
+     * **WARNING** This is almost always unsafe, and must NEVER be used on
+     * archives from untrusted sources, such as user input, and every entry must
+     * be validated to ensure it is safe to write. Even if the input is not
+     * malicious, mistakes can cause a lot of damage!
+     */
+    P?: TarOptions['preservePaths'];
+    /**
+     * When extracting, unlink files before creating them. Without this option,
+     * tar overwrites existing files, which preserves existing hardlinks. With
+     * this option, existing hardlinks will be broken, as will any symlink that
+     * would affect the location of an extracted file.
+     */
+    U?: TarOptions['unlink'];
+    /**
+     * When extracting, strip the specified number of path portions from the
+     * entry path. For example, with `{strip: 2}`, the entry `a/b/c/d` would be
+     * extracted to `{cwd}/c/d`.
+     */
+    'strip-components'?: TarOptions['strip'];
+    /**
+     * When extracting, strip the specified number of path portions from the
+     * entry path. For example, with `{strip: 2}`, the entry `a/b/c/d` would be
+     * extracted to `{cwd}/c/d`.
+     */
+    stripComponents?: TarOptions['strip'];
+    /**
+     * When extracting, keep the existing file on disk if it's newer than the
+     * file in the archive.
+     */
+    'keep-newer'?: TarOptions['newer'];
+    /**
+     * When extracting, keep the existing file on disk if it's newer than the
+     * file in the archive.
+     */
+    keepNewer?: TarOptions['newer'];
+    /**
+     * When extracting, keep the existing file on disk if it's newer than the
+     * file in the archive.
+     */
+    'keep-newer-files'?: TarOptions['newer'];
+    /**
+     * When extracting, keep the existing file on disk if it's newer than the
+     * file in the archive.
+     */
+    keepNewerFiles?: TarOptions['newer'];
+    /**
+     * When extracting, do not overwrite existing files at all.
+     */
+    k?: TarOptions['keep'];
+    /**
+     * When extracting, do not overwrite existing files at all.
+     */
+    'keep-existing'?: TarOptions['keep'];
+    /**
+     * When extracting, do not overwrite existing files at all.
+     */
+    keepExisting?: TarOptions['keep'];
+    /**
+     * When extracting, do not set the `mtime` value for extracted entries to
+     * match the `mtime` in the archive.
+     *
+     * When creating archives, do not store the `mtime` value in the entry. Note
+     * that this prevents properly using other mtime-based features (such as
+     * `tar.update` or the `newer` option) with the resulting archive.
+     */
+    m?: TarOptions['noMtime'];
+    /**
+     * When extracting, do not set the `mtime` value for extracted entries to
+     * match the `mtime` in the archive.
+     *
+     * When creating archives, do not store the `mtime` value in the entry. Note
+     * that this prevents properly using other mtime-based features (such as
+     * `tar.update` or the `newer` option) with the resulting archive.
+     */
+    'no-mtime'?: TarOptions['noMtime'];
+    /**
+     * When extracting, set the `uid` and `gid` of extracted entries to the `uid`
+     * and `gid` fields in the archive. Defaults to true when run as root, and
+     * false otherwise.
+     *
+     * If false, then files and directories will be set with the owner and group
+     * of the user running the process. This is similar to `-p` in `tar(1)`, but
+     * ACLs and other system-specific data is never unpacked in this
+     * implementation, and modes are set by default already.
+     */
+    p?: TarOptions['preserveOwner'];
+    /**
+     * Pack the targets of symbolic links rather than the link itself.
+     */
+    L?: TarOptions['follow'];
+    /**
+     * Pack the targets of symbolic links rather than the link itself.
+     */
+    h?: TarOptions['follow'];
+    /**
+     * Deprecated option. Set explicitly false to set `chmod: true`. Ignored
+     * if {@link TarOptions#chmod} is set to any boolean value.
+     *
+     * @deprecated
+     */
+    noChmod?: boolean;
+}
+export type TarOptionsWithAliasesSync = TarOptionsWithAliases & {
+    sync: true;
+};
+export type TarOptionsWithAliasesAsync = TarOptionsWithAliases & {
+    sync?: false;
+};
+export type TarOptionsWithAliasesFile = (TarOptionsWithAliases & {
+    file: string;
+}) | (TarOptionsWithAliases & {
+    f: string;
+});
+export type TarOptionsWithAliasesSyncFile = TarOptionsWithAliasesSync & TarOptionsWithAliasesFile;
+export type TarOptionsWithAliasesAsyncFile = TarOptionsWithAliasesAsync & TarOptionsWithAliasesFile;
+export type TarOptionsWithAliasesNoFile = TarOptionsWithAliases & {
+    f?: undefined;
+    file?: undefined;
+};
+export type TarOptionsWithAliasesSyncNoFile = TarOptionsWithAliasesSync & TarOptionsWithAliasesNoFile;
+export type TarOptionsWithAliasesAsyncNoFile = TarOptionsWithAliasesAsync & TarOptionsWithAliasesNoFile;
+export declare const isSyncFile: <O extends TarOptions>(o: O) => o is O & TarOptionsSyncFile;
+export declare const isAsyncFile: <O extends TarOptions>(o: O) => o is O & TarOptionsAsyncFile;
+export declare const isSyncNoFile: <O extends TarOptions>(o: O) => o is O & TarOptionsSyncNoFile;
+export declare const isAsyncNoFile: <O extends TarOptions>(o: O) => o is O & TarOptionsAsyncNoFile;
+export declare const isSync: <O extends TarOptions>(o: O) => o is O & TarOptionsSync;
+export declare const isAsync: <O extends TarOptions>(o: O) => o is O & TarOptionsAsync;
+export declare const isFile: <O extends TarOptions>(o: O) => o is O & TarOptionsFile;
+export declare const isNoFile: <O extends TarOptions>(o: O) => o is O & TarOptionsNoFile;
+export declare const dealias: (opt?: TarOptionsWithAliases) => TarOptions;
+//# sourceMappingURL=options.d.ts.map

package/libexec/authoring/node_modules/tar/dist/commonjs/options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../src/options.ts"],"names":[],"mappings":"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"}

package/libexec/authoring/node_modules/tar/dist/commonjs/options.js

@@ -0,0 +1,66 @@
+"use strict";
+// turn tar(1) style args like `C` into the more verbose things like `cwd`
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dealias = exports.isNoFile = exports.isFile = exports.isAsync = exports.isSync = exports.isAsyncNoFile = exports.isSyncNoFile = exports.isAsyncFile = exports.isSyncFile = void 0;
+const argmap = new Map([
+    ['C', 'cwd'],
+    ['f', 'file'],
+    ['z', 'gzip'],
+    ['P', 'preservePaths'],
+    ['U', 'unlink'],
+    ['strip-components', 'strip'],
+    ['stripComponents', 'strip'],
+    ['keep-newer', 'newer'],
+    ['keepNewer', 'newer'],
+    ['keep-newer-files', 'newer'],
+    ['keepNewerFiles', 'newer'],
+    ['k', 'keep'],
+    ['keep-existing', 'keep'],
+    ['keepExisting', 'keep'],
+    ['m', 'noMtime'],
+    ['no-mtime', 'noMtime'],
+    ['p', 'preserveOwner'],
+    ['L', 'follow'],
+    ['h', 'follow'],
+    ['onentry', 'onReadEntry'],
+]);
+const isSyncFile = (o) => !!o.sync && !!o.file;
+exports.isSyncFile = isSyncFile;
+const isAsyncFile = (o) => !o.sync && !!o.file;
+exports.isAsyncFile = isAsyncFile;
+const isSyncNoFile = (o) => !!o.sync && !o.file;
+exports.isSyncNoFile = isSyncNoFile;
+const isAsyncNoFile = (o) => !o.sync && !o.file;
+exports.isAsyncNoFile = isAsyncNoFile;
+const isSync = (o) => !!o.sync;
+exports.isSync = isSync;
+const isAsync = (o) => !o.sync;
+exports.isAsync = isAsync;
+const isFile = (o) => !!o.file;
+exports.isFile = isFile;
+const isNoFile = (o) => !o.file;
+exports.isNoFile = isNoFile;
+const dealiasKey = (k) => {
+    const d = argmap.get(k);
+    if (d)
+        return d;
+    return k;
+};
+const dealias = (opt = {}) => {
+    if (!opt)
+        return {};
+    const result = {};
+    for (const [key, v] of Object.entries(opt)) {
+        // TS doesn't know that aliases are going to always be the same type
+        const k = dealiasKey(key);
+        result[k] = v;
+    }
+    // affordance for deprecated noChmod -> chmod
+    if (result.chmod === undefined && result.noChmod === false) {
+        result.chmod = true;
+    }
+    delete result.noChmod;
+    return result;
+};
+exports.dealias = dealias;
+//# sourceMappingURL=options.js.map