import { readFile } from 'node:fs/promises';

import querystring from 'node:querystring';

import { inflateSync } from 'node:zlib';

import { Command } from './Command.js';

import { ErrorCode } from './ErrorCode.js';

import { Language } from './Language.js';

import { NewLine } from './NewLine.js';

/**

* Stateful HTTP client: pass the activation key to the constructor, configure other options via

* setters, then {@link StringEncrypt#send}.

*

* POST field `code` (activation key) is the value given at construction (empty string = demo).

*

* For {@link Command.Encrypt} with {@link StringEncrypt#setCompression}`(true)`, the API returns

* `source` as base64-encoded gzip of the decryptor text. {@link StringEncrypt#send} decodes that

* automatically so `source` is always plain text on success (unless

* {@link StringEncrypt#setDecompressEncryptSource}`(false)`).

*/

export class StringEncrypt {

static DEFAULT_API_URL = 'https://www.stringencrypt.com/api.php';

/** @type {boolean} */

#preferCurl = false;

/** When true (default), decompress `source` after successful encrypt+compression responses. */

#decompressEncryptSource = true;

/** @type {string | null} */

#command = null;

/** Activation code sent as `code` (empty = demo). */

#apiKey = '';

// —— encrypt ——

/** @type {string} */

#label = 'Label';

/** @type {string | null} */

#inputString = null;

/** @type {Buffer | null} */

#inputBytes = null;

/** @type {boolean} */

#compression = false;

/** @type {string} */

#language = Language.Php;

/** `false`, or highlight mode string such as `geshi` / `js` when supported server-side. */

#highlight = false;

/** @type {number} */

#cmdMin = 1;

/** @type {number} */

#cmdMax = 3;

/** @type {boolean} */

#local = false;

/** @type {boolean} */

#unicode = true;

/** @type {string} */

#langLocale = 'en_US.utf8';

/** @type {string} */

#ansiEncoding = 'WINDOWS-1250';

/** @type {string} */

#newLines = NewLine.Lf;

/** @type {string | null} */

#template = null;

/** @type {boolean} */

#returnTemplate = false;

/** @type {boolean} */

#includeTags = false;

/** @type {boolean} */

#includeExample = false;

/** When true, server emits a trace comment block above the encrypted array (hashes, VM JSON). */

#includeDebugComments = false;

/**

* @param {string} [apiKey]

* @param {boolean} [preferCurl] Ignored; the JS client always uses `fetch` (kept for parity with the PHP SDK).

*/

constructor(apiKey = '', preferCurl = false) {

this.#apiKey = apiKey;

this.#preferCurl = preferCurl;

}

/**

* Activation status and limits for the activation key passed to the constructor.

*

* @returns {Promise<Record<string, unknown> | false>} Parsed JSON on success, or false on transport/parse failure.

*/

async isDemo() {

const previousCommand = this.#command;

this.setCommand(Command.IsDemo);

const result = await this.send();

this.#command = previousCommand;

return result;

}

/**

* Encrypt raw file contents (binary). Uses other encrypt options already set on this client.

*

* @param {string} filePath

* @param {string} label

* @returns {Promise<Record<string, unknown> | false>}

*/

async encryptFileContents(filePath, label) {

let raw;

try {

raw = await readFile(filePath);

} catch {

return false;

}

if (!raw.length) {

return false;

}

const saved = {

command: this.#command,

inputString: this.#inputString,

inputBytes: this.#inputBytes,

label: this.#label,

};

this.setCommand(Command.Encrypt).setBytes(raw).setLabel(label);

const result = await this.send();

this.#command = saved.command;

this.#inputString = saved.inputString;

this.#inputBytes = saved.inputBytes;

this.#label = saved.label;

return result;

}

/**

* Encrypt a UTF-8 string. Uses other encrypt options already set on this client (language,

* compression, cmd range, etc.).

*

* @param {string} string

* @param {string} label

* @returns {Promise<Record<string, unknown> | false>}

*/

async encryptString(string, label) {

const saved = {

command: this.#command,

inputString: this.#inputString,

inputBytes: this.#inputBytes,

label: this.#label,

};

this.setCommand(Command.Encrypt).setString(string).setLabel(label);

const result = await this.send();

this.#command = saved.command;

this.#inputString = saved.inputString;

this.#inputBytes = saved.inputBytes;

this.#label = saved.label;

return result;

}

getPreferCurl() {

return this.#preferCurl;

}

/** @param {boolean} preferCurl */

setPreferCurl(/sitelet?url=https%3A%2F%2Fgithub.com%2FPELock%2FStringEncrypt-JavaScript%2Fblob%2Fmain%2Fsrc%2FpreferCurl) {

this.#preferCurl = preferCurl;

return this;

}

getDecompressEncryptSource() {

return this.#decompressEncryptSource;

}

/**

* Disable automatic gzip+base64 decoding of `source` for encrypt+compression responses

* if you need the raw payload from the API.

*

* @param {boolean} decompressEncryptSource

*/

setDecompressEncryptSource(decompressEncryptSource) {

this.#decompressEncryptSource = decompressEncryptSource;

return this;

}

getCommand() {

return this.#command;

}

/** @param {string} command One of {@link Command} values. */

setCommand(command) {

this.#command = command;

return this;

}

getLabel() {

return this.#label;

}

/** @param {string} label */

setLabel(label) {

this.#label = label;

return this;

}

/** UTF-8 text input; clears raw bytes input. */

setString(string) {

this.#inputString = string;

this.#inputBytes = null;

return this;

}

/** Raw binary input; clears string input. */

setBytes(bytes) {

this.#inputBytes = Buffer.isBuffer(bytes) ? bytes : Buffer.from(bytes);

this.#inputString = null;

return this;

}

getCompression() {

return this.#compression;

}

/** @param {boolean} compression */

setCompression(compression) {

this.#compression = compression;

return this;

}

getLanguage() {

return this.#language;

}

/** @param {string} language One of {@link Language} values. */

setLanguage(language) {

this.#language = language;

return this;

}

getHighlight() {

return this.#highlight;

}

/** @param {string | boolean} highlight */

setHighlight(highlight) {

this.#highlight = highlight;

return this;

}

getCmdMin() {

return this.#cmdMin;

}

/** @param {number} cmdMin */

setCmdMin(cmdMin) {

this.#cmdMin = cmdMin;

return this;

}

getCmdMax() {

return this.#cmdMax;

}

/** @param {number} cmdMax */

setCmdMax(cmdMax) {

this.#cmdMax = cmdMax;

return this;

}

getLocal() {

return this.#local;

}

/** @param {boolean} local */

setLocal(local) {

this.#local = local;

return this;

}

getUnicode() {

return this.#unicode;

}

/** @param {boolean} unicode */

setUnicode(unicode) {

this.#unicode = unicode;

return this;

}

getLangLocale() {

return this.#langLocale;

}

/** @param {string} langLocale */

setLangLocale(langLocale) {

this.#langLocale = langLocale;

return this;

}

getAnsiEncoding() {

return this.#ansiEncoding;

}

/** @param {string} ansiEncoding */

setAnsiEncoding(ansiEncoding) {

this.#ansiEncoding = ansiEncoding;

return this;

}

getNewLines() {

return this.#newLines;

}

/** @param {string} newLines One of {@link NewLine} values. */

setNewLines(newLines) {

this.#newLines = newLines;

return this;

}

getTemplate() {

return this.#template;

}

/** @param {string | null} template */

setTemplate(template) {

this.#template = template;

return this;

}

getReturnTemplate() {

return this.#returnTemplate;

}

/** @param {boolean} returnTemplate */

setReturnTemplate(returnTemplate) {

this.#returnTemplate = returnTemplate;

return this;

}

getIncludeTags() {

return this.#includeTags;

}

/** @param {boolean} includeTags */

setIncludeTags(includeTags) {

this.#includeTags = includeTags;

return this;

}

getIncludeExample() {

return this.#includeExample;

}

/** @param {boolean} includeExample */

setIncludeExample(includeExample) {

this.#includeExample = includeExample;

return this;

}

getIncludeDebugComments() {

return this.#includeDebugComments;

}

/** @param {boolean} includeDebugComments */

setIncludeDebugComments(includeDebugComments) {

this.#includeDebugComments = includeDebugComments;

return this;

}

/**

* Reset request fields to defaults (reuse the same client for another call).

*/

reset() {

this.#command = null;

this.#label = '$label';

this.#inputString = null;

this.#inputBytes = null;

this.#compression = false;

this.#language = Language.Php;

this.#highlight = false;

this.#cmdMin = 1;

this.#cmdMax = 3;

this.#local = false;

this.#unicode = true;

this.#langLocale = 'en_US.utf8';

this.#ansiEncoding = 'WINDOWS-1250';

this.#newLines = NewLine.Lf;

this.#template = null;

this.#returnTemplate = false;

this.#includeTags = false;

this.#includeExample = false;

this.#includeDebugComments = false;

return this;

}

/**

* Build the POST body the client would send (for debugging and tests).

*

* @returns {Record<string, string | number | boolean | Buffer>}

*/

toRequestArray() {

if (this.#command === null) {

throw new Error('Command must be set (use setCommand()).');

}

if (this.#command === Command.Info) {

return this.#buildInfoParams();

}

if (this.#command === Command.IsDemo) {

return this.#buildIsDemoParams();

}

if (this.#command === Command.Encrypt) {

return this.#buildEncryptParams();

}

throw new Error('Unknown command.');

}

/**

* Send the request and return decoded JSON, or false on transport / JSON failure.

*

* @returns {Promise<Record<string, unknown> | false>}

*/

async send() {

const params = this.#formEncodeParams(this.toRequestArray());

const raw = await this.#post(StringEncrypt.DEFAULT_API_URL, params);

if (raw === false || raw === '') {

return false;

}

let decoded;

try {

decoded = JSON.parse(raw);

} catch {

return false;

}

if (decoded === null || typeof decoded !== 'object' || Array.isArray(decoded)) {

return false;

}

return this.#applyDecryptorSourceDecompression(/** @type {Record<string, unknown>} */ (decoded));

}

/**

* Replace `source` with plain text when the request used compression (API returns

* base64(gzip(decryptor source))).

*

* @param {Record<string, unknown>} response

*/

#applyDecryptorSourceDecompression(response) {

if (this.#command !== Command.Encrypt || !this.#compression || !this.#decompressEncryptSource) {

return response;

}

if (response.error !== ErrorCode.SUCCESS) {

return response;

}

const src = response.source;

if (typeof src !== 'string') {

return response;

}

let binary;

try {

binary = Buffer.from(src, 'base64');

} catch {

return response;

}

let plain;

try {

plain = inflateSync(binary);

} catch {

return response;

}

return { ...response, source: plain.toString('utf8') };

}

/** @returns {Record<string, string | number | boolean>} */

#buildInfoParams() {

return {

command: Command.Info,

code: this.#apiKey,

};

}

/** @returns {Record<string, string | number | boolean>} */

#buildIsDemoParams() {

return {

command: Command.IsDemo,

code: this.#apiKey,

};

}

/** @returns {Record<string, string | number | boolean | Buffer>} */

#buildEncryptParams() {

/** @type {Record<string, string | number | boolean | Buffer>} */

const p = {

command: Command.Encrypt,

code: this.#apiKey,

label: this.#label,

compression: this.#compression,

lang: this.#language,

cmd_min: this.#cmdMin,

cmd_max: this.#cmdMax,

local: this.#local,

unicode: this.#unicode,

lang_locale: this.#langLocale,

ansi_encoding: this.#ansiEncoding,

new_lines: this.#newLines,

return_template: this.#returnTemplate,

include_tags: this.#includeTags,

include_example: this.#includeExample,

include_debug_comments: this.#includeDebugComments,

};

if (this.#inputString !== null) {

p.string = this.#inputString;

} else if (this.#inputBytes !== null) {

p.bytes = this.#inputBytes;

}

if (this.#highlight !== false) {

p.highlight = this.#highlight;

}

if (this.#template !== null) {

p.template = this.#template;

}

return p;

}

/**

* Match PHP `http_build_query`: booleans become "0"/"1"; `Buffer` values (e.g. `bytes`) become

* a byte-per-character string so `querystring.stringify` percent-encodes like PHP.

*

* @param {Record<string, string | number | boolean | Buffer>} data

*/

#formEncodeParams(data) {

/** @type {Record<string, string | number>} */

const flat = {};

for (const [key, value] of Object.entries(data)) {

if (typeof value === 'boolean') {

flat[key] = value ? 1 : 0;

} else if (Buffer.isBuffer(value)) {

flat[key] = value.toString('latin1');

} else {

flat[key] = value;

}

}

return querystring.stringify(flat);

}

/**

* @param {string} url

* @param {string} body

* @returns {Promise<string | false>}

*/

async #post(url, body) {

try {

const res = await fetch(url, {

method: 'POST',

headers: {

'Content-Type': 'application/x-www-form-urlencoded',

'User-Agent': 'pelock/stringencrypt (+https://www.stringencrypt.com)',

},

body,

});

const text = await res.text();

return text;

} catch {

return false;

}

}

}