@browsercapturesalt/herokuappman
Version:
Heroku application manager.
2,403 lines (2,294 loc) • 2.46 MB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('punycode'), require('os'), require('worker_threads'), require('buffer'), require('path'), require('events'), require('util'), require('tty'), require('fs'), require('net'), require('stream'), require('crypto'), require('querystring'), require('http'), require('child_process'), require('string_decoder'), require('zlib'), require('url'), require('https'), require('node:http'), require('node:https'), require('node:zlib'), require('node:stream'), require('node:buffer'), require('node:util'), require('node:url'), require('node:net'), require('node:fs'), require('node:path')) :
typeof define === 'function' && define.amd ? define(['exports', 'punycode', 'os', 'worker_threads', 'buffer', 'path', 'events', 'util', 'tty', 'fs', 'net', 'stream', 'crypto', 'querystring', 'http', 'child_process', 'string_decoder', 'zlib', 'url', 'https', 'node:http', 'node:https', 'node:zlib', 'node:stream', 'node:buffer', 'node:util', 'node:url', 'node:net', 'node:fs', 'node:path'], factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.herokuappman = {}, global.punycode, global.os, global.worker_threads, global.buffer, global.path$2, global.events, global.util, global.tty, global.fs, global.net, global.Stream, global.crypto$1, global.querystring, global.http, global.child_process, global.string_decoder, global.zlib, global.Url$1, global.https, global.http$1, global.https$1, global.zlib$1, global.Stream$1, global.node_buffer, global.node_util, global.node_url, global.node_net));
})(this, (function (exports, punycode, os, worker_threads, buffer, path$2, events, util, tty, fs, net, Stream, crypto$1, querystring, http, child_process, string_decoder, zlib, Url$1, https, http$1, https$1, zlib$1, Stream$1, node_buffer, node_util, node_url, node_net) { 'use strict';
function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
var punycode__default = /*#__PURE__*/_interopDefaultLegacy(punycode);
var os__default = /*#__PURE__*/_interopDefaultLegacy(os);
var worker_threads__default = /*#__PURE__*/_interopDefaultLegacy(worker_threads);
var buffer__default = /*#__PURE__*/_interopDefaultLegacy(buffer);
var path__default = /*#__PURE__*/_interopDefaultLegacy(path$2);
var events__default = /*#__PURE__*/_interopDefaultLegacy(events);
var util__default = /*#__PURE__*/_interopDefaultLegacy(util);
var tty__default = /*#__PURE__*/_interopDefaultLegacy(tty);
var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
var net__default = /*#__PURE__*/_interopDefaultLegacy(net);
var Stream__default = /*#__PURE__*/_interopDefaultLegacy(Stream);
var crypto__default = /*#__PURE__*/_interopDefaultLegacy(crypto$1);
var querystring__default = /*#__PURE__*/_interopDefaultLegacy(querystring);
var http__default = /*#__PURE__*/_interopDefaultLegacy(http);
var child_process__default = /*#__PURE__*/_interopDefaultLegacy(child_process);
var string_decoder__default = /*#__PURE__*/_interopDefaultLegacy(string_decoder);
var zlib__default = /*#__PURE__*/_interopDefaultLegacy(zlib);
var Url__default = /*#__PURE__*/_interopDefaultLegacy(Url$1);
var https__default = /*#__PURE__*/_interopDefaultLegacy(https);
var http__default$1 = /*#__PURE__*/_interopDefaultLegacy(http$1);
var https__default$1 = /*#__PURE__*/_interopDefaultLegacy(https$1);
var zlib__default$1 = /*#__PURE__*/_interopDefaultLegacy(zlib$1);
var Stream__default$1 = /*#__PURE__*/_interopDefaultLegacy(Stream$1);
/*! *****************************************************************************
Copyright (c) Microsoft Corporation.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
function __awaiter(thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
}
function __generator(thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
}
function getUserAgent() {
if (typeof navigator === "object" && "userAgent" in navigator) {
return navigator.userAgent;
}
if (typeof process === "object" && "version" in process) {
return `Node.js/${process.version.substr(1)} (${process.platform}; ${process.arch})`;
}
return "<environment undetectable>";
}
var distWeb$b = /*#__PURE__*/Object.freeze({
__proto__: null,
getUserAgent: getUserAgent
});
var register_1 = register;
function register(state, name, method, options) {
if (typeof method !== "function") {
throw new Error("method for before hook must be a function");
}
if (!options) {
options = {};
}
if (Array.isArray(name)) {
return name.reverse().reduce(function (callback, name) {
return register.bind(null, state, name, callback, options);
}, method)();
}
return Promise.resolve().then(function () {
if (!state.registry[name]) {
return method(options);
}
return state.registry[name].reduce(function (method, registered) {
return registered.hook.bind(null, method, options);
}, method)();
});
}
var add = addHook;
function addHook(state, kind, name, hook) {
var orig = hook;
if (!state.registry[name]) {
state.registry[name] = [];
}
if (kind === "before") {
hook = function (method, options) {
return Promise.resolve()
.then(orig.bind(null, options))
.then(method.bind(null, options));
};
}
if (kind === "after") {
hook = function (method, options) {
var result;
return Promise.resolve()
.then(method.bind(null, options))
.then(function (result_) {
result = result_;
return orig(result, options);
})
.then(function () {
return result;
});
};
}
if (kind === "error") {
hook = function (method, options) {
return Promise.resolve()
.then(method.bind(null, options))
.catch(function (error) {
return orig(error, options);
});
};
}
state.registry[name].push({
hook: hook,
orig: orig,
});
}
var remove = removeHook;
function removeHook(state, name, method) {
if (!state.registry[name]) {
return;
}
var index = state.registry[name]
.map(function (registered) {
return registered.orig;
})
.indexOf(method);
if (index === -1) {
return;
}
state.registry[name].splice(index, 1);
}
// bind with array of arguments: https://stackoverflow.com/a/21792913
var bind = Function.bind;
var bindable = bind.bind(bind);
function bindApi (hook, state, name) {
var removeHookRef = bindable(remove, null).apply(null, name ? [state, name] : [state]);
hook.api = { remove: removeHookRef };
hook.remove = removeHookRef
;['before', 'error', 'after', 'wrap'].forEach(function (kind) {
var args = name ? [state, kind, name] : [state, kind];
hook[kind] = hook.api[kind] = bindable(add, null).apply(null, args);
});
}
function HookSingular () {
var singularHookName = 'h';
var singularHookState = {
registry: {}
};
var singularHook = register_1.bind(null, singularHookState, singularHookName);
bindApi(singularHook, singularHookState, singularHookName);
return singularHook
}
function HookCollection () {
var state = {
registry: {}
};
var hook = register_1.bind(null, state);
bindApi(hook, state);
return hook
}
var collectionHookDeprecationMessageDisplayed = false;
function Hook () {
if (!collectionHookDeprecationMessageDisplayed) {
console.warn('[before-after-hook]: "Hook()" repurposing warning, use "Hook.Collection()". Read more: https://git.io/upgrade-before-after-hook-to-1.4');
collectionHookDeprecationMessageDisplayed = true;
}
return HookCollection()
}
Hook.Singular = HookSingular.bind();
Hook.Collection = HookCollection.bind();
var beforeAfterHook = Hook;
// expose constructors as a named property for TypeScript
var Hook_1 = Hook;
var Singular = Hook.Singular;
var Collection = Hook.Collection;
beforeAfterHook.Hook = Hook_1;
beforeAfterHook.Singular = Singular;
beforeAfterHook.Collection = Collection;
/*!
* is-plain-object <https://github.com/jonschlinkert/is-plain-object>
*
* Copyright (c) 2014-2017, Jon Schlinkert.
* Released under the MIT License.
*/
function isObject(o) {
return Object.prototype.toString.call(o) === '[object Object]';
}
function isPlainObject(o) {
var ctor,prot;
if (isObject(o) === false) return false;
// If has modified constructor
ctor = o.constructor;
if (ctor === undefined) return true;
// If has modified prototype
prot = ctor.prototype;
if (isObject(prot) === false) return false;
// If constructor does not have an Object-specific method
if (prot.hasOwnProperty('isPrototypeOf') === false) {
return false;
}
// Most likely a plain Object
return true;
}
function lowercaseKeys(object) {
if (!object) {
return {};
}
return Object.keys(object).reduce((newObj, key) => {
newObj[key.toLowerCase()] = object[key];
return newObj;
}, {});
}
function mergeDeep(defaults, options) {
const result = Object.assign({}, defaults);
Object.keys(options).forEach((key) => {
if (isPlainObject(options[key])) {
if (!(key in defaults))
Object.assign(result, { [key]: options[key] });
else
result[key] = mergeDeep(defaults[key], options[key]);
}
else {
Object.assign(result, { [key]: options[key] });
}
});
return result;
}
function removeUndefinedProperties(obj) {
for (const key in obj) {
if (obj[key] === undefined) {
delete obj[key];
}
}
return obj;
}
function merge$2(defaults, route, options) {
if (typeof route === "string") {
let [method, url] = route.split(" ");
options = Object.assign(url ? { method, url } : { url: method }, options);
}
else {
options = Object.assign({}, route);
}
// lowercase header names before merging with defaults to avoid duplicates
options.headers = lowercaseKeys(options.headers);
// remove properties with undefined values before merging
removeUndefinedProperties(options);
removeUndefinedProperties(options.headers);
const mergedOptions = mergeDeep(defaults || {}, options);
// mediaType.previews arrays are merged, instead of overwritten
if (defaults && defaults.mediaType.previews.length) {
mergedOptions.mediaType.previews = defaults.mediaType.previews
.filter((preview) => !mergedOptions.mediaType.previews.includes(preview))
.concat(mergedOptions.mediaType.previews);
}
mergedOptions.mediaType.previews = mergedOptions.mediaType.previews.map((preview) => preview.replace(/-preview/, ""));
return mergedOptions;
}
function addQueryParameters(url, parameters) {
const separator = /\?/.test(url) ? "&" : "?";
const names = Object.keys(parameters);
if (names.length === 0) {
return url;
}
return (url +
separator +
names
.map((name) => {
if (name === "q") {
return ("q=" + parameters.q.split("+").map(encodeURIComponent).join("+"));
}
return `${name}=${encodeURIComponent(parameters[name])}`;
})
.join("&"));
}
const urlVariableRegex = /\{[^}]+\}/g;
function removeNonChars(variableName) {
return variableName.replace(/^\W+|\W+$/g, "").split(/,/);
}
function extractUrlVariableNames(url) {
const matches = url.match(urlVariableRegex);
if (!matches) {
return [];
}
return matches.map(removeNonChars).reduce((a, b) => a.concat(b), []);
}
function omit(object, keysToOmit) {
return Object.keys(object)
.filter((option) => !keysToOmit.includes(option))
.reduce((obj, key) => {
obj[key] = object[key];
return obj;
}, {});
}
// Based on https://github.com/bramstein/url-template, licensed under BSD
// TODO: create separate package.
//
// Copyright (c) 2012-2014, Bram Stein
// All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// 3. The name of the author may not be used to endorse or promote products
// derived from this software without specific prior written permission.
// THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR IMPLIED
// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
// EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
// EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
/* istanbul ignore file */
function encodeReserved(str) {
return str
.split(/(%[0-9A-Fa-f]{2})/g)
.map(function (part) {
if (!/%[0-9A-Fa-f]/.test(part)) {
part = encodeURI(part).replace(/%5B/g, "[").replace(/%5D/g, "]");
}
return part;
})
.join("");
}
function encodeUnreserved(str) {
return encodeURIComponent(str).replace(/[!'()*]/g, function (c) {
return "%" + c.charCodeAt(0).toString(16).toUpperCase();
});
}
function encodeValue(operator, value, key) {
value =
operator === "+" || operator === "#"
? encodeReserved(value)
: encodeUnreserved(value);
if (key) {
return encodeUnreserved(key) + "=" + value;
}
else {
return value;
}
}
function isDefined(value) {
return value !== undefined && value !== null;
}
function isKeyOperator(operator) {
return operator === ";" || operator === "&" || operator === "?";
}
function getValues(context, operator, key, modifier) {
var value = context[key], result = [];
if (isDefined(value) && value !== "") {
if (typeof value === "string" ||
typeof value === "number" ||
typeof value === "boolean") {
value = value.toString();
if (modifier && modifier !== "*") {
value = value.substring(0, parseInt(modifier, 10));
}
result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : ""));
}
else {
if (modifier === "*") {
if (Array.isArray(value)) {
value.filter(isDefined).forEach(function (value) {
result.push(encodeValue(operator, value, isKeyOperator(operator) ? key : ""));
});
}
else {
Object.keys(value).forEach(function (k) {
if (isDefined(value[k])) {
result.push(encodeValue(operator, value[k], k));
}
});
}
}
else {
const tmp = [];
if (Array.isArray(value)) {
value.filter(isDefined).forEach(function (value) {
tmp.push(encodeValue(operator, value));
});
}
else {
Object.keys(value).forEach(function (k) {
if (isDefined(value[k])) {
tmp.push(encodeUnreserved(k));
tmp.push(encodeValue(operator, value[k].toString()));
}
});
}
if (isKeyOperator(operator)) {
result.push(encodeUnreserved(key) + "=" + tmp.join(","));
}
else if (tmp.length !== 0) {
result.push(tmp.join(","));
}
}
}
}
else {
if (operator === ";") {
if (isDefined(value)) {
result.push(encodeUnreserved(key));
}
}
else if (value === "" && (operator === "&" || operator === "?")) {
result.push(encodeUnreserved(key) + "=");
}
else if (value === "") {
result.push("");
}
}
return result;
}
function parseUrl(template) {
return {
expand: expand.bind(null, template),
};
}
function expand(template, context) {
var operators = ["+", "#", ".", "/", ";", "?", "&"];
return template.replace(/\{([^\{\}]+)\}|([^\{\}]+)/g, function (_, expression, literal) {
if (expression) {
let operator = "";
const values = [];
if (operators.indexOf(expression.charAt(0)) !== -1) {
operator = expression.charAt(0);
expression = expression.substr(1);
}
expression.split(/,/g).forEach(function (variable) {
var tmp = /([^:\*]*)(?::(\d+)|(\*))?/.exec(variable);
values.push(getValues(context, operator, tmp[1], tmp[2] || tmp[3]));
});
if (operator && operator !== "+") {
var separator = ",";
if (operator === "?") {
separator = "&";
}
else if (operator !== "#") {
separator = operator;
}
return (values.length !== 0 ? operator : "") + values.join(separator);
}
else {
return values.join(",");
}
}
else {
return encodeReserved(literal);
}
});
}
function parse$b(options) {
// https://fetch.spec.whatwg.org/#methods
let method = options.method.toUpperCase();
// replace :varname with {varname} to make it RFC 6570 compatible
let url = (options.url || "/").replace(/:([a-z]\w+)/g, "{$1}");
let headers = Object.assign({}, options.headers);
let body;
let parameters = omit(options, [
"method",
"baseUrl",
"url",
"headers",
"request",
"mediaType",
]);
// extract variable names from URL to calculate remaining variables later
const urlVariableNames = extractUrlVariableNames(url);
url = parseUrl(url).expand(parameters);
if (!/^http/.test(url)) {
url = options.baseUrl + url;
}
const omittedParameters = Object.keys(options)
.filter((option) => urlVariableNames.includes(option))
.concat("baseUrl");
const remainingParameters = omit(parameters, omittedParameters);
const isBinaryRequest = /application\/octet-stream/i.test(headers.accept);
if (!isBinaryRequest) {
if (options.mediaType.format) {
// e.g. application/vnd.github.v3+json => application/vnd.github.v3.raw
headers.accept = headers.accept
.split(/,/)
.map((preview) => preview.replace(/application\/vnd(\.\w+)(\.v3)?(\.\w+)?(\+json)?$/, `application/vnd$1$2.${options.mediaType.format}`))
.join(",");
}
if (options.mediaType.previews.length) {
const previewsFromAcceptHeader = headers.accept.match(/[\w-]+(?=-preview)/g) || [];
headers.accept = previewsFromAcceptHeader
.concat(options.mediaType.previews)
.map((preview) => {
const format = options.mediaType.format
? `.${options.mediaType.format}`
: "+json";
return `application/vnd.github.${preview}-preview${format}`;
})
.join(",");
}
}
// for GET/HEAD requests, set URL query parameters from remaining parameters
// for PATCH/POST/PUT/DELETE requests, set request body from remaining parameters
if (["GET", "HEAD"].includes(method)) {
url = addQueryParameters(url, remainingParameters);
}
else {
if ("data" in remainingParameters) {
body = remainingParameters.data;
}
else {
if (Object.keys(remainingParameters).length) {
body = remainingParameters;
}
else {
headers["content-length"] = 0;
}
}
}
// default content-type for JSON if body is set
if (!headers["content-type"] && typeof body !== "undefined") {
headers["content-type"] = "application/json; charset=utf-8";
}
// GitHub expects 'content-length: 0' header for PUT/PATCH requests without body.
// fetch does not allow to set `content-length` header, but we can set body to an empty string
if (["PATCH", "PUT"].includes(method) && typeof body === "undefined") {
body = "";
}
// Only return body/request keys if present
return Object.assign({ method, url, headers }, typeof body !== "undefined" ? { body } : null, options.request ? { request: options.request } : null);
}
function endpointWithDefaults(defaults, route, options) {
return parse$b(merge$2(defaults, route, options));
}
function withDefaults$2(oldDefaults, newDefaults) {
const DEFAULTS = merge$2(oldDefaults, newDefaults);
const endpoint = endpointWithDefaults.bind(null, DEFAULTS);
return Object.assign(endpoint, {
DEFAULTS,
defaults: withDefaults$2.bind(null, DEFAULTS),
merge: merge$2.bind(null, DEFAULTS),
parse: parse$b,
});
}
const VERSION$b = "6.0.12";
const userAgent = `octokit-endpoint.js/${VERSION$b} ${getUserAgent()}`;
// DEFAULTS has all properties set that EndpointOptions has, except url.
// So we use RequestParameters and add method as additional required property.
const DEFAULTS = {
method: "GET",
baseUrl: "https://api.github.com",
headers: {
accept: "application/vnd.github.v3+json",
"user-agent": userAgent,
},
mediaType: {
format: "",
previews: [],
},
};
const endpoint = withDefaults$2(null, DEFAULTS);
var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
function commonjsRequire () {
throw new Error('Dynamic requires are not currently supported by rollup-plugin-commonjs');
}
function unwrapExports (x) {
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}
function createCommonjsModule(fn, module) {
return module = { exports: {} }, fn(module, module.exports), module.exports;
}
function getCjsExportFromNamespace (n) {
return n && n['default'] || n;
}
var conversions = {};
var lib$2 = conversions;
function sign$3(x) {
return x < 0 ? -1 : 1;
}
function evenRound(x) {
// Round x to the nearest integer, choosing the even integer if it lies halfway between two.
if ((x % 1) === 0.5 && (x & 1) === 0) { // [even number].5; round down (i.e. floor)
return Math.floor(x);
} else {
return Math.round(x);
}
}
function createNumberConversion(bitLength, typeOpts) {
if (!typeOpts.unsigned) {
--bitLength;
}
const lowerBound = typeOpts.unsigned ? 0 : -Math.pow(2, bitLength);
const upperBound = Math.pow(2, bitLength) - 1;
const moduloVal = typeOpts.moduloBitLength ? Math.pow(2, typeOpts.moduloBitLength) : Math.pow(2, bitLength);
const moduloBound = typeOpts.moduloBitLength ? Math.pow(2, typeOpts.moduloBitLength - 1) : Math.pow(2, bitLength - 1);
return function(V, opts) {
if (!opts) opts = {};
let x = +V;
if (opts.enforceRange) {
if (!Number.isFinite(x)) {
throw new TypeError("Argument is not a finite number");
}
x = sign$3(x) * Math.floor(Math.abs(x));
if (x < lowerBound || x > upperBound) {
throw new TypeError("Argument is not in byte range");
}
return x;
}
if (!isNaN(x) && opts.clamp) {
x = evenRound(x);
if (x < lowerBound) x = lowerBound;
if (x > upperBound) x = upperBound;
return x;
}
if (!Number.isFinite(x) || x === 0) {
return 0;
}
x = sign$3(x) * Math.floor(Math.abs(x));
x = x % moduloVal;
if (!typeOpts.unsigned && x >= moduloBound) {
return x - moduloVal;
} else if (typeOpts.unsigned) {
if (x < 0) {
x += moduloVal;
} else if (x === -0) { // don't return negative zero
return 0;
}
}
return x;
}
}
conversions["void"] = function () {
return undefined;
};
conversions["boolean"] = function (val) {
return !!val;
};
conversions["byte"] = createNumberConversion(8, { unsigned: false });
conversions["octet"] = createNumberConversion(8, { unsigned: true });
conversions["short"] = createNumberConversion(16, { unsigned: false });
conversions["unsigned short"] = createNumberConversion(16, { unsigned: true });
conversions["long"] = createNumberConversion(32, { unsigned: false });
conversions["unsigned long"] = createNumberConversion(32, { unsigned: true });
conversions["long long"] = createNumberConversion(32, { unsigned: false, moduloBitLength: 64 });
conversions["unsigned long long"] = createNumberConversion(32, { unsigned: true, moduloBitLength: 64 });
conversions["double"] = function (V) {
const x = +V;
if (!Number.isFinite(x)) {
throw new TypeError("Argument is not a finite floating-point value");
}
return x;
};
conversions["unrestricted double"] = function (V) {
const x = +V;
if (isNaN(x)) {
throw new TypeError("Argument is NaN");
}
return x;
};
// not quite valid, but good enough for JS
conversions["float"] = conversions["double"];
conversions["unrestricted float"] = conversions["unrestricted double"];
conversions["DOMString"] = function (V, opts) {
if (!opts) opts = {};
if (opts.treatNullAsEmptyString && V === null) {
return "";
}
return String(V);
};
conversions["ByteString"] = function (V, opts) {
const x = String(V);
let c = undefined;
for (let i = 0; (c = x.codePointAt(i)) !== undefined; ++i) {
if (c > 255) {
throw new TypeError("Argument is not a valid bytestring");
}
}
return x;
};
conversions["USVString"] = function (V) {
const S = String(V);
const n = S.length;
const U = [];
for (let i = 0; i < n; ++i) {
const c = S.charCodeAt(i);
if (c < 0xD800 || c > 0xDFFF) {
U.push(String.fromCodePoint(c));
} else if (0xDC00 <= c && c <= 0xDFFF) {
U.push(String.fromCodePoint(0xFFFD));
} else {
if (i === n - 1) {
U.push(String.fromCodePoint(0xFFFD));
} else {
const d = S.charCodeAt(i + 1);
if (0xDC00 <= d && d <= 0xDFFF) {
const a = c & 0x3FF;
const b = d & 0x3FF;
U.push(String.fromCodePoint((2 << 15) + (2 << 9) * a + b));
++i;
} else {
U.push(String.fromCodePoint(0xFFFD));
}
}
}
}
return U.join('');
};
conversions["Date"] = function (V, opts) {
if (!(V instanceof Date)) {
throw new TypeError("Argument is not a Date object");
}
if (isNaN(V)) {
return undefined;
}
return V;
};
conversions["RegExp"] = function (V, opts) {
if (!(V instanceof RegExp)) {
V = new RegExp(V);
}
return V;
};
var utils$3 = createCommonjsModule(function (module) {
module.exports.mixin = function mixin(target, source) {
const keys = Object.getOwnPropertyNames(source);
for (let i = 0; i < keys.length; ++i) {
Object.defineProperty(target, keys[i], Object.getOwnPropertyDescriptor(source, keys[i]));
}
};
module.exports.wrapperSymbol = Symbol("wrapper");
module.exports.implSymbol = Symbol("impl");
module.exports.wrapperForImpl = function (impl) {
return impl[module.exports.wrapperSymbol];
};
module.exports.implForWrapper = function (wrapper) {
return wrapper[module.exports.implSymbol];
};
});
utils$3.mixin;
utils$3.wrapperSymbol;
utils$3.implSymbol;
utils$3.wrapperForImpl;
utils$3.implForWrapper;
var mappingTable$1 = [
[
[
0,
44
],
"disallowed_STD3_valid"
],
[
[
45,
46
],
"valid"
],
[
[
47,
47
],
"disallowed_STD3_valid"
],
[
[
48,
57
],
"valid"
],
[
[
58,
64
],
"disallowed_STD3_valid"
],
[
[
65,
65
],
"mapped",
[
97
]
],
[
[
66,
66
],
"mapped",
[
98
]
],
[
[
67,
67
],
"mapped",
[
99
]
],
[
[
68,
68
],
"mapped",
[
100
]
],
[
[
69,
69
],
"mapped",
[
101
]
],
[
[
70,
70
],
"mapped",
[
102
]
],
[
[
71,
71
],
"mapped",
[
103
]
],
[
[
72,
72
],
"mapped",
[
104
]
],
[
[
73,
73
],
"mapped",
[
105
]
],
[
[
74,
74
],
"mapped",
[
106
]
],
[
[
75,
75
],
"mapped",
[
107
]
],
[
[
76,
76
],
"mapped",
[
108
]
],
[
[
77,
77
],
"mapped",
[
109
]
],
[
[
78,
78
],
"mapped",
[
110
]
],
[
[
79,
79
],
"mapped",
[
111
]
],
[
[
80,
80
],
"mapped",
[
112
]
],
[
[
81,
81
],
"mapped",
[
113
]
],
[
[
82,
82
],
"mapped",
[
114
]
],
[
[
83,
83
],
"mapped",
[
115
]
],
[
[
84,
84
],
"mapped",
[
116
]
],
[
[
85,
85
],
"mapped",
[
117
]
],
[
[
86,
86
],
"mapped",
[
118
]
],
[
[
87,
87
],
"mapped",
[
119
]
],
[
[
88,
88
],
"mapped",
[
120
]
],
[
[
89,
89
],
"mapped",
[
121
]
],
[
[
90,
90
],
"mapped",
[
122
]
],
[
[
91,
96
],
"disallowed_STD3_valid"
],
[
[
97,
122
],
"valid"
],
[
[
123,
127
],
"disallowed_STD3_valid"
],
[
[
128,
159
],
"disallowed"
],
[
[
160,
160
],
"disallowed_STD3_mapped",
[
32
]
],
[
[
161,
167
],
"valid",
[
],
"NV8"
],
[
[
168,
168
],
"disallowed_STD3_mapped",
[
32,
776
]
],
[
[
169,
169
],
"valid",
[
],
"NV8"
],
[
[
170,
170
],
"mapped",
[
97
]
],
[
[
171,
172
],
"valid",
[
],
"NV8"
],
[
[
173,
173
],
"ignored"
],
[
[
174,
174
],
"valid",
[
],
"NV8"
],
[
[
175,
175
],
"disallowed_STD3_mapped",
[
32,
772
]
],
[
[
176,
177
],
"valid",
[
],
"NV8"
],
[
[
178,
178
],
"mapped",
[
50
]
],
[
[
179,
179
],
"mapped",
[
51
]
],
[
[
180,
180
],
"disallowed_STD3_mapped",
[
32,
769
]
],
[
[
181,
181
],
"mapped",
[
956
]
],
[
[
182,
182
],
"valid",
[
],
"NV8"
],
[
[
183,
183
],
"valid"
],
[
[
184,
184
],
"disallowed_STD3_mapped",
[
32,
807
]
],
[
[
185,
185
],
"mapped",
[
49
]
],
[
[
186,
186
],
"mapped",
[
111
]
],
[
[
187,
187
],
"valid",
[
],
"NV8"
],
[
[
188,
188
],
"mapped",
[
49,
8260,
52
]
],
[
[
189,
189
],
"mapped",
[
49,
8260,
50
]
],
[
[
190,
190
],
"mapped",
[
51,
8260,
52
]
],
[
[
191,
191
],
"valid",
[
],
"NV8"
],
[
[
192,
192
],
"mapped",
[
224
]
],
[
[
193,
193
],
"mapped",
[
225
]
],
[
[
194,
194
],
"mapped",
[
226
]
],
[
[
195,
195
],
"mapped",
[
227
]
],
[
[
196,
196
],
"mapped",
[
228
]
],
[
[
197,
197
],
"mapped",
[
229
]
],
[
[
198,
198
],
"mapped",
[
230
]
],
[
[
199,
199
],
"mapped",
[
231
]
],
[
[
200,
200
],
"mapped",
[
232
]
],
[
[
201,
201
],
"mapped",
[
233
]
],
[
[
202,
202
],
"mapped",
[
234
]
],
[
[
203,
203
],
"mapped",
[
235
]
],
[
[
204,
204
],
"mapped",
[
236
]
],
[
[
205,
205
],
"mapped",
[
237
]
],
[
[
206,
206
],
"mapped",
[
238
]
],
[
[
207,
207
],
"mapped",
[
239
]
],
[
[
208,
208
],
"mapped",
[
240
]
],
[
[
209,
209
],
"mapped",
[
241
]
],
[
[
210,
210
],
"mapped",
[
242
]
],
[
[
211,
211
],
"mapped",
[
243
]
],
[
[
212,
212
],
"mapped",
[
244
]
],
[
[
213,
213
],
"mapped",
[
245
]
],
[
[
214,
214
],
"mapped",
[
246
]
],
[
[
215,
215
],
"valid",
[
],
"NV8"
],
[
[
216,
216
],
"mapped",
[
248
]
],
[
[
217,
217
],
"mapped",
[
249
]
],
[
[
218,
218
],
"mapped",
[
250
]
],
[
[
219,
219
],
"mapped",
[
251
]
],
[
[
220,
220
],
"mapped",
[
252
]
],
[
[
221,
221
],
"mapped",
[
253
]
],
[
[
222,
222
],
"mapped",
[
254
]
],
[
[
223,
223
],
"deviation",
[
115,
115
]
],
[
[
224,
246
],
"valid"
],
[
[
247,
247
],
"valid",
[
],
"NV8"
],
[
[
248,
255
],
"valid"
],
[
[
256,
256
],
"mapped",
[
257
]
],
[
[
257,
257
],
"valid"
],
[
[
258,
258
],
"mapped",
[
259
]
],
[
[
259,
259
],
"valid"
],
[
[
260,
260
],
"mapped",
[
261
]
],
[
[
261,
261
],
"valid"
],
[
[
262,
262
],
"mapped",
[
263
]
],
[
[
263,
263
],
"valid"
],
[
[
264,
264
],
"mapped",
[
265
]
],
[
[
265,
265
],
"valid"
],
[
[
266,
266
],
"mapped",
[
267
]
],
[
[
267,
267
],
"valid"
],
[
[
268,
268
],
"mapped",
[
269
]
],
[
[
269,
269
],
"valid"
],
[
[
270,
270
],
"mapped",
[
271
]
],
[
[
271,
271
],
"valid"
],
[
[
272,
272
],
"mapped",
[
273
]
],
[
[
273,
273
],
"valid"
],
[
[
274,
274
],
"mapped",
[
275
]
],
[
[
275,
275
],
"valid"
],
[
[
276,
276
],
"mapped",
[
277
]
],
[
[
277,
277
],
"valid"
],
[
[
278,
278
],
"mapped",
[
279
]
],
[
[
279,
279
],
"valid"
],
[
[
280,
280
],
"mapped",
[
281
]
],
[
[
281,
281
],
"valid"
],
[
[
282,
282
],
"mapped",
[
283
]
],
[
[
283,
283
],
"valid"
],
[
[
284,
284
],
"mapped",
[
285
]
],
[
[
285,
285
],
"valid"
],
[
[
286,
286
],
"mapped",
[
287
]
],
[
[
287,
287
],
"valid"
],
[
[
288,
288
],
"mapped",
[
289
]
],
[
[
289,
289
],
"valid"
],
[
[
290,
290
],
"mapped",
[
291
]
],
[
[
291,
291
],
"valid"
],
[
[
292,
292
],
"mapped",
[
293
]
],
[
[
293,
293
],
"valid"
],
[
[
294,
294
],
"mapped",
[
295
]
],
[
[
295,
295
],
"valid"
],
[
[
296,
296
],
"mapped",
[
297
]
],
[
[
297,
297
],
"valid"
],
[
[
298,
298
],
"mapped",
[
299
]
],
[
[
299,
299
],
"valid"
],
[
[
300,
300
],
"mapped",
[
301
]
],
[
[
301,
301
],
"valid"
],
[
[
302,
302
],
"mapped",
[
303
]
],
[
[
303,
303
],
"valid"
],
[
[
304,
304
],
"mapped",
[
105,
775
]
],
[
[
305,
305
],
"valid"
],
[
[
306,
307
],
"mapped",
[
105,
106
]
],
[
[
308,
308
],
"mapped",
[
309
]
],
[
[
309,
309
],
"valid"
],
[
[
310,
310
],
"mapped",
[
311
]
],
[
[
311,
312
],
"valid"
],
[
[
313,
313
],
"mapped",
[
314
]
],
[
[
314,
314
],
"valid"
],
[
[
315,
315
],
"mapped",
[
316
]
],
[
[
316,
316
],
"valid"
],
[
[
317,
317
],
"mapped",
[
318
]
],
[
[
318,
318
],
"valid"
],
[
[
319,
320
],
"mapped",
[
108,
183
]
],
[
[
321,
321
],
"mapped",
[
322
]
],
[
[
322,
322
],
"valid"
],
[
[
323,
323
],
"mapped",
[
324
]
],
[
[
324,
324
],
"valid"
],
[
[
325,
325
],
"mapped",
[
326
]
],
[
[
326,
326
],
"valid"
],
[
[
327,
327
],
"mapped",
[
328
]
],
[
[
32