lakutata/src/components/docker/Docker.cjs

An IoC-based universal application framework.

"use strict";

Object.defineProperty(exports, Symbol.toStringTag, {
    value: "Module"
});

const e = require("../../../vendor/Package.1.cjs");

const t = require("../../lib/core/Component.cjs");

const n = require("../../decorators/di/Lifetime.cjs");

const r = require("./lib/DockerImage.cjs");

const i = require("./lib/DockerContainer.cjs");

const s = require("os");

const a = require("../../decorators/di/Configurable.cjs");

const o = require("../../../vendor/Package.2.cjs");

const u = require("../../../vendor/Package.19.cjs");

const c = require("./exceptions/DockerConnectionException.cjs");

const l = require("./exceptions/DockerImageNotFoundException.cjs");

const f = require("./options/image/ImagePullOptions.cjs");

const h = require("../../decorators/dto/Accept.cjs");

const d = require("node:readline");

const g = require("./exceptions/DockerImagePullException.cjs");

const p = require("../../lib/helpers/IsAbortError.cjs");

const m = require("./options/image/ImageBuildOptions.cjs");

const b = require("./exceptions/DockerImageBuildException.cjs");

const _ = require("./options/image/ImageImportOptions.cjs");

const v = require("./exceptions/DockerImageImportException.cjs");

const y = require("../../../vendor/Package.5.cjs");

require("../../../vendor/Package.8.cjs");

const A = require("events");

const k = require("node:fs");

const w = require("node:stream");

const x = require("./options/network/NetworkCreateOptions.cjs");

const S = require("../../lib/helpers/As.cjs");

const R = require("../../lib/core/Time.cjs");

const I = require("./exceptions/DockerNetworkNotFoundException.cjs");

const O = require("./options/container/ContainerSettingOptions.cjs");

const C = require("./options/DockerPruneOptions.cjs");

const P = require("./options/auth/DockerAuthOptions.cjs");

const E = require("../../lib/helpers/DevNull.cjs");

const T = require("../../../vendor/Package.7.cjs");

const D = require("node:fs/promises");

const j = require("node:path");

require("../../../vendor/Package.3.cjs");

require("../../lib/base/async-constructor/AsyncConstructor.cjs");

require("../../lib/base/async-constructor/Append.cjs");

require("../../lib/helpers/IsPromiseLike.cjs");

require("../../lib/helpers/IsPromise.cjs");

require("util/types");

require("../../exceptions/MethodNotFoundException.cjs");

require("../../lib/base/abstracts/Exception.cjs");

require("../../lib/base/internal/BasicInfo.cjs");

require("../../../vendor/Package.6.cjs");

require("../../lib/base/internal/ThrowWarning.cjs");

require("../../lib/helpers/Templating.cjs");

require("../../lib/base/internal/CamelCase.cjs");

require("../../lib/helpers/NoCase.cjs");

require("../../lib/ioc/DependencyInjectionContainer.cjs");

require("util");

require("../../lib/ioc/Errors.cjs");

require("../../exceptions/di/DependencyInjectionException.cjs");

require("../../lib/base/internal/ConstructorSymbol.cjs");

require("../../constants/DIMetadataKey.cjs");

require("../../../vendor/Package.4.cjs");

require("node:crypto");

require("../../lib/base/internal/DataValidator.cjs");

require("node:util/types");

require("../../lib/validation/VLD.cjs");

require("../../../vendor/Package.11.cjs");

require("url");

require("../../../vendor/Package.10.cjs");

require("../../exceptions/dto/InvalidValueException.cjs");

require("../../../vendor/Package.9.cjs");

require("../../lib/helpers/IsHtml.cjs");

require("../../lib/helpers/IsXML.cjs");

require("../../constants/DTOMetadataKey.cjs");

require("../../lib/helpers/ObjectConstructor.cjs");

require("../../lib/helpers/ObjectParentConstructors.cjs");

require("../../lib/helpers/ObjectParentConstructor.cjs");

require("../../lib/helpers/ObjectPrototype.cjs");

require("../../lib/ioc/InjectionMode.cjs");

require("../../lib/ioc/Lifetime.cjs");

require("../../lib/ioc/ListModules.cjs");

require("path");

require("stream");

require("fs");

require("../../lib/ioc/Utils.cjs");

require("../../lib/ioc/FunctionTokenizer.cjs");

require("../../lib/ioc/LoadModules.cjs");

require("../../lib/ioc/Resolvers.cjs");

require("../../lib/ioc/ParamParser.cjs");

require("../../lib/base/internal/ObjectLifetime.cjs");

require("../../exceptions/di/LifetimeLockedException.cjs");

require("../../lib/base/internal/ObjectWeakRefs.cjs");

require("../../lib/base/internal/ConfigurableRecordsInjection.cjs");

require("../../lib/base/internal/ObjectConfiguration.cjs");

require("../../lib/base/internal/ObjectInjection.cjs");

require("../../lib/base/internal/ObjectContainer.cjs");

require("../../decorators/dto/Expect.cjs");

require("../../decorators/dto/IndexSignature.cjs");

require("../../lib/helpers/IsEmptyObject.cjs");

require("../../lib/base/EventEmitter.cjs");

require("../../lib/core/Provider.cjs");

require("../../lib/base/internal/MethodValidation.cjs");

require("../../exceptions/dto/InvalidMethodAcceptException.cjs");

require("../../exceptions/dto/InvalidMethodReturnException.cjs");

require("./options/image/ImageTagOptions.cjs");

require("./options/image/ImageExportOptions.cjs");

require("stream/promises");

require("./exceptions/DockerImageRepoTagNotFoundException.cjs");

require("./options/image/ImageRemoveOptions.cjs");

require("./options/image/ImagePushOptions.cjs");

require("./exceptions/DockerImagePushException.cjs");

require("./lib/ParseRepositoryTag.cjs");

require("./lib/ParseEnvToRecord.cjs");

require("./options/container/ContainerStopOptions.cjs");

require("./options/container/ContainerRemoveOptions.cjs");

require("./options/container/ContainerKillOptions.cjs");

require("../../lib/helpers/UniqueArray.cjs");

require("./options/container/ContainerCommitOptions.cjs");

require("./options/container/ContainerCreateTTYOptions.cjs");

require("./options/container/ContainerTTYConsoleSizeOptions.cjs");

require("./options/container/ContainerLogsOptions.cjs");

require("./options/container/ContainerExecOptions.cjs");

require("./options/container/ContainerExportDirectoryOptions.cjs");

require("querystring");

require("https");

require("http");

require("net");

require("child_process");

require("../../../vendor/Package.15.cjs");

require("crypto");

require("../../../vendor/Package.18.cjs");

require("assert");

require("../../../vendor/Package.14.cjs");

require("buffer");

require("tls");

require("dns");

require("zlib");

require("../../../vendor/Package.62.cjs");

require("../../../vendor/Package.132.cjs");

require("module");

require("tty");

require("../../../vendor/Package.17.cjs");

require("worker_threads");

require("string_decoder");

require("../../../vendor/Package.20.cjs");

require("constants");

require("process");

require("http2");

require("../../decorators/di/Inject.cjs");

require("./types/ContainerCapability.cjs");

const L = e => e && e.__esModule ? e : {
    default: e
};

const N = L(A);

const q = L(j);

var F = {};

var M = class FixedFIFO {
    constructor(e) {
        if (!(e > 0) || (e - 1 & e) !== 0) throw new Error("Max size for a FixedFIFO should be a power of two");
        this.buffer = new Array(e);
        this.mask = e - 1;
        this.top = 0;
        this.btm = 0;
        this.next = null;
    }
    clear() {
        this.top = this.btm = 0;
        this.next = null;
        this.buffer.fill(undefined);
    }
    push(e) {
        if (this.buffer[this.top] !== undefined) return false;
        this.buffer[this.top] = e;
        this.top = this.top + 1 & this.mask;
        return true;
    }
    shift() {
        const e = this.buffer[this.btm];
        if (e === undefined) return undefined;
        this.buffer[this.btm] = undefined;
        this.btm = this.btm + 1 & this.mask;
        return e;
    }
    peek() {
        return this.buffer[this.btm];
    }
    isEmpty() {
        return this.buffer[this.btm] === undefined;
    }
};

const V = y.getDefaultExportFromCjs(M);

const B = M;

var U = class FastFIFO {
    constructor(e) {
        this.hwm = e || 16;
        this.head = new B(this.hwm);
        this.tail = this.head;
        this.length = 0;
    }
    clear() {
        this.head = this.tail;
        this.head.clear();
        this.length = 0;
    }
    push(e) {
        this.length++;
        if (!this.head.push(e)) {
            const t = this.head;
            this.head = t.next = new B(2 * this.head.buffer.length);
            this.head.push(e);
        }
    }
    shift() {
        if (this.length !== 0) this.length--;
        const e = this.tail.shift();
        if (e === undefined && this.tail.next) {
            const e = this.tail.next;
            this.tail.next = null;
            this.tail = e;
            return this.tail.shift();
        }
        return e;
    }
    peek() {
        const e = this.tail.peek();
        if (e === undefined && this.tail.next) return this.tail.next.peek();
        return e;
    }
    isEmpty() {
        return this.length === 0;
    }
};

const W = y.getDefaultExportFromCjs(U);

function H(e) {
    return Buffer.isBuffer(e) || e instanceof Uint8Array;
}

function z(e) {
    return Buffer.isEncoding(e);
}

function K(e, t, n) {
    return Buffer.alloc(e, t, n);
}

function $(e) {
    return Buffer.allocUnsafe(e);
}

function J(e) {
    return Buffer.allocUnsafeSlow(e);
}

function G(e, t) {
    return Buffer.byteLength(e, t);
}

function Y(e, t) {
    return Buffer.compare(e, t);
}

function X(e, t) {
    return Buffer.concat(e, t);
}

function Z(e, t, n, r, i) {
    return ue(e).copy(t, n, r, i);
}

function Q(e, t) {
    return ue(e).equals(t);
}

function ee(e, t, n, r, i) {
    return ue(e).fill(t, n, r, i);
}

function te(e, t, n) {
    return Buffer.from(e, t, n);
}

function ne(e, t, n, r) {
    return ue(e).includes(t, n, r);
}

function re(e, t, n, r) {
    return ue(e).indexOf(t, n, r);
}

function ie(e, t, n, r) {
    return ue(e).lastIndexOf(t, n, r);
}

function se(e) {
    return ue(e).swap16();
}

function ae(e) {
    return ue(e).swap32();
}

function oe(e) {
    return ue(e).swap64();
}

function ue(e) {
    if (Buffer.isBuffer(e)) return e;
    return Buffer.from(e.buffer, e.byteOffset, e.byteLength);
}

function ce(e, t, n, r) {
    return ue(e).toString(t, n, r);
}

function le(e, t, n, r, i) {
    return ue(e).write(t, n, r, i);
}

function fe(e, t, n) {
    return ue(e).writeDoubleLE(t, n);
}

function he(e, t, n) {
    return ue(e).writeFloatLE(t, n);
}

function de(e, t, n) {
    return ue(e).writeUInt32LE(t, n);
}

function ge(e, t, n) {
    return ue(e).writeInt32LE(t, n);
}

function pe(e, t) {
    return ue(e).readDoubleLE(t);
}

function me(e, t) {
    return ue(e).readFloatLE(t);
}

function be(e, t) {
    return ue(e).readUInt32LE(t);
}

function _e(e, t) {
    return ue(e).readInt32LE(t);
}

function ve(e, t, n) {
    return ue(e).writeDoubleBE(t, n);
}

function ye(e, t, n) {
    return ue(e).writeFloatBE(t, n);
}

function Ae(e, t, n) {
    return ue(e).writeUInt32BE(t, n);
}

function ke(e, t, n) {
    return ue(e).writeInt32BE(t, n);
}

function we(e, t) {
    return ue(e).readDoubleBE(t);
}

function xe(e, t) {
    return ue(e).readFloatBE(t);
}

function Se(e, t) {
    return ue(e).readUInt32BE(t);
}

function Re(e, t) {
    return ue(e).readInt32BE(t);
}

var Ie = {
    isBuffer: H,
    isEncoding: z,
    alloc: K,
    allocUnsafe: $,
    allocUnsafeSlow: J,
    byteLength: G,
    compare: Y,
    concat: X,
    copy: Z,
    equals: Q,
    fill: ee,
    from: te,
    includes: ne,
    indexOf: re,
    lastIndexOf: ie,
    swap16: se,
    swap32: ae,
    swap64: oe,
    toBuffer: ue,
    toString: ce,
    write: le,
    writeDoubleLE: fe,
    writeFloatLE: he,
    writeUInt32LE: de,
    writeInt32LE: ge,
    readDoubleLE: pe,
    readFloatLE: me,
    readUInt32LE: be,
    readInt32LE: _e,
    writeDoubleBE: ve,
    writeFloatBE: ye,
    writeUInt32BE: Ae,
    writeInt32BE: ke,
    readDoubleBE: we,
    readFloatBE: xe,
    readUInt32BE: Se,
    readInt32BE: Re
};

const Oe = y.getDefaultExportFromCjs(Ie);

const Ce = Ie;

var Pe = class PassThroughDecoder {
    constructor(e) {
        this.encoding = e;
    }
    get remaining() {
        return 0;
    }
    decode(e) {
        return Ce.toString(e, this.encoding);
    }
    flush() {
        return "";
    }
};

const Ee = y.getDefaultExportFromCjs(Pe);

const Te = Ie;

var De = class UTF8Decoder {
    constructor() {
        this.codePoint = 0;
        this.bytesSeen = 0;
        this.bytesNeeded = 0;
        this.lowerBoundary = 128;
        this.upperBoundary = 191;
    }
    get remaining() {
        return this.bytesSeen;
    }
    decode(e) {
        if (this.bytesNeeded === 0) {
            let t = true;
            for (let n = Math.max(0, e.byteLength - 4), r = e.byteLength; n < r && t; n++) {
                t = e[n] <= 127;
            }
            if (t) return Te.toString(e, "utf8");
        }
        let t = "";
        for (let n = 0, r = e.byteLength; n < r; n++) {
            const r = e[n];
            if (this.bytesNeeded === 0) {
                if (r <= 127) {
                    t += String.fromCharCode(r);
                } else {
                    this.bytesSeen = 1;
                    if (r >= 194 && r <= 223) {
                        this.bytesNeeded = 2;
                        this.codePoint = r & 31;
                    } else if (r >= 224 && r <= 239) {
                        if (r === 224) this.lowerBoundary = 160; else if (r === 237) this.upperBoundary = 159;
                        this.bytesNeeded = 3;
                        this.codePoint = r & 15;
                    } else if (r >= 240 && r <= 244) {
                        if (r === 240) this.lowerBoundary = 144;
                        if (r === 244) this.upperBoundary = 143;
                        this.bytesNeeded = 4;
                        this.codePoint = r & 7;
                    } else {
                        t += "�";
                    }
                }
                continue;
            }
            if (r < this.lowerBoundary || r > this.upperBoundary) {
                this.codePoint = 0;
                this.bytesNeeded = 0;
                this.bytesSeen = 0;
                this.lowerBoundary = 128;
                this.upperBoundary = 191;
                t += "�";
                continue;
            }
            this.lowerBoundary = 128;
            this.upperBoundary = 191;
            this.codePoint = this.codePoint << 6 | r & 63;
            this.bytesSeen++;
            if (this.bytesSeen !== this.bytesNeeded) continue;
            t += String.fromCodePoint(this.codePoint);
            this.codePoint = 0;
            this.bytesNeeded = 0;
            this.bytesSeen = 0;
        }
        return t;
    }
    flush() {
        const e = this.bytesNeeded > 0 ? "�" : "";
        this.codePoint = 0;
        this.bytesNeeded = 0;
        this.bytesSeen = 0;
        this.lowerBoundary = 128;
        this.upperBoundary = 191;
        return e;
    }
};

const je = y.getDefaultExportFromCjs(De);

const Le = Pe;

const Ne = De;

var qe = class TextDecoder {
    constructor(e = "utf8") {
        this.encoding = Fe(e);
        switch (this.encoding) {
          case "utf8":
            this.decoder = new Ne;
            break;

          case "utf16le":
          case "base64":
            throw new Error("Unsupported encoding: " + this.encoding);

          default:
            this.decoder = new Le(this.encoding);
        }
    }
    get remaining() {
        return this.decoder.remaining;
    }
    push(e) {
        if (typeof e === "string") return e;
        return this.decoder.decode(e);
    }
    write(e) {
        return this.push(e);
    }
    end(e) {
        let t = "";
        if (e) t = this.push(e);
        t += this.decoder.flush();
        return t;
    }
};

function Fe(e) {
    e = e.toLowerCase();
    switch (e) {
      case "utf8":
      case "utf-8":
        return "utf8";

      case "ucs2":
      case "ucs-2":
      case "utf16le":
      case "utf-16le":
        return "utf16le";

      case "latin1":
      case "binary":
        return "latin1";

      case "base64":
      case "ascii":
      case "hex":
        return e;

      default:
        throw new Error("Unknown encoding: " + e);
    }
}

const Me = y.getDefaultExportFromCjs(qe);

const {EventEmitter: Ve} = N.default;

const Be = new Error("Stream was destroyed");

const Ue = new Error("Premature close");

const We = U;

const He = qe;

const ze = typeof queueMicrotask === "undefined" ? e => y.commonjsGlobal.process.nextTick(e) : queueMicrotask;

const Ke = (1 << 29) - 1;

const $e = 1;

const Je = 2;

const Ge = 4;

const Ye = 8;

const Xe = Ke ^ $e;

const Ze = Ke ^ Je;

const Qe = 1 << 4;

const et = 2 << 4;

const tt = 4 << 4;

const nt = 8 << 4;

const rt = 16 << 4;

const it = 32 << 4;

const st = 64 << 4;

const at = 128 << 4;

const ot = 256 << 4;

const ut = 512 << 4;

const ct = 1024 << 4;

const lt = 2048 << 4;

const ft = 4096 << 4;

const ht = 8192 << 4;

const dt = rt | it;

const gt = Qe | ft;

const pt = tt | Qe;

const mt = ot | nt;

const bt = rt | ht;

const _t = Ke ^ Qe;

const vt = Ke ^ tt;

const yt = Ke ^ (tt | ft);

const At = Ke ^ ft;

const kt = Ke ^ rt;

const wt = Ke ^ (nt | ut);

const xt = Ke ^ st;

const St = Ke ^ dt;

const Rt = Ke ^ lt;

const It = Ke ^ et;

const Ot = Ke ^ ht;

const Ct = Ke ^ bt;

const Pt = 1 << 18;

const Et = 2 << 18;

const Tt = 4 << 18;

const Dt = 8 << 18;

const jt = 16 << 18;

const Lt = 32 << 18;

const Nt = 64 << 18;

const qt = 128 << 18;

const Ft = 256 << 18;

const Mt = 512 << 18;

const Vt = 1024 << 18;

const Bt = Ke ^ (Pt | Ft);

const Ut = Ke ^ Tt;

const Wt = Ke ^ (Pt | Mt);

const Ht = Ke ^ jt;

const zt = Ke ^ Dt;

const Kt = Ke ^ qt;

const $t = Ke ^ Et;

const Jt = Ke ^ Vt;

const Gt = Qe | Pt;

const Yt = Ke ^ Gt;

const Xt = ct | Lt;

const Zt = Ge | Ye | Je;

const Qt = Zt | $e;

const en = Zt | Xt;

const tn = Ut & vt;

const nn = qt | lt;

const rn = nn & Yt;

const sn = Qt | rn;

const an = Qt | st | ct;

const on = Qt | ct | nt;

const un = Qt | st | nt;

const cn = Qt | ot | nt | ut;

const ln = Qt | Qe | st | ct | ft | ht;

const fn = Zt | st | ct;

const hn = et | Qt | lt | tt;

const dn = lt | $e;

const gn = Qt | Mt | Lt;

const pn = Dt | jt;

const mn = Dt | Pt;

const bn = Dt | jt | Qt | Pt;

const _n = Qt | Pt | Dt | Vt;

const vn = Tt | Pt;

const yn = Pt | Ft;

const An = Qt | Mt | mn | Lt;

const kn = jt | Zt | Mt | Lt;

const wn = Et | Qt | qt | Tt;

const xn = Mt | Lt | Zt;

const Sn = Symbol.asyncIterator || Symbol("asyncIterator");

class WritableState {
    constructor(e, {highWaterMark: t = 16384, map: n = null, mapWritable: r, byteLength: i, byteLengthWritable: s} = {}) {
        this.stream = e;
        this.queue = new We;
        this.highWaterMark = t;
        this.buffered = 0;
        this.error = null;
        this.pipeline = null;
        this.drains = null;
        this.byteLength = s || i || Xn;
        this.map = r || n;
        this.afterWrite = Cn.bind(this);
        this.afterUpdateNextTick = Tn.bind(this);
    }
    get ended() {
        return (this.stream._duplexState & Lt) !== 0;
    }
    push(e) {
        if ((this.stream._duplexState & xn) !== 0) return false;
        if (this.map !== null) e = this.map(e);
        this.buffered += this.byteLength(e);
        this.queue.push(e);
        if (this.buffered < this.highWaterMark) {
            this.stream._duplexState |= Dt;
            return true;
        }
        this.stream._duplexState |= pn;
        return false;
    }
    shift() {
        const e = this.queue.shift();
        this.buffered -= this.byteLength(e);
        if (this.buffered === 0) this.stream._duplexState &= zt;
        return e;
    }
    end(e) {
        if (typeof e === "function") this.stream.once("finish", e); else if (e !== undefined && e !== null) this.push(e);
        this.stream._duplexState = (this.stream._duplexState | Mt) & Ut;
    }
    autoBatch(e, t) {
        const n = [];
        const r = this.stream;
        n.push(e);
        while ((r._duplexState & _n) === mn) {
            n.push(r._writableState.shift());
        }
        if ((r._duplexState & Qt) !== 0) return t(null);
        r._writev(n, t);
    }
    update() {
        const e = this.stream;
        e._duplexState |= Et;
        do {
            while ((e._duplexState & _n) === Dt) {
                const t = this.shift();
                e._duplexState |= yn;
                e._write(t, this.afterWrite);
            }
            if ((e._duplexState & vn) === 0) this.updateNonPrimary();
        } while (this.continueUpdate() === true);
        e._duplexState &= $t;
    }
    updateNonPrimary() {
        const e = this.stream;
        if ((e._duplexState & An) === Mt) {
            e._duplexState = e._duplexState | Pt;
            e._final(In.bind(this));
            return;
        }
        if ((e._duplexState & Zt) === Ge) {
            if ((e._duplexState & nn) === 0) {
                e._duplexState |= Gt;
                e._destroy(On.bind(this));
            }
            return;
        }
        if ((e._duplexState & sn) === $e) {
            e._duplexState = (e._duplexState | Gt) & Xe;
            e._open(jn.bind(this));
        }
    }
    continueUpdate() {
        if ((this.stream._duplexState & qt) === 0) return false;
        this.stream._duplexState &= Kt;
        return true;
    }
    updateCallback() {
        if ((this.stream._duplexState & wn) === Tt) this.update(); else this.updateNextTick();
    }
    updateNextTick() {
        if ((this.stream._duplexState & qt) !== 0) return;
        this.stream._duplexState |= qt;
        if ((this.stream._duplexState & Et) === 0) ze(this.afterUpdateNextTick);
    }
}

class ReadableState {
    constructor(e, {highWaterMark: t = 16384, map: n = null, mapReadable: r, byteLength: i, byteLengthReadable: s} = {}) {
        this.stream = e;
        this.queue = new We;
        this.highWaterMark = t === 0 ? 1 : t;
        this.buffered = 0;
        this.readAhead = t > 0;
        this.error = null;
        this.pipeline = null;
        this.byteLength = s || i || Xn;
        this.map = r || n;
        this.pipeTo = null;
        this.afterRead = Pn.bind(this);
        this.afterUpdateNextTick = En.bind(this);
    }
    get ended() {
        return (this.stream._duplexState & ct) !== 0;
    }
    pipe(e, t) {
        if (this.pipeTo !== null) throw new Error("Can only pipe to one destination");
        if (typeof t !== "function") t = null;
        this.stream._duplexState |= it;
        this.pipeTo = e;
        this.pipeline = new Pipeline(this.stream, e, t);
        if (t) this.stream.on("error", Zn);
        if (Hn(e)) {
            e._writableState.pipeline = this.pipeline;
            if (t) e.on("error", Zn);
            e.on("finish", this.pipeline.finished.bind(this.pipeline));
        } else {
            const t = this.pipeline.done.bind(this.pipeline, e);
            const n = this.pipeline.done.bind(this.pipeline, e, null);
            e.on("error", t);
            e.on("close", n);
            e.on("finish", this.pipeline.finished.bind(this.pipeline));
        }
        e.on("drain", Rn.bind(this));
        this.stream.emit("piping", e);
        e.emit("pipe", this.stream);
    }
    push(e) {
        const t = this.stream;
        if (e === null) {
            this.highWaterMark = 0;
            t._duplexState = (t._duplexState | st) & yt;
            return false;
        }
        if (this.map !== null) {
            e = this.map(e);
            if (e === null) {
                t._duplexState &= At;
                return this.buffered < this.highWaterMark;
            }
        }
        this.buffered += this.byteLength(e);
        this.queue.push(e);
        t._duplexState = (t._duplexState | nt) & At;
        return this.buffered < this.highWaterMark;
    }
    shift() {
        const e = this.queue.shift();
        this.buffered -= this.byteLength(e);
        if (this.buffered === 0) this.stream._duplexState &= wt;
        return e;
    }
    unshift(e) {
        const t = [ this.map !== null ? this.map(e) : e ];
        while (this.buffered > 0) t.push(this.shift());
        for (let e = 0; e < t.length - 1; e++) {
            const n = t[e];
            this.buffered += this.byteLength(n);
            this.queue.push(n);
        }
        this.push(t[t.length - 1]);
    }
    read() {
        const e = this.stream;
        if ((e._duplexState & on) === nt) {
            const t = this.shift();
            if (this.pipeTo !== null && this.pipeTo.write(t) === false) e._duplexState &= St;
            if ((e._duplexState & at) !== 0) e.emit("data", t);
            return t;
        }
        if (this.readAhead === false) {
            e._duplexState |= ht;
            this.updateNextTick();
        }
        return null;
    }
    drain() {
        const e = this.stream;
        while ((e._duplexState & on) === nt && (e._duplexState & dt) !== 0) {
            const t = this.shift();
            if (this.pipeTo !== null && this.pipeTo.write(t) === false) e._duplexState &= St;
            if ((e._duplexState & at) !== 0) e.emit("data", t);
        }
    }
    update() {
        const e = this.stream;
        e._duplexState |= et;
        do {
            this.drain();
            while (this.buffered < this.highWaterMark && (e._duplexState & ln) === ht) {
                e._duplexState |= gt;
                e._read(this.afterRead);
                this.drain();
            }
            if ((e._duplexState & cn) === mt) {
                e._duplexState |= ut;
                e.emit("readable");
            }
            if ((e._duplexState & pt) === 0) this.updateNonPrimary();
        } while (this.continueUpdate() === true);
        e._duplexState &= It;
    }
    updateNonPrimary() {
        const e = this.stream;
        if ((e._duplexState & un) === st) {
            e._duplexState = (e._duplexState | ct) & xt;
            e.emit("end");
            if ((e._duplexState & en) === Xt) e._duplexState |= Ge;
            if (this.pipeTo !== null) this.pipeTo.end();
        }
        if ((e._duplexState & Zt) === Ge) {
            if ((e._duplexState & nn) === 0) {
                e._duplexState |= Gt;
                e._destroy(On.bind(this));
            }
            return;
        }
        if ((e._duplexState & sn) === $e) {
            e._duplexState = (e._duplexState | Gt) & Xe;
            e._open(jn.bind(this));
        }
    }
    continueUpdate() {
        if ((this.stream._duplexState & lt) === 0) return false;
        this.stream._duplexState &= Rt;
        return true;
    }
    updateCallback() {
        if ((this.stream._duplexState & hn) === tt) this.update(); else this.updateNextTick();
    }
    updateNextTickIfOpen() {
        if ((this.stream._duplexState & dn) !== 0) return;
        this.stream._duplexState |= lt;
        if ((this.stream._duplexState & et) === 0) ze(this.afterUpdateNextTick);
    }
    updateNextTick() {
        if ((this.stream._duplexState & lt) !== 0) return;
        this.stream._duplexState |= lt;
        if ((this.stream._duplexState & et) === 0) ze(this.afterUpdateNextTick);
    }
}

class TransformState {
    constructor(e) {
        this.data = null;
        this.afterTransform = Ln.bind(e);
        this.afterFinal = null;
    }
}

class Pipeline {
    constructor(e, t, n) {
        this.from = e;
        this.to = t;
        this.afterPipe = n;
        this.error = null;
        this.pipeToFinished = false;
    }
    finished() {
        this.pipeToFinished = true;
    }
    done(e, t) {
        if (t) this.error = t;
        if (e === this.to) {
            this.to = null;
            if (this.from !== null) {
                if ((this.from._duplexState & ct) === 0 || !this.pipeToFinished) {
                    this.from.destroy(this.error || new Error("Writable stream closed prematurely"));
                }
                return;
            }
        }
        if (e === this.from) {
            this.from = null;
            if (this.to !== null) {
                if ((e._duplexState & ct) === 0) {
                    this.to.destroy(this.error || new Error("Readable stream closed before ending"));
                }
                return;
            }
        }
        if (this.afterPipe !== null) this.afterPipe(this.error);
        this.to = this.from = this.afterPipe = null;
    }
}

function Rn() {
    this.stream._duplexState |= it;
    this.updateCallback();
}

function In(e) {
    const t = this.stream;
    if (e) t.destroy(e);
    if ((t._duplexState & Zt) === 0) {
        t._duplexState |= Lt;
        t.emit("finish");
    }
    if ((t._duplexState & en) === Xt) {
        t._duplexState |= Ge;
    }
    t._duplexState &= Wt;
    if ((t._duplexState & Et) === 0) this.update(); else this.updateNextTick();
}

function On(e) {
    const t = this.stream;
    if (!e && this.error !== Be) e = this.error;
    if (e) t.emit("error", e);
    t._duplexState |= Ye;
    t.emit("close");
    const n = t._readableState;
    const r = t._writableState;
    if (n !== null && n.pipeline !== null) n.pipeline.done(t, e);
    if (r !== null) {
        while (r.drains !== null && r.drains.length > 0) r.drains.shift().resolve(false);
        if (r.pipeline !== null) r.pipeline.done(t, e);
    }
}

function Cn(e) {
    const t = this.stream;
    if (e) t.destroy(e);
    t._duplexState &= Bt;
    if (this.drains !== null) Dn(this.drains);
    if ((t._duplexState & bn) === jt) {
        t._duplexState &= Ht;
        if ((t._duplexState & Nt) === Nt) {
            t.emit("drain");
        }
    }
    this.updateCallback();
}

function Pn(e) {
    if (e) this.stream.destroy(e);
    this.stream._duplexState &= _t;
    if (this.readAhead === false && (this.stream._duplexState & rt) === 0) this.stream._duplexState &= Ot;
    this.updateCallback();
}

function En() {
    if ((this.stream._duplexState & et) === 0) {
        this.stream._duplexState &= Rt;
        this.update();
    }
}

function Tn() {
    if ((this.stream._duplexState & Et) === 0) {
        this.stream._duplexState &= Kt;
        this.update();
    }
}

function Dn(e) {
    for (let t = 0; t < e.length; t++) {
        if (--e[t].writes === 0) {
            e.shift().resolve(true);
            t--;
        }
    }
}

function jn(e) {
    const t = this.stream;
    if (e) t.destroy(e);
    if ((t._duplexState & Ge) === 0) {
        if ((t._duplexState & an) === 0) t._duplexState |= tt;
        if ((t._duplexState & gn) === 0) t._duplexState |= Tt;
        t.emit("open");
    }
    t._duplexState &= Yt;
    if (t._writableState !== null) {
        t._writableState.updateCallback();
    }
    if (t._readableState !== null) {
        t._readableState.updateCallback();
    }
}

function Ln(e, t) {
    if (t !== undefined && t !== null) this.push(t);
    this._writableState.afterWrite(e);
}

function Nn(e) {
    if (this._readableState !== null) {
        if (e === "data") {
            this._duplexState |= at | bt;
            this._readableState.updateNextTick();
        }
        if (e === "readable") {
            this._duplexState |= ot;
            this._readableState.updateNextTick();
        }
    }
    if (this._writableState !== null) {
        if (e === "drain") {
            this._duplexState |= Nt;
            this._writableState.updateNextTick();
        }
    }
}

class Stream extends Ve {
    constructor(e) {
        super();
        this._duplexState = 0;
        this._readableState = null;
        this._writableState = null;
        if (e) {
            if (e.open) this._open = e.open;
            if (e.destroy) this._destroy = e.destroy;
            if (e.predestroy) this._predestroy = e.predestroy;
            if (e.signal) {
                e.signal.addEventListener("abort", Qn.bind(this));
            }
        }
        this.on("newListener", Nn);
    }
    _open(e) {
        e(null);
    }
    _destroy(e) {
        e(null);
    }
    _predestroy() {}
    get readable() {
        return this._readableState !== null ? true : undefined;
    }
    get writable() {
        return this._writableState !== null ? true : undefined;
    }
    get destroyed() {
        return (this._duplexState & Ye) !== 0;
    }
    get destroying() {
        return (this._duplexState & Zt) !== 0;
    }
    destroy(e) {
        if ((this._duplexState & Zt) === 0) {
            if (!e) e = Be;
            this._duplexState = (this._duplexState | Ge) & tn;
            if (this._readableState !== null) {
                this._readableState.highWaterMark = 0;
                this._readableState.error = e;
            }
            if (this._writableState !== null) {
                this._writableState.highWaterMark = 0;
                this._writableState.error = e;
            }
            this._duplexState |= Je;
            this._predestroy();
            this._duplexState &= Ze;
            if (this._readableState !== null) this._readableState.updateNextTick();
            if (this._writableState !== null) this._writableState.updateNextTick();
        }
    }
}

let qn = class Readable extends Stream {
    constructor(e) {
        super(e);
        this._duplexState |= $e | Lt | ht;
        this._readableState = new ReadableState(this, e);
        if (e) {
            if (this._readableState.readAhead === false) this._duplexState &= Ot;
            if (e.read) this._read = e.read;
            if (e.eagerOpen) this._readableState.updateNextTick();
            if (e.encoding) this.setEncoding(e.encoding);
        }
    }
    setEncoding(e) {
        const t = new He(e);
        const n = this._readableState.map || Un;
        this._readableState.map = r;
        return this;
        function r(e) {
            const r = t.push(e);
            return r === "" && (e.byteLength !== 0 || t.remaining > 0) ? null : n(r);
        }
    }
    _read(e) {
        e(null);
    }
    pipe(e, t) {
        this._readableState.updateNextTick();
        this._readableState.pipe(e, t);
        return e;
    }
    read() {
        this._readableState.updateNextTick();
        return this._readableState.read();
    }
    push(e) {
        this._readableState.updateNextTickIfOpen();
        return this._readableState.push(e);
    }
    unshift(e) {
        this._readableState.updateNextTickIfOpen();
        return this._readableState.unshift(e);
    }
    resume() {
        this._duplexState |= bt;
        this._readableState.updateNextTick();
        return this;
    }
    pause() {
        this._duplexState &= this._readableState.readAhead === false ? Ct : kt;
        return this;
    }
    static _fromAsyncIterator(e, t) {
        let n;
        const r = new Readable({
            ...t,
            read(t) {
                e.next().then(i).then(t.bind(null, null)).catch(t);
            },
            predestroy() {
                n = e.return();
            },
            destroy(e) {
                if (!n) return e(null);
                n.then(e.bind(null, null)).catch(e);
            }
        });
        return r;
        function i(e) {
            if (e.done) r.push(null); else r.push(e.value);
        }
    }
    static from(e, t) {
        if (Jn(e)) return e;
        if (e[Sn]) return this._fromAsyncIterator(e[Sn](), t);
        if (!Array.isArray(e)) e = e === undefined ? [] : [ e ];
        let n = 0;
        return new Readable({
            ...t,
            read(t) {
                this.push(n === e.length ? null : e[n++]);
                t(null);
            }
        });
    }
    static isBackpressured(e) {
        return (e._duplexState & fn) !== 0 || e._readableState.buffered >= e._readableState.highWaterMark;
    }
    static isPaused(e) {
        return (e._duplexState & rt) === 0;
    }
    [Sn]() {
        const e = this;
        let t = null;
        let n = null;
        let r = null;
        this.on("error", (e => {
            t = e;
        }));
        this.on("readable", i);
        this.on("close", s);
        return {
            [Sn]() {
                return this;
            },
            next() {
                return new Promise((function(t, i) {
                    n = t;
                    r = i;
                    const s = e.read();
                    if (s !== null) a(s); else if ((e._duplexState & Ye) !== 0) a(null);
                }));
            },
            return() {
                return o(null);
            },
            throw(e) {
                return o(e);
            }
        };
        function i() {
            if (n !== null) a(e.read());
        }
        function s() {
            if (n !== null) a(null);
        }
        function a(i) {
            if (r === null) return;
            if (t) r(t); else if (i === null && (e._duplexState & ct) === 0) r(Be); else n({
                value: i,
                done: i === null
            });
            r = n = null;
        }
        function o(t) {
            e.destroy(t);
            return new Promise(((n, r) => {
                if (e._duplexState & Ye) return n({
                    value: undefined,
                    done: true
                });
                e.once("close", (function() {
                    if (t) r(t); else n({
                        value: undefined,
                        done: true
                    });
                }));
            }));
        }
    }
};

let Fn = class Writable extends Stream {
    constructor(e) {
        super(e);
        this._duplexState |= $e | ct;
        this._writableState = new WritableState(this, e);
        if (e) {
            if (e.writev) this._writev = e.writev;
            if (e.write) this._write = e.write;
            if (e.final) this._final = e.final;
            if (e.eagerOpen) this._writableState.updateNextTick();
        }
    }
    cork() {
        this._duplexState |= Vt;
    }
    uncork() {
        this._duplexState &= Jt;
        this._writableState.updateNextTick();
    }
    _writev(e, t) {
        t(null);
    }
    _write(e, t) {
        this._writableState.autoBatch(e, t);
    }
    _final(e) {
        e(null);
    }
    static isBackpressured(e) {
        return (e._duplexState & kn) !== 0;
    }
    static drained(e) {
        if (e.destroyed) return Promise.resolve(false);
        const t = e._writableState;
        const n = er(e) ? Math.min(1, t.queue.length) : t.queue.length;
        const r = n + (e._duplexState & Ft ? 1 : 0);
        if (r === 0) return Promise.resolve(true);
        if (t.drains === null) t.drains = [];
        return new Promise((e => {
            t.drains.push({
                writes: r,
                resolve: e
            });
        }));
    }
    write(e) {
        this._writableState.updateNextTick();
        return this._writableState.push(e);
    }
    end(e) {
        this._writableState.updateNextTick();
        this._writableState.end(e);
        return this;
    }
};

class Duplex extends qn {
    constructor(e) {
        super(e);
        this._duplexState = $e | this._duplexState & ht;
        this._writableState = new WritableState(this, e);
        if (e) {
            if (e.writev) this._writev = e.writev;
            if (e.write) this._write = e.write;
            if (e.final) this._final = e.final;
        }
    }
    cork() {
        this._duplexState |= Vt;
    }
    uncork() {
        this._duplexState &= Jt;
        this._writableState.updateNextTick();
    }
    _writev(e, t) {
        t(null);
    }
    _write(e, t) {
        this._writableState.autoBatch(e, t);
    }
    _final(e) {
        e(null);
    }
    write(e) {
        this._writableState.updateNextTick();
        return this._writableState.push(e);
    }
    end(e) {
        this._writableState.updateNextTick();
        this._writableState.end(e);
        return this;
    }
}

class Transform extends Duplex {
    constructor(e) {
        super(e);
        this._transformState = new TransformState(this);
        if (e) {
            if (e.transform) this._transform = e.transform;
            if (e.flush) this._flush = e.flush;
        }
    }
    _write(e, t) {
        if (this._readableState.buffered >= this._readableState.highWaterMark) {
            this._transformState.data = e;
        } else {
            this._transform(e, this._transformState.afterTransform);
        }
    }
    _read(e) {
        if (this._transformState.data !== null) {
            const t = this._transformState.data;
            this._transformState.data = null;
            e(null);
            this._transform(t, this._transformState.afterTransform);
        } else {
            e(null);
        }
    }
    destroy(e) {
        super.destroy(e);
        if (this._transformState.data !== null) {
            this._transformState.data = null;
            this._transformState.afterTransform();
        }
    }
    _transform(e, t) {
        t(null, e);
    }
    _flush(e) {
        e(null);
    }
    _final(e) {
        this._transformState.afterFinal = e;
        this._flush(Mn.bind(this));
    }
}

class PassThrough extends Transform {}

function Mn(e, t) {
    const n = this._transformState.afterFinal;
    if (e) return n(e);
    if (t !== null && t !== undefined) this.push(t);
    this.push(null);
    n(null);
}

function Vn(...e) {
    return new Promise(((t, n) => Bn(...e, (e => {
        if (e) return n(e);
        t();
    }))));
}

function Bn(e, ...t) {
    const n = Array.isArray(e) ? [ ...e, ...t ] : [ e, ...t ];
    const r = n.length && typeof n[n.length - 1] === "function" ? n.pop() : null;
    if (n.length < 2) throw new Error("Pipeline requires at least 2 streams");
    let i = n[0];
    let s = null;
    let a = null;
    for (let e = 1; e < n.length; e++) {
        s = n[e];
        if (Hn(i)) {
            i.pipe(s, u);
        } else {
            o(i, true, e > 1, u);
            i.pipe(s);
        }
        i = s;
    }
    if (r) {
        let e = false;
        const t = Hn(s) || !!(s._writableState && s._writableState.autoDestroy);
        s.on("error", (e => {
            if (a === null) a = e;
        }));
        s.on("finish", (() => {
            e = true;
            if (!t) r(a);
        }));
        if (t) {
            s.on("close", (() => r(a || (e ? null : Ue))));
        }
    }
    return s;
    function o(e, t, n, r) {
        e.on("error", r);
        e.on("close", i);
        function i() {
            if (t && e._readableState && !e._readableState.ended) return r(Ue);
            if (n && e._writableState && !e._writableState.ended) return r(Ue);
        }
    }
    function u(e) {
        if (!e || a) return;
        a = e;
        for (const t of n) {
            t.destroy(e);
        }
    }
}

function Un(e) {
    return e;
}

function Wn(e) {
    return !!e._readableState || !!e._writableState;
}

function Hn(e) {
    return typeof e._duplexState === "number" && Wn(e);
}

function zn(e) {
    return !!e._readableState && e._readableState.ended;
}

function Kn(e) {
    return !!e._writableState && e._writableState.ended;
}

function $n(e, t = {}) {
    const n = e._readableState && e._readableState.error || e._writableState && e._writableState.error;
    return !t.all && n === Be ? null : n;
}

function Jn(e) {
    return Hn(e) && e.readable;
}

function Gn(e) {
    return (e._duplexState & $e) !== $e || (e._duplexState & nn) !== 0;
}

function Yn(e) {
    return typeof e === "object" && e !== null && typeof e.byteLength === "number";
}

function Xn(e) {
    return Yn(e) ? e.byteLength : 1024;
}

function Zn() {}

function Qn() {
    this.destroy(new Error("Stream aborted."));
}

function er(e) {
    return e._writev !== Fn.prototype._writev && e._writev !== Duplex.prototype._writev;
}

var tr = {
    pipeline: Bn,
    pipelinePromise: Vn,
    isStream: Wn,
    isStreamx: Hn,
    isEnded: zn,
    isFinished: Kn,
    isDisturbed: Gn,
    getStreamError: $n,
    Stream: Stream,
    Writable: Fn,
    Readable: qn,
    Duplex: Duplex,
    Transform: Transform,
    PassThrough: PassThrough
};

const nr = y.getDefaultExportFromCjs(tr);

var rr = {};

const ir = Ie;

const sr = "0000000000000000000";

const ar = "7777777777777777777";

const or = "0".charCodeAt(0);

const ur = ir.from([ 117, 115, 116, 97, 114, 0 ]);

const cr = ir.from([ or, or ]);

const lr = ir.from([ 117, 115, 116, 97, 114, 32 ]);

const fr = ir.from([ 32, 0 ]);

const hr = 4095;

const dr = 257;

const gr = 263;

var pr = rr.decodeLongPath = function e(t, n) {
    return Tr(t, 0, t.length, n);
};

var mr = rr.encodePax = function e(t) {
    let n = "";
    if (t.name) n += Dr(" path=" + t.name + "\n");
    if (t.linkname) n += Dr(" linkpath=" + t.linkname + "\n");
    const r = t.pax;
    if (r) {
        for (const e in r) {
            n += Dr(" " + e + "=" + r[e] + "\n");
        }
    }
    return ir.from(n);
};

var br = rr.decodePax = function e(t) {
    const n = {};
    while (t.length) {
        let e = 0;
        while (e < t.length && t[e] !== 32) e++;
        const r = parseInt(ir.toString(t.subarray(0, e)), 10);
        if (!r) return n;
        const i = ir.toString(t.subarray(e + 1, r - 1));
        const s = i.indexOf("=");
        if (s === -1) return n;
        n[i.slice(0, s)] = i.slice(s + 1);
        t = t.subarray(r);
    }
    return n;
};

var _r = rr.encode = function e(t) {
    const n = ir.alloc(512);
    let r = t.name;
    let i = "";
    if (t.typeflag === 5 && r[r.length - 1] !== "/") r += "/";
    if (ir.byteLength(r) !== r.length) return null;
    while (ir.byteLength(r) > 100) {
        const e = r.indexOf("/");
        if (e === -1) return null;
        i += i ? "/" + r.slice(0, e) : r.slice(0, e);
        r = r.slice(e + 1);
    }
    if (ir.byteLength(r) > 100 || ir.byteLength(i) > 155) return null;
    if (t.linkname && ir.byteLength(t.linkname) > 100) return null;
    ir.write(n, r);
    ir.write(n, Ir(t.mode & hr, 6), 100);
    ir.write(n, Ir(t.uid, 6), 108);
    ir.write(n, Ir(t.gid, 6), 116);
    Cr(t.size, n, 124);
    ir.write(n, Ir(t.mtime.getTime() / 1e3 | 0, 11), 136);
    n[156] = or + xr(t.type);
    if (t.linkname) ir.write(n, t.linkname, 157);
    ir.copy(ur, n, dr);
    ir.copy(cr, n, gr);
    if (t.uname) ir.write(n, t.uname, 265);
    if (t.gname) ir.write(n, t.gname, 297);
    ir.write(n, Ir(t.devmajor || 0, 6), 329);
    ir.write(n, Ir(t.devminor || 0, 6), 337);
    if (i) ir.write(n, i, 345);
    ir.write(n, Ir(Rr(n), 6), 148);
    return n;
};

var vr = rr.decode = function e(t, n, r) {
    let i = t[156] === 0 ? 0 : t[156] - or;
    let s = Tr(t, 0, 100, n);
    const a = Er(t, 100, 8);
    const o = Er(t, 108, 8);
    const u = Er(t, 116, 8);
    const c = Er(t, 124, 12);
    const l = Er(t, 136, 12);
    const f = wr(i);
    const h = t[157] === 0 ? null : Tr(t, 157, 100, n);
    const d = Tr(t, 265, 32);
    const g = Tr(t, 297, 32);
    const p = Er(t, 329, 8);
    const m = Er(t, 337, 8);
    const b = Rr(t);
    if (b === 8 * 32) return null;
    if (b !== Er(t, 148, 8)) throw new Error("Invalid tar header. Maybe the tar is corrupted or it needs to be gunzipped?");
    if (yr(t)) {
        if (t[345]) s = Tr(t, 345, 155, n) + "/" + s;
    } else if (Ar(t)) {} else {
        if (!r) {
            throw new Error("Invalid tar header: unknown format.");
        }
    }
    if (i === 0 && s && s[s.length - 1] === "/") i = 5;
    return {
        name: s,
        mode: a,
        uid: o,
        gid: u,
        size: c,
        mtime: new Date(1e3 * l),
        type: f,
        linkname: h,
        uname: d,
        gname: g,
        devmajor: p,
        devminor: m,
        pax: null
    };
};

function yr(e) {
    return ir.equals(ur, e.subarray(dr, dr + 6));
}

function Ar(e) {
    return ir.equals(lr, e.subarray(dr, dr + 6)) && ir.equals(fr, e.subarray(gr, gr + 2));
}

function kr(e, t, n) {
    if (typeof e !== "number") return n;
    e = ~~e;
    if (e >= t) return t;
    if (e >= 0) return e;
    e += t;
    if (e >= 0) return e;
    return 0;
}

function wr(e) {
    switch (e) {
      case 0:
        return "file";

      case 1:
        return "link";

      case 2:
        return "symlink";

      case 3:
        return "character-device";

      case 4:
        return "block-device";

      case 5:
        return "directory";

      case 6:
        return "fifo";

      case 7:
        return "contiguous-file";

      case 72:
        return "pax-header";

      case 55:
        return "pax-global-header";

      case 27:
        return "gnu-long-link-path";

      case 28:
      case 30:
        return "gnu-long-path";
    }
    return null;
}

function xr(e) {
    switch (e) {
      case "file":
        return 0;

      case "link":
        return 1;

      case "symlink":
        return 2;

      case "character-device":
        return 3;

      case "block-device":
        return 4;

      case "directory":
        return 5;

      case "fifo":
        return 6;

      case "contiguous-file":
        return 7;

      case "pax-header":
        return 72;
    }
    return 0;
}

function Sr(e, t, n, r) {
    for (;n < r; n++) {
        if (e[n] === t) return n;
    }
    return r;
}

function Rr(e) {
    let t = 8 * 32;
    for (let n = 0; n < 148; n++) t += e[n];
    for (let n = 156; n < 512; n++) t += e[n];
    return t;
}

function Ir(e, t) {
    e = e.toString(8);
    if (e.length > t) return ar.slice(0, t) + " ";
    return sr.slice(0, t - e.length) + e + " ";
}

function Or(e, t, n) {
    t[n] = 128;
    for (let r = 11; r > 0; r--) {
        t[n + r] = e & 255;
        e = Math.floor(e / 256);
    }
}

function Cr(e, t, n) {
    if (e.toString(8).length > 11) {
        Or(e, t, n);
    } else {
        ir.write(t, Ir(e, 11), n);
    }
}

function Pr(e) {
    let t;
    if (e[0] === 128) t = true; else if (e[0] === 255) t = false; else return null;
    const n = [];
    let r;
    for (r = e.length