azot 5.0.0-alpha.11 → 5.0.0-alpha.13

package/dist/azt.cjs

@@ -1,2 +1,196 @@
 #!/usr/bin/env node
-const e=require(`./chunk-350yNsax.cjs`);let t=require(`node:util`),n=require(`node:fs`),r=require(`node:path`);r=e.n(r);let i=require(`tsdown`),a=require(`node:crypto`),o=require(`javascript-obfuscator`);o=e.n(o);const s=Buffer.from(`STX`,`utf8`),c=(e,t,r)=>{let i=(0,a.randomBytes)(32),o=(0,a.randomBytes)(16),c=(0,n.readFileSync)(t),l=(0,a.createCipheriv)(`aes-256-cbc`,i,o),u=Buffer.concat([l.update(c),l.final()]),d=(0,a.publicEncrypt)(e,i),f=Buffer.concat([s,o,d,u]);return r&&(0,n.writeFileSync)(r,f),{aesIv:o,encryptedAesKey:d,encryptedCode:u}},l=(e,t,r)=>{let i=(0,n.readFileSync)(t),o=s.byteLength;if(!i.subarray(0,o).equals(s))throw Error(`Incorrect file format`);let c=o,l=c+16,u=l+512,d=i.subarray(c,l),f=i.subarray(l,u),p=i.subarray(u),m=(0,a.createDecipheriv)(`aes-256-cbc`,(0,a.privateDecrypt)(e,f),d),h=Buffer.concat([m.update(p),m.final()]).toString(`utf8`);return r&&(0,n.writeFileSync)(r,h),h},u=(e,t)=>{let r=(0,n.readFileSync)(e,`utf8`);console.log(`Obfuscating...`),console.time(`Obfuscation complete in`);let i=o.default.obfuscate(r,{target:`node`,compact:!0,controlFlowFlattening:!0,controlFlowFlatteningThreshold:1,deadCodeInjection:!0,debugProtection:!0,identifierNamesGenerator:`hexadecimal`,numbersToExpressions:!0,selfDefending:!0,simplify:!0,splitStrings:!0,splitStringsChunkLength:5,stringArray:!0,stringArrayCallsTransform:!0,stringArrayCallsTransformThreshold:1,stringArrayEncoding:[`base64`],stringArrayIndexShift:!0,stringArrayRotate:!0,stringArrayShuffle:!0,stringArrayWrappersCount:2,stringArrayWrappersChainedCalls:!0,stringArrayWrappersType:`function`,stringArrayThreshold:1,transformObjectKeys:!0,unicodeEscapeSequence:!1});console.timeEnd(`Obfuscation complete in`);let a=i.getObfuscatedCode();return(0,n.writeFileSync)(t||e,a),a},d=(0,t.parseArgs)({allowPositionals:!0,allowNegative:!0,options:{input:{type:`string`,short:`i`,description:`Path to the input file`},key:{type:`string`,short:`k`,description:`Path to the key file (public for encrypt, private for decrypt)`},output:{type:`string`,short:`o`,description:`Path to the output file`},format:{type:`string`,short:`f`,description:`Output format`},watch:{type:`boolean`,description:`Watch file changes`},minify:{type:`boolean`,description:`Minify output`},obfuscate:{type:`boolean`,description:`Obfuscate output`},encrypt:{type:`boolean`,description:`Encrypt extension source code (.js will be packed inside .stx)`},decrypt:{type:`boolean`,description:`Decrypt encrypted extension`}}}),f=()=>{let e=[process.cwd(),r.default.join(process.cwd(),`src`),r.default.join(process.cwd(),`lib`)];for(let t of e){let e=(0,n.readdirSync)(t).filter(e=>!e.endsWith(`.d.ts`)).filter(e=>new Set([`.ts`,`.js`,`.cjs`,`.mjs`]).has(r.default.extname(e))),i=e=>r.default.basename(e,r.default.extname(e)),a=e.find(e=>i(e)===`index`)||e.find(e=>i(e)===`main`)||e[0];if(a)return r.default.join(t,a)}};(async()=>{let[e,...t]=d.positionals,a=d.values.input||t[0]||f();if(!a)throw Error(`No entry file found`);if(e===`build`||e===`pack`){let t=typeof d.values.minify==`boolean`?d.values.minify:!0;await(0,i.build)({entry:a.replace(process.cwd(),`.`).replace(r.default.sep,`/`),format:d.values.format??`cjs`,platform:`node`,target:`node22`,watch:d.values.watch,minify:t});let o=d.values.format??`cjs`;d.values.input=r.default.join(process.cwd(),`dist`,r.default.basename(a).replace(/\.ts$/,`.${o}`));let s=require(r.default.join(process.cwd(),`package.json`));if((typeof d.values.obfuscate==`boolean`?d.values.obfuscate:s.private)&&u(d.values.input,d.values.input),d.values.encrypt||e===`pack`){let e=(0,n.readFileSync)(d.values.key||r.default.join(__dirname,`../public.pem`),`utf8`),t=d.values.output||d.values.input.replace(/\.js$/,`-${s.version}.stx`);c(e,d.values.input,t),(0,n.rmSync)(d.values.input)}}else if(e===`decrypt`)l((0,n.readFileSync)(d.values.key||r.default.join(__dirname,`../private.pem`),`utf8`),a,d.values.output||a.replace(/\.stx$/,`.js`)),d.values.input&&(0,n.rmSync)(d.values.input);else if(e===`dev`||e===`develop`||!e){let e=typeof d.values.minify==`boolean`?d.values.minify:!1;await(0,i.build)({entry:a,format:d.values.format??`cjs`,platform:`node`,target:`node22`,watch:!0,minify:e})}})();
+const require_chunk = require('./chunk-BmvPcxpV.cjs');
+let node_util = require("node:util");
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path);
+let tsdown = require("tsdown");
+let node_crypto = require("node:crypto");
+let javascript_obfuscator = require("javascript-obfuscator");
+javascript_obfuscator = require_chunk.__toESM(javascript_obfuscator);
+
+//#region src/crypto.ts
+const MAGIC_BYTES = Buffer.from("STX", "utf8");
+const encrypt = (publicKey, inputPath, outputPath) => {
+	const aesKey = (0, node_crypto.randomBytes)(32);
+	const aesIv = (0, node_crypto.randomBytes)(16);
+	const code = (0, node_fs.readFileSync)(inputPath);
+	const cipher = (0, node_crypto.createCipheriv)("aes-256-cbc", aesKey, aesIv);
+	const encryptedCode = Buffer.concat([cipher.update(code), cipher.final()]);
+	const encryptedAesKey = (0, node_crypto.publicEncrypt)(publicKey, aesKey);
+	const output = Buffer.concat([
+		MAGIC_BYTES,
+		aesIv,
+		encryptedAesKey,
+		encryptedCode
+	]);
+	if (outputPath) (0, node_fs.writeFileSync)(outputPath, output);
+	return {
+		aesIv,
+		encryptedAesKey,
+		encryptedCode
+	};
+};
+const decrypt = (privateKey, inputPath, outputPath) => {
+	const data = (0, node_fs.readFileSync)(inputPath);
+	const magicSize = MAGIC_BYTES.byteLength;
+	if (!data.subarray(0, magicSize).equals(MAGIC_BYTES)) throw new Error("Incorrect file format");
+	const aesIvStart = magicSize;
+	const encryptedAesKeyStart = aesIvStart + 16;
+	const encryptedCodeStart = encryptedAesKeyStart + 512;
+	const aesIv = data.subarray(aesIvStart, encryptedAesKeyStart);
+	const encryptedAesKey = data.subarray(encryptedAesKeyStart, encryptedCodeStart);
+	const encryptedCode = data.subarray(encryptedCodeStart);
+	const decipher = (0, node_crypto.createDecipheriv)("aes-256-cbc", (0, node_crypto.privateDecrypt)(privateKey, encryptedAesKey), aesIv);
+	const result = Buffer.concat([decipher.update(encryptedCode), decipher.final()]).toString("utf8");
+	if (outputPath) (0, node_fs.writeFileSync)(outputPath, result);
+	return result;
+};
+
+//#endregion
+//#region src/obfuscation.ts
+const obfuscate = (inputPath, outputPath) => {
+	const code = (0, node_fs.readFileSync)(inputPath, "utf8");
+	console.log("Obfuscating...");
+	console.time("Obfuscation complete in");
+	const result = javascript_obfuscator.default.obfuscate(code, {
+		target: "node",
+		compact: true,
+		controlFlowFlattening: true,
+		controlFlowFlatteningThreshold: 1,
+		deadCodeInjection: true,
+		debugProtection: true,
+		identifierNamesGenerator: "hexadecimal",
+		numbersToExpressions: true,
+		selfDefending: true,
+		simplify: true,
+		splitStrings: true,
+		splitStringsChunkLength: 5,
+		stringArray: true,
+		stringArrayCallsTransform: true,
+		stringArrayCallsTransformThreshold: 1,
+		stringArrayEncoding: ["base64"],
+		stringArrayIndexShift: true,
+		stringArrayRotate: true,
+		stringArrayShuffle: true,
+		stringArrayWrappersCount: 2,
+		stringArrayWrappersChainedCalls: true,
+		stringArrayWrappersType: "function",
+		stringArrayThreshold: 1,
+		transformObjectKeys: true,
+		unicodeEscapeSequence: false
+	});
+	console.timeEnd("Obfuscation complete in");
+	const obfuscatedCode = result.getObfuscatedCode();
+	(0, node_fs.writeFileSync)(outputPath || inputPath, obfuscatedCode);
+	return obfuscatedCode;
+};
+
+//#endregion
+//#region src/cli.ts
+const args = (0, node_util.parseArgs)({
+	allowPositionals: true,
+	allowNegative: true,
+	options: {
+		input: {
+			type: "string",
+			short: "i",
+			description: "Path to the input file"
+		},
+		key: {
+			type: "string",
+			short: "k",
+			description: "Path to the key file (public for encrypt, private for decrypt)"
+		},
+		output: {
+			type: "string",
+			short: "o",
+			description: "Path to the output file"
+		},
+		format: {
+			type: "string",
+			short: "f",
+			description: "Output format"
+		},
+		watch: {
+			type: "boolean",
+			description: "Watch file changes"
+		},
+		minify: {
+			type: "boolean",
+			description: "Minify output"
+		},
+		obfuscate: {
+			type: "boolean",
+			description: "Obfuscate output"
+		},
+		encrypt: {
+			type: "boolean",
+			description: "Encrypt extension source code (.js will be packed inside .stx)"
+		},
+		decrypt: {
+			type: "boolean",
+			description: "Decrypt encrypted extension"
+		}
+	}
+});
+const getDefaultEntryFile = () => {
+	const searchDirs = [
+		process.cwd(),
+		node_path.default.join(process.cwd(), "src"),
+		node_path.default.join(process.cwd(), "lib")
+	];
+	for (const searchDir of searchDirs) {
+		const scripts = (0, node_fs.readdirSync)(searchDir).filter((file) => !file.endsWith(".d.ts")).filter((file) => new Set([
+			".ts",
+			".js",
+			".cjs",
+			".mjs"
+		]).has(node_path.default.extname(file)));
+		const getFilename = (file) => node_path.default.basename(file, node_path.default.extname(file));
+		const entry = scripts.find((file) => getFilename(file) === "index") || scripts.find((file) => getFilename(file) === "main") || scripts[0];
+		if (entry) return node_path.default.join(searchDir, entry);
+	}
+};
+(async () => {
+	const [command, ...commands] = args.positionals;
+	const entry = args.values.input || commands[0] || getDefaultEntryFile();
+	if (!entry) throw new Error("No entry file found");
+	if (command === "build" || command === "pack") {
+		const shouldMinify = typeof args.values.minify === "boolean" ? args.values.minify : true;
+		await (0, tsdown.build)({
+			entry: entry.replace(process.cwd(), ".").replace(node_path.default.sep, "/"),
+			format: args.values.format ?? "cjs",
+			platform: "node",
+			target: "node22",
+			watch: args.values.watch,
+			minify: shouldMinify,
+			inlineOnly: false
+		});
+		const ext = args.values.format ?? "cjs";
+		args.values.input = node_path.default.join(process.cwd(), "dist", node_path.default.basename(entry).replace(/\.ts$/, `.${ext}`));
+		const packageJson = require(node_path.default.join(process.cwd(), "package.json"));
+		if (typeof args.values.obfuscate === "boolean" ? args.values.obfuscate : packageJson.private) obfuscate(args.values.input, args.values.input);
+		if (args.values.encrypt || command === "pack") {
+			const key = (0, node_fs.readFileSync)(args.values.key || node_path.default.join(__dirname, "../public.pem"), "utf8");
+			const output = args.values.output || args.values.input.replace(/\.js$/, `-${packageJson.version}.stx`);
+			encrypt(key, args.values.input, output);
+			(0, node_fs.rmSync)(args.values.input);
+		}
+	} else if (command === "decrypt") {
+		decrypt((0, node_fs.readFileSync)(args.values.key || node_path.default.join(__dirname, "../private.pem"), "utf8"), entry, args.values.output || entry.replace(/\.stx$/, ".js"));
+		if (args.values.input) (0, node_fs.rmSync)(args.values.input);
+	} else if (command === "dev" || command === "develop" || !command) {
+		const shouldMinify = typeof args.values.minify === "boolean" ? args.values.minify : false;
+		await (0, tsdown.build)({
+			entry,
+			format: args.values.format ?? "cjs",
+			platform: "node",
+			target: "node22",
+			watch: true,
+			minify: shouldMinify
+		});
+	}
+})();
+
+//#endregion

package/dist/azt.mjs

@@ -1,2 +1,195 @@
 #!/usr/bin/env node
-import{n as e}from"./chunk-DtROqxiw.mjs";import{parseArgs as t}from"node:util";import{readFileSync as n,readdirSync as r,rmSync as i,writeFileSync as a}from"node:fs";import o from"node:path";import{build as s}from"tsdown";import{createCipheriv as c,createDecipheriv as l,privateDecrypt as u,publicEncrypt as d,randomBytes as f}from"node:crypto";import p from"javascript-obfuscator";const m=Buffer.from(`STX`,`utf8`),h=(e,t,r)=>{let i=f(32),o=f(16),s=n(t),l=c(`aes-256-cbc`,i,o),u=Buffer.concat([l.update(s),l.final()]),p=d(e,i),h=Buffer.concat([m,o,p,u]);return r&&a(r,h),{aesIv:o,encryptedAesKey:p,encryptedCode:u}},g=(e,t,r)=>{let i=n(t),o=m.byteLength;if(!i.subarray(0,o).equals(m))throw Error(`Incorrect file format`);let s=o,c=s+16,d=c+512,f=i.subarray(s,c),p=i.subarray(c,d),h=i.subarray(d),g=l(`aes-256-cbc`,u(e,p),f),_=Buffer.concat([g.update(h),g.final()]).toString(`utf8`);return r&&a(r,_),_},_=(e,t)=>{let r=n(e,`utf8`);console.log(`Obfuscating...`),console.time(`Obfuscation complete in`);let i=p.obfuscate(r,{target:`node`,compact:!0,controlFlowFlattening:!0,controlFlowFlatteningThreshold:1,deadCodeInjection:!0,debugProtection:!0,identifierNamesGenerator:`hexadecimal`,numbersToExpressions:!0,selfDefending:!0,simplify:!0,splitStrings:!0,splitStringsChunkLength:5,stringArray:!0,stringArrayCallsTransform:!0,stringArrayCallsTransformThreshold:1,stringArrayEncoding:[`base64`],stringArrayIndexShift:!0,stringArrayRotate:!0,stringArrayShuffle:!0,stringArrayWrappersCount:2,stringArrayWrappersChainedCalls:!0,stringArrayWrappersType:`function`,stringArrayThreshold:1,transformObjectKeys:!0,unicodeEscapeSequence:!1});console.timeEnd(`Obfuscation complete in`);let o=i.getObfuscatedCode();return a(t||e,o),o},v=t({allowPositionals:!0,allowNegative:!0,options:{input:{type:`string`,short:`i`,description:`Path to the input file`},key:{type:`string`,short:`k`,description:`Path to the key file (public for encrypt, private for decrypt)`},output:{type:`string`,short:`o`,description:`Path to the output file`},format:{type:`string`,short:`f`,description:`Output format`},watch:{type:`boolean`,description:`Watch file changes`},minify:{type:`boolean`,description:`Minify output`},obfuscate:{type:`boolean`,description:`Obfuscate output`},encrypt:{type:`boolean`,description:`Encrypt extension source code (.js will be packed inside .stx)`},decrypt:{type:`boolean`,description:`Decrypt encrypted extension`}}}),y=()=>{let e=[process.cwd(),o.join(process.cwd(),`src`),o.join(process.cwd(),`lib`)];for(let t of e){let e=r(t).filter(e=>!e.endsWith(`.d.ts`)).filter(e=>new Set([`.ts`,`.js`,`.cjs`,`.mjs`]).has(o.extname(e))),n=e=>o.basename(e,o.extname(e)),i=e.find(e=>n(e)===`index`)||e.find(e=>n(e)===`main`)||e[0];if(i)return o.join(t,i)}};(async()=>{let[t,...r]=v.positionals,a=v.values.input||r[0]||y();if(!a)throw Error(`No entry file found`);if(t===`build`||t===`pack`){let r=typeof v.values.minify==`boolean`?v.values.minify:!0;await s({entry:a.replace(process.cwd(),`.`).replace(o.sep,`/`),format:v.values.format??`cjs`,platform:`node`,target:`node22`,watch:v.values.watch,minify:r});let c=v.values.format??`cjs`;v.values.input=o.join(process.cwd(),`dist`,o.basename(a).replace(/\.ts$/,`.${c}`));let l=e(o.join(process.cwd(),`package.json`));if((typeof v.values.obfuscate==`boolean`?v.values.obfuscate:l.private)&&_(v.values.input,v.values.input),v.values.encrypt||t===`pack`){let e=n(v.values.key||o.join(__dirname,`../public.pem`),`utf8`),t=v.values.output||v.values.input.replace(/\.js$/,`-${l.version}.stx`);h(e,v.values.input,t),i(v.values.input)}}else if(t===`decrypt`)g(n(v.values.key||o.join(__dirname,`../private.pem`),`utf8`),a,v.values.output||a.replace(/\.stx$/,`.js`)),v.values.input&&i(v.values.input);else if(t===`dev`||t===`develop`||!t){let e=typeof v.values.minify==`boolean`?v.values.minify:!1;await s({entry:a,format:v.values.format??`cjs`,platform:`node`,target:`node22`,watch:!0,minify:e})}})();export{};
+import { n as __require } from "./chunk-DEt8GZDa.mjs";
+import { parseArgs } from "node:util";
+import { readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { build } from "tsdown";
+import { createCipheriv, createDecipheriv, privateDecrypt, publicEncrypt, randomBytes } from "node:crypto";
+import JavaScriptObfuscator from "javascript-obfuscator";
+
+//#region src/crypto.ts
+const MAGIC_BYTES = Buffer.from("STX", "utf8");
+const encrypt = (publicKey, inputPath, outputPath) => {
+	const aesKey = randomBytes(32);
+	const aesIv = randomBytes(16);
+	const code = readFileSync(inputPath);
+	const cipher = createCipheriv("aes-256-cbc", aesKey, aesIv);
+	const encryptedCode = Buffer.concat([cipher.update(code), cipher.final()]);
+	const encryptedAesKey = publicEncrypt(publicKey, aesKey);
+	const output = Buffer.concat([
+		MAGIC_BYTES,
+		aesIv,
+		encryptedAesKey,
+		encryptedCode
+	]);
+	if (outputPath) writeFileSync(outputPath, output);
+	return {
+		aesIv,
+		encryptedAesKey,
+		encryptedCode
+	};
+};
+const decrypt = (privateKey, inputPath, outputPath) => {
+	const data = readFileSync(inputPath);
+	const magicSize = MAGIC_BYTES.byteLength;
+	if (!data.subarray(0, magicSize).equals(MAGIC_BYTES)) throw new Error("Incorrect file format");
+	const aesIvStart = magicSize;
+	const encryptedAesKeyStart = aesIvStart + 16;
+	const encryptedCodeStart = encryptedAesKeyStart + 512;
+	const aesIv = data.subarray(aesIvStart, encryptedAesKeyStart);
+	const encryptedAesKey = data.subarray(encryptedAesKeyStart, encryptedCodeStart);
+	const encryptedCode = data.subarray(encryptedCodeStart);
+	const decipher = createDecipheriv("aes-256-cbc", privateDecrypt(privateKey, encryptedAesKey), aesIv);
+	const result = Buffer.concat([decipher.update(encryptedCode), decipher.final()]).toString("utf8");
+	if (outputPath) writeFileSync(outputPath, result);
+	return result;
+};
+
+//#endregion
+//#region src/obfuscation.ts
+const obfuscate = (inputPath, outputPath) => {
+	const code = readFileSync(inputPath, "utf8");
+	console.log("Obfuscating...");
+	console.time("Obfuscation complete in");
+	const result = JavaScriptObfuscator.obfuscate(code, {
+		target: "node",
+		compact: true,
+		controlFlowFlattening: true,
+		controlFlowFlatteningThreshold: 1,
+		deadCodeInjection: true,
+		debugProtection: true,
+		identifierNamesGenerator: "hexadecimal",
+		numbersToExpressions: true,
+		selfDefending: true,
+		simplify: true,
+		splitStrings: true,
+		splitStringsChunkLength: 5,
+		stringArray: true,
+		stringArrayCallsTransform: true,
+		stringArrayCallsTransformThreshold: 1,
+		stringArrayEncoding: ["base64"],
+		stringArrayIndexShift: true,
+		stringArrayRotate: true,
+		stringArrayShuffle: true,
+		stringArrayWrappersCount: 2,
+		stringArrayWrappersChainedCalls: true,
+		stringArrayWrappersType: "function",
+		stringArrayThreshold: 1,
+		transformObjectKeys: true,
+		unicodeEscapeSequence: false
+	});
+	console.timeEnd("Obfuscation complete in");
+	const obfuscatedCode = result.getObfuscatedCode();
+	writeFileSync(outputPath || inputPath, obfuscatedCode);
+	return obfuscatedCode;
+};
+
+//#endregion
+//#region src/cli.ts
+const args = parseArgs({
+	allowPositionals: true,
+	allowNegative: true,
+	options: {
+		input: {
+			type: "string",
+			short: "i",
+			description: "Path to the input file"
+		},
+		key: {
+			type: "string",
+			short: "k",
+			description: "Path to the key file (public for encrypt, private for decrypt)"
+		},
+		output: {
+			type: "string",
+			short: "o",
+			description: "Path to the output file"
+		},
+		format: {
+			type: "string",
+			short: "f",
+			description: "Output format"
+		},
+		watch: {
+			type: "boolean",
+			description: "Watch file changes"
+		},
+		minify: {
+			type: "boolean",
+			description: "Minify output"
+		},
+		obfuscate: {
+			type: "boolean",
+			description: "Obfuscate output"
+		},
+		encrypt: {
+			type: "boolean",
+			description: "Encrypt extension source code (.js will be packed inside .stx)"
+		},
+		decrypt: {
+			type: "boolean",
+			description: "Decrypt encrypted extension"
+		}
+	}
+});
+const getDefaultEntryFile = () => {
+	const searchDirs = [
+		process.cwd(),
+		path.join(process.cwd(), "src"),
+		path.join(process.cwd(), "lib")
+	];
+	for (const searchDir of searchDirs) {
+		const scripts = readdirSync(searchDir).filter((file) => !file.endsWith(".d.ts")).filter((file) => new Set([
+			".ts",
+			".js",
+			".cjs",
+			".mjs"
+		]).has(path.extname(file)));
+		const getFilename = (file) => path.basename(file, path.extname(file));
+		const entry = scripts.find((file) => getFilename(file) === "index") || scripts.find((file) => getFilename(file) === "main") || scripts[0];
+		if (entry) return path.join(searchDir, entry);
+	}
+};
+(async () => {
+	const [command, ...commands] = args.positionals;
+	const entry = args.values.input || commands[0] || getDefaultEntryFile();
+	if (!entry) throw new Error("No entry file found");
+	if (command === "build" || command === "pack") {
+		const shouldMinify = typeof args.values.minify === "boolean" ? args.values.minify : true;
+		await build({
+			entry: entry.replace(process.cwd(), ".").replace(path.sep, "/"),
+			format: args.values.format ?? "cjs",
+			platform: "node",
+			target: "node22",
+			watch: args.values.watch,
+			minify: shouldMinify,
+			inlineOnly: false
+		});
+		const ext = args.values.format ?? "cjs";
+		args.values.input = path.join(process.cwd(), "dist", path.basename(entry).replace(/\.ts$/, `.${ext}`));
+		const packageJson = __require(path.join(process.cwd(), "package.json"));
+		if (typeof args.values.obfuscate === "boolean" ? args.values.obfuscate : packageJson.private) obfuscate(args.values.input, args.values.input);
+		if (args.values.encrypt || command === "pack") {
+			const key = readFileSync(args.values.key || path.join(__dirname, "../public.pem"), "utf8");
+			const output = args.values.output || args.values.input.replace(/\.js$/, `-${packageJson.version}.stx`);
+			encrypt(key, args.values.input, output);
+			rmSync(args.values.input);
+		}
+	} else if (command === "decrypt") {
+		decrypt(readFileSync(args.values.key || path.join(__dirname, "../private.pem"), "utf8"), entry, args.values.output || entry.replace(/\.stx$/, ".js"));
+		if (args.values.input) rmSync(args.values.input);
+	} else if (command === "dev" || command === "develop" || !command) {
+		const shouldMinify = typeof args.values.minify === "boolean" ? args.values.minify : false;
+		await build({
+			entry,
+			format: args.values.format ?? "cjs",
+			platform: "node",
+			target: "node22",
+			watch: true,
+			minify: shouldMinify
+		});
+	}
+})();
+
+//#endregion
+export {  };

package/dist/chunk-BmvPcxpV.cjs

@@ -0,0 +1,41 @@
+//#region \0rolldown/runtime.js
+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 __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+Object.defineProperty(exports, '__commonJSMin', {
+  enumerable: true,
+  get: function () {
+    return __commonJSMin;
+  }
+});
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});

package/dist/chunk-DEt8GZDa.mjs

@@ -0,0 +1,8 @@
+import { createRequire } from "node:module";
+
+//#region \0rolldown/runtime.js
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+export { __require as n, __commonJSMin as t };