lakutata 2.0.95 → 2.0.96

package/vendor/Package.internal.188.cjs

@@ -1,14 +1,943 @@
-/* Build Date: Mon Nov 24 2025 17:58:53 GMT+0800 (China Standard Time) */
+/* Build Date: Mon Nov 24 2025 18:02:01 GMT+0800 (China Standard Time) */
 "use strict";
 
-function t(t) {
-    if (typeof t !== "string") {
-        throw new TypeError(`Expected a string, got ${typeof t}`);
+const e = require("./Package.internal.189.cjs");
+
+const t = require("./Package.internal.91.cjs");
+
+const i = require("./Package.internal.36.cjs");
+
+var n = {};
+
+var s = {};
+
+const r = i.b4a;
+
+const a = "0000000000000000000";
+
+const h = "7777777777777777777";
+
+const o = "0".charCodeAt(0);
+
+const u = r.from([ 117, 115, 116, 97, 114, 0 ]);
+
+const l = r.from([ o, o ]);
+
+const c = r.from([ 117, 115, 116, 97, 114, 32 ]);
+
+const f = r.from([ 32, 0 ]);
+
+const _ = 4095;
+
+const d = 257;
+
+const p = 263;
+
+s.decodeLongPath = function e(t, i) {
+    return I(t, 0, t.length, i);
+};
+
+s.encodePax = function e(t) {
+    let i = "";
+    if (t.name) i += E(" path=" + t.name + "\n");
+    if (t.linkname) i += E(" linkpath=" + t.linkname + "\n");
+    const n = t.pax;
+    if (n) {
+        for (const e in n) {
+            i += E(" " + e + "=" + n[e] + "\n");
+        }
     }
-    if (t.charCodeAt(0) === 65279) {
-        return t.slice(1);
+    return r.from(i);
+};
+
+s.decodePax = function e(t) {
+    const i = {};
+    while (t.length) {
+        let e = 0;
+        while (e < t.length && t[e] !== 32) e++;
+        const n = parseInt(r.toString(t.subarray(0, e)), 10);
+        if (!n) return i;
+        const s = r.toString(t.subarray(e + 1, n - 1));
+        const a = s.indexOf("=");
+        if (a === -1) return i;
+        i[s.slice(0, a)] = s.slice(a + 1);
+        t = t.subarray(n);
+    }
+    return i;
+};
+
+s.encode = function e(t) {
+    const i = r.alloc(512);
+    let n = t.name;
+    let s = "";
+    if (t.typeflag === 5 && n[n.length - 1] !== "/") n += "/";
+    if (r.byteLength(n) !== n.length) return null;
+    while (r.byteLength(n) > 100) {
+        const e = n.indexOf("/");
+        if (e === -1) return null;
+        s += s ? "/" + n.slice(0, e) : n.slice(0, e);
+        n = n.slice(e + 1);
+    }
+    if (r.byteLength(n) > 100 || r.byteLength(s) > 155) return null;
+    if (t.linkname && r.byteLength(t.linkname) > 100) return null;
+    r.write(i, n);
+    r.write(i, L(t.mode & _, 6), 100);
+    r.write(i, L(t.uid, 6), 108);
+    r.write(i, L(t.gid, 6), 116);
+    P(t.size, i, 124);
+    r.write(i, L(t.mtime.getTime() / 1e3 | 0, 11), 136);
+    i[156] = o + b(t.type);
+    if (t.linkname) r.write(i, t.linkname, 157);
+    r.copy(u, i, d);
+    r.copy(l, i, p);
+    if (t.uname) r.write(i, t.uname, 265);
+    if (t.gname) r.write(i, t.gname, 297);
+    r.write(i, L(t.devmajor || 0, 6), 329);
+    r.write(i, L(t.devminor || 0, 6), 337);
+    if (s) r.write(i, s, 345);
+    r.write(i, L(x(i), 6), 148);
+    return i;
+};
+
+s.decode = function e(t, i, n) {
+    let s = t[156] === 0 ? 0 : t[156] - o;
+    let r = I(t, 0, 100, i);
+    const a = v(t, 100, 8);
+    const h = v(t, 108, 8);
+    const u = v(t, 116, 8);
+    const l = v(t, 124, 12);
+    const c = v(t, 136, 12);
+    const f = y(s);
+    const _ = t[157] === 0 ? null : I(t, 157, 100, i);
+    const d = I(t, 265, 32);
+    const p = I(t, 297, 32);
+    const k = v(t, 329, 8);
+    const b = v(t, 337, 8);
+    const w = x(t);
+    if (w === 8 * 32) return null;
+    if (w !== v(t, 148, 8)) throw new Error("Invalid tar header. Maybe the tar is corrupted or it needs to be gunzipped?");
+    if (m(t)) {
+        if (t[345]) r = I(t, 345, 155, i) + "/" + r;
+    } else if (g(t)) ; else {
+        if (!n) {
+            throw new Error("Invalid tar header: unknown format.");
+        }
     }
+    if (s === 0 && r && r[r.length - 1] === "/") s = 5;
+    return {
+        name: r,
+        mode: a,
+        uid: h,
+        gid: u,
+        size: l,
+        mtime: new Date(1e3 * c),
+        type: f,
+        linkname: _,
+        uname: d,
+        gname: p,
+        devmajor: k,
+        devminor: b,
+        pax: null
+    };
+};
+
+function m(e) {
+    return r.equals(u, e.subarray(d, d + 6));
+}
+
+function g(e) {
+    return r.equals(c, e.subarray(d, d + 6)) && r.equals(f, e.subarray(p, p + 2));
+}
+
+function k(e, t, i) {
+    if (typeof e !== "number") return i;
+    e = ~~e;
+    if (e >= t) return t;
+    if (e >= 0) return e;
+    e += t;
+    if (e >= 0) return e;
+    return 0;
+}
+
+function y(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 b(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 w(e, t, i, n) {
+    for (;i < n; i++) {
+        if (e[i] === t) return i;
+    }
+    return n;
+}
+
+function x(e) {
+    let t = 8 * 32;
+    for (let i = 0; i < 148; i++) t += e[i];
+    for (let i = 156; i < 512; i++) t += e[i];
     return t;
 }
 
-exports.stripBom = t;
+function L(e, t) {
+    e = e.toString(8);
+    if (e.length > t) return h.slice(0, t) + " ";
+    return a.slice(0, t - e.length) + e + " ";
+}
+
+function z(e, t, i) {
+    t[i] = 128;
+    for (let n = 11; n > 0; n--) {
+        t[i + n] = e & 255;
+        e = Math.floor(e / 256);
+    }
+}
+
+function P(e, t, i) {
+    if (e.toString(8).length > 11) {
+        z(e, t, i);
+    } else {
+        r.write(t, L(e, 11), i);
+    }
+}
+
+function S(e) {
+    let t;
+    if (e[0] === 128) t = true; else if (e[0] === 255) t = false; else return null;
+    const i = [];
+    let n;
+    for (n = e.length - 1; n > 0; n--) {
+        const s = e[n];
+        if (t) i.push(s); else i.push(255 - s);
+    }
+    let s = 0;
+    const r = i.length;
+    for (n = 0; n < r; n++) {
+        s += i[n] * Math.pow(256, n);
+    }
+    return t ? s : -1 * s;
+}
+
+function v(e, t, i) {
+    e = e.subarray(t, t + i);
+    t = 0;
+    if (e[t] & 128) {
+        return S(e);
+    } else {
+        while (t < e.length && e[t] === 32) t++;
+        const i = k(w(e, 32, t, e.length), e.length, e.length);
+        while (t < i && e[t] === 0) t++;
+        if (i === t) return 0;
+        return parseInt(r.toString(e.subarray(t, i)), 8);
+    }
+}
+
+function I(e, t, i, n) {
+    return r.toString(e.subarray(t, w(e, 0, t, t + i)), n);
+}
+
+function E(e) {
+    const t = r.byteLength(e);
+    let i = Math.floor(Math.log(t) / Math.log(10)) + 1;
+    if (t + i >= Math.pow(10, i)) i++;
+    return t + i + e;
+}
+
+const {Writable: F, Readable: H, getStreamError: q} = e.streamx;
+
+const O = t.fastFifo;
+
+const B = i.b4a;
+
+const M = s;
+
+const W = B.alloc(0);
+
+class BufferList {
+    constructor() {
+        this.buffered = 0;
+        this.shifted = 0;
+        this.queue = new O;
+        this._offset = 0;
+    }
+    push(e) {
+        this.buffered += e.byteLength;
+        this.queue.push(e);
+    }
+    shiftFirst(e) {
+        return this._buffered === 0 ? null : this._next(e);
+    }
+    shift(e) {
+        if (e > this.buffered) return null;
+        if (e === 0) return W;
+        let t = this._next(e);
+        if (e === t.byteLength) return t;
+        const i = [ t ];
+        while ((e -= t.byteLength) > 0) {
+            t = this._next(e);
+            i.push(t);
+        }
+        return B.concat(i);
+    }
+    _next(e) {
+        const t = this.queue.peek();
+        const i = t.byteLength - this._offset;
+        if (e >= i) {
+            const e = this._offset ? t.subarray(this._offset, t.byteLength) : t;
+            this.queue.shift();
+            this._offset = 0;
+            this.buffered -= i;
+            this.shifted += i;
+            return e;
+        }
+        this.buffered -= e;
+        this.shifted += e;
+        return t.subarray(this._offset, this._offset += e);
+    }
+}
+
+class Source extends H {
+    constructor(e, t, i) {
+        super();
+        this.header = t;
+        this.offset = i;
+        this._parent = e;
+    }
+    _read(e) {
+        if (this.header.size === 0) {
+            this.push(null);
+        }
+        if (this._parent._stream === this) {
+            this._parent._update();
+        }
+        e(null);
+    }
+    _predestroy() {
+        this._parent.destroy(q(this));
+    }
+    _detach() {
+        if (this._parent._stream === this) {
+            this._parent._stream = null;
+            this._parent._missing = D(this.header.size);
+            this._parent._update();
+        }
+    }
+    _destroy(e) {
+        this._detach();
+        e(null);
+    }
+}
+
+class Extract extends F {
+    constructor(e) {
+        super(e);
+        if (!e) e = {};
+        this._buffer = new BufferList;
+        this._offset = 0;
+        this._header = null;
+        this._stream = null;
+        this._missing = 0;
+        this._longHeader = false;
+        this._callback = C;
+        this._locked = false;
+        this._finished = false;
+        this._pax = null;
+        this._paxGlobal = null;
+        this._gnuLongPath = null;
+        this._gnuLongLinkPath = null;
+        this._filenameEncoding = e.filenameEncoding || "utf-8";
+        this._allowUnknownFormat = !!e.allowUnknownFormat;
+        this._unlockBound = this._unlock.bind(this);
+    }
+    _unlock(e) {
+        this._locked = false;
+        if (e) {
+            this.destroy(e);
+            this._continueWrite(e);
+            return;
+        }
+        this._update();
+    }
+    _consumeHeader() {
+        if (this._locked) return false;
+        this._offset = this._buffer.shifted;
+        try {
+            this._header = M.decode(this._buffer.shift(512), this._filenameEncoding, this._allowUnknownFormat);
+        } catch (e) {
+            this._continueWrite(e);
+            return false;
+        }
+        if (!this._header) return true;
+        switch (this._header.type) {
+          case "gnu-long-path":
+          case "gnu-long-link-path":
+          case "pax-global-header":
+          case "pax-header":
+            this._longHeader = true;
+            this._missing = this._header.size;
+            return true;
+        }
+        this._locked = true;
+        this._applyLongHeaders();
+        if (this._header.size === 0 || this._header.type === "directory") {
+            this.emit("entry", this._header, this._createStream(), this._unlockBound);
+            return true;
+        }
+        this._stream = this._createStream();
+        this._missing = this._header.size;
+        this.emit("entry", this._header, this._stream, this._unlockBound);
+        return true;
+    }
+    _applyLongHeaders() {
+        if (this._gnuLongPath) {
+            this._header.name = this._gnuLongPath;
+            this._gnuLongPath = null;
+        }
+        if (this._gnuLongLinkPath) {
+            this._header.linkname = this._gnuLongLinkPath;
+            this._gnuLongLinkPath = null;
+        }
+        if (this._pax) {
+            if (this._pax.path) this._header.name = this._pax.path;
+            if (this._pax.linkpath) this._header.linkname = this._pax.linkpath;
+            if (this._pax.size) this._header.size = parseInt(this._pax.size, 10);
+            this._header.pax = this._pax;
+            this._pax = null;
+        }
+    }
+    _decodeLongHeader(e) {
+        switch (this._header.type) {
+          case "gnu-long-path":
+            this._gnuLongPath = M.decodeLongPath(e, this._filenameEncoding);
+            break;
+
+          case "gnu-long-link-path":
+            this._gnuLongLinkPath = M.decodeLongPath(e, this._filenameEncoding);
+            break;
+
+          case "pax-global-header":
+            this._paxGlobal = M.decodePax(e);
+            break;
+
+          case "pax-header":
+            this._pax = this._paxGlobal === null ? M.decodePax(e) : Object.assign({}, this._paxGlobal, M.decodePax(e));
+            break;
+        }
+    }
+    _consumeLongHeader() {
+        this._longHeader = false;
+        this._missing = D(this._header.size);
+        const e = this._buffer.shift(this._header.size);
+        try {
+            this._decodeLongHeader(e);
+        } catch (e) {
+            this._continueWrite(e);
+            return false;
+        }
+        return true;
+    }
+    _consumeStream() {
+        const e = this._buffer.shiftFirst(this._missing);
+        if (e === null) return false;
+        this._missing -= e.byteLength;
+        const t = this._stream.push(e);
+        if (this._missing === 0) {
+            this._stream.push(null);
+            if (t) this._stream._detach();
+            return t && this._locked === false;
+        }
+        return t;
+    }
+    _createStream() {
+        return new Source(this, this._header, this._offset);
+    }
+    _update() {
+        while (this._buffer.buffered > 0 && !this.destroying) {
+            if (this._missing > 0) {
+                if (this._stream !== null) {
+                    if (this._consumeStream() === false) return;
+                    continue;
+                }
+                if (this._longHeader === true) {
+                    if (this._missing > this._buffer.buffered) break;
+                    if (this._consumeLongHeader() === false) return false;
+                    continue;
+                }
+                const e = this._buffer.shiftFirst(this._missing);
+                if (e !== null) this._missing -= e.byteLength;
+                continue;
+            }
+            if (this._buffer.buffered < 512) break;
+            if (this._stream !== null || this._consumeHeader() === false) return;
+        }
+        this._continueWrite(null);
+    }
+    _continueWrite(e) {
+        const t = this._callback;
+        this._callback = C;
+        t(e);
+    }
+    _write(e, t) {
+        this._callback = t;
+        this._buffer.push(e);
+        this._update();
+    }
+    _final(e) {
+        this._finished = this._missing === 0 && this._buffer.buffered === 0;
+        e(this._finished ? null : new Error("Unexpected end of data"));
+    }
+    _predestroy() {
+        this._continueWrite(null);
+    }
+    _destroy(e) {
+        if (this._stream) this._stream.destroy(q(this));
+        e(null);
+    }
+    [Symbol.asyncIterator]() {
+        let e = null;
+        let t = null;
+        let i = null;
+        let n = null;
+        let s = null;
+        const r = this;
+        this.on("entry", o);
+        this.on("error", t => {
+            e = t;
+        });
+        this.on("close", u);
+        return {
+            [Symbol.asyncIterator]() {
+                return this;
+            },
+            next() {
+                return new Promise(h);
+            },
+            return() {
+                return l(null);
+            },
+            throw(e) {
+                return l(e);
+            }
+        };
+        function a(e) {
+            if (!s) return;
+            const t = s;
+            s = null;
+            t(e);
+        }
+        function h(s, h) {
+            if (e) {
+                return h(e);
+            }
+            if (n) {
+                s({
+                    value: n,
+                    done: false
+                });
+                n = null;
+                return;
+            }
+            t = s;
+            i = h;
+            a(null);
+            if (r._finished && t) {
+                t({
+                    value: undefined,
+                    done: true
+                });
+                t = i = null;
+            }
+        }
+        function o(e, r, a) {
+            s = a;
+            r.on("error", C);
+            if (t) {
+                t({
+                    value: r,
+                    done: false
+                });
+                t = i = null;
+            } else {
+                n = r;
+            }
+        }
+        function u() {
+            a(e);
+            if (!t) return;
+            if (e) i(e); else t({
+                value: undefined,
+                done: true
+            });
+            t = i = null;
+        }
+        function l(e) {
+            r.destroy(e);
+            a(e);
+            return new Promise((t, i) => {
+                if (r.destroyed) return t({
+                    value: undefined,
+                    done: true
+                });
+                r.once("close", function() {
+                    if (e) i(e); else t({
+                        value: undefined,
+                        done: true
+                    });
+                });
+            });
+        }
+    }
+}
+
+var j = function e(t) {
+    return new Extract(t);
+};
+
+function C() {}
+
+function D(e) {
+    e &= 511;
+    return e && 512 - e;
+}
+
+var R = {
+    exports: {}
+};
+
+R.exports;
+
+const G = {
+    S_IFMT: 61440,
+    S_IFDIR: 16384,
+    S_IFCHR: 8192,
+    S_IFBLK: 24576,
+    S_IFIFO: 4096,
+    S_IFLNK: 40960
+};
+
+try {
+    R.exports = require("fs").constants || G;
+} catch {
+    R.exports = G;
+}
+
+var K = R.exports;
+
+const {Readable: U, Writable: V, getStreamError: N} = e.streamx;
+
+const T = i.b4a;
+
+const A = K;
+
+const J = s;
+
+const Q = 493;
+
+const X = 420;
+
+const Y = T.alloc(1024);
+
+class Sink extends V {
+    constructor(e, t, i) {
+        super({
+            mapWritable: ie,
+            eagerOpen: true
+        });
+        this.written = 0;
+        this.header = t;
+        this._callback = i;
+        this._linkname = null;
+        this._isLinkname = t.type === "symlink" && !t.linkname;
+        this._isVoid = t.type !== "file" && t.type !== "contiguous-file";
+        this._finished = false;
+        this._pack = e;
+        this._openCallback = null;
+        if (this._pack._stream === null) this._pack._stream = this; else this._pack._pending.push(this);
+    }
+    _open(e) {
+        this._openCallback = e;
+        if (this._pack._stream === this) this._continueOpen();
+    }
+    _continuePack(e) {
+        if (this._callback === null) return;
+        const t = this._callback;
+        this._callback = null;
+        t(e);
+    }
+    _continueOpen() {
+        if (this._pack._stream === null) this._pack._stream = this;
+        const e = this._openCallback;
+        this._openCallback = null;
+        if (e === null) return;
+        if (this._pack.destroying) return e(new Error("pack stream destroyed"));
+        if (this._pack._finalized) return e(new Error("pack stream is already finalized"));
+        this._pack._stream = this;
+        if (!this._isLinkname) {
+            this._pack._encode(this.header);
+        }
+        if (this._isVoid) {
+            this._finish();
+            this._continuePack(null);
+        }
+        e(null);
+    }
+    _write(e, t) {
+        if (this._isLinkname) {
+            this._linkname = this._linkname ? T.concat([ this._linkname, e ]) : e;
+            return t(null);
+        }
+        if (this._isVoid) {
+            if (e.byteLength > 0) {
+                return t(new Error("No body allowed for this entry"));
+            }
+            return t();
+        }
+        this.written += e.byteLength;
+        if (this._pack.push(e)) return t();
+        this._pack._drain = t;
+    }
+    _finish() {
+        if (this._finished) return;
+        this._finished = true;
+        if (this._isLinkname) {
+            this.header.linkname = this._linkname ? T.toString(this._linkname, "utf-8") : "";
+            this._pack._encode(this.header);
+        }
+        te(this._pack, this.header.size);
+        this._pack._done(this);
+    }
+    _final(e) {
+        if (this.written !== this.header.size) {
+            return e(new Error("Size mismatch"));
+        }
+        this._finish();
+        e(null);
+    }
+    _getError() {
+        return N(this) || new Error("tar entry destroyed");
+    }
+    _predestroy() {
+        this._pack.destroy(this._getError());
+    }
+    _destroy(e) {
+        this._pack._done(this);
+        this._continuePack(this._finished ? null : this._getError());
+        e();
+    }
+}
+
+class Pack extends U {
+    constructor(e) {
+        super(e);
+        this._drain = ee;
+        this._finalized = false;
+        this._finalizing = false;
+        this._pending = [];
+        this._stream = null;
+    }
+    entry(e, t, i) {
+        if (this._finalized || this.destroying) throw new Error("already finalized or destroyed");
+        if (typeof t === "function") {
+            i = t;
+            t = null;
+        }
+        if (!i) i = ee;
+        if (!e.size || e.type === "symlink") e.size = 0;
+        if (!e.type) e.type = $(e.mode);
+        if (!e.mode) e.mode = e.type === "directory" ? Q : X;
+        if (!e.uid) e.uid = 0;
+        if (!e.gid) e.gid = 0;
+        if (!e.mtime) e.mtime = new Date;
+        if (typeof t === "string") t = T.from(t);
+        const n = new Sink(this, e, i);
+        if (T.isBuffer(t)) {
+            e.size = t.byteLength;
+            n.write(t);
+            n.end();
+            return n;
+        }
+        if (n._isVoid) {
+            return n;
+        }
+        return n;
+    }
+    finalize() {
+        if (this._stream || this._pending.length > 0) {
+            this._finalizing = true;
+            return;
+        }
+        if (this._finalized) return;
+        this._finalized = true;
+        this.push(Y);
+        this.push(null);
+    }
+    _done(e) {
+        if (e !== this._stream) return;
+        this._stream = null;
+        if (this._finalizing) this.finalize();
+        if (this._pending.length) this._pending.shift()._continueOpen();
+    }
+    _encode(e) {
+        if (!e.pax) {
+            const t = J.encode(e);
+            if (t) {
+                this.push(t);
+                return;
+            }
+        }
+        this._encodePax(e);
+    }
+    _encodePax(e) {
+        const t = J.encodePax({
+            name: e.name,
+            linkname: e.linkname,
+            pax: e.pax
+        });
+        const i = {
+            name: "PaxHeader",
+            mode: e.mode,
+            uid: e.uid,
+            gid: e.gid,
+            size: t.byteLength,
+            mtime: e.mtime,
+            type: "pax-header",
+            linkname: e.linkname && "PaxHeader",
+            uname: e.uname,
+            gname: e.gname,
+            devmajor: e.devmajor,
+            devminor: e.devminor
+        };
+        this.push(J.encode(i));
+        this.push(t);
+        te(this, t.byteLength);
+        i.size = e.size;
+        i.type = e.type;
+        this.push(J.encode(i));
+    }
+    _doDrain() {
+        const e = this._drain;
+        this._drain = ee;
+        e();
+    }
+    _predestroy() {
+        const e = N(this);
+        if (this._stream) this._stream.destroy(e);
+        while (this._pending.length) {
+            const t = this._pending.shift();
+            t.destroy(e);
+            t._continueOpen();
+        }
+        this._doDrain();
+    }
+    _read(e) {
+        this._doDrain();
+        e();
+    }
+}
+
+var Z = function e(t) {
+    return new Pack(t);
+};
+
+function $(e) {
+    switch (e & A.S_IFMT) {
+      case A.S_IFBLK:
+        return "block-device";
+
+      case A.S_IFCHR:
+        return "character-device";
+
+      case A.S_IFDIR:
+        return "directory";
+
+      case A.S_IFIFO:
+        return "fifo";
+
+      case A.S_IFLNK:
+        return "symlink";
+    }
+    return "file";
+}
+
+function ee() {}
+
+function te(e, t) {
+    t &= 511;
+    if (t) e.push(Y.subarray(0, 512 - t));
+}
+
+function ie(e) {
+    return T.isBuffer(e) ? e : T.from(e);
+}
+
+exports.extract = n.extract = j;
+
+n.pack = Z;