@checkly/playwright-core 1.51.16 → 1.51.17-beta.1

package/lib/utils/ascii.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.jsonStringifyForceASCII = jsonStringifyForceASCII;
+exports.wrapInASCIIBox = wrapInASCIIBox;
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+function wrapInASCIIBox(text, padding = 0) {
+  const lines = text.split('\n');
+  const maxLength = Math.max(...lines.map(line => line.length));
+  return ['╔' + '═'.repeat(maxLength + padding * 2) + '╗', ...lines.map(line => '║' + ' '.repeat(padding) + line + ' '.repeat(maxLength - line.length + padding) + '║'), '╚' + '═'.repeat(maxLength + padding * 2) + '╝'].join('\n');
+}
+function jsonStringifyForceASCII(object) {
+  return JSON.stringify(object).replace(/[\u007f-\uffff]/g, c => '\\u' + ('0000' + c.charCodeAt(0).toString(16)).slice(-4));
+}

package/lib/utils/comparators.js

@@ -0,0 +1,171 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getComparator = getComparator;
+var _utilsBundle = require("../utilsBundle");
+var _compare = require("../image_tools/compare");
+/**
+ * Copyright 2017 Google Inc. All rights reserved.
+ * Modifications copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const pixelmatch = require('../third_party/pixelmatch');
+const {
+  diff_match_patch,
+  DIFF_INSERT,
+  DIFF_DELETE,
+  DIFF_EQUAL
+} = require('../third_party/diff_match_patch');
+function getComparator(mimeType) {
+  if (mimeType === 'image/png') return compareImages.bind(null, 'image/png');
+  if (mimeType === 'image/jpeg') return compareImages.bind(null, 'image/jpeg');
+  if (mimeType === 'text/plain') return compareText;
+  return compareBuffersOrStrings;
+}
+const JPEG_JS_MAX_BUFFER_SIZE_IN_MB = 5 * 1024; // ~5 GB
+
+function compareBuffersOrStrings(actualBuffer, expectedBuffer) {
+  if (typeof actualBuffer === 'string') return compareText(actualBuffer, expectedBuffer);
+  if (!actualBuffer || !(actualBuffer instanceof Buffer)) return {
+    errorMessage: 'Actual result should be a Buffer or a string.'
+  };
+  if (Buffer.compare(actualBuffer, expectedBuffer)) return {
+    errorMessage: 'Buffers differ'
+  };
+  return null;
+}
+function compareImages(mimeType, actualBuffer, expectedBuffer, options = {}) {
+  var _options$comparator, _ref;
+  if (!actualBuffer || !(actualBuffer instanceof Buffer)) return {
+    errorMessage: 'Actual result should be a Buffer.'
+  };
+  validateBuffer(expectedBuffer, mimeType);
+  let actual = mimeType === 'image/png' ? _utilsBundle.PNG.sync.read(actualBuffer) : _utilsBundle.jpegjs.decode(actualBuffer, {
+    maxMemoryUsageInMB: JPEG_JS_MAX_BUFFER_SIZE_IN_MB
+  });
+  let expected = mimeType === 'image/png' ? _utilsBundle.PNG.sync.read(expectedBuffer) : _utilsBundle.jpegjs.decode(expectedBuffer, {
+    maxMemoryUsageInMB: JPEG_JS_MAX_BUFFER_SIZE_IN_MB
+  });
+  const size = {
+    width: Math.max(expected.width, actual.width),
+    height: Math.max(expected.height, actual.height)
+  };
+  let sizesMismatchError = '';
+  if (expected.width !== actual.width || expected.height !== actual.height) {
+    sizesMismatchError = `Expected an image ${expected.width}px by ${expected.height}px, received ${actual.width}px by ${actual.height}px. `;
+    actual = resizeImage(actual, size);
+    expected = resizeImage(expected, size);
+  }
+  const diff = new _utilsBundle.PNG({
+    width: size.width,
+    height: size.height
+  });
+  let count;
+  if (options.comparator === 'ssim-cie94') {
+    count = (0, _compare.compare)(expected.data, actual.data, diff.data, size.width, size.height, {
+      // All ΔE* formulae are originally designed to have the difference of 1.0 stand for a "just noticeable difference" (JND).
+      // See https://en.wikipedia.org/wiki/Color_difference#CIELAB_%CE%94E*
+      maxColorDeltaE94: 1.0
+    });
+  } else if (((_options$comparator = options.comparator) !== null && _options$comparator !== void 0 ? _options$comparator : 'pixelmatch') === 'pixelmatch') {
+    var _options$threshold;
+    count = pixelmatch(expected.data, actual.data, diff.data, size.width, size.height, {
+      threshold: (_options$threshold = options.threshold) !== null && _options$threshold !== void 0 ? _options$threshold : 0.2
+    });
+  } else {
+    throw new Error(`Configuration specifies unknown comparator "${options.comparator}"`);
+  }
+  const maxDiffPixels1 = options.maxDiffPixels;
+  const maxDiffPixels2 = options.maxDiffPixelRatio !== undefined ? expected.width * expected.height * options.maxDiffPixelRatio : undefined;
+  let maxDiffPixels;
+  if (maxDiffPixels1 !== undefined && maxDiffPixels2 !== undefined) maxDiffPixels = Math.min(maxDiffPixels1, maxDiffPixels2);else maxDiffPixels = (_ref = maxDiffPixels1 !== null && maxDiffPixels1 !== void 0 ? maxDiffPixels1 : maxDiffPixels2) !== null && _ref !== void 0 ? _ref : 0;
+  const ratio = Math.ceil(count / (expected.width * expected.height) * 100) / 100;
+  const pixelsMismatchError = count > maxDiffPixels ? `${count} pixels (ratio ${ratio.toFixed(2)} of all image pixels) are different.` : '';
+  if (pixelsMismatchError || sizesMismatchError) return {
+    errorMessage: sizesMismatchError + pixelsMismatchError,
+    diff: _utilsBundle.PNG.sync.write(diff)
+  };
+  return null;
+}
+function validateBuffer(buffer, mimeType) {
+  if (mimeType === 'image/png') {
+    const pngMagicNumber = [137, 80, 78, 71, 13, 10, 26, 10];
+    if (buffer.length < pngMagicNumber.length || !pngMagicNumber.every((byte, index) => buffer[index] === byte)) throw new Error('could not decode image as PNG.');
+  } else if (mimeType === 'image/jpeg') {
+    const jpegMagicNumber = [255, 216];
+    if (buffer.length < jpegMagicNumber.length || !jpegMagicNumber.every((byte, index) => buffer[index] === byte)) throw new Error('could not decode image as JPEG.');
+  }
+}
+function compareText(actual, expectedBuffer) {
+  if (typeof actual !== 'string') return {
+    errorMessage: 'Actual result should be a string'
+  };
+  const expected = expectedBuffer.toString('utf-8');
+  if (expected === actual) return null;
+  const dmp = new diff_match_patch();
+  const d = dmp.diff_main(expected, actual);
+  dmp.diff_cleanupSemantic(d);
+  return {
+    errorMessage: diff_prettyTerminal(d)
+  };
+}
+function diff_prettyTerminal(diffs) {
+  const html = [];
+  for (let x = 0; x < diffs.length; x++) {
+    const op = diffs[x][0]; // Operation (insert, delete, equal)
+    const data = diffs[x][1]; // Text of change.
+    const text = data;
+    switch (op) {
+      case DIFF_INSERT:
+        html[x] = _utilsBundle.colors.green(text);
+        break;
+      case DIFF_DELETE:
+        html[x] = _utilsBundle.colors.reset(_utilsBundle.colors.strikethrough(_utilsBundle.colors.red(text)));
+        break;
+      case DIFF_EQUAL:
+        html[x] = text;
+        break;
+    }
+  }
+  return html.join('');
+}
+function resizeImage(image, size) {
+  if (image.width === size.width && image.height === size.height) return image;
+  const buffer = new Uint8Array(size.width * size.height * 4);
+  for (let y = 0; y < size.height; y++) {
+    for (let x = 0; x < size.width; x++) {
+      const to = (y * size.width + x) * 4;
+      if (y < image.height && x < image.width) {
+        const from = (y * image.width + x) * 4;
+        buffer[to] = image.data[from];
+        buffer[to + 1] = image.data[from + 1];
+        buffer[to + 2] = image.data[from + 2];
+        buffer[to + 3] = image.data[from + 3];
+      } else {
+        buffer[to] = 0;
+        buffer[to + 1] = 0;
+        buffer[to + 2] = 0;
+        buffer[to + 3] = 0;
+      }
+    }
+  }
+  return {
+    data: Buffer.from(buffer),
+    width: size.width,
+    height: size.height
+  };
+}

package/lib/utils/crypto.js

@@ -0,0 +1,174 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.calculateSha1 = calculateSha1;
+exports.createGuid = createGuid;
+exports.generateSelfSignedCertificate = generateSelfSignedCertificate;
+var _crypto = _interopRequireDefault(require("crypto"));
+var _debug = require("./debug");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+function createGuid() {
+  return _crypto.default.randomBytes(16).toString('hex');
+}
+function calculateSha1(buffer) {
+  const hash = _crypto.default.createHash('sha1');
+  hash.update(buffer);
+  return hash.digest('hex');
+}
+
+// Variable-length quantity encoding aka. base-128 encoding
+function encodeBase128(value) {
+  const bytes = [];
+  do {
+    let byte = value & 0x7f;
+    value >>>= 7;
+    if (bytes.length > 0) byte |= 0x80;
+    bytes.push(byte);
+  } while (value > 0);
+  return Buffer.from(bytes.reverse());
+}
+;
+
+// ASN1/DER Speficiation:   https://www.itu.int/rec/T-REC-X.680-X.693-202102-I/en
+class DER {
+  static encodeSequence(data) {
+    return this._encode(0x30, Buffer.concat(data));
+  }
+  static encodeInteger(data) {
+    (0, _debug.assert)(data >= -128 && data <= 127);
+    return this._encode(0x02, Buffer.from([data]));
+  }
+  static encodeObjectIdentifier(oid) {
+    const parts = oid.split('.').map(v => Number(v));
+    // Encode the second part, which could be large, using base-128 encoding if necessary
+    const output = [encodeBase128(40 * parts[0] + parts[1])];
+    for (let i = 2; i < parts.length; i++) {
+      output.push(encodeBase128(parts[i]));
+    }
+    return this._encode(0x06, Buffer.concat(output));
+  }
+  static encodeNull() {
+    return Buffer.from([0x05, 0x00]);
+  }
+  static encodeSet(data) {
+    (0, _debug.assert)(data.length === 1, 'Only one item in the set is supported. We\'d need to sort the data to support more.');
+    // We expect the data to be already sorted.
+    return this._encode(0x31, Buffer.concat(data));
+  }
+  static encodeExplicitContextDependent(tag, data) {
+    return this._encode(0xa0 + tag, data);
+  }
+  static encodePrintableString(data) {
+    return this._encode(0x13, Buffer.from(data));
+  }
+  static encodeBitString(data) {
+    // The first byte of the content is the number of unused bits at the end
+    const unusedBits = 0; // Assuming all bits are used
+    const content = Buffer.concat([Buffer.from([unusedBits]), data]);
+    return this._encode(0x03, content);
+  }
+  static encodeDate(date) {
+    const year = date.getUTCFullYear();
+    const isGeneralizedTime = year >= 2050;
+    const parts = [isGeneralizedTime ? year.toString() : year.toString().slice(-2), (date.getUTCMonth() + 1).toString().padStart(2, '0'), date.getUTCDate().toString().padStart(2, '0'), date.getUTCHours().toString().padStart(2, '0'), date.getUTCMinutes().toString().padStart(2, '0'), date.getUTCSeconds().toString().padStart(2, '0')];
+    const encodedDate = parts.join('') + 'Z';
+    const tag = isGeneralizedTime ? 0x18 : 0x17; // 0x18 for GeneralizedTime, 0x17 for UTCTime
+    return this._encode(tag, Buffer.from(encodedDate));
+  }
+  static _encode(tag, data) {
+    const lengthBytes = this._encodeLength(data.length);
+    return Buffer.concat([Buffer.from([tag]), lengthBytes, data]);
+  }
+  static _encodeLength(length) {
+    if (length < 128) {
+      return Buffer.from([length]);
+    } else {
+      const lengthBytes = [];
+      while (length > 0) {
+        lengthBytes.unshift(length & 0xFF);
+        length >>= 8;
+      }
+      return Buffer.from([0x80 | lengthBytes.length, ...lengthBytes]);
+    }
+  }
+}
+
+// X.509 Specification: https://datatracker.ietf.org/doc/html/rfc2459#section-4.1
+function generateSelfSignedCertificate() {
+  const {
+    privateKey,
+    publicKey
+  } = _crypto.default.generateKeyPairSync('rsa', {
+    modulusLength: 2048
+  });
+  const publicKeyDer = publicKey.export({
+    type: 'pkcs1',
+    format: 'der'
+  });
+  const oneYearInMilliseconds = 365 * 24 * 60 * 60 * 1_000;
+  const notBefore = new Date(new Date().getTime() - oneYearInMilliseconds);
+  const notAfter = new Date(new Date().getTime() + oneYearInMilliseconds);
+
+  // List of fields / structure: https://datatracker.ietf.org/doc/html/rfc2459#section-4.1
+  const tbsCertificate = DER.encodeSequence([DER.encodeExplicitContextDependent(0, DER.encodeInteger(1)),
+  // version
+  DER.encodeInteger(1),
+  // serialNumber
+  DER.encodeSequence([DER.encodeObjectIdentifier('1.2.840.113549.1.1.11'),
+  // sha256WithRSAEncryption PKCS #1
+  DER.encodeNull()]),
+  // signature
+  DER.encodeSequence([DER.encodeSet([DER.encodeSequence([DER.encodeObjectIdentifier('2.5.4.3'),
+  // commonName X.520 DN component
+  DER.encodePrintableString('localhost')])]), DER.encodeSet([DER.encodeSequence([DER.encodeObjectIdentifier('2.5.4.10'),
+  // organizationName X.520 DN component
+  DER.encodePrintableString('Playwright Client Certificate Support')])])]),
+  // issuer
+  DER.encodeSequence([DER.encodeDate(notBefore),
+  // notBefore
+  DER.encodeDate(notAfter) // notAfter
+  ]),
+  // validity
+  DER.encodeSequence([DER.encodeSet([DER.encodeSequence([DER.encodeObjectIdentifier('2.5.4.3'),
+  // commonName X.520 DN component
+  DER.encodePrintableString('localhost')])]), DER.encodeSet([DER.encodeSequence([DER.encodeObjectIdentifier('2.5.4.10'),
+  // organizationName X.520 DN component
+  DER.encodePrintableString('Playwright Client Certificate Support')])])]),
+  // subject
+  DER.encodeSequence([DER.encodeSequence([DER.encodeObjectIdentifier('1.2.840.113549.1.1.1'),
+  // rsaEncryption PKCS #1
+  DER.encodeNull()]), DER.encodeBitString(publicKeyDer)]) // SubjectPublicKeyInfo
+  ]);
+  const signature = _crypto.default.sign('sha256', tbsCertificate, privateKey);
+  const certificate = DER.encodeSequence([tbsCertificate, DER.encodeSequence([DER.encodeObjectIdentifier('1.2.840.113549.1.1.11'),
+  // sha256WithRSAEncryption PKCS #1
+  DER.encodeNull()]), DER.encodeBitString(signature)]);
+  const certPem = ['-----BEGIN CERTIFICATE-----',
+  // Split the base64 string into lines of 64 characters
+  certificate.toString('base64').match(/.{1,64}/g).join('\n'), '-----END CERTIFICATE-----'].join('\n');
+  return {
+    cert: certPem,
+    key: privateKey.export({
+      type: 'pkcs1',
+      format: 'pem'
+    })
+  };
+}

package/lib/utils/debug.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assert = assert;
+exports.debugAssert = debugAssert;
+exports.debugMode = debugMode;
+exports.isUnderTest = isUnderTest;
+exports.setUnderTest = setUnderTest;
+var _env = require("./env");
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+function assert(value, message) {
+  if (!value) throw new Error(message || 'Assertion error');
+}
+function debugAssert(value, message) {
+  if (isUnderTest() && !value) throw new Error(message);
+}
+const debugEnv = (0, _env.getFromENV)('PWDEBUG') || '';
+function debugMode() {
+  if (debugEnv === 'console') return 'console';
+  if (debugEnv === '0' || debugEnv === 'false') return '';
+  return debugEnv ? 'inspector' : '';
+}
+let _isUnderTest = !!process.env.PWTEST_UNDER_TEST;
+function setUnderTest() {
+  _isUnderTest = true;
+}
+function isUnderTest() {
+  return _isUnderTest;
+}

package/lib/utils/debugLogger.js

@@ -0,0 +1,91 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.debugLogger = exports.RecentLogsCollector = void 0;
+var _utilsBundle = require("../utilsBundle");
+var _fs = _interopRequireDefault(require("fs"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const debugLoggerColorMap = {
+  'api': 45,
+  // cyan
+  'protocol': 34,
+  // green
+  'install': 34,
+  // green
+  'download': 34,
+  // green
+  'browser': 0,
+  // reset
+  'socks': 92,
+  // purple
+  'client-certificates': 92,
+  // purple
+  'error': 160,
+  // red,
+  'channel': 33,
+  // blue
+  'server': 45,
+  // cyan
+  'server:channel': 34,
+  // green
+  'server:metadata': 33 // blue
+};
+class DebugLogger {
+  constructor() {
+    this._debuggers = new Map();
+    if (process.env.DEBUG_FILE) {
+      const ansiRegex = new RegExp(['[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)', '(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))'].join('|'), 'g');
+      const stream = _fs.default.createWriteStream(process.env.DEBUG_FILE);
+      _utilsBundle.debug.log = data => {
+        stream.write(data.replace(ansiRegex, ''));
+        stream.write('\n');
+      };
+    }
+  }
+  log(name, message) {
+    let cachedDebugger = this._debuggers.get(name);
+    if (!cachedDebugger) {
+      cachedDebugger = (0, _utilsBundle.debug)(`pw:${name}`);
+      this._debuggers.set(name, cachedDebugger);
+      cachedDebugger.color = debugLoggerColorMap[name] || 0;
+    }
+    cachedDebugger(message);
+  }
+  isEnabled(name) {
+    return _utilsBundle.debug.enabled(`pw:${name}`);
+  }
+}
+const debugLogger = exports.debugLogger = new DebugLogger();
+const kLogCount = 150;
+class RecentLogsCollector {
+  constructor() {
+    this._logs = [];
+  }
+  log(message) {
+    this._logs.push(message);
+    if (this._logs.length === kLogCount * 2) this._logs.splice(0, kLogCount);
+  }
+  recentLogs() {
+    if (this._logs.length > kLogCount) return this._logs.slice(-kLogCount);
+    return this._logs;
+  }
+}
+exports.RecentLogsCollector = RecentLogsCollector;

package/lib/utils/env.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getAsBooleanFromENV = getAsBooleanFromENV;
+exports.getFromENV = getFromENV;
+exports.getPackageManager = getPackageManager;
+exports.getPackageManagerExecCommand = getPackageManagerExecCommand;
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+function getFromENV(name) {
+  let value = process.env[name];
+  value = value === undefined ? process.env[`npm_config_${name.toLowerCase()}`] : value;
+  value = value === undefined ? process.env[`npm_package_config_${name.toLowerCase()}`] : value;
+  return value;
+}
+function getAsBooleanFromENV(name, defaultValue) {
+  const value = getFromENV(name);
+  if (value === 'false' || value === '0') return false;
+  if (value) return true;
+  return !!defaultValue;
+}
+function getPackageManager() {
+  const env = process.env.npm_config_user_agent || '';
+  if (env.includes('yarn')) return 'yarn';
+  if (env.includes('pnpm')) return 'pnpm';
+  return 'npm';
+}
+function getPackageManagerExecCommand() {
+  const packageManager = getPackageManager();
+  if (packageManager === 'yarn') return 'yarn';
+  if (packageManager === 'pnpm') return 'pnpm exec';
+  return 'npx';
+}

package/lib/utils/eventsHelper.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.eventsHelper = void 0;
+/**
+ * Copyright 2017 Google Inc. All rights reserved.
+ * Modifications copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class EventsHelper {
+  static addEventListener(emitter, eventName, handler) {
+    emitter.on(eventName, handler);
+    return {
+      emitter,
+      eventName,
+      handler
+    };
+  }
+  static removeEventListeners(listeners) {
+    for (const listener of listeners) listener.emitter.removeListener(listener.eventName, listener.handler);
+    listeners.splice(0, listeners.length);
+  }
+}
+const eventsHelper = exports.eventsHelper = EventsHelper;