From 4b59a429dba6f6bf641264a15801b79fc2266e54 Mon Sep 17 00:00:00 2001 From: CrazyMax Date: Mon, 28 Feb 2022 08:28:55 +0100 Subject: [PATCH] update to node 16 Signed-off-by: CrazyMax --- __tests__/aws.test.ts | 1 + __tests__/context.test.ts | 1 + __tests__/docker.test.ts | 23 +- __tests__/main.test.ts | 31 +- action.yml | 2 +- dist/bridge.js | 984 - dist/events.js | 1033 - dist/index.js | 52721 ++--------------------------------- dist/setup-node-sandbox.js | 473 - dist/setup-sandbox.js | 462 - docker-bake.hcl | 2 +- jest.config.js | 2 - package.json | 28 +- src/aws.ts | 7 +- src/main.ts | 2 +- tsconfig.json | 6 +- yarn.lock | 2803 +- 17 files changed, 2541 insertions(+), 56040 deletions(-) delete mode 100644 dist/bridge.js delete mode 100644 dist/events.js delete mode 100644 dist/setup-node-sandbox.js delete mode 100644 dist/setup-sandbox.js diff --git a/__tests__/aws.test.ts b/__tests__/aws.test.ts index 4a6a583..30e82a6 100644 --- a/__tests__/aws.test.ts +++ b/__tests__/aws.test.ts @@ -1,3 +1,4 @@ +import {beforeEach, describe, expect, jest, test} from '@jest/globals'; import {AuthorizationData} from '@aws-sdk/client-ecr'; import * as aws from '../src/aws'; diff --git a/__tests__/context.test.ts b/__tests__/context.test.ts index ec4a394..f6e430d 100644 --- a/__tests__/context.test.ts +++ b/__tests__/context.test.ts @@ -1,3 +1,4 @@ +import {expect, test} from '@jest/globals'; import {getInputs} from '../src/context'; test('with password and username getInputs does not throw error', async () => { diff --git a/__tests__/docker.test.ts b/__tests__/docker.test.ts index 8691b87..1914161 100644 --- a/__tests__/docker.test.ts +++ b/__tests__/docker.test.ts @@ -1,20 +1,19 @@ +import {expect, jest, test} from '@jest/globals'; import {loginStandard, logout} from '../src/docker'; - import * as path from 'path'; - import * as exec from '@actions/exec'; process.env['RUNNER_TEMP'] = path.join(__dirname, 'runner'); test('loginStandard calls exec', async () => { - const execSpy: jest.SpyInstance = jest.spyOn(exec, 'getExecOutput'); - execSpy.mockImplementation(() => - Promise.resolve({ + // @ts-ignore + const execSpy = jest.spyOn(exec, 'getExecOutput').mockImplementation(async () => { + return { exitCode: expect.any(Number), stdout: expect.any(Function), stderr: expect.any(Function) - }) - ); + }; + }); const username: string = 'dbowie'; const password: string = 'groundcontrol'; @@ -30,14 +29,14 @@ test('loginStandard calls exec', async () => { }); test('logout calls exec', async () => { - const execSpy: jest.SpyInstance = jest.spyOn(exec, 'getExecOutput'); - execSpy.mockImplementation(() => - Promise.resolve({ + // @ts-ignore + const execSpy = jest.spyOn(exec, 'getExecOutput').mockImplementation(async () => { + return { exitCode: expect.any(Number), stdout: expect.any(Function), stderr: expect.any(Function) - }) - ); + }; + }); const registry: string = 'https://ghcr.io'; diff --git a/__tests__/main.test.ts b/__tests__/main.test.ts index dd5f998..2fcbe87 100644 --- a/__tests__/main.test.ts +++ b/__tests__/main.test.ts @@ -1,3 +1,4 @@ +import {expect, jest, test} from '@jest/globals'; import osm = require('os'); import {run} from '../src/main'; @@ -7,26 +8,20 @@ import * as stateHelper from '../src/state-helper'; import * as core from '@actions/core'; test('errors without username and password', async () => { - const platSpy = jest.spyOn(osm, 'platform'); - platSpy.mockImplementation(() => 'linux'); + const platSpy = jest.spyOn(osm, 'platform').mockImplementation(() => 'linux'); process.env['INPUT_LOGOUT'] = 'true'; // default value - - const coreSpy: jest.SpyInstance = jest.spyOn(core, 'setFailed'); + const coreSpy = jest.spyOn(core, 'setFailed'); await run(); - expect(coreSpy).toHaveBeenCalledWith('Username and password required'); }); test('successful with username and password', async () => { - const platSpy = jest.spyOn(osm, 'platform'); - platSpy.mockImplementation(() => 'linux'); - - const setRegistrySpy: jest.SpyInstance = jest.spyOn(stateHelper, 'setRegistry'); - const setLogoutSpy: jest.SpyInstance = jest.spyOn(stateHelper, 'setLogout'); - const dockerSpy: jest.SpyInstance = jest.spyOn(docker, 'login'); - dockerSpy.mockImplementation(() => {}); + const platSpy = jest.spyOn(osm, 'platform').mockImplementation(() => 'linux'); + const setRegistrySpy = jest.spyOn(stateHelper, 'setRegistry'); + const setLogoutSpy = jest.spyOn(stateHelper, 'setLogout'); + const dockerSpy = jest.spyOn(docker, 'login').mockImplementation(jest.fn()); const username: string = 'dbowie'; process.env[`INPUT_USERNAME`] = username; @@ -48,13 +43,11 @@ test('successful with username and password', async () => { }); test('calls docker login', async () => { - const platSpy = jest.spyOn(osm, 'platform'); - platSpy.mockImplementation(() => 'linux'); - - const setRegistrySpy: jest.SpyInstance = jest.spyOn(stateHelper, 'setRegistry'); - const setLogoutSpy: jest.SpyInstance = jest.spyOn(stateHelper, 'setLogout'); - const dockerSpy: jest.SpyInstance = jest.spyOn(docker, 'login'); - dockerSpy.mockImplementation(() => {}); + const platSpy = jest.spyOn(osm, 'platform').mockImplementation(() => 'linux'); + const setRegistrySpy = jest.spyOn(stateHelper, 'setRegistry'); + const setLogoutSpy = jest.spyOn(stateHelper, 'setLogout'); + const dockerSpy = jest.spyOn(docker, 'login'); + dockerSpy.mockImplementation(jest.fn()); const username: string = 'dbowie'; process.env[`INPUT_USERNAME`] = username; diff --git a/action.yml b/action.yml index 5e837ac..fd47c79 100644 --- a/action.yml +++ b/action.yml @@ -26,6 +26,6 @@ inputs: required: false runs: - using: 'node12' + using: 'node16' main: 'dist/index.js' post: 'dist/index.js' diff --git a/dist/bridge.js b/dist/bridge.js deleted file mode 100644 index 6679478..0000000 --- a/dist/bridge.js +++ /dev/null @@ -1,984 +0,0 @@ -/******/ (() => { // webpackBootstrap -/******/ "use strict"; -/******/ var __webpack_modules__ = ({ - -/***/ 989: -/***/ ((__unused_webpack_module, exports) => { - - - -/** - * __ ___ ____ _ _ ___ _ _ ____ - * \ \ / / \ | _ \| \ | |_ _| \ | |/ ___| - * \ \ /\ / / _ \ | |_) | \| || || \| | | _ - * \ V V / ___ \| _ <| |\ || || |\ | |_| | - * \_/\_/_/ \_\_| \_\_| \_|___|_| \_|\____| - * - * This file is critical for vm2. It implements the bridge between the host and the sandbox. - * If you do not know exactly what you are doing, you should NOT edit this file. - * - * The file is loaded in the host and sandbox to handle objects in both directions. - * This is done to ensure that RangeErrors are from the correct context. - * The boundary between the sandbox and host might throw RangeErrors from both contexts. - * Therefore, thisFromOther and friends can handle objects from both domains. - * - * Method parameters have comments to tell from which context they came. - * - */ - -const globalsList = [ - 'Number', - 'String', - 'Boolean', - 'Date', - 'RegExp', - 'Map', - 'WeakMap', - 'Set', - 'WeakSet', - 'Promise', - 'Function' -]; - -const errorsList = [ - 'RangeError', - 'ReferenceError', - 'SyntaxError', - 'TypeError', - 'EvalError', - 'URIError', - 'Error' -]; - -const OPNA = 'Operation not allowed on contextified object.'; - -const thisGlobalPrototypes = { - __proto__: null, - Object: Object.prototype, - Array: Array.prototype -}; - -for (let i = 0; i < globalsList.length; i++) { - const key = globalsList[i]; - const g = global[key]; - if (g) thisGlobalPrototypes[key] = g.prototype; -} - -for (let i = 0; i < errorsList.length; i++) { - const key = errorsList[i]; - const g = global[key]; - if (g) thisGlobalPrototypes[key] = g.prototype; -} - -const { - getPrototypeOf: thisReflectGetPrototypeOf, - setPrototypeOf: thisReflectSetPrototypeOf, - defineProperty: thisReflectDefineProperty, - deleteProperty: thisReflectDeleteProperty, - getOwnPropertyDescriptor: thisReflectGetOwnPropertyDescriptor, - isExtensible: thisReflectIsExtensible, - preventExtensions: thisReflectPreventExtensions, - apply: thisReflectApply, - construct: thisReflectConstruct, - set: thisReflectSet, - get: thisReflectGet, - has: thisReflectHas, - ownKeys: thisReflectOwnKeys, - enumerate: thisReflectEnumerate, -} = Reflect; - -const thisObject = Object; -const { - freeze: thisObjectFreeze, - prototype: thisObjectPrototype -} = thisObject; -const thisObjectHasOwnProperty = thisObjectPrototype.hasOwnProperty; -const ThisProxy = Proxy; -const ThisWeakMap = WeakMap; -const { - get: thisWeakMapGet, - set: thisWeakMapSet -} = ThisWeakMap.prototype; -const ThisMap = Map; -const thisMapGet = ThisMap.prototype.get; -const thisMapSet = ThisMap.prototype.set; -const thisFunction = Function; -const thisFunctionBind = thisFunction.prototype.bind; -const thisArrayIsArray = Array.isArray; -const thisErrorCaptureStackTrace = Error.captureStackTrace; - -const thisSymbolToString = Symbol.prototype.toString; -const thisSymbolToStringTag = Symbol.toStringTag; - -/** - * VMError. - * - * @public - * @extends {Error} - */ -class VMError extends Error { - - /** - * Create VMError instance. - * - * @public - * @param {string} message - Error message. - * @param {string} code - Error code. - */ - constructor(message, code) { - super(message); - - this.name = 'VMError'; - this.code = code; - - thisErrorCaptureStackTrace(this, this.constructor); - } -} - -thisGlobalPrototypes['VMError'] = VMError.prototype; - -function thisUnexpected() { - return new VMError('Unexpected'); -} - -if (!thisReflectSetPrototypeOf(exports, null)) throw thisUnexpected(); - -function thisSafeGetOwnPropertyDescriptor(obj, key) { - const desc = thisReflectGetOwnPropertyDescriptor(obj, key); - if (!desc) return desc; - if (!thisReflectSetPrototypeOf(desc, null)) throw thisUnexpected(); - return desc; -} - -function thisThrowCallerCalleeArgumentsAccess(key) { - 'use strict'; - thisThrowCallerCalleeArgumentsAccess[key]; - return thisUnexpected(); -} - -function thisIdMapping(factory, other) { - return other; -} - -const thisThrowOnKeyAccessHandler = thisObjectFreeze({ - __proto__: null, - get(target, key, receiver) { - if (typeof key === 'symbol') { - key = thisReflectApply(thisSymbolToString, key, []); - } - throw new VMError(`Unexpected access to key '${key}'`); - } -}); - -const emptyForzenObject = thisObjectFreeze({ - __proto__: null -}); - -const thisThrowOnKeyAccess = new ThisProxy(emptyForzenObject, thisThrowOnKeyAccessHandler); - -function SafeBase() {} - -if (!thisReflectDefineProperty(SafeBase, 'prototype', { - __proto__: null, - value: thisThrowOnKeyAccess -})) throw thisUnexpected(); - -function SHARED_FUNCTION() {} - -const TEST_PROXY_HANDLER = thisObjectFreeze({ - __proto__: thisThrowOnKeyAccess, - construct() { - return this; - } -}); - -function thisIsConstructor(obj) { - // Note: obj@any(unsafe) - const Func = new ThisProxy(obj, TEST_PROXY_HANDLER); - try { - // eslint-disable-next-line no-new - new Func(); - return true; - } catch (e) { - return false; - } -} - -function thisCreateTargetObject(obj, proto) { - // Note: obj@any(unsafe) proto@any(unsafe) returns@this(unsafe) throws@this(unsafe) - let base; - if (typeof obj === 'function') { - if (thisIsConstructor(obj)) { - // Bind the function since bound functions do not have a prototype property. - base = thisReflectApply(thisFunctionBind, SHARED_FUNCTION, [null]); - } else { - base = () => {}; - } - } else if (thisArrayIsArray(obj)) { - base = []; - } else { - return {__proto__: proto}; - } - if (!thisReflectSetPrototypeOf(base, proto)) throw thisUnexpected(); - return base; -} - -function createBridge(otherInit, registerProxy) { - - const mappingOtherToThis = new ThisWeakMap(); - const protoMappings = new ThisMap(); - const protoName = new ThisMap(); - - function thisAddProtoMapping(proto, other, name) { - // Note: proto@this(unsafe) other@other(unsafe) name@this(unsafe) throws@this(unsafe) - thisReflectApply(thisMapSet, protoMappings, [proto, thisIdMapping]); - thisReflectApply(thisMapSet, protoMappings, [other, - (factory, object) => thisProxyOther(factory, object, proto)]); - if (name) thisReflectApply(thisMapSet, protoName, [proto, name]); - } - - function thisAddProtoMappingFactory(protoFactory, other, name) { - // Note: protoFactory@this(unsafe) other@other(unsafe) name@this(unsafe) throws@this(unsafe) - let proto; - thisReflectApply(thisMapSet, protoMappings, [other, - (factory, object) => { - if (!proto) { - proto = protoFactory(); - thisReflectApply(thisMapSet, protoMappings, [proto, thisIdMapping]); - if (name) thisReflectApply(thisMapSet, protoName, [proto, name]); - } - return thisProxyOther(factory, object, proto); - }]); - } - - const result = { - __proto__: null, - globalPrototypes: thisGlobalPrototypes, - safeGetOwnPropertyDescriptor: thisSafeGetOwnPropertyDescriptor, - fromArguments: thisFromOtherArguments, - from: thisFromOther, - fromWithFactory: thisFromOtherWithFactory, - ensureThis: thisEnsureThis, - mapping: mappingOtherToThis, - connect: thisConnect, - reflectSet: thisReflectSet, - reflectGet: thisReflectGet, - reflectDefineProperty: thisReflectDefineProperty, - reflectDeleteProperty: thisReflectDeleteProperty, - reflectApply: thisReflectApply, - reflectConstruct: thisReflectConstruct, - reflectHas: thisReflectHas, - reflectOwnKeys: thisReflectOwnKeys, - reflectEnumerate: thisReflectEnumerate, - reflectGetPrototypeOf: thisReflectGetPrototypeOf, - reflectIsExtensible: thisReflectIsExtensible, - reflectPreventExtensions: thisReflectPreventExtensions, - objectHasOwnProperty: thisObjectHasOwnProperty, - weakMapSet: thisWeakMapSet, - addProtoMapping: thisAddProtoMapping, - addProtoMappingFactory: thisAddProtoMappingFactory, - defaultFactory, - protectedFactory, - readonlyFactory, - VMError - }; - - const isHost = typeof otherInit !== 'object'; - - if (isHost) { - otherInit = otherInit(result, registerProxy); - } - - result.other = otherInit; - - const { - globalPrototypes: otherGlobalPrototypes, - safeGetOwnPropertyDescriptor: otherSafeGetOwnPropertyDescriptor, - fromArguments: otherFromThisArguments, - from: otherFromThis, - mapping: mappingThisToOther, - reflectSet: otherReflectSet, - reflectGet: otherReflectGet, - reflectDefineProperty: otherReflectDefineProperty, - reflectDeleteProperty: otherReflectDeleteProperty, - reflectApply: otherReflectApply, - reflectConstruct: otherReflectConstruct, - reflectHas: otherReflectHas, - reflectOwnKeys: otherReflectOwnKeys, - reflectEnumerate: otherReflectEnumerate, - reflectGetPrototypeOf: otherReflectGetPrototypeOf, - reflectIsExtensible: otherReflectIsExtensible, - reflectPreventExtensions: otherReflectPreventExtensions, - objectHasOwnProperty: otherObjectHasOwnProperty, - weakMapSet: otherWeakMapSet - } = otherInit; - - function thisOtherHasOwnProperty(object, key) { - // Note: object@other(safe) key@prim throws@this(unsafe) - try { - return otherReflectApply(otherObjectHasOwnProperty, object, [key]) === true; - } catch (e) { // @other(unsafe) - throw thisFromOther(e); - } - } - - function thisDefaultGet(handler, object, key, desc) { - // Note: object@other(unsafe) key@prim desc@other(safe) - let ret; // @other(unsafe) - if (desc.get || desc.set) { - const getter = desc.get; - if (!getter) return undefined; - try { - ret = otherReflectApply(getter, object, [key]); - } catch (e) { - throw thisFromOther(e); - } - } else { - ret = desc.value; - } - return handler.fromOtherWithContext(ret); - } - - function otherFromThisIfAvailable(to, from, key) { - // Note: to@other(safe) from@this(safe) key@prim throws@this(unsafe) - if (!thisReflectApply(thisObjectHasOwnProperty, from, [key])) return false; - try { - to[key] = otherFromThis(from[key]); - } catch (e) { // @other(unsafe) - throw thisFromOther(e); - } - return true; - } - - class BaseHandler extends SafeBase { - - constructor(object) { - // Note: object@other(unsafe) throws@this(unsafe) - super(); - this.object = object; - } - - getFactory() { - return defaultFactory; - } - - fromOtherWithContext(other) { - // Note: other@other(unsafe) throws@this(unsafe) - return thisFromOtherWithFactory(this.getFactory(), other); - } - - doPreventExtensions(target, object, factory) { - // Note: target@this(unsafe) object@other(unsafe) throws@this(unsafe) - let keys; // @other(safe-array-of-prim) - try { - keys = otherReflectOwnKeys(object); - } catch (e) { // @other(unsafe) - throw thisFromOther(e); - } - for (let i = 0; i < keys.length; i++) { - const key = keys[i]; // @prim - let desc; - try { - desc = otherSafeGetOwnPropertyDescriptor(object, key); - } catch (e) { // @other(unsafe) - throw thisFromOther(e); - } - if (!desc) continue; - if (!desc.configurable) { - const current = thisSafeGetOwnPropertyDescriptor(target, key); - if (current && !current.configurable) continue; - if (desc.get || desc.set) { - desc.get = this.fromOtherWithContext(desc.get); - desc.set = this.fromOtherWithContext(desc.set); - } else if (typeof object === 'function' && (key === 'caller' || key === 'callee' || key === 'arguments')) { - desc.value = null; - } else { - desc.value = this.fromOtherWithContext(desc.value); - } - } else { - if (desc.get || desc.set) { - desc = { - __proto__: null, - configurable: true, - enumerable: desc.enumerable, - writable: true, - value: null - }; - } else { - desc.value = null; - } - } - if (!thisReflectDefineProperty(target, key, desc)) throw thisUnexpected(); - } - if (!thisReflectPreventExtensions(target)) throw thisUnexpected(); - } - - get(target, key, receiver) { - // Note: target@this(unsafe) key@prim receiver@this(unsafe) throws@this(unsafe) - const object = this.object; // @other(unsafe) - switch (key) { - case 'constructor': { - const desc = otherSafeGetOwnPropertyDescriptor(object, key); - if (desc) return thisDefaultGet(this, object, key, desc); - const proto = thisReflectGetPrototypeOf(target); - return proto === null ? undefined : proto.constructor; - } - case '__proto__': { - const desc = otherSafeGetOwnPropertyDescriptor(object, key); - if (desc) return thisDefaultGet(this, object, key, desc); - return thisReflectGetPrototypeOf(target); - } - case thisSymbolToStringTag: - if (!thisOtherHasOwnProperty(object, thisSymbolToStringTag)) { - const proto = thisReflectGetPrototypeOf(target); - const name = thisReflectApply(thisMapGet, protoName, [proto]); - if (name) return name; - } - break; - case 'arguments': - case 'caller': - case 'callee': - if (thisOtherHasOwnProperty(object, key)) throw thisThrowCallerCalleeArgumentsAccess(key); - break; - } - let ret; // @other(unsafe) - try { - ret = otherReflectGet(object, key); - } catch (e) { // @other(unsafe) - throw thisFromOther(e); - } - return this.fromOtherWithContext(ret); - } - - set(target, key, value, receiver) { - // Note: target@this(unsafe) key@prim value@this(unsafe) receiver@this(unsafe) throws@this(unsafe) - const object = this.object; // @other(unsafe) - if (key === '__proto__' && !thisOtherHasOwnProperty(object, key)) { - return this.setPrototypeOf(target, value); - } - try { - value = otherFromThis(value); - return otherReflectSet(object, key, value) === true; - } catch (e) { // @other(unsafe) - throw thisFromOther(e); - } - } - - getPrototypeOf(target) { - // Note: target@this(unsafe) - return thisReflectGetPrototypeOf(target); - } - - setPrototypeOf(target, value) { - // Note: target@this(unsafe) throws@this(unsafe) - throw new VMError(OPNA); - } - - apply(target, context, args) { - // Note: target@this(unsafe) context@this(unsafe) args@this(safe-array) throws@this(unsafe) - const object = this.object; // @other(unsafe) - let ret; // @other(unsafe) - try { - context = otherFromThis(context); - args = otherFromThisArguments(args); - ret = otherReflectApply(object, context, args); - } catch (e) { // @other(unsafe) - throw thisFromOther(e); - } - return thisFromOther(ret); - } - - construct(target, args, newTarget) { - // Note: target@this(unsafe) args@this(safe-array) newTarget@this(unsafe) throws@this(unsafe) - const object = this.object; // @other(unsafe) - let ret; // @other(unsafe) - try { - args = otherFromThisArguments(args); - ret = otherReflectConstruct(object, args); - } catch (e) { // @other(unsafe) - throw thisFromOther(e); - } - return thisFromOtherWithFactory(this.getFactory(), ret, thisFromOther(object)); - } - - getOwnPropertyDescriptorDesc(target, prop, desc) { - // Note: target@this(unsafe) prop@prim desc@other{safe} throws@this(unsafe) - const object = this.object; // @other(unsafe) - if (desc && typeof object === 'function' && (prop === 'arguments' || prop === 'caller' || prop === 'callee')) desc.value = null; - return desc; - } - - getOwnPropertyDescriptor(target, prop) { - // Note: target@this(unsafe) prop@prim throws@this(unsafe) - const object = this.object; // @other(unsafe) - let desc; // @other(safe) - try { - desc = otherSafeGetOwnPropertyDescriptor(object, prop); - } catch (e) { // @other(unsafe) - throw thisFromOther(e); - } - - desc = this.getOwnPropertyDescriptorDesc(target, prop, desc); - - if (!desc) return undefined; - - let thisDesc; - if (desc.get || desc.set) { - thisDesc = { - __proto__: null, - get: this.fromOtherWithContext(desc.get), - set: this.fromOtherWithContext(desc.set), - enumerable: desc.enumerable === true, - configurable: desc.configurable === true - }; - } else { - thisDesc = { - __proto__: null, - value: this.fromOtherWithContext(desc.value), - writable: desc.writable === true, - enumerable: desc.enumerable === true, - configurable: desc.configurable === true - }; - } - if (!thisDesc.configurable) { - const oldDesc = thisSafeGetOwnPropertyDescriptor(target, prop); - if (!oldDesc || oldDesc.configurable || oldDesc.writable !== thisDesc.writable) { - if (!thisReflectDefineProperty(target, prop, thisDesc)) throw thisUnexpected(); - } - } - return thisDesc; - } - - definePropertyDesc(target, prop, desc) { - // Note: target@this(unsafe) prop@prim desc@this(safe) throws@this(unsafe) - return desc; - } - - defineProperty(target, prop, desc) { - // Note: target@this(unsafe) prop@prim desc@this(unsafe) throws@this(unsafe) - const object = this.object; // @other(unsafe) - if (!thisReflectSetPrototypeOf(desc, null)) throw thisUnexpected(); - - desc = this.definePropertyDesc(target, prop, desc); - - if (!desc) return false; - - let otherDesc = {__proto__: null}; - let hasFunc = true; - let hasValue = true; - let hasBasic = true; - hasFunc &= otherFromThisIfAvailable(otherDesc, desc, 'get'); - hasFunc &= otherFromThisIfAvailable(otherDesc, desc, 'set'); - hasValue &= otherFromThisIfAvailable(otherDesc, desc, 'value'); - hasValue &= otherFromThisIfAvailable(otherDesc, desc, 'writable'); - hasBasic &= otherFromThisIfAvailable(otherDesc, desc, 'enumerable'); - hasBasic &= otherFromThisIfAvailable(otherDesc, desc, 'configurable'); - - try { - if (!otherReflectDefineProperty(object, prop, otherDesc)) return false; - if (otherDesc.configurable !== true && (!hasBasic || !(hasFunc || hasValue))) { - otherDesc = otherSafeGetOwnPropertyDescriptor(object, prop); - } - } catch (e) { // @other(unsafe) - throw thisFromOther(e); - } - - if (!otherDesc.configurable) { - let thisDesc; - if (otherDesc.get || otherDesc.set) { - thisDesc = { - __proto__: null, - get: this.fromOtherWithContext(otherDesc.get), - set: this.fromOtherWithContext(otherDesc.set), - enumerable: otherDesc.enumerable, - configurable: otherDesc.configurable - }; - } else { - thisDesc = { - __proto__: null, - value: this.fromOtherWithContext(otherDesc.value), - writable: otherDesc.writable, - enumerable: otherDesc.enumerable, - configurable: otherDesc.configurable - }; - } - if (!thisReflectDefineProperty(target, prop, thisDesc)) throw thisUnexpected(); - } - return true; - } - - deleteProperty(target, prop) { - // Note: target@this(unsafe) prop@prim throws@this(unsafe) - const object = this.object; // @other(unsafe) - try { - return otherReflectDeleteProperty(object, prop) === true; - } catch (e) { // @other(unsafe) - throw thisFromOther(e); - } - } - - has(target, key) { - // Note: target@this(unsafe) key@prim throws@this(unsafe) - const object = this.object; // @other(unsafe) - try { - return otherReflectHas(object, key) === true; - } catch (e) { // @other(unsafe) - throw thisFromOther(e); - } - } - - isExtensible(target) { - // Note: target@this(unsafe) throws@this(unsafe) - const object = this.object; // @other(unsafe) - try { - if (otherReflectIsExtensible(object)) return true; - } catch (e) { // @other(unsafe) - throw thisFromOther(e); - } - if (thisReflectIsExtensible(target)) { - this.doPreventExtensions(target, object, this); - } - return false; - } - - ownKeys(target) { - // Note: target@this(unsafe) throws@this(unsafe) - const object = this.object; // @other(unsafe) - let res; // @other(unsafe) - try { - res = otherReflectOwnKeys(object); - } catch (e) { // @other(unsafe) - throw thisFromOther(e); - } - return thisFromOther(res); - } - - preventExtensions(target) { - // Note: target@this(unsafe) throws@this(unsafe) - const object = this.object; // @other(unsafe) - try { - if (!otherReflectPreventExtensions(object)) return false; - } catch (e) { // @other(unsafe) - throw thisFromOther(e); - } - if (thisReflectIsExtensible(target)) { - this.doPreventExtensions(target, object, this); - } - return true; - } - - enumerate(target) { - // Note: target@this(unsafe) throws@this(unsafe) - const object = this.object; // @other(unsafe) - let res; // @other(unsafe) - try { - res = otherReflectEnumerate(object); - } catch (e) { // @other(unsafe) - throw thisFromOther(e); - } - return this.fromOtherWithContext(res); - } - - } - - function defaultFactory(object) { - // Note: other@other(unsafe) returns@this(unsafe) throws@this(unsafe) - return new BaseHandler(object); - } - - class ProtectedHandler extends BaseHandler { - - getFactory() { - return protectedFactory; - } - - set(target, key, value, receiver) { - // Note: target@this(unsafe) key@prim value@this(unsafe) receiver@this(unsafe) throws@this(unsafe) - if (typeof value === 'function') { - return thisReflectDefineProperty(receiver, key, { - __proto__: null, - value: value, - writable: true, - enumerable: true, - configurable: true - }) === true; - } - return super.set(target, key, value, receiver); - } - - definePropertyDesc(target, prop, desc) { - // Note: target@this(unsafe) prop@prim desc@this(safe) throws@this(unsafe) - if (desc && (desc.set || desc.get || typeof desc.value === 'function')) return undefined; - return desc; - } - - } - - function protectedFactory(object) { - // Note: other@other(unsafe) returns@this(unsafe) throws@this(unsafe) - return new ProtectedHandler(object); - } - - class ReadOnlyHandler extends BaseHandler { - - getFactory() { - return readonlyFactory; - } - - set(target, key, value, receiver) { - // Note: target@this(unsafe) key@prim value@this(unsafe) receiver@this(unsafe) throws@this(unsafe) - return thisReflectDefineProperty(receiver, key, { - __proto__: null, - value: value, - writable: true, - enumerable: true, - configurable: true - }); - } - - setPrototypeOf(target, value) { - // Note: target@this(unsafe) throws@this(unsafe) - return false; - } - - defineProperty(target, prop, desc) { - // Note: target@this(unsafe) prop@prim desc@this(unsafe) throws@this(unsafe) - return false; - } - - deleteProperty(target, prop) { - // Note: target@this(unsafe) prop@prim throws@this(unsafe) - return false; - } - - isExtensible(target) { - // Note: target@this(unsafe) throws@this(unsafe) - return false; - } - - preventExtensions(target) { - // Note: target@this(unsafe) throws@this(unsafe) - return false; - } - - } - - function readonlyFactory(object) { - // Note: other@other(unsafe) returns@this(unsafe) throws@this(unsafe) - return new ReadOnlyHandler(object); - } - - class ReadOnlyMockHandler extends ReadOnlyHandler { - - constructor(object, mock) { - // Note: object@other(unsafe) mock:this(unsafe) throws@this(unsafe) - super(object); - this.mock = mock; - } - - get(target, key, receiver) { - // Note: target@this(unsafe) key@prim receiver@this(unsafe) throws@this(unsafe) - const object = this.object; // @other(unsafe) - const mock = this.mock; - if (thisReflectApply(thisObjectHasOwnProperty, mock, key) && !thisOtherHasOwnProperty(object, key)) { - return mock[key]; - } - return super.get(target, key, receiver); - } - - } - - function thisFromOther(other) { - // Note: other@other(unsafe) returns@this(unsafe) throws@this(unsafe) - return thisFromOtherWithFactory(defaultFactory, other); - } - - function thisProxyOther(factory, other, proto) { - const target = thisCreateTargetObject(other, proto); - const handler = factory(other); - const proxy = new ThisProxy(target, handler); - try { - otherReflectApply(otherWeakMapSet, mappingThisToOther, [proxy, other]); - registerProxy(proxy, handler); - } catch (e) { - throw new VMError('Unexpected error'); - } - if (!isHost) { - thisReflectApply(thisWeakMapSet, mappingOtherToThis, [other, proxy]); - return proxy; - } - const proxy2 = new ThisProxy(proxy, emptyForzenObject); - try { - otherReflectApply(otherWeakMapSet, mappingThisToOther, [proxy2, other]); - registerProxy(proxy2, handler); - } catch (e) { - throw new VMError('Unexpected error'); - } - thisReflectApply(thisWeakMapSet, mappingOtherToThis, [other, proxy2]); - return proxy2; - } - - function thisEnsureThis(other) { - const type = typeof other; - switch (type) { - case 'object': - case 'function': - if (other === null) { - return null; - } else { - let proto = thisReflectGetPrototypeOf(other); - if (!proto) { - return other; - } - while (proto) { - const mapping = thisReflectApply(thisMapGet, protoMappings, [proto]); - if (mapping) { - const mapped = thisReflectApply(thisWeakMapGet, mappingOtherToThis, [other]); - if (mapped) return mapped; - return mapping(defaultFactory, other); - } - proto = thisReflectGetPrototypeOf(proto); - } - return other; - } - - case 'undefined': - case 'string': - case 'number': - case 'boolean': - case 'symbol': - case 'bigint': - return other; - - default: // new, unknown types can be dangerous - throw new VMError(`Unknown type '${type}'`); - } - } - - function thisFromOtherWithFactory(factory, other, proto) { - for (let loop = 0; loop < 10; loop++) { - const type = typeof other; - switch (type) { - case 'object': - case 'function': - if (other === null) { - return null; - } else { - const mapped = thisReflectApply(thisWeakMapGet, mappingOtherToThis, [other]); - if (mapped) return mapped; - if (proto) { - return thisProxyOther(factory, other, proto); - } - try { - proto = otherReflectGetPrototypeOf(other); - } catch (e) { // @other(unsafe) - other = e; - break; - } - if (!proto) { - return thisProxyOther(factory, other, null); - } - while (proto) { - const mapping = thisReflectApply(thisMapGet, protoMappings, [proto]); - if (mapping) return mapping(factory, other); - try { - proto = otherReflectGetPrototypeOf(proto); - } catch (e) { // @other(unsafe) - other = e; - break; - } - } - return thisProxyOther(factory, other, thisObjectPrototype); - } - - case 'undefined': - case 'string': - case 'number': - case 'boolean': - case 'symbol': - case 'bigint': - return other; - - default: // new, unknown types can be dangerous - throw new VMError(`Unknown type '${type}'`); - } - factory = defaultFactory; - proto = undefined; - } - throw new VMError('Exception recursion depth'); - } - - function thisFromOtherArguments(args) { - // Note: args@other(safe-array) returns@this(safe-array) throws@this(unsafe) - const arr = []; - for (let i = 0; i < args.length; i++) { - const value = thisFromOther(args[i]); - thisReflectDefineProperty(arr, i, { - __proto__: null, - value: value, - writable: true, - enumerable: true, - configurable: true - }); - } - return arr; - } - - function thisConnect(obj, other) { - // Note: obj@this(unsafe) other@other(unsafe) throws@this(unsafe) - try { - otherReflectApply(otherWeakMapSet, mappingThisToOther, [obj, other]); - } catch (e) { - throw new VMError('Unexpected error'); - } - thisReflectApply(thisWeakMapSet, mappingOtherToThis, [other, obj]); - } - - thisAddProtoMapping(thisGlobalPrototypes.Object, otherGlobalPrototypes.Object); - thisAddProtoMapping(thisGlobalPrototypes.Array, otherGlobalPrototypes.Array); - - for (let i = 0; i < globalsList.length; i++) { - const key = globalsList[i]; - const tp = thisGlobalPrototypes[key]; - const op = otherGlobalPrototypes[key]; - if (tp && op) thisAddProtoMapping(tp, op, key); - } - - for (let i = 0; i < errorsList.length; i++) { - const key = errorsList[i]; - const tp = thisGlobalPrototypes[key]; - const op = otherGlobalPrototypes[key]; - if (tp && op) thisAddProtoMapping(tp, op, 'Error'); - } - - thisAddProtoMapping(thisGlobalPrototypes.VMError, otherGlobalPrototypes.VMError, 'Error'); - - result.BaseHandler = BaseHandler; - result.ProtectedHandler = ProtectedHandler; - result.ReadOnlyHandler = ReadOnlyHandler; - result.ReadOnlyMockHandler = ReadOnlyMockHandler; - - return result; -} - -exports.createBridge = createBridge; -exports.VMError = VMError; - - -/***/ }) - -/******/ }); -/************************************************************************/ -/******/ /* webpack/runtime/compat */ -/******/ -/******/ if (typeof __nccwpck_require__ !== 'undefined') __nccwpck_require__.ab = __dirname + "/";/************************************************************************/ -/******/ -/******/ // startup -/******/ // Load entry module and return exports -/******/ // This entry module is referenced by other modules so it can't be inlined -/******/ var __webpack_exports__ = {}; -/******/ __webpack_modules__[989](0, __webpack_exports__); -/******/ module.exports = __webpack_exports__; -/******/ -/******/ })() -; \ No newline at end of file diff --git a/dist/events.js b/dist/events.js deleted file mode 100644 index f91938c..0000000 --- a/dist/events.js +++ /dev/null @@ -1,1033 +0,0 @@ -/******/ (() => { // webpackBootstrap -/******/ "use strict"; -/******/ var __webpack_modules__ = ({ - -/***/ 906: -/***/ ((module) => { - -// Copyright Joyent, Inc. and other Node contributors. -// -// Permission is hereby granted, free of charge, to any person obtaining a -// copy of this software and associated documentation files (the -// "Software"), to deal in the Software without restriction, including -// without limitation the rights to use, copy, modify, merge, publish, -// distribute, sublicense, and/or sell copies of the Software, and to permit -// persons to whom the Software is furnished to do so, subject to the -// following conditions: -// -// The above copyright notice and this permission notice shall be included -// in all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS -// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN -// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, -// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR -// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE -// USE OR OTHER DEALINGS IN THE SOFTWARE. - -// Modified by the vm2 team to make this a standalone module to be loaded into the sandbox. - - - -const host = fromhost; - -const { - Boolean, - Error, - String, - Symbol -} = globalThis; - -const ReflectApply = Reflect.apply; -const ReflectOwnKeys = Reflect.ownKeys; - -const ErrorCaptureStackTrace = Error.captureStackTrace; - -const NumberIsNaN = Number.isNaN; - -const ObjectCreate = Object.create; -const ObjectDefineProperty = Object.defineProperty; -const ObjectDefineProperties = Object.defineProperties; -const ObjectGetPrototypeOf = Object.getPrototypeOf; - -const SymbolFor = Symbol.for; - -function uncurryThis(func) { - return (thiz, ...args) => ReflectApply(func, thiz, args); -} - -const ArrayPrototypeIndexOf = uncurryThis(Array.prototype.indexOf); -const ArrayPrototypeJoin = uncurryThis(Array.prototype.join); -const ArrayPrototypeSlice = uncurryThis(Array.prototype.slice); -const ArrayPrototypeSplice = uncurryThis(Array.prototype.splice); -const ArrayPrototypeUnshift = uncurryThis(Array.prototype.unshift); - -const kRejection = SymbolFor('nodejs.rejection'); - -function inspect(obj) { - return typeof obj === 'symbol' ? obj.toString() : `${obj}`; -} - -function spliceOne(list, index) { - for (; index + 1 < list.length; index++) - list[index] = list[index + 1]; - list.pop(); -} - -function assert(what, message) { - if (!what) throw new Error(message); -} - -function E(key, msg, Base) { - return function NodeError(...args) { - const error = new Base(); - const message = ReflectApply(msg, error, args); - ObjectDefineProperties(error, { - message: { - value: message, - enumerable: false, - writable: true, - configurable: true, - }, - toString: { - value() { - return `${this.name} [${key}]: ${this.message}`; - }, - enumerable: false, - writable: true, - configurable: true, - }, - }); - error.code = key; - return error; - }; -} - - -const ERR_INVALID_ARG_TYPE = E('ERR_INVALID_ARG_TYPE', - (name, expected, actual) => { - assert(typeof name === 'string', "'name' must be a string"); - if (!ArrayIsArray(expected)) { - expected = [expected]; - } - - let msg = 'The '; - if (StringPrototypeEndsWith(name, ' argument')) { - // For cases like 'first argument' - msg += `${name} `; - } else { - const type = StringPrototypeIncludes(name, '.') ? 'property' : 'argument'; - msg += `"${name}" ${type} `; - } - msg += 'must be '; - - const types = []; - const instances = []; - const other = []; - - for (const value of expected) { - assert(typeof value === 'string', - 'All expected entries have to be of type string'); - if (ArrayPrototypeIncludes(kTypes, value)) { - ArrayPrototypePush(types, StringPrototypeToLowerCase(value)); - } else if (RegExpPrototypeTest(classRegExp, value)) { - ArrayPrototypePush(instances, value); - } else { - assert(value !== 'object', - 'The value "object" should be written as "Object"'); - ArrayPrototypePush(other, value); - } - } - - // Special handle `object` in case other instances are allowed to outline - // the differences between each other. - if (instances.length > 0) { - const pos = ArrayPrototypeIndexOf(types, 'object'); - if (pos !== -1) { - ArrayPrototypeSplice(types, pos, 1); - ArrayPrototypePush(instances, 'Object'); - } - } - - if (types.length > 0) { - if (types.length > 2) { - const last = ArrayPrototypePop(types); - msg += `one of type ${ArrayPrototypeJoin(types, ', ')}, or ${last}`; - } else if (types.length === 2) { - msg += `one of type ${types[0]} or ${types[1]}`; - } else { - msg += `of type ${types[0]}`; - } - if (instances.length > 0 || other.length > 0) - msg += ' or '; - } - - if (instances.length > 0) { - if (instances.length > 2) { - const last = ArrayPrototypePop(instances); - msg += - `an instance of ${ArrayPrototypeJoin(instances, ', ')}, or ${last}`; - } else { - msg += `an instance of ${instances[0]}`; - if (instances.length === 2) { - msg += ` or ${instances[1]}`; - } - } - if (other.length > 0) - msg += ' or '; - } - - if (other.length > 0) { - if (other.length > 2) { - const last = ArrayPrototypePop(other); - msg += `one of ${ArrayPrototypeJoin(other, ', ')}, or ${last}`; - } else if (other.length === 2) { - msg += `one of ${other[0]} or ${other[1]}`; - } else { - if (StringPrototypeToLowerCase(other[0]) !== other[0]) - msg += 'an '; - msg += `${other[0]}`; - } - } - - if (actual == null) { - msg += `. Received ${actual}`; - } else if (typeof actual === 'function' && actual.name) { - msg += `. Received function ${actual.name}`; - } else if (typeof actual === 'object') { - if (actual.constructor && actual.constructor.name) { - msg += `. Received an instance of ${actual.constructor.name}`; - } else { - const inspected = inspect(actual, { depth: -1 }); - msg += `. Received ${inspected}`; - } - } else { - let inspected = inspect(actual, { colors: false }); - if (inspected.length > 25) - inspected = `${StringPrototypeSlice(inspected, 0, 25)}...`; - msg += `. Received type ${typeof actual} (${inspected})`; - } - return msg; - }, TypeError); - -const ERR_INVALID_THIS = E('ERR_INVALID_THIS', s => `Value of "this" must be of type ${s}`, TypeError); - -const ERR_OUT_OF_RANGE = E('ERR_OUT_OF_RANGE', - (str, range, input, replaceDefaultBoolean = false) => { - assert(range, 'Missing "range" argument'); - let msg = replaceDefaultBoolean ? str : - `The value of "${str}" is out of range.`; - const received = inspect(input); - msg += ` It must be ${range}. Received ${received}`; - return msg; - }, RangeError); - -const ERR_UNHANDLED_ERROR = E('ERR_UNHANDLED_ERROR', - err => { - const msg = 'Unhandled error.'; - if (err === undefined) return msg; - return `${msg} (${err})`; - }, Error); - -function validateBoolean(value, name) { - if (typeof value !== 'boolean') - throw new ERR_INVALID_ARG_TYPE(name, 'boolean', value); -} - -function validateFunction(value, name) { - if (typeof value !== 'function') - throw new ERR_INVALID_ARG_TYPE(name, 'Function', value); -} - -function validateString(value, name) { - if (typeof value !== 'string') - throw new ERR_INVALID_ARG_TYPE(name, 'string', value); -} - -function nc(cond, e) { - return cond === undefined || cond === null ? e : cond; -} - -function oc(base, key) { - return base === undefined || base === null ? undefined : base[key]; -} - -const kCapture = Symbol('kCapture'); -const kErrorMonitor = host.kErrorMonitor || Symbol('events.errorMonitor'); -const kMaxEventTargetListeners = Symbol('events.maxEventTargetListeners'); -const kMaxEventTargetListenersWarned = - Symbol('events.maxEventTargetListenersWarned'); - -const kIsEventTarget = SymbolFor('nodejs.event_target'); - -function isEventTarget(obj) { - return oc(oc(obj, 'constructor'), kIsEventTarget); -} - -/** - * Creates a new `EventEmitter` instance. - * @param {{ captureRejections?: boolean; }} [opts] - * @constructs {EventEmitter} - */ -function EventEmitter(opts) { - EventEmitter.init.call(this, opts); -} -module.exports = EventEmitter; -if (host.once) module.exports.once = host.once; -if (host.on) module.exports.on = host.on; -if (host.getEventListeners) module.exports.getEventListeners = host.getEventListeners; -// Backwards-compat with node 0.10.x -EventEmitter.EventEmitter = EventEmitter; - -EventEmitter.usingDomains = false; - -EventEmitter.captureRejectionSymbol = kRejection; -ObjectDefineProperty(EventEmitter, 'captureRejections', { - get() { - return EventEmitter.prototype[kCapture]; - }, - set(value) { - validateBoolean(value, 'EventEmitter.captureRejections'); - - EventEmitter.prototype[kCapture] = value; - }, - enumerable: true -}); - -if (host.EventEmitterReferencingAsyncResource) { - const kAsyncResource = Symbol('kAsyncResource'); - const EventEmitterReferencingAsyncResource = host.EventEmitterReferencingAsyncResource; - - class EventEmitterAsyncResource extends EventEmitter { - /** - * @param {{ - * name?: string, - * triggerAsyncId?: number, - * requireManualDestroy?: boolean, - * }} [options] - */ - constructor(options = undefined) { - let name; - if (typeof options === 'string') { - name = options; - options = undefined; - } else { - if (new.target === EventEmitterAsyncResource) { - validateString(oc(options, 'name'), 'options.name'); - } - name = oc(options, 'name') || new.target.name; - } - super(options); - - this[kAsyncResource] = - new EventEmitterReferencingAsyncResource(this, name, options); - } - - /** - * @param {symbol,string} event - * @param {...any} args - * @returns {boolean} - */ - emit(event, ...args) { - if (this[kAsyncResource] === undefined) - throw new ERR_INVALID_THIS('EventEmitterAsyncResource'); - const { asyncResource } = this; - ArrayPrototypeUnshift(args, super.emit, this, event); - return ReflectApply(asyncResource.runInAsyncScope, asyncResource, - args); - } - - /** - * @returns {void} - */ - emitDestroy() { - if (this[kAsyncResource] === undefined) - throw new ERR_INVALID_THIS('EventEmitterAsyncResource'); - this.asyncResource.emitDestroy(); - } - - /** - * @type {number} - */ - get asyncId() { - if (this[kAsyncResource] === undefined) - throw new ERR_INVALID_THIS('EventEmitterAsyncResource'); - return this.asyncResource.asyncId(); - } - - /** - * @type {number} - */ - get triggerAsyncId() { - if (this[kAsyncResource] === undefined) - throw new ERR_INVALID_THIS('EventEmitterAsyncResource'); - return this.asyncResource.triggerAsyncId(); - } - - /** - * @type {EventEmitterReferencingAsyncResource} - */ - get asyncResource() { - if (this[kAsyncResource] === undefined) - throw new ERR_INVALID_THIS('EventEmitterAsyncResource'); - return this[kAsyncResource]; - } - } - EventEmitter.EventEmitterAsyncResource = EventEmitterAsyncResource; -} - -EventEmitter.errorMonitor = kErrorMonitor; - -// The default for captureRejections is false -ObjectDefineProperty(EventEmitter.prototype, kCapture, { - value: false, - writable: true, - enumerable: false -}); - -EventEmitter.prototype._events = undefined; -EventEmitter.prototype._eventsCount = 0; -EventEmitter.prototype._maxListeners = undefined; - -// By default EventEmitters will print a warning if more than 10 listeners are -// added to it. This is a useful default which helps finding memory leaks. -let defaultMaxListeners = 10; - -function checkListener(listener) { - validateFunction(listener, 'listener'); -} - -ObjectDefineProperty(EventEmitter, 'defaultMaxListeners', { - enumerable: true, - get: function() { - return defaultMaxListeners; - }, - set: function(arg) { - if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) { - throw new ERR_OUT_OF_RANGE('defaultMaxListeners', - 'a non-negative number', - arg); - } - defaultMaxListeners = arg; - } -}); - -ObjectDefineProperties(EventEmitter, { - kMaxEventTargetListeners: { - value: kMaxEventTargetListeners, - enumerable: false, - configurable: false, - writable: false, - }, - kMaxEventTargetListenersWarned: { - value: kMaxEventTargetListenersWarned, - enumerable: false, - configurable: false, - writable: false, - } -}); - -/** - * Sets the max listeners. - * @param {number} n - * @param {EventTarget[] | EventEmitter[]} [eventTargets] - * @returns {void} - */ -EventEmitter.setMaxListeners = - function(n = defaultMaxListeners, ...eventTargets) { - if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) - throw new ERR_OUT_OF_RANGE('n', 'a non-negative number', n); - if (eventTargets.length === 0) { - defaultMaxListeners = n; - } else { - for (let i = 0; i < eventTargets.length; i++) { - const target = eventTargets[i]; - if (isEventTarget(target)) { - target[kMaxEventTargetListeners] = n; - target[kMaxEventTargetListenersWarned] = false; - } else if (typeof target.setMaxListeners === 'function') { - target.setMaxListeners(n); - } else { - throw new ERR_INVALID_ARG_TYPE( - 'eventTargets', - ['EventEmitter', 'EventTarget'], - target); - } - } - } - }; - -// If you're updating this function definition, please also update any -// re-definitions, such as the one in the Domain module (lib/domain.js). -EventEmitter.init = function(opts) { - - if (this._events === undefined || - this._events === ObjectGetPrototypeOf(this)._events) { - this._events = ObjectCreate(null); - this._eventsCount = 0; - } - - this._maxListeners = this._maxListeners || undefined; - - - if (oc(opts, 'captureRejections')) { - validateBoolean(opts.captureRejections, 'options.captureRejections'); - this[kCapture] = Boolean(opts.captureRejections); - } else { - // Assigning the kCapture property directly saves an expensive - // prototype lookup in a very sensitive hot path. - this[kCapture] = EventEmitter.prototype[kCapture]; - } -}; - -function addCatch(that, promise, type, args) { - if (!that[kCapture]) { - return; - } - - // Handle Promises/A+ spec, then could be a getter - // that throws on second use. - try { - const then = promise.then; - - if (typeof then === 'function') { - then.call(promise, undefined, function(err) { - // The callback is called with nextTick to avoid a follow-up - // rejection from this promise. - process.nextTick(emitUnhandledRejectionOrErr, that, err, type, args); - }); - } - } catch (err) { - that.emit('error', err); - } -} - -function emitUnhandledRejectionOrErr(ee, err, type, args) { - if (typeof ee[kRejection] === 'function') { - ee[kRejection](err, type, ...args); - } else { - // We have to disable the capture rejections mechanism, otherwise - // we might end up in an infinite loop. - const prev = ee[kCapture]; - - // If the error handler throws, it is not catchable and it - // will end up in 'uncaughtException'. We restore the previous - // value of kCapture in case the uncaughtException is present - // and the exception is handled. - try { - ee[kCapture] = false; - ee.emit('error', err); - } finally { - ee[kCapture] = prev; - } - } -} - -/** - * Increases the max listeners of the event emitter. - * @param {number} n - * @returns {EventEmitter} - */ -EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) { - if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) { - throw new ERR_OUT_OF_RANGE('n', 'a non-negative number', n); - } - this._maxListeners = n; - return this; -}; - -function _getMaxListeners(that) { - if (that._maxListeners === undefined) - return EventEmitter.defaultMaxListeners; - return that._maxListeners; -} - -/** - * Returns the current max listener value for the event emitter. - * @returns {number} - */ -EventEmitter.prototype.getMaxListeners = function getMaxListeners() { - return _getMaxListeners(this); -}; - -/** - * Synchronously calls each of the listeners registered - * for the event. - * @param {string | symbol} type - * @param {...any} [args] - * @returns {boolean} - */ -EventEmitter.prototype.emit = function emit(type, ...args) { - let doError = (type === 'error'); - - const events = this._events; - if (events !== undefined) { - if (doError && events[kErrorMonitor] !== undefined) - this.emit(kErrorMonitor, ...args); - doError = (doError && events.error === undefined); - } else if (!doError) - return false; - - // If there is no 'error' event listener then throw. - if (doError) { - let er; - if (args.length > 0) - er = args[0]; - if (er instanceof Error) { - try { - const capture = {}; - ErrorCaptureStackTrace(capture, EventEmitter.prototype.emit); - } catch (e) {} - - // Note: The comments on the `throw` lines are intentional, they show - // up in Node's output if this results in an unhandled exception. - throw er; // Unhandled 'error' event - } - - let stringifiedEr; - try { - stringifiedEr = inspect(er); - } catch (e) { - stringifiedEr = er; - } - - // At least give some kind of context to the user - const err = new ERR_UNHANDLED_ERROR(stringifiedEr); - err.context = er; - throw err; // Unhandled 'error' event - } - - const handler = events[type]; - - if (handler === undefined) - return false; - - if (typeof handler === 'function') { - const result = handler.apply(this, args); - - // We check if result is undefined first because that - // is the most common case so we do not pay any perf - // penalty - if (result !== undefined && result !== null) { - addCatch(this, result, type, args); - } - } else { - const len = handler.length; - const listeners = arrayClone(handler); - for (let i = 0; i < len; ++i) { - const result = listeners[i].apply(this, args); - - // We check if result is undefined first because that - // is the most common case so we do not pay any perf - // penalty. - // This code is duplicated because extracting it away - // would make it non-inlineable. - if (result !== undefined && result !== null) { - addCatch(this, result, type, args); - } - } - } - - return true; -}; - -function _addListener(target, type, listener, prepend) { - let m; - let events; - let existing; - - checkListener(listener); - - events = target._events; - if (events === undefined) { - events = target._events = ObjectCreate(null); - target._eventsCount = 0; - } else { - // To avoid recursion in the case that type === "newListener"! Before - // adding it to the listeners, first emit "newListener". - if (events.newListener !== undefined) { - target.emit('newListener', type, - nc(listener.listener, listener)); - - // Re-assign `events` because a newListener handler could have caused the - // this._events to be assigned to a new object - events = target._events; - } - existing = events[type]; - } - - if (existing === undefined) { - // Optimize the case of one listener. Don't need the extra array object. - events[type] = listener; - ++target._eventsCount; - } else { - if (typeof existing === 'function') { - // Adding the second element, need to change to array. - existing = events[type] = - prepend ? [listener, existing] : [existing, listener]; - // If we've already got an array, just append. - } else if (prepend) { - existing.unshift(listener); - } else { - existing.push(listener); - } - - // Check for listener leak - m = _getMaxListeners(target); - if (m > 0 && existing.length > m && !existing.warned) { - existing.warned = true; - // No error code for this since it is a Warning - // eslint-disable-next-line no-restricted-syntax - const w = new Error('Possible EventEmitter memory leak detected. ' + - `${existing.length} ${String(type)} listeners ` + - `added to ${inspect(target, { depth: -1 })}. Use ` + - 'emitter.setMaxListeners() to increase limit'); - w.name = 'MaxListenersExceededWarning'; - w.emitter = target; - w.type = type; - w.count = existing.length; - process.emitWarning(w); - } - } - - return target; -} - -/** - * Adds a listener to the event emitter. - * @param {string | symbol} type - * @param {Function} listener - * @returns {EventEmitter} - */ -EventEmitter.prototype.addListener = function addListener(type, listener) { - return _addListener(this, type, listener, false); -}; - -EventEmitter.prototype.on = EventEmitter.prototype.addListener; - -/** - * Adds the `listener` function to the beginning of - * the listeners array. - * @param {string | symbol} type - * @param {Function} listener - * @returns {EventEmitter} - */ -EventEmitter.prototype.prependListener = - function prependListener(type, listener) { - return _addListener(this, type, listener, true); - }; - -function onceWrapper() { - if (!this.fired) { - this.target.removeListener(this.type, this.wrapFn); - this.fired = true; - if (arguments.length === 0) - return this.listener.call(this.target); - return this.listener.apply(this.target, arguments); - } -} - -function _onceWrap(target, type, listener) { - const state = { fired: false, wrapFn: undefined, target, type, listener }; - const wrapped = onceWrapper.bind(state); - wrapped.listener = listener; - state.wrapFn = wrapped; - return wrapped; -} - -/** - * Adds a one-time `listener` function to the event emitter. - * @param {string | symbol} type - * @param {Function} listener - * @returns {EventEmitter} - */ -EventEmitter.prototype.once = function once(type, listener) { - checkListener(listener); - - this.on(type, _onceWrap(this, type, listener)); - return this; -}; - -/** - * Adds a one-time `listener` function to the beginning of - * the listeners array. - * @param {string | symbol} type - * @param {Function} listener - * @returns {EventEmitter} - */ -EventEmitter.prototype.prependOnceListener = - function prependOnceListener(type, listener) { - checkListener(listener); - - this.prependListener(type, _onceWrap(this, type, listener)); - return this; - }; - - -/** - * Removes the specified `listener` from the listeners array. - * @param {string | symbol} type - * @param {Function} listener - * @returns {EventEmitter} - */ -EventEmitter.prototype.removeListener = - function removeListener(type, listener) { - checkListener(listener); - - const events = this._events; - if (events === undefined) - return this; - - const list = events[type]; - if (list === undefined) - return this; - - if (list === listener || list.listener === listener) { - if (--this._eventsCount === 0) - this._events = ObjectCreate(null); - else { - delete events[type]; - if (events.removeListener) - this.emit('removeListener', type, list.listener || listener); - } - } else if (typeof list !== 'function') { - let position = -1; - - for (let i = list.length - 1; i >= 0; i--) { - if (list[i] === listener || list[i].listener === listener) { - position = i; - break; - } - } - - if (position < 0) - return this; - - if (position === 0) - list.shift(); - else { - spliceOne(list, position); - } - - if (list.length === 1) - events[type] = list[0]; - - if (events.removeListener !== undefined) - this.emit('removeListener', type, listener); - } - - return this; - }; - -EventEmitter.prototype.off = EventEmitter.prototype.removeListener; - -/** - * Removes all listeners from the event emitter. (Only - * removes listeners for a specific event name if specified - * as `type`). - * @param {string | symbol} [type] - * @returns {EventEmitter} - */ -EventEmitter.prototype.removeAllListeners = - function removeAllListeners(type) { - const events = this._events; - if (events === undefined) - return this; - - // Not listening for removeListener, no need to emit - if (events.removeListener === undefined) { - if (arguments.length === 0) { - this._events = ObjectCreate(null); - this._eventsCount = 0; - } else if (events[type] !== undefined) { - if (--this._eventsCount === 0) - this._events = ObjectCreate(null); - else - delete events[type]; - } - return this; - } - - // Emit removeListener for all listeners on all events - if (arguments.length === 0) { - for (const key of ReflectOwnKeys(events)) { - if (key === 'removeListener') continue; - this.removeAllListeners(key); - } - this.removeAllListeners('removeListener'); - this._events = ObjectCreate(null); - this._eventsCount = 0; - return this; - } - - const listeners = events[type]; - - if (typeof listeners === 'function') { - this.removeListener(type, listeners); - } else if (listeners !== undefined) { - // LIFO order - for (let i = listeners.length - 1; i >= 0; i--) { - this.removeListener(type, listeners[i]); - } - } - - return this; - }; - -function _listeners(target, type, unwrap) { - const events = target._events; - - if (events === undefined) - return []; - - const evlistener = events[type]; - if (evlistener === undefined) - return []; - - if (typeof evlistener === 'function') - return unwrap ? [evlistener.listener || evlistener] : [evlistener]; - - return unwrap ? - unwrapListeners(evlistener) : arrayClone(evlistener); -} - -/** - * Returns a copy of the array of listeners for the event name - * specified as `type`. - * @param {string | symbol} type - * @returns {Function[]} - */ -EventEmitter.prototype.listeners = function listeners(type) { - return _listeners(this, type, true); -}; - -/** - * Returns a copy of the array of listeners and wrappers for - * the event name specified as `type`. - * @param {string | symbol} type - * @returns {Function[]} - */ -EventEmitter.prototype.rawListeners = function rawListeners(type) { - return _listeners(this, type, false); -}; - -/** - * Returns the number of listeners listening to the event name - * specified as `type`. - * @deprecated since v3.2.0 - * @param {EventEmitter} emitter - * @param {string | symbol} type - * @returns {number} - */ -EventEmitter.listenerCount = function(emitter, type) { - if (typeof emitter.listenerCount === 'function') { - return emitter.listenerCount(type); - } - return emitter.listenerCount(type); -}; - -EventEmitter.prototype.listenerCount = listenerCount; - -/** - * Returns the number of listeners listening to event name - * specified as `type`. - * @param {string | symbol} type - * @returns {number} - */ -function listenerCount(type) { - const events = this._events; - - if (events !== undefined) { - const evlistener = events[type]; - - if (typeof evlistener === 'function') { - return 1; - } else if (evlistener !== undefined) { - return evlistener.length; - } - } - - return 0; -} - -/** - * Returns an array listing the events for which - * the emitter has registered listeners. - * @returns {any[]} - */ -EventEmitter.prototype.eventNames = function eventNames() { - return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : []; -}; - -function arrayClone(arr) { - // At least since V8 8.3, this implementation is faster than the previous - // which always used a simple for-loop - switch (arr.length) { - case 2: return [arr[0], arr[1]]; - case 3: return [arr[0], arr[1], arr[2]]; - case 4: return [arr[0], arr[1], arr[2], arr[3]]; - case 5: return [arr[0], arr[1], arr[2], arr[3], arr[4]]; - case 6: return [arr[0], arr[1], arr[2], arr[3], arr[4], arr[5]]; - } - return ArrayPrototypeSlice(arr); -} - -function unwrapListeners(arr) { - const ret = arrayClone(arr); - for (let i = 0; i < ret.length; ++i) { - const orig = ret[i].listener; - if (typeof orig === 'function') - ret[i] = orig; - } - return ret; -} - - -/***/ }) - -/******/ }); -/************************************************************************/ -/******/ // The module cache -/******/ var __webpack_module_cache__ = {}; -/******/ -/******/ // The require function -/******/ function __nccwpck_require__(moduleId) { -/******/ // Check if module is in cache -/******/ var cachedModule = __webpack_module_cache__[moduleId]; -/******/ if (cachedModule !== undefined) { -/******/ return cachedModule.exports; -/******/ } -/******/ // Create a new module (and put it into the cache) -/******/ var module = __webpack_module_cache__[moduleId] = { -/******/ // no module.id needed -/******/ // no module.loaded needed -/******/ exports: {} -/******/ }; -/******/ -/******/ // Execute the module function -/******/ var threw = true; -/******/ try { -/******/ __webpack_modules__[moduleId](module, module.exports, __nccwpck_require__); -/*