Warning: session_start(): Session cannot be started after headers have already been sent in /home/tvrreohg/public_html/manga.php on line 13
/** * The `node:vm` module enables compiling and running code within V8 Virtual * Machine contexts. * * **The `node:vm` module is not a security** * **mechanism. Do not use it to run untrusted code.** * * JavaScript code can be compiled and run immediately or * compiled, saved, and run later. * * A common use case is to run the code in a different V8 Context. This means * invoked code has a different global object than the invoking code. * * One can provide the context by `contextifying` an * object. The invoked code treats any property in the context like a * global variable. Any changes to global variables caused by the invoked * code are reflected in the context object. * * ```js * const vm = require('node:vm'); * * const x = 1; * * const context = { x: 2 }; * vm.createContext(context); // Contextify the object. * * const code = 'x += 40; var y = 17;'; * // `x` and `y` are global variables in the context. * // Initially, x has the value 2 because that is the value of context.x. * vm.runInContext(code, context); * * console.log(context.x); // 42 * console.log(context.y); // 17 * * console.log(x); // 1; y is not defined. * ``` * @see [source](https://github.com/nodejs/node/blob/v20.13.1/lib/vm.js) */ declare module "vm" { import { ImportAttributes } from "node:module"; interface Context extends NodeJS.Dict {} interface BaseOptions { /** * Specifies the filename used in stack traces produced by this script. * @default '' */ filename?: string | undefined; /** * Specifies the line number offset that is displayed in stack traces produced by this script. * @default 0 */ lineOffset?: number | undefined; /** * Specifies the column number offset that is displayed in stack traces produced by this script. * @default 0 */ columnOffset?: number | undefined; } interface ScriptOptions extends BaseOptions { /** * V8's code cache data for the supplied source. */ cachedData?: Buffer | NodeJS.ArrayBufferView | undefined; /** @deprecated in favor of `script.createCachedData()` */ produceCachedData?: boolean | undefined; /** * Used to specify how the modules should be loaded during the evaluation of this script when `import()` is called. This option is * part of the experimental modules API. We do not recommend using it in a production environment. For detailed information, see * [Support of dynamic `import()` in compilation APIs](https://nodejs.org/docs/latest-v20.x/api/vm.html#support-of-dynamic-import-in-compilation-apis). */ importModuleDynamically?: | ((specifier: string, script: Script, importAttributes: ImportAttributes) => Module) | typeof constants.USE_MAIN_CONTEXT_DEFAULT_LOADER | undefined; } interface RunningScriptOptions extends BaseOptions { /** * When `true`, if an `Error` occurs while compiling the `code`, the line of code causing the error is attached to the stack trace. * @default true */ displayErrors?: boolean | undefined; /** * Specifies the number of milliseconds to execute code before terminating execution. * If execution is terminated, an `Error` will be thrown. This value must be a strictly positive integer. */ timeout?: number | undefined; /** * If `true`, the execution will be terminated when `SIGINT` (Ctrl+C) is received. * Existing handlers for the event that have been attached via `process.on('SIGINT')` will be disabled during script execution, but will continue to work after that. * If execution is terminated, an `Error` will be thrown. * @default false */ breakOnSigint?: boolean | undefined; } interface RunningScriptInNewContextOptions extends RunningScriptOptions { /** * Human-readable name of the newly created context. */ contextName?: CreateContextOptions["name"]; /** * Origin corresponding to the newly created context for display purposes. The origin should be formatted like a URL, * but with only the scheme, host, and port (if necessary), like the value of the `url.origin` property of a `URL` object. * Most notably, this string should omit the trailing slash, as that denotes a path. */ contextOrigin?: CreateContextOptions["origin"]; contextCodeGeneration?: CreateContextOptions["codeGeneration"]; /** * If set to `afterEvaluate`, microtasks will be run immediately after the script has run. */ microtaskMode?: CreateContextOptions["microtaskMode"]; } interface RunningCodeOptions extends RunningScriptOptions { cachedData?: ScriptOptions["cachedData"]; importModuleDynamically?: ScriptOptions["importModuleDynamically"]; } interface RunningCodeInNewContextOptions extends RunningScriptInNewContextOptions { cachedData?: ScriptOptions["cachedData"]; importModuleDynamically?: ScriptOptions["importModuleDynamically"]; } interface CompileFunctionOptions extends BaseOptions { /** * Provides an optional data with V8's code cache data for the supplied source. */ cachedData?: Buffer | undefined; /** * Specifies whether to produce new cache data. * @default false */ produceCachedData?: boolean | undefined; /** * The sandbox/context in which the said function should be compiled in. */ parsingContext?: Context | undefined; /** * An array containing a collection of context extensions (objects wrapping the current scope) to be applied while compiling */ contextExtensions?: Object[] | undefined; } interface CreateContextOptions { /** * Human-readable name of the newly created context. * @default 'VM Context i' Where i is an ascending numerical index of the created context. */ name?: string | undefined; /** * Corresponds to the newly created context for display purposes. * The origin should be formatted like a `URL`, but with only the scheme, host, and port (if necessary), * like the value of the `url.origin` property of a URL object. * Most notably, this string should omit the trailing slash, as that denotes a path. * @default '' */ origin?: string | undefined; codeGeneration?: | { /** * If set to false any calls to eval or function constructors (Function, GeneratorFunction, etc) * will throw an EvalError. * @default true */ strings?: boolean | undefined; /** * If set to false any attempt to compile a WebAssembly module will throw a WebAssembly.CompileError. * @default true */ wasm?: boolean | undefined; } | undefined; /** * If set to `afterEvaluate`, microtasks will be run immediately after the script has run. */ microtaskMode?: "afterEvaluate" | undefined; } type MeasureMemoryMode = "summary" | "detailed"; interface MeasureMemoryOptions { /** * @default 'summary' */ mode?: MeasureMemoryMode | undefined; /** * @default 'default' */ execution?: "default" | "eager" | undefined; } interface MemoryMeasurement { total: { jsMemoryEstimate: number; jsMemoryRange: [number, number]; }; } /** * Instances of the `vm.Script` class contain precompiled scripts that can be * executed in specific contexts. * @since v0.3.1 */ class Script { constructor(code: string, options?: ScriptOptions | string); /** * Runs the compiled code contained by the `vm.Script` object within the given `contextifiedObject` and returns the result. Running code does not have access * to local scope. * * The following example compiles code that increments a global variable, sets * the value of another global variable, then execute the code multiple times. * The globals are contained in the `context` object. * * ```js * const vm = require('node:vm'); * * const context = { * animal: 'cat', * count: 2, * }; * * const script = new vm.Script('count += 1; name = "kitty";'); * * vm.createContext(context); * for (let i = 0; i < 10; ++i) { * script.runInContext(context); * } * * console.log(context); * // Prints: { animal: 'cat', count: 12, name: 'kitty' } * ``` * * Using the `timeout` or `breakOnSigint` options will result in new event loops * and corresponding threads being started, which have a non-zero performance * overhead. * @since v0.3.1 * @param contextifiedObject A `contextified` object as returned by the `vm.createContext()` method. * @return the result of the very last statement executed in the script. */ runInContext(contextifiedObject: Context, options?: RunningScriptOptions): any; /** * First contextifies the given `contextObject`, runs the compiled code contained * by the `vm.Script` object within the created context, and returns the result. * Running code does not have access to local scope. * * The following example compiles code that sets a global variable, then executes * the code multiple times in different contexts. The globals are set on and * contained within each individual `context`. * * ```js * const vm = require('node:vm'); * * const script = new vm.Script('globalVar = "set"'); * * const contexts = [{}, {}, {}]; * contexts.forEach((context) => { * script.runInNewContext(context); * }); * * console.log(contexts); * // Prints: [{ globalVar: 'set' }, { globalVar: 'set' }, { globalVar: 'set' }] * ``` * @since v0.3.1 * @param contextObject An object that will be `contextified`. If `undefined`, a new object will be created. * @return the result of the very last statement executed in the script. */ runInNewContext(contextObject?: Context, options?: RunningScriptInNewContextOptions): any; /** * Runs the compiled code contained by the `vm.Script` within the context of the * current `global` object. Running code does not have access to local scope, but _does_ have access to the current `global` object. * * The following example compiles code that increments a `global` variable then * executes that code multiple times: * * ```js * const vm = require('node:vm'); * * global.globalVar = 0; * * const script = new vm.Script('globalVar += 1', { filename: 'myfile.vm' }); * * for (let i = 0; i < 1000; ++i) { * script.runInThisContext(); * } * * console.log(globalVar); * * // 1000 * ``` * @since v0.3.1 * @return the result of the very last statement executed in the script. */ runInThisContext(options?: RunningScriptOptions): any; /** * Creates a code cache that can be used with the `Script` constructor's `cachedData` option. Returns a `Buffer`. This method may be called at any * time and any number of times. * * The code cache of the `Script` doesn't contain any JavaScript observable * states. The code cache is safe to be saved along side the script source and * used to construct new `Script` instances multiple times. * * Functions in the `Script` source can be marked as lazily compiled and they are * not compiled at construction of the `Script`. These functions are going to be * compiled when they are invoked the first time. The code cache serializes the * metadata that V8 currently knows about the `Script` that it can use to speed up * future compilations. * * ```js * const script = new vm.Script(` * function add(a, b) { * return a + b; * } * * const x = add(1, 2); * `); * * const cacheWithoutAdd = script.createCachedData(); * // In `cacheWithoutAdd` the function `add()` is marked for full compilation * // upon invocation. * * script.runInThisContext(); * * const cacheWithAdd = script.createCachedData(); * // `cacheWithAdd` contains fully compiled function `add()`. * ``` * @since v10.6.0 */ createCachedData(): Buffer; /** @deprecated in favor of `script.createCachedData()` */ cachedDataProduced?: boolean | undefined; /** * When `cachedData` is supplied to create the `vm.Script`, this value will be set * to either `true` or `false` depending on acceptance of the data by V8. * Otherwise the value is `undefined`. * @since v5.7.0 */ cachedDataRejected?: boolean | undefined; cachedData?: Buffer | undefined; /** * When the script is compiled from a source that contains a source map magic * comment, this property will be set to the URL of the source map. * * ```js * import vm from 'node:vm'; * * const script = new vm.Script(` * function myFunc() {} * //# sourceMappingURL=sourcemap.json * `); * * console.log(script.sourceMapURL); * // Prints: sourcemap.json * ``` * @since v19.1.0, v18.13.0 */ sourceMapURL?: string | undefined; } /** * If given a `contextObject`, the `vm.createContext()` method will * [prepare that object](https://nodejs.org/docs/latest-v20.x/api/vm.html#what-does-it-mean-to-contextify-an-object) * and return a reference to it so that it can be used in `{@link runInContext}` or * [`script.runInContext()`](https://nodejs.org/docs/latest-v20.x/api/vm.html#scriptrunincontextcontextifiedobject-options). Inside such * scripts, the `contextObject` will be the global object, retaining all of its * existing properties but also having the built-in objects and functions any * standard [global object](https://es5.github.io/#x15.1) has. Outside of scripts run by the vm module, global * variables will remain unchanged. * * ```js * const vm = require('node:vm'); * * global.globalVar = 3; * * const context = { globalVar: 1 }; * vm.createContext(context); * * vm.runInContext('globalVar *= 2;', context); * * console.log(context); * // Prints: { globalVar: 2 } * * console.log(global.globalVar); * // Prints: 3 * ``` * * If `contextObject` is omitted (or passed explicitly as `undefined`), a new, * empty `contextified` object will be returned. * * The `vm.createContext()` method is primarily useful for creating a single * context that can be used to run multiple scripts. For instance, if emulating a * web browser, the method can be used to create a single context representing a * window's global object, then run all `