aboutsummaryrefslogtreecommitdiffstats
path: root/node_modules/tar/dist/esm/write-entry.js
diff options
context:
space:
mode:
Diffstat (limited to 'node_modules/tar/dist/esm/write-entry.js')
-rw-r--r--node_modules/tar/dist/esm/write-entry.js656
1 files changed, 0 insertions, 656 deletions
diff --git a/node_modules/tar/dist/esm/write-entry.js b/node_modules/tar/dist/esm/write-entry.js
deleted file mode 100644
index 1582602..0000000
--- a/node_modules/tar/dist/esm/write-entry.js
+++ /dev/null
@@ -1,656 +0,0 @@
-import fs from 'fs';
-import { Minipass } from 'minipass';
-import path from 'path';
-import { Header } from './header.js';
-import { modeFix } from './mode-fix.js';
-import { normalizeWindowsPath } from './normalize-windows-path.js';
-import { dealias } from './options.js';
-import { Pax } from './pax.js';
-import { stripAbsolutePath } from './strip-absolute-path.js';
-import { stripTrailingSlashes } from './strip-trailing-slashes.js';
-import { warnMethod } from './warn-method.js';
-import * as winchars from './winchars.js';
-const prefixPath = (path, prefix) => {
- if (!prefix) {
- return normalizeWindowsPath(path);
- }
- path = normalizeWindowsPath(path).replace(/^\.(\/|$)/, '');
- return stripTrailingSlashes(prefix) + '/' + path;
-};
-const maxReadSize = 16 * 1024 * 1024;
-const PROCESS = Symbol('process');
-const FILE = Symbol('file');
-const DIRECTORY = Symbol('directory');
-const SYMLINK = Symbol('symlink');
-const HARDLINK = Symbol('hardlink');
-const HEADER = Symbol('header');
-const READ = Symbol('read');
-const LSTAT = Symbol('lstat');
-const ONLSTAT = Symbol('onlstat');
-const ONREAD = Symbol('onread');
-const ONREADLINK = Symbol('onreadlink');
-const OPENFILE = Symbol('openfile');
-const ONOPENFILE = Symbol('onopenfile');
-const CLOSE = Symbol('close');
-const MODE = Symbol('mode');
-const AWAITDRAIN = Symbol('awaitDrain');
-const ONDRAIN = Symbol('ondrain');
-const PREFIX = Symbol('prefix');
-export class WriteEntry extends Minipass {
- path;
- portable;
- myuid = (process.getuid && process.getuid()) || 0;
- // until node has builtin pwnam functions, this'll have to do
- myuser = process.env.USER || '';
- maxReadSize;
- linkCache;
- statCache;
- preservePaths;
- cwd;
- strict;
- mtime;
- noPax;
- noMtime;
- prefix;
- fd;
- blockLen = 0;
- blockRemain = 0;
- buf;
- pos = 0;
- remain = 0;
- length = 0;
- offset = 0;
- win32;
- absolute;
- header;
- type;
- linkpath;
- stat;
- onWriteEntry;
- #hadError = false;
- constructor(p, opt_ = {}) {
- const opt = dealias(opt_);
- super();
- this.path = normalizeWindowsPath(p);
- // suppress atime, ctime, uid, gid, uname, gname
- this.portable = !!opt.portable;
- this.maxReadSize = opt.maxReadSize || maxReadSize;
- this.linkCache = opt.linkCache || new Map();
- this.statCache = opt.statCache || new Map();
- this.preservePaths = !!opt.preservePaths;
- this.cwd = normalizeWindowsPath(opt.cwd || process.cwd());
- this.strict = !!opt.strict;
- this.noPax = !!opt.noPax;
- this.noMtime = !!opt.noMtime;
- this.mtime = opt.mtime;
- this.prefix = opt.prefix ? normalizeWindowsPath(opt.prefix) : undefined;
- this.onWriteEntry = opt.onWriteEntry;
- if (typeof opt.onwarn === 'function') {
- this.on('warn', opt.onwarn);
- }
- let pathWarn = false;
- if (!this.preservePaths) {
- const [root, stripped] = stripAbsolutePath(this.path);
- if (root && typeof stripped === 'string') {
- this.path = stripped;
- pathWarn = root;
- }
- }
- this.win32 = !!opt.win32 || process.platform === 'win32';
- if (this.win32) {
- // force the \ to / normalization, since we might not *actually*
- // be on windows, but want \ to be considered a path separator.
- this.path = winchars.decode(this.path.replaceAll(/\\/g, '/'));
- p = p.replaceAll(/\\/g, '/');
- }
- this.absolute = normalizeWindowsPath(opt.absolute || path.resolve(this.cwd, p));
- if (this.path === '') {
- this.path = './';
- }
- if (pathWarn) {
- this.warn('TAR_ENTRY_INFO', `stripping ${pathWarn} from absolute path`, {
- entry: this,
- path: pathWarn + this.path,
- });
- }
- const cs = this.statCache.get(this.absolute);
- if (cs) {
- this[ONLSTAT](cs);
- }
- else {
- this[LSTAT]();
- }
- }
- warn(code, message, data = {}) {
- return warnMethod(this, code, message, data);
- }
- emit(ev, ...data) {
- if (ev === 'error') {
- this.#hadError = true;
- }
- return super.emit(ev, ...data);
- }
- [LSTAT]() {
- fs.lstat(this.absolute, (er, stat) => {
- if (er) {
- return this.emit('error', er);
- }
- this[ONLSTAT](stat);
- });
- }
- [ONLSTAT](stat) {
- this.statCache.set(this.absolute, stat);
- this.stat = stat;
- if (!stat.isFile()) {
- stat.size = 0;
- }
- this.type = getType(stat);
- this.emit('stat', stat);
- this[PROCESS]();
- }
- [PROCESS]() {
- switch (this.type) {
- case 'File':
- return this[FILE]();
- case 'Directory':
- return this[DIRECTORY]();
- case 'SymbolicLink':
- return this[SYMLINK]();
- // unsupported types are ignored.
- default:
- return this.end();
- }
- }
- [MODE](mode) {
- return modeFix(mode, this.type === 'Directory', this.portable);
- }
- [PREFIX](path) {
- return prefixPath(path, this.prefix);
- }
- [HEADER]() {
- /* c8 ignore start */
- if (!this.stat) {
- throw new Error('cannot write header before stat');
- }
- /* c8 ignore stop */
- if (this.type === 'Directory' && this.portable) {
- this.noMtime = true;
- }
- this.onWriteEntry?.(this);
- this.header = new Header({
- path: this[PREFIX](this.path),
- // only apply the prefix to hard links.
- linkpath: this.type === 'Link' && this.linkpath !== undefined ?
- this[PREFIX](this.linkpath)
- : this.linkpath,
- // only the permissions and setuid/setgid/sticky bitflags
- // not the higher-order bits that specify file type
- mode: this[MODE](this.stat.mode),
- uid: this.portable ? undefined : this.stat.uid,
- gid: this.portable ? undefined : this.stat.gid,
- size: this.stat.size,
- mtime: this.noMtime ? undefined : this.mtime || this.stat.mtime,
- /* c8 ignore next */
- type: this.type === 'Unsupported' ? undefined : this.type,
- uname: this.portable ? undefined
- : this.stat.uid === this.myuid ? this.myuser
- : '',
- atime: this.portable ? undefined : this.stat.atime,
- ctime: this.portable ? undefined : this.stat.ctime,
- });
- if (this.header.encode() && !this.noPax) {
- super.write(new Pax({
- atime: this.portable ? undefined : this.header.atime,
- ctime: this.portable ? undefined : this.header.ctime,
- gid: this.portable ? undefined : this.header.gid,
- mtime: this.noMtime ? undefined : this.mtime || this.header.mtime,
- path: this[PREFIX](this.path),
- linkpath: this.type === 'Link' && this.linkpath !== undefined ?
- this[PREFIX](this.linkpath)
- : this.linkpath,
- size: this.header.size,
- uid: this.portable ? undefined : this.header.uid,
- uname: this.portable ? undefined : this.header.uname,
- dev: this.portable ? undefined : this.stat.dev,
- ino: this.portable ? undefined : this.stat.ino,
- nlink: this.portable ? undefined : this.stat.nlink,
- }).encode());
- }
- const block = this.header?.block;
- /* c8 ignore start */
- if (!block) {
- throw new Error('failed to encode header');
- }
- /* c8 ignore stop */
- super.write(block);
- }
- [DIRECTORY]() {
- /* c8 ignore start */
- if (!this.stat) {
- throw new Error('cannot create directory entry without stat');
- }
- /* c8 ignore stop */
- if (this.path.slice(-1) !== '/') {
- this.path += '/';
- }
- this.stat.size = 0;
- this[HEADER]();
- this.end();
- }
- [SYMLINK]() {
- fs.readlink(this.absolute, (er, linkpath) => {
- if (er) {
- return this.emit('error', er);
- }
- this[ONREADLINK](linkpath);
- });
- }
- [ONREADLINK](linkpath) {
- this.linkpath = normalizeWindowsPath(linkpath);
- this[HEADER]();
- this.end();
- }
- [HARDLINK](linkpath) {
- /* c8 ignore start */
- if (!this.stat) {
- throw new Error('cannot create link entry without stat');
- }
- /* c8 ignore stop */
- this.type = 'Link';
- this.linkpath = normalizeWindowsPath(path.relative(this.cwd, linkpath));
- this.stat.size = 0;
- this[HEADER]();
- this.end();
- }
- [FILE]() {
- /* c8 ignore start */
- if (!this.stat) {
- throw new Error('cannot create file entry without stat');
- }
- /* c8 ignore stop */
- if (this.stat.nlink > 1) {
- const linkKey = `${this.stat.dev}:${this.stat.ino}`;
- const linkpath = this.linkCache.get(linkKey);
- if (linkpath?.indexOf(this.cwd) === 0) {
- return this[HARDLINK](linkpath);
- }
- this.linkCache.set(linkKey, this.absolute);
- }
- this[HEADER]();
- if (this.stat.size === 0) {
- return this.end();
- }
- this[OPENFILE]();
- }
- [OPENFILE]() {
- fs.open(this.absolute, 'r', (er, fd) => {
- if (er) {
- return this.emit('error', er);
- }
- this[ONOPENFILE](fd);
- });
- }
- [ONOPENFILE](fd) {
- this.fd = fd;
- if (this.#hadError) {
- return this[CLOSE]();
- }
- /* c8 ignore start */
- if (!this.stat) {
- throw new Error('should stat before calling onopenfile');
- }
- /* c8 ignore start */
- this.blockLen = 512 * Math.ceil(this.stat.size / 512);
- this.blockRemain = this.blockLen;
- const bufLen = Math.min(this.blockLen, this.maxReadSize);
- this.buf = Buffer.allocUnsafe(bufLen);
- this.offset = 0;
- this.pos = 0;
- this.remain = this.stat.size;
- this.length = this.buf.length;
- this[READ]();
- }
- [READ]() {
- const { fd, buf, offset, length, pos } = this;
- if (fd === undefined || buf === undefined) {
- throw new Error('cannot read file without first opening');
- }
- fs.read(fd, buf, offset, length, pos, (er, bytesRead) => {
- if (er) {
- // ignoring the error from close(2) is a bad practice, but at
- // this point we already have an error, don't need another one
- return this[CLOSE](() => this.emit('error', er));
- }
- this[ONREAD](bytesRead);
- });
- }
- /* c8 ignore start */
- [CLOSE](cb = () => { }) {
- /* c8 ignore stop */
- if (this.fd !== undefined)
- fs.close(this.fd, cb);
- }
- [ONREAD](bytesRead) {
- if (bytesRead <= 0 && this.remain > 0) {
- const er = Object.assign(new Error('encountered unexpected EOF'), {
- path: this.absolute,
- syscall: 'read',
- code: 'EOF',
- });
- return this[CLOSE](() => this.emit('error', er));
- }
- if (bytesRead > this.remain) {
- const er = Object.assign(new Error('did not encounter expected EOF'), {
- path: this.absolute,
- syscall: 'read',
- code: 'EOF',
- });
- return this[CLOSE](() => this.emit('error', er));
- }
- /* c8 ignore start */
- if (!this.buf) {
- throw new Error('should have created buffer prior to reading');
- }
- /* c8 ignore stop */
- // null out the rest of the buffer, if we could fit the block padding
- // at the end of this loop, we've incremented bytesRead and this.remain
- // to be incremented up to the blockRemain level, as if we had expected
- // to get a null-padded file, and read it until the end. then we will
- // decrement both remain and blockRemain by bytesRead, and know that we
- // reached the expected EOF, without any null buffer to append.
- if (bytesRead === this.remain) {
- for (let i = bytesRead; i < this.length && bytesRead < this.blockRemain; i++) {
- this.buf[i + this.offset] = 0;
- bytesRead++;
- this.remain++;
- }
- }
- const chunk = this.offset === 0 && bytesRead === this.buf.length ?
- this.buf
- : this.buf.subarray(this.offset, this.offset + bytesRead);
- const flushed = this.write(chunk);
- if (!flushed) {
- this[AWAITDRAIN](() => this[ONDRAIN]());
- }
- else {
- this[ONDRAIN]();
- }
- }
- [AWAITDRAIN](cb) {
- this.once('drain', cb);
- }
- write(chunk, encoding, cb) {
- /* c8 ignore start - just junk to comply with NodeJS.WritableStream */
- if (typeof encoding === 'function') {
- cb = encoding;
- encoding = undefined;
- }
- if (typeof chunk === 'string') {
- chunk = Buffer.from(chunk, typeof encoding === 'string' ? encoding : 'utf8');
- }
- /* c8 ignore stop */
- if (this.blockRemain < chunk.length) {
- const er = Object.assign(new Error('writing more data than expected'), {
- path: this.absolute,
- });
- return this.emit('error', er);
- }
- this.remain -= chunk.length;
- this.blockRemain -= chunk.length;
- this.pos += chunk.length;
- this.offset += chunk.length;
- return super.write(chunk, null, cb);
- }
- [ONDRAIN]() {
- if (!this.remain) {
- if (this.blockRemain) {
- super.write(Buffer.alloc(this.blockRemain));
- }
- return this[CLOSE](er => (er ? this.emit('error', er) : this.end()));
- }
- /* c8 ignore start */
- if (!this.buf) {
- throw new Error('buffer lost somehow in ONDRAIN');
- }
- /* c8 ignore stop */
- if (this.offset >= this.length) {
- // if we only have a smaller bit left to read, alloc a smaller buffer
- // otherwise, keep it the same length it was before.
- this.buf = Buffer.allocUnsafe(Math.min(this.blockRemain, this.buf.length));
- this.offset = 0;
- }
- this.length = this.buf.length - this.offset;
- this[READ]();
- }
-}
-export class WriteEntrySync extends WriteEntry {
- sync = true;
- [LSTAT]() {
- this[ONLSTAT](fs.lstatSync(this.absolute));
- }
- [SYMLINK]() {
- this[ONREADLINK](fs.readlinkSync(this.absolute));
- }
- [OPENFILE]() {
- this[ONOPENFILE](fs.openSync(this.absolute, 'r'));
- }
- [READ]() {
- let threw = true;
- try {
- const { fd, buf, offset, length, pos } = this;
- /* c8 ignore start */
- if (fd === undefined || buf === undefined) {
- throw new Error('fd and buf must be set in READ method');
- }
- /* c8 ignore stop */
- const bytesRead = fs.readSync(fd, buf, offset, length, pos);
- this[ONREAD](bytesRead);
- threw = false;
- }
- finally {
- // ignoring the error from close(2) is a bad practice, but at
- // this point we already have an error, don't need another one
- if (threw) {
- try {
- this[CLOSE](() => { });
- }
- catch { }
- }
- }
- }
- [AWAITDRAIN](cb) {
- cb();
- }
- /* c8 ignore start */
- [CLOSE](cb = () => { }) {
- /* c8 ignore stop */
- if (this.fd !== undefined)
- fs.closeSync(this.fd);
- cb();
- }
-}
-export class WriteEntryTar extends Minipass {
- blockLen = 0;
- blockRemain = 0;
- buf = 0;
- pos = 0;
- remain = 0;
- length = 0;
- preservePaths;
- portable;
- strict;
- noPax;
- noMtime;
- readEntry;
- type;
- prefix;
- path;
- mode;
- uid;
- gid;
- uname;
- gname;
- header;
- mtime;
- atime;
- ctime;
- linkpath;
- size;
- onWriteEntry;
- warn(code, message, data = {}) {
- return warnMethod(this, code, message, data);
- }
- constructor(readEntry, opt_ = {}) {
- const opt = dealias(opt_);
- super();
- this.preservePaths = !!opt.preservePaths;
- this.portable = !!opt.portable;
- this.strict = !!opt.strict;
- this.noPax = !!opt.noPax;
- this.noMtime = !!opt.noMtime;
- this.onWriteEntry = opt.onWriteEntry;
- this.readEntry = readEntry;
- const { type } = readEntry;
- /* c8 ignore start */
- if (type === 'Unsupported') {
- throw new Error('writing entry that should be ignored');
- }
- /* c8 ignore stop */
- this.type = type;
- if (this.type === 'Directory' && this.portable) {
- this.noMtime = true;
- }
- this.prefix = opt.prefix;
- this.path = normalizeWindowsPath(readEntry.path);
- this.mode =
- readEntry.mode !== undefined ? this[MODE](readEntry.mode) : undefined;
- this.uid = this.portable ? undefined : readEntry.uid;
- this.gid = this.portable ? undefined : readEntry.gid;
- this.uname = this.portable ? undefined : readEntry.uname;
- this.gname = this.portable ? undefined : readEntry.gname;
- this.size = readEntry.size;
- this.mtime = this.noMtime ? undefined : opt.mtime || readEntry.mtime;
- this.atime = this.portable ? undefined : readEntry.atime;
- this.ctime = this.portable ? undefined : readEntry.ctime;
- this.linkpath =
- readEntry.linkpath !== undefined ?
- normalizeWindowsPath(readEntry.linkpath)
- : undefined;
- if (typeof opt.onwarn === 'function') {
- this.on('warn', opt.onwarn);
- }
- let pathWarn = false;
- if (!this.preservePaths) {
- const [root, stripped] = stripAbsolutePath(this.path);
- if (root && typeof stripped === 'string') {
- this.path = stripped;
- pathWarn = root;
- }
- }
- this.remain = readEntry.size;
- this.blockRemain = readEntry.startBlockSize;
- this.onWriteEntry?.(this);
- this.header = new Header({
- path: this[PREFIX](this.path),
- linkpath: this.type === 'Link' && this.linkpath !== undefined ?
- this[PREFIX](this.linkpath)
- : this.linkpath,
- // only the permissions and setuid/setgid/sticky bitflags
- // not the higher-order bits that specify file type
- mode: this.mode,
- uid: this.portable ? undefined : this.uid,
- gid: this.portable ? undefined : this.gid,
- size: this.size,
- mtime: this.noMtime ? undefined : this.mtime,
- type: this.type,
- uname: this.portable ? undefined : this.uname,
- atime: this.portable ? undefined : this.atime,
- ctime: this.portable ? undefined : this.ctime,
- });
- if (pathWarn) {
- this.warn('TAR_ENTRY_INFO', `stripping ${pathWarn} from absolute path`, {
- entry: this,
- path: pathWarn + this.path,
- });
- }
- if (this.header.encode() && !this.noPax) {
- super.write(new Pax({
- atime: this.portable ? undefined : this.atime,
- ctime: this.portable ? undefined : this.ctime,
- gid: this.portable ? undefined : this.gid,
- mtime: this.noMtime ? undefined : this.mtime,
- path: this[PREFIX](this.path),
- linkpath: this.type === 'Link' && this.linkpath !== undefined ?
- this[PREFIX](this.linkpath)
- : this.linkpath,
- size: this.size,
- uid: this.portable ? undefined : this.uid,
- uname: this.portable ? undefined : this.uname,
- dev: this.portable ? undefined : this.readEntry.dev,
- ino: this.portable ? undefined : this.readEntry.ino,
- nlink: this.portable ? undefined : this.readEntry.nlink,
- }).encode());
- }
- const b = this.header?.block;
- /* c8 ignore start */
- if (!b)
- throw new Error('failed to encode header');
- /* c8 ignore stop */
- super.write(b);
- readEntry.pipe(this);
- }
- [PREFIX](path) {
- return prefixPath(path, this.prefix);
- }
- [MODE](mode) {
- return modeFix(mode, this.type === 'Directory', this.portable);
- }
- write(chunk, encoding, cb) {
- /* c8 ignore start - just junk to comply with NodeJS.WritableStream */
- if (typeof encoding === 'function') {
- cb = encoding;
- encoding = undefined;
- }
- if (typeof chunk === 'string') {
- chunk = Buffer.from(chunk, typeof encoding === 'string' ? encoding : 'utf8');
- }
- /* c8 ignore stop */
- const writeLen = chunk.length;
- if (writeLen > this.blockRemain) {
- throw new Error('writing more to entry than is appropriate');
- }
- this.blockRemain -= writeLen;
- return super.write(chunk, cb);
- }
- end(chunk, encoding, cb) {
- if (this.blockRemain) {
- super.write(Buffer.alloc(this.blockRemain));
- }
- /* c8 ignore start - just junk to comply with NodeJS.WritableStream */
- if (typeof chunk === 'function') {
- cb = chunk;
- encoding = undefined;
- chunk = undefined;
- }
- if (typeof encoding === 'function') {
- cb = encoding;
- encoding = undefined;
- }
- if (typeof chunk === 'string') {
- chunk = Buffer.from(chunk, encoding ?? 'utf8');
- }
- if (cb)
- this.once('finish', cb);
- if (chunk)
- super.end(chunk, cb);
- else
- super.end(cb);
- /* c8 ignore stop */
- return this;
- }
-}
-const getType = (stat) => stat.isFile() ? 'File'
- : stat.isDirectory() ? 'Directory'
- : stat.isSymbolicLink() ? 'SymbolicLink'
- : 'Unsupported';
-//# sourceMappingURL=write-entry.js.map \ No newline at end of file