@kscs-inc/cli 0.0.0-stage → 0.3.3

package/bin/kscs.mjs

@@ -0,0 +1,2015 @@
+#!/usr/bin/env node
+import { createRequire as npmCreateRequire } from 'node:module'; const require = npmCreateRequire(import.meta.url);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../../../../code/node_modules/.pnpm/pend@1.2.0/node_modules/pend/index.js
+var require_pend = __commonJS({
+  "../../../../../code/node_modules/.pnpm/pend@1.2.0/node_modules/pend/index.js"(exports, module) {
+    module.exports = Pend;
+    function Pend() {
+      this.pending = 0;
+      this.max = Infinity;
+      this.listeners = [];
+      this.waiting = [];
+      this.error = null;
+    }
+    Pend.prototype.go = function(fn) {
+      if (this.pending < this.max) {
+        pendGo(this, fn);
+      } else {
+        this.waiting.push(fn);
+      }
+    };
+    Pend.prototype.wait = function(cb) {
+      if (this.pending === 0) {
+        cb(this.error);
+      } else {
+        this.listeners.push(cb);
+      }
+    };
+    Pend.prototype.hold = function() {
+      return pendHold(this);
+    };
+    function pendHold(self) {
+      self.pending += 1;
+      var called = false;
+      return onCb;
+      function onCb(err) {
+        if (called) throw new Error("callback called twice");
+        called = true;
+        self.error = self.error || err;
+        self.pending -= 1;
+        if (self.waiting.length > 0 && self.pending < self.max) {
+          pendGo(self, self.waiting.shift());
+        } else if (self.pending === 0) {
+          var listeners = self.listeners;
+          self.listeners = [];
+          listeners.forEach(cbListener);
+        }
+      }
+      function cbListener(listener) {
+        listener(self.error);
+      }
+    }
+    function pendGo(self, fn) {
+      fn(pendHold(self));
+    }
+  }
+});
+
+// ../../../../../code/node_modules/.pnpm/yauzl@3.4.0/node_modules/yauzl/fd-slicer.js
+var require_fd_slicer = __commonJS({
+  "../../../../../code/node_modules/.pnpm/yauzl@3.4.0/node_modules/yauzl/fd-slicer.js"(exports) {
+    var fs = __require("fs");
+    var util = __require("util");
+    var stream = __require("stream");
+    var Readable = stream.Readable;
+    var PassThrough = stream.PassThrough;
+    var Pend = require_pend();
+    var EventEmitter = __require("events").EventEmitter;
+    exports.BufferSlicer = BufferSlicer;
+    exports.FdSlicer = FdSlicer;
+    util.inherits(FdSlicer, EventEmitter);
+    function FdSlicer(fd) {
+      EventEmitter.call(this);
+      this.fd = fd;
+      this.pend = new Pend();
+      this.pend.max = 1;
+      this.refCount = 0;
+    }
+    FdSlicer.prototype.read = function(buffer, offset, length, position, callback) {
+      var self = this;
+      self.pend.go(function(cb) {
+        fs.read(self.fd, buffer, offset, length, position, function(err, bytesRead, buffer2) {
+          cb();
+          callback(err, bytesRead, buffer2);
+        });
+      });
+    };
+    FdSlicer.prototype.createReadStream = function(options2) {
+      return new ReadStream(this, options2);
+    };
+    FdSlicer.prototype.ref = function() {
+      this.refCount += 1;
+    };
+    FdSlicer.prototype.unref = function() {
+      var self = this;
+      self.refCount -= 1;
+      if (self.refCount < 0) throw new Error("invalid unref");
+      if (self.refCount > 0) return;
+      fs.close(self.fd, onCloseDone);
+      function onCloseDone(err) {
+        if (err) {
+          self.emit("error", err);
+        } else {
+          self.emit("close");
+        }
+      }
+    };
+    util.inherits(ReadStream, Readable);
+    function ReadStream(context, options2) {
+      options2 = options2 || {};
+      Readable.call(this, options2);
+      this.context = context;
+      this.context.ref();
+      this.start = options2.start || 0;
+      this.endOffset = options2.end;
+      this.pos = this.start;
+    }
+    ReadStream.prototype._read = function(n) {
+      var self = this;
+      var toRead = Math.min(self._readableState.highWaterMark, n);
+      if (self.endOffset != null) {
+        toRead = Math.min(toRead, self.endOffset - self.pos);
+      }
+      if (toRead <= 0) {
+        self.push(null);
+        this._cleanup();
+        return;
+      }
+      self.context.pend.go(function(cb) {
+        var buffer = Buffer.allocUnsafe(toRead);
+        fs.read(self.context.fd, buffer, 0, toRead, self.pos, function(err, bytesRead) {
+          if (err) {
+            self.destroy(err);
+          } else if (bytesRead === 0) {
+            self.push(null);
+            self._cleanup();
+          } else {
+            self.pos += bytesRead;
+            self.push(buffer.slice(0, bytesRead));
+          }
+          cb();
+        });
+      });
+    };
+    ReadStream.prototype._destroy = function(err, cb) {
+      this._cleanup();
+      cb(err);
+    };
+    ReadStream.prototype._cleanup = function() {
+      if (this.context != null) {
+        this.context.unref();
+        this.context = null;
+      }
+    };
+    util.inherits(BufferSlicer, EventEmitter);
+    function BufferSlicer(buffer) {
+      EventEmitter.call(this);
+      this.refCount = 0;
+      this.buffer = buffer;
+    }
+    BufferSlicer.prototype.read = function(buffer, offset, length, position, callback) {
+      if (!(0 <= offset && offset <= buffer.length)) throw new RangeError("offset outside buffer: 0 <= " + offset + " <= " + buffer.length);
+      if (position < 0) throw new RangeError("position is negative: " + position);
+      if (offset + length > buffer.length) {
+        length = buffer.length - offset;
+      }
+      if (position + length > this.buffer.length) {
+        length = this.buffer.length - position;
+      }
+      if (length <= 0) {
+        setImmediate(function() {
+          callback(null, 0);
+        });
+        return;
+      }
+      this.buffer.copy(buffer, offset, position, position + length);
+      setImmediate(function() {
+        callback(null, length);
+      });
+    };
+    BufferSlicer.prototype.createReadStream = function(options2) {
+      options2 = options2 || {};
+      var readStream = new PassThrough(options2);
+      readStream.start = options2.start || 0;
+      readStream.endOffset = options2.end;
+      readStream.pos = readStream.endOffset || this.buffer.length;
+      var entireSlice = this.buffer.slice(readStream.start, readStream.pos);
+      var maxChunkSize = 65536;
+      var offset = 0;
+      while (true) {
+        var nextOffset = offset + maxChunkSize;
+        if (nextOffset >= entireSlice.length) {
+          if (offset < entireSlice.length) {
+            readStream.write(entireSlice.slice(offset, entireSlice.length));
+          }
+          break;
+        }
+        readStream.write(entireSlice.slice(offset, nextOffset));
+        offset = nextOffset;
+      }
+      readStream.end();
+      return readStream;
+    };
+    BufferSlicer.prototype.ref = function() {
+      this.refCount += 1;
+    };
+    BufferSlicer.prototype.unref = function() {
+      this.refCount -= 1;
+      if (this.refCount < 0) {
+        throw new Error("invalid unref");
+      }
+    };
+  }
+});
+
+// ../../../../../code/node_modules/.pnpm/yauzl@3.4.0/node_modules/yauzl/crc32.js
+var require_crc32 = __commonJS({
+  "../../../../../code/node_modules/.pnpm/yauzl@3.4.0/node_modules/yauzl/crc32.js"(exports, module) {
+    var CRC_TABLE = new Int32Array([
+      0,
+      1996959894,
+      3993919788,
+      2567524794,
+      124634137,
+      1886057615,
+      3915621685,
+      2657392035,
+      249268274,
+      2044508324,
+      3772115230,
+      2547177864,
+      162941995,
+      2125561021,
+      3887607047,
+      2428444049,
+      498536548,
+      1789927666,
+      4089016648,
+      2227061214,
+      450548861,
+      1843258603,
+      4107580753,
+      2211677639,
+      325883990,
+      1684777152,
+      4251122042,
+      2321926636,
+      335633487,
+      1661365465,
+      4195302755,
+      2366115317,
+      997073096,
+      1281953886,
+      3579855332,
+      2724688242,
+      1006888145,
+      1258607687,
+      3524101629,
+      2768942443,
+      901097722,
+      1119000684,
+      3686517206,
+      2898065728,
+      853044451,
+      1172266101,
+      3705015759,
+      2882616665,
+      651767980,
+      1373503546,
+      3369554304,
+      3218104598,
+      565507253,
+      1454621731,
+      3485111705,
+      3099436303,
+      671266974,
+      1594198024,
+      3322730930,
+      2970347812,
+      795835527,
+      1483230225,
+      3244367275,
+      3060149565,
+      1994146192,
+      31158534,
+      2563907772,
+      4023717930,
+      1907459465,
+      112637215,
+      2680153253,
+      3904427059,
+      2013776290,
+      251722036,
+      2517215374,
+      3775830040,
+      2137656763,
+      141376813,
+      2439277719,
+      3865271297,
+      1802195444,
+      476864866,
+      2238001368,
+      4066508878,
+      1812370925,
+      453092731,
+      2181625025,
+      4111451223,
+      1706088902,
+      314042704,
+      2344532202,
+      4240017532,
+      1658658271,
+      366619977,
+      2362670323,
+      4224994405,
+      1303535960,
+      984961486,
+      2747007092,
+      3569037538,
+      1256170817,
+      1037604311,
+      2765210733,
+      3554079995,
+      1131014506,
+      879679996,
+      2909243462,
+      3663771856,
+      1141124467,
+      855842277,
+      2852801631,
+      3708648649,
+      1342533948,
+      654459306,
+      3188396048,
+      3373015174,
+      1466479909,
+      544179635,
+      3110523913,
+      3462522015,
+      1591671054,
+      702138776,
+      2966460450,
+      3352799412,
+      1504918807,
+      783551873,
+      3082640443,
+      3233442989,
+      3988292384,
+      2596254646,
+      62317068,
+      1957810842,
+      3939845945,
+      2647816111,
+      81470997,
+      1943803523,
+      3814918930,
+      2489596804,
+      225274430,
+      2053790376,
+      3826175755,
+      2466906013,
+      167816743,
+      2097651377,
+      4027552580,
+      2265490386,
+      503444072,
+      1762050814,
+      4150417245,
+      2154129355,
+      426522225,
+      1852507879,
+      4275313526,
+      2312317920,
+      282753626,
+      1742555852,
+      4189708143,
+      2394877945,
+      397917763,
+      1622183637,
+      3604390888,
+      2714866558,
+      953729732,
+      1340076626,
+      3518719985,
+      2797360999,
+      1068828381,
+      1219638859,
+      3624741850,
+      2936675148,
+      906185462,
+      1090812512,
+      3747672003,
+      2825379669,
+      829329135,
+      1181335161,
+      3412177804,
+      3160834842,
+      628085408,
+      1382605366,
+      3423369109,
+      3138078467,
+      570562233,
+      1426400815,
+      3317316542,
+      2998733608,
+      733239954,
+      1555261956,
+      3268935591,
+      3050360625,
+      752459403,
+      1541320221,
+      2607071920,
+      3965973030,
+      1969922972,
+      40735498,
+      2617837225,
+      3943577151,
+      1913087877,
+      83908371,
+      2512341634,
+      3803740692,
+      2075208622,
+      213261112,
+      2463272603,
+      3855990285,
+      2094854071,
+      198958881,
+      2262029012,
+      4057260610,
+      1759359992,
+      534414190,
+      2176718541,
+      4139329115,
+      1873836001,
+      414664567,
+      2282248934,
+      4279200368,
+      1711684554,
+      285281116,
+      2405801727,
+      4167216745,
+      1634467795,
+      376229701,
+      2685067896,
+      3608007406,
+      1308918612,
+      956543938,
+      2808555105,
+      3495958263,
+      1231636301,
+      1047427035,
+      2932959818,
+      3654703836,
+      1088359270,
+      936918e3,
+      2847714899,
+      3736837829,
+      1202900863,
+      817233897,
+      3183342108,
+      3401237130,
+      1404277552,
+      615818150,
+      3134207493,
+      3453421203,
+      1423857449,
+      601450431,
+      3009837614,
+      3294710456,
+      1567103746,
+      711928724,
+      3020668471,
+      3272380065,
+      1510334235,
+      755167117
+    ]);
+    function crc32(buf) {
+      let crc = -1;
+      for (let x of buf) {
+        crc = CRC_TABLE[(crc ^ x) & 255] ^ crc >>> 8;
+      }
+      return (crc ^ -1) >>> 0;
+    }
+    module.exports = crc32;
+  }
+});
+
+// ../../../../../code/node_modules/.pnpm/yauzl@3.4.0/node_modules/yauzl/index.js
+var require_yauzl = __commonJS({
+  "../../../../../code/node_modules/.pnpm/yauzl@3.4.0/node_modules/yauzl/index.js"(exports) {
+    var fs = __require("fs");
+    var zlib = __require("zlib");
+    var fd_slicer = require_fd_slicer();
+    var util = __require("util");
+    var EventEmitter = __require("events").EventEmitter;
+    var Transform2 = __require("stream").Transform;
+    var PassThrough = __require("stream").PassThrough;
+    var Writable = __require("stream").Writable;
+    var crc32 = typeof zlib.crc32 === "function" ? zlib.crc32 : require_crc32();
+    exports.open = open3;
+    exports.fromFd = fromFd;
+    exports.fromBuffer = fromBuffer;
+    exports.fromRandomAccessReader = fromRandomAccessReader;
+    exports.openPromise = openPromise;
+    exports.fromFdPromise = fromFdPromise;
+    exports.fromBufferPromise = fromBufferPromise;
+    exports.fromRandomAccessReaderPromise = fromRandomAccessReaderPromise;
+    exports.dosDateTimeToDate = dosDateTimeToDate;
+    exports.getFileNameLowLevel = getFileNameLowLevel;
+    exports.validateFileName = validateFileName;
+    exports.parseExtraFields = parseExtraFields;
+    exports.ZipFile = ZipFile;
+    exports.Entry = Entry;
+    exports.LocalFileHeader = LocalFileHeader;
+    exports.RandomAccessReader = RandomAccessReader;
+    function openPromise(path, options2) {
+      return new Promise((resolve4, reject) => {
+        open3(path, { ...options2, lazyEntries: true }, function(err, zipfile) {
+          if (err) return reject(err);
+          resolve4(zipfile);
+        });
+      });
+    }
+    function fromFdPromise(fd, options2) {
+      return new Promise((resolve4, reject) => {
+        fromFd(fd, { ...options2, lazyEntries: true }, function(err, zipfile) {
+          if (err) return reject(err);
+          resolve4(zipfile);
+        });
+      });
+    }
+    function fromBufferPromise(buffer, options2) {
+      return new Promise((resolve4, reject) => {
+        fromBuffer(buffer, { ...options2, lazyEntries: true }, function(err, zipfile) {
+          if (err) return reject(err);
+          resolve4(zipfile);
+        });
+      });
+    }
+    function fromRandomAccessReaderPromise(reader, totalSize, options2) {
+      return new Promise((resolve4, reject) => {
+        fromRandomAccessReader(reader, totalSize, { ...options2, lazyEntries: true }, function(err, zipfile) {
+          if (err) return reject(err);
+          resolve4(zipfile);
+        });
+      });
+    }
+    function open3(path, options2, callback) {
+      if (typeof options2 === "function") {
+        callback = options2;
+        options2 = null;
+      }
+      if (options2 == null) options2 = {};
+      if (options2.autoClose == null) options2.autoClose = true;
+      if (options2.lazyEntries == null) options2.lazyEntries = false;
+      if (options2.decodeStrings == null) options2.decodeStrings = true;
+      if (options2.validateEntrySizes == null) options2.validateEntrySizes = true;
+      if (options2.strictFileNames == null) options2.strictFileNames = false;
+      if (callback == null) callback = defaultCallback;
+      fs.open(path, "r", function(err, fd) {
+        if (err) return callback(err);
+        fromFd(fd, options2, function(err2, zipfile) {
+          if (err2) fs.close(fd, defaultCallback);
+          callback(err2, zipfile);
+        });
+      });
+    }
+    function fromFd(fd, options2, callback) {
+      if (typeof options2 === "function") {
+        callback = options2;
+        options2 = null;
+      }
+      if (options2 == null) options2 = {};
+      if (options2.autoClose == null) options2.autoClose = false;
+      if (options2.lazyEntries == null) options2.lazyEntries = false;
+      if (options2.decodeStrings == null) options2.decodeStrings = true;
+      if (options2.validateEntrySizes == null) options2.validateEntrySizes = true;
+      if (options2.strictFileNames == null) options2.strictFileNames = false;
+      if (callback == null) callback = defaultCallback;
+      fs.fstat(fd, function(err, stats) {
+        if (err) return callback(err);
+        var reader = new fd_slicer.FdSlicer(fd);
+        fromRandomAccessReader(reader, stats.size, options2, callback);
+      });
+    }
+    function fromBuffer(buffer, options2, callback) {
+      if (typeof options2 === "function") {
+        callback = options2;
+        options2 = null;
+      }
+      if (options2 == null) options2 = {};
+      options2.autoClose = false;
+      if (options2.lazyEntries == null) options2.lazyEntries = false;
+      if (options2.decodeStrings == null) options2.decodeStrings = true;
+      if (options2.validateEntrySizes == null) options2.validateEntrySizes = true;
+      if (options2.strictFileNames == null) options2.strictFileNames = false;
+      var reader = new fd_slicer.BufferSlicer(buffer);
+      fromRandomAccessReader(reader, buffer.length, options2, callback);
+    }
+    function fromRandomAccessReader(reader, totalSize, options2, callback) {
+      if (typeof options2 === "function") {
+        callback = options2;
+        options2 = null;
+      }
+      if (options2 == null) options2 = {};
+      if (options2.autoClose == null) options2.autoClose = true;
+      if (options2.lazyEntries == null) options2.lazyEntries = false;
+      if (options2.decodeStrings == null) options2.decodeStrings = true;
+      var decodeStrings = !!options2.decodeStrings;
+      if (options2.validateEntrySizes == null) options2.validateEntrySizes = true;
+      if (options2.strictFileNames == null) options2.strictFileNames = false;
+      if (callback == null) callback = defaultCallback;
+      if (typeof totalSize !== "number") throw new Error("expected totalSize parameter to be a number");
+      if (totalSize > Number.MAX_SAFE_INTEGER) {
+        throw new Error("zip file too large. only file sizes up to 2^52 are supported due to JavaScript's Number type being an IEEE 754 double.");
+      }
+      reader.ref();
+      var eocdrWithoutCommentSize = 22;
+      var zip64EocdlSize = 20;
+      var maxCommentSize = 65535;
+      var bufferSize = Math.min(zip64EocdlSize + eocdrWithoutCommentSize + maxCommentSize, totalSize);
+      var buffer = newBuffer(bufferSize);
+      var bufferReadStart = totalSize - buffer.length;
+      readAndAssertNoEof(reader, buffer, 0, bufferSize, bufferReadStart, function(err) {
+        if (err) return callback(err);
+        for (var i = bufferSize - eocdrWithoutCommentSize; i >= 0; i -= 1) {
+          if (buffer.readUInt32LE(i) !== 101010256) continue;
+          var eocdrBuffer = buffer.subarray(i);
+          var diskNumber = eocdrBuffer.readUInt16LE(4);
+          var entryCount = eocdrBuffer.readUInt16LE(10);
+          var centralDirectoryOffset = eocdrBuffer.readUInt32LE(16);
+          var commentLength = eocdrBuffer.readUInt16LE(20);
+          var expectedCommentLength = eocdrBuffer.length - eocdrWithoutCommentSize;
+          if (commentLength !== expectedCommentLength) {
+            return callback(new Error("Invalid comment length. Expected: " + expectedCommentLength + ". Found: " + commentLength + ". Are there extra bytes at the end of the file? Or is the end of central dir signature `PK\u263A\u263B` in the comment?"));
+          }
+          var comment = decodeStrings ? decodeBuffer(eocdrBuffer.subarray(22), false) : eocdrBuffer.subarray(22);
+          if (i - zip64EocdlSize >= 0 && buffer.readUInt32LE(i - zip64EocdlSize) === 117853008) {
+            var zip64EocdlBuffer = buffer.subarray(i - zip64EocdlSize, i - zip64EocdlSize + zip64EocdlSize);
+            var zip64EocdrOffset = readUInt64LE(zip64EocdlBuffer, 8);
+            var zip64EocdrBuffer = newBuffer(56);
+            return readAndAssertNoEof(reader, zip64EocdrBuffer, 0, zip64EocdrBuffer.length, zip64EocdrOffset, function(err2) {
+              if (err2) return callback(err2);
+              if (zip64EocdrBuffer.readUInt32LE(0) !== 101075792) {
+                return callback(new Error("invalid zip64 end of central directory record signature"));
+              }
+              diskNumber = zip64EocdrBuffer.readUInt32LE(16);
+              if (diskNumber !== 0) {
+                return callback(new Error("multi-disk zip files are not supported: found disk number: " + diskNumber));
+              }
+              entryCount = readUInt64LE(zip64EocdrBuffer, 32);
+              centralDirectoryOffset = readUInt64LE(zip64EocdrBuffer, 48);
+              return callback(null, new ZipFile(reader, centralDirectoryOffset, totalSize, entryCount, comment, options2.autoClose, options2.lazyEntries, decodeStrings, options2.validateEntrySizes, options2.strictFileNames));
+            });
+          }
+          if (diskNumber !== 0) {
+            return callback(new Error("multi-disk zip files are not supported: found disk number: " + diskNumber));
+          }
+          return callback(null, new ZipFile(reader, centralDirectoryOffset, totalSize, entryCount, comment, options2.autoClose, options2.lazyEntries, decodeStrings, options2.validateEntrySizes, options2.strictFileNames));
+        }
+        callback(new Error("End of central directory record signature not found. Either not a zip file, or file is truncated."));
+      });
+    }
+    util.inherits(ZipFile, EventEmitter);
+    function ZipFile(reader, centralDirectoryOffset, fileSize, entryCount, comment, autoClose, lazyEntries, decodeStrings, validateEntrySizes, strictFileNames) {
+      var self = this;
+      EventEmitter.call(self);
+      self.reader = reader;
+      self.reader.on("error", function(err) {
+        emitError(self, err);
+      });
+      self.reader.once("close", function() {
+        self.emit("close");
+      });
+      self.readEntryCursor = centralDirectoryOffset;
+      self.fileSize = fileSize;
+      self.entryCount = entryCount;
+      self.comment = comment;
+      self.entriesRead = 0;
+      self.autoClose = !!autoClose;
+      self.lazyEntries = !!lazyEntries;
+      self.decodeStrings = !!decodeStrings;
+      self.validateEntrySizes = !!validateEntrySizes;
+      self.strictFileNames = !!strictFileNames;
+      self.isOpen = true;
+      self.emittedError = false;
+      self.hasEachEntryBeenCalled = false;
+      if (!self.lazyEntries) self._readEntry();
+    }
+    ZipFile.prototype.close = function() {
+      if (!this.isOpen) return;
+      this.isOpen = false;
+      this.reader.unref();
+    };
+    function emitErrorAndAutoClose(self, err) {
+      if (self.autoClose) self.close();
+      emitError(self, err);
+    }
+    function emitError(self, err) {
+      if (self.emittedError) return;
+      self.emittedError = true;
+      self.emit("error", err);
+    }
+    ZipFile.prototype.readEntry = function() {
+      if (!this.lazyEntries) throw new Error("readEntry() called without lazyEntries:true");
+      this._readEntry();
+    };
+    ZipFile.prototype._readEntry = function() {
+      var self = this;
+      if (self.entryCount === self.entriesRead) {
+        setImmediate(function() {
+          if (self.autoClose) self.close();
+          if (self.emittedError) return;
+          self.emit("end");
+        });
+        return;
+      }
+      if (self.emittedError) return;
+      var buffer = newBuffer(46);
+      readAndAssertNoEof(self.reader, buffer, 0, buffer.length, self.readEntryCursor, function(err) {
+        if (err) return emitErrorAndAutoClose(self, err);
+        if (self.emittedError) return;
+        var entry = new Entry();
+        var signature = buffer.readUInt32LE(0);
+        if (signature !== 33639248) return emitErrorAndAutoClose(self, new Error("invalid central directory file header signature: 0x" + signature.toString(16)));
+        entry.versionMadeBy = buffer.readUInt16LE(4);
+        entry.versionNeededToExtract = buffer.readUInt16LE(6);
+        entry.generalPurposeBitFlag = buffer.readUInt16LE(8);
+        entry.compressionMethod = buffer.readUInt16LE(10);
+        entry.lastModFileTime = buffer.readUInt16LE(12);
+        entry.lastModFileDate = buffer.readUInt16LE(14);
+        entry.crc32 = buffer.readUInt32LE(16);
+        entry.compressedSize = buffer.readUInt32LE(20);
+        entry.uncompressedSize = buffer.readUInt32LE(24);
+        entry.fileNameLength = buffer.readUInt16LE(28);
+        entry.extraFieldLength = buffer.readUInt16LE(30);
+        entry.fileCommentLength = buffer.readUInt16LE(32);
+        entry.internalFileAttributes = buffer.readUInt16LE(36);
+        entry.externalFileAttributes = buffer.readUInt32LE(38);
+        entry.relativeOffsetOfLocalHeader = buffer.readUInt32LE(42);
+        if (entry.generalPurposeBitFlag & 64) return emitErrorAndAutoClose(self, new Error("strong encryption is not supported"));
+        self.readEntryCursor += 46;
+        buffer = newBuffer(entry.fileNameLength + entry.extraFieldLength + entry.fileCommentLength);
+        readAndAssertNoEof(self.reader, buffer, 0, buffer.length, self.readEntryCursor, function(err2) {
+          if (err2) return emitErrorAndAutoClose(self, err2);
+          if (self.emittedError) return;
+          entry.fileNameRaw = buffer.subarray(0, entry.fileNameLength);
+          var fileCommentStart = entry.fileNameLength + entry.extraFieldLength;
+          entry.extraFieldRaw = buffer.subarray(entry.fileNameLength, fileCommentStart);
+          entry.fileCommentRaw = buffer.subarray(fileCommentStart, fileCommentStart + entry.fileCommentLength);
+          try {
+            entry.extraFields = parseExtraFields(entry.extraFieldRaw);
+          } catch (err3) {
+            return emitErrorAndAutoClose(self, err3);
+          }
+          if (self.decodeStrings) {
+            var isUtf8 = (entry.generalPurposeBitFlag & 2048) !== 0;
+            entry.fileComment = decodeBuffer(entry.fileCommentRaw, isUtf8);
+            entry.fileName = getFileNameLowLevel(entry.generalPurposeBitFlag, entry.fileNameRaw, entry.extraFields, self.strictFileNames);
+            var errorMessage = validateFileName(entry.fileName);
+            if (errorMessage != null) return emitErrorAndAutoClose(self, new Error(errorMessage));
+          } else {
+            entry.fileComment = entry.fileCommentRaw;
+            entry.fileName = entry.fileNameRaw;
+          }
+          entry.comment = entry.fileComment;
+          self.readEntryCursor += buffer.length;
+          self.entriesRead += 1;
+          for (var i = 0; i < entry.extraFields.length; i++) {
+            var extraField = entry.extraFields[i];
+            if (extraField.id !== 1) continue;
+            var zip64EiefBuffer = extraField.data;
+            var index = 0;
+            if (entry.uncompressedSize === 4294967295) {
+              if (index + 8 > zip64EiefBuffer.length) {
+                return emitErrorAndAutoClose(self, new Error("zip64 extended information extra field does not include uncompressed size"));
+              }
+              entry.uncompressedSize = readUInt64LE(zip64EiefBuffer, index);
+              index += 8;
+            }
+            if (entry.compressedSize === 4294967295) {
+              if (index + 8 > zip64EiefBuffer.length) {
+                return emitErrorAndAutoClose(self, new Error("zip64 extended information extra field does not include compressed size"));
+              }
+              entry.compressedSize = readUInt64LE(zip64EiefBuffer, index);
+              index += 8;
+            }
+            if (entry.relativeOffsetOfLocalHeader === 4294967295) {
+              if (index + 8 > zip64EiefBuffer.length) {
+                return emitErrorAndAutoClose(self, new Error("zip64 extended information extra field does not include relative header offset"));
+              }
+              entry.relativeOffsetOfLocalHeader = readUInt64LE(zip64EiefBuffer, index);
+              index += 8;
+            }
+            break;
+          }
+          if (self.validateEntrySizes && entry.compressionMethod === 0) {
+            var expectedCompressedSize = entry.uncompressedSize;
+            if (entry.isEncrypted()) {
+              expectedCompressedSize += 12;
+            }
+            if (entry.compressedSize !== expectedCompressedSize) {
+              var msg = "compressed/uncompressed size mismatch for stored file: " + entry.compressedSize + " != " + entry.uncompressedSize;
+              return emitErrorAndAutoClose(self, new Error(msg));
+            }
+          }
+          self.emit("entry", entry);
+          if (!self.lazyEntries) self._readEntry();
+        });
+      });
+    };
+    ZipFile.prototype.eachEntry = function() {
+      const self = this;
+      if (!self.lazyEntries) throw new Error("eachEntry() requires lazyEntries: true");
+      if (self.hasEachEntryBeenCalled) throw new Error("eachEntry() must only be called once per ZipFile");
+      self.hasEachEntryBeenCalled = true;
+      let pendingResolveReject = null;
+      self.on("entry", onEntry);
+      self.on("end", onEnd);
+      self.on("error", onError);
+      function cleanup() {
+        self.removeListener("entry", onEntry);
+        self.removeListener("end", onEnd);
+        self.removeListener("error", onError);
+        if (self.autoClose) self.close();
+      }
+      function onEntry(entry) {
+        let { resolve: resolve4 } = pendingResolveReject;
+        pendingResolveReject = null;
+        resolve4({ value: entry });
+      }
+      function onEnd() {
+        let { resolve: resolve4 } = pendingResolveReject;
+        pendingResolveReject = null;
+        cleanup();
+        resolve4({ done: true });
+      }
+      function onError(err) {
+        let { reject } = pendingResolveReject;
+        pendingResolveReject = null;
+        cleanup();
+        reject(err);
+      }
+      return {
+        [Symbol.asyncIterator]() {
+          return this;
+        },
+        next() {
+          const promise = new Promise((resolve4, reject) => {
+            if (pendingResolveReject != null) throw new Error("next() called before previous Promise was resolved.");
+            pendingResolveReject = { resolve: resolve4, reject };
+          });
+          self.readEntry();
+          return promise;
+        },
+        return(value) {
+          cleanup();
+          return Promise.resolve({ done: true, value });
+        },
+        throw(value) {
+          cleanup();
+          return Promise.reject(value);
+        }
+      };
+    };
+    ZipFile.prototype.openReadStream = function(entry, options2, callback) {
+      var self = this;
+      var relativeStart = 0;
+      var relativeEnd = entry.compressedSize;
+      if (callback == null) {
+        callback = options2;
+        options2 = null;
+      }
+      if (options2 == null) {
+        options2 = {};
+      } else {
+        if (options2.decodeFileData === false) {
+          if (options2.decrypt != null) {
+            throw new Error("cannot use options.decrypt when options.decodeFileData === false");
+          }
+          if (options2.decompress != null) {
+            throw new Error("cannot use options.decompress when options.decodeFileData === false");
+          }
+        } else {
+          if (options2.decrypt != null) {
+            if (!entry.isEncrypted()) {
+              throw new Error("options.decrypt can only be specified for encrypted entries. See also option decodeFileData.");
+            }
+            if (options2.decrypt !== false) throw new Error("invalid options.decrypt value: " + options2.decrypt);
+            if (entry.isCompressed()) {
+              if (options2.decompress !== false) throw new Error("entry is encrypted and compressed, and options.decompress !== false. See also option decodeFileData.");
+            }
+          }
+          if (options2.decompress != null) {
+            if (!entry.isCompressed()) {
+              throw new Error("options.decompress can only be specified for compressed entries. See also option decodeFileData.");
+            }
+            if (!(options2.decompress === false || options2.decompress === true)) {
+              throw new Error("invalid options.decompress value: " + options2.decompress);
+            }
+            decompress = options2.decompress;
+          }
+        }
+        if (options2.start != null) {
+          relativeStart = options2.start;
+          if (relativeStart < 0) throw new Error("options.start < 0");
+          if (relativeStart > entry.compressedSize) throw new Error("options.start > entry.compressedSize");
+        }
+        if (options2.end != null) {
+          relativeEnd = options2.end;
+          if (relativeEnd < 0) throw new Error("options.end < 0");
+          if (relativeEnd > entry.compressedSize) throw new Error("options.end > entry.compressedSize");
+          if (relativeEnd < relativeStart) throw new Error("options.end < options.start");
+        }
+      }
+      var rawMode = options2.decodeFileData === false || // Explicitly requested raw.
+      (entry.compressionMethod === 0 || // Naturally without compression.
+      entry.compressionMethod === 8 && options2.decompress === false) && (!entry.isEncrypted() || // Naturally without encryption.
+      options2.decrypt === false);
+      if (options2.start != null || options2.end != null) {
+        if (!rawMode) throw new Error("start/end range require options.decodeFileData === false for non-trivial encoded entries.");
+      }
+      if (!self.isOpen) return callback(new Error("closed"));
+      if (entry.isEncrypted() && !rawMode) {
+        if (options2.decrypt !== false) return callback(new Error("entry is encrypted, and options.decodeFileData !== false"));
+      }
+      var decompress;
+      if (rawMode) {
+        decompress = false;
+      } else if (entry.compressionMethod === 8) {
+        decompress = options2.decodeFileData !== true;
+      } else {
+        return callback(new Error("unsupported compression method: " + entry.compressionMethod));
+      }
+      self.readLocalFileHeader(entry, { minimal: true }, function(err, localFileHeader) {
+        if (err) return callback(err);
+        self.openReadStreamLowLevel(
+          localFileHeader.fileDataStart,
+          entry.compressedSize,
+          relativeStart,
+          relativeEnd,
+          decompress,
+          entry.uncompressedSize,
+          callback
+        );
+      });
+    };
+    ZipFile.prototype.openReadStreamLowLevel = function(fileDataStart, compressedSize, relativeStart, relativeEnd, decompress, uncompressedSize, callback) {
+      var self = this;
+      var fileDataEnd = fileDataStart + compressedSize;
+      var readStream = self.reader.createReadStream({
+        start: fileDataStart + relativeStart,
+        end: fileDataStart + relativeEnd
+      });
+      var endpointStream = readStream;
+      if (decompress) {
+        var destroyed = false;
+        var inflateFilter = zlib.createInflateRaw();
+        readStream.on("error", function(err) {
+          setImmediate(function() {
+            if (!destroyed) inflateFilter.emit("error", err);
+          });
+        });
+        readStream.pipe(inflateFilter);
+        if (self.validateEntrySizes) {
+          endpointStream = new AssertByteCountStream(uncompressedSize);
+          inflateFilter.on("error", function(err) {
+            setImmediate(function() {
+              if (!destroyed) endpointStream.emit("error", err);
+            });
+          });
+          inflateFilter.pipe(endpointStream);
+        } else {
+          endpointStream = inflateFilter;
+        }
+        installDestroyFn(endpointStream, function() {
+          destroyed = true;
+          if (inflateFilter !== endpointStream) inflateFilter.unpipe(endpointStream);
+          readStream.unpipe(inflateFilter);
+          readStream.destroy();
+        });
+      }
+      callback(null, endpointStream);
+    };
+    ZipFile.prototype.readLocalFileHeader = function(entry, options2, callback) {
+      var self = this;
+      if (callback == null) {
+        callback = options2;
+        options2 = null;
+      }
+      if (options2 == null) options2 = {};
+      self.reader.ref();
+      var buffer = newBuffer(30);
+      readAndAssertNoEof(self.reader, buffer, 0, buffer.length, entry.relativeOffsetOfLocalHeader, function(err) {
+        try {
+          if (err) return callback(err);
+          var signature = buffer.readUInt32LE(0);
+          if (signature !== 67324752) {
+            return callback(new Error("invalid local file header signature: 0x" + signature.toString(16)));
+          }
+          var fileNameLength = buffer.readUInt16LE(26);
+          var extraFieldLength = buffer.readUInt16LE(28);
+          var fileDataStart = entry.relativeOffsetOfLocalHeader + 30 + fileNameLength + extraFieldLength;
+          if (fileDataStart + entry.compressedSize > self.fileSize) {
+            return callback(new Error("file data overflows file bounds: " + fileDataStart + " + " + entry.compressedSize + " > " + self.fileSize));
+          }
+          if (options2.minimal) {
+            return callback(null, { fileDataStart });
+          }
+          var localFileHeader = new LocalFileHeader();
+          localFileHeader.fileDataStart = fileDataStart;
+          localFileHeader.versionNeededToExtract = buffer.readUInt16LE(4);
+          localFileHeader.generalPurposeBitFlag = buffer.readUInt16LE(6);
+          localFileHeader.compressionMethod = buffer.readUInt16LE(8);
+          localFileHeader.lastModFileTime = buffer.readUInt16LE(10);
+          localFileHeader.lastModFileDate = buffer.readUInt16LE(12);
+          localFileHeader.crc32 = buffer.readUInt32LE(14);
+          localFileHeader.compressedSize = buffer.readUInt32LE(18);
+          localFileHeader.uncompressedSize = buffer.readUInt32LE(22);
+          localFileHeader.fileNameLength = fileNameLength;
+          localFileHeader.extraFieldLength = extraFieldLength;
+          buffer = newBuffer(fileNameLength + extraFieldLength);
+          self.reader.ref();
+          readAndAssertNoEof(self.reader, buffer, 0, buffer.length, entry.relativeOffsetOfLocalHeader + 30, function(err2) {
+            try {
+              if (err2) return callback(err2);
+              localFileHeader.fileName = buffer.subarray(0, fileNameLength);
+              localFileHeader.extraField = buffer.subarray(fileNameLength);
+              return callback(null, localFileHeader);
+            } finally {
+              self.reader.unref();
+            }
+          });
+        } finally {
+          self.reader.unref();
+        }
+      });
+    };
+    ZipFile.prototype.openReadStreamPromise = function(entry, options2) {
+      return new Promise((resolve4, reject) => {
+        this.openReadStream(entry, options2, function(err, readStream) {
+          if (err) return reject(err);
+          resolve4(readStream);
+        });
+      });
+    };
+    ZipFile.prototype.openReadStreamLowLevelPromise = function(fileDataStart, compressedSize, relativeStart, relativeEnd, decompress, uncompressedSize) {
+      return new Promise((resolve4, reject) => {
+        this.openReadStream(fileDataStart, compressedSize, relativeStart, relativeEnd, decompress, uncompressedSize, function(err, readStream) {
+          if (err) return reject(err);
+          resolve4(readStream);
+        });
+      });
+    };
+    ZipFile.prototype.readLocalFileHeaderPromise = function(entry, options2) {
+      return new Promise((resolve4, reject) => {
+        this.readLocalFileHeader(entry, options2, function(err, localFileHeader) {
+          if (err) return reject(err);
+          resolve4(localFileHeader);
+        });
+      });
+    };
+    function Entry() {
+    }
+    Entry.prototype.getLastModDate = function(options2) {
+      if (options2 == null) options2 = {};
+      if (!options2.forceDosFormat) {
+        for (var i = 0; i < this.extraFields.length; i++) {
+          var extraField = this.extraFields[i];
+          if (extraField.id === 21589) {
+            var data = extraField.data;
+            if (data.length < 5) continue;
+            var flags = data[0];
+            var HAS_MTIME = 1;
+            if (!(flags & HAS_MTIME)) continue;
+            var posixTimestamp = data.readInt32LE(1);
+            return new Date(posixTimestamp * 1e3);
+          } else if (extraField.id === 10) {
+            var data = extraField.data;
+            if (data.length !== 32) continue;
+            if (data.readUInt16LE(4) !== 1) continue;
+            if (data.readUInt16LE(6) !== 24) continue;
+            var hundredNanoSecondsSince1601 = data.readUInt32LE(8) + 4294967296 * data.readInt32LE(12);
+            var millisecondsSince1970 = hundredNanoSecondsSince1601 / 1e4 - 116444736e5;
+            return new Date(millisecondsSince1970);
+          }
+        }
+      }
+      return dosDateTimeToDate(this.lastModFileDate, this.lastModFileTime, options2.timezone);
+    };
+    Entry.prototype.canDecodeFileData = function() {
+      return !this.isEncrypted() && (this.compressionMethod === 0 || this.compressionMethod === 8);
+    };
+    Entry.prototype.isEncrypted = function() {
+      return (this.generalPurposeBitFlag & 1) !== 0;
+    };
+    Entry.prototype.isCompressed = function() {
+      return this.compressionMethod === 8;
+    };
+    function LocalFileHeader() {
+    }
+    function dosDateTimeToDate(date, time, timezone) {
+      var day = date & 31;
+      var month = (date >> 5 & 15) - 1;
+      var year = (date >> 9 & 127) + 1980;
+      var millisecond = 0;
+      var second = (time & 31) * 2;
+      var minute = time >> 5 & 63;
+      var hour = time >> 11 & 31;
+      if (timezone == null || timezone === "local") {
+        return new Date(year, month, day, hour, minute, second, millisecond);
+      } else if (timezone === "UTC") {
+        return new Date(Date.UTC(year, month, day, hour, minute, second, millisecond));
+      } else {
+        throw new Error("unrecognized options.timezone: " + options.timezone);
+      }
+    }
+    function getFileNameLowLevel(generalPurposeBitFlag, fileNameBuffer, extraFields, strictFileNames) {
+      var fileName = null;
+      for (var i = 0; i < extraFields.length; i++) {
+        var extraField = extraFields[i];
+        if (extraField.id === 28789) {
+          if (extraField.data.length < 6) {
+            continue;
+          }
+          if (extraField.data.readUInt8(0) !== 1) {
+            continue;
+          }
+          var oldNameCrc32 = extraField.data.readUInt32LE(1);
+          if (crc32(fileNameBuffer) !== oldNameCrc32) {
+            continue;
+          }
+          fileName = decodeBuffer(extraField.data.subarray(5), true);
+          break;
+        }
+      }
+      if (fileName == null) {
+        var isUtf8 = (generalPurposeBitFlag & 2048) !== 0;
+        fileName = decodeBuffer(fileNameBuffer, isUtf8);
+      }
+      if (!strictFileNames) {
+        fileName = fileName.replace(/\\/g, "/");
+      }
+      return fileName;
+    }
+    function validateFileName(fileName) {
+      if (fileName.indexOf("\\") !== -1) {
+        return "invalid characters in fileName: " + fileName;
+      }
+      if (/^[a-zA-Z]:/.test(fileName) || /^\//.test(fileName)) {
+        return "absolute path: " + fileName;
+      }
+      if (fileName.split("/").indexOf("..") !== -1) {
+        return "invalid relative path: " + fileName;
+      }
+      return null;
+    }
+    function parseExtraFields(extraFieldBuffer) {
+      var extraFields = [];
+      var i = 0;
+      while (i < extraFieldBuffer.length - 3) {
+        var headerId = extraFieldBuffer.readUInt16LE(i + 0);
+        var dataSize = extraFieldBuffer.readUInt16LE(i + 2);
+        var dataStart = i + 4;
+        var dataEnd = dataStart + dataSize;
+        if (dataEnd > extraFieldBuffer.length) throw new Error("extra field length exceeds extra field buffer size");
+        var dataBuffer = extraFieldBuffer.subarray(dataStart, dataEnd);
+        extraFields.push({
+          id: headerId,
+          data: dataBuffer
+        });
+        i = dataEnd;
+      }
+      return extraFields;
+    }
+    function readAndAssertNoEof(reader, buffer, offset, length, position, callback) {
+      if (length === 0) {
+        return setImmediate(function() {
+          callback(null, newBuffer(0));
+        });
+      }
+      reader.read(buffer, offset, length, position, function(err, bytesRead) {
+        if (err) return callback(err);
+        if (bytesRead < length) {
+          return callback(new Error("unexpected EOF"));
+        }
+        callback();
+      });
+    }
+    util.inherits(AssertByteCountStream, Transform2);
+    function AssertByteCountStream(byteCount) {
+      Transform2.call(this);
+      this.actualByteCount = 0;
+      this.expectedByteCount = byteCount;
+    }
+    AssertByteCountStream.prototype._transform = function(chunk, encoding, cb) {
+      this.actualByteCount += chunk.length;
+      if (this.actualByteCount > this.expectedByteCount) {
+        var msg = "too many bytes in the stream. expected " + this.expectedByteCount + ". got at least " + this.actualByteCount;
+        return cb(new Error(msg));
+      }
+      cb(null, chunk);
+    };
+    AssertByteCountStream.prototype._flush = function(cb) {
+      if (this.actualByteCount < this.expectedByteCount) {
+        var msg = "not enough bytes in the stream. expected " + this.expectedByteCount + ". got only " + this.actualByteCount;
+        return cb(new Error(msg));
+      }
+      cb();
+    };
+    util.inherits(RandomAccessReader, EventEmitter);
+    function RandomAccessReader() {
+      EventEmitter.call(this);
+      this.refCount = 0;
+    }
+    RandomAccessReader.prototype.ref = function() {
+      this.refCount += 1;
+    };
+    RandomAccessReader.prototype.unref = function() {
+      var self = this;
+      self.refCount -= 1;
+      if (self.refCount > 0) return;
+      if (self.refCount < 0) throw new Error("invalid unref");
+      self.close(onCloseDone);
+      function onCloseDone(err) {
+        if (err) return self.emit("error", err);
+        self.emit("close");
+      }
+    };
+    RandomAccessReader.prototype.createReadStream = function(options2) {
+      if (options2 == null) options2 = {};
+      var start = options2.start;
+      var end = options2.end;
+      if (start === end) {
+        var emptyStream = new PassThrough();
+        setImmediate(function() {
+          emptyStream.end();
+        });
+        return emptyStream;
+      }
+      var stream = this._readStreamForRange(start, end);
+      var destroyed = false;
+      var refUnrefFilter = new RefUnrefFilter(this);
+      stream.on("error", function(err) {
+        setImmediate(function() {
+          if (!destroyed) refUnrefFilter.emit("error", err);
+        });
+      });
+      installDestroyFn(refUnrefFilter, function() {
+        stream.unpipe(refUnrefFilter);
+        refUnrefFilter.unref();
+        stream.destroy();
+      });
+      var byteCounter = new AssertByteCountStream(end - start);
+      refUnrefFilter.on("error", function(err) {
+        setImmediate(function() {
+          if (!destroyed) byteCounter.emit("error", err);
+        });
+      });
+      installDestroyFn(byteCounter, function() {
+        destroyed = true;
+        refUnrefFilter.unpipe(byteCounter);
+        refUnrefFilter.destroy();
+      });
+      return stream.pipe(refUnrefFilter).pipe(byteCounter);
+    };
+    RandomAccessReader.prototype._readStreamForRange = function(start, end) {
+      throw new Error("not implemented");
+    };
+    RandomAccessReader.prototype.read = function(buffer, offset, length, position, callback) {
+      var readStream = this.createReadStream({ start: position, end: position + length });
+      var writeStream = new Writable();
+      var written = 0;
+      writeStream._write = function(chunk, encoding, cb) {
+        chunk.copy(buffer, offset + written, 0, chunk.length);
+        written += chunk.length;
+        cb();
+      };
+      writeStream.on("finish", callback);
+      readStream.on("error", function(error) {
+        callback(error);
+      });
+      readStream.pipe(writeStream);
+    };
+    RandomAccessReader.prototype.close = function(callback) {
+      setImmediate(callback);
+    };
+    util.inherits(RefUnrefFilter, PassThrough);
+    function RefUnrefFilter(context) {
+      PassThrough.call(this);
+      this.context = context;
+      this.context.ref();
+      this.unreffedYet = false;
+    }
+    RefUnrefFilter.prototype._flush = function(cb) {
+      this.unref();
+      cb();
+    };
+    RefUnrefFilter.prototype.unref = function(cb) {
+      if (this.unreffedYet) return;
+      this.unreffedYet = true;
+      this.context.unref();
+    };
+    var cp437 = "\0\u263A\u263B\u2665\u2666\u2663\u2660\u2022\u25D8\u25CB\u25D9\u2642\u2640\u266A\u266B\u263C\u25BA\u25C4\u2195\u203C\xB6\xA7\u25AC\u21A8\u2191\u2193\u2192\u2190\u221F\u2194\u25B2\u25BC !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\u2302\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\xEC\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\xFF\xD6\xDC\xA2\xA3\xA5\u20A7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\u2310\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0";
+    function decodeBuffer(buffer, isUtf8) {
+      if (isUtf8) {
+        return buffer.toString("utf8");
+      } else {
+        var result = "";
+        for (var i = 0; i < buffer.length; i++) {
+          result += cp437[buffer[i]];
+        }
+        return result;
+      }
+    }
+    function readUInt64LE(buffer, offset) {
+      var lower32 = buffer.readUInt32LE(offset);
+      var upper32 = buffer.readUInt32LE(offset + 4);
+      return upper32 * 4294967296 + lower32;
+    }
+    var newBuffer;
+    if (typeof Buffer.allocUnsafe === "function") {
+      newBuffer = function(len) {
+        return Buffer.allocUnsafe(len);
+      };
+    } else {
+      newBuffer = function(len) {
+        return new Buffer(len);
+      };
+    }
+    function installDestroyFn(stream, fn) {
+      if (typeof stream.destroy === "function") {
+        stream._destroy = function(err, cb) {
+          fn();
+          if (cb != null) cb(err);
+        };
+      } else {
+        stream.destroy = fn;
+      }
+    }
+    function defaultCallback(err) {
+      if (err) throw err;
+    }
+  }
+});
+
+// cli/src/service/installation/npm.entry.ts
+import { dirname as dirname2, resolve as resolve3 } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// cli/src/common/config/release-trust.config.ts
+var RELEASE_TRUST = Object.freeze({
+  /** 唯一信任根标识；未知标识拒绝，不接受远端下发公钥。 */
+  keyId: "kscs-release-20261023",
+  /** Ed25519 SPKI公钥，必须与受控发布签名私钥匹配。 */
+  publicKey: "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEA8I4Ah9NG3c3CZ9nShiflqAhAyh6xU13SALWlqxwYKJI=\n-----END PUBLIC KEY-----\n"
+});
+var NPM_PACKAGE_NAME = "@kscs-inc/cli";
+
+// cli/src/service/installation/npm-bootstrap.service.ts
+import { spawn } from "node:child_process";
+import { createHash as createHash3 } from "node:crypto";
+import { lstat as lstat2, mkdtemp, readFile, realpath as realpath2, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join as join3, resolve as resolve2 } from "node:path";
+import { parseArgs } from "node:util";
+
+// cli/src/common/client/installation-download.client.ts
+import { createHash as createHash2, randomUUID } from "node:crypto";
+import { createReadStream, createWriteStream } from "node:fs";
+import { open } from "node:fs/promises";
+import { Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
+
+// cli/src/common/client/release-signature.client.ts
+import { createHash, createPublicKey, verify } from "node:crypto";
+function verifyReleaseSignature(bytes, envelope, expectedPath, trust = RELEASE_TRUST, nowSeconds = Math.floor(Date.now() / 1e3)) {
+  if (!envelope || typeof envelope !== "object" || Array.isArray(envelope))
+    throw new Error("\u53D1\u884C\u7B7E\u540D\u683C\u5F0F\u65E0\u6548");
+  const value = envelope;
+  if (value.algorithm !== "Ed25519" || value.key_id !== trust.keyId || typeof value.payload !== "string" || typeof value.signature !== "string")
+    throw new Error("\u53D1\u884C\u7B7E\u540D\u7B97\u6CD5\u6216\u4FE1\u4EFB\u6839\u65E0\u6548");
+  const payload = Buffer.from(value.payload, "base64");
+  const signature = Buffer.from(value.signature, "base64");
+  if (payload.length > 8192 || signature.length !== 64 || payload.toString("base64") !== value.payload || signature.toString("base64") !== value.signature)
+    throw new Error("\u53D1\u884C\u7B7E\u540D\u5B57\u8282\u683C\u5F0F\u65E0\u6548");
+  const publicKey = createPublicKey(trust.publicKey);
+  if (publicKey.asymmetricKeyType !== "ed25519" || !verify(null, payload, publicKey, signature))
+    throw new Error("\u53D1\u884C\u7B7E\u540D\u9A8C\u8BC1\u5931\u8D25");
+  const identity = JSON.parse(payload.toString("utf8"));
+  if (!identity || typeof identity !== "object" || Array.isArray(identity))
+    throw new Error("\u7B7E\u540D\u58F0\u660E\u683C\u5F0F\u65E0\u6548");
+  const data = identity;
+  if (data.schema_version !== 1 || data.path !== expectedPath || data.sha256 !== createHash("sha256").update(bytes).digest("hex"))
+    throw new Error("\u7B7E\u540D\u58F0\u660E\u4E0E\u53D1\u884C\u6587\u4EF6\u4E0D\u4E00\u81F4");
+  if (!Number.isSafeInteger(data.issued_at) || !Number.isSafeInteger(data.expires_at) || Number(data.issued_at) > nowSeconds + 300 || Number(data.expires_at) <= nowSeconds || Number(data.expires_at) <= Number(data.issued_at))
+    throw new Error("\u53D1\u884C\u7B7E\u540D\u5DF2\u8FC7\u671F\u6216\u7B7E\u53D1\u65F6\u95F4\u65E0\u6548\uFF0C\u8BF7\u4F7F\u7528\u5B98\u7F51\u6700\u65B0\u5B89\u88C5\u5165\u53E3");
+  return {
+    schema_version: 1,
+    path: expectedPath,
+    sha256: String(data.sha256),
+    issued_at: Number(data.issued_at),
+    expires_at: Number(data.expires_at)
+  };
+}
+
+// cli/src/common/client/installation-download.client.ts
+function checkedDownloadUrl(value, allowLocal = false) {
+  const url = new URL(value);
+  const local = allowLocal && url.protocol === "http:" && ["127.0.0.1", "localhost", "[::1]"].includes(url.hostname);
+  if (url.protocol !== "https:" && !local || url.username || url.password || url.hash)
+    throw new Error("\u4E0B\u8F7D\u5FC5\u987B\u4F7F\u7528HTTPS\uFF1B\u672C\u5730\u9A8C\u6536\u4EC5\u5141\u8BB8\u56DE\u73AFHTTP");
+  return url;
+}
+function sameOriginUrl(value, base, allowLocal = false) {
+  const url = checkedDownloadUrl(new URL(value, base).href, allowLocal);
+  if (url.origin !== checkedDownloadUrl(base, allowLocal).origin) throw new Error("\u62D2\u7EDD\u8DE8\u57DF\u53D1\u884C\u6E90");
+  return url.href;
+}
+async function downloadResponse(url, allowLocal, timeoutMs) {
+  let target = checkedDownloadUrl(url, allowLocal).href;
+  const signal = AbortSignal.timeout(timeoutMs);
+  for (let redirects = 0; redirects <= 5; redirects += 1) {
+    let response;
+    try {
+      response = await fetch(target, {
+        redirect: "manual",
+        signal,
+        headers: { "User-Agent": "kscs-node-installer/1" }
+      });
+    } catch (error) {
+      const cause = error instanceof Error ? error.cause : void 0;
+      const code = cause && typeof cause === "object" && "code" in cause ? cause.code : void 0;
+      const reason = typeof code === "string" && /^[A-Z][A-Z0-9_]{1,63}$/.test(code) ? code : signal.aborted ? "DOWNLOAD_TIMEOUT" : "NETWORK_ERROR";
+      throw new Error(
+        `\u4E0B\u8F7D\u8FDE\u63A5\u5931\u8D25\uFF08${reason}\uFF09\uFF1A${new URL(target).origin}\uFF1B\u8BF7\u68C0\u67E5\u7F51\u7EDC\u3001\u4EE3\u7406\u4E0E\u8BC1\u4E66\u540E\u91CD\u8BD5\u3002\u539F\u5BA2\u6237\u7AEF\u4E0E\u914D\u7F6E\u4E0D\u4F1A\u56E0\u4E0B\u8F7D\u5931\u8D25\u88AB\u66FF\u6362\u3002`,
+        { cause: error }
+      );
+    }
+    if ([301, 302, 303, 307, 308].includes(response.status)) {
+      await response.body?.cancel();
+      const location = response.headers.get("location");
+      if (!location) throw new Error("\u4E0B\u8F7D\u91CD\u5B9A\u5411\u7F3A\u5C11\u5730\u5740");
+      target = sameOriginUrl(location, target, allowLocal);
+      continue;
+    }
+    if (!response.ok || !response.body) {
+      await response.body?.cancel();
+      throw new Error(`\u4E0B\u8F7DHTTP\u72B6\u6001\u5F02\u5E38\uFF1A${response.status}`);
+    }
+    return response;
+  }
+  throw new Error("\u4E0B\u8F7D\u91CD\u5B9A\u5411\u6B21\u6570\u8D85\u9650");
+}
+async function downloadBytes(url, limit, allowLocal = false, timeoutMs = 6e4) {
+  const response = await downloadResponse(url, allowLocal, timeoutMs);
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of response.body) {
+    size += chunk.length;
+    if (size > limit) throw new Error("\u4E0B\u8F7D\u8D85\u8FC7\u5141\u8BB8\u5927\u5C0F");
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks);
+}
+async function downloadFile(url, path, limit, allowLocal = false, onProgress) {
+  let size = 0;
+  onProgress?.(size, "downloading");
+  try {
+    const response = await downloadResponse(url, allowLocal, 6e4);
+    const budget = new Transform({
+      transform(chunk, _encoding, callback) {
+        size += chunk.length;
+        if (size <= limit) onProgress?.(size, "downloading");
+        callback(size > limit ? new Error("\u4E0B\u8F7D\u8D85\u8FC7\u5141\u8BB8\u5927\u5C0F") : null, chunk);
+      }
+    });
+    await pipeline(response.body, budget, createWriteStream(path, { flags: "wx", mode: 384 }));
+    const file = await open(path, "r+");
+    try {
+      await file.sync();
+    } finally {
+      await file.close();
+    }
+    onProgress?.(size, "downloaded");
+    return size;
+  } catch (error) {
+    onProgress?.(size, "failed");
+    throw error;
+  }
+}
+async function fileDigest(path) {
+  const hash = createHash2("sha256");
+  for await (const chunk of createReadStream(path)) hash.update(chunk);
+  return hash.digest("hex");
+}
+async function downloadVerifiedRelease(url, limit, allowLocal = false, timeoutMs = 6e4) {
+  const target = checkedDownloadUrl(url, allowLocal);
+  const bytes = await downloadBytes(url, limit, allowLocal, timeoutMs);
+  if (!(allowLocal && target.protocol === "http:")) {
+    const envelope = await downloadBytes(url + ".signature.json", 16384, false, timeoutMs);
+    verifyReleaseSignature(bytes, JSON.parse(envelope.toString("utf8")), target.pathname);
+  }
+  return bytes;
+}
+
+// cli/src/common/client/installation-archive.client.ts
+var import_yauzl = __toESM(require_yauzl(), 1);
+import { createWriteStream as createWriteStream2 } from "node:fs";
+import { chmod, lstat, mkdir, open as open2, readdir, realpath } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { pipeline as pipeline2 } from "node:stream/promises";
+var MAX_ARCHIVE_FILES = 3e4;
+var MAX_EXPANDED_BYTES = 1024 * 1024 * 1024;
+function validateArchivePath(name) {
+  const parts = name.replace(/\/$/, "").split("/");
+  if (!name || /[\\:\x00-\x1f]/.test(name) || parts.some(
+    (part) => !part || part === "." || part === ".." || /[. ]$/.test(part) || /^(CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])(?:\..*)?$/i.test(part)
+  ))
+    throw new Error("\u5B89\u88C5\u5305\u5305\u542B\u8D8A\u754C\u6216\u4FDD\u7559\u8DEF\u5F84");
+  return parts;
+}
+async function unpackArchive(archive, destination) {
+  const zip = await new Promise(
+    (accept, reject) => import_yauzl.default.open(
+      archive,
+      { lazyEntries: true, autoClose: false, strictFileNames: true },
+      (error, value) => error || !value ? reject(error ?? new Error("\u65E0\u6CD5\u8BFB\u53D6ZIP")) : accept(value)
+    )
+  );
+  const entries = [];
+  const names = /* @__PURE__ */ new Set();
+  let size = 0;
+  try {
+    await new Promise((accept, reject) => {
+      zip.on("error", reject);
+      zip.on("end", accept);
+      zip.on("entry", (entry) => {
+        try {
+          const parts = validateArchivePath(entry.fileName);
+          const kind = entry.externalFileAttributes >>> 16 & 61440;
+          const canonical = parts.join("/").toLowerCase();
+          size += entry.uncompressedSize;
+          if (parts[0] !== "kscs-cli" || names.has(canonical) || ![0, 32768, 16384].includes(kind) || entry.generalPurposeBitFlag & 1 || entries.length >= MAX_ARCHIVE_FILES || size > MAX_EXPANDED_BYTES)
+            throw new Error("\u5B89\u88C5\u5305\u542B\u94FE\u63A5\u3001\u91CD\u590D\u3001\u52A0\u5BC6\u6587\u4EF6\u6216\u5C55\u5F00\u89C4\u6A21\u8D85\u9650");
+          names.add(canonical);
+          entries.push(entry);
+          zip.readEntry();
+        } catch (error) {
+          reject(error);
+        }
+      });
+      zip.readEntry();
+    });
+    await mkdir(destination, { recursive: true, mode: 448 });
+    if (await realpath(destination) !== resolve(destination))
+      throw new Error("\u89E3\u5305\u76EE\u6807\u4E0D\u80FD\u5305\u542B\u94FE\u63A5");
+    for (const entry of entries) {
+      const target = join(destination, ...validateArchivePath(entry.fileName));
+      if (entry.fileName.endsWith("/")) {
+        await mkdir(target, { recursive: true, mode: 448 });
+        continue;
+      }
+      await mkdir(dirname(target), { recursive: true, mode: 448 });
+      if (await realpath(dirname(target)) !== resolve(dirname(target)))
+        throw new Error("\u89E3\u5305\u7236\u76EE\u5F55\u4E0D\u80FD\u5305\u542B\u94FE\u63A5");
+      const stream = await new Promise(
+        (accept, reject) => zip.openReadStream(
+          entry,
+          (error, value) => error || !value ? reject(error ?? new Error("\u65E0\u6CD5\u8BFB\u53D6ZIP\u6761\u76EE")) : accept(value)
+        )
+      );
+      await pipeline2(stream, createWriteStream2(target, { flags: "wx", mode: 384 }));
+      const file = await open2(target, "r+");
+      try {
+        await file.sync();
+      } finally {
+        await file.close();
+      }
+      await chmod(target, entry.externalFileAttributes >>> 16 & 73 ? 448 : 384);
+    }
+  } finally {
+    zip.close();
+  }
+}
+async function verifyReleaseFiles(application, expected) {
+  if (await realpath(application) !== resolve(application))
+    throw new Error("\u5B89\u88C5\u76EE\u5F55\u4E0D\u80FD\u5305\u542B\u94FE\u63A5");
+  const paths = /* @__PURE__ */ new Set();
+  const aliases = /* @__PURE__ */ new Set();
+  for (const entry of expected) {
+    const name = validateArchivePath(entry.path).join("/");
+    if (paths.has(name) || aliases.has(name.toLowerCase())) throw new Error("\u6587\u4EF6\u6E05\u5355\u5305\u542B\u91CD\u590D\u8DEF\u5F84");
+    paths.add(name);
+    aliases.add(name.toLowerCase());
+    const target = join(application, name);
+    if (!(await lstat(target)).isFile() || await realpath(target) !== resolve(target) || await fileDigest(target) !== entry.sha256)
+      throw new Error("\u5B89\u88C5\u6587\u4EF6\u6821\u9A8C\u5931\u8D25\uFF1A" + name);
+  }
+  const actual = /* @__PURE__ */ new Set();
+  async function walk(directory, prefix) {
+    for (const entry of await readdir(directory, { withFileTypes: true })) {
+      const name = prefix + entry.name;
+      if (entry.isDirectory()) await walk(join(directory, entry.name), name + "/");
+      else if (entry.isFile()) actual.add(name);
+      else throw new Error("\u5B89\u88C5\u76EE\u5F55\u4E0D\u5141\u8BB8\u94FE\u63A5\u6216\u7279\u6B8A\u6587\u4EF6");
+    }
+  }
+  await walk(application, "");
+  if (actual.size !== paths.size || [...actual].some((name) => !paths.has(name)))
+    throw new Error("\u5B89\u88C5\u76EE\u5F55\u6587\u4EF6\u4E0E\u6E05\u5355\u4E0D\u4E00\u81F4");
+}
+
+// cli/src/common/config/installation-paths.config.ts
+import { homedir } from "node:os";
+import { join as join2 } from "node:path";
+function launcherPath(root) {
+  return join2(root, process.platform === "win32" ? "bin/kscs.cmd" : "bin/kscs");
+}
+function defaultInstallRoot(mode, userDirectory = homedir()) {
+  return process.platform === "win32" ? join2(process.env.LOCALAPPDATA ?? join2(userDirectory, "AppData/Local"), "kscs-cli", mode) : join2(userDirectory, ".local/share/kscs-cli", mode);
+}
+
+// cli/src/service/installation/installation-target.constants.ts
+var INSTALL_MODES = ["personal", "team"];
+var INSTALL_PLATFORMS = ["darwin", "linux", "win32"];
+var INSTALL_ARCHITECTURES = ["x64", "arm64"];
+
+// cli/src/service/installation/installation.model.ts
+var BUILD_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,100}$/;
+var SHA256_PATTERN = /^[a-f0-9]{64}$/;
+var MAX_DOWNLOAD_BYTES = 512 * 1024 * 1024;
+function jsonObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("\u9884\u671FJSON\u5BF9\u8C61");
+  return value;
+}
+function validateTarget(value) {
+  const target = jsonObject(value);
+  if (!INSTALL_MODES.includes(target.mode) || !INSTALL_PLATFORMS.includes(target.platform) || !INSTALL_ARCHITECTURES.includes(target.arch) || target.mode === "team" && target.platform !== "linux")
+    throw new Error("\u65E0\u6548\u53D1\u884C\u6A21\u5F0F\u6216\u5E73\u53F0");
+  if (target.available !== true || typeof target.auto_update !== "boolean")
+    throw new Error("\u53D1\u884C\u5236\u54C1\u672A\u653E\u884C");
+  if (typeof target.build_id !== "string" || !BUILD_PATTERN.test(target.build_id))
+    throw new Error("\u975E\u6CD5\u6784\u5EFA\u7F16\u53F7");
+  if (!Number.isSafeInteger(target.release_sequence) || Number(target.release_sequence) <= 0)
+    throw new Error("\u53D1\u884C\u5E8F\u53F7\u65E0\u6548");
+  for (const [key, maximum] of [
+    ["version", 64],
+    ["summary", 160]
+  ]) {
+    const text = target[key];
+    if (typeof text !== "string" || !text.trim() || text.length > maximum || /[\x00-\x1f]/.test(text))
+      throw new Error("\u53D1\u884C\u7248\u672C\u6216\u7B80\u4ECB\u65E0\u6548");
+  }
+  return {
+    mode: target.mode,
+    platform: target.platform,
+    arch: target.arch,
+    available: true,
+    auto_update: target.auto_update,
+    build_id: target.build_id,
+    release_sequence: Number(target.release_sequence),
+    version: String(target.version),
+    summary: String(target.summary)
+  };
+}
+function validateArtifact(value) {
+  const target = validateTarget(value);
+  const artifact = jsonObject(value);
+  if (typeof artifact.url !== "string" || typeof artifact.sha256 !== "string" || !SHA256_PATTERN.test(artifact.sha256) || !Number.isSafeInteger(artifact.size) || Number(artifact.size) <= 0 || Number(artifact.size) > MAX_DOWNLOAD_BYTES || !Array.isArray(artifact.files) || !artifact.files.length || artifact.files.length > MAX_ARCHIVE_FILES)
+    throw new Error("\u53D1\u884C\u6E05\u5355\u7F3A\u5C11\u5B8C\u6574\u6027\u6821\u9A8C");
+  for (const entry of artifact.files) {
+    const file = jsonObject(entry);
+    if (typeof file.path !== "string" || typeof file.sha256 !== "string" || !SHA256_PATTERN.test(file.sha256))
+      throw new Error("\u6587\u4EF6\u6458\u8981\u65E0\u6548");
+  }
+  return {
+    ...target,
+    url: artifact.url,
+    size: Number(artifact.size),
+    sha256: artifact.sha256,
+    files: artifact.files.map((entry) => {
+      const file = jsonObject(entry);
+      return { path: String(file.path), sha256: String(file.sha256) };
+    })
+  };
+}
+
+// cli/src/service/installation/installation-progress.formatter.ts
+function createDownloadProgress(totalBytes, output = process.stderr) {
+  const startedAt = performance.now();
+  let lastPaint = -Infinity;
+  let previousLength = 0;
+  const interactive = output.isTTY === true && process.env.TERM !== "dumb";
+  return (receivedBytes, status) => {
+    const now = performance.now();
+    const finished = status !== "downloading";
+    if (!finished && now - lastPaint < (interactive ? 150 : 2e3)) return;
+    lastPaint = now;
+    const knownSize = Number.isFinite(totalBytes) && totalBytes > 0;
+    const percent = knownSize ? Math.min(
+      status === "downloaded" && receivedBytes === totalBytes ? 100 : 99,
+      Math.floor(receivedBytes / totalBytes * 100)
+    ) : null;
+    const megabytes = (bytes) => (bytes / 1024 / 1024).toFixed(1);
+    const amount = `${megabytes(receivedBytes)}${knownSize ? `/${megabytes(totalBytes)}` : ""} MB`;
+    const speed = `${megabytes(receivedBytes / Math.max((now - startedAt) / 1e3, 1e-3))} MB/s`;
+    const label = status === "failed" ? "\u4E0B\u8F7D\u4E2D\u65AD" : status === "downloaded" ? "\u4E0B\u8F7D\u5B8C\u6210" : "\u4E0B\u8F7D";
+    const width = output.columns ?? 80;
+    const barWidth = Math.max(0, Math.min(20, width - 58));
+    const filled = percent === null ? 0 : Math.floor(percent / 100 * barWidth);
+    const bar = barWidth && percent !== null ? `[${"=".repeat(filled)}${"-".repeat(barWidth - filled)}] ` : "";
+    const line = width < 36 ? `${label} ${percent === null ? `${megabytes(receivedBytes)} MB` : `${percent}%`}` : `${label} ${bar}${percent === null ? "" : `${percent}% `}${amount}${width >= 58 ? ` \xB7 ${speed}` : ""}`;
+    output.write(
+      interactive ? `\r${line}${" ".repeat(Math.max(0, previousLength - line.length))}${finished ? "\n" : ""}` : `${line}
+`
+    );
+    previousLength = line.length;
+  };
+}
+
+// cli/src/service/installation/npm-bootstrap.service.ts
+async function readNpmRelease(directory) {
+  const bytes = await readFile(join3(directory, "release.json"));
+  if (bytes.length > 65536) throw new Error("npm\u53D1\u884C\u63CF\u8FF0\u8D85\u9650");
+  const raw = JSON.parse(bytes.toString("utf8"));
+  if (!raw || typeof raw !== "object") throw new Error("npm\u53D1\u884C\u63CF\u8FF0\u65E0\u6548");
+  const value = raw;
+  if (value.schema_version !== 1 || value.name !== NPM_PACKAGE_NAME || typeof value.version !== "string" || !/^\d+\.\d+\.\d+(?:-[a-z0-9.-]+)?$/.test(value.version) || !Array.isArray(value.targets))
+    throw new Error("npm\u53D1\u884C\u63CF\u8FF0\u65E0\u6548");
+  verifyReleaseSignature(
+    bytes,
+    JSON.parse(await readFile(join3(directory, "release.signature.json"), "utf8")),
+    `/downloads/cli/node/npm/${value.version}/release.json`
+  );
+  const keys = /* @__PURE__ */ new Set();
+  const targets = value.targets.map((target) => {
+    if (!target || typeof target !== "object") throw new Error("npm\u53D1\u884C\u76EE\u6807\u65E0\u6548");
+    const item = target;
+    if (!INSTALL_MODES.includes(item.mode) || !INSTALL_PLATFORMS.includes(item.platform) || !INSTALL_ARCHITECTURES.includes(item.arch) || !["stable", "trial"].includes(String(item.channel)) || typeof item.manifest !== "string" || typeof item.manifest_sha256 !== "string" || !/^[a-f0-9]{64}$/.test(item.manifest_sha256) || typeof item.build_id !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,100}$/.test(item.build_id))
+      throw new Error("npm\u53D1\u884C\u76EE\u6807\u5B57\u6BB5\u65E0\u6548");
+    const url = new URL(item.manifest);
+    if (url.origin !== "https://cli.xaweiju.com" || url.username || url.password || url.hash || url.search || !url.pathname.startsWith("/downloads/cli/node/") || !url.pathname.endsWith("/manifest.json"))
+      throw new Error("npm\u53D1\u884C\u76EE\u6807\u6765\u6E90\u65E0\u6548");
+    const key = `${item.mode}/${item.platform}/${item.arch}/${item.channel}`;
+    if (keys.has(key)) throw new Error("npm\u53D1\u884C\u76EE\u6807\u91CD\u590D");
+    keys.add(key);
+    return {
+      mode: item.mode,
+      platform: item.platform,
+      arch: item.arch,
+      channel: item.channel,
+      manifest: item.manifest,
+      manifest_sha256: item.manifest_sha256,
+      build_id: item.build_id
+    };
+  });
+  return { schema_version: 1, name: value.name, version: value.version, targets };
+}
+async function runNpmChild(command, argumentsList) {
+  return new Promise((accept, reject) => {
+    const child = spawn(command, argumentsList, { stdio: "inherit", shell: false });
+    const forwardInterrupt = () => {
+      child.kill("SIGINT");
+    };
+    const forwardTerminate = () => {
+      child.kill("SIGTERM");
+    };
+    process.on("SIGINT", forwardInterrupt);
+    process.on("SIGTERM", forwardTerminate);
+    const cleanup = () => {
+      process.off("SIGINT", forwardInterrupt);
+      process.off("SIGTERM", forwardTerminate);
+    };
+    child.once("error", (error) => {
+      cleanup();
+      reject(error);
+    });
+    child.once("exit", (code, signal) => {
+      cleanup();
+      accept(code ?? (signal === "SIGINT" ? 130 : 143));
+    });
+  });
+}
+async function readPrivateInstallationFile(root, filename = "installation.json") {
+  try {
+    const file = join3(root, filename);
+    const info = await lstat2(file);
+    if (!info.isFile() || info.size > 65536 || await realpath2(file) !== file || process.platform !== "win32" && (info.uid !== process.getuid?.() || info.mode & 63))
+      throw new Error("\u5B89\u88C5\u5143\u6570\u636E\u4E0D\u662F\u53D7\u4FDD\u62A4\u666E\u901A\u6587\u4EF6");
+    const value = JSON.parse(await readFile(file, "utf8"));
+    if (!value || typeof value !== "object" || Array.isArray(value))
+      throw new Error("\u5B89\u88C5\u5143\u6570\u636E\u683C\u5F0F\u65E0\u6548");
+    return value;
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+async function nativeArchitecture() {
+  if (process.platform === "darwin") {
+    const { execFile } = await import("node:child_process");
+    const { promisify } = await import("node:util");
+    try {
+      if ((await promisify(execFile)("/usr/sbin/sysctl", ["-n", "hw.optional.arm64"])).stdout.trim() === "1")
+        return "arm64";
+    } catch {
+    }
+  }
+  if (process.platform === "win32") {
+    const architecture = (process.env.PROCESSOR_ARCHITEW6432 ?? process.env.PROCESSOR_ARCHITECTURE ?? process.arch).toLowerCase();
+    return architecture === "amd64" ? "x64" : architecture;
+  }
+  return process.arch;
+}
+async function installFromNpm(release, argv, onFormat) {
+  const { values } = parseArgs({
+    args: argv,
+    options: {
+      mode: { type: "string", default: "personal" },
+      channel: { type: "string", default: "stable" },
+      root: { type: "string" },
+      config: { type: "string" },
+      "skill-dir": { type: "string", multiple: true },
+      "update-policy": { type: "string" },
+      "no-path": { type: "boolean" },
+      "verify-connection": { type: "boolean" },
+      json: { type: "boolean" },
+      human: { type: "boolean" }
+    }
+  });
+  onFormat?.(values.json === true);
+  if (values.json && values.human) throw new Error("--json\u4E0E--human\u4E0D\u80FD\u540C\u65F6\u4F7F\u7528");
+  if (!INSTALL_MODES.includes(values.mode) || !["stable", "trial"].includes(values.channel))
+    throw new Error("\u5B89\u88C5\u6A21\u5F0F\u6216\u901A\u9053\u65E0\u6548");
+  const arch = await nativeArchitecture();
+  const matches = release.targets.filter(
+    (target2) => target2.mode === values.mode && target2.platform === process.platform && target2.arch === arch && target2.channel === values.channel
+  );
+  if (matches.length !== 1)
+    throw new Error(
+      "\u5F53\u524D\u5E73\u53F0\u6CA1\u6709\u6B63\u5F0F\u76EE\u6807\uFF1B\u5982\u786E\u8BA4\u63A5\u53D7\u672A\u5B8C\u6210\u539F\u751F\u9A8C\u6536\u7684\u8BD5\u7528\u5305\uFF0C\u8BF7\u663E\u5F0F\u4F7F\u7528 --channel trial\u3002\u7F51\u7EDC\u9519\u8BEF\u4E0D\u4F1A\u81EA\u52A8\u5207\u6362\u901A\u9053\u3002"
+    );
+  const target = matches[0];
+  if (target.channel === "trial")
+    process.stderr.write("\u6CE8\u610F\uFF1A\u5F53\u524D\u76EE\u6807\u4E3A\u8BD5\u7528\u901A\u9053\uFF0C\u539F\u751F\u9A8C\u6536\u672A\u5B8C\u6210\uFF0C\u4E0D\u542F\u7528\u81EA\u52A8\u5347\u7EA7\u3002\n");
+  const root = resolve2(values.root ?? defaultInstallRoot(target.mode));
+  const previous = await readPrivateInstallationFile(root);
+  process.stderr.write(
+    `\u6B63\u5728\u9A8C\u8BC1 ${release.name}@${release.version} \u5BF9\u5E94\u7684 ${target.mode}/${target.platform}/${target.arch} \u5BA2\u6237\u7AEF\u3002
+`
+  );
+  const manifest = await downloadVerifiedRelease(target.manifest, 8 * 1024 * 1024);
+  if (createHash3("sha256").update(manifest).digest("hex") !== target.manifest_sha256)
+    throw new Error("npm\u76EE\u6807\u4E0E\u56FA\u5B9A\u6E05\u5355\u6458\u8981\u4E0D\u4E00\u81F4");
+  const data = JSON.parse(manifest.toString("utf8"));
+  if (data.schema_version !== 1 || !Array.isArray(data.artifacts) || data.artifacts.length !== 1)
+    throw new Error("\u56FA\u5B9A\u6E05\u5355\u5FC5\u987B\u53EA\u6709\u4E00\u4E2A\u76EE\u6807");
+  const artifact = validateArtifact(data.artifacts[0]);
+  if (artifact.build_id !== target.build_id || artifact.mode !== target.mode || artifact.platform !== target.platform || artifact.arch !== target.arch)
+    throw new Error("npm\u76EE\u6807\u4E0E\u5236\u54C1\u8EAB\u4EFD\u4E0D\u4E00\u81F4");
+  if (previous && Number(previous.release_sequence) > artifact.release_sequence)
+    throw new Error("\u5DF2\u5B89\u88C5\u7248\u672C\u8F83\u65B0\uFF0C\u4FDD\u7559\u5F53\u524D\u7248\u672C\uFF1B\u666E\u901A\u5B89\u88C5\u7981\u6B62\u964D\u7EA7");
+  const stage = await realpath2(await mkdtemp(join3(tmpdir(), "kscs-npm-")));
+  try {
+    const archive = join3(stage, "application.zip");
+    process.stderr.write(`\u6B63\u5728\u4E0B\u8F7D\u5BA2\u6237\u7AEF ${artifact.version}\uFF08${artifact.build_id}\uFF09\u3002
+`);
+    const size = await downloadFile(
+      sameOriginUrl(artifact.url, target.manifest),
+      archive,
+      512 * 1024 * 1024,
+      false,
+      values.json ? void 0 : createDownloadProgress(artifact.size)
+    );
+    if (size !== artifact.size || await fileDigest(archive) !== artifact.sha256)
+      throw new Error("\u5BA2\u6237\u7AEF\u5927\u5C0F\u6216\u6458\u8981\u4E0D\u4E00\u81F4");
+    await unpackArchive(archive, join3(stage, "unpacked"));
+    const application = join3(stage, "unpacked/kscs-cli");
+    await verifyReleaseFiles(application, artifact.files);
+    const installerArguments = [
+      "--mode",
+      target.mode,
+      "--root",
+      root,
+      "--manifest",
+      target.manifest,
+      "--manifest-sha256",
+      target.manifest_sha256,
+      "--expected-build",
+      target.build_id,
+      "--archive-path",
+      archive
+    ];
+    if (values.json) installerArguments.push("--json");
+    for (const option of ["config", "update-policy"])
+      if (values[option]) installerArguments.push("--" + option, values[option]);
+    for (const directory of values["skill-dir"] ?? [])
+      installerArguments.push("--skill-dir", directory);
+    if (values["no-path"]) installerArguments.push("--no-path");
+    if (values["verify-connection"]) installerArguments.push("--verify-connection");
+    if (target.channel === "trial") {
+      if (values["update-policy"] === "auto") throw new Error("\u8BD5\u7528\u76EE\u6807\u7981\u6B62\u81EA\u52A8\u5347\u7EA7");
+      installerArguments.push("--update-policy", "off");
+    }
+    const status = await runNpmChild(
+      join3(application, process.platform === "win32" ? "runtime/node.exe" : "runtime/node"),
+      [join3(application, "dist/service/installation/install.entry.js"), ...installerArguments]
+    );
+    if (status !== 0) return status;
+    const receipt = await readPrivateInstallationFile(root);
+    if (receipt?.build_id !== artifact.build_id || receipt.root !== root || receipt.command !== launcherPath(root))
+      throw new Error("\u5B89\u88C5\u56DE\u6267\u4E0E\u76EE\u6807\u4E0D\u4E00\u81F4");
+    return 0;
+  } finally {
+    await rm(stage, { recursive: true, force: true });
+  }
+}
+async function forwardNpmCommand(argv) {
+  const root = defaultInstallRoot("personal");
+  const receipt = await readPrivateInstallationFile(root);
+  if (!receipt || receipt.installer_runtime !== "node" || receipt.root !== root || receipt.command !== launcherPath(root) || typeof receipt.build_id !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,100}$/.test(receipt.build_id))
+    throw new Error(
+      "\u672A\u627E\u5230\u6709\u6548\u4E2A\u4EBA\u5B89\u88C5\uFF0C\u8BF7\u5148\u8FD0\u884C npx <\u5305\u540D>@latest install\uFF1B\u81EA\u5B9A\u4E49\u6216\u56E2\u961F\u5B89\u88C5\u8BF7\u4F7F\u7528\u56DE\u6267\u4E2D\u7684\u7EDD\u5BF9\u5165\u53E3"
+    );
+  const expectedApplication = join3(root, "releases", receipt.build_id);
+  if (process.platform === "win32") {
+    const pointer = await readPrivateInstallationFile(root, "current.json");
+    if (pointer?.release !== `releases/${receipt.build_id}`)
+      throw new Error("\u7248\u672C\u6307\u9488\u4E0E\u56DE\u6267\u4E0D\u4E00\u81F4");
+  }
+  const application = await realpath2(
+    process.platform === "win32" ? expectedApplication : join3(root, "current")
+  );
+  if (application !== expectedApplication)
+    throw new Error("\u7248\u672C\u6307\u9488\u4E0E\u56DE\u6267\u4E0D\u4E00\u81F4");
+  return runNpmChild(
+    join3(application, process.platform === "win32" ? "runtime/node.exe" : "runtime/node"),
+    [join3(application, "dist/service/installation/update.entry.js"), "--root", root, "--", ...argv]
+  );
+}
+
+// cli/src/service/installation/npm.entry.ts
+var jsonOutput = false;
+async function main() {
+  const argv = process.argv.slice(2);
+  if (argv[0] === "--entry-version") {
+    const release2 = await readNpmRelease(resolve3(dirname2(fileURLToPath(import.meta.url)), ".."));
+    process.stdout.write(`${release2.name}@${release2.version}
+`);
+    return;
+  }
+  if (!argv.length || argv[0] === "--help" || argv[0] === "-h" || argv[0] === "install" && argv.includes("--help")) {
+    process.stdout.write(
+      `\u65F7\u4E16\u4F20\u58F0 CLI \u5B89\u88C5\u5165\u53E3
+
+\u7528\u6CD5\uFF1Anpx ${NPM_PACKAGE_NAME}@latest install [--mode personal|team] [--channel stable|trial]
+\u53EF\u9009\uFF1A--root \u79C1\u6709\u76EE\u5F55 --config \u5DF2\u6709\u914D\u7F6E --skill-dir \u6280\u80FD\u76EE\u5F55 --update-policy off|notify|auto --no-path
+
+\u5B89\u88C5\u540E\uFF1Akscs --version\uFF1Bkscs auth login\uFF1Bkscs products list
+\u65E0\u9700Python\u3001Java\u6216\u7F16\u8BD1\u5668\u3002\u6CA1\u6709Node\u8BF7\u8BBF\u95EE https://cli.xaweiju.com/install/
+\u5378\u8F7Dnpm\u5165\u53E3\u4E0D\u4F1A\u5220\u9664\u5B9E\u9645\u5BA2\u6237\u7AEF\u3001\u8EAB\u4EFD\u914D\u7F6E\u6216Skill\u3002
+`
+    );
+    return;
+  }
+  if (argv[0] !== "install") {
+    process.exitCode = await forwardNpmCommand(argv);
+    return;
+  }
+  jsonOutput = argv.includes("--json") && !argv.includes("--human");
+  const release = await readNpmRelease(resolve3(dirname2(fileURLToPath(import.meta.url)), ".."));
+  process.exitCode = await installFromNpm(release, argv.slice(1), (json) => {
+    jsonOutput = json;
+  });
+}
+void main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  process.stderr.write(
+    jsonOutput ? JSON.stringify({ installed: false, status: "installation_failed", message }) + "\n" : `\u5B89\u88C5\u5165\u53E3\u5931\u8D25\uFF1A${message}
+`
+  );
+  process.exitCode = 1;
+});