/** Gets string length. */

static async strlen(ctx, strArg) {

const str = await ctx.toVal(strArg);

if (Buffer.isBuffer(str))

return str.length;

return String(str ?? "").length;

}

/** Count the number of substring occurrences. */

static async substr_count(ctx, haystackArg, needleArg, offsetArg, lengthArg) {

const rawOffset = await offsetArg?.get();

const rawLength = await lengthArg?.get();

const offset = Number(rawOffset) || 0;

const length = rawLength !== undefined ? Number(rawLength) : undefined;

const source = String(await haystackArg?.get() ?? "").slice(offset, length === undefined ? undefined : offset + length);

const search = String(await needleArg?.get() ?? "");

if (!search)

return 0;

let count = 0;

let position = 0;

while ((position = source.indexOf(search, position)) !== -1) {

count++;

position += search.length;

}

return count;

}

/** Return part of a string. */

static async substr(ctx, strArg, startArg, lengthArg) {

const s = await ctx.str(await ctx.toVal(strArg));

const startVal = await ctx.toVal(startArg);

let start = Number(startVal) || 0;

const lenVal = await ctx.toVal(lengthArg);

const length = lenVal !== undefined && lenVal !== null ? Number(lenVal) : undefined;

if (start < 0)

start = s.length + start;

if (length !== undefined) {

if (length < 0)

return s.substring(start, s.length + length);

return s.substring(start, start + length);

}

return s.substring(start);

}

/** Replace text within a portion of a string. */

static async substr_replace(ctx, subjectArg, replacementArg, offsetArg, lengthArg) {

const subject = await subjectArg?.get();

const replacement = await replacementArg?.get();

const offset = await offsetArg?.get();

const length = await lengthArg?.get();

if (Array.isArray(subject)) {

const results = [];

for (let index = 0; index < subject.length; index++) {

results.push(String(await StringRuntime.substr_replace(ctx, new PHPLiteral(subject[index]), new PHPLiteral(Array.isArray(replacement) ? replacement[index] ?? "" : replacement), new PHPLiteral(Array.isArray(offset) ? offset[index] ?? 0 : offset), new PHPLiteral(Array.isArray(length) ? length[index] : length))));

}

return results;

}

const source = String(subject ?? "");

const startValue = Math.trunc(Number(offset) || 0);

const start = Math.max(0, Math.min(source.length, startValue < 0 ? source.length + startValue : startValue));

const lengthValue = length == null ? source.length : Math.trunc(Number(length) || 0);

const end = lengthValue < 0

? Math.max(start, source.length + lengthValue)

: Math.min(source.length, start + lengthValue);

const inserted = Array.isArray(replacement) ? replacement[0] ?? "" : replacement ?? "";

return source.slice(0, start) + String(inserted) + source.slice(end);

}

/** Find the position of the first occurrence of a substring in a string. */

static async strpos(ctx, haystackArg, needleArg, offsetArg) {

const haystack = String(await haystackArg?.get() ?? "");

const needle = String(await needleArg?.get() ?? "");

const offset = Number(await offsetArg?.get()) || 0;

const idx = haystack.indexOf(needle, offset);

return idx === -1 ? false : idx;

}

/** Find the position of the first occurrence of a case-insensitive substring in a string. */

static async stripos(ctx, haystackArg, needleArg, offsetArg) {

const haystack = String(await haystackArg?.get() ?? "").toLowerCase();

const needle = String(await needleArg?.get() ?? "").toLowerCase();

const offset = Number(await offsetArg?.get()) || 0;

const idx = haystack.indexOf(needle, offset);

return idx === -1 ? false : idx;

}

/** Find the position of the last occurrence of a substring in a string. */

static async strrpos(ctx, haystackArg, needleArg, offsetArg) {

const haystack = String(await haystackArg?.get() ?? "");

const needle = String(await needleArg?.get() ?? "");

const offset = Number(await offsetArg?.get()) || 0;

const idx = haystack.lastIndexOf(needle, offset || undefined);

return idx === -1 ? false : idx;

}

/** Find the position of the last occurrence of a case-insensitive substring in a string. */

static async strripos(ctx, haystackArg, needleArg, offsetArg) {

const haystack = String(await haystackArg?.get() ?? "").toLowerCase();

const needle = String(await needleArg?.get() ?? "").toLowerCase();

const offset = Number(await offsetArg?.get()) || 0;

const idx = haystack.lastIndexOf(needle, offset || undefined);

return idx === -1 ? false : idx;

}

/** Find the first occurrence of a string. */

static async strstr(ctx, haystackArg, needleArg, beforeNeedleArg) {

const s = String(await haystackArg?.get() ?? "");

const n = String(await needleArg?.get() ?? "");

const beforeNeedle = Boolean(await beforeNeedleArg?.get());

const idx = s.indexOf(n);

if (idx === -1)

return false;

return beforeNeedle ? s.substring(0, idx) : s.substring(idx);

}

/** Find the first case-insensitive occurrence of a string. */

static async stristr(ctx, haystackArg, needleArg, beforeNeedleArg) {

const s = String(await haystackArg?.get() ?? "");

const n = String(await needleArg?.get() ?? "");

const beforeNeedle = Boolean(await beforeNeedleArg?.get());

const idx = s.toLowerCase().indexOf(n.toLowerCase());

if (idx === -1)

return false;

return beforeNeedle ? s.substring(0, idx) : s.substring(idx);

}

/**

static async str_replace(ctx, searchArg, replaceArg, subjectArg, countRef) {

const search = await searchArg?.get();

const replace = await replaceArg?.get();

const subject = await subjectArg?.get();

var replaceCount = 0;

if (Array.isArray(subject)) {

const res = await Promise.all(subject.map((s) => StringRuntime.str_replace(ctx, new PHPLiteral(search), new PHPLiteral(replace), new PHPLiteral(s), countRef)));

if (countRef && typeof countRef.set === "function")

await countRef.set(replaceCount);

return res;

}

let s = String(subject ?? "");

const searches = Array.isArray(search) ? search : [search];

const replaces = Array.isArray(replace) ? replace : [replace];

searches.forEach((sch, i) => {

const rep = replaces[i] !== undefined ? replaces[i] : replaces[replaces.length - 1] || "";

if (String(sch))

replaceCount += s.split(String(sch)).length - 1;

s = s.split(String(sch)).join(String(rep));

});

if (countRef && typeof countRef.set === "function") {

await countRef.set(replaceCount);

}

return s;

}

/** Translate characters or replace substrings. */

static async strtr(ctx, subjectArg, fromArg, toArg) {

let result = String(await subjectArg?.get() ?? "");

const from = await fromArg?.get();

const to = await toArg?.get();

if (from && typeof from === "object" && !Array.isArray(from)) {

for (const [search, replacement] of Object.entries(from))

result = result.split(search).join(String(replacement));

return result;

}

const search = String(from ?? "");

const replacement = String(to ?? "");

return result.split(search).join(replacement);

}

/** Case-insensitive version of str_replace. */

static async str_ireplace(ctx, searchArg, replaceArg, subjectArg, countRef) {

const search = await searchArg?.get();

const replace = await replaceArg?.get();

const subject = await subjectArg?.get();

if (Array.isArray(subject)) {

return Promise.all(subject.map((s) => StringRuntime.str_ireplace(ctx, new PHPLiteral(search), new PHPLiteral(replace), new PHPLiteral(s), countRef)));

}

let s = String(subject ?? "");

const searches = Array.isArray(search) ? search : [search];

const replaces = Array.isArray(replace) ? replace : [replace];

searches.forEach((sch, i) => {

const rep = replaces[i] !== undefined ? replaces[i] : replaces[replaces.length - 1] || "";

const regex = new RegExp(String(sch).replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&"), "gi");

s = s.replace(regex, String(rep));

});

return s;

}

/** Return a formatted string. */

static async sprintf(ctx, fmtArg, ...args) {

const fmt = String(await fmtArg?.get() ?? "");

let argIndex = 0;

const formatPattern = /%(\d+\$)?([-+0' ])?(\d+)?(\.\d+)?([%sbcdeufFoghxX])/g;

let output = "";

let previousIndex = 0;

for (const match of fmt.matchAll(formatPattern)) {

const [whole, param, flags, width, precision, type] = match;

const matchIndex = match.index;

output += fmt.slice(previousIndex, matchIndex);

previousIndex = matchIndex + whole.length;

if (type === "%") {

output += "%";

continue;

}

let idx = argIndex;

if (param) {

idx = parseInt(param.slice(0, -1), 10) - 1;

}

else {

argIndex++;

}

const val = await args[idx]?.get();

let str = "";

const numWidth = width ? parseInt(width, 10) : 0;

const padChar = flags && flags.includes("0") ? "0" : " ";

const leftAlign = flags && flags.includes("-");

if (type === "s") {

str = String(val ?? "");

if (precision) {

str = str.slice(0, parseInt(precision.slice(1), 10));

}

}

else if (type === "d" || type === "i" || type === "u") {

const num = Math.trunc(Number(val) || 0);

str = String(type === "u" ? Math.abs(num) : num);

}

else if (type === "f" || type === "F") {

const num = Number(val) || 0;

const prec = precision ? parseInt(precision.slice(1), 10) : 6;

str = num.toFixed(prec);

}

else if (type === "x") {

str = (parseInt(val, 10) || 0).toString(16);

}

else if (type === "X") {

str = (parseInt(val, 10) || 0).toString(16).toUpperCase();

}

else if (type === "b") {

str = (parseInt(val, 10) || 0).toString(2);

}

else if (type === "o") {

str = (parseInt(val, 10) || 0).toString(8);

}

else if (type === "c") {

str = String.fromCharCode(parseInt(val, 10) || 0);

}

else {

str = String(val ?? "");

}

if (str.length < numWidth) {

const padLen = numWidth - str.length;

if (padLen > 1000000)

throw new PHPWarning("str_pad(): padding length is too large");

const padding = padChar.repeat(padLen);

str = leftAlign ? str + padding : padding + str;

}

output += str;

}

return output + fmt.slice(previousIndex);

}

/** Output a formatted string. */

static async printf(ctx, fmtArg, ...args) {

const output = await StringRuntime.sprintf(ctx, fmtArg, ...args);

await ctx.echo(output);

return output.length;

}

/** Split a string by a string. */

static async explode(ctx, delimiterArg, stringArg, limitArg) {

const delimiter = String(await delimiterArg?.get() ?? "");

const string = String(await stringArg?.get() ?? "");

const rawLimit = await limitArg?.get();

const limit = rawLimit !== undefined ? Number(rawLimit) : undefined;

const res = string.split(delimiter);

if (limit !== undefined && limit > 0 && res.length > limit) {

return [...res.slice(0, limit - 1), res.slice(limit - 1).join(delimiter)];

}

return res;

}

/** Join array elements with a string. */

static async implode(ctx, glueArg, piecesArg) {

const val1 = await glueArg?.get();

const val2 = await piecesArg?.get();

let glue = "";

let pieces = [];

if (Array.isArray(val1) || (val1 && typeof val1 === "object" && (val1.constructor === Object || val1.constructor === Array))) {

pieces = Array.isArray(val1) ? val1 : Object.values(val1);

glue = val2 !== undefined && val2 !== null ? String(val2) : "";

}

else if (Array.isArray(val2) || (val2 && typeof val2 === "object" && (val2.constructor === Object || val2.constructor === Array))) {

pieces = Array.isArray(val2) ? val2 : Object.values(val2);

glue = val1 !== undefined && val1 !== null ? String(val1) : "";

}

return (await Promise.all(pieces.map(async (piece) => String(await ctx.toVal(piece) ?? "")))).join(glue);

}

/** Strip whitespace (or other characters) from the beginning and end of a string. */

static async trim(ctx, strArg, charlistArg) {

const s = await ctx.str(await strArg?.get());

const charlist = await charlistArg?.get();

if (!charlist)

return s.trim();

const mask = String(charlist).replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");

return s.replace(new RegExp(`^[${mask}]+|[${mask}]+$`, "g"), "");

}

/** Strip whitespace (or other characters) from the beginning of a string. */

static async ltrim(ctx, strArg, charlistArg) {

const s = await ctx.str(await strArg?.get());

const charlist = await charlistArg?.get();

if (!charlist)

return s.trimStart();

const mask = String(charlist).replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");

return s.replace(new RegExp(`^[${mask}]+`, "g"), "");

}

/** Strip whitespace (or other characters) from the end of a string. */

static async rtrim(ctx, strArg, charlistArg) {

const s = await ctx.str(await strArg?.get());

const charlist = await charlistArg?.get();

if (!charlist)

return s.trimEnd();

const mask = String(charlist).replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");

return s.replace(new RegExp(`[${mask}]+$`, "g"), "");

}

/** Strip HTML and PHP tags from a string. */

static async strip_tags(ctx, strArg, allowable_tagsArg) {

const s = String(await strArg?.get() ?? "");

const allowable_tags = await allowable_tagsArg?.get();

if (!allowable_tags) {

return s.replace(/<!--[\s\S]*?-->|<\?(?:php)?[\s\S]*?\?>|<[^>]*>/gi, "");

}

const tags = Array.isArray(allowable_tags)

? allowable_tags

: String(allowable_tags).match(/<[a-z0-9]+>/gi) || [];

const allowed = new Set(tags.map((t) => t.replace(/[<>]/g, "").toLowerCase()));

return s.replace(/<!--[\s\S]*?-->|<\?(?:php)?[\s\S]*?\?>|<(?:\/)?([a-z0-9]+)[^>]*>/gi, (match, tagName) => {

if (tagName && allowed.has(tagName.toLowerCase()))

return match;

return "";

});

}

/** Make a string lowercase. */

static async strtolower(ctx, strArg) { return String(await strArg?.get() ?? "").toLowerCase(); }

/** Make a string uppercase. */

static async strtoupper(ctx, strArg) { return String(await strArg?.get() ?? "").toUpperCase(); }

/** Make a string's first character uppercase. */

static async ucfirst(ctx, strArg) {

const s = String(await strArg?.get() ?? "");

return s.charAt(0).toUpperCase() + s.slice(1);

}

/** Make a string's first character lowercase. */

static async lcfirst(ctx, strArg) {

const s = String(await strArg?.get() ?? "");

return s.charAt(0).toLowerCase() + s.slice(1);

}

/** Uppercase the first character of each word in a string. */

static async ucwords(ctx, strArg) {

return String(await strArg?.get() ?? "").replace(/\b\w/g, (l) => l.toUpperCase());

}

/** Binary safe string comparison. */

static async strcmp(ctx, str1Arg, str2Arg) {

const s1 = String(await str1Arg?.get() ?? "");

const s2 = String(await str2Arg?.get() ?? "");

return s1.localeCompare(s2);

}

/** Binary safe string comparison of the first n characters. */

static async strncmp(ctx, str1Arg, str2Arg, lengthArg) {

const length = Number(await lengthArg?.get()) || 0;

return StringRuntime.strcmp(ctx, new PHPLiteral(String(await str1Arg?.get() ?? "").slice(0, length)), new PHPLiteral(String(await str2Arg?.get() ?? "").slice(0, length)));

}

/** Binary safe case-insensitive string comparison. */

static async strcasecmp(ctx, str1Arg, str2Arg) {

const s1 = String(await str1Arg?.get() ?? "").toLowerCase();

const s2 = String(await str2Arg?.get() ?? "").toLowerCase();

if (s1 === s2)

return 0;

return s1 < s2 ? -1 : 1;

}

/** Binary safe case-insensitive string comparison of the first n characters. */

static async strncasecmp(ctx, str1Arg, str2Arg, lengthArg) {

const length = Number(await lengthArg?.get()) || 0;

return StringRuntime.strcasecmp(ctx, new PHPLiteral(String(await str1Arg?.get() ?? "").slice(0, length)), new PHPLiteral(String(await str2Arg?.get() ?? "").slice(0, length)));

}

static async strnatcmp(ctx, str1Arg, str2Arg) {

const s1 = await ctx.str(await str1Arg?.get());

const s2 = await ctx.str(await str2Arg?.get());

return s1.localeCompare(s2, undefined, { numeric: true });

}

static async strnatcasecmp(ctx, str1Arg, str2Arg) {

const s1 = (await ctx.str(await str1Arg?.get())).toLowerCase();

const s2 = (await ctx.str(await str2Arg?.get())).toLowerCase();

return s1.localeCompare(s2, undefined, { numeric: true, sensitivity: "base" });

}

/** Quote string with slashes. */

static async addslashes(ctx, strArg) {

return (await ctx.str(strArg)).replace(/[\\\"']/g, "\\$&").replace(/\u0000/g, "\\0");

}

static async addcslashes(ctx, strArg, charlistArg) {

const string = String(await strArg?.get() ?? "");

const list = String(await charlistArg?.get() ?? "");

const chars = new Set();

for (let i = 0; i < list.length; i++) {

if (list[i] === "\\" && i + 1 < list.length) {

chars.add(list[++i]);

}

else if (i + 3 < list.length && list[i + 1] === "." && list[i + 2] === ".") {

const start = list.charCodeAt(i);

const end = list.charCodeAt(i + 3);

for (let c = start; c <= end; c++) {

chars.add(String.fromCharCode(c));

}

i += 3;

}

else {

chars.add(list[i]);

}

}

let res = "";

for (let i = 0; i < string.length; i++) {

const ch = string[i];

if (chars.has(ch)) {

if (ch === "\n")

res += "\\n";

else if (ch === "\r")

res += "\\r";

else if (ch === "\t")

res += "\\t";

else

res += "\\" + ch;

}

else {

res += ch;

}

}

return res;

}

/** Un-quotes a quoted string. */

static async stripslashes(ctx, strArg) {

return (await ctx.str(strArg)).replace(/\\(['"\\0])/g, "$1");

}

static async stripcslashes(ctx, strArg) {

return StringRuntime.stripslashes(ctx, strArg);

}

/** Convert special characters to HTML entities. */

static async htmlspecialchars(ctx, strArg) {

return (await ctx.str(strArg))

.replace(/&/g, "&amp;")

.replace(/</g, "&lt;")

.replace(/>/g, "&gt;")

.replace(/"/g, "&quot;")

.replace(/'/g, "&#039;");

}

/** Convert special HTML entities back to characters. */

static async htmlspecialchars_decode(ctx, strArg) {

return String(await strArg?.get() ?? "")

.replace(/&amp;/g, "&")

.replace(/&lt;/g, "<")

.replace(/&gt;/g, ">")

.replace(/&quot;/g, '"')

.replace(/&#039;/g, "'");

}

static async htmlentities(ctx, strArg) {

return StringRuntime.htmlspecialchars(ctx, strArg);

}

static async html_entity_decode(ctx, strArg) {

return StringRuntime.htmlspecialchars_decode(ctx, strArg);

}

static async unpack(ctx, formatArg, stringArg, offsetArg) {

const format = String(await formatArg?.get() ?? "");

const rawStr = await stringArg?.get();

const offset = Number(await offsetArg?.get()) || 0;

if (rawStr === undefined || rawStr === null || !format)

return false;

const buffer = Buffer.isBuffer(rawStr) ? rawStr : Buffer.from(String(rawStr), "binary");

const result = {};

let bufIdx = offset;

const codes = format.split("/");

let autoIdx = 1;

for (const item of codes) {

if (!item)

continue;

const type = item[0];

const name = item.slice(1) || String(autoIdx++);

if (bufIdx >= buffer.length)

break;

if (type === "N") {

if (bufIdx + 4 > buffer.length)

break;

result[name] = buffer.readUInt32BE(bufIdx);

bufIdx += 4;

}

else if (type === "V") {

if (bufIdx + 4 > buffer.length)

break;

result[name] = buffer.readUInt32LE(bufIdx);

bufIdx += 4;

}

else if (type === "n") {

if (bufIdx + 2 > buffer.length)

break;

result[name] = buffer.readUInt16BE(bufIdx);

bufIdx += 2;

}

else if (type === "v") {

if (bufIdx + 2 > buffer.length)

break;

result[name] = buffer.readUInt16LE(bufIdx);

bufIdx += 2;

}

else if (type === "C") {

result[name] = buffer.readUInt8(bufIdx);

bufIdx += 1;

}

else if (type === "c") {

result[name] = buffer.readInt8(bufIdx);

bufIdx += 1;

}

}

return Object.keys(result).length > 0 ? result : false;

}

static async pack(ctx, formatArg, ...args) {