dep 1.0.0 → 1.1.0

package/node_modules/tar/dist/esm/options.js.map

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

package/node_modules/tar/dist/esm/pack.d.ts

@@ -1,105 +0,0 @@
-import { type Stats } from 'fs';
-import { WriteEntry, WriteEntrySync, WriteEntryTar } from './write-entry.js';
-export declare class PackJob {
-    path: string;
-    absolute: string;
-    entry?: WriteEntry | WriteEntryTar;
-    stat?: Stats;
-    readdir?: string[];
-    pending: boolean;
-    pendingLink: boolean;
-    ignore: boolean;
-    piped: boolean;
-    constructor(path: string, absolute: string);
-}
-import { Minipass } from 'minipass';
-import * as zlib from 'minizlib';
-import { Yallist } from 'yallist';
-import type { ReadEntry } from './read-entry.js';
-import type { WarnEvent } from './warn-method.js';
-import { type WarnData, type Warner } from './warn-method.js';
-declare const ONSTAT: unique symbol;
-declare const ENDED: unique symbol;
-declare const QUEUE: unique symbol;
-declare const PENDINGLINKS: unique symbol;
-declare const CURRENT: unique symbol;
-declare const PROCESS: unique symbol;
-declare const PROCESSING: unique symbol;
-declare const PROCESSJOB: unique symbol;
-declare const JOBS: unique symbol;
-declare const JOBDONE: unique symbol;
-declare const ADDFSENTRY: unique symbol;
-declare const ADDTARENTRY: unique symbol;
-declare const STAT: unique symbol;
-declare const READDIR: unique symbol;
-declare const ONREADDIR: unique symbol;
-declare const PIPE: unique symbol;
-declare const ENTRY: unique symbol;
-declare const ENTRYOPT: unique symbol;
-declare const WRITEENTRYCLASS: unique symbol;
-declare const WRITE: unique symbol;
-declare const ONDRAIN: unique symbol;
-import type { TarOptions } from './options.js';
-export declare class Pack extends Minipass<Buffer, ReadEntry | string, WarnEvent<Buffer>> implements Warner {
-    sync: boolean;
-    opt: TarOptions;
-    cwd: string;
-    maxReadSize?: number;
-    preservePaths: boolean;
-    strict: boolean;
-    noPax: boolean;
-    prefix: string;
-    linkCache: Exclude<TarOptions['linkCache'], undefined>;
-    statCache: Exclude<TarOptions['statCache'], undefined>;
-    file: string;
-    portable: boolean;
-    zip?: zlib.BrotliCompress | zlib.Gzip | zlib.ZstdCompress;
-    readdirCache: Exclude<TarOptions['readdirCache'], undefined>;
-    noDirRecurse: boolean;
-    follow: boolean;
-    noMtime: boolean;
-    mtime?: Date;
-    filter: Exclude<TarOptions['filter'], undefined>;
-    jobs: number;
-    [WRITEENTRYCLASS]: typeof WriteEntry | typeof WriteEntrySync;
-    onWriteEntry?: (entry: WriteEntry) => void;
-    [QUEUE]: Yallist<PackJob>;
-    [PENDINGLINKS]: Map<`${number}:${number}`, PackJob[]>;
-    [JOBS]: number;
-    [PROCESSING]: boolean;
-    [ENDED]: boolean;
-    constructor(opt?: TarOptions);
-    [WRITE](chunk: Buffer): boolean;
-    add(path: string | ReadEntry): this;
-    end(cb?: () => void): this;
-    end(path: string | ReadEntry, cb?: () => void): this;
-    end(path: string | ReadEntry, encoding?: Minipass.Encoding, cb?: () => void): this;
-    write(path: string | ReadEntry): boolean;
-    [ADDTARENTRY](p: ReadEntry): void;
-    [ADDFSENTRY](p: string): void;
-    [STAT](job: PackJob): void;
-    [ONSTAT](job: PackJob, stat: Stats): void;
-    [READDIR](job: PackJob): void;
-    [ONREADDIR](job: PackJob, entries: string[]): void;
-    [PROCESS](): void;
-    get [CURRENT](): PackJob | undefined;
-    [JOBDONE](job: PackJob): void;
-    [PROCESSJOB](job: PackJob): void;
-    [ENTRYOPT](job: PackJob): TarOptions;
-    [ENTRY](job: PackJob): WriteEntry | undefined;
-    [ONDRAIN](): void;
-    [PIPE](job: PackJob): void;
-    pause(): void;
-    warn(code: string, message: string | Error, data?: WarnData): void;
-}
-export declare class PackSync extends Pack {
-    sync: true;
-    constructor(opt: TarOptions);
-    pause(): void;
-    resume(): void;
-    [STAT](job: PackJob): void;
-    [READDIR](job: PackJob): void;
-    [PIPE](job: PackJob): void;
-}
-export {};
-//# sourceMappingURL=pack.d.ts.map

package/node_modules/tar/dist/esm/pack.d.ts.map

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

package/node_modules/tar/dist/esm/pack.js

@@ -1,502 +0,0 @@
-// A readable tar stream creator
-// Technically, this is a transform stream that you write paths into,
-// and tar format comes out of.
-// The `add()` method is like `write()` but returns this,
-// and end() return `this` as well, so you can
-// do `new Pack(opt).add('files').add('dir').end().pipe(output)
-// You could also do something like:
-// streamOfPaths().pipe(new Pack()).pipe(new fs.WriteStream('out.tar'))
-import fs from 'fs';
-import { WriteEntry, WriteEntrySync, WriteEntryTar, } from './write-entry.js';
-export class PackJob {
-    path;
-    absolute;
-    entry;
-    stat;
-    readdir;
-    pending = false;
-    pendingLink = false;
-    ignore = false;
-    piped = false;
-    constructor(path, absolute) {
-        this.path = path || './';
-        this.absolute = absolute;
-    }
-}
-import { Minipass } from 'minipass';
-import * as zlib from 'minizlib';
-import { Yallist } from 'yallist';
-import { warnMethod } from './warn-method.js';
-const EOF = Buffer.alloc(1024);
-const ONSTAT = Symbol('onStat');
-const ENDED = Symbol('ended');
-const QUEUE = Symbol('queue');
-const PENDINGLINKS = Symbol('pendingLinks');
-const CURRENT = Symbol('current');
-const PROCESS = Symbol('process');
-const PROCESSING = Symbol('processing');
-const PROCESSJOB = Symbol('processJob');
-const JOBS = Symbol('jobs');
-const JOBDONE = Symbol('jobDone');
-const ADDFSENTRY = Symbol('addFSEntry');
-const ADDTARENTRY = Symbol('addTarEntry');
-const STAT = Symbol('stat');
-const READDIR = Symbol('readdir');
-const ONREADDIR = Symbol('onreaddir');
-const PIPE = Symbol('pipe');
-const ENTRY = Symbol('entry');
-const ENTRYOPT = Symbol('entryOpt');
-const WRITEENTRYCLASS = Symbol('writeEntryClass');
-const WRITE = Symbol('write');
-const ONDRAIN = Symbol('ondrain');
-import path from 'path';
-import { normalizeWindowsPath } from './normalize-windows-path.js';
-export class Pack extends Minipass {
-    sync = false;
-    opt;
-    cwd;
-    maxReadSize;
-    preservePaths;
-    strict;
-    noPax;
-    prefix;
-    linkCache;
-    statCache;
-    file;
-    portable;
-    zip;
-    readdirCache;
-    noDirRecurse;
-    follow;
-    noMtime;
-    mtime;
-    filter;
-    jobs;
-    [WRITEENTRYCLASS];
-    onWriteEntry;
-    // Note: we actually DO need a linked list here, because we
-    // shift() to update the head of the list where we start, but still
-    // while that happens, need to know what the next item in the queue
-    // will be. Since we do multiple jobs in parallel, it's not as simple
-    // as just an Array.shift(), since that would lose the information about
-    // the next job in the list. We could add a .next field on the PackJob
-    // class, but then we'd have to be tracking the tail of the queue the
-    // whole time, and Yallist just does that for us anyway.
-    [QUEUE];
-    [PENDINGLINKS] = new Map();
-    [JOBS] = 0;
-    [PROCESSING] = false;
-    [ENDED] = false;
-    constructor(opt = {}) {
-        super();
-        this.opt = opt;
-        this.file = opt.file || '';
-        this.cwd = opt.cwd || process.cwd();
-        this.maxReadSize = opt.maxReadSize;
-        this.preservePaths = !!opt.preservePaths;
-        this.strict = !!opt.strict;
-        this.noPax = !!opt.noPax;
-        this.prefix = normalizeWindowsPath(opt.prefix || '');
-        this.linkCache = opt.linkCache || new Map();
-        this.statCache = opt.statCache || new Map();
-        this.readdirCache = opt.readdirCache || new Map();
-        this.onWriteEntry = opt.onWriteEntry;
-        this[WRITEENTRYCLASS] = WriteEntry;
-        if (typeof opt.onwarn === 'function') {
-            this.on('warn', opt.onwarn);
-        }
-        this.portable = !!opt.portable;
-        if (opt.gzip || opt.brotli || opt.zstd) {
-            if ((opt.gzip ? 1 : 0) + (opt.brotli ? 1 : 0) + (opt.zstd ? 1 : 0) >
-                1) {
-                throw new TypeError('gzip, brotli, zstd are mutually exclusive');
-            }
-            if (opt.gzip) {
-                if (typeof opt.gzip !== 'object') {
-                    opt.gzip = {};
-                }
-                if (this.portable) {
-                    opt.gzip.portable = true;
-                }
-                this.zip = new zlib.Gzip(opt.gzip);
-            }
-            if (opt.brotli) {
-                if (typeof opt.brotli !== 'object') {
-                    opt.brotli = {};
-                }
-                this.zip = new zlib.BrotliCompress(opt.brotli);
-            }
-            if (opt.zstd) {
-                if (typeof opt.zstd !== 'object') {
-                    opt.zstd = {};
-                }
-                this.zip = new zlib.ZstdCompress(opt.zstd);
-            }
-            /* c8 ignore next */
-            if (!this.zip)
-                throw new Error('impossible');
-            const zip = this.zip;
-            zip.on('data', chunk => super.write(chunk));
-            zip.on('end', () => super.end());
-            zip.on('drain', () => this[ONDRAIN]());
-            this.on('resume', () => zip.resume());
-        }
-        else {
-            this.on('drain', this[ONDRAIN]);
-        }
-        this.noDirRecurse = !!opt.noDirRecurse;
-        this.follow = !!opt.follow;
-        this.noMtime = !!opt.noMtime;
-        if (opt.mtime)
-            this.mtime = opt.mtime;
-        this.filter =
-            typeof opt.filter === 'function' ? opt.filter : () => true;
-        this[QUEUE] = new Yallist();
-        this[JOBS] = 0;
-        this.jobs = Number(opt.jobs) || 4;
-        this[PROCESSING] = false;
-        this[ENDED] = false;
-    }
-    [WRITE](chunk) {
-        return super.write(chunk);
-    }
-    add(path) {
-        this.write(path);
-        return this;
-    }
-    end(path, encoding, cb) {
-        /* c8 ignore start */
-        if (typeof path === 'function') {
-            cb = path;
-            path = undefined;
-        }
-        if (typeof encoding === 'function') {
-            cb = encoding;
-            encoding = undefined;
-        }
-        /* c8 ignore stop */
-        if (path) {
-            this.add(path);
-        }
-        this[ENDED] = true;
-        this[PROCESS]();
-        /* c8 ignore next */
-        if (cb)
-            cb();
-        return this;
-    }
-    write(path) {
-        if (this[ENDED]) {
-            throw new Error('write after end');
-        }
-        if (typeof path === 'string') {
-            this[ADDFSENTRY](path);
-        }
-        else {
-            this[ADDTARENTRY](path);
-        }
-        return this.flowing;
-    }
-    [ADDTARENTRY](p) {
-        const absolute = normalizeWindowsPath(path.resolve(this.cwd, p.path));
-        // in this case, we don't have to wait for the stat
-        if (!this.filter(p.path, p)) {
-            p.resume();
-        }
-        else {
-            const job = new PackJob(p.path, absolute);
-            job.entry = new WriteEntryTar(p, this[ENTRYOPT](job));
-            job.entry.on('end', () => this[JOBDONE](job));
-            this[JOBS] += 1;
-            this[QUEUE].push(job);
-        }
-        this[PROCESS]();
-    }
-    [ADDFSENTRY](p) {
-        const absolute = normalizeWindowsPath(path.resolve(this.cwd, p));
-        this[QUEUE].push(new PackJob(p, absolute));
-        this[PROCESS]();
-    }
-    [STAT](job) {
-        job.pending = true;
-        this[JOBS] += 1;
-        const stat = this.follow ? 'stat' : 'lstat';
-        fs[stat](job.absolute, (er, stat) => {
-            job.pending = false;
-            this[JOBS] -= 1;
-            if (er) {
-                this.emit('error', er);
-            }
-            else {
-                this[ONSTAT](job, stat);
-            }
-        });
-    }
-    [ONSTAT](job, stat) {
-        this.statCache.set(job.absolute, stat);
-        job.stat = stat;
-        // now we have the stat, we can filter it.
-        if (!this.filter(job.path, stat)) {
-            job.ignore = true;
-        }
-        else if (stat.isFile() &&
-            stat.nlink > 1 &&
-            !this.linkCache.get(`${stat.dev}:${stat.ino}`) &&
-            !this.sync) {
-            // if it's not filtered, and it's a new File entry, and next anyway
-            // process right away in case any pending Link entries are about
-            // to try to link to it.
-            if (job === this[CURRENT]) {
-                this[PROCESSJOB](job);
-            }
-            else {
-                // if it's NOT the current entry, it needs to be deferred,
-                // so that the link target can be built first.
-                const key = `${stat.dev}:${stat.ino}`;
-                const pending = this[PENDINGLINKS].get(key);
-                if (pending)
-                    pending.push(job);
-                else
-                    this[PENDINGLINKS].set(key, [job]);
-                job.pendingLink = true;
-                job.pending = true;
-            }
-        }
-        this[PROCESS]();
-    }
-    [READDIR](job) {
-        job.pending = true;
-        this[JOBS] += 1;
-        fs.readdir(job.absolute, (er, entries) => {
-            job.pending = false;
-            this[JOBS] -= 1;
-            if (er) {
-                return this.emit('error', er);
-            }
-            this[ONREADDIR](job, entries);
-        });
-    }
-    [ONREADDIR](job, entries) {
-        this.readdirCache.set(job.absolute, entries);
-        job.readdir = entries;
-        this[PROCESS]();
-    }
-    [PROCESS]() {
-        if (this[PROCESSING]) {
-            return;
-        }
-        this[PROCESSING] = true;
-        for (let w = this[QUEUE].head; !!w && this[JOBS] < this.jobs; w = w.next) {
-            this[PROCESSJOB](w.value);
-            if (w.value.ignore) {
-                const p = w.next;
-                this[QUEUE].removeNode(w);
-                w.next = p;
-            }
-        }
-        this[PROCESSING] = false;
-        if (this[ENDED] && this[QUEUE].length === 0 && this[JOBS] === 0) {
-            if (this.zip) {
-                this.zip.end(EOF);
-            }
-            else {
-                super.write(EOF);
-                super.end();
-            }
-        }
-    }
-    get [CURRENT]() {
-        return this[QUEUE] && this[QUEUE].head && this[QUEUE].head.value;
-    }
-    [JOBDONE](job) {
-        this[QUEUE].shift();
-        this[JOBS] -= 1;
-        const { stat } = job;
-        if (stat && stat.isFile() && stat.nlink > 1) {
-            // might be a file with pending links
-            const key = `${stat.dev}:${stat.ino}`;
-            const pending = this[PENDINGLINKS].get(key);
-            if (pending) {
-                this[PENDINGLINKS].delete(key);
-                for (const job of pending) {
-                    job.pending = false;
-                    this[PROCESSJOB](job);
-                }
-            }
-        }
-        this[PROCESS]();
-    }
-    [PROCESSJOB](job) {
-        if (job.pending && job.pendingLink && job === this[CURRENT]) {
-            // At least one of the links to this file are not being included
-            // in the tarball, so we need to just proceed.
-            job.pending = false;
-            job.pendingLink = false;
-        }
-        if (job.pending) {
-            return;
-        }
-        if (job.entry) {
-            if (job === this[CURRENT] && !job.piped) {
-                this[PIPE](job);
-            }
-            return;
-        }
-        if (!job.stat) {
-            const sc = this.statCache.get(job.absolute);
-            if (sc) {
-                this[ONSTAT](job, sc);
-            }
-            else {
-                this[STAT](job);
-            }
-        }
-        if (!job.stat) {
-            return;
-        }
-        // filtered out!
-        if (job.ignore) {
-            return;
-        }
-        if (!this.noDirRecurse && job.stat.isDirectory() && !job.readdir) {
-            const rc = this.readdirCache.get(job.absolute);
-            if (rc) {
-                this[ONREADDIR](job, rc);
-            }
-            else {
-                this[READDIR](job);
-            }
-            if (!job.readdir) {
-                return;
-            }
-        }
-        // we know it doesn't have an entry, because that got checked above
-        job.entry = this[ENTRY](job);
-        if (!job.entry) {
-            job.ignore = true;
-            return;
-        }
-        if (job === this[CURRENT] && !job.piped) {
-            this[PIPE](job);
-        }
-    }
-    [ENTRYOPT](job) {
-        return {
-            onwarn: (code, msg, data) => this.warn(code, msg, data),
-            noPax: this.noPax,
-            cwd: this.cwd,
-            absolute: job.absolute,
-            preservePaths: this.preservePaths,
-            maxReadSize: this.maxReadSize,
-            strict: this.strict,
-            portable: this.portable,
-            linkCache: this.linkCache,
-            statCache: this.statCache,
-            noMtime: this.noMtime,
-            mtime: this.mtime,
-            prefix: this.prefix,
-            onWriteEntry: this.onWriteEntry,
-        };
-    }
-    [ENTRY](job) {
-        this[JOBS] += 1;
-        try {
-            const e = new this[WRITEENTRYCLASS](job.path, this[ENTRYOPT](job));
-            return e
-                .on('end', () => this[JOBDONE](job))
-                .on('error', er => this.emit('error', er));
-        }
-        catch (er) {
-            this.emit('error', er);
-        }
-    }
-    [ONDRAIN]() {
-        if (this[CURRENT] && this[CURRENT].entry) {
-            this[CURRENT].entry.resume();
-        }
-    }
-    // like .pipe() but using super, because our write() is special
-    [PIPE](job) {
-        job.piped = true;
-        if (job.readdir) {
-            job.readdir.forEach(entry => {
-                const p = job.path;
-                const base = p === './' ? '' : p.replace(/\/*$/, '/');
-                this[ADDFSENTRY](base + entry);
-            });
-        }
-        const source = job.entry;
-        const zip = this.zip;
-        /* c8 ignore start */
-        if (!source)
-            throw new Error('cannot pipe without source');
-        /* c8 ignore stop */
-        if (zip) {
-            source.on('data', chunk => {
-                if (!zip.write(chunk)) {
-                    source.pause();
-                }
-            });
-        }
-        else {
-            source.on('data', chunk => {
-                if (!super.write(chunk)) {
-                    source.pause();
-                }
-            });
-        }
-    }
-    pause() {
-        if (this.zip) {
-            this.zip.pause();
-        }
-        return super.pause();
-    }
-    warn(code, message, data = {}) {
-        warnMethod(this, code, message, data);
-    }
-}
-export class PackSync extends Pack {
-    sync = true;
-    constructor(opt) {
-        super(opt);
-        this[WRITEENTRYCLASS] = WriteEntrySync;
-    }
-    // pause/resume are no-ops in sync streams.
-    pause() { }
-    resume() { }
-    [STAT](job) {
-        const stat = this.follow ? 'statSync' : 'lstatSync';
-        this[ONSTAT](job, fs[stat](job.absolute));
-    }
-    [READDIR](job) {
-        this[ONREADDIR](job, fs.readdirSync(job.absolute));
-    }
-    // gotta get it all in this tick
-    [PIPE](job) {
-        const source = job.entry;
-        const zip = this.zip;
-        if (job.readdir) {
-            job.readdir.forEach(entry => {
-                const p = job.path;
-                const base = p === './' ? '' : p.replace(/\/*$/, '/');
-                this[ADDFSENTRY](base + entry);
-            });
-        }
-        /* c8 ignore start */
-        if (!source)
-            throw new Error('Cannot pipe without source');
-        /* c8 ignore stop */
-        if (zip) {
-            source.on('data', chunk => {
-                zip.write(chunk);
-            });
-        }
-        else {
-            source.on('data', chunk => {
-                super[WRITE](chunk);
-            });
-        }
-    }
-}
-//# sourceMappingURL=pack.js.map