Vue project configures webpack-obfuscator to implement code encryption and obfuscation

npm install --save-dev webpack-obfuscator

// webpack.config.js
const JavaScriptObfuscator = require('webpack-obfuscator');
module.exports = {
 entry: {
 'abc': './test/input/index.js',
 'cde': './test/input/index1.js'
 },
 output: {
 path: 'dist',
 filename: '[name].js'
 },
 plugins: [
 new JavaScriptObfuscator({
 rotateUnicodeArray: true
 // The array contains files that need to be excluded}, ['abc.js'])
 ]
};

// vue.config.js
const path = require('path');
var JavaScriptObfuscator = require('webpack-obfuscator');
module.exports = {
 publicPath: process.env.NODE_ENV === 'production' ? './' : '/',
 productionSourceMap: false,
 configureWebpack: {
 plugins: [
 new JavaScriptObfuscator({
 rotateStringArray: true,
 }, [])
 ]
 },
 pwa: {},
 pages: {}
}

configureWebpack: (process.env.NODE_ENV === 'production') ? {
 plugins: [
 new JavaScriptObfuscator({
 // ...
 }, [])
 ]
 } : {},

npm run build

//test.js
function abc() {
 for (let i = 0; i < 10; i++) {
 console.log(`${i}th, hello, hello`)
 }
}
abc()

webpackJsonp([2],{lVK7:function(o,l){!function(){for(var o=0;o<10;o++)console.log("The "+o+"th, hello, hello")}()}},["lVK7"]);

new JavaScriptObfuscator({
}, [])

var _0x1f6e=["个,你好,hello","lVK7","log"];!function(n,o){!function(o){for(;--o;)n.push(n.shift())}(++o)}(_0x1f6e,323);var _0x3655=function(n,o){return _0x1f6e[n-=0]};webpackJsonp([2],{lVK7:function(n,o){!function(){for(var n=0;n<10;n++)console[_0x3655("0x0")]("第"+n+_0x3655("0x1"))}()}},[_0x3655("0x2")]);

new JavaScriptObfuscator({
 // Compress code compact: true,
 // Whether to enable control flow flattening (reduce running speed by 1.5 times)
 controlFlowFlattening: true,
 // Application probability; In larger code bases, it is recommended to lower this value, as a large number of control flow transitions may increase the size of the code and reduce the speed of the code.
 controlFlowFlatteningThreshold: 1,
 // Random dead code blocks (increases the size of the obfuscated code)
 deadCodeInjection: true,
 //Dead code block impact probability deadCodeInjectionThreshold: 1,
 // This option makes it almost impossible to use the console tab of the developer tools debugProtection: true,
 // If checked, will force debugging mode with intervals on the Console tab, making it more difficult to use other features of the Developer Tools.
 debugProtectionInterval: true,
 // Disable console.log, console.info, console.error and console.warn by replacing them with empty functions. This makes using the debugger more difficult.
 disableConsoleOutput: true,
 // Obfuscation method of identifier hexadecimal (hexadecimal) mangled (short identifier)
 identifierNamesGenerator: 'hexadecimal',
 log: false,
 // Whether to enable confusion of global variables and function names renameGlobals: false,
 // Move the array through fixed and random (generated when the code is obfuscated) positions. This makes it more difficult to match the order of the deleted strings with their original positions. This option is recommended if the original source code is not small, as the helper functions can draw attention.
 rotateStringArray: true,
 // After the code is obfuscated, you cannot use code beautification, and you need to configure cpmpat:true;
 selfDefending: true,
 // Remove string literals and put them in a special array stringArray: true,
 stringArrayEncoding: 'rc4',
 stringArrayThreshold: 1,
 // Allows to enable/disable string conversion to unicode escape sequences. Unicode escape sequences significantly increase code size and make it easy to restore a string to its original view. It is recommended to enable this option only for small source codes.
 transformObjectKeys: true,
 unicodeEscapeSequence: false
}, []),

var _0xa0d1=["w7Bzw6oKw6E=","wrwIUcOVw4M=","w4bChi3DtcOQ","wpLDtsK5w4LDpA==","OUlQwp1z","woEqw4XCtsOe","YR3DrkDCiA==","woAjwq/Ci8KQ","dDNzw5bDgA==",
// ...
("0x201","xatR")]=function(x){return x()},x[_0x34e6("0x202","vdcx")](_0x2c01f8)},4e3);

new JavaScriptObfuscator({
 // Compress code compact: true,
 // Whether to enable control flow flattening (reduce running speed by 1.5 times)
 controlFlowFlattening: true,
 // Application probability; In larger code bases, it is recommended to lower this value, as a large number of control flow transitions may increase the size of the code and reduce the speed of the code.
 controlFlowFlatteningThreshold: 0.75,
 // Random dead code blocks (increases the size of the obfuscated code)
 deadCodeInjection: true,
 //Dead code block impact probability deadCodeInjectionThreshold: 0.4,
 // This option makes it almost impossible to use the console tab of the developer tools debugProtection: false,
 // If checked, will force debugging mode with intervals on the Console tab, making it more difficult to use other features of the Developer Tools.
 debugProtectionInterval: false,
 // Disable console.log, console.info, console.error and console.warn by replacing them with empty functions. This makes using the debugger more difficult.
 disableConsoleOutput: true,
 // Obfuscation method of identifier hexadecimal (hexadecimal) mangled (short identifier)
 identifierNamesGenerator: 'hexadecimal',
 log: false,
 // Whether to enable confusion of global variables and function names renameGlobals: false,
 // Move the array through fixed and random (generated when the code is obfuscated) positions. This makes it more difficult to match the order of the deleted strings with their original positions. This option is recommended if the original source code is not small, as the helper functions can draw attention.
 rotateStringArray: true,
 // After the code is obfuscated, you cannot use code beautification, and you need to configure cpmpat:true;
 selfDefending: true,
 // Remove string literals and put them in a special array stringArray: true,
 stringArrayEncoding: 'base64',
 stringArrayThreshold: 0.75,
 transformObjectKeys: true,
 // Allows to enable/disable string conversion to unicode escape sequences. Unicode escape sequences significantly increase code size and make it easy to restore a string to its original view. It is recommended to enable this option only for small source codes.
 unicodeEscapeSequence: false
}, []),

var _0x1a25=["UmFzT1U=","RkVIc0o=","VUt2eW4=","Q29IS0g=","V1NSZ0k=","d3RNT2w=","dlV6cUw=","RlpzZWg=","QnpzSlE=","cXBqQ1k=","YXBwbHk=","bFZLNw==","Y3p1Ymo=","TFZlQXE=","Y2NKWlY=","cmV0dXJuIChmdW5jdGlvbigpIA==",
// ...
(b[_0x4bcb("0x2a")]("第"+c,b[_0x4bcb("0x2b")]))}})}},[_0x4bcb("0x2f")]);

new JavaScriptObfuscator({
 // Compress code compact: true,
 // Whether to enable control flow flattening (reduce running speed by 1.5 times)
 controlFlowFlattening: false,
 // Random dead code blocks (increases the size of the obfuscated code)
 deadCodeInjection: false,
 // This option makes it almost impossible to use the console tab of the developer tools debugProtection: false,
 // If checked, will force debugging mode with intervals on the Console tab, making it more difficult to use other features of the Developer Tools.
 debugProtectionInterval: false,
 // Disable console.log, console.info, console.error and console.warn by replacing them with empty functions. This makes using the debugger more difficult.
 disableConsoleOutput: true,
 // Obfuscation method of identifier hexadecimal (hexadecimal) mangled (short identifier)
 identifierNamesGenerator: 'hexadecimal',
 log: false,
 // Whether to enable confusion of global variables and function names renameGlobals: false,
 // Move the array through fixed and random (generated when the code is obfuscated) positions. This makes it more difficult to match the order of the deleted strings with their original positions. This option is recommended if the original source code is not small, as the helper functions can draw attention.
 rotateStringArray: true,
 // After the code is obfuscated, you cannot use code beautification, and you need to configure cpmpat:true;
 selfDefending: true,
 // Remove string literals and put them in a special array stringArray: true,
 stringArrayEncoding: false,
 stringArrayThreshold: 0.75,
 // Allows to enable/disable string conversion to unicode escape sequences. Unicode escape sequences significantly increase code size and make it easy to restore a string to its original view. It is recommended to enable this option only for small source codes.
 unicodeEscapeSequence: false
}, []),

var _0x37a6=["exception","trace","console","个,你好,hello","lVK7","apply","return (function() ",'{}.constructor("return this")() ',"log","warn","debug","info","error"];!function(n,e){var o=function(e){for(;--e;)n.push(n.shift())};
// ...
[_0xe1fd("0x3")]("第"+n+_0xe1fd("0xb"))}()}},[_0xe1fd("0xc")]);