new vm.Script(code[, options])

• code <string> Код JavaScript для компиляции.
• options <Object> | <string>
  • filename <string> Указывает имя файла, используемое в трассировках стека, создаваемых этим скриптом. По умолчанию: 'evalmachine.<anonymous>'.
  • lineOffset <number> Указывает смещение номера строки, отображаемое в трассировках стека, создаваемых этим скриптом. По умолчанию: 0.
  • columnOffset <number> Указывает смещение номера столбца первой строки, отображаемое в трассировках стека, создаваемых этим скриптом. По умолчанию: 0.
  • cachedData <Buffer> | <TypedArray> | <DataView> Предоставляет необязательный Buffer или TypedArray либо DataView с данными кэша кода V8 для предоставленного исходного кода. Если он указан, значение cachedDataRejected будет установлено в true или false в зависимости от того, примет ли V8 эти данные.
  • produceCachedData <boolean> Если задано true и параметр cachedData отсутствует, V8 попытается создать данные кэша кода для code. В случае успеха будет создан Buffer с данными кэша кода V8 и сохранён в свойстве cachedData возвращённого экземпляра vm.Script. Значение cachedDataProduced будет установлено в true или false в зависимости от успешности создания данных кэша кода. Этот параметр устарел; вместо него следует использовать script.createCachedData(). По умолчанию: false.
  • importModuleDynamically <Function> | <vm.constants.USE_MAIN_CONTEXT_DEFAULT_LOADER> Используется для указания способа загрузки модулей при вычислении этого скрипта, когда вызывается import(). Этот параметр является частью экспериментального API модулей. Мы не рекомендуем использовать его в производственной среде. Подробную информацию см. в разделе Поддержка динамического import() в API компиляции.

Если options — строка, она задаёт имя файла.

Создание нового объекта vm.Script компилирует code, но не выполняет его. Скомпилированный vm.Script впоследствии можно выполнять многократно. code не привязывается к какому-либо глобальному объекту; вместо этого он привязывается перед каждым запуском только на время этого запуска.

script.cachedDataRejected

• Тип: <boolean> | <undefined>

Если при создании vm.Script указан параметр cachedData, это значение будет установлено в true или false в зависимости от того, примет ли V8 эти данные. В противном случае значение равно undefined.

script.createCachedData()

• Возвращает: <Buffer>

Создаёт кэш кода, который можно использовать с параметром cachedData конструктора Script. Возвращает Buffer. Этот метод можно вызывать в любое время и любое количество раз.

Кэш кода Script не содержит состояний, доступных для наблюдения из JavaScript. Кэш кода можно безопасно сохранять вместе с исходным кодом скрипта и многократно использовать для создания новых экземпляров Script.

Функции в исходном коде Script могут быть помечены для отложенной компиляции, поэтому при создании Script они не компилируются. Эти функции будут скомпилированы при первом вызове. Кэш кода сериализует метаданные, известные V8 на данный момент о Script, которые можно использовать для ускорения последующих компиляций.

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()`. copy

script.runInContext(contextifiedObject[, options])

• contextifiedObject <Object> Объект, преобразованный в контекст, как возвращаемый методом vm.createContext().
• options <Object>
  • displayErrors <boolean> Если задано true, при возникновении Error во время компиляции code строка кода, вызвавшая ошибку, добавляется в трассировку стека. По умолчанию: true.
  • timeout <integer> Задаёт количество миллисекунд, в течение которых выполняется code, прежде чем выполнение будет остановлено. При остановке выполнения будет выброшен Error. Значение должно быть строго положительным целым числом.
  • breakOnSigint <boolean> Если задано true, получение SIGINT (Ctrl+C) остановит выполнение и вызовет Error. Обработчики этого события, ранее добавленные с помощью process.on('SIGINT'), отключаются на время выполнения скрипта, но продолжают работать после его завершения. По умолчанию: false.
• Возвращает: <any> результат последнего выполненного в скрипте оператора.

Выполняет скомпилированный код, содержащийся в объекте vm.Script, в указанном contextifiedObject и возвращает результат. Выполняемый код не имеет доступа к локальной области видимости.

В следующем примере компилируется код, который увеличивает глобальную переменную, задаёт значение другой глобальной переменной, а затем выполняется несколько раз. Глобальные переменные содержатся в объекте context.

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' } copy

Использование параметров timeout или breakOnSigint приводит к запуску новых циклов событий и соответствующих потоков, что влечёт ненулевые накладные расходы.

script.runInNewContext([contextObject[, options]])

• contextObject <Object> | <vm.constants.DONT_CONTEXTIFY> | <undefined> Либо vm.constants.DONT_CONTEXTIFY, либо объект, который будет преобразован в контекст. Если значение равно undefined, для обратной совместимости будет создан пустой объект, преобразованный в контекст.
• options <Object>
  • displayErrors <boolean> Если задано true, при возникновении Error во время компиляции code строка кода, вызвавшая ошибку, добавляется в трассировку стека. По умолчанию: true.
  • timeout <integer> Задаёт количество миллисекунд, в течение которых выполняется code, прежде чем выполнение будет остановлено. При остановке выполнения будет выброшен Error. Значение должно быть строго положительным целым числом.
  • breakOnSigint <boolean> Если задано true, получение SIGINT (Ctrl+C) остановит выполнение и вызовет Error. Обработчики этого события, ранее добавленные с помощью process.on('SIGINT'), отключаются на время выполнения скрипта, но продолжают работать после его завершения. По умолчанию: false.
  • contextName <string> Понятное пользователю имя созданного контекста. По умолчанию: 'VM Context i', где i — возрастающий числовой индекс созданного контекста.
  • contextOrigin <string> Источник, соответствующий созданному контексту и используемый для отображения. Источник должен быть оформлен как URL, но содержать только схему, хост и порт (если необходимо), подобно значению свойства url.origin объекта URL. В частности, эта строка не должна содержать завершающую косую черту, так как она обозначает путь. По умолчанию: ''.
  • contextCodeGeneration <Object>
    • strings <boolean> Если задано значение false, любые вызовы eval или конструкторов функций (Function, GeneratorFunction и т. д.) вызовут EvalError. По умолчанию: true.
    • wasm <boolean> Если задано значение false, любая попытка скомпилировать модуль WebAssembly вызовет WebAssembly.CompileError. По умолчанию: true.
  • microtaskMode <string> Если задано значение afterEvaluate, микрозадачи (задачи, запланированные с помощью Promise и async function) будут выполнены сразу после завершения скрипта. В этом случае они входят в области видимости timeout и breakOnSigint.
• Возвращает: <any> результат последнего выполненного в скрипте оператора.

Этот метод является сокращённой формой script.runInContext(vm.createContext(options), options). Он выполняет сразу несколько действий:

1. Создаёт новый контекст.
2. Если contextObject — объект, он преобразуется в контекст с помощью нового контекста. Если contextObject не определён, создаётся новый объект и преобразуется в контекст. Если contextObject равен vm.constants.DONT_CONTEXTIFY, ничего не нужно преобразовывать в контекст.
3. Выполняет скомпилированный код, содержащийся в объекте vm.Script, в созданном контексте. Код не имеет доступа к области видимости, в которой вызывается этот метод.
4. Возвращает результат.

В следующем примере компилируется код, который задаёт глобальную переменную, а затем выполняет этот код несколько раз в разных контекстах. Глобальные переменные задаются и хранятся в каждом отдельном context.

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' }]

// This would throw if the context is created from a contextified object.
// vm.constants.DONT_CONTEXTIFY allows creating contexts with ordinary
// global objects that can be frozen.
const freezeScript = new vm.Script('Object.freeze(globalThis); globalThis;');
const frozenContext = freezeScript.runInNewContext(vm.constants.DONT_CONTEXTIFY); copy

script.runInThisContext([options])

• options <Object>
  • displayErrors <boolean> Если задано true, при возникновении Error во время компиляции code строка кода, вызвавшая ошибку, добавляется в трассировку стека. По умолчанию: true.
  • timeout <integer> Задаёт количество миллисекунд, в течение которых выполняется code, прежде чем выполнение будет остановлено. При остановке выполнения будет выброшен Error. Значение должно быть строго положительным целым числом.
  • breakOnSigint <boolean> Если задано true, получение SIGINT (Ctrl+C) остановит выполнение и вызовет Error. Обработчики этого события, ранее добавленные с помощью process.on('SIGINT'), отключаются на время выполнения скрипта, но продолжают работать после его завершения. По умолчанию: false.
• Возвращает: <any> результат последнего выполненного в скрипте оператора.

Выполняет скомпилированный код, содержащийся в vm.Script, в контексте текущего объекта global. Выполняемый код не имеет доступа к локальной области видимости, но имеет доступ к текущему объекту global.

В следующем примере компилируется код, который увеличивает переменную global, а затем выполняет этот код несколько раз:

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 copy

script.sourceMapURL

• Тип: <string> | <undefined>

Если скрипт скомпилирован из исходного кода, содержащего специальный комментарий source map, этому свойству будет присвоен URL карты исходного кода.

import vm from 'node:vm';

const script = new vm.Script(`
function myFunc() {}
//# sourceMappingURL=sourcemap.json
`);

console.log(script.sourceMapURL);
// Prints: sourcemap.json

const vm = require('node:vm');

const script = new vm.Script(`
function myFunc() {}
//# sourceMappingURL=sourcemap.json
`);

console.log(script.sourceMapURL);
// Prints: sourcemap.json

module.error

• Тип: <any>

Если module.status имеет значение 'errored', это свойство содержит исключение, вызванное модулем во время вычисления. Если статус имеет любое другое значение, обращение к этому свойству приведет к выбросу исключения.

Значение undefined нельзя использовать в случаях, когда исключение не было вызвано, из-за возможной неоднозначности с throw undefined;.

Соответствует полю [[EvaluationError]] циклических записей модулей в спецификации ECMAScript.

module.evaluate([options])

• options <Object>
  • timeout <integer> Указывает количество миллисекунд, в течение которых будет выполняться вычисление, прежде чем выполнение будет остановлено. Если выполнение прервано, будет выброшена ошибка Error. Это значение должно быть строго положительным целым числом.
  • breakOnSigint <boolean> Если значение true, получение сигнала SIGINT (Ctrl+C) завершит выполнение и вызовет ошибку Error. Существующие обработчики события, подключенные с помощью process.on('SIGINT'), отключаются во время выполнения скрипта, но продолжают работать после него. По умолчанию: false.
• Возвращает: <Promise> При успешном выполнении разрешается значением undefined.

Вычисляет модуль.

Этот метод необходимо вызвать после связывания модуля, иначе он будет отклонен. Его также можно вызвать, если модуль уже вычислен. В этом случае он либо ничего не сделает, если первоначальное вычисление завершилось успешно (module.status имеет значение 'evaluated'), либо повторно вызовет исключение, возникшее при первоначальном вычислении (module.status имеет значение 'errored').

Этот метод нельзя вызвать во время вычисления модуля (module.status имеет значение 'evaluating').

Соответствует полю конкретного метода Evaluate() циклических записей модулей в спецификации ECMAScript.

module.identifier

• Тип: <string>

Идентификатор текущего модуля, заданный в конструкторе.

module.link(linker)

• linker <Function>

  • specifier <string> Спецификатор запрашиваемого модуля:

    import foo from 'foo';
    //              ^^^^^ the module specifier copy

  • referencingModule <vm.Module> Объект Module, для которого вызывается link().

  • extra <Object>

    • attributes <Object> Данные атрибута:

      import foo from 'foo' with { name: 'value' };
      //                         ^^^^^^^^^^^^^^^^^ the attribute copy

      Согласно ECMA-262, ожидается, что хост вызовет ошибку, если присутствует неподдерживаемый атрибут.
    • assert <Object> Псевдоним для extra.attributes.

  • Возвращает: <vm.Module> | <Promise>

• Возвращает: <Promise>

Связывает зависимости модуля. Этот метод необходимо вызвать до вычисления; для каждого модуля его можно вызвать только один раз.

Ожидается, что функция вернет объект Module или объект Promise, который в итоге разрешится объектом Module. Возвращаемый объект Module должен удовлетворять следующим двум инвариантам:

• Он должен принадлежать тому же контексту, что и родительский Module.
• Его status не должен иметь значение 'errored'.

Если status возвращенного объекта Module имеет значение 'unlinked', этот метод будет рекурсивно вызван для возвращенного Module с той же переданной функцией linker.

link() возвращает Promise, который будет разрешен, когда все экземпляры связывания разрешатся в допустимый Module, или отклонен, если функция-связыватель вызовет исключение либо вернет недопустимый Module.

Функция-связыватель примерно соответствует зависящей от реализации абстрактной операции HostResolveImportedModule в спецификации ECMAScript, но имеет несколько важных отличий:

• Функция-связыватель может быть асинхронной, тогда как HostResolveImportedModule является синхронной.

Фактическая реализация HostResolveImportedModule, используемая при связывании модулей, возвращает модули, связанные в ходе этого процесса. Поскольку к этому моменту все модули уже полностью связаны, реализация HostResolveImportedModule согласно спецификации полностью синхронна.

Соответствует полю конкретного метода Link() циклических записей модулей в спецификации ECMAScript.

module.namespace

• Тип: <Object>

Объект пространства имен модуля. Он доступен только после завершения связывания (module.link()).

Соответствует абстрактной операции GetModuleNamespace в спецификации ECMAScript.

module.status

• Тип: <string>

Текущий статус модуля. Возможны следующие значения:

• 'unlinked': module.link() еще не вызывался.

• 'linking': module.link() был вызван, но не все промисы, возвращенные функцией-связывателем, еще разрешились.

• 'linked': Модуль успешно связан, и все его зависимости связаны, но module.evaluate() еще не вызывался.

• 'evaluating': Модуль вычисляется посредством module.evaluate() для самого себя или родительского модуля.

• 'evaluated': Модуль успешно вычислен.

• 'errored': Модуль вычислен, но было вызвано исключение.

За исключением 'errored', эта строка статуса соответствует полю [[Status]] циклической записи модуля из спецификации. 'errored' соответствует 'evaluated' в спецификации, но с [[EvaluationError]], имеющим значение, отличное от undefined.

new vm.SourceTextModule(code[, options])

• code <string> Код модуля JavaScript для разбора
• options
  • identifier <string> Строка, используемая в трассировках стека. По умолчанию: 'vm:module(i)', где i — контекстно-зависимый возрастающий индекс.
  • cachedData <Buffer> | <TypedArray> | <DataView> Предоставляет необязательный Buffer или TypedArray либо DataView с данными кэша кода V8 для указанного исходного кода. code должен быть тем же модулем, из которого был создан этот cachedData.
  • context <Object> Контекстуализированный объект, возвращаемый методом vm.createContext(), в котором будет компилироваться и вычисляться этот Module. Если контекст не указан, модуль вычисляется в текущем контексте выполнения.
  • lineOffset <integer> Задает смещение номера строки, отображаемое в трассировках стека, создаваемых этим Module. По умолчанию: 0.
  • columnOffset <integer> Задает смещение номера столбца первой строки, отображаемое в трассировках стека, создаваемых этим Module. По умолчанию: 0.
  • initializeImportMeta <Function> Вызывается во время вычисления этого Module для инициализации import.meta.
    • meta <import.meta>
    • module <vm.SourceTextModule>
  • importModuleDynamically <Function> Используется для указания способа загрузки модулей во время вычисления этого модуля при вызове import(). Этот параметр является частью экспериментального API модулей. Не рекомендуется использовать его в производственной среде. Подробную информацию см. в разделе Поддержка динамического import() в API компиляции.

Создает новый экземпляр SourceTextModule.

Объекты, назначенные свойствам объекта import.meta, могут предоставить модулю доступ к информации за пределами указанного context. Используйте vm.runInContext() для создания объектов в определенном контексте.

import vm from 'node:vm';

const contextifiedObject = vm.createContext({ secret: 42 });

const module = new vm.SourceTextModule(
  'Object.getPrototypeOf(import.meta.prop).secret = secret;',
  {
    initializeImportMeta(meta) {
      // Note: this object is created in the top context. As such,
      // Object.getPrototypeOf(import.meta.prop) points to the
      // Object.prototype in the top context rather than that in
      // the contextified object.
      meta.prop = {};
    },
  });
// Since module has no dependencies, the linker function will never be called.
await module.link(() => {});
await module.evaluate();

// Now, Object.prototype.secret will be equal to 42.
//
// To fix this problem, replace
//     meta.prop = {};
// above with
//     meta.prop = vm.runInContext('{}', contextifiedObject);

const vm = require('node:vm');
const contextifiedObject = vm.createContext({ secret: 42 });
(async () => {
  const module = new vm.SourceTextModule(
    'Object.getPrototypeOf(import.meta.prop).secret = secret;',
    {
      initializeImportMeta(meta) {
        // Note: this object is created in the top context. As such,
        // Object.getPrototypeOf(import.meta.prop) points to the
        // Object.prototype in the top context rather than that in
        // the contextified object.
        meta.prop = {};
      },
    });
  // Since module has no dependencies, the linker function will never be called.
  await module.link(() => {});
  await module.evaluate();
  // Now, Object.prototype.secret will be equal to 42.
  //
  // To fix this problem, replace
  //     meta.prop = {};
  // above with
  //     meta.prop = vm.runInContext('{}', contextifiedObject);
})();

sourceTextModule.createCachedData()

• Возвращает: <Buffer>

Создает кэш кода, который можно использовать с параметром cachedData конструктора SourceTextModule. Возвращает Buffer. Этот метод можно вызывать любое количество раз до вычисления модуля.

Кэш кода SourceTextModule не содержит состояний, наблюдаемых из JavaScript. Кэш кода безопасно сохранять вместе с исходным кодом скрипта и использовать для многократного создания новых экземпляров SourceTextModule.

Функции в исходном коде SourceTextModule могут быть помечены как компилируемые лениво; в этом случае они не компилируются при создании SourceTextModule. Такие функции будут скомпилированы при первом вызове. Кэш кода сериализует метаданные, известные V8 о SourceTextModule, которые можно использовать для ускорения будущих компиляций.

// Create an initial module
const module = new vm.SourceTextModule('const a = 1;');

// Create cached data from this module
const cachedData = module.createCachedData();

// Create a new module using the cached data. The code must be the same.
const module2 = new vm.SourceTextModule('const a = 1;', { cachedData }); copy

sourceTextModule.dependencySpecifiers

• <string[]>

Спецификаторы всех зависимостей этого модуля. Возвращаемый массив заморожен, чтобы запретить любые изменения.

Соответствует полю [[RequestedModules]] циклических записей модулей в спецификации ECMAScript.

sourceTextModule.moduleRequests

• <ModuleRequest[]> Зависимости этого модуля.

Запрошенные зависимости импорта этого модуля. Возвращаемый массив заморожен, чтобы запретить любые изменения.

Например, для следующего исходного текста:

import foo from 'foo';
import fooAlias from 'foo';
import bar from './bar.js';
import withAttrs from '../with-attrs.ts' with { arbitraryAttr: 'attr-val' }; copy

Значение sourceTextModule.moduleRequests будет следующим:

[
  {
    specifier: 'foo',
    attributes: {},
  },
  {
    specifier: 'foo',
    attributes: {},
  },
  {
    specifier: './bar.js',
    attributes: {},
  },
  {
    specifier: '../with-attrs.ts',
    attributes: { arbitraryAttr: 'attr-val' },
  },
]; copy

new vm.SyntheticModule(exportNames, evaluateCallback[, options])

• exportNames <string[]> Массив имен, которые будут экспортированы из модуля.
• evaluateCallback <Function> Вызывается при вычислении модуля.
• options
  • identifier <string> Строка, используемая в трассировках стека. По умолчанию: 'vm:module(i)', где i — контекстно-зависимый возрастающий индекс.
  • context <Object> Контекстуализированный объект, возвращаемый методом vm.createContext(), в котором будет компилироваться и вычисляться этот Module.

Создает новый экземпляр SyntheticModule.

Объекты, назначенные экспортам этого экземпляра, могут предоставить импортирующим модулям доступ к информации за пределами указанного context. Используйте vm.runInContext() для создания объектов в определенном контексте.

syntheticModule.setExport(name, value)

• name <string> Имя экспорта, которому нужно присвоить значение.
• value <any> Значение, которое нужно присвоить экспорту.

Этот метод используется после связывания модуля для задания значений экспортов. Если вызвать его до связывания модуля, будет выброшена ошибка ERR_VM_MODULE_STATUS.

import vm from 'node:vm';

const m = new vm.SyntheticModule(['x'], () => {
  m.setExport('x', 1);
});

await m.link(() => {});
await m.evaluate();

assert.strictEqual(m.namespace.x, 1);

const vm = require('node:vm');
(async () => {
  const m = new vm.SyntheticModule(['x'], () => {
    m.setExport('x', 1);
  });
  await m.link(() => {});
  await m.evaluate();
  assert.strictEqual(m.namespace.x, 1);
})();

vm.constants.USE_MAIN_CONTEXT_DEFAULT_LOADER

Константа, которую можно использовать в качестве параметра importModuleDynamically для vm.Script и vm.compileFunction(), чтобы Node.js загружал запрашиваемый модуль с помощью загрузчика ESM по умолчанию из основного контекста.

Подробную информацию см. в разделе Поддержка динамического import() в API компиляции.

vm.constants.DONT_CONTEXTIFY

Эта константа, используемая в качестве аргумента contextObject в API vm, указывает Node.js создать контекст, не оборачивая его глобальный объект в другой объект специфичным для Node.js способом. В результате значение globalThis внутри нового контекста будет вести себя ближе к обычному объекту.

const vm = require('node:vm');

// Use vm.constants.DONT_CONTEXTIFY to freeze the global object.
const context = vm.createContext(vm.constants.DONT_CONTEXTIFY);
vm.runInContext('Object.freeze(globalThis);', context);
try {
  vm.runInContext('bar = 1; bar;', context);
} catch (e) {
  console.log(e); // Uncaught ReferenceError: bar is not defined
} copy

Если vm.constants.DONT_CONTEXTIFY используется в качестве аргумента contextObject для vm.createContext(), возвращаемый объект является прокси-подобным объектом глобального объекта в созданном контексте, с меньшим количеством особенностей, специфичных для Node.js. Он является тем же объектом, что и значение globalThis в новом контексте, может изменяться извне контекста и может использоваться для прямого доступа к встроенным объектам нового контекста.

const vm = require('node:vm');

const context = vm.createContext(vm.constants.DONT_CONTEXTIFY);

// Returned object is reference equal to globalThis in the new context.
console.log(vm.runInContext('globalThis', context) === context);  // true

// Can be used to access globals in the new context directly.
console.log(context.Array);  // [Function: Array]
vm.runInContext('foo = 1;', context);
console.log(context.foo);  // 1
context.bar = 1;
console.log(vm.runInContext('bar;', context));  // 1

// Can be frozen and it affects the inner context.
Object.freeze(context);
try {
  vm.runInContext('baz = 1; baz;', context);
} catch (e) {
  console.log(e); // Uncaught ReferenceError: baz is not defined
} copy

Если параметр importModuleDynamically не указан или имеет значение undefined

Если этот параметр не указан или имеет значение undefined, код с import() по-прежнему можно скомпилировать с помощью API vm, но при выполнении скомпилированного кода, если он действительно вызывает import(), результатом будет отклоненный промис с ошибкой ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING.

Если importModuleDynamically имеет значение vm.constants.USE_MAIN_CONTEXT_DEFAULT_LOADER

В настоящее время этот параметр не поддерживается для vm.SourceTextModule.

При использовании этого параметра, если в скомпилированном коде выполняется import(), Node.js использует загрузчик ESM по умолчанию из основного контекста, чтобы загрузить запрошенный модуль и передать его выполняемому коду.

Это предоставляет скомпилированному коду доступ к встроенным модулям Node.js, таким как fs или http. Если код выполняется в другом контексте, следует учитывать, что объекты, созданные модулями, загруженными из основного контекста, принадлежат основному контексту, а не являются встроенными классами instanceof в новом контексте.

const { Script, constants } = require('node:vm');
const script = new Script(
  'import("node:fs").then(({readFile}) => readFile instanceof Function)',
  { importModuleDynamically: constants.USE_MAIN_CONTEXT_DEFAULT_LOADER });

// false: URL loaded from the main context is not an instance of the Function
// class in the new context.
script.runInNewContext().then(console.log);

import { Script, constants } from 'node:vm';

const script = new Script(
  'import("node:fs").then(({readFile}) => readFile instanceof Function)',
  { importModuleDynamically: constants.USE_MAIN_CONTEXT_DEFAULT_LOADER });

// false: URL loaded from the main context is not an instance of the Function
// class in the new context.
script.runInNewContext().then(console.log);

Этот параметр также позволяет скрипту или функции загружать пользовательские модули:

import { Script, constants } from 'node:vm';
import { resolve } from 'node:path';
import { writeFileSync } from 'node:fs';

// Write test.js and test.txt to the directory where the current script
// being run is located.
writeFileSync(resolve(import.meta.dirname, 'test.mjs'),
              'export const filename = "./test.json";');
writeFileSync(resolve(import.meta.dirname, 'test.json'),
              '{"hello": "world"}');

// Compile a script that loads test.mjs and then test.json
// as if the script is placed in the same directory.
const script = new Script(
  `(async function() {
    const { filename } = await import('./test.mjs');
    return import(filename, { with: { type: 'json' } })
  })();`,
  {
    filename: resolve(import.meta.dirname, 'test-with-default.js'),
    importModuleDynamically: constants.USE_MAIN_CONTEXT_DEFAULT_LOADER,
  });

// { default: { hello: 'world' } }
script.runInThisContext().then(console.log);

const { Script, constants } = require('node:vm');
const { resolve } = require('node:path');
const { writeFileSync } = require('node:fs');

// Write test.js and test.txt to the directory where the current script
// being run is located.
writeFileSync(resolve(__dirname, 'test.mjs'),
              'export const filename = "./test.json";');
writeFileSync(resolve(__dirname, 'test.json'),
              '{"hello": "world"}');

// Compile a script that loads test.mjs and then test.json
// as if the script is placed in the same directory.
const script = new Script(
  `(async function() {
    const { filename } = await import('./test.mjs');
    return import(filename, { with: { type: 'json' } })
  })();`,
  {
    filename: resolve(__dirname, 'test-with-default.js'),
    importModuleDynamically: constants.USE_MAIN_CONTEXT_DEFAULT_LOADER,
  });

// { default: { hello: 'world' } }
script.runInThisContext().then(console.log);

При загрузке пользовательских модулей с помощью загрузчика по умолчанию из основного контекста следует учитывать несколько особенностей:

1. Модуль будет разрешаться относительно параметра filename, переданного в vm.Script или vm.compileFunction(). Разрешение может выполняться относительно filename, заданного абсолютным путем или строкой URL. Если filename — это строка, которая не является ни абсолютным путем, ни URL, либо имеет значение undefined, разрешение будет выполняться относительно текущего рабочего каталога процесса. В случае vm.createContext() разрешение всегда выполняется относительно текущего рабочего каталога, поскольку этот параметр используется только при отсутствии ссылающегося скрипта или модуля.
2. Для любого filename, разрешающегося в определенный путь, после загрузки процесса из этого пути конкретного модуля результат может быть кэширован, и при последующей загрузке того же модуля из того же пути будет возвращен тот же объект. Если filename — это строка URL, кэш не будет использоваться, если строка содержит другие параметры поиска. Для filename, не являющихся строками URL, в настоящее время невозможно обойти кэширование.

Если importModuleDynamically является функцией

Если importModuleDynamically является функцией, она будет вызвана при вызове import() в скомпилированном коде, чтобы пользователи могли настроить способ компиляции и вычисления запрошенного модуля. В настоящее время для работы этого параметра экземпляр Node.js необходимо запускать с флагом --experimental-vm-modules. Если флаг не установлен, этот обратный вызов будет проигнорирован. Если вычисляемый код действительно вызывает import(), результатом будет отклоненный промис с ошибкой ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING_FLAG.

Обратный вызов importModuleDynamically(specifier, referrer, importAttributes) имеет следующую сигнатуру:

• specifier <string> спецификатор, переданный в import()
• referrer <vm.Script> | <Function> | <vm.SourceTextModule> | <Object> Ссылающийся объект — это скомпилированный vm.Script для new vm.Script, vm.runInThisContext, vm.runInContext и vm.runInNewContext. Для vm.compileFunction это скомпилированный Function, для new vm.SourceTextModule — скомпилированный vm.SourceTextModule, а для vm.createContext() — контекст Object.
• importAttributes <Object> Значение "with", переданное необязательному параметру optionsExpression, или пустой объект, если значение не было указано.
• Возвращает: <Module Namespace Object> | <vm.Module> Рекомендуется возвращать vm.Module, чтобы воспользоваться отслеживанием ошибок и избежать проблем с пространствами имен, содержащими именованные экспорты функций then.

// This script must be run with --experimental-vm-modules.
import { Script, SyntheticModule } from 'node:vm';

const script = new Script('import("foo.json", { with: { type: "json" } })', {
  async importModuleDynamically(specifier, referrer, importAttributes) {
    console.log(specifier);  // 'foo.json'
    console.log(referrer);   // The compiled script
    console.log(importAttributes);  // { type: 'json' }
    const m = new SyntheticModule(['bar'], () => { });
    await m.link(() => { });
    m.setExport('bar', { hello: 'world' });
    return m;
  },
});
const result = await script.runInThisContext();
console.log(result);  //  { bar: { hello: 'world' } }

// This script must be run with --experimental-vm-modules.
const { Script, SyntheticModule } = require('node:vm');

(async function main() {
  const script = new Script('import("foo.json", { with: { type: "json" } })', {
    async importModuleDynamically(specifier, referrer, importAttributes) {
      console.log(specifier);  // 'foo.json'
      console.log(referrer);   // The compiled script
      console.log(importAttributes);  // { type: 'json' }
      const m = new SyntheticModule(['bar'], () => { });
      await m.link(() => { });
      m.setExport('bar', { hello: 'world' });
      return m;
    },
  });
  const result = await script.runInThisContext();
  console.log(result);  //  { bar: { hello: 'world' } }
})();