lakutata/src/components/docker/Docker.cjs

An IoC-based universal application framework.

/* Build Date: Mon Jan 05 2026 23:52:23 GMT+0800 (China Standard Time) */
"use strict";

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

const e = require("../../../vendor/Package.internal.3.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.internal.7.cjs");

const u = require("../../../vendor/Package.internal.56.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 y = require("./exceptions/DockerImageImportException.cjs");

const v = require("../../../vendor/Package.internal.2.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 T = require("../../lib/helpers/DevNull.cjs");

const E = require("../../../vendor/Package.internal.6.cjs");

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

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

require("../../../vendor/Package.internal.4.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("../../../vendor/Package.internal.5.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.internal.1.cjs");

require("node:crypto");

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

require("node:util/types");

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

require("url");

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

require("../../../vendor/Package.internal.8.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("./types/ContainerCapability.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("crypto");

require("assert");

require("buffer");

require("tls");

require("dns");

require("zlib");

require("../../../vendor/Package.internal.52.cjs");

require("tty");

require("constants");

require("../../../vendor/Package.internal.54.cjs");

require("node:os");

require("node:events");

require("node:diagnostics_channel");

require("worker_threads");

require("module");

require("string_decoder");

require("node:worker_threads");

require("process");

require("http2");

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

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

const N = L(A);

const q = L(j);

var F = {};

var M = N.default;

var V = 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 B = V;

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;
    }
};

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

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

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

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

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

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

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

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

function Y(e, t, n, r, i) {
    return oe(e).copy(t, n, r, i);
}

function Z(e, t) {
    return oe(e).equals(t);
}

function Q(e, t, n, r, i) {
    return oe(e).fill(t, n, r, i);
}

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

function te(e, t, n, r) {
    return oe(e).includes(t, n, r);
}

function ne(e, t, n, r) {
    return oe(e).indexOf(t, n, r);
}

function re(e, t, n, r) {
    return oe(e).lastIndexOf(t, n, r);
}

function ie(e) {
    return oe(e).swap16();
}

function se(e) {
    return oe(e).swap32();
}

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

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

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

function ce(e, t, n, r, i) {
    return oe(e).write(t, n, r, i);
}

function le(e, t) {
    return oe(e).readDoubleBE(t);
}

function fe(e, t) {
    return oe(e).readDoubleLE(t);
}

function he(e, t) {
    return oe(e).readFloatBE(t);
}

function de(e, t) {
    return oe(e).readFloatLE(t);
}

function ge(e, t) {
    return oe(e).readInt32BE(t);
}

function pe(e, t) {
    return oe(e).readInt32LE(t);
}

function me(e, t) {
    return oe(e).readUInt32BE(t);
}

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

function _e(e, t, n) {
    return oe(e).writeDoubleBE(t, n);
}

function ye(e, t, n) {
    return oe(e).writeDoubleLE(t, n);
}

function ve(e, t, n) {
    return oe(e).writeFloatBE(t, n);
}

function Ae(e, t, n) {
    return oe(e).writeFloatLE(t, n);
}

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

function we(e, t, n) {
    return oe(e).writeInt32LE(t, n);
}

function xe(e, t, n) {
    return oe(e).writeUInt32BE(t, n);
}

function Se(e, t, n) {
    return oe(e).writeUInt32LE(t, n);
}

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

const Ie = Re;

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

const Ce = Re;

var Pe = 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 Ce.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 Te = Oe;

const Ee = Pe;

var De = class TextDecoder {
    constructor(e = "utf8") {
        this.encoding = je(e);
        switch (this.encoding) {
          case "utf8":
            this.decoder = new Ee;
            break;

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

          default:
            this.decoder = new Te(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 je(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 {EventEmitter: Le} = M;

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

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

const Fe = U;

const Me = De;

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

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

const Ue = 1;

const We = 2;

const He = 4;

const ze = 8;

const Ke = Be ^ Ue;

const $e = Be ^ We;

const Je = 1 << 4;

const Ge = 2 << 4;

const Xe = 4 << 4;

const Ye = 8 << 4;

const Ze = 16 << 4;

const Qe = 32 << 4;

const et = 64 << 4;

const tt = 128 << 4;

const nt = 256 << 4;

const rt = 512 << 4;

const it = 1024 << 4;

const st = 2048 << 4;

const at = 4096 << 4;

const ot = 8192 << 4;

const ut = Ze | Qe;

const ct = Je | at;

const lt = Xe | Je;

const ft = nt | Ye;

const ht = Ze | ot;

const dt = Be ^ Je;

const gt = Be ^ Xe;

const pt = Be ^ (Xe | at);

const mt = Be ^ at;

const bt = Be ^ Ze;

const _t = Be ^ (Ye | rt);

const yt = Be ^ et;

const vt = Be ^ ut;

const At = Be ^ st;

const kt = Be ^ Ge;

const wt = Be ^ ot;

const xt = Be ^ ht;

const St = 1 << 18;

const Rt = 2 << 18;

const It = 4 << 18;

const Ot = 8 << 18;

const Ct = 16 << 18;

const Pt = 32 << 18;

const Tt = 64 << 18;

const Et = 128 << 18;

const Dt = 256 << 18;

const jt = 512 << 18;

const Lt = 1024 << 18;

const Nt = Be ^ (St | Dt);

const qt = Be ^ It;

const Ft = Be ^ (St | jt);

const Mt = Be ^ Ct;

const Vt = Be ^ Ot;

const Bt = Be ^ Et;

const Ut = Be ^ Rt;

const Wt = Be ^ Lt;

const Ht = Je | St;

const zt = Be ^ Ht;

const Kt = it | Pt;

const $t = He | ze | We;

const Jt = $t | Ue;

const Gt = $t | Kt;

const Xt = qt & gt;

const Yt = Et | st;

const Zt = Yt & zt;

const Qt = Jt | Zt;

const en = Jt | et | it;

const tn = Jt | it | Ye;

const nn = Jt | et | Ye;

const rn = Jt | nt | Ye | rt;

const sn = Jt | Je | et | it | at | ot;

const an = $t | et | it;

const on = Ge | Jt | st | Xe;

const un = st | Ue;

const cn = Jt | jt | Pt;

const ln = Ot | Ct;

const fn = Ot | St;

const hn = Ot | Ct | Jt | St;

const dn = Jt | St | Ot | Lt;

const gn = It | St;

const pn = St | Dt;

const mn = Jt | jt | fn | Pt;

const bn = Ct | $t | jt | Pt;

const _n = Rt | Jt | Et | It;

const yn = jt | Pt | $t;

const vn = 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 Fe;
        this.highWaterMark = t;
        this.buffered = 0;
        this.error = null;
        this.pipeline = null;
        this.drains = null;
        this.byteLength = s || i || Kn;
        this.map = r || n;
        this.afterWrite = xn.bind(this);
        this.afterUpdateNextTick = In.bind(this);
    }
    get ended() {
        return (this.stream._duplexState & Pt) !== 0;
    }
    push(e) {
        if ((this.stream._duplexState & yn) !== 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 |= Ot;
            return true;
        }
        this.stream._duplexState |= ln;
        return false;
    }
    shift() {
        const e = this.queue.shift();
        this.buffered -= this.byteLength(e);
        if (this.buffered === 0) this.stream._duplexState &= Vt;
        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 | jt) & qt;
    }
    autoBatch(e, t) {
        const n = [];
        const r = this.stream;
        n.push(e);
        while ((r._duplexState & dn) === fn) {
            n.push(r._writableState.shift());
        }
        if ((r._duplexState & Jt) !== 0) return t(null);
        r._writev(n, t);
    }
    update() {
        const e = this.stream;
        e._duplexState |= Rt;
        do {
            while ((e._duplexState & dn) === Ot) {
                const t = this.shift();
                e._duplexState |= pn;
                e._write(t, this.afterWrite);
            }
            if ((e._duplexState & gn) === 0) this.updateNonPrimary();
        } while (this.continueUpdate() === true);
        e._duplexState &= Ut;
    }
    updateNonPrimary() {
        const e = this.stream;
        if ((e._duplexState & mn) === jt) {
            e._duplexState = e._duplexState | St;
            e._final(kn.bind(this));
            return;
        }
        if ((e._duplexState & $t) === He) {
            if ((e._duplexState & Yt) === 0) {
                e._duplexState |= Ht;
                e._destroy(wn.bind(this));
            }
            return;
        }
        if ((e._duplexState & Qt) === Ue) {
            e._duplexState = (e._duplexState | Ht) & Ke;
            e._open(Cn.bind(this));
        }
    }
    continueUpdate() {
        if ((this.stream._duplexState & Et) === 0) return false;
        this.stream._duplexState &= Bt;
        return true;
    }
    updateCallback() {
        if ((this.stream._duplexState & _n) === It) this.update(); else this.updateNextTick();
    }
    updateNextTick() {
        if ((this.stream._duplexState & Et) !== 0) return;
        this.stream._duplexState |= Et;
        if ((this.stream._duplexState & Rt) === 0) Ve(this.afterUpdateNextTick);
    }
}

class ReadableState {
    constructor(e, {highWaterMark: t = 16384, map: n = null, mapReadable: r, byteLength: i, byteLengthReadable: s} = {}) {
        this.stream = e;
        this.queue = new Fe;
        this.highWaterMark = t === 0 ? 1 : t;
        this.buffered = 0;
        this.readAhead = t > 0;
        this.error = null;
        this.pipeline = null;
        this.byteLength = s || i || Kn;
        this.map = r || n;
        this.pipeTo = null;
        this.afterRead = Sn.bind(this);
        this.afterUpdateNextTick = Rn.bind(this);
    }
    get ended() {
        return (this.stream._duplexState & it) !== 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 |= Qe;
        this.pipeTo = e;
        this.pipeline = new Pipeline(this.stream, e, t);
        if (t) this.stream.on("error", $n);
        if (Mn(e)) {
            e._writableState.pipeline = this.pipeline;
            if (t) e.on("error", $n);
            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", An.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 | et) & pt;
            return false;
        }
        if (this.map !== null) {
            e = this.map(e);
            if (e === null) {
                t._duplexState &= mt;
                return this.buffered < this.highWaterMark;
            }
        }
        this.buffered += this.byteLength(e);
        this.queue.push(e);
        t._duplexState = (t._duplexState | Ye) & mt;
        return this.buffered < this.highWaterMark;
    }
    shift() {
        const e = this.queue.shift();
        this.buffered -= this.byteLength(e);
        if (this.buffered === 0) this.stream._duplexState &= _t;
        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 & tn) === Ye) {
            const t = this.shift();
            if (this.pipeTo !== null && this.pipeTo.write(t) === false) e._duplexState &= vt;
            if ((e._duplexState & tt) !== 0) e.emit("data", t);
            return t;
        }
        if (this.readAhead === false) {
            e._duplexState |= ot;
            this.updateNextTick();
        }
        return null;
    }
    drain() {
        const e = this.stream;
        while ((e._duplexState & tn) === Ye && (e._duplexState & ut) !== 0) {
            const t = this.shift();
            if (this.pipeTo !== null && this.pipeTo.write(t) === false) e._duplexState &= vt;
            if ((e._duplexState & tt) !== 0) e.emit("data", t);
        }
    }
    update() {
        const e = this.stream;
        e._duplexState |= Ge;
        do {
            this.drain();
            while (this.buffered < this.highWaterMark && (e._duplexState & sn) === ot) {
                e._duplexState |= ct;
                e._read(this.afterRead);
                this.drain();
            }
            if ((e._duplexState & rn) === ft) {
                e._duplexState |= rt;
                e.emit("readable");
            }
            if ((e._duplexState & lt) === 0) this.updateNonPrimary();
        } while (this.continueUpdate() === true);
        e._duplexState &= kt;
    }
    updateNonPrimary() {
        const e = this.stream;
        if ((e._duplexState & nn) === et) {
            e._duplexState = (e._duplexState | it) & yt;
            e.emit("end");
            if ((e._duplexState & Gt) === Kt) e._duplexState |= He;
            if (this.pipeTo !== null) this.pipeTo.end();
        }
        if ((e._duplexState & $t) === He) {
            if ((e._duplexState & Yt) === 0) {
                e._duplexState |= Ht;
                e._destroy(wn.bind(this));
            }
            return;
        }
        if ((e._duplexState & Qt) === Ue) {
            e._duplexState = (e._duplexState | Ht) & Ke;
            e._open(Cn.bind(this));
        }
    }
    continueUpdate() {
        if ((this.stream._duplexState & st) === 0) return false;
        this.stream._duplexState &= At;
        return true;
    }
    updateCallback() {
        if ((this.stream._duplexState & on) === Xe) this.update(); else this.updateNextTick();
    }
    updateNextTickIfOpen() {
        if ((this.stream._duplexState & un) !== 0) return;
        this.stream._duplexState |= st;
        if ((this.stream._duplexState & Ge) === 0) Ve(this.afterUpdateNextTick);
    }
    updateNextTick() {
        if ((this.stream._duplexState & st) !== 0) return;
        this.stream._duplexState |= st;
        if ((this.stream._duplexState & Ge) === 0) Ve(this.afterUpdateNextTick);
    }
}

class TransformState {
    constructor(e) {
        this.data = null;
        this.afterTransform = Pn.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 & it) === 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 & it) === 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 An() {
    this.stream._duplexState |= Qe;
    this.updateCallback();
}

function kn(e) {
    const t = this.stream;
    if (e) t.destroy(e);
    if ((t._duplexState & $t) === 0) {
        t._duplexState |= Pt;
        t.emit("finish");
    }
    if ((t._duplexState & Gt) === Kt) {
        t._duplexState |= He;
    }
    t._duplexState &= Ft;
    if ((t._duplexState & Rt) === 0) this.update(); else this.updateNextTick();
}

function wn(e) {
    const t = this.stream;
    if (!e && this.error !== Ne) e = this.error;
    if (e) t.emit("error", e);
    t._duplexState |= ze;
    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 xn(e) {
    const t = this.stream;
    if (e) t.destroy(e);
    t._duplexState &= Nt;
    if (this.drains !== null) On(this.drains);
    if ((t._duplexState & hn) === Ct) {
        t._duplexState &= Mt;
        if ((t._duplexState & Tt) === Tt) {
            t.emit("drain");
        }
    }
    this.updateCallback();
}

function Sn(e) {
    if (e) this.stream.destroy(e);
    this.stream._duplexState &= dt;
    if (this.readAhead === false && (this.stream._duplexState & Ze) === 0) this.stream._duplexState &= wt;
    this.updateCallback();
}

function Rn() {
    if ((this.stream._duplexState & Ge) === 0) {
        this.stream._duplexState &= At;
        this.update();
    }
}

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

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

function Cn(e) {
    const t = this.stream;
    if (e) t.destroy(e);
    if ((t._duplexState & He) === 0) {
        if ((t._duplexState & en) === 0) t._duplexState |= Xe;
        if ((t._duplexState & cn) === 0) t._duplexState |= It;
        t.emit("open");
    }
    t._duplexState &= zt;
    if (t._writableState !== null) {
        t._writableState.updateCallback();
    }
    if (t._readableState !== null) {
        t._readableState.updateCallback();
    }
}

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

function Tn(e) {
    if (this._readableState !== null) {
        if (e === "data") {
            this._duplexState |= tt | ht;
            this._readableState.updateNextTick();
        }
        if (e === "readable") {
            this._duplexState |= nt;
            this._readableState.updateNextTick();
        }
    }
    if (this._writableState !== null) {
        if (e === "drain") {
            this._duplexState |= Tt;
            this._writableState.updateNextTick();
        }
    }
}

class Stream extends Le {
    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", Jn.bind(this));
            }
        }
        this.on("newListener", Tn);
    }
    _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 & ze) !== 0;
    }
    get destroying() {
        return (this._duplexState & $t) !== 0;
    }
    destroy(e) {
        if ((this._duplexState & $t) === 0) {
            if (!e) e = Ne;
            this._duplexState = (this._duplexState | He) & Xt;
            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 |= We;
            this._predestroy();
            this._duplexState &= $e;
            if (this._readableState !== null) this._readableState.updateNextTick();
            if (this._writableState !== null) this._writableState.updateNextTick();
        }
    }
}

let En = class Readable extends Stream {
    constructor(e) {
        super(e);
        this._duplexState |= Ue | Pt | ot;
        this._readableState = new ReadableState(this, e);
        if (e) {
            if (this._readableState.readAhead === false) this._duplexState &= wt;
            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 Me(e);
        const n = this._readableState.map || qn;
        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 |= ht;
        this._readableState.updateNextTick();
        return this;
    }
    pause() {
        this._duplexState &= this._readableState.readAhead === false ? xt : bt;
        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 (Wn(e)) return e;
        if (e[vn]) return this._fromAsyncIterator(e[vn](), 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 & an) !== 0 || e._readableState.buffered >= e._readableState.highWaterMark;
    }
    static isPaused(e) {
        return (e._duplexState & Ze) === 0;
    }
    [vn]() {
        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 {
            [vn]() {
                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 & ze) !== 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 & it) === 0) r(Ne); else n({
                value: i,
                done: i === null
            });
            r = n = null;
        }
        function o(t) {
            e.destroy(t);
            return new Promise((n, r) => {
                if (e._duplexState & ze) return n({
                    value: undefined,
                    done: true
                });
                e.once("close", function() {
                    if (t) r(t); else n({
                        value: undefined,
                        done: true
                    });
                });
            });
        }
    }
};

let Dn = class Writable extends Stream {
    constructor(e) {
        super(e);
        this._duplexState |= Ue | it;
        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 |= Lt;
    }
    uncork() {
        this._duplexState &= Wt;
        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 & bn) !== 0;
    }
    static drained(e) {
        if (e.destroyed) return Promise.resolve(false);
        const t = e._writableState;
        const n = Gn(e) ? Math.min(1, t.queue.length) : t.queue.length;
        const r = n + (e._duplexState & Dt ? 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 En {
    constructor(e) {
        super(e);
        this._duplexState = Ue | this._duplexState & ot;
        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 |= Lt;
    }
    uncork() {
        this._duplexState &= Wt;
        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(jn.bind(this));
    }
}

class PassThrough extends Transform {}

function jn(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 Ln(...e) {
    return new Promise((t, n) => Nn(...e, e => {
        if (e) return n(e);
        t();
    }));
}

function Nn(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 (Mn(i)) {
            i.pipe(s, u);
        } else {
            o(i, true, e > 1, u);
            i.pipe(s);
        }
        i = s;
    }
    if (r) {
        let e = false;
        const t = Mn(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 : qe)));
        }
    }
    return s;
    function o(e, t, n, r) {
        e.on("error", r);
        e.on("close", i);
        function i() {
            if (e._readableState && !e._readableState.ended) return r(qe);
            if (n && e._writableState && !e._writableState.ended) return r(qe);
        }
    }
    function u(e) {
        if (!e || a) return;
        a = e;
        for (const t of n) {
            t.destroy(e);
        }
    }
}

function qn(e) {
    return e;
}

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

function Mn(e) {
    return typeof e._duplexState === "number" && Fn(e);
}

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

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

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

function Wn(e) {
    return Mn(e) && e.readable;
}

function Hn(e) {
    return (e._duplexState & Ue) !== Ue || (e._duplexState & Yt) !== 0;
}

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

function Kn(e) {
    return zn(e) ? e.byteLength : 1024;
}

function $n() {}

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

function Gn(e) {
    return e._writev !== Dn.prototype._writev && e._writev !== Duplex.prototype._writev;
}

var Xn = {
    pipeline: Nn,
    pipelinePromise: Ln,
    isStream: Fn,
    isStreamx: Mn,
    isEnded: Vn,
    isFinished: Bn,
    isDisturbed: Hn,
    getStreamError: Un,
    Stream: Stream,
    Writable: Dn,
    Readable: En,
    Duplex: Duplex,
    Transform: Transform,
    PassThrough: PassThrough
};

var Yn = {};

const Zn = Re;

const Qn = "0000000000000000000";

const er = "7777777777777777777";

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

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

const rr = Zn.from([ tr, tr ]);

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

const sr = Zn.from([ 32, 0 ]);

const ar = 4095;

const or = 257;

const ur = 263;

Yn.decodeLongPath = function e(t, n) {
    return Ar(t, 0, t.length, n);
};

Yn.encodePax = function e(t) {
    let n = "";
    if (t.name) n += kr(" path=" + t.name + "\n");
    if (t.linkname) n += kr(" linkpath=" + t.linkname + "\n");
    const r = t.pax;
    if (r) {
        for (const e in r) {
            n += kr(" " + e + "=" + r[e] + "\n");
        }
    }
    return Zn.from(n);
};

Yn.decodePax = function e(t) {
    const n = {};
    while (t.length) {
        let e = 0;
        while (e < t.length && t[e] !== 32) e++;
        const r = parseInt(Zn.toString(t.subarray(0, e)), 10);
        if (!r) return n;
        const i = Zn.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;
};

Yn.encode = function e(t) {
    const n = Zn.alloc(512);
    let r = t.name;
    let i = "";
    if (t.typeflag === 5 && r[r.length - 1] !== "/") r += "/";
    if (Zn.byteLength(r) !== r.length) return null;
    while (Zn.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 (Zn.byteLength(r) > 100 || Zn.byteLength(i) > 155) return null;
    if (t.linkname && Zn.byteLength(t.linkname) > 100) return null;
    Zn.write(n, r);
    Zn.write(n, mr(t.mode & ar, 6), 100);
    Zn.write(n, mr(t.uid, 6), 108);
    Zn.write(n, mr(t.gid, 6), 116);
    _r(t.size, n, 124);
    Zn.write(n, mr(t.mtime.getTime() / 1e3 | 0, 11), 136);
    n[156] = tr + dr(t.type);
    if (t.linkname) Zn.write(n, t.linkname, 157);
    Zn.copy(nr, n, or);
    Zn.copy(rr, n, ur);
    if (t.uname) Zn.write(n, t.uname, 265);
    if (t.gname) Zn.write(n, t.gname, 297);
    Zn.write(n, mr(t.devmajor || 0, 6), 329);
    Zn.write(n, mr(t.devminor || 0, 6), 337);
    if (i) Zn.write(n, i, 345);
    Zn.write(n, mr(pr(n), 6), 148);
    return n;
};

Yn.decode = function e(t, n, r) {
    let i = t[156] === 0 ? 0 : t[156] - tr;
    let s = Ar(t, 0, 100, n);
    const a = vr(t, 100, 8);
    const o = vr(t, 108, 8);
    const u = vr(t, 116, 8);
    const c = vr(t, 124, 12);
    const l = vr(t, 136, 12);
    const f = hr(i);
    const h = t[157] === 0 ? null : Ar(t, 157, 100, n);
    const d = Ar(t, 265, 32);
    const g = Ar(t, 297, 32);
    const p = vr(t, 329, 8);
    const m = vr(t, 337, 8);
    const b = pr(t);
    if (b === 8 * 32) return null;
    if (b !== vr(t, 148, 8)) throw new Error("Invalid tar header. Maybe the tar is corrupted or it needs to be gunzipped?");
    if (cr(t)) {
        if (t[345]) s = Ar(t, 345, 155, n) + "/" + s;
    } else if (lr(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 cr(e) {
    return Zn.equals(nr, e.subarray(or, or + 6));
}

function lr(e) {
    return Zn.equals(ir, e.subarray(or, or + 6)) && Zn.equals(sr, e.subarray(ur, ur + 2));
}

function fr(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 hr(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 dr(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 gr(e, t, n, r) {
    for (;n < r; n++) {
        if (e[n] === t) return n;
    }
    return r;
}

function pr(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 mr(e, t) {
    e = e.toString(8);
    if (e.length > t) return er.slice(0, t) + " ";
    return Qn.slice(0, t - e.length) + e + " ";
}

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

function _r(e, t, n) {
    if (e.toString(8).length > 11) {
        br(e, t, n);
    } else {
        Zn.write(t, mr(e, 11), n);
    }
}

function yr(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 - 1; r > 0; r--) {
        const i = e[r];
        if (t) n.push(i); else n.push(255 - i);
    }
    let i = 0;
    const s = n.length;
    for (r = 0; r < s; r++) {
        i += n[r] * Math.pow(256, r);
    }
    return t ? i : -1 * i;
}

function vr(e, t, n) {
    e = e.subarray(t, t + n);
    t = 0;
    if (e[t] & 128) {
        return yr(e);
    } else {
        while (t < e.length && e[t] === 32) t++;
        const n = fr(gr(e, 32, t, e.length), e.length, e.len