Buckets:
| 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 |
Xet Storage Details
- Size:
- 22.8 kB
- Xet hash:
- 941bfc6f59127dc24a2d0318b5420018df34abc65df20b68e1650d3f2bc47b38
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.