@scrypted/nvr 0.10.122 → 0.10.124

package/dist/724

@@ -0,0 +1,1734 @@
+"use strict";
+exports.id = 724;
+exports.ids = [724];
+exports.modules = {
+
+/***/ 7529:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  BASIC: () => (/* reexport */ basic)
+});
+
+// UNUSED EXPORTS: BEARER, DIGEST, buildAuthorizationHeader, buildWWWAuthenticateHeader, mechanisms, parseAuthorizationHeader, parseWWWAuthenticateHeader
+
+// EXTERNAL MODULE: ../../scrypted/common/node_modules/yerror/dist/index.js
+var dist = __webpack_require__(9126);
+// EXTERNAL MODULE: ../../scrypted/common/node_modules/http-auth-utils/dist/utils.js
+var utils = __webpack_require__(1845);
+;// ../../scrypted/common/node_modules/http-auth-utils/dist/mechanisms/basic.js
+/**
+ * @module http-auth-utils/mechanisms/basic
+ */
+
+
+const REQUIRED_WWW_AUTHENTICATE_KEYS = ['realm'];
+const AUTHORIZED_WWW_AUTHENTICATE_KEYS = REQUIRED_WWW_AUTHENTICATE_KEYS;
+/* Architecture Note #1.2: Basic mechanism
+
+See the following [RFC](https://tools.ietf.org/html/rfc7617).
+
+*/
+/**
+ * Basic authentication mechanism.
+ * @type {Object}
+ * @see http://tools.ietf.org/html/rfc2617#section-2
+ */
+const BASIC = {
+    /**
+     * The Basic auth mechanism prefix.
+     * @type {String}
+     */
+    type: 'Basic',
+    /**
+     * Parse the WWW Authenticate header rest.
+     * @param  {String} rest The header rest (string after the authentication mechanism prefix).
+     * @return {Object}      Object representing the result of the parse operation.
+     * @example
+     * assert.deepEqual(
+     *   BASIC.parseWWWAuthenticateRest('realm="perlinpinpin"'), {
+     *     realm: 'perlinpinpin'
+     *   }
+     * );
+     * @api public
+     */
+    parseWWWAuthenticateRest: function parseWWWAuthenticateRest(rest) {
+        return (0,utils.parseHTTPHeadersQuotedKeyValueSet)(rest, AUTHORIZED_WWW_AUTHENTICATE_KEYS, REQUIRED_WWW_AUTHENTICATE_KEYS);
+    },
+    /**
+     * Build the WWW Authenticate header rest.
+     * @param  {Object} data The content from wich to build the rest.
+     * @return {String}         The built rest.
+     * @example
+     * assert.equal(
+     *   BASIC.buildWWWAuthenticateRest({
+     *     realm: 'perlinpinpin'
+     *   }),
+     *   'realm="perlinpinpin"'
+     * );
+     * @api public
+     */
+    buildWWWAuthenticateRest: function buildWWWAuthenticateRest(data) {
+        return (0,utils/* buildHTTPHeadersQuotedKeyValueSet */.$)(data, AUTHORIZED_WWW_AUTHENTICATE_KEYS, REQUIRED_WWW_AUTHENTICATE_KEYS);
+    },
+    /**
+     * Parse the Authorization header rest.
+     * @param  {String} rest The header rest (string after the authentication mechanism prefix).)
+     * @return {Object}      Object representing the result of the parse operation {hash}.
+     * @example
+     * assert.deepEqual(
+     *   BASIC.parseAuthorizationRest('QWxpIEJhYmE6b3BlbiBzZXNhbWU='), {
+     *     hash: 'QWxpIEJhYmE6b3BlbiBzZXNhbWU=',
+     *     username: 'Ali Baba',
+     *     password: 'open sesame'
+     *   }
+     * );
+     * @api public
+     */
+    parseAuthorizationRest: function parseAuthorizationRest(rest) {
+        if (!rest) {
+            throw new dist/* YError */.w('E_EMPTY_AUTH');
+        }
+        const { username, password } = BASIC.decodeHash(rest);
+        return {
+            hash: rest,
+            username,
+            password,
+        };
+    },
+    /**
+     * Build the Authorization header rest.
+     * @param  {Object} content The content from wich to build the rest.
+     * @return {String}         The rest built.
+     * @example
+     * assert.equal(
+     *   BASIC.buildAuthorizationRest({
+     *     hash: 'QWxpIEJhYmE6b3BlbiBzZXNhbWU='
+     *   }),
+     *   'QWxpIEJhYmE6b3BlbiBzZXNhbWU='
+     * );
+     * @api public
+     */
+    buildAuthorizationRest: function buildAuthorizationRest({ hash, username, password, }) {
+        if (username && password) {
+            return BASIC.computeHash({
+                username,
+                password,
+            });
+        }
+        if (!hash) {
+            throw new dist/* YError */.w('E_NO_HASH');
+        }
+        return hash;
+    },
+    /**
+     * Compute the Basic authentication hash from the given credentials.
+     * @param  {Object} credentials The credentials to encode {username, password}.
+     * @return {String}             The hash representing the credentials.
+     * @example
+     * assert.equal(
+     *   BASIC.computeHash({
+     *     username: 'Ali Baba',
+     *     password: 'open sesame'
+     *   }),
+     *   'QWxpIEJhYmE6b3BlbiBzZXNhbWU='
+     * );
+     * @api public
+     */
+    computeHash: function computeHash({ username, password, }) {
+        return Buffer.from(username + ':' + password).toString('base64');
+    },
+    /**
+     * Decode the Basic hash and return the corresponding credentials.
+     * @param  {String} hash The hash.
+     * @return {Object}      Object representing the credentials {username, password}.
+     * @example
+     * assert.deepEqual(
+     *   BASIC.decodeHash('QWxpIEJhYmE6b3BlbiBzZXNhbWU='), {
+     *     username: 'Ali Baba',
+     *     password: 'open sesame'
+     *   }
+     * );
+     * @api public
+     */
+    decodeHash: function decodeHash(hash) {
+        const [username, ...passwordParts] = Buffer.from(hash, 'base64')
+            .toString()
+            .split(':');
+        return {
+            username,
+            password: passwordParts.join(':'),
+        };
+    },
+};
+/* harmony default export */ const basic = (BASIC);
+//# sourceMappingURL=basic.js.map
+// EXTERNAL MODULE: external "crypto"
+var external_crypto_ = __webpack_require__(6982);
+;// ../../scrypted/common/node_modules/http-auth-utils/dist/mechanisms/digest.js
+/**
+ * @module http-auth-utils/mechanisms/digest
+ */
+
+
+const digest_REQUIRED_WWW_AUTHENTICATE_KEYS = ['realm', 'nonce'];
+const digest_AUTHORIZED_WWW_AUTHENTICATE_KEYS = [
+    ...digest_REQUIRED_WWW_AUTHENTICATE_KEYS,
+    'domain',
+    'opaque',
+    'stale',
+    'algorithm',
+    'qop',
+];
+const CASE_INSENSITIVE_WWW_AUTHENTICATE_VALUES = ['stale'];
+const REQUIRED_AUTHORIZATION_KEYS = [
+    'username',
+    'realm',
+    'nonce',
+    'uri',
+    'response',
+];
+const AUTHORIZED_AUTHORIZATION_KEYS = [
+    ...REQUIRED_AUTHORIZATION_KEYS,
+    'algorithm',
+    'cnonce',
+    'opaque',
+    'qop',
+    'nc',
+];
+/* Architecture Note #1.3: Digest mechanism
+
+See the following [RFC](https://tools.ietf.org/html/rfc2617).
+
+*/
+/**
+ * Digest authentication mechanism.
+ * @type {Object}
+ * @see http://tools.ietf.org/html/rfc2617#section-3
+ * @see http://tools.ietf.org/html/rfc2069#section-2
+ */
+const DIGEST = {
+    /**
+     * The Digest auth mechanism prefix.
+     * @type {String}
+     */
+    type: 'Digest',
+    /**
+     * Parse the WWW Authenticate header rest.
+     * @param  {String} rest The header rest (string after the authentication mechanism prefix).
+     * @return {Object}      Object representing the result of the parse operation.
+     * @example
+     * assert.deepEqual(
+     *   DIGEST.parseWWWAuthenticateRest(
+     *     'realm="testrealm@host.com", ' +
+     *     'qop="auth, auth-int", ' +
+     *     'nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093", ' +
+     *     'opaque="5ccc069c403ebaf9f0171e9517f40e41"'
+     *   ), {
+     *     realm: 'testrealm@host.com',
+     *     qop: 'auth, auth-int',
+     *     nonce: 'dcd98b7102dd2f0e8b11d0f600bfb0c093',
+     *     opaque: '5ccc069c403ebaf9f0171e9517f40e41'
+     *   }
+     * );
+     * @api public
+     */
+    parseWWWAuthenticateRest: function parseWWWAuthenticateRest(rest) {
+        return (0,utils.parseHTTPHeadersQuotedKeyValueSet)(rest, digest_AUTHORIZED_WWW_AUTHENTICATE_KEYS, digest_REQUIRED_WWW_AUTHENTICATE_KEYS, CASE_INSENSITIVE_WWW_AUTHENTICATE_VALUES);
+    },
+    /**
+     * Build the WWW Authenticate header rest.
+     * @param  {Object} data The content from which to build the rest.
+     * @return {String}         The built rest.
+     * @example
+     * assert.equal(
+     *   DIGEST.buildWWWAuthenticateRest({
+     *     realm: 'testrealm@host.com',
+     *     qop: 'auth, auth-int',
+     *     nonce: 'dcd98b7102dd2f0e8b11d0f600bfb0c093',
+     *     opaque: '5ccc069c403ebaf9f0171e9517f40e41'
+     *   }),
+     *   'realm="testrealm@host.com", ' +
+     *   'qop="auth, auth-int", ' +
+     *   'nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093", ' +
+     *   'opaque="5ccc069c403ebaf9f0171e9517f40e41"'
+     * );
+     * @api public
+     */
+    buildWWWAuthenticateRest: function buildWWWAuthenticateRest(data) {
+        return (0,utils/* buildHTTPHeadersQuotedKeyValueSet */.$)(data, digest_AUTHORIZED_WWW_AUTHENTICATE_KEYS, digest_REQUIRED_WWW_AUTHENTICATE_KEYS);
+    },
+    /**
+     * Parse the Authorization header rest.
+     * @param  {String} rest The header rest (string after the authentication mechanism prefix).)
+     * @return {Object}      Object representing the result of the parse operation {hash}.
+     * @example
+     * assert.deepEqual(
+     *   DIGEST.parseAuthorizationRest(
+     *     'username="Mufasa",' +
+     *     'realm="testrealm@host.com",' +
+     *     'nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093",' +
+     *     'uri="/dir/index.html",' +
+     *     'qop="auth",' +
+     *     'nc="00000001",' +
+     *     'cnonce="0a4f113b",' +
+     *     'response="6629fae49393a05397450978507c4ef1",' +
+     *     'opaque="5ccc069c403ebaf9f0171e9517f40e41"'
+     *   ), {
+     *     username: "Mufasa",
+     *     realm: 'testrealm@host.com',
+     *     nonce: "dcd98b7102dd2f0e8b11d0f600bfb0c093",
+     *     uri: "/dir/index.html",
+     *     qop: 'auth',
+     *     nc: '00000001',
+     *     cnonce: "0a4f113b",
+     *     response: "6629fae49393a05397450978507c4ef1",
+     *     opaque: "5ccc069c403ebaf9f0171e9517f40e41"
+     *   }
+     * );
+     * @api public
+     */
+    parseAuthorizationRest: function parseAuthorizationRest(rest) {
+        return (0,utils.parseHTTPHeadersQuotedKeyValueSet)(rest, AUTHORIZED_AUTHORIZATION_KEYS, REQUIRED_AUTHORIZATION_KEYS);
+    },
+    /**
+     * Build the Authorization header rest.
+     * @param  {Object} data The content from which to build the rest.
+     * @return {String}         The rest built.
+     * @example
+     * assert.equal(
+     *   DIGEST.buildAuthorizationRest({
+     *     username: "Mufasa",
+     *     realm: 'testrealm@host.com',
+     *     nonce: "dcd98b7102dd2f0e8b11d0f600bfb0c093",
+     *     uri: "/dir/index.html",
+     *     qop: 'auth',
+     *     nc: '00000001',
+     *     cnonce: "0a4f113b",
+     *     response: "6629fae49393a05397450978507c4ef1",
+     *     opaque: "5ccc069c403ebaf9f0171e9517f40e41"
+     *   }),
+     *   'username="Mufasa", ' +
+     *   'realm="testrealm@host.com", ' +
+     *   'nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093", ' +
+     *   'uri="/dir/index.html", ' +
+     *   'response="6629fae49393a05397450978507c4ef1", ' +
+     *   'cnonce="0a4f113b", ' +
+     *   'opaque="5ccc069c403ebaf9f0171e9517f40e41", ' +
+     *   'qop="auth", ' +
+     *   'nc="00000001"'
+     * );
+     * @api public
+     */
+    buildAuthorizationRest: function buildAuthorizationRest(data) {
+        return (0,utils/* buildHTTPHeadersQuotedKeyValueSet */.$)(data, AUTHORIZED_AUTHORIZATION_KEYS, REQUIRED_AUTHORIZATION_KEYS);
+    },
+    /**
+     * Compute the Digest authentication hash from the given credentials.
+     * @param  {Object} data The credentials to encode and other encoding details.
+     * @return {String}             The hash representing the credentials.
+     * @example
+     * assert.equal(
+     *   DIGEST.computeHash({
+     *     username: 'Mufasa',
+     *     realm: 'testrealm@host.com',
+     *     password: 'Circle Of Life',
+     *     method: 'GET',
+     *     uri: '/dir/index.html',
+     *     nonce: 'dcd98b7102dd2f0e8b11d0f600bfb0c093',
+     *     nc: '00000001',
+     *     cnonce: '0a4f113b',
+     *     qop: 'auth',
+     *     algorithm: 'md5'
+     *   }),
+     *   '6629fae49393a05397450978507c4ef1'
+     * );
+     * @api public
+     */
+    computeHash: function computeHash(data) {
+        const ha1 = data.ha1 ||
+            _computeHash(data.algorithm, [data.username, data.realm, data.password].join(':'));
+        const ha2 = _computeHash(data.algorithm, [data.method, data.uri].join(':'));
+        return _computeHash(data.algorithm, [ha1, data.nonce, data.nc, data.cnonce, data.qop, ha2].join(':'));
+    },
+};
+function _computeHash(algorithm, str) {
+    const hashsum = external_crypto_.createHash(algorithm);
+    hashsum.update(str);
+    return hashsum.digest('hex');
+}
+/* harmony default export */ const digest = (DIGEST);
+//# sourceMappingURL=digest.js.map
+;// ../../scrypted/common/node_modules/http-auth-utils/dist/mechanisms/bearer.js
+/**
+ * @module http-auth-utils/mechanisms/bearer
+ */
+
+
+const AUTHORIZED_ERROR_CODES = [
+    'invalid_request',
+    'invalid_token',
+    'insufficient_scope',
+];
+const bearer_REQUIRED_WWW_AUTHENTICATE_KEYS = ['realm'];
+const bearer_AUTHORIZED_WWW_AUTHENTICATE_KEYS = [
+    ...bearer_REQUIRED_WWW_AUTHENTICATE_KEYS,
+    'scope',
+    'error',
+    'error_description',
+];
+/* Architecture Note #1.1: Bearer mechanism
+
+See the following [RFC](https://tools.ietf.org/html/rfc6750).
+
+*/
+/**
+ * Bearer authentication mechanism.
+ * @type {Object}
+ * @see https://tools.ietf.org/html/rfc6750#section-3
+ */
+const BEARER = {
+    /**
+     * The Bearer auth mechanism prefix.
+     * @type {String}
+     */
+    type: 'Bearer',
+    /**
+     * Parse the WWW Authenticate header rest.
+     * @param  {String} rest The header rest (string after the authentication mechanism prefix).
+     * @return {Object}      Object representing the result of the parse operation.
+     * @example
+     * assert.deepEqual(
+     *   BEARER.parseWWWAuthenticateRest(
+     *     'realm="testrealm@host.com", ' +
+     *     'scope="openid profile email"'
+     *   ), {
+     *     realm: 'testrealm@host.com',
+     *     scope: 'openid profile email',
+     *   }
+     * );
+     * @api public
+     */
+    parseWWWAuthenticateRest: function parseWWWAuthenticateRest(rest) {
+        return (0,utils.parseHTTPHeadersQuotedKeyValueSet)(rest, bearer_AUTHORIZED_WWW_AUTHENTICATE_KEYS, []);
+    },
+    /**
+     * Build the WWW Authenticate header rest.
+     * @param  {Object} data The content from wich to build the rest.
+     * @return {String}         The built rest.
+     * @example
+     * assert.equal(
+     *   BEARER.buildWWWAuthenticateRest({
+     *     realm: 'testrealm@host.com',
+     *     error: 'invalid_request',
+     *     error_description: 'The access token expired',
+     *   }),
+     *   'realm="testrealm@host.com", ' +
+     *   'error="invalid_request", ' +
+     *   'error_description="The access token expired"'
+     * );
+     * @api public
+     */
+    buildWWWAuthenticateRest: function buildWWWAuthenticateRest(data) {
+        if (data.error &&
+            -1 ===
+                AUTHORIZED_ERROR_CODES.indexOf(data.error)) {
+            throw new dist/* YError */.w('E_INVALID_ERROR', data.error, AUTHORIZED_ERROR_CODES);
+        }
+        return (0,utils/* buildHTTPHeadersQuotedKeyValueSet */.$)(data, bearer_AUTHORIZED_WWW_AUTHENTICATE_KEYS, []);
+    },
+    /**
+     * Parse the Authorization header rest.
+     * @param  {String} rest The header rest (string after the authentication mechanism prefix).)
+     * @return {Object}      Object representing the result of the parse operation {hash}.
+     * @example
+     * assert.deepEqual(
+     *   BEARER.parseAuthorizationRest('mF_9.B5f-4.1JqM'), {
+     *     hash: 'mF_9.B5f-4.1JqM',
+     *   }
+     * );
+     * @api public
+     */
+    parseAuthorizationRest: function parseAuthorizationRest(rest) {
+        if (!rest) {
+            throw new dist/* YError */.w('E_EMPTY_AUTH');
+        }
+        return {
+            hash: rest,
+        };
+    },
+    /**
+     * Build the Authorization header rest.
+     * @param  {Object} content The content from wich to build the rest.
+     * @return {String}         The rest built.
+     * @example
+     * assert.equal(
+     *   BEARER.buildAuthorizationRest({
+     *     hash: 'mF_9.B5f-4.1JqM'
+     *   }),
+     *   'mF_9.B5f-4.1JqM=='
+     * );
+     * @api public
+     */
+    buildAuthorizationRest: function buildAuthorizationRest({ hash, }) {
+        if (!hash) {
+            throw new dist/* YError */.w('E_NO_HASH');
+        }
+        return hash;
+    },
+};
+/* harmony default export */ const bearer = (BEARER);
+//# sourceMappingURL=bearer.js.map
+;// ../../scrypted/common/node_modules/http-auth-utils/dist/index.js
+
+
+
+
+/**
+ * @module http-auth-utils
+ */
+/**
+ * Natively supported authentication mechanisms.
+ * @type {Array}
+ */
+const mechanisms = [basic, digest, bearer];
+/**
+ * Basic authentication mechanism.
+ * @type {Object}
+ * @see  {@link module:http-auth-utils/mechanisms/basic}
+ */
+basic;
+/**
+ * Digest authentication mechanism.
+ * @type {Object}
+ * @see  {@link module:http-auth-utils/mechanisms/digest}
+ */
+digest;
+/**
+ * Bearer authentication mechanism.
+ * @type {Object}
+ * @see  {@link module:http-auth-utils/mechanisms/digest}
+ */
+bearer;
+
+/**
+ * Parse HTTP WWW-Authenticate header contents.
+ * @type {Function}
+ * @param {string} header
+ * The WWW-Authenticate header contents
+ * @param {Array} [authMechanisms=[BASIC, DIGEST, BEARER]]
+ * Allow providing custom authentication mechanisms.
+ * @param {Object} [options]
+ * Parsing options
+ * @param {boolean} [options.strict=true]
+ * Strictly detect the mechanism type (case sensitive)
+ * @return {Object} Result of the contents parse.
+ * @api public
+ * @example
+ * assert.deepEqual(
+ *   parseWWWAuthenticateHeader('Basic realm="test"'), {
+ *     type: 'Basic',
+ *     data: {
+ *       realm: 'test'
+ *     }
+ *   }
+ * );
+ */
+function parseWWWAuthenticateHeader(header, authMechanisms = mechanisms, { strict = true } = { strict: true }) {
+    let result = null;
+    authMechanisms.some((authMechanism) => {
+        if (0 === header.indexOf(authMechanism.type + ' ') ||
+            (!strict && 0 === header.indexOf(authMechanism.type.toLowerCase() + ' '))) {
+            result = {
+                type: authMechanism.type,
+                data: authMechanism.parseWWWAuthenticateRest(header.substr(authMechanism.type.length + 1)),
+            };
+            return true;
+        }
+        return false;
+    });
+    if (!result) {
+        throw new YError('E_UNKNOWN_AUTH_MECHANISM', header);
+    }
+    return result;
+}
+/**
+ * Parse HTTP Authorization header contents.
+ * @type {Function}
+ * @param {string} header The Authorization header contents
+ * @param {Array} [authMechanisms=[BASIC, DIGEST, BEARER]]
+ * Allow custom authentication mechanisms.
+ * @param {Object} [options]
+ * Parsing options
+ * @param {boolean} [options.strict=true]
+ * Strictly detect the mechanism type (case sensitive)
+ * @return {Object} Result of the contents parse.
+ * @api public
+ * @example
+ * assert.deepEqual(
+ *   parseAuthorizationHeader('Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ=='), {
+ *     type: 'Basic',
+ *     data: {
+ *       hash: 'QWxhZGRpbjpvcGVuIHNlc2FtZQ=='
+ *     }
+ *   }
+ * );
+ */
+function parseAuthorizationHeader(header, authMechanisms = mechanisms, { strict = true } = { strict: true }) {
+    let result = null;
+    authMechanisms.some(function (authMechanism) {
+        if (0 === header.indexOf(authMechanism.type + ' ') ||
+            (!strict && 0 === header.indexOf(authMechanism.type.toLowerCase() + ' '))) {
+            result = {
+                type: authMechanism.type,
+                data: authMechanism.parseAuthorizationRest(header.substr(authMechanism.type.length + 1)),
+            };
+            return true;
+        }
+        return false;
+    });
+    if (result) {
+        return result;
+    }
+    throw new YError('E_UNKNOWN_AUTH_MECHANISM', header);
+}
+/**
+ * Build HTTP WWW-Authenticate header value.
+ * @type {Function}
+ * @param {Object} authMechanism The mechanism to use
+ * @param {Object}
+ * The WWW-Authenticate header contents to base the value on.
+ * @return {string} The header value.
+ * @api public
+ * @example
+ * assert.deepEqual(
+ *   buildWWWAuthenticateHeader(BASIC, {
+ *     realm: 'test'
+ *   }),
+ *   'Basic realm="test"'
+ * );
+ */
+function buildWWWAuthenticateHeader(authMechanism, data) {
+    return `${authMechanism.type} ${authMechanism.buildWWWAuthenticateRest(data)}`;
+}
+/**
+ * Build HTTP Authorization header value.
+ * @type {Function}
+ * @param {Object} authMechanism The mechanism to use
+ * @param {Object}
+ * The Authorization header contents to base the value on.
+ * @return {string} The header value.
+ * @api public
+ * @example
+ * assert.deepEqual(
+ *   buildAuthorizationHeader(BASIC, {
+ *     realm: 'test'
+ *   }),
+ *   'Basic realm="test"'
+ * );
+ */
+function buildAuthorizationHeader(authMechanism, data) {
+    return `${authMechanism.type} ${authMechanism.buildAuthorizationRest(data)}`;
+}
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+
+/***/ 1845:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   $: () => (/* binding */ buildHTTPHeadersQuotedKeyValueSet),
+/* harmony export */   parseHTTPHeadersQuotedKeyValueSet: () => (/* binding */ parseHTTPHeadersQuotedKeyValueSet)
+/* harmony export */ });
+/* harmony import */ var yerror__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(9126);
+
+const QUOTE = '"';
+const EQUAL = '=';
+const SEPARATOR = ', ';
+/*
+ * Regular expression for matching the key-value pairs
+ * \w+     = The key
+ * =       = The equal sign
+ * ".*?"   = Value option 1: A double-quoted value (using the non-greedy *? to stop at the first doublequote)
+ * [^",]+  = Value option 2: A string without commas or double-quotes
+ * (?=,|$) = Zero-width (as in not captured) positive lookahead assertion.
+ *           The previous match will only be valid if it's followed by a " literal
+ *           or the end of the string
+ */
+const KEYVALUE_REGEXP = /\w+=(".*?"|[^",]+)(?=,|$)/g;
+// FIXME: Create a real parser
+function parseHTTPHeadersQuotedKeyValueSet(contents, authorizedKeys, requiredKeys = [], valuesToNormalize = []) {
+    const matches = contents.trim().match(KEYVALUE_REGEXP);
+    if (!matches)
+        throw new yerror__WEBPACK_IMPORTED_MODULE_0__/* .YError */ .w('E_MALFORMED_QUOTEDKEYVALUE', contents);
+    const data = matches
+        .map((part, partPosition) => {
+        const [key, ...rest] = part.split(EQUAL);
+        const value = rest.join(EQUAL);
+        if (0 === rest.length) {
+            throw new yerror__WEBPACK_IMPORTED_MODULE_0__/* .YError */ .w('E_MALFORMED_QUOTEDKEYVALUE', partPosition, part);
+        }
+        return [key, value];
+    })
+        .reduce(function (parsedValues, [name, value], valuePosition) {
+        const normalizedName = name.toLowerCase();
+        if (-1 === authorizedKeys.indexOf(normalizedName)) {
+            throw new yerror__WEBPACK_IMPORTED_MODULE_0__/* .YError */ .w('E_UNAUTHORIZED_KEY', valuePosition, normalizedName);
+        }
+        /*
+         * Regular expression for stripping paired starting and ending double quotes off the value:
+         * ^      = The beginning of the string
+         * "      = The first double quote
+         * .+     = One or more characters of any kind
+         * (?="$) = Zero-width (as in not captured) positive lookahead assertion.
+         *          The previous match will only be valid if it's followed by a " literal
+         *          or the end of the string
+         * "      = The ending double quote
+         * $      = The end of the string
+         */
+        const strippedValue = value.replace(/^"(.+(?="$))"$/, '$1');
+        parsedValues[normalizedName] = valuesToNormalize.includes(normalizedName)
+            ? strippedValue.toLowerCase()
+            : strippedValue;
+        return parsedValues;
+    }, {});
+    _checkRequiredKeys(requiredKeys, data);
+    return data;
+}
+function buildHTTPHeadersQuotedKeyValueSet(data, authorizedKeys, requiredKeys = []) {
+    _checkRequiredKeys(requiredKeys, data);
+    return authorizedKeys.reduce(function (contents, key) {
+        if (data[key]) {
+            return (contents +
+                (contents ? SEPARATOR : '') +
+                key +
+                EQUAL +
+                QUOTE +
+                data[key] +
+                QUOTE);
+        }
+        return contents;
+    }, '');
+}
+function _checkRequiredKeys(requiredKeys, data) {
+    requiredKeys.forEach((name) => {
+        if ('undefined' === typeof data[name]) {
+            throw new yerror__WEBPACK_IMPORTED_MODULE_0__/* .YError */ .w('E_REQUIRED_KEY', name);
+        }
+    });
+}
+//# sourceMappingURL=utils.js.map
+
+/***/ }),
+
+/***/ 9126:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   w: () => (/* binding */ YError)
+/* harmony export */ });
+/* unused harmony export printStackTrace */
+/* harmony import */ var os__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(857);
+
+/**
+ * A YError class able to contain some params and
+ *  print better stack traces
+ * @extends Error
+ */
+class YError extends Error {
+    code;
+    params;
+    wrappedErrors;
+    constructor(wrappedErrors, errorCode, ...params) {
+        // Detecting if wrappedErrors are passed
+        if (!(wrappedErrors instanceof Array)) {
+            params = ('undefined' === typeof errorCode ? [] : [errorCode]).concat(params);
+            errorCode = wrappedErrors;
+            wrappedErrors = [];
+        }
+        // Call the parent constructor
+        super(errorCode);
+        // Filling error
+        this.code = errorCode || 'E_UNEXPECTED';
+        this.params = params;
+        this.wrappedErrors = wrappedErrors;
+        this.name = this.toString();
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+    /**
+     * Wraps any error and output a YError with an error
+     *  code and some params as debug values.
+     * @param {Error} err
+     * The error to wrap
+     * @param {string} [errorCode = 'E_UNEXPECTED']
+     * The error code corresponding to the actual error
+     * @param {...YErrorParams} [params]
+     * Some additional debugging values
+     * @return {YError}
+     * The wrapped error
+     */
+    static wrap(err, errorCode, ...params) {
+        const wrappedErrorIsACode = _looksLikeAYErrorCode(err.message);
+        const wrappedErrors = ('wrappedErrors' in err ? err.wrappedErrors : []).concat(err);
+        if (!errorCode) {
+            if (wrappedErrorIsACode) {
+                errorCode = err.message;
+            }
+            else {
+                errorCode = 'E_UNEXPECTED';
+            }
+        }
+        if (err.message && !wrappedErrorIsACode) {
+            params.push(err.message);
+        }
+        return new YError(wrappedErrors, errorCode, ...params);
+    }
+    /**
+     * Return a YError as is or wraps any other error and output
+     *  a YError with a code and some params as debug values.
+     * @param {Error} err
+     * The error to cast
+     * @param {string} [errorCode = 'E_UNEXPECTED']
+     * The error code corresponding to the actual error
+     * @param {...YErrorParams} [params]
+     * Some additional debugging values
+     * @return {YError}
+     * The wrapped error
+     */
+    static cast(err, errorCode, ...params) {
+        if (_looksLikeAYError(err)) {
+            return err;
+        }
+        return YError.wrap(err, errorCode, ...params);
+    }
+    /**
+     * Same than `YError.wrap()` but preserves the code
+     *  and the debug values of the error if it is
+     *  already an instance of the YError constructor.
+     * @param {Error} err
+     * The error to bump
+     * @param {string} [errorCode = 'E_UNEXPECTED']
+     * The error code corresponding to the actual error
+     * @param {...YErrorParams} [params]
+     * Some additional debugging values
+     * @return {YError}
+     * The wrapped error
+     */
+    static bump(err, errorCode, ...params) {
+        if (_looksLikeAYError(err)) {
+            return YError.wrap(err, err.code, ...err.params);
+        }
+        return YError.wrap(err, errorCode, ...params);
+    }
+    toString() {
+        return ((this.wrappedErrors.length
+            ? // eslint-disable-next-line
+                this.wrappedErrors[this.wrappedErrors.length - 1].stack + os__WEBPACK_IMPORTED_MODULE_0__.EOL
+            : '') +
+            this.constructor.name +
+            ': ' +
+            this.code +
+            ' (' +
+            this.params.join(', ') +
+            ')');
+    }
+}
+/**
+ * Allow to print a stack from anything (especially catched
+ *  errors that may or may not contain errors 🤷).
+ * @param {Error} err
+ * The error to print
+ * @return {string}
+ * The stack trace if any
+ */
+function printStackTrace(err) {
+    return typeof err === 'object' && typeof err.stack === 'string'
+        ? err.stack
+        : `[no_stack_trace]: error is ${err != null && typeof err.toString === 'function'
+            ? err.toString()
+            : typeof err}`;
+}
+// In order to keep compatibility through major versions
+// we have to make kind of an cross major version instanceof
+function _looksLikeAYError(err) {
+    return (!!(err instanceof YError) ||
+        !!(err.constructor &&
+            err.constructor.name &&
+            err.constructor.name.endsWith('Error') &&
+            'code' in err &&
+            'string' === typeof err.code &&
+            _looksLikeAYErrorCode(err.code) &&
+            'params' in err &&
+            err.params &&
+            err.params instanceof Array));
+}
+function _looksLikeAYErrorCode(str) {
+    return /^([A-Z0-9_]+)$/.test(str);
+}
+
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+
+/***/ 8188:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  BASIC: () => (/* reexport */ basic),
+  DIGEST: () => (/* reexport */ digest),
+  buildAuthorizationHeader: () => (/* binding */ buildAuthorizationHeader),
+  parseWWWAuthenticateHeader: () => (/* binding */ parseWWWAuthenticateHeader)
+});
+
+// UNUSED EXPORTS: BEARER, buildWWWAuthenticateHeader, mechanisms, parseAuthorizationHeader
+
+// EXTERNAL MODULE: external "os"
+var external_os_ = __webpack_require__(857);
+;// ../../scrypted/packages/auth-fetch/node_modules/yerror/dist/index.js
+
+/**
+ * A YError class able to contain some params and
+ *  print better stack traces
+ * @extends Error
+ */
+class dist_YError extends Error {
+    code;
+    params;
+    wrappedErrors;
+    constructor(wrappedErrors, errorCode, ...params) {
+        // Detecting if wrappedErrors are passed
+        if (!(wrappedErrors instanceof Array)) {
+            params = ('undefined' === typeof errorCode ? [] : [errorCode]).concat(params);
+            errorCode = wrappedErrors;
+            wrappedErrors = [];
+        }
+        // Call the parent constructor
+        super(errorCode);
+        // Filling error
+        this.code = errorCode || 'E_UNEXPECTED';
+        this.params = params;
+        this.wrappedErrors = wrappedErrors;
+        this.name = this.toString();
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+    /**
+     * Wraps any error and output a YError with an error
+     *  code and some params as debug values.
+     * @param {Error} err
+     * The error to wrap
+     * @param {string} [errorCode = 'E_UNEXPECTED']
+     * The error code corresponding to the actual error
+     * @param {...YErrorParams} [params]
+     * Some additional debugging values
+     * @return {YError}
+     * The wrapped error
+     */
+    static wrap(err, errorCode, ...params) {
+        const wrappedErrorIsACode = _looksLikeAYErrorCode(err.message);
+        const wrappedErrors = ('wrappedErrors' in err ? err.wrappedErrors : []).concat(err);
+        if (!errorCode) {
+            if (wrappedErrorIsACode) {
+                errorCode = err.message;
+            }
+            else {
+                errorCode = 'E_UNEXPECTED';
+            }
+        }
+        if (err.message && !wrappedErrorIsACode) {
+            params.push(err.message);
+        }
+        return new dist_YError(wrappedErrors, errorCode, ...params);
+    }
+    /**
+     * Return a YError as is or wraps any other error and output
+     *  a YError with a code and some params as debug values.
+     * @param {Error} err
+     * The error to cast
+     * @param {string} [errorCode = 'E_UNEXPECTED']
+     * The error code corresponding to the actual error
+     * @param {...YErrorParams} [params]
+     * Some additional debugging values
+     * @return {YError}
+     * The wrapped error
+     */
+    static cast(err, errorCode, ...params) {
+        if (_looksLikeAYError(err)) {
+            return err;
+        }
+        return dist_YError.wrap(err, errorCode, ...params);
+    }
+    /**
+     * Same than `YError.wrap()` but preserves the code
+     *  and the debug values of the error if it is
+     *  already an instance of the YError constructor.
+     * @param {Error} err
+     * The error to bump
+     * @param {string} [errorCode = 'E_UNEXPECTED']
+     * The error code corresponding to the actual error
+     * @param {...YErrorParams} [params]
+     * Some additional debugging values
+     * @return {YError}
+     * The wrapped error
+     */
+    static bump(err, errorCode, ...params) {
+        if (_looksLikeAYError(err)) {
+            return dist_YError.wrap(err, err.code, ...err.params);
+        }
+        return dist_YError.wrap(err, errorCode, ...params);
+    }
+    toString() {
+        return ((this.wrappedErrors.length
+            ? // eslint-disable-next-line
+                this.wrappedErrors[this.wrappedErrors.length - 1].stack + external_os_.EOL
+            : '') +
+            this.constructor.name +
+            ': ' +
+            this.code +
+            ' (' +
+            this.params.join(', ') +
+            ')');
+    }
+}
+/**
+ * Allow to print a stack from anything (especially catched
+ *  errors that may or may not contain errors 🤷).
+ * @param {Error} err
+ * The error to print
+ * @return {string}
+ * The stack trace if any
+ */
+function printStackTrace(err) {
+    return typeof err === 'object' && typeof err.stack === 'string'
+        ? err.stack
+        : `[no_stack_trace]: error is ${err != null && typeof err.toString === 'function'
+            ? err.toString()
+            : typeof err}`;
+}
+// In order to keep compatibility through major versions
+// we have to make kind of an cross major version instanceof
+function _looksLikeAYError(err) {
+    return (!!(err instanceof dist_YError) ||
+        !!(err.constructor &&
+            err.constructor.name &&
+            err.constructor.name.endsWith('Error') &&
+            'code' in err &&
+            'string' === typeof err.code &&
+            _looksLikeAYErrorCode(err.code) &&
+            'params' in err &&
+            err.params &&
+            err.params instanceof Array));
+}
+function _looksLikeAYErrorCode(str) {
+    return /^([A-Z0-9_]+)$/.test(str);
+}
+
+//# sourceMappingURL=index.js.map
+;// ../../scrypted/packages/auth-fetch/node_modules/http-auth-utils/dist/utils.js
+
+const QUOTE = '"';
+const EQUAL = '=';
+const SEPARATOR = ', ';
+/*
+ * Regular expression for matching the key-value pairs
+ * \w+     = The key
+ * =       = The equal sign
+ * ".*?"   = Value option 1: A double-quoted value (using the non-greedy *? to stop at the first doublequote)
+ * [^",]+  = Value option 2: A string without commas or double-quotes
+ * (?=,|$) = Zero-width (as in not captured) positive lookahead assertion.
+ *           The previous match will only be valid if it's followed by a " literal
+ *           or the end of the string
+ */
+const KEYVALUE_REGEXP = /\w+=(".*?"|[^",]+)(?=,|$)/g;
+// FIXME: Create a real parser
+function parseHTTPHeadersQuotedKeyValueSet(contents, authorizedKeys, requiredKeys = [], valuesToNormalize = []) {
+    const matches = contents.trim().match(KEYVALUE_REGEXP);
+    if (!matches)
+        throw new dist_YError('E_MALFORMED_QUOTEDKEYVALUE', contents);
+    const data = matches
+        .map((part, partPosition) => {
+        const [key, ...rest] = part.split(EQUAL);
+        const value = rest.join(EQUAL);
+        if (0 === rest.length) {
+            throw new dist_YError('E_MALFORMED_QUOTEDKEYVALUE', partPosition, part);
+        }
+        return [key, value];
+    })
+        .reduce(function (parsedValues, [name, value], valuePosition) {
+        const normalizedName = name.toLowerCase();
+        if (-1 === authorizedKeys.indexOf(normalizedName)) {
+            throw new dist_YError('E_UNAUTHORIZED_KEY', valuePosition, normalizedName);
+        }
+        /*
+         * Regular expression for stripping paired starting and ending double quotes off the value:
+         * ^      = The beginning of the string
+         * "      = The first double quote
+         * .+     = One or more characters of any kind
+         * (?="$) = Zero-width (as in not captured) positive lookahead assertion.
+         *          The previous match will only be valid if it's followed by a " literal
+         *          or the end of the string
+         * "      = The ending double quote
+         * $      = The end of the string
+         */
+        const strippedValue = value.replace(/^"(.+(?="$))"$/, '$1');
+        parsedValues[normalizedName] = valuesToNormalize.includes(normalizedName)
+            ? strippedValue.toLowerCase()
+            : strippedValue;
+        return parsedValues;
+    }, {});
+    _checkRequiredKeys(requiredKeys, data);
+    return data;
+}
+function buildHTTPHeadersQuotedKeyValueSet(data, authorizedKeys, requiredKeys = []) {
+    _checkRequiredKeys(requiredKeys, data);
+    return authorizedKeys.reduce(function (contents, key) {
+        if (data[key]) {
+            return (contents +
+                (contents ? SEPARATOR : '') +
+                key +
+                EQUAL +
+                QUOTE +
+                data[key] +
+                QUOTE);
+        }
+        return contents;
+    }, '');
+}
+function _checkRequiredKeys(requiredKeys, data) {
+    requiredKeys.forEach((name) => {
+        if ('undefined' === typeof data[name]) {
+            throw new dist_YError('E_REQUIRED_KEY', name);
+        }
+    });
+}
+//# sourceMappingURL=utils.js.map
+;// ../../scrypted/packages/auth-fetch/node_modules/http-auth-utils/dist/mechanisms/basic.js
+/**
+ * @module http-auth-utils/mechanisms/basic
+ */
+
+
+const REQUIRED_WWW_AUTHENTICATE_KEYS = ['realm'];
+const AUTHORIZED_WWW_AUTHENTICATE_KEYS = REQUIRED_WWW_AUTHENTICATE_KEYS;
+/* Architecture Note #1.2: Basic mechanism
+
+See the following [RFC](https://tools.ietf.org/html/rfc7617).
+
+*/
+/**
+ * Basic authentication mechanism.
+ * @type {Object}
+ * @see http://tools.ietf.org/html/rfc2617#section-2
+ */
+const BASIC = {
+    /**
+     * The Basic auth mechanism prefix.
+     * @type {String}
+     */
+    type: 'Basic',
+    /**
+     * Parse the WWW Authenticate header rest.
+     * @param  {String} rest The header rest (string after the authentication mechanism prefix).
+     * @return {Object}      Object representing the result of the parse operation.
+     * @example
+     * assert.deepEqual(
+     *   BASIC.parseWWWAuthenticateRest('realm="perlinpinpin"'), {
+     *     realm: 'perlinpinpin'
+     *   }
+     * );
+     * @api public
+     */
+    parseWWWAuthenticateRest: function parseWWWAuthenticateRest(rest) {
+        return parseHTTPHeadersQuotedKeyValueSet(rest, AUTHORIZED_WWW_AUTHENTICATE_KEYS, REQUIRED_WWW_AUTHENTICATE_KEYS);
+    },
+    /**
+     * Build the WWW Authenticate header rest.
+     * @param  {Object} data The content from wich to build the rest.
+     * @return {String}         The built rest.
+     * @example
+     * assert.equal(
+     *   BASIC.buildWWWAuthenticateRest({
+     *     realm: 'perlinpinpin'
+     *   }),
+     *   'realm="perlinpinpin"'
+     * );
+     * @api public
+     */
+    buildWWWAuthenticateRest: function buildWWWAuthenticateRest(data) {
+        return buildHTTPHeadersQuotedKeyValueSet(data, AUTHORIZED_WWW_AUTHENTICATE_KEYS, REQUIRED_WWW_AUTHENTICATE_KEYS);
+    },
+    /**
+     * Parse the Authorization header rest.
+     * @param  {String} rest The header rest (string after the authentication mechanism prefix).)
+     * @return {Object}      Object representing the result of the parse operation {hash}.
+     * @example
+     * assert.deepEqual(
+     *   BASIC.parseAuthorizationRest('QWxpIEJhYmE6b3BlbiBzZXNhbWU='), {
+     *     hash: 'QWxpIEJhYmE6b3BlbiBzZXNhbWU=',
+     *     username: 'Ali Baba',
+     *     password: 'open sesame'
+     *   }
+     * );
+     * @api public
+     */
+    parseAuthorizationRest: function parseAuthorizationRest(rest) {
+        if (!rest) {
+            throw new dist_YError('E_EMPTY_AUTH');
+        }
+        const { username, password } = BASIC.decodeHash(rest);
+        return {
+            hash: rest,
+            username,
+            password,
+        };
+    },
+    /**
+     * Build the Authorization header rest.
+     * @param  {Object} content The content from wich to build the rest.
+     * @return {String}         The rest built.
+     * @example
+     * assert.equal(
+     *   BASIC.buildAuthorizationRest({
+     *     hash: 'QWxpIEJhYmE6b3BlbiBzZXNhbWU='
+     *   }),
+     *   'QWxpIEJhYmE6b3BlbiBzZXNhbWU='
+     * );
+     * @api public
+     */
+    buildAuthorizationRest: function buildAuthorizationRest({ hash, username, password, }) {
+        if (username && password) {
+            return BASIC.computeHash({
+                username,
+                password,
+            });
+        }
+        if (!hash) {
+            throw new dist_YError('E_NO_HASH');
+        }
+        return hash;
+    },
+    /**
+     * Compute the Basic authentication hash from the given credentials.
+     * @param  {Object} credentials The credentials to encode {username, password}.
+     * @return {String}             The hash representing the credentials.
+     * @example
+     * assert.equal(
+     *   BASIC.computeHash({
+     *     username: 'Ali Baba',
+     *     password: 'open sesame'
+     *   }),
+     *   'QWxpIEJhYmE6b3BlbiBzZXNhbWU='
+     * );
+     * @api public
+     */
+    computeHash: function computeHash({ username, password, }) {
+        return Buffer.from(username + ':' + password).toString('base64');
+    },
+    /**
+     * Decode the Basic hash and return the corresponding credentials.
+     * @param  {String} hash The hash.
+     * @return {Object}      Object representing the credentials {username, password}.
+     * @example
+     * assert.deepEqual(
+     *   BASIC.decodeHash('QWxpIEJhYmE6b3BlbiBzZXNhbWU='), {
+     *     username: 'Ali Baba',
+     *     password: 'open sesame'
+     *   }
+     * );
+     * @api public
+     */
+    decodeHash: function decodeHash(hash) {
+        const [username, ...passwordParts] = Buffer.from(hash, 'base64')
+            .toString()
+            .split(':');
+        return {
+            username,
+            password: passwordParts.join(':'),
+        };
+    },
+};
+/* harmony default export */ const basic = (BASIC);
+//# sourceMappingURL=basic.js.map
+// EXTERNAL MODULE: external "crypto"
+var external_crypto_ = __webpack_require__(6982);
+;// ../../scrypted/packages/auth-fetch/node_modules/http-auth-utils/dist/mechanisms/digest.js
+/**
+ * @module http-auth-utils/mechanisms/digest
+ */
+
+
+const digest_REQUIRED_WWW_AUTHENTICATE_KEYS = ['realm', 'nonce'];
+const digest_AUTHORIZED_WWW_AUTHENTICATE_KEYS = [
+    ...digest_REQUIRED_WWW_AUTHENTICATE_KEYS,
+    'domain',
+    'opaque',
+    'stale',
+    'algorithm',
+    'qop',
+];
+const CASE_INSENSITIVE_WWW_AUTHENTICATE_VALUES = ['stale'];
+const REQUIRED_AUTHORIZATION_KEYS = [
+    'username',
+    'realm',
+    'nonce',
+    'uri',
+    'response',
+];
+const AUTHORIZED_AUTHORIZATION_KEYS = [
+    ...REQUIRED_AUTHORIZATION_KEYS,
+    'algorithm',
+    'cnonce',
+    'opaque',
+    'qop',
+    'nc',
+];
+/* Architecture Note #1.3: Digest mechanism
+
+See the following [RFC](https://tools.ietf.org/html/rfc2617).
+
+*/
+/**
+ * Digest authentication mechanism.
+ * @type {Object}
+ * @see http://tools.ietf.org/html/rfc2617#section-3
+ * @see http://tools.ietf.org/html/rfc2069#section-2
+ */
+const DIGEST = {
+    /**
+     * The Digest auth mechanism prefix.
+     * @type {String}
+     */
+    type: 'Digest',
+    /**
+     * Parse the WWW Authenticate header rest.
+     * @param  {String} rest The header rest (string after the authentication mechanism prefix).
+     * @return {Object}      Object representing the result of the parse operation.
+     * @example
+     * assert.deepEqual(
+     *   DIGEST.parseWWWAuthenticateRest(
+     *     'realm="testrealm@host.com", ' +
+     *     'qop="auth, auth-int", ' +
+     *     'nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093", ' +
+     *     'opaque="5ccc069c403ebaf9f0171e9517f40e41"'
+     *   ), {
+     *     realm: 'testrealm@host.com',
+     *     qop: 'auth, auth-int',
+     *     nonce: 'dcd98b7102dd2f0e8b11d0f600bfb0c093',
+     *     opaque: '5ccc069c403ebaf9f0171e9517f40e41'
+     *   }
+     * );
+     * @api public
+     */
+    parseWWWAuthenticateRest: function parseWWWAuthenticateRest(rest) {
+        return parseHTTPHeadersQuotedKeyValueSet(rest, digest_AUTHORIZED_WWW_AUTHENTICATE_KEYS, digest_REQUIRED_WWW_AUTHENTICATE_KEYS, CASE_INSENSITIVE_WWW_AUTHENTICATE_VALUES);
+    },
+    /**
+     * Build the WWW Authenticate header rest.
+     * @param  {Object} data The content from which to build the rest.
+     * @return {String}         The built rest.
+     * @example
+     * assert.equal(
+     *   DIGEST.buildWWWAuthenticateRest({
+     *     realm: 'testrealm@host.com',
+     *     qop: 'auth, auth-int',
+     *     nonce: 'dcd98b7102dd2f0e8b11d0f600bfb0c093',
+     *     opaque: '5ccc069c403ebaf9f0171e9517f40e41'
+     *   }),
+     *   'realm="testrealm@host.com", ' +
+     *   'qop="auth, auth-int", ' +
+     *   'nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093", ' +
+     *   'opaque="5ccc069c403ebaf9f0171e9517f40e41"'
+     * );
+     * @api public
+     */
+    buildWWWAuthenticateRest: function buildWWWAuthenticateRest(data) {
+        return buildHTTPHeadersQuotedKeyValueSet(data, digest_AUTHORIZED_WWW_AUTHENTICATE_KEYS, digest_REQUIRED_WWW_AUTHENTICATE_KEYS);
+    },
+    /**
+     * Parse the Authorization header rest.
+     * @param  {String} rest The header rest (string after the authentication mechanism prefix).)
+     * @return {Object}      Object representing the result of the parse operation {hash}.
+     * @example
+     * assert.deepEqual(
+     *   DIGEST.parseAuthorizationRest(
+     *     'username="Mufasa",' +
+     *     'realm="testrealm@host.com",' +
+     *     'nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093",' +
+     *     'uri="/dir/index.html",' +
+     *     'qop="auth",' +
+     *     'nc="00000001",' +
+     *     'cnonce="0a4f113b",' +
+     *     'response="6629fae49393a05397450978507c4ef1",' +
+     *     'opaque="5ccc069c403ebaf9f0171e9517f40e41"'
+     *   ), {
+     *     username: "Mufasa",
+     *     realm: 'testrealm@host.com',
+     *     nonce: "dcd98b7102dd2f0e8b11d0f600bfb0c093",
+     *     uri: "/dir/index.html",
+     *     qop: 'auth',
+     *     nc: '00000001',
+     *     cnonce: "0a4f113b",
+     *     response: "6629fae49393a05397450978507c4ef1",
+     *     opaque: "5ccc069c403ebaf9f0171e9517f40e41"
+     *   }
+     * );
+     * @api public
+     */
+    parseAuthorizationRest: function parseAuthorizationRest(rest) {
+        return parseHTTPHeadersQuotedKeyValueSet(rest, AUTHORIZED_AUTHORIZATION_KEYS, REQUIRED_AUTHORIZATION_KEYS);
+    },
+    /**
+     * Build the Authorization header rest.
+     * @param  {Object} data The content from which to build the rest.
+     * @return {String}         The rest built.
+     * @example
+     * assert.equal(
+     *   DIGEST.buildAuthorizationRest({
+     *     username: "Mufasa",
+     *     realm: 'testrealm@host.com',
+     *     nonce: "dcd98b7102dd2f0e8b11d0f600bfb0c093",
+     *     uri: "/dir/index.html",
+     *     qop: 'auth',
+     *     nc: '00000001',
+     *     cnonce: "0a4f113b",
+     *     response: "6629fae49393a05397450978507c4ef1",
+     *     opaque: "5ccc069c403ebaf9f0171e9517f40e41"
+     *   }),
+     *   'username="Mufasa", ' +
+     *   'realm="testrealm@host.com", ' +
+     *   'nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093", ' +
+     *   'uri="/dir/index.html", ' +
+     *   'response="6629fae49393a05397450978507c4ef1", ' +
+     *   'cnonce="0a4f113b", ' +
+     *   'opaque="5ccc069c403ebaf9f0171e9517f40e41", ' +
+     *   'qop="auth", ' +
+     *   'nc="00000001"'
+     * );
+     * @api public
+     */
+    buildAuthorizationRest: function buildAuthorizationRest(data) {
+        return buildHTTPHeadersQuotedKeyValueSet(data, AUTHORIZED_AUTHORIZATION_KEYS, REQUIRED_AUTHORIZATION_KEYS);
+    },
+    /**
+     * Compute the Digest authentication hash from the given credentials.
+     * @param  {Object} data The credentials to encode and other encoding details.
+     * @return {String}             The hash representing the credentials.
+     * @example
+     * assert.equal(
+     *   DIGEST.computeHash({
+     *     username: 'Mufasa',
+     *     realm: 'testrealm@host.com',
+     *     password: 'Circle Of Life',
+     *     method: 'GET',
+     *     uri: '/dir/index.html',
+     *     nonce: 'dcd98b7102dd2f0e8b11d0f600bfb0c093',
+     *     nc: '00000001',
+     *     cnonce: '0a4f113b',
+     *     qop: 'auth',
+     *     algorithm: 'md5'
+     *   }),
+     *   '6629fae49393a05397450978507c4ef1'
+     * );
+     * @api public
+     */
+    computeHash: function computeHash(data) {
+        const ha1 = data.ha1 ||
+            _computeHash(data.algorithm, [data.username, data.realm, data.password].join(':'));
+        const ha2 = _computeHash(data.algorithm, [data.method, data.uri].join(':'));
+        return _computeHash(data.algorithm, [ha1, data.nonce, data.nc, data.cnonce, data.qop, ha2].join(':'));
+    },
+};
+function _computeHash(algorithm, str) {
+    const hashsum = external_crypto_.createHash(algorithm);
+    hashsum.update(str);
+    return hashsum.digest('hex');
+}
+/* harmony default export */ const digest = (DIGEST);
+//# sourceMappingURL=digest.js.map
+;// ../../scrypted/packages/auth-fetch/node_modules/http-auth-utils/dist/mechanisms/bearer.js
+/**
+ * @module http-auth-utils/mechanisms/bearer
+ */
+
+
+const AUTHORIZED_ERROR_CODES = [
+    'invalid_request',
+    'invalid_token',
+    'insufficient_scope',
+];
+const bearer_REQUIRED_WWW_AUTHENTICATE_KEYS = ['realm'];
+const bearer_AUTHORIZED_WWW_AUTHENTICATE_KEYS = [
+    ...bearer_REQUIRED_WWW_AUTHENTICATE_KEYS,
+    'scope',
+    'error',
+    'error_description',
+];
+/* Architecture Note #1.1: Bearer mechanism
+
+See the following [RFC](https://tools.ietf.org/html/rfc6750).
+
+*/
+/**
+ * Bearer authentication mechanism.
+ * @type {Object}
+ * @see https://tools.ietf.org/html/rfc6750#section-3
+ */
+const BEARER = {
+    /**
+     * The Bearer auth mechanism prefix.
+     * @type {String}
+     */
+    type: 'Bearer',
+    /**
+     * Parse the WWW Authenticate header rest.
+     * @param  {String} rest The header rest (string after the authentication mechanism prefix).
+     * @return {Object}      Object representing the result of the parse operation.
+     * @example
+     * assert.deepEqual(
+     *   BEARER.parseWWWAuthenticateRest(
+     *     'realm="testrealm@host.com", ' +
+     *     'scope="openid profile email"'
+     *   ), {
+     *     realm: 'testrealm@host.com',
+     *     scope: 'openid profile email',
+     *   }
+     * );
+     * @api public
+     */
+    parseWWWAuthenticateRest: function parseWWWAuthenticateRest(rest) {
+        return parseHTTPHeadersQuotedKeyValueSet(rest, bearer_AUTHORIZED_WWW_AUTHENTICATE_KEYS, []);
+    },
+    /**
+     * Build the WWW Authenticate header rest.
+     * @param  {Object} data The content from wich to build the rest.
+     * @return {String}         The built rest.
+     * @example
+     * assert.equal(
+     *   BEARER.buildWWWAuthenticateRest({
+     *     realm: 'testrealm@host.com',
+     *     error: 'invalid_request',
+     *     error_description: 'The access token expired',
+     *   }),
+     *   'realm="testrealm@host.com", ' +
+     *   'error="invalid_request", ' +
+     *   'error_description="The access token expired"'
+     * );
+     * @api public
+     */
+    buildWWWAuthenticateRest: function buildWWWAuthenticateRest(data) {
+        if (data.error &&
+            -1 ===
+                AUTHORIZED_ERROR_CODES.indexOf(data.error)) {
+            throw new dist_YError('E_INVALID_ERROR', data.error, AUTHORIZED_ERROR_CODES);
+        }
+        return buildHTTPHeadersQuotedKeyValueSet(data, bearer_AUTHORIZED_WWW_AUTHENTICATE_KEYS, []);
+    },
+    /**
+     * Parse the Authorization header rest.
+     * @param  {String} rest The header rest (string after the authentication mechanism prefix).)
+     * @return {Object}      Object representing the result of the parse operation {hash}.
+     * @example
+     * assert.deepEqual(
+     *   BEARER.parseAuthorizationRest('mF_9.B5f-4.1JqM'), {
+     *     hash: 'mF_9.B5f-4.1JqM',
+     *   }
+     * );
+     * @api public
+     */
+    parseAuthorizationRest: function parseAuthorizationRest(rest) {
+        if (!rest) {
+            throw new dist_YError('E_EMPTY_AUTH');
+        }
+        return {
+            hash: rest,
+        };
+    },
+    /**
+     * Build the Authorization header rest.
+     * @param  {Object} content The content from wich to build the rest.
+     * @return {String}         The rest built.
+     * @example
+     * assert.equal(
+     *   BEARER.buildAuthorizationRest({
+     *     hash: 'mF_9.B5f-4.1JqM'
+     *   }),
+     *   'mF_9.B5f-4.1JqM=='
+     * );
+     * @api public
+     */
+    buildAuthorizationRest: function buildAuthorizationRest({ hash, }) {
+        if (!hash) {
+            throw new dist_YError('E_NO_HASH');
+        }
+        return hash;
+    },
+};
+/* harmony default export */ const bearer = (BEARER);
+//# sourceMappingURL=bearer.js.map
+;// ../../scrypted/packages/auth-fetch/node_modules/http-auth-utils/dist/index.js
+
+
+
+
+/**
+ * @module http-auth-utils
+ */
+/**
+ * Natively supported authentication mechanisms.
+ * @type {Array}
+ */
+const mechanisms = [basic, digest, bearer];
+/**
+ * Basic authentication mechanism.
+ * @type {Object}
+ * @see  {@link module:http-auth-utils/mechanisms/basic}
+ */
+basic;
+/**
+ * Digest authentication mechanism.
+ * @type {Object}
+ * @see  {@link module:http-auth-utils/mechanisms/digest}
+ */
+digest;
+/**
+ * Bearer authentication mechanism.
+ * @type {Object}
+ * @see  {@link module:http-auth-utils/mechanisms/digest}
+ */
+bearer;
+
+/**
+ * Parse HTTP WWW-Authenticate header contents.
+ * @type {Function}
+ * @param {string} header
+ * The WWW-Authenticate header contents
+ * @param {Array} [authMechanisms=[BASIC, DIGEST, BEARER]]
+ * Allow providing custom authentication mechanisms.
+ * @param {Object} [options]
+ * Parsing options
+ * @param {boolean} [options.strict=true]
+ * Strictly detect the mechanism type (case sensitive)
+ * @return {Object} Result of the contents parse.
+ * @api public
+ * @example
+ * assert.deepEqual(
+ *   parseWWWAuthenticateHeader('Basic realm="test"'), {
+ *     type: 'Basic',
+ *     data: {
+ *       realm: 'test'
+ *     }
+ *   }
+ * );
+ */
+function parseWWWAuthenticateHeader(header, authMechanisms = mechanisms, { strict = true } = { strict: true }) {
+    let result = null;
+    authMechanisms.some((authMechanism) => {
+        if (0 === header.indexOf(authMechanism.type + ' ') ||
+            (!strict && 0 === header.indexOf(authMechanism.type.toLowerCase() + ' '))) {
+            result = {
+                type: authMechanism.type,
+                data: authMechanism.parseWWWAuthenticateRest(header.substr(authMechanism.type.length + 1)),
+            };
+            return true;
+        }
+        return false;
+    });
+    if (!result) {
+        throw new dist_YError('E_UNKNOWN_AUTH_MECHANISM', header);
+    }
+    return result;
+}
+/**
+ * Parse HTTP Authorization header contents.
+ * @type {Function}
+ * @param {string} header The Authorization header contents
+ * @param {Array} [authMechanisms=[BASIC, DIGEST, BEARER]]
+ * Allow custom authentication mechanisms.
+ * @param {Object} [options]
+ * Parsing options
+ * @param {boolean} [options.strict=true]
+ * Strictly detect the mechanism type (case sensitive)
+ * @return {Object} Result of the contents parse.
+ * @api public
+ * @example
+ * assert.deepEqual(
+ *   parseAuthorizationHeader('Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ=='), {
+ *     type: 'Basic',
+ *     data: {
+ *       hash: 'QWxhZGRpbjpvcGVuIHNlc2FtZQ=='
+ *     }
+ *   }
+ * );
+ */
+function parseAuthorizationHeader(header, authMechanisms = mechanisms, { strict = true } = { strict: true }) {
+    let result = null;
+    authMechanisms.some(function (authMechanism) {
+        if (0 === header.indexOf(authMechanism.type + ' ') ||
+            (!strict && 0 === header.indexOf(authMechanism.type.toLowerCase() + ' '))) {
+            result = {
+                type: authMechanism.type,
+                data: authMechanism.parseAuthorizationRest(header.substr(authMechanism.type.length + 1)),
+            };
+            return true;
+        }
+        return false;
+    });
+    if (result) {
+        return result;
+    }
+    throw new YError('E_UNKNOWN_AUTH_MECHANISM', header);
+}
+/**
+ * Build HTTP WWW-Authenticate header value.
+ * @type {Function}
+ * @param {Object} authMechanism The mechanism to use
+ * @param {Object}
+ * The WWW-Authenticate header contents to base the value on.
+ * @return {string} The header value.
+ * @api public
+ * @example
+ * assert.deepEqual(
+ *   buildWWWAuthenticateHeader(BASIC, {
+ *     realm: 'test'
+ *   }),
+ *   'Basic realm="test"'
+ * );
+ */
+function buildWWWAuthenticateHeader(authMechanism, data) {
+    return `${authMechanism.type} ${authMechanism.buildWWWAuthenticateRest(data)}`;
+}
+/**
+ * Build HTTP Authorization header value.
+ * @type {Function}
+ * @param {Object} authMechanism The mechanism to use
+ * @param {Object}
+ * The Authorization header contents to base the value on.
+ * @return {string} The header value.
+ * @api public
+ * @example
+ * assert.deepEqual(
+ *   buildAuthorizationHeader(BASIC, {
+ *     realm: 'test'
+ *   }),
+ *   'Basic realm="test"'
+ * );
+ */
+function buildAuthorizationHeader(authMechanism, data) {
+    return `${authMechanism.type} ${authMechanism.buildAuthorizationRest(data)}`;
+}
+//# sourceMappingURL=index.js.map
+
+/***/ })
+
+};
+;
+
+//# sourceURL=/plugin/724