statusCode = 200;

headers = [];

headersSent = false;

/** Sets an HTTP response header. */

setHeader(name, value, replace = true) {

if (replace) {

this.headers = this.headers.filter((h) => h.name.toLowerCase() !== name.toLowerCase());

}

this.headers.push({ name, value });

if (name.toLowerCase() === "location" && this.statusCode === 200) {

this.statusCode = 302;

}

}

/** Removes an HTTP response header. */

removeHeader(name) {

if (this.headersSent) {

return;

}

if (!name) {

this.headers = [];

return;

}

this.headers = this.headers.filter((h) => h.name.toLowerCase() !== name.toLowerCase());

}

/** Gets an HTTP response header value by name. */

getHeader(name) {

const found = this.headers.filter((h) => h.name.toLowerCase() === name.toLowerCase());

return found.length > 0 ? found[found.length - 1].value : undefined;

}

/** Gets all formatted HTTP response headers. */

getHeadersList() {

return this.headers.map((h) => `${h.name}: ${h.value}`);

}

/** Sets a Set-Cookie HTTP header. */

setCookie(name, value = "", expires = 0, path = "", domain = "", secure = false, httponly = false, raw = false) {

if (this.headersSent) {

return;

}

const encodedName = raw ? name : encodeURIComponent(name);

const encodedValue = raw ? value : encodeURIComponent(value);

let cookieStr = `${encodedName}=${encodedValue}`;

if (expires > 0) {

cookieStr += `; expires=${new Date(expires * 1000).toUTCString()}`;

}

if (path)

cookieStr += `; path=${path}`;

if (domain)

cookieStr += `; domain=${domain}`;

if (secure)

cookieStr += `; secure`;

if (httponly)

cookieStr += `; HttpOnly`;

this.setHeader("Set-Cookie", cookieStr, false);

}

engine;

cwd;

root;

env;

vars = {};

constants;

functions;

classes;

interfaces;

internalVars;

scopes = [];

globalBindings = [];

staticBindings = [];

staticVars = Object.create(null);

superglobals;

outputBuffer;

response;

errorHandlerStack = [];

errorReportingLevel = 32767; // E_ALL

includedFiles = new Set();

currentFile = "";

currentLine = 0;

lastError = null;

currentDir = "";

executionDepth = 0;

stdout;

stderr;

outputChunks = [];

get outputText() {

return this.outputChunks.join("");

}

get symbols() {

return this.engine.symbols;

}

set outputText(val) {

this.outputChunks = [val];

}

constructor(engine, options = {}) {

this.engine = engine;

this.constants = Object.create(engine.constants);

this.functions = Object.create(engine.functions);

this.classes = Object.create(engine.classes);

this.interfaces = Object.create(engine.interfaces || {});

this.internalVars = Object.create(engine.internalVars);

this.cwd = options.cwd || process.cwd();

this.root = options.root || process.cwd();

this.env = options.env || process.env;

this.stdout = options.stdout || ((data) => { });

this.stderr = options.stderr || ((data) => { console.error(data); });

this.superglobals = new Superglobals({ ...options.superglobals, env: this.env });

this.vars['_GET'] = new PHPVariable(this.superglobals.GET);

this.vars['_POST'] = new PHPVariable(this.superglobals.POST);

this.vars['_SERVER'] = new PHPVariable(this.superglobals.SERVER);

this.vars['_COOKIE'] = new PHPVariable(this.superglobals.COOKIE);

this.vars['_FILES'] = new PHPVariable(this.superglobals.FILES);

this.vars['_ENV'] = new PHPVariable(this.superglobals.ENV);

this.vars['_REQUEST'] = new PHPVariable(this.superglobals.REQUEST);

this.vars['_SESSION'] = new PHPVariable(this.superglobals.SESSION);

this.outputBuffer = new OutputBufferStack();

this.response = new PHPResponse();

if (this.superglobals.SERVER['argv']) {

const argvArr = Array.isArray(this.superglobals.SERVER['argv']) ? this.superglobals.SERVER['argv'] : [];

this.vars['argv'] = new PHPVariable(argvArr);

this.vars['argc'] = new PHPVariable(argvArr.length);

}

if (options.errorReporting !== undefined) {

this.errorReportingLevel = options.errorReporting;

}

}

currentClassStack = [];

close() {

this.classes = {};

this.functions = {};

this.vars = {};

this.scopes = [];

this.globalBindings = [];

this.staticBindings = [];

this.outputBuffer.flushAll(this);

}

get currentClass() {

return this.currentClassStack.length > 0 ? this.currentClassStack[this.currentClassStack.length - 1] : undefined;

}

get currentClassName() {

const cls = this.currentClass;

return cls ? (cls.name || cls.phpClass?.name || "") : "";

}

get currentParentClassName() {

const cls = this.currentClass;

const parent = cls ? (cls.parentClass || cls.phpClass?.parentClass) : undefined;

return parent ? (parent.name || parent.phpClass?.name || "") : "";

}

toLiteral(val) {

return isPHPReference(val) ? val : new PHPLiteral(val);

}

async toVal(val) {

let unwrap = isPHPReference(val) ? await val.get() : await val;

while (isPHPReference(unwrap))

unwrap = await unwrap.get();

return unwrap;

}

async add(left, right) {

const l = await this.toVal(left);

const r = await this.toVal(right);

if ((l && typeof l === "object") || (r && typeof r === "object")) {

if (Array.isArray(l) && Array.isArray(r) && l.length === Object.keys(l).length && r.length === Object.keys(r).length) {

const res = [...l];

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

if (res[i] === undefined)

res[i] = r[i];

}

return res;

}

const lObj = typeof l === "object" && l !== null ? l : {};

const rObj = typeof r === "object" && r !== null ? r : {};

return { ...rObj, ...lObj };

}

return (Number(l) || 0) + (Number(r) || 0);

}

async equals(left, right, strict = false, negate = false) {

const l = await this.toVal(left);

const r = await this.toVal(right);

const compare = (a, b, isStrict) => {

if (a === b)

return true;

if (a === null || a === undefined)

return b === null || b === undefined;

if (b === null || b === undefined)

return false;

if (typeof a === "object" && typeof b === "object") {

if (Array.isArray(a) || Array.isArray(b) || a.constructor === Object || b.constructor === Object) {

const keysA = Object.keys(a);

const keysB = Object.keys(b);

if (keysA.length !== keysB.length)

return false;

if (isStrict) {

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

if (keysA[i] !== keysB[i])

return false;

if (!compare(a[keysA[i]], b[keysB[i]], true))

return false;

}

return true;

}

else {

for (const key of keysA) {

if (!(key in b))

return false;

if (!compare(a[key], b[key], false))

return false;

}

return true;

}

}

}

if (isStrict)

return a === b;

return String(a) === String(b);

};

const res = compare(l, r, strict);

return negate ? !res : res;

}

/**

async isInstanceOf(objArg, className) {

const obj = await this.toVal(objArg);

if (!obj || (typeof obj !== "object" && typeof obj !== "function"))

return false;

const lowerName = normalizePhpRegistryName(className);

let cls = this.classes[lowerName];

if (cls && typeof cls === "function" && obj instanceof cls) {

return true;

}

const objectClass = obj[SYMBOL_PHP_CLASS] || obj.constructor;

if (typeof objectClass === "function") {

if (normalizePhpRegistryName(objectClass.name) === lowerName)

return true;

if (objectClass[SYMBOL_PHP_NAME] && normalizePhpRegistryName(objectClass[SYMBOL_PHP_NAME]) === lowerName)

return true;

}

let target = obj;

while (target && target !== Object.prototype) {

const targetClass = target[SYMBOL_PHP_CLASS] || target.constructor;

if (typeof targetClass === "function" && normalizePhpRegistryName(targetClass.name) === lowerName)

return true;

if (typeof targetClass === "function" && targetClass[SYMBOL_PHP_NAME] && normalizePhpRegistryName(targetClass[SYMBOL_PHP_NAME]) === lowerName)

return true;

const targetIfaces = target[SYMBOL_PHP_CLASS_INTERFACES] || targetClass?.[SYMBOL_PHP_CLASS_INTERFACES] || targetClass?.prototype?.[SYMBOL_PHP_CLASS_INTERFACES];

if (Array.isArray(targetIfaces) && targetIfaces.some((iface) => typeof iface?.isSubinterfaceOf === "function" ? iface.isSubinterfaceOf(lowerName) : normalizePhpRegistryName(iface?.name || "") === lowerName)) {

return true;

}

target = Object.getPrototypeOf(target);

}

return false;

}

/** Converts native JavaScript stack frames to PHP backtrace entries. */

getPHPBacktrace() {

const err = new Error();

const rawLines = (err.stack || "").split("\n");

const frames = [];

for (let i = 1; i < rawLines.length; i++) {

const line = rawLines[i].trim();

if (!line)

continue;

if (line.includes("PHPContext.") || line.includes("PHPContext.ts") || line.includes("PHPContext.js")

|| line.includes("PHPEngine.") || line.includes("PHPEngine.ts") || line.includes("PHPEngine.js")

|| line.includes("debug_backtrace") || line.includes("debug_print_backtrace")

|| line.includes("node:internal"))

continue;

const match = line.match(/^at (?:(.*?) \()?(.+):(\d+):(\d+)\)?$/);

if (!match)

continue;

frames.push({

file: match[2],

line: Number(match[3]),

function: (match[1] || "{main}").replace(/^async\s+/, ""),

});

}

return frames;

}

/** Sets a user-defined error handler function. */

setErrorHandler(handler, levels = 32767) {

const prev = this.errorHandlerStack.length > 0 ? this.errorHandlerStack[this.errorHandlerStack.length - 1] : null;

this.errorHandlerStack.push({ handler, levels });

return prev ? prev.handler : null;

}

/** Restores the previous error handler from the stack. */

restoreErrorHandler() {

if (this.errorHandlerStack.length > 0) {

this.errorHandlerStack.pop();

}

return true;

}

/** Triggers a userland error or warning. */

async triggerError(message, level = PHPError.E_USER_NOTICE, file = "", line = 0) {

this.lastError = {

type: level,

message,

file: file || this.currentFile || "",

line: line || this.currentLine || 0,

};

if ((this.errorReportingLevel & level) === 0) {

return false; // Suppressed

}

if (this.errorHandlerStack.length > 0) {

const top = this.errorHandlerStack[this.errorHandlerStack.length - 1];

if ((top.levels & level) !== 0) {

const handler = top.handler;

let res;

if (typeof handler === "function") {

res = await handler(this, level, message, file, line);

}

else if (typeof handler === "string") {

const fn = this.functions[normalizePhpRegistryName(handler)] || this.functionMissing(handler);

res = await fn(this, new PHPLiteral(level), new PHPLiteral(message), new PHPLiteral(file), new PHPLiteral(line));

}

if (res !== false) {

return true; // Handled

}

}

}

// Default error handling

if (level === 1 || level === 256 || level === 4 || level === 64) {

throw new PHPFatalError(`Fatal error: ${message} in ${file} on line ${line}`);

}

else {

const typeStr = (level === 2 || level === 512) ? "Warning" : "Notice";

await this.echo(`PHP ${typeStr}: ${message} in ${file} on line ${line}\n`);

return true;

}

}

/** Gets an internal variable value. */

getInternalVar(name) {

return this.internalVars[name];

}

/** Sets an internal variable value. */

setInternalVar(name, value) {

this.internalVars[name] = value;

}

/** Gets response headers as a key-value dictionary. */

get responseHeaders() {

const res = {};

for (const h of this.response.headers) {

res[h.name.toLowerCase()] = h.value;

}

return res;

}

/** Gets the current HTTP status code. */

get statusCode() {

return this.response.statusCode;

}

/** Flushes response headers to the client. */

flushHeaders() {

if (this.response.headersSent)

return;

this.response.headersSent = true;

const onFlush = this.getInternalVar("onFlushHeaders");

if (typeof onFlush === "function") {

onFlush(this.response.statusCode, this.response.headers);

}

}

/** Converts a value to a PHP string according to PHP type casting rules (false/null -> "", true -> "1"). */

async str(v) {

const val = await this.toVal(v);

if (val === false || val === null || val === undefined)

return "";

if (val === true)

return "1";

if (Buffer.isBuffer(val))

return val.toString("latin1");

return String(val);

}

/** Writes output text to stdout or active output buffer. */

async echo(data) {

const str = String(data ?? "");

if (this.outputBuffer.getLevel() > 0) {

this.outputBuffer.write(str);

}

else {

if (str.length > 0) {

this.flushHeaders();

}

this.writeStdout(str);

}

}

writeStdout(str) {

if (str)

this.outputChunks.push(str);

if (typeof this.stdout === "function") {

this.stdout(str);

}

else if (this.stdout && typeof this.stdout.write === "function") {

this.stdout.write(str);

}

}

/** Gets a constant value. */

getConstant(name) {

const lower = String(name ?? "").toLowerCase();

return this.constants[lower] ?? this.engine.constants[lower];

}

/** Checks if a constant is defined. */

hasConstant(name) {

if (!name || typeof name !== "string")

return false;

const lower = name.toLowerCase();

return Object.hasOwn(this.constants, lower) || Object.hasOwn(this.engine.constants, lower);

}

/** Defines a constant. */

defineConstant(name, val) {

this.constants[name.toLowerCase()] = val;

}

globalsProxy;

getGlobalPHPVar(name) {

let phpVar = this.vars[name];

if (!isPHPReference(phpVar)) {

phpVar = new PHPVariable(phpVar);

this.vars[name] = phpVar;

}

return phpVar;

}

getGlobalsProxy() {

if (!this.globalsProxy) {

this.globalsProxy = new Proxy(this.vars, {

get: (target, prop) => {

if (typeof prop === "string") {

if (prop === "GLOBALS")

return this.globalsProxy;

return this.getGlobalPHPVar(prop);

}

return target[prop];

},

set: (target, prop, value) => {

if (typeof prop === "string") {

const phpVar = this.getGlobalPHPVar(prop);

if (isPHPReference(value)) {

target[prop] = value;

}

else {

void phpVar.set(value);

}

return true;

}

target[prop] = value;

return true;

},

has: (target, prop) => {

if (typeof prop === "string") {

if (["GLOBALS", "_GET", "_POST", "_SERVER", "_COOKIE", "_FILES", "_ENV", "_REQUEST", "_SESSION"].includes(prop)) {

return true;

}

return prop in target;

}

return Reflect.has(target, prop);

},

deleteProperty: (target, prop) => {

if (typeof prop === "string") {

delete target[prop];

return true;

}

return Reflect.deleteProperty(target, prop);

},

ownKeys: (target) => {

const keys = new Set(Object.keys(target));

keys.add("GLOBALS");

keys.add("_GET");

keys.add("_POST");

keys.add("_SERVER");

keys.add("_COOKIE");

keys.add("_FILES");

keys.add("_ENV");

keys.add("_REQUEST");

keys.add("_SESSION");

return Array.from(keys);

},

getOwnPropertyDescriptor: (target, prop) => {

if (typeof prop === "string") {

if (prop === "GLOBALS") {

return { enumerable: true, configurable: true, writable: true, value: this.globalsProxy };

}

if (["_GET", "_POST", "_SERVER", "_COOKIE", "_FILES", "_ENV", "_REQUEST", "_SESSION"].includes(prop)) {

return { enumerable: true, configurable: true, writable: true, value: this.getGlobalPHPVar(prop) };

}

if (prop in target) {

return { enumerable: true, configurable: true, writable: true, value: this.getGlobalPHPVar(prop) };

}

}

return Reflect.getOwnPropertyDescriptor(target, prop);

}

});

}

return this.globalsProxy;

}

getPHPVar(name) {

if (name === "_GET" || name === "_POST" || name === "_SERVER" || name === "_COOKIE" || name === "_FILES" || name === "_ENV" || name === "_REQUEST" || name === "_SESSION" || name === "GLOBALS") {

let globalVar = this.vars[name];

if (!isPHPReference(globalVar)) {

globalVar = new PHPVariable(globalVar);

this.vars[name] = globalVar;

}

return globalVar;

}

const isGlobal = this.globalBindings.length > 0 && this.globalBindings[this.globalBindings.length - 1].has(name);

const scope = isGlobal || this.scopes.length === 0 ? this.vars : this.scopes[this.scopes.length - 1];

let phpVar = scope[name];

if (!isPHPReference(phpVar)) {

phpVar = new PHPVariable(phpVar);

scope[name] = phpVar;

}

return phpVar;

}

async argPHPVar(name, value, byReference = false, variadic = false) {

let variable;

if (byReference && !variadic && isPHPReference(value)) {

variable = value;

}

else {

const argVariable = new PHPVariable();

if (variadic) {

const args = value;

const values = byReference

? await Promise.all(args.map(async (arg) => isPHPReference(arg) ? arg : new PHPVariable(await this.toVal(arg))))

: await Promise.all(args.map((arg) => this.toVal(arg)));

await argVariable.set(values);

}

else if (isPHPReference(value)) {

await argVariable.setFrom(value);

}

else {

await argVariable.set(value);

}

variable = argVariable;

}

const isGlobal = this.globalBindings.length > 0 && this.globalBindings[this.globalBindings.length - 1].has(name);

const scope = isGlobal || this.scopes.length === 0 ? this.vars : this.scopes[this.scopes.length - 1];

scope[name] = variable;

return variable;

}

/** Gets a variable value from the current or global scope. */

async getVar(name) {

if (name === "GLOBALS")

return this.getGlobalsProxy();

if (name.startsWith("_")) {

switch (name) {

case "_GET":

case "_POST":

case "_SERVER":

case "_COOKIE":

case "_FILES":

case "_ENV":

case "_REQUEST":

case "_SESSION":

return await this.getPHPVar(name).get();

}

}

return await this.getPHPVar(name).get();

}

/** Sets a variable value in the current scope. */

async setVar(name, value) {

const isGlobal = this.globalBindings.length > 0 && this.globalBindings[this.globalBindings.length - 1].has(name);

const scope = isGlobal || this.scopes.length === 0 ? this.vars : this.scopes[this.scopes.length - 1];

if (isPHPReference(value)) {

scope[name] = value;

}

else {

await this.getPHPVar(name).set(value);

}

const phpVar = this.getPHPVar(name);

if (this.staticBindings.length > 0) {

for (const key of this.staticBindings[this.staticBindings.length - 1]) {

if (key.endsWith(`:${name}`))

this.staticVars[key] = phpVar;

}

}

return isPHPReference(value) ? await value.get() : value;

}

/** Binds a variable name to global scope. */

bindGlobal(name) {

if (this.globalBindings.length > 0) {

this.globalBindings[this.globalBindings.length - 1].add(name);

if (this.scopes.length > 0) {

const currentScope = this.scopes[this.scopes.length - 1];

const globalVar = this.getGlobalPHPVar(name);

currentScope[name] = globalVar;

return globalVar;

}

}

return this.getGlobalPHPVar(name);

}

unsetVar(name) {

const global = this.globalBindings.length > 0 && this.globalBindings[this.globalBindings.length - 1].has(name);

const scope = global || this.scopes.length === 0 ? this.vars : this.scopes[this.scopes.length - 1];

delete scope[name];

}

scopeArgs = [];

/** Pushes a new variable scope. */

pushScope(args = [], offset = 0) {

this.scopes.push({});

this.globalBindings.push(new Set());

this.staticBindings.push(new Set());

this.scopeArgs.push({ args, offset });

}

/** Pops the current variable scope. */

popScope() {

this.scopes.pop();

this.globalBindings.pop();

this.staticBindings.pop();

this.scopeArgs.pop();

}

getCurrentFunctionArgs() {

const scopeArgs = this.scopeArgs[this.scopeArgs.length - 1];