CPL
/
banboshi_V2
1
0
Форкнуть 0
Код Задачи 0 Pull Request'ы 0 Релизы 1 Вики Активность
版博士V2.0程序
Вы не можете выбрать более 25 тем Темы должны начинаться с буквы или цифры, могут содержать дефисы(-) и должны содержать не более 35 символов.
63 коммитов
5 Ветки
6.2 GiB
 
 
 
 
ветка: TongWei-PS
Ветки Теги
${ item.name }
Создать ветку ${ searchTerm }
из 'TongWei-PS'
${ noResults }
banboshi_V2/HalftoneWeb/node_modules/vite-plugin-inspect/dist/index.cjs

1005 строки
30 KiB
Исходник Постоянная ссылка Вина История 

  1. 'use strict';

  2. 

  3. const node_path = require('node:path');

  4. const fs = require('fs-extra');

  5. const _debug = require('debug');

  6. const kolorist = require('kolorist');

  7. const sirv = require('sirv');

  8. const pluginutils = require('@rollup/pluginutils');

  9. const node_url = require('node:url');

  10. 

  11. function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }

  12. 

  13. const fs__default = /*#__PURE__*/_interopDefaultCompat(fs);

  14. const _debug__default = /*#__PURE__*/_interopDefaultCompat(_debug);

  15. const sirv__default = /*#__PURE__*/_interopDefaultCompat(sirv);

  16. 

  17. const DEFAULT_TIMEOUT = 6e4;

  18. const defaultSerialize = (i) => i;

  19. const defaultDeserialize = defaultSerialize;

  20. function createBirpc(functions, options) {

  21.   const {

  22.     post,

  23.     on,

  24.     eventNames = [],

  25.     serialize = defaultSerialize,

  26.     deserialize = defaultDeserialize,

  27.     timeout = DEFAULT_TIMEOUT

  28.   } = options;

  29.   const rpcPromiseMap = /* @__PURE__ */ new Map();

  30.   let _promise;

  31.   const rpc = new Proxy({}, {

  32.     get(_, method) {

  33.       const sendEvent = (...args) => {

  34.         post(serialize({ m: method, a: args, t: "q" }));

  35.       };

  36.       if (eventNames.includes(method)) {

  37.         sendEvent.asEvent = sendEvent;

  38.         return sendEvent;

  39.       }

  40.       const sendCall = async (...args) => {

  41.         await _promise;

  42.         return new Promise((resolve, reject) => {

  43.           const id = nanoid();

  44.           rpcPromiseMap.set(id, { resolve, reject });

  45.           post(serialize({ m: method, a: args, i: id, t: "q" }));

  46.           if (timeout >= 0) {

  47.             setTimeout(() => {

  48.               reject(new Error(`[birpc] timeout on calling "${method}"`));

  49.               rpcPromiseMap.delete(id);

  50.             }, timeout);

  51.           }

  52.         });

  53.       };

  54.       sendCall.asEvent = sendEvent;

  55.       return sendCall;

  56.     }

  57.   });

  58.   _promise = on(async (data, ...extra) => {

  59.     const msg = deserialize(data);

  60.     if (msg.t === "q") {

  61.       const { m: method, a: args } = msg;

  62.       let result, error;

  63.       try {

  64.         result = await functions[method].apply(rpc, args);

  65.       } catch (e) {

  66.         error = e;

  67.       }

  68.       if (msg.i)

  69.         post(serialize({ t: "s", i: msg.i, r: result, e: error }), ...extra);

  70.     } else {

  71.       const { i: ack, r: result, e: error } = msg;

  72.       const promise = rpcPromiseMap.get(ack);

  73.       if (promise) {

  74.         if (error)

  75.           promise.reject(error);

  76.         else

  77.           promise.resolve(result);

  78.       }

  79.       rpcPromiseMap.delete(ack);

  80.     }

  81.   });

  82.   return rpc;

  83. }

  84. const cacheMap = /* @__PURE__ */ new WeakMap();

  85. function cachedMap(items, fn) {

  86.   return items.map((i) => {

  87.     let r = cacheMap.get(i);

  88.     if (!r) {

  89.       r = fn(i);

  90.       cacheMap.set(i, r);

  91.     }

  92.     return r;

  93.   });

  94. }

  95. function createBirpcGroup(functions, channels, options = {}) {

  96.   const getChannels = () => typeof channels === "function" ? channels() : channels;

  97.   const getClients = (channels2 = getChannels()) => cachedMap(channels2, (s) => createBirpc(functions, { ...options, ...s }));

  98.   const broadcastProxy = new Proxy({}, {

  99.     get(_, method) {

  100.       const client = getClients();

  101.       const functions2 = client.map((c) => c[method]);

  102.       const sendCall = (...args) => {

  103.         return Promise.all(functions2.map((i) => i(...args)));

  104.       };

  105.       sendCall.asEvent = (...args) => {

  106.         functions2.map((i) => i.asEvent(...args));

  107.       };

  108.       return sendCall;

  109.     }

  110.   });

  111.   function updateChannels(fn) {

  112.     const channels2 = getChannels();

  113.     fn?.(channels2);

  114.     return getClients(channels2);

  115.   }

  116.   getClients();

  117.   return {

  118.     get clients() {

  119.       return getClients();

  120.     },

  121.     updateChannels,

  122.     broadcast: broadcastProxy,

  123.     /**

  124.      * @deprecated use `broadcast`

  125.      */

  126.     boardcast: broadcastProxy

  127.   };

  128. }

  129. const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";

  130. function nanoid(size = 21) {

  131.   let id = "";

  132.   let i = size;

  133.   while (i--)

  134.     id += urlAlphabet[Math.random() * 64 | 0];

  135.   return id;

  136. }

  137. 

  138. function createRPCServer(name, ws, functions) {

  139.   const event = `${name}:rpc`;

  140.   const group = createBirpcGroup(

  141.     functions,

  142.     () => cachedMap(

  143.       Array.from(ws?.clients || []),

  144.       (socket) => {

  145.         return {

  146.           on: (fn) => {

  147.             ws.on(event, (data, source) => {

  148.               if (socket === source)

  149.                 fn(data);

  150.             });

  151.           },

  152.           post: (data) => {

  153.             socket.send(event, data);

  154.           }

  155.         };

  156.       }

  157.     )

  158.   );

  159.   ws.on("connection", () => {

  160.     group.updateChannels();

  161.   });

  162.   return group.broadcast;

  163. }

  164. 

  165. const defaults = {

  166.   ignoreUnknown: false,

  167.   respectType: false,

  168.   respectFunctionNames: false,

  169.   respectFunctionProperties: false,

  170.   unorderedObjects: true,

  171.   unorderedArrays: false,

  172.   unorderedSets: false

  173. };

  174. function objectHash(object, options = {}) {

  175.   options = { ...defaults, ...options };

  176.   const hasher = createHasher(options);

  177.   hasher.dispatch(object);

  178.   return hasher.toString();

  179. }

  180. function createHasher(options) {

  181.   const buff = [];

  182.   let context = [];

  183.   const write = (str) => {

  184.     buff.push(str);

  185.   };

  186.   return {

  187.     toString() {

  188.       return buff.join("");

  189.     },

  190.     getContext() {

  191.       return context;

  192.     },

  193.     dispatch(value) {

  194.       if (options.replacer) {

  195.         value = options.replacer(value);

  196.       }

  197.       const type = value === null ? "null" : typeof value;

  198.       return this["_" + type](value);

  199.     },

  200.     _object(object) {

  201.       const pattern = /\[object (.*)]/i;

  202.       const objString = Object.prototype.toString.call(object);

  203.       const _objType = pattern.exec(objString);

  204.       const objType = _objType ? _objType[1].toLowerCase() : "unknown:[" + objString.toLowerCase() + "]";

  205.       let objectNumber = null;

  206.       if ((objectNumber = context.indexOf(object)) >= 0) {

  207.         return this.dispatch("[CIRCULAR:" + objectNumber + "]");

  208.       } else {

  209.         context.push(object);

  210.       }

  211.       if (typeof Buffer !== "undefined" && Buffer.isBuffer && Buffer.isBuffer(object)) {

  212.         write("buffer:");

  213.         return write(object.toString("utf8"));

  214.       }

  215.       if (objType !== "object" && objType !== "function" && objType !== "asyncfunction") {

  216.         if (this["_" + objType]) {

  217.           this["_" + objType](object);

  218.         } else if (options.ignoreUnknown) {

  219.           return write("[" + objType + "]");

  220.         } else {

  221.           throw new Error('Unknown object type "' + objType + '"');

  222.         }

  223.       } else {

  224.         let keys = Object.keys(object);

  225.         if (options.unorderedObjects) {

  226.           keys = keys.sort();

  227.         }

  228.         if (options.respectType !== false && !isNativeFunction(object)) {

  229.           keys.splice(0, 0, "prototype", "__proto__", "letructor");

  230.         }

  231.         if (options.excludeKeys) {

  232.           keys = keys.filter(function(key) {

  233.             return !options.excludeKeys(key);

  234.           });

  235.         }

  236.         write("object:" + keys.length + ":");

  237.         for (const key of keys) {

  238.           this.dispatch(key);

  239.           write(":");

  240.           if (!options.excludeValues) {

  241.             this.dispatch(object[key]);

  242.           }

  243.           write(",");

  244.         }

  245.       }

  246.     },

  247.     _array(arr, unordered) {

  248.       unordered = typeof unordered !== "undefined" ? unordered : options.unorderedArrays !== false;

  249.       write("array:" + arr.length + ":");

  250.       if (!unordered || arr.length <= 1) {

  251.         for (const entry of arr) {

  252.           this.dispatch(entry);

  253.         }

  254.         return;

  255.       }

  256.       const contextAdditions = [];

  257.       const entries = arr.map((entry) => {

  258.         const hasher = createHasher(options);

  259.         hasher.dispatch(entry);

  260.         contextAdditions.push(hasher.getContext());

  261.         return hasher.toString();

  262.       });

  263.       context = [...context, ...contextAdditions];

  264.       entries.sort();

  265.       return this._array(entries, false);

  266.     },

  267.     _date(date) {

  268.       return write("date:" + date.toJSON());

  269.     },

  270.     _symbol(sym) {

  271.       return write("symbol:" + sym.toString());

  272.     },

  273.     _error(err) {

  274.       return write("error:" + err.toString());

  275.     },

  276.     _boolean(bool) {

  277.       return write("bool:" + bool.toString());

  278.     },

  279.     _string(string) {

  280.       write("string:" + string.length + ":");

  281.       write(string.toString());

  282.     },

  283.     _function(fn) {

  284.       write("fn:");

  285.       if (isNativeFunction(fn)) {

  286.         this.dispatch("[native]");

  287.       } else {

  288.         this.dispatch(fn.toString());

  289.       }

  290.       if (options.respectFunctionNames !== false) {

  291.         this.dispatch("function-name:" + String(fn.name));

  292.       }

  293.       if (options.respectFunctionProperties) {

  294.         this._object(fn);

  295.       }

  296.     },

  297.     _number(number) {

  298.       return write("number:" + number.toString());

  299.     },

  300.     _xml(xml) {

  301.       return write("xml:" + xml.toString());

  302.     },

  303.     _null() {

  304.       return write("Null");

  305.     },

  306.     _undefined() {

  307.       return write("Undefined");

  308.     },

  309.     _regexp(regex) {

  310.       return write("regex:" + regex.toString());

  311.     },

  312.     _uint8array(arr) {

  313.       write("uint8array:");

  314.       return this.dispatch(Array.prototype.slice.call(arr));

  315.     },

  316.     _uint8clampedarray(arr) {

  317.       write("uint8clampedarray:");

  318.       return this.dispatch(Array.prototype.slice.call(arr));

  319.     },

  320.     _int8array(arr) {

  321.       write("int8array:");

  322.       return this.dispatch(Array.prototype.slice.call(arr));

  323.     },

  324.     _uint16array(arr) {

  325.       write("uint16array:");

  326.       return this.dispatch(Array.prototype.slice.call(arr));

  327.     },

  328.     _int16array(arr) {

  329.       write("int16array:");

  330.       return this.dispatch(Array.prototype.slice.call(arr));

  331.     },

  332.     _uint32array(arr) {

  333.       write("uint32array:");

  334.       return this.dispatch(Array.prototype.slice.call(arr));

  335.     },

  336.     _int32array(arr) {

  337.       write("int32array:");

  338.       return this.dispatch(Array.prototype.slice.call(arr));

  339.     },

  340.     _float32array(arr) {

  341.       write("float32array:");

  342.       return this.dispatch(Array.prototype.slice.call(arr));

  343.     },

  344.     _float64array(arr) {

  345.       write("float64array:");

  346.       return this.dispatch(Array.prototype.slice.call(arr));

  347.     },

  348.     _arraybuffer(arr) {

  349.       write("arraybuffer:");

  350.       return this.dispatch(new Uint8Array(arr));

  351.     },

  352.     _url(url) {

  353.       return write("url:" + url.toString());

  354.     },

  355.     _map(map) {

  356.       write("map:");

  357.       const arr = [...map];

  358.       return this._array(arr, options.unorderedSets !== false);

  359.     },

  360.     _set(set) {

  361.       write("set:");

  362.       const arr = [...set];

  363.       return this._array(arr, options.unorderedSets !== false);

  364.     },

  365.     _file(file) {

  366.       write("file:");

  367.       return this.dispatch([file.name, file.size, file.type, file.lastModfied]);

  368.     },

  369.     _blob() {

  370.       if (options.ignoreUnknown) {

  371.         return write("[blob]");

  372.       }

  373.       throw new Error('Hashing Blob objects is currently not supported\nUse "options.replacer" or "options.ignoreUnknown"\n');

  374.     },

  375.     _domwindow() {

  376.       return write("domwindow");

  377.     },

  378.     _bigint(number) {

  379.       return write("bigint:" + number.toString());

  380.     },

  381.     _process() {

  382.       return write("process");

  383.     },

  384.     _timer() {

  385.       return write("timer");

  386.     },

  387.     _pipe() {

  388.       return write("pipe");

  389.     },

  390.     _tcp() {

  391.       return write("tcp");

  392.     },

  393.     _udp() {

  394.       return write("udp");

  395.     },

  396.     _tty() {

  397.       return write("tty");

  398.     },

  399.     _statwatcher() {

  400.       return write("statwatcher");

  401.     },

  402.     _securecontext() {

  403.       return write("securecontext");

  404.     },

  405.     _connection() {

  406.       return write("connection");

  407.     },

  408.     _zlib() {

  409.       return write("zlib");

  410.     },

  411.     _context() {

  412.       return write("context");

  413.     },

  414.     _nodescript() {

  415.       return write("nodescript");

  416.     },

  417.     _httpparser() {

  418.       return write("httpparser");

  419.     },

  420.     _dataview() {

  421.       return write("dataview");

  422.     },

  423.     _signal() {

  424.       return write("signal");

  425.     },

  426.     _fsevent() {

  427.       return write("fsevent");

  428.     },

  429.     _tlswrap() {

  430.       return write("tlswrap");

  431.     }

  432.   };

  433. }

  434. function isNativeFunction(f) {

  435.   if (typeof f !== "function") {

  436.     return false;

  437.   }

  438.   const exp = /^function\s+\w*\s*\(\s*\)\s*{\s+\[native code]\s+}$/i;

  439.   return exp.exec(Function.prototype.toString.call(f)) != null;

  440. }

  441. 

  442. class WordArray {

  443.   constructor(words, sigBytes) {

  444.     words = this.words = words || [];

  445.     this.sigBytes = sigBytes !== void 0 ? sigBytes : words.length * 4;

  446.   }

  447.   toString(encoder) {

  448.     return (encoder || Hex).stringify(this);

  449.   }

  450.   concat(wordArray) {

  451.     this.clamp();

  452.     if (this.sigBytes % 4) {

  453.       for (let i = 0; i < wordArray.sigBytes; i++) {

  454.         const thatByte = wordArray.words[i >>> 2] >>> 24 - i % 4 * 8 & 255;

  455.         this.words[this.sigBytes + i >>> 2] |= thatByte << 24 - (this.sigBytes + i) % 4 * 8;

  456.       }

  457.     } else {

  458.       for (let j = 0; j < wordArray.sigBytes; j += 4) {

  459.         this.words[this.sigBytes + j >>> 2] = wordArray.words[j >>> 2];

  460.       }

  461.     }

  462.     this.sigBytes += wordArray.sigBytes;

  463.     return this;

  464.   }

  465.   clamp() {

  466.     this.words[this.sigBytes >>> 2] &= 4294967295 << 32 - this.sigBytes % 4 * 8;

  467.     this.words.length = Math.ceil(this.sigBytes / 4);

  468.   }

  469.   clone() {

  470.     return new WordArray([...this.words]);

  471.   }

  472. }

  473. const Hex = {

  474.   stringify(wordArray) {

  475.     const hexChars = [];

  476.     for (let i = 0; i < wordArray.sigBytes; i++) {

  477.       const bite = wordArray.words[i >>> 2] >>> 24 - i % 4 * 8 & 255;

  478.       hexChars.push(

  479.         (bite >>> 4).toString(16),

  480.         (bite & 15).toString(16)

  481.       );

  482.     }

  483.     return hexChars.join("");

  484.   }

  485. };

  486. const Base64 = {

  487.   stringify(wordArray) {

  488.     const keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";

  489.     const base64Chars = [];

  490.     for (let i = 0; i < wordArray.sigBytes; i += 3) {

  491.       const byte1 = wordArray.words[i >>> 2] >>> 24 - i % 4 * 8 & 255;

  492.       const byte2 = wordArray.words[i + 1 >>> 2] >>> 24 - (i + 1) % 4 * 8 & 255;

  493.       const byte3 = wordArray.words[i + 2 >>> 2] >>> 24 - (i + 2) % 4 * 8 & 255;

  494.       const triplet = byte1 << 16 | byte2 << 8 | byte3;

  495.       for (let j = 0; j < 4 && i * 8 + j * 6 < wordArray.sigBytes * 8; j++) {

  496.         base64Chars.push(keyStr.charAt(triplet >>> 6 * (3 - j) & 63));

  497.       }

  498.     }

  499.     return base64Chars.join("");

  500.   }

  501. };

  502. const Latin1 = {

  503.   parse(latin1Str) {

  504.     const latin1StrLength = latin1Str.length;

  505.     const words = [];

  506.     for (let i = 0; i < latin1StrLength; i++) {

  507.       words[i >>> 2] |= (latin1Str.charCodeAt(i) & 255) << 24 - i % 4 * 8;

  508.     }

  509.     return new WordArray(words, latin1StrLength);

  510.   }

  511. };

  512. const Utf8 = {

  513.   parse(utf8Str) {

  514.     return Latin1.parse(unescape(encodeURIComponent(utf8Str)));

  515.   }

  516. };

  517. class BufferedBlockAlgorithm {

  518.   constructor() {

  519.     this._minBufferSize = 0;

  520.     this.blockSize = 512 / 32;

  521.     this.reset();

  522.   }

  523.   reset() {

  524.     this._data = new WordArray();

  525.     this._nDataBytes = 0;

  526.   }

  527.   _append(data) {

  528.     if (typeof data === "string") {

  529.       data = Utf8.parse(data);

  530.     }

  531.     this._data.concat(data);

  532.     this._nDataBytes += data.sigBytes;

  533.   }

  534.   _doProcessBlock(_dataWords, _offset) {

  535.   }

  536.   _process(doFlush) {

  537.     let processedWords;

  538.     let nBlocksReady = this._data.sigBytes / (this.blockSize * 4);

  539.     if (doFlush) {

  540.       nBlocksReady = Math.ceil(nBlocksReady);

  541.     } else {

  542.       nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);

  543.     }

  544.     const nWordsReady = nBlocksReady * this.blockSize;

  545.     const nBytesReady = Math.min(nWordsReady * 4, this._data.sigBytes);

  546.     if (nWordsReady) {

  547.       for (let offset = 0; offset < nWordsReady; offset += this.blockSize) {

  548.         this._doProcessBlock(this._data.words, offset);

  549.       }

  550.       processedWords = this._data.words.splice(0, nWordsReady);

  551.       this._data.sigBytes -= nBytesReady;

  552.     }

  553.     return new WordArray(processedWords, nBytesReady);

  554.   }

  555. }

  556. class Hasher extends BufferedBlockAlgorithm {

  557.   update(messageUpdate) {

  558.     this._append(messageUpdate);

  559.     this._process();

  560.     return this;

  561.   }

  562.   finalize(messageUpdate) {

  563.     if (messageUpdate) {

  564.       this._append(messageUpdate);

  565.     }

  566.   }

  567. }

  568. 

  569. const H = [1779033703, -1150833019, 1013904242, -1521486534, 1359893119, -1694144372, 528734635, 1541459225];

  570. const K = [1116352408, 1899447441, -1245643825, -373957723, 961987163, 1508970993, -1841331548, -1424204075, -670586216, 310598401, 607225278, 1426881987, 1925078388, -2132889090, -1680079193, -1046744716, -459576895, -272742522, 264347078, 604807628, 770255983, 1249150122, 1555081692, 1996064986, -1740746414, -1473132947, -1341970488, -1084653625, -958395405, -710438585, 113926993, 338241895, 666307205, 773529912, 1294757372, 1396182291, 1695183700, 1986661051, -2117940946, -1838011259, -1564481375, -1474664885, -1035236496, -949202525, -778901479, -694614492, -200395387, 275423344, 430227734, 506948616, 659060556, 883997877, 958139571, 1322822218, 1537002063, 1747873779, 1955562222, 2024104815, -2067236844, -1933114872, -1866530822, -1538233109, -1090935817, -965641998];

  571. const W = [];

  572. class SHA256 extends Hasher {

  573.   constructor() {

  574.     super();

  575.     this.reset();

  576.   }

  577.   reset() {

  578.     super.reset();

  579.     this._hash = new WordArray([...H]);

  580.   }

  581.   _doProcessBlock(M, offset) {

  582.     const H2 = this._hash.words;

  583.     let a = H2[0];

  584.     let b = H2[1];

  585.     let c = H2[2];

  586.     let d = H2[3];

  587.     let e = H2[4];

  588.     let f = H2[5];

  589.     let g = H2[6];

  590.     let h = H2[7];

  591.     for (let i = 0; i < 64; i++) {

  592.       if (i < 16) {

  593.         W[i] = M[offset + i] | 0;

  594.       } else {

  595.         const gamma0x = W[i - 15];

  596.         const gamma0 = (gamma0x << 25 | gamma0x >>> 7) ^ (gamma0x << 14 | gamma0x >>> 18) ^ gamma0x >>> 3;

  597.         const gamma1x = W[i - 2];

  598.         const gamma1 = (gamma1x << 15 | gamma1x >>> 17) ^ (gamma1x << 13 | gamma1x >>> 19) ^ gamma1x >>> 10;

  599.         W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16];

  600.       }

  601.       const ch = e & f ^ ~e & g;

  602.       const maj = a & b ^ a & c ^ b & c;

  603.       const sigma0 = (a << 30 | a >>> 2) ^ (a << 19 | a >>> 13) ^ (a << 10 | a >>> 22);

  604.       const sigma1 = (e << 26 | e >>> 6) ^ (e << 21 | e >>> 11) ^ (e << 7 | e >>> 25);

  605.       const t1 = h + sigma1 + ch + K[i] + W[i];

  606.       const t2 = sigma0 + maj;

  607.       h = g;

  608.       g = f;

  609.       f = e;

  610.       e = d + t1 | 0;

  611.       d = c;

  612.       c = b;

  613.       b = a;

  614.       a = t1 + t2 | 0;

  615.     }

  616.     H2[0] = H2[0] + a | 0;

  617.     H2[1] = H2[1] + b | 0;

  618.     H2[2] = H2[2] + c | 0;

  619.     H2[3] = H2[3] + d | 0;

  620.     H2[4] = H2[4] + e | 0;

  621.     H2[5] = H2[5] + f | 0;

  622.     H2[6] = H2[6] + g | 0;

  623.     H2[7] = H2[7] + h | 0;

  624.   }

  625.   finalize(messageUpdate) {

  626.     super.finalize(messageUpdate);

  627.     const nBitsTotal = this._nDataBytes * 8;

  628.     const nBitsLeft = this._data.sigBytes * 8;

  629.     this._data.words[nBitsLeft >>> 5] |= 128 << 24 - nBitsLeft % 32;

  630.     this._data.words[(nBitsLeft + 64 >>> 9 << 4) + 14] = Math.floor(nBitsTotal / 4294967296);

  631.     this._data.words[(nBitsLeft + 64 >>> 9 << 4) + 15] = nBitsTotal;

  632.     this._data.sigBytes = this._data.words.length * 4;

  633.     this._process();

  634.     return this._hash;

  635.   }

  636. }

  637. function sha256base64(message) {

  638.   return new SHA256().finalize(message).toString(Base64);

  639. }

  640. 

  641. function hash(object, options = {}) {

  642.   const hashed = typeof object === "string" ? object : objectHash(object, options);

  643.   return sha256base64(hashed).slice(0, 10);

  644. }

  645. 

  646. const DIR_DIST = typeof __dirname !== "undefined" ? __dirname : node_path.dirname(node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (document.currentScript && document.currentScript.src || new URL('index.cjs', document.baseURI).href))));

  647. const DIR_CLIENT = node_path.resolve(DIR_DIST, "../dist/client");

  648. 

  649. const debug = _debug__default("vite-plugin-inspect");

  650. const NAME = "vite-plugin-inspect";

  651. const dummyLoadPluginName = "__load__";

  652. function PluginInspect(options = {}) {

  653.   const {

  654.     dev = true,

  655.     build = false,

  656.     outputDir = ".vite-inspect"

  657.   } = options;

  658.   if (!dev && !build) {

  659.     return {

  660.       name: NAME

  661.     };

  662.   }

  663.   const filter = pluginutils.createFilter(options.include, options.exclude);

  664.   let config;

  665.   const transformMap = {};

  666.   const transformMapSSR = {};

  667.   const idMap = {};

  668.   const idMapSSR = {};

  669.   function hijackHook(plugin2, name, wrapper) {

  670.     if (!plugin2[name])

  671.       return;

  672.     debug(`hijack plugin "${name}"`, plugin2.name);

  673.     let order = plugin2.order || plugin2.enforce || "normal";

  674.     const hook = plugin2[name];

  675.     if ("handler" in hook) {

  676.       const oldFn = hook.handler;

  677.       order += `-${hook.order || hook.enforce || "normal"}`;

  678.       hook.handler = function(...args) {

  679.         return wrapper(oldFn, this, args, order);

  680.       };

  681.     } else if ("transform" in hook) {

  682.       const oldFn = hook.transform;

  683.       order += `-${hook.order || hook.enforce || "normal"}`;

  684.       hook.transform = function(...args) {

  685.         return wrapper(oldFn, this, args, order);

  686.       };

  687.     } else {

  688.       const oldFn = hook;

  689.       plugin2[name] = function(...args) {

  690.         return wrapper(oldFn, this, args, order);

  691.       };

  692.     }

  693.   }

  694.   function hijackPlugin(plugin2) {

  695.     hijackHook(plugin2, "transform", async (fn, context, args, order) => {

  696.       const code = args[0];

  697.       const id = args[1];

  698.       const ssr = args[2]?.ssr;

  699.       const start = Date.now();

  700.       const _result = await fn.apply(context, args);

  701.       const end = Date.now();

  702.       const result = typeof _result === "string" ? _result : _result?.code;

  703.       const map = ssr ? transformMapSSR : transformMap;

  704.       if (filter(id) && result != null) {

  705.         if (!map[id])

  706.           map[id] = [{ name: dummyLoadPluginName, result: code, start, end: start }];

  707.         map[id].push({ name: plugin2.name, result, start, end, order });

  708.       }

  709.       return _result;

  710.     });

  711.     hijackHook(plugin2, "load", async (fn, context, args) => {

  712.       const id = args[0];

  713.       const ssr = args[1]?.ssr;

  714.       const start = Date.now();

  715.       const _result = await fn.apply(context, args);

  716.       const end = Date.now();

  717.       const result = typeof _result === "string" ? _result : _result?.code;

  718.       const map = ssr ? transformMapSSR : transformMap;

  719.       if (filter(id) && result != null)

  720.         map[id] = [{ name: plugin2.name, result, start, end }];

  721.       return _result;

  722.     });

  723.     hijackHook(plugin2, "resolveId", async (fn, context, args) => {

  724.       const id = args[0];

  725.       const ssr = args[2]?.ssr;

  726.       const start = Date.now();

  727.       const _result = await fn.apply(context, args);

  728.       const end = Date.now();

  729.       const result = typeof _result === "object" ? _result?.id : _result;

  730.       const map = ssr ? idMapSSR : idMap;

  731.       if (result && result !== id) {

  732.         if (!map[id])

  733.           map[id] = [];

  734.         map[id].push({ name: plugin2.name, result, start, end });

  735.       }

  736.       return _result;

  737.     });

  738.   }

  739.   function resolveId(id = "", ssr = false) {

  740.     if (id.startsWith("./"))

  741.       id = node_path.resolve(config.root, id).replace(/\\/g, "/");

  742.     return resolveIdRec(id, ssr);

  743.   }

  744.   function resolveIdRec(id, ssr = false) {

  745.     const map = ssr ? idMapSSR : idMap;

  746.     return map[id]?.[0] ? resolveIdRec(map[id][0].result, ssr) : id;

  747.   }

  748.   function getPluginMetrics(ssr = false) {

  749.     const map = {};

  750.     const defaultMetricInfo = () => ({

  751.       transform: { invokeCount: 0, totalTime: 0 },

  752.       resolveId: { invokeCount: 0, totalTime: 0 }

  753.     });

  754.     config.plugins.forEach((i) => {

  755.       map[i.name] = {

  756.         ...defaultMetricInfo(),

  757.         name: i.name,

  758.         enforce: i.enforce

  759.       };

  760.     });

  761.     Object.values(ssr ? transformMapSSR : transformMap).forEach((transformInfos) => {

  762.       transformInfos.forEach(({ name, start, end }) => {

  763.         if (name === dummyLoadPluginName)

  764.           return;

  765.         if (!map[name])

  766.           map[name] = { ...defaultMetricInfo(), name };

  767.         map[name].transform.totalTime += end - start;

  768.         map[name].transform.invokeCount += 1;

  769.       });

  770.     });

  771.     Object.values(ssr ? idMapSSR : idMap).forEach((resolveIdInfos) => {

  772.       resolveIdInfos.forEach(({ name, start, end }) => {

  773.         if (!map[name])

  774.           map[name] = { ...defaultMetricInfo(), name };

  775.         map[name].resolveId.totalTime += end - start;

  776.         map[name].resolveId.invokeCount += 1;

  777.       });

  778.     });

  779.     const metrics = Object.values(map).filter(Boolean).sort((a, b) => a.name.localeCompare(b.name));

  780.     return metrics;

  781.   }

  782.   function configureServer(server) {

  783.     const _invalidateModule = server.moduleGraph.invalidateModule;

  784.     server.moduleGraph.invalidateModule = function(...args) {

  785.       const mod = args[0];

  786.       if (mod?.id) {

  787.         delete transformMap[mod.id];

  788.         delete transformMapSSR[mod.id];

  789.       }

  790.       return _invalidateModule.apply(this, args);

  791.     };

  792.     const base = (options.base ?? server.config.base) || "/";

  793.     server.middlewares.use(`${base}__inspect`, sirv__default(DIR_CLIENT, {

  794.       single: true,

  795.       dev: true

  796.     }));

  797.     const rpcFunctions = {

  798.       list,

  799.       getIdInfo,

  800.       getPluginMetrics,

  801.       resolveId,

  802.       clear: clearId

  803.     };

  804.     createRPCServer("vite-plugin-inspect", server.ws, rpcFunctions);

  805.     async function getIdInfo(id, ssr = false, clear = false) {

  806.       if (clear) {

  807.         clearId(id, ssr);

  808.         try {

  809.           await server.transformRequest(id, { ssr });

  810.         } catch {

  811.         }

  812.       }

  813.       const resolvedId = resolveId(id, ssr);

  814.       const map = ssr ? transformMapSSR : transformMap;

  815.       return {

  816.         resolvedId,

  817.         transforms: map[resolvedId] || []

  818.       };

  819.     }

  820.     function getModulesInfo(map) {

  821.       return Object.keys(map).sort().map((id) => {

  822.         const plugins = map[id]?.map((i) => i.name);

  823.         const deps = Array.from(server.moduleGraph.getModuleById(id)?.importedModules || []).map((i) => i.id || "").filter(Boolean);

  824.         return {

  825.           id,

  826.           plugins,

  827.           deps,

  828.           virtual: plugins[0] !== dummyLoadPluginName

  829.         };

  830.       });

  831.     }

  832.     function list() {

  833.       return {

  834.         root: config.root,

  835.         modules: getModulesInfo(transformMap),

  836.         ssrModules: getModulesInfo(transformMapSSR)

  837.       };

  838.     }

  839.     function clearId(_id, ssr = false) {

  840.       const id = resolveId(_id);

  841.       if (id) {

  842.         const mod = server.moduleGraph.getModuleById(id);

  843.         if (mod)

  844.           server.moduleGraph.invalidateModule(mod);

  845.         const map = ssr ? transformMapSSR : transformMap;

  846.         delete map[id];

  847.       }

  848.     }

  849.     const _print = server.printUrls;

  850.     server.printUrls = () => {

  851.       const colorUrl = (url2) => kolorist.green(url2.replace(/:(\d+)\//, (_, port) => `:${kolorist.bold(port)}/`));

  852.       let host = `${config.server.https ? "https" : "http"}://localhost:${config.server.port || "80"}`;

  853.       const url = server.resolvedUrls?.local[0];

  854.       if (url) {

  855.         try {

  856.           const u = new URL(url);

  857.           host = `${u.protocol}//${u.host}`;

  858.         } catch (error) {

  859.           console.warn("Parse resolved url failed:", error);

  860.         }

  861.       }

  862.       _print();

  863.       console.log(`  ${kolorist.green("\u279C")}  ${kolorist.bold("Inspect")}: ${colorUrl(`${host}${base}__inspect/`)}`);

  864.     };

  865.     return rpcFunctions;

  866.   }

  867.   async function generateBuild() {

  868.     const targetDir = node_path.join(config.root, outputDir);

  869.     const reportsDir = node_path.join(targetDir, "reports");

  870.     await fs__default.mkdir(targetDir, { recursive: true });

  871.     await fs__default.copy(DIR_CLIENT, targetDir, { overwrite: true });

  872.     await fs__default.writeFile(

  873.       node_path.join(targetDir, "index.html"),

  874.       (await fs__default.readFile(node_path.join(targetDir, "index.html"), "utf-8")).replace(

  875.         'data-vite-inspect-mode="DEV"',

  876.         'data-vite-inspect-mode="BUILD"'

  877.       )

  878.     );

  879.     await fs__default.rm(reportsDir, {

  880.       recursive: true,

  881.       force: true

  882.     });

  883.     await fs__default.mkdir(reportsDir, { recursive: true });

  884.     function getModulesInfo(map) {

  885.       return Object.keys(map).sort().map((id) => {

  886.         const plugins = map[id]?.map((i) => i.name);

  887.         return {

  888.           id,

  889.           deps: [],

  890.           plugins,

  891.           virtual: plugins[0] !== dummyLoadPluginName && map[id][0].name !== "vite:load-fallback"

  892.         };

  893.       });

  894.     }

  895.     function list() {

  896.       return {

  897.         root: config.root,

  898.         modules: getModulesInfo(transformMap),

  899.         ssrModules: getModulesInfo(transformMapSSR)

  900.       };

  901.     }

  902.     await fs__default.writeFile(

  903.       node_path.join(reportsDir, "list.json"),

  904.       JSON.stringify(list(), null, 2),

  905.       "utf-8"

  906.     );

  907.     await fs__default.writeFile(

  908.       node_path.join(reportsDir, "metrics.json"),

  909.       JSON.stringify(getPluginMetrics(false), null, 2),

  910.       "utf-8"

  911.     );

  912.     await fs__default.writeFile(

  913.       node_path.join(reportsDir, "metrics-ssr.json"),

  914.       JSON.stringify(getPluginMetrics(true), null, 2),

  915.       "utf-8"

  916.     );

  917.     async function dumpModuleInfo(dir, map, ssr = false) {

  918.       await fs__default.ensureDir(dir);

  919.       return Promise.all(

  920.         Object.entries(map).map(

  921.           ([id, info]) => fs__default.writeJSON(

  922.             node_path.join(dir, `${hash(id)}.json`),

  923.             {

  924.               resolvedId: resolveId(id, ssr),

  925.               transforms: info

  926.             }

  927.           )

  928.         )

  929.       );

  930.     }

  931.     await dumpModuleInfo(node_path.join(reportsDir, "transform"), transformMap);

  932.     await dumpModuleInfo(node_path.join(reportsDir, "transform-ssr"), transformMapSSR, true);

  933.     return targetDir;

  934.   }

  935.   const plugin = {

  936.     name: NAME,

  937.     enforce: "pre",

  938.     apply(_, { command }) {

  939.       if (command === "serve" && dev)

  940.         return true;

  941.       if (command === "build" && build)

  942.         return true;

  943.       return false;

  944.     },

  945.     configResolved(_config) {

  946.       config = _config;

  947.       config.plugins.forEach(hijackPlugin);

  948.       const _createResolver = config.createResolver;

  949.       config.createResolver = function(...args) {

  950.         const _resolver = _createResolver.apply(this, args);

  951.         return async function(...args2) {

  952.           const id = args2[0];

  953.           const aliasOnly = args2[2];

  954.           const ssr = args2[3];

  955.           const start = Date.now();

  956.           const result = await _resolver.apply(this, args2);

  957.           const end = Date.now();

  958.           const map = ssr ? idMapSSR : idMap;

  959.           if (result && result !== id) {

  960.             const pluginName = aliasOnly ? "alias" : "vite:resolve (+alias)";

  961.             if (!map[id])

  962.               map[id] = [];

  963.             map[id].push({ name: pluginName, result, start, end });

  964.           }

  965.           return result;

  966.         };

  967.       };

  968.     },

  969.     configureServer(server) {

  970.       const rpc = configureServer(server);

  971.       plugin.api = {

  972.         rpc

  973.       };

  974.     },

  975.     load: {

  976.       order: "pre",

  977.       handler(id, { ssr } = {}) {

  978.         const map = ssr ? transformMapSSR : transformMap;

  979.         delete map[id];

  980.         return null;

  981.       }

  982.     },

  983.     handleHotUpdate({ modules, server }) {

  984.       const ids = modules.map((module) => module.id);

  985.       server.ws.send({

  986.         type: "custom",

  987.         event: "vite-plugin-inspect:update",

  988.         data: { ids }

  989.       });

  990.     },

  991.     async buildEnd() {

  992.       if (!build)

  993.         return;

  994.       const dir = await generateBuild();

  995.       console.log(kolorist.green("Inspect report generated at"), kolorist.dim(`${dir}`));

  996.     }

  997.   };

  998.   return plugin;

  999. }

  1000. PluginInspect.getViteInspectAPI = function(plugins) {

  1001.   return plugins.find((p) => p.name === NAME)?.api;

  1002. };

  1003. 

  1004. module.exports = PluginInspect;