node-datachannel 0.2.2 → 0.3.0

package/node_modules/decompress-response/package.json

@@ -1,59 +1,60 @@
 {
   "_args": [
     [
-      "decompress-response@4.2.1",
+      "decompress-response@6.0.0",
       "/home/runner/work/node-datachannel/node-datachannel"
     ]
   ],
-  "_from": "decompress-response@4.2.1",
-  "_id": "decompress-response@4.2.1",
+  "_from": "decompress-response@6.0.0",
+  "_id": "decompress-response@6.0.0",
   "_inBundle": false,
-  "_integrity": "sha512-jOSne2qbyE+/r8G1VU+G/82LBs2Fs4LAsTiLSHOCOMZQl2OKZ6i8i4IyHemTe+/yIXOtTcRQMzPcgyhoFlqPkw==",
+  "_integrity": "sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==",
   "_location": "/decompress-response",
   "_phantomChildren": {},
   "_requested": {
     "type": "version",
     "registry": true,
-    "raw": "decompress-response@4.2.1",
+    "raw": "decompress-response@6.0.0",
     "name": "decompress-response",
     "escapedName": "decompress-response",
-    "rawSpec": "4.2.1",
+    "rawSpec": "6.0.0",
     "saveSpec": null,
-    "fetchSpec": "4.2.1"
+    "fetchSpec": "6.0.0"
   },
   "_requiredBy": [
     "/simple-get"
   ],
-  "_resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-4.2.1.tgz",
-  "_spec": "4.2.1",
+  "_resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-6.0.0.tgz",
+  "_spec": "6.0.0",
   "_where": "/home/runner/work/node-datachannel/node-datachannel",
   "author": {
     "name": "Sindre Sorhus",
     "email": "sindresorhus@gmail.com",
-    "url": "sindresorhus.com"
+    "url": "https://sindresorhus.com"
   },
   "bugs": {
     "url": "https://github.com/sindresorhus/decompress-response/issues"
   },
   "dependencies": {
-    "mimic-response": "^2.0.0"
+    "mimic-response": "^3.1.0"
   },
   "description": "Decompress a HTTP response if needed",
   "devDependencies": {
-    "@types/node": "^12.7.1",
+    "@types/node": "^14.0.1",
     "ava": "^2.2.0",
     "get-stream": "^5.0.0",
-    "pify": "^4.0.1",
-    "tsd": "^0.7.1",
-    "xo": "^0.24.0"
+    "pify": "^5.0.0",
+    "tsd": "^0.11.0",
+    "xo": "^0.30.0"
   },
   "engines": {
-    "node": ">=8"
+    "node": ">=10"
   },
   "files": [
     "index.js",
     "index.d.ts"
   ],
+  "funding": "https://github.com/sponsors/sindresorhus",
   "homepage": "https://github.com/sindresorhus/decompress-response#readme",
   "keywords": [
     "decompress",
@@ -81,5 +82,10 @@
   "scripts": {
     "test": "xo && ava && tsd"
   },
-  "version": "4.2.1"
+  "version": "6.0.0",
+  "xo": {
+    "rules": {
+      "@typescript-eslint/prefer-readonly-parameter-types": "off"
+    }
+  }
 }

package/node_modules/decompress-response/readme.md

@@ -1,4 +1,4 @@
-# decompress-response [![Build Status](https://travis-ci.org/sindresorhus/decompress-response.svg?branch=master)](https://travis-ci.org/sindresorhus/decompress-response)
+# decompress-response [![Build Status](https://travis-ci.com/sindresorhus/decompress-response.svg?branch=master)](https://travis-ci.com/sindresorhus/decompress-response)
 
 > Decompress a HTTP response if needed
 
@@ -6,14 +6,12 @@ Decompresses the [response](https://nodejs.org/api/http.html#http_class_http_inc
 
 Used by [`got`](https://github.com/sindresorhus/got).
 
-
 ## Install
 
 ```
 $ npm install decompress-response
 ```
 
-
 ## Usage
 
 ```js
@@ -25,7 +23,6 @@ http.get('https://sindresorhus.com', response => {
 });
 ```
 
-
 ## API
 
 ### decompressResponse(response)
@@ -38,12 +35,11 @@ Type: [`http.IncomingMessage`](https://nodejs.org/api/http.html#http_class_http_
 
 The HTTP incoming stream with compressed data.
 
-
 ---
 
 <div align="center">
 	<b>
-		<a href="https://tidelift.com/subscription/pkg/npm-unzip-response?utm_source=npm-unzip-response&utm_medium=referral&utm_campaign=readme">Get professional support for this package with a Tidelift subscription</a>
+		<a href="https://tidelift.com/subscription/pkg/npm-decompress-response?utm_source=npm-decompress-response&utm_medium=referral&utm_campaign=readme">Get professional support for this package with a Tidelift subscription</a>
 	</b>
 	<br>
 	<sub>

package/node_modules/detect-libc/README.md

@@ -1,16 +1,15 @@
 # detect-libc
 
-Node.js module to detect the C standard library (libc) implementation
-family and version in use on a given Linux system.
+Node.js module to detect details of the C standard library (libc)
+implementation provided by a given Linux system.
 
-Provides a value suitable for use with the `LIBC` option of
-[prebuild](https://www.npmjs.com/package/prebuild),
-[prebuild-ci](https://www.npmjs.com/package/prebuild-ci) and
-[prebuild-install](https://www.npmjs.com/package/prebuild-install),
-therefore allowing build and provision of pre-compiled binaries
-for musl-based Linux e.g. Alpine as well as glibc-based.
+Currently supports detection of GNU glibc and MUSL libc.
 
-Currently supports libc detection of `glibc` and `musl`.
+Provides asychronous and synchronous functions for the
+family (e.g. `glibc`, `musl`) and version (e.g. `1.23`, `1.2.3`).
+
+For previous v1.x releases, please see the
+[v1](https://github.com/lovell/detect-libc/tree/v1) branch.
 
 ## Install
 
@@ -18,54 +17,137 @@ Currently supports libc detection of `glibc` and `musl`.
 npm install detect-libc
 ```
 
-## Usage
+## API
+
+### GLIBC
+
+```ts
+const GLIBC: string = 'glibc';
+```
+
+A String constant containing the value `glibc`.
+
+### MUSL
+
+```ts
+const MUSL: string = 'musl';
+```
+
+A String constant containing the value `musl`.
+
+### family
+
+```ts
+function family(): Promise<string | null>;
+```
+
+Resolves asychronously with:
 
-### API
+* `glibc` or `musl` when the libc family can be determined
+* `null` when the libc family cannot be determined
+* `null` when run on a non-Linux platform
 
 ```js
-const { GLIBC, MUSL, family, version, isNonGlibcLinux } = require('detect-libc');
+const { family, GLIBC, MUSL } = require('detect-libc');
+
+switch (await family()) {
+  case GLIBC: ...
+  case MUSL: ...
+  case null: ...
+}
 ```
 
-* `GLIBC` is a String containing the value "glibc" for comparison with `family`.
-* `MUSL` is a String containing the value "musl" for comparison with `family`.
-* `family` is a String representing the system libc family.
-* `version` is a String representing the system libc version number.
-* `isNonGlibcLinux` is a Boolean representing whether the system is a non-glibc Linux, e.g. Alpine.
+### familySync
 
-### detect-libc command line tool
+```ts
+function familySync(): string | null;
+```
 
-When run on a Linux system with a non-glibc libc,
-the child command will be run with the `LIBC` environment variable
-set to the relevant value.
+Synchronous version of `family()`.
 
-On all other platforms will run the child command as-is.
+```js
+const { familySync, GLIBC, MUSL } = require('detect-libc');
 
-The command line feature requires `spawnSync` provided by Node v0.12+.
+switch (familySync()) {
+  case GLIBC: ...
+  case MUSL: ...
+  case null: ...
+}
+```
 
-```sh
-detect-libc child-command
+### version
+
+```ts
+function version(): Promise<string | null>;
+```
+
+Resolves asychronously with:
+
+* The version when it can be determined
+* `null` when the libc family cannot be determined
+* `null` when run on a non-Linux platform
+
+```js
+const { version } = require('detect-libc');
+
+const v = await version();
+if (v) {
+  const [major, minor, patch] = v.split('.');
+}
+```
+
+### versionSync
+
+```ts
+function versionSync(): string | null;
+```
+
+Synchronous version of `version()`.
+
+```js
+const { versionSync } = require('detect-libc');
+
+const v = versionSync();
+if (v) {
+  const [major, minor, patch] = v.split('.');
+}
+```
+
+### isNonGlibcLinux
+
+```ts
+function isNonGlibcLinux(): Promise<boolean>;
 ```
 
-## Integrating with prebuild
-
-```json
-  "scripts": {
-    "install": "detect-libc prebuild-install || node-gyp rebuild",
-    "test": "mocha && detect-libc prebuild-ci"
-  },
-  "dependencies": {
-    "detect-libc": "^1.0.2",
-    "prebuild-install": "^2.2.0"
-  },
-  "devDependencies": {
-    "prebuild": "^6.2.1",
-    "prebuild-ci": "^2.2.3"
-  }
+Resolves asychronously with:
+
+* `false` when the libc family is `glibc`
+* `true` when the libc family is not `glibc`
+* `false` when run on a non-Linux platform
+
+```js
+const { isNonGlibcLinux } = require('detect-libc');
+
+if (await isNonGlibcLinux()) { ... }
+```
+
+### isNonGlibcLinuxSync
+
+```ts
+function isNonGlibcLinuxSync(): boolean;
+```
+
+Synchronous version of `isNonGlibcLinux()`.
+
+```js
+const { isNonGlibcLinuxSync } = require('detect-libc');
+
+if (isNonGlibcLinuxSync()) { ... }
 ```
 
-## Licence
+## Licensing
 
-Copyright 2017 Lovell Fuller
+Copyright 2017, 2022 Lovell Fuller
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

package/node_modules/detect-libc/index.d.ts

@@ -0,0 +1,11 @@
+export const GLIBC: 'glibc';
+export const MUSL: 'musl';
+
+export function family(): Promise<string | null>;
+export function familySync(): string | null;
+
+export function isNonGlibcLinux(): Promise<boolean>;
+export function isNonGlibcLinuxSync(): boolean;
+
+export function version(): Promise<string | null>;
+export function versionSync(): string | null;

package/node_modules/detect-libc/lib/detect-libc.js

@@ -1,92 +1,178 @@
 'use strict';
 
-var platform = require('os').platform();
-var spawnSync = require('child_process').spawnSync;
-var readdirSync = require('fs').readdirSync;
+const childProcess = require('child_process');
+const { isLinux, getReport } = require('./process');
 
-var GLIBC = 'glibc';
-var MUSL = 'musl';
+const command = 'getconf GNU_LIBC_VERSION 2>&1 || true; ldd --version 2>&1 || true';
+let commandOut = '';
 
-var spawnOptions = {
-  encoding: 'utf8',
-  env: process.env
+const safeCommand = () => {
+  if (!commandOut) {
+    return new Promise((resolve) => {
+      childProcess.exec(command, (err, out) => {
+        commandOut = err ? ' ' : out;
+        resolve(commandOut);
+      });
+    });
+  }
+  return commandOut;
+};
+
+const safeCommandSync = () => {
+  if (!commandOut) {
+    try {
+      commandOut = childProcess.execSync(command, { encoding: 'utf8' });
+    } catch (_err) {
+      commandOut = ' ';
+    }
+  }
+  return commandOut;
+};
+
+/**
+ * A String constant containing the value `glibc`.
+ * @type {string}
+ * @public
+ */
+const GLIBC = 'glibc';
+
+/**
+ * A String constant containing the value `musl`.
+ * @type {string}
+ * @public
+ */
+const MUSL = 'musl';
+
+const isFileMusl = (f) => f.includes('libc.musl-') || f.includes('ld-musl-');
+
+const familyFromReport = () => {
+  const report = getReport();
+  if (report.header && report.header.glibcVersionRuntime) {
+    return GLIBC;
+  }
+  if (Array.isArray(report.sharedObjects)) {
+    if (report.sharedObjects.some(isFileMusl)) {
+      return MUSL;
+    }
+  }
+  return null;
+};
+
+const familyFromCommand = (out) => {
+  const [getconf, ldd1] = out.split(/[\r\n]+/);
+  if (getconf && getconf.includes(GLIBC)) {
+    return GLIBC;
+  }
+  if (ldd1 && ldd1.includes(MUSL)) {
+    return MUSL;
+  }
+  return null;
 };
 
-if (!spawnSync) {
-  spawnSync = function () {
-    return { status: 126, stdout: '', stderr: '' };
-  };
-}
-
-function contains (needle) {
-  return function (haystack) {
-    return haystack.indexOf(needle) !== -1;
-  };
-}
-
-function versionFromMuslLdd (out) {
-  return out.split(/[\r\n]+/)[1].trim().split(/\s/)[1];
-}
-
-function safeReaddirSync (path) {
-  try {
-    return readdirSync(path);
-  } catch (e) {}
-  return [];
-}
-
-var family = '';
-var version = '';
-var method = '';
-
-if (platform === 'linux') {
-  // Try getconf
-  var glibc = spawnSync('getconf', ['GNU_LIBC_VERSION'], spawnOptions);
-  if (glibc.status === 0) {
-    family = GLIBC;
-    version = glibc.stdout.trim().split(' ')[1];
-    method = 'getconf';
-  } else {
-    // Try ldd
-    var ldd = spawnSync('ldd', ['--version'], spawnOptions);
-    if (ldd.status === 0 && ldd.stdout.indexOf(MUSL) !== -1) {
-      family = MUSL;
-      version = versionFromMuslLdd(ldd.stdout);
-      method = 'ldd';
-    } else if (ldd.status === 1 && ldd.stderr.indexOf(MUSL) !== -1) {
-      family = MUSL;
-      version = versionFromMuslLdd(ldd.stderr);
-      method = 'ldd';
-    } else {
-      // Try filesystem (family only)
-      var lib = safeReaddirSync('/lib');
-      if (lib.some(contains('-linux-gnu'))) {
-        family = GLIBC;
-        method = 'filesystem';
-      } else if (lib.some(contains('libc.musl-'))) {
-        family = MUSL;
-        method = 'filesystem';
-      } else if (lib.some(contains('ld-musl-'))) {
-        family = MUSL;
-        method = 'filesystem';
-      } else {
-        var usrSbin = safeReaddirSync('/usr/sbin');
-        if (usrSbin.some(contains('glibc'))) {
-          family = GLIBC;
-          method = 'filesystem';
-        }
-      }
+/**
+ * Resolves with the libc family when it can be determined, `null` otherwise.
+ * @returns {Promise<?string>}
+ */
+const family = async () => {
+  let family = null;
+  if (isLinux()) {
+    family = familyFromReport();
+    if (!family) {
+      const out = await safeCommand();
+      family = familyFromCommand(out);
     }
   }
-}
+  return family;
+};
 
-var isNonGlibcLinux = (family !== '' && family !== GLIBC);
+/**
+ * Returns the libc family when it can be determined, `null` otherwise.
+ * @returns {?string}
+ */
+const familySync = () => {
+  let family = null;
+  if (isLinux()) {
+    family = familyFromReport();
+    if (!family) {
+      const out = safeCommandSync();
+      family = familyFromCommand(out);
+    }
+  }
+  return family;
+};
+
+/**
+ * Resolves `true` only when the platform is Linux and the libc family is not `glibc`.
+ * @returns {Promise<boolean>}
+ */
+const isNonGlibcLinux = async () => isLinux() && await family() !== GLIBC;
+
+/**
+ * Returns `true` only when the platform is Linux and the libc family is not `glibc`.
+ * @returns {boolean}
+ */
+const isNonGlibcLinuxSync = () => isLinux() && familySync() !== GLIBC;
+
+const versionFromReport = () => {
+  const report = getReport();
+  if (report.header && report.header.glibcVersionRuntime) {
+    return report.header.glibcVersionRuntime;
+  }
+  return null;
+};
+
+const versionSuffix = (s) => s.trim().split(/\s+/)[1];
+
+const versionFromCommand = (out) => {
+  const [getconf, ldd1, ldd2] = out.split(/[\r\n]+/);
+  if (getconf && getconf.includes(GLIBC)) {
+    return versionSuffix(getconf);
+  }
+  if (ldd1 && ldd2 && ldd1.includes(MUSL)) {
+    return versionSuffix(ldd2);
+  }
+  return null;
+};
+
+/**
+ * Resolves with the libc version when it can be determined, `null` otherwise.
+ * @returns {Promise<?string>}
+ */
+const version = async () => {
+  let version = null;
+  if (isLinux()) {
+    version = versionFromReport();
+    if (!version) {
+      const out = await safeCommand();
+      version = versionFromCommand(out);
+    }
+  }
+  return version;
+};
+
+/**
+ * Returns the libc version when it can be determined, `null` otherwise.
+ * @returns {?string}
+ */
+const versionSync = () => {
+  let version = null;
+  if (isLinux()) {
+    version = versionFromReport();
+    if (!version) {
+      const out = safeCommandSync();
+      version = versionFromCommand(out);
+    }
+  }
+  return version;
+};
 
 module.exports = {
-  GLIBC: GLIBC,
-  MUSL: MUSL,
-  family: family,
-  version: version,
-  method: method,
-  isNonGlibcLinux: isNonGlibcLinux
+  GLIBC,
+  MUSL,
+  family,
+  familySync,
+  isNonGlibcLinux,
+  isNonGlibcLinuxSync,
+  version,
+  versionSync
 };

package/node_modules/detect-libc/lib/process.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const isLinux = () => process.platform === 'linux';
+
+let report = null;
+const getReport = () => {
+  if (!report) {
+    /* istanbul ignore next */
+    report = isLinux() && process.report
+      ? process.report.getReport()
+      : {};
+  }
+  return report;
+};
+
+module.exports = { isLinux, getReport };