init

马宇豪

2024-07-16 f591c27b57e2418c9495bc02ae8cfff84d35bc18

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
/*
    MIT License http://www.opensource.org/licenses/mit-license.php
    Author Tobias Koppers @sokra
*/
 
"use strict";
 
/** @typedef {import("../util/Hash")} Hash */
 
/**
 * StringXor class provides methods for performing
 * [XOR operations](https://en.wikipedia.org/wiki/Exclusive_or) on strings. In this context
 * we operating on the character codes of two strings, which are represented as
 * [Buffer](https://nodejs.org/api/buffer.html) objects.
 *
 * We use [StringXor in webpack](https://github.com/webpack/webpack/commit/41a8e2ea483a544c4ccd3e6217bdfb80daffca39)
 * to create a hash of the current state of the compilation. By XOR'ing the Module hashes, it
 * doesn't matter if the Module hashes are sorted or not. This is useful because it allows us to avoid sorting the
 * Module hashes.
 *
 * @example
 * ```js
 * const xor = new StringXor();
 * xor.add('hello');
 * xor.add('world');
 * console.log(xor.toString());
 * ```
 *
 * @example
 * ```js
 * const xor = new StringXor();
 * xor.add('foo');
 * xor.add('bar');
 * const hash = createHash('sha256');
 * hash.update(xor.toString());
 * console.log(hash.digest('hex'));
 * ```
 */
class StringXor {
    constructor() {
        /** @type {Buffer|undefined} */
        this._value = undefined;
    }
 
    /**
     * Adds a string to the current StringXor object.
     *
     * @param {string} str string
     * @returns {void}
     */
    add(str) {
        const len = str.length;
        const value = this._value;
        if (value === undefined) {
            /**
             * We are choosing to use Buffer.allocUnsafe() because it is often faster than Buffer.alloc() because
             * it allocates a new buffer of the specified size without initializing the memory.
             */
            const newValue = (this._value = Buffer.allocUnsafe(len));
            for (let i = 0; i < len; i++) {
                newValue[i] = str.charCodeAt(i);
            }
            return;
        }
        const valueLen = value.length;
        if (valueLen < len) {
            const newValue = (this._value = Buffer.allocUnsafe(len));
            let i;
            for (i = 0; i < valueLen; i++) {
                newValue[i] = value[i] ^ str.charCodeAt(i);
            }
            for (; i < len; i++) {
                newValue[i] = str.charCodeAt(i);
            }
        } else {
            for (let i = 0; i < len; i++) {
                value[i] = value[i] ^ str.charCodeAt(i);
            }
        }
    }
 
    /**
     * Returns a string that represents the current state of the StringXor object. We chose to use "latin1" encoding
     * here because "latin1" encoding is a single-byte encoding that can represent all characters in the
     * [ISO-8859-1 character set](https://en.wikipedia.org/wiki/ISO/IEC_8859-1). This is useful when working
     * with binary data that needs to be represented as a string.
     *
     * @returns {string} Returns a string that represents the current state of the StringXor object.
     */
    toString() {
        const value = this._value;
        return value === undefined ? "" : value.toString("latin1");
    }
 
    /**
     * Updates the hash with the current state of the StringXor object.
     *
     * @param {Hash} hash Hash instance
     */
    updateHash(hash) {
        const value = this._value;
        if (value !== undefined) hash.update(value);
    }
}
 
module.exports = StringXor;