p2pcf
Version:
WebRTC signalling using Cloudflare Workers
1,466 lines (1,456 loc) • 97.5 kB
JavaScript
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __commonJS = (cb, mod) => function __require() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
// node_modules/get-browser-rtc/index.js
var require_get_browser_rtc = __commonJS({
"node_modules/get-browser-rtc/index.js"(exports, module) {
module.exports = function getBrowserRTC2() {
if (typeof globalThis === "undefined")
return null;
var wrtc = {
RTCPeerConnection: globalThis.RTCPeerConnection || globalThis.mozRTCPeerConnection || globalThis.webkitRTCPeerConnection,
RTCSessionDescription: globalThis.RTCSessionDescription || globalThis.mozRTCSessionDescription || globalThis.webkitRTCSessionDescription,
RTCIceCandidate: globalThis.RTCIceCandidate || globalThis.mozRTCIceCandidate || globalThis.webkitRTCIceCandidate
};
if (!wrtc.RTCPeerConnection)
return null;
return wrtc;
};
}
});
// node_modules/events/events.js
var require_events = __commonJS({
"node_modules/events/events.js"(exports, module) {
"use strict";
var R = typeof Reflect === "object" ? Reflect : null;
var ReflectApply = R && typeof R.apply === "function" ? R.apply : function ReflectApply2(target, receiver, args) {
return Function.prototype.apply.call(target, receiver, args);
};
var ReflectOwnKeys;
if (R && typeof R.ownKeys === "function") {
ReflectOwnKeys = R.ownKeys;
} else if (Object.getOwnPropertySymbols) {
ReflectOwnKeys = function ReflectOwnKeys2(target) {
return Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target));
};
} else {
ReflectOwnKeys = function ReflectOwnKeys2(target) {
return Object.getOwnPropertyNames(target);
};
}
function ProcessEmitWarning(warning) {
if (console && console.warn)
console.warn(warning);
}
var NumberIsNaN = Number.isNaN || function NumberIsNaN2(value) {
return value !== value;
};
function EventEmitter2() {
EventEmitter2.init.call(this);
}
module.exports = EventEmitter2;
module.exports.once = once;
EventEmitter2.EventEmitter = EventEmitter2;
EventEmitter2.prototype._events = void 0;
EventEmitter2.prototype._eventsCount = 0;
EventEmitter2.prototype._maxListeners = void 0;
var defaultMaxListeners = 10;
function checkListener(listener) {
if (typeof listener !== "function") {
throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
}
}
Object.defineProperty(EventEmitter2, "defaultMaxListeners", {
enumerable: true,
get: function() {
return defaultMaxListeners;
},
set: function(arg) {
if (typeof arg !== "number" || arg < 0 || NumberIsNaN(arg)) {
throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + ".");
}
defaultMaxListeners = arg;
}
});
EventEmitter2.init = function() {
if (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) {
this._events = /* @__PURE__ */ Object.create(null);
this._eventsCount = 0;
}
this._maxListeners = this._maxListeners || void 0;
};
EventEmitter2.prototype.setMaxListeners = function setMaxListeners(n) {
if (typeof n !== "number" || n < 0 || NumberIsNaN(n)) {
throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + ".");
}
this._maxListeners = n;
return this;
};
function _getMaxListeners(that) {
if (that._maxListeners === void 0)
return EventEmitter2.defaultMaxListeners;
return that._maxListeners;
}
EventEmitter2.prototype.getMaxListeners = function getMaxListeners() {
return _getMaxListeners(this);
};
EventEmitter2.prototype.emit = function emit(type) {
var args = [];
for (var i = 1; i < arguments.length; i++)
args.push(arguments[i]);
var doError = type === "error";
var events = this._events;
if (events !== void 0)
doError = doError && events.error === void 0;
else if (!doError)
return false;
if (doError) {
var er;
if (args.length > 0)
er = args[0];
if (er instanceof Error) {
throw er;
}
var err = new Error("Unhandled error." + (er ? " (" + er.message + ")" : ""));
err.context = er;
throw err;
}
var handler = events[type];
if (handler === void 0)
return false;
if (typeof handler === "function") {
ReflectApply(handler, this, args);
} else {
var len = handler.length;
var listeners = arrayClone(handler, len);
for (var i = 0; i < len; ++i)
ReflectApply(listeners[i], this, args);
}
return true;
};
function _addListener(target, type, listener, prepend) {
var m;
var events;
var existing;
checkListener(listener);
events = target._events;
if (events === void 0) {
events = target._events = /* @__PURE__ */ Object.create(null);
target._eventsCount = 0;
} else {
if (events.newListener !== void 0) {
target.emit(
"newListener",
type,
listener.listener ? listener.listener : listener
);
events = target._events;
}
existing = events[type];
}
if (existing === void 0) {
existing = events[type] = listener;
++target._eventsCount;
} else {
if (typeof existing === "function") {
existing = events[type] = prepend ? [listener, existing] : [existing, listener];
} else if (prepend) {
existing.unshift(listener);
} else {
existing.push(listener);
}
m = _getMaxListeners(target);
if (m > 0 && existing.length > m && !existing.warned) {
existing.warned = true;
var w = new Error("Possible EventEmitter memory leak detected. " + existing.length + " " + String(type) + " listeners added. Use emitter.setMaxListeners() to increase limit");
w.name = "MaxListenersExceededWarning";
w.emitter = target;
w.type = type;
w.count = existing.length;
ProcessEmitWarning(w);
}
}
return target;
}
EventEmitter2.prototype.addListener = function addListener(type, listener) {
return _addListener(this, type, listener, false);
};
EventEmitter2.prototype.on = EventEmitter2.prototype.addListener;
EventEmitter2.prototype.prependListener = function prependListener(type, listener) {
return _addListener(this, type, listener, true);
};
function onceWrapper() {
if (!this.fired) {
this.target.removeListener(this.type, this.wrapFn);
this.fired = true;
if (arguments.length === 0)
return this.listener.call(this.target);
return this.listener.apply(this.target, arguments);
}
}
function _onceWrap(target, type, listener) {
var state = { fired: false, wrapFn: void 0, target, type, listener };
var wrapped = onceWrapper.bind(state);
wrapped.listener = listener;
state.wrapFn = wrapped;
return wrapped;
}
EventEmitter2.prototype.once = function once2(type, listener) {
checkListener(listener);
this.on(type, _onceWrap(this, type, listener));
return this;
};
EventEmitter2.prototype.prependOnceListener = function prependOnceListener(type, listener) {
checkListener(listener);
this.prependListener(type, _onceWrap(this, type, listener));
return this;
};
EventEmitter2.prototype.removeListener = function removeListener(type, listener) {
var list, events, position, i, originalListener;
checkListener(listener);
events = this._events;
if (events === void 0)
return this;
list = events[type];
if (list === void 0)
return this;
if (list === listener || list.listener === listener) {
if (--this._eventsCount === 0)
this._events = /* @__PURE__ */ Object.create(null);
else {
delete events[type];
if (events.removeListener)
this.emit("removeListener", type, list.listener || listener);
}
} else if (typeof list !== "function") {
position = -1;
for (i = list.length - 1; i >= 0; i--) {
if (list[i] === listener || list[i].listener === listener) {
originalListener = list[i].listener;
position = i;
break;
}
}
if (position < 0)
return this;
if (position === 0)
list.shift();
else {
spliceOne(list, position);
}
if (list.length === 1)
events[type] = list[0];
if (events.removeListener !== void 0)
this.emit("removeListener", type, originalListener || listener);
}
return this;
};
EventEmitter2.prototype.off = EventEmitter2.prototype.removeListener;
EventEmitter2.prototype.removeAllListeners = function removeAllListeners(type) {
var listeners, events, i;
events = this._events;
if (events === void 0)
return this;
if (events.removeListener === void 0) {
if (arguments.length === 0) {
this._events = /* @__PURE__ */ Object.create(null);
this._eventsCount = 0;
} else if (events[type] !== void 0) {
if (--this._eventsCount === 0)
this._events = /* @__PURE__ */ Object.create(null);
else
delete events[type];
}
return this;
}
if (arguments.length === 0) {
var keys = Object.keys(events);
var key;
for (i = 0; i < keys.length; ++i) {
key = keys[i];
if (key === "removeListener")
continue;
this.removeAllListeners(key);
}
this.removeAllListeners("removeListener");
this._events = /* @__PURE__ */ Object.create(null);
this._eventsCount = 0;
return this;
}
listeners = events[type];
if (typeof listeners === "function") {
this.removeListener(type, listeners);
} else if (listeners !== void 0) {
for (i = listeners.length - 1; i >= 0; i--) {
this.removeListener(type, listeners[i]);
}
}
return this;
};
function _listeners(target, type, unwrap) {
var events = target._events;
if (events === void 0)
return [];
var evlistener = events[type];
if (evlistener === void 0)
return [];
if (typeof evlistener === "function")
return unwrap ? [evlistener.listener || evlistener] : [evlistener];
return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
}
EventEmitter2.prototype.listeners = function listeners(type) {
return _listeners(this, type, true);
};
EventEmitter2.prototype.rawListeners = function rawListeners(type) {
return _listeners(this, type, false);
};
EventEmitter2.listenerCount = function(emitter, type) {
if (typeof emitter.listenerCount === "function") {
return emitter.listenerCount(type);
} else {
return listenerCount.call(emitter, type);
}
};
EventEmitter2.prototype.listenerCount = listenerCount;
function listenerCount(type) {
var events = this._events;
if (events !== void 0) {
var evlistener = events[type];
if (typeof evlistener === "function") {
return 1;
} else if (evlistener !== void 0) {
return evlistener.length;
}
}
return 0;
}
EventEmitter2.prototype.eventNames = function eventNames() {
return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
};
function arrayClone(arr, n) {
var copy = new Array(n);
for (var i = 0; i < n; ++i)
copy[i] = arr[i];
return copy;
}
function spliceOne(list, index) {
for (; index + 1 < list.length; index++)
list[index] = list[index + 1];
list.pop();
}
function unwrapListeners(arr) {
var ret = new Array(arr.length);
for (var i = 0; i < ret.length; ++i) {
ret[i] = arr[i].listener || arr[i];
}
return ret;
}
function once(emitter, name) {
return new Promise(function(resolve, reject) {
function errorListener(err) {
emitter.removeListener(name, resolver);
reject(err);
}
function resolver() {
if (typeof emitter.removeListener === "function") {
emitter.removeListener("error", errorListener);
}
resolve([].slice.call(arguments));
}
;
eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
if (name !== "error") {
addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
}
});
}
function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
if (typeof emitter.on === "function") {
eventTargetAgnosticAddListener(emitter, "error", handler, flags);
}
}
function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
if (typeof emitter.on === "function") {
if (flags.once) {
emitter.once(name, listener);
} else {
emitter.on(name, listener);
}
} else if (typeof emitter.addEventListener === "function") {
emitter.addEventListener(name, function wrapListener(arg) {
if (flags.once) {
emitter.removeEventListener(name, wrapListener);
}
listener(arg);
});
} else {
throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
}
}
}
});
// node_modules/ms/index.js
var require_ms = __commonJS({
"node_modules/ms/index.js"(exports, module) {
var s = 1e3;
var m = s * 60;
var h = m * 60;
var d = h * 24;
var w = d * 7;
var y = d * 365.25;
module.exports = function(val, options) {
options = options || {};
var type = typeof val;
if (type === "string" && val.length > 0) {
return parse(val);
} else if (type === "number" && isFinite(val)) {
return options.long ? fmtLong(val) : fmtShort(val);
}
throw new Error(
"val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
);
};
function parse(str) {
str = String(str);
if (str.length > 100) {
return;
}
var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
str
);
if (!match) {
return;
}
var n = parseFloat(match[1]);
var type = (match[2] || "ms").toLowerCase();
switch (type) {
case "years":
case "year":
case "yrs":
case "yr":
case "y":
return n * y;
case "weeks":
case "week":
case "w":
return n * w;
case "days":
case "day":
case "d":
return n * d;
case "hours":
case "hour":
case "hrs":
case "hr":
case "h":
return n * h;
case "minutes":
case "minute":
case "mins":
case "min":
case "m":
return n * m;
case "seconds":
case "second":
case "secs":
case "sec":
case "s":
return n * s;
case "milliseconds":
case "millisecond":
case "msecs":
case "msec":
case "ms":
return n;
default:
return void 0;
}
}
function fmtShort(ms) {
var msAbs = Math.abs(ms);
if (msAbs >= d) {
return Math.round(ms / d) + "d";
}
if (msAbs >= h) {
return Math.round(ms / h) + "h";
}
if (msAbs >= m) {
return Math.round(ms / m) + "m";
}
if (msAbs >= s) {
return Math.round(ms / s) + "s";
}
return ms + "ms";
}
function fmtLong(ms) {
var msAbs = Math.abs(ms);
if (msAbs >= d) {
return plural(ms, msAbs, d, "day");
}
if (msAbs >= h) {
return plural(ms, msAbs, h, "hour");
}
if (msAbs >= m) {
return plural(ms, msAbs, m, "minute");
}
if (msAbs >= s) {
return plural(ms, msAbs, s, "second");
}
return ms + " ms";
}
function plural(ms, msAbs, n, name) {
var isPlural = msAbs >= n * 1.5;
return Math.round(ms / n) + " " + name + (isPlural ? "s" : "");
}
}
});
// node_modules/debug/src/common.js
var require_common = __commonJS({
"node_modules/debug/src/common.js"(exports, module) {
function setup(env) {
createDebug.debug = createDebug;
createDebug.default = createDebug;
createDebug.coerce = coerce;
createDebug.disable = disable;
createDebug.enable = enable;
createDebug.enabled = enabled;
createDebug.humanize = require_ms();
createDebug.destroy = destroy;
Object.keys(env).forEach((key) => {
createDebug[key] = env[key];
});
createDebug.names = [];
createDebug.skips = [];
createDebug.formatters = {};
function selectColor(namespace) {
let hash = 0;
for (let i = 0; i < namespace.length; i++) {
hash = (hash << 5) - hash + namespace.charCodeAt(i);
hash |= 0;
}
return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
}
createDebug.selectColor = selectColor;
function createDebug(namespace) {
let prevTime;
let enableOverride = null;
let namespacesCache;
let enabledCache;
function debug(...args) {
if (!debug.enabled) {
return;
}
const self = debug;
const curr = Number(new Date());
const ms = curr - (prevTime || curr);
self.diff = ms;
self.prev = prevTime;
self.curr = curr;
prevTime = curr;
args[0] = createDebug.coerce(args[0]);
if (typeof args[0] !== "string") {
args.unshift("%O");
}
let index = 0;
args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
if (match === "%%") {
return "%";
}
index++;
const formatter = createDebug.formatters[format];
if (typeof formatter === "function") {
const val = args[index];
match = formatter.call(self, val);
args.splice(index, 1);
index--;
}
return match;
});
createDebug.formatArgs.call(self, args);
const logFn = self.log || createDebug.log;
logFn.apply(self, args);
}
debug.namespace = namespace;
debug.useColors = createDebug.useColors();
debug.color = createDebug.selectColor(namespace);
debug.extend = extend;
debug.destroy = createDebug.destroy;
Object.defineProperty(debug, "enabled", {
enumerable: true,
configurable: false,
get: () => {
if (enableOverride !== null) {
return enableOverride;
}
if (namespacesCache !== createDebug.namespaces) {
namespacesCache = createDebug.namespaces;
enabledCache = createDebug.enabled(namespace);
}
return enabledCache;
},
set: (v) => {
enableOverride = v;
}
});
if (typeof createDebug.init === "function") {
createDebug.init(debug);
}
return debug;
}
function extend(namespace, delimiter) {
const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
newDebug.log = this.log;
return newDebug;
}
function enable(namespaces) {
createDebug.save(namespaces);
createDebug.namespaces = namespaces;
createDebug.names = [];
createDebug.skips = [];
let i;
const split = (typeof namespaces === "string" ? namespaces : "").split(/[\s,]+/);
const len = split.length;
for (i = 0; i < len; i++) {
if (!split[i]) {
continue;
}
namespaces = split[i].replace(/\*/g, ".*?");
if (namespaces[0] === "-") {
createDebug.skips.push(new RegExp("^" + namespaces.slice(1) + "$"));
} else {
createDebug.names.push(new RegExp("^" + namespaces + "$"));
}
}
}
function disable() {
const namespaces = [
...createDebug.names.map(toNamespace),
...createDebug.skips.map(toNamespace).map((namespace) => "-" + namespace)
].join(",");
createDebug.enable("");
return namespaces;
}
function enabled(name) {
if (name[name.length - 1] === "*") {
return true;
}
let i;
let len;
for (i = 0, len = createDebug.skips.length; i < len; i++) {
if (createDebug.skips[i].test(name)) {
return false;
}
}
for (i = 0, len = createDebug.names.length; i < len; i++) {
if (createDebug.names[i].test(name)) {
return true;
}
}
return false;
}
function toNamespace(regexp) {
return regexp.toString().substring(2, regexp.toString().length - 2).replace(/\.\*\?$/, "*");
}
function coerce(val) {
if (val instanceof Error) {
return val.stack || val.message;
}
return val;
}
function destroy() {
console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
}
createDebug.enable(createDebug.load());
return createDebug;
}
module.exports = setup;
}
});
// node_modules/debug/src/browser.js
var require_browser = __commonJS({
"node_modules/debug/src/browser.js"(exports, module) {
exports.formatArgs = formatArgs;
exports.save = save;
exports.load = load;
exports.useColors = useColors;
exports.storage = localstorage();
exports.destroy = (() => {
let warned = false;
return () => {
if (!warned) {
warned = true;
console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
}
};
})();
exports.colors = [
"#0000CC",
"#0000FF",
"#0033CC",
"#0033FF",
"#0066CC",
"#0066FF",
"#0099CC",
"#0099FF",
"#00CC00",
"#00CC33",
"#00CC66",
"#00CC99",
"#00CCCC",
"#00CCFF",
"#3300CC",
"#3300FF",
"#3333CC",
"#3333FF",
"#3366CC",
"#3366FF",
"#3399CC",
"#3399FF",
"#33CC00",
"#33CC33",
"#33CC66",
"#33CC99",
"#33CCCC",
"#33CCFF",
"#6600CC",
"#6600FF",
"#6633CC",
"#6633FF",
"#66CC00",
"#66CC33",
"#9900CC",
"#9900FF",
"#9933CC",
"#9933FF",
"#99CC00",
"#99CC33",
"#CC0000",
"#CC0033",
"#CC0066",
"#CC0099",
"#CC00CC",
"#CC00FF",
"#CC3300",
"#CC3333",
"#CC3366",
"#CC3399",
"#CC33CC",
"#CC33FF",
"#CC6600",
"#CC6633",
"#CC9900",
"#CC9933",
"#CCCC00",
"#CCCC33",
"#FF0000",
"#FF0033",
"#FF0066",
"#FF0099",
"#FF00CC",
"#FF00FF",
"#FF3300",
"#FF3333",
"#FF3366",
"#FF3399",
"#FF33CC",
"#FF33FF",
"#FF6600",
"#FF6633",
"#FF9900",
"#FF9933",
"#FFCC00",
"#FFCC33"
];
function useColors() {
if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
return true;
}
if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
return false;
}
return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
}
function formatArgs(args) {
args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module.exports.humanize(this.diff);
if (!this.useColors) {
return;
}
const c = "color: " + this.color;
args.splice(1, 0, c, "color: inherit");
let index = 0;
let lastC = 0;
args[0].replace(/%[a-zA-Z%]/g, (match) => {
if (match === "%%") {
return;
}
index++;
if (match === "%c") {
lastC = index;
}
});
args.splice(lastC, 0, c);
}
exports.log = console.debug || console.log || (() => {
});
function save(namespaces) {
try {
if (namespaces) {
exports.storage.setItem("debug", namespaces);
} else {
exports.storage.removeItem("debug");
}
} catch (error) {
}
}
function load() {
let r;
try {
r = exports.storage.getItem("debug");
} catch (error) {
}
if (!r && typeof process !== "undefined" && "env" in process) {
r = process.env.DEBUG;
}
return r;
}
function localstorage() {
try {
return localStorage;
} catch (error) {
}
}
module.exports = require_common()(exports);
var { formatters } = module.exports;
formatters.j = function(v) {
try {
return JSON.stringify(v);
} catch (error) {
return "[UnexpectedJSONParseError]: " + error.message;
}
};
}
});
// node_modules/random-string/lib/random-string.js
var require_random_string = __commonJS({
"node_modules/random-string/lib/random-string.js"(exports, module) {
"use strict";
var numbers = "0123456789";
var letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
var specials = "!$%^&*()_+|~-=`{}[]:;<>?,./";
function _defaults(opts) {
opts || (opts = {});
return {
length: opts.length || 8,
numeric: typeof opts.numeric === "boolean" ? opts.numeric : true,
letters: typeof opts.letters === "boolean" ? opts.letters : true,
special: typeof opts.special === "boolean" ? opts.special : false,
exclude: Array.isArray(opts.exclude) ? opts.exclude : []
};
}
function _buildChars(opts) {
var chars2 = "";
if (opts.numeric) {
chars2 += numbers;
}
if (opts.letters) {
chars2 += letters;
}
if (opts.special) {
chars2 += specials;
}
for (var i = 0; i <= opts.exclude.length; i++) {
chars2 = chars2.replace(opts.exclude[i], "");
}
return chars2;
}
module.exports = function randomString(opts) {
opts = _defaults(opts);
var i, rn, rnd = "", len = opts.length, exclude = opts.exclude, randomChars = _buildChars(opts);
for (i = 1; i <= len; i++) {
rnd += randomChars.substring(rn = Math.floor(Math.random() * randomChars.length), rn + 1);
}
return rnd;
};
}
});
// node_modules/queue-microtask/index.js
var require_queue_microtask = __commonJS({
"node_modules/queue-microtask/index.js"(exports, module) {
var promise;
module.exports = typeof queueMicrotask === "function" ? queueMicrotask.bind(typeof window !== "undefined" ? window : window) : (cb) => (promise || (promise = Promise.resolve())).then(cb).catch((err) => setTimeout(() => {
throw err;
}, 0));
}
});
// node_modules/err-code/index.js
var require_err_code = __commonJS({
"node_modules/err-code/index.js"(exports, module) {
"use strict";
function assign(obj, props) {
for (const key in props) {
Object.defineProperty(obj, key, {
value: props[key],
enumerable: true,
configurable: true
});
}
return obj;
}
function createError(err, code, props) {
if (!err || typeof err === "string") {
throw new TypeError("Please pass an Error to err-code");
}
if (!props) {
props = {};
}
if (typeof code === "object") {
props = code;
code = "";
}
if (code) {
props.code = code;
}
try {
return assign(err, props);
} catch (_) {
props.message = err.message;
props.stack = err.stack;
const ErrClass = function() {
};
ErrClass.prototype = Object.create(Object.getPrototypeOf(err));
const output = assign(new ErrClass(), props);
return output;
}
}
module.exports = createError;
}
});
// node_modules/tiny-simple-peer/index.js
var require_tiny_simple_peer = __commonJS({
"node_modules/tiny-simple-peer/index.js"(exports, module) {
var debug = require_browser()("simple-peer");
var getBrowserRTC2 = require_get_browser_rtc();
var randomstring2 = require_random_string();
var queueMicrotask2 = require_queue_microtask();
var { EventEmitter: EventEmitter2 } = require_events();
var errCode = require_err_code();
var MAX_BUFFERED_AMOUNT = 64 * 1024;
var ICECOMPLETE_TIMEOUT = 5 * 1e3;
var CHANNEL_CLOSING_TIMEOUT = 5 * 1e3;
function filterTrickle(sdp) {
return sdp.replace(/a=ice-options:trickle\s\n/g, "");
}
function warn(message) {
console.warn(message);
}
var Peer2 = class extends EventEmitter2 {
constructor(opts) {
opts = Object.assign({
allowHalfOpen: false
}, opts);
super(opts);
this.id = opts.id || randomstring2({ length: 20 });
this._debug("new peer %o", opts);
this.channelName = opts.initiator ? opts.channelName || randomstring2({ length: 20 }) : null;
this.initiator = opts.initiator || false;
this.channelConfig = opts.channelConfig || Peer2.channelConfig;
this.channelNegotiated = this.channelConfig.negotiated;
this.config = Object.assign({}, Peer2.config, opts.config);
this.proprietaryConstraints = Object.assign({}, Peer2.proprietaryConstraints, opts.proprietaryConstraints);
this.offerOptions = opts.offerOptions || {};
this.answerOptions = opts.answerOptions || {};
this.sdpTransform = opts.sdpTransform || ((sdp) => sdp);
this.streams = opts.streams || (opts.stream ? [opts.stream] : []);
this.trickle = opts.trickle !== void 0 ? opts.trickle : true;
this.allowHalfTrickle = opts.allowHalfTrickle !== void 0 ? opts.allowHalfTrickle : false;
this.iceCompleteTimeout = opts.iceCompleteTimeout || ICECOMPLETE_TIMEOUT;
this.destroyed = false;
this.destroying = false;
this._connected = false;
this.remoteAddress = void 0;
this.remoteFamily = void 0;
this.remotePort = void 0;
this.localAddress = void 0;
this.localFamily = void 0;
this.localPort = void 0;
this._wrtc = opts.wrtc && typeof opts.wrtc === "object" ? opts.wrtc : getBrowserRTC2();
if (!this._wrtc) {
if (typeof window === "undefined") {
throw errCode(new Error("No WebRTC support: Specify `opts.wrtc` option in this environment"), "ERR_WEBRTC_SUPPORT");
} else {
throw errCode(new Error("No WebRTC support: Not a supported browser"), "ERR_WEBRTC_SUPPORT");
}
}
this._pcReady = false;
this._channelReady = false;
this._iceComplete = false;
this._iceCompleteTimer = null;
this._channel = null;
this._pendingCandidates = [];
this._isNegotiating = false;
this._firstNegotiation = true;
this._batchedNegotiation = false;
this._queuedNegotiation = false;
this._sendersAwaitingStable = [];
this._senderMap = /* @__PURE__ */ new Map();
this._closingInterval = null;
this._remoteTracks = [];
this._remoteStreams = [];
this._chunk = null;
this._cb = null;
this._interval = null;
try {
this._pc = new this._wrtc.RTCPeerConnection(this.config, this.proprietaryConstraints);
} catch (err) {
this.destroy(errCode(err, "ERR_PC_CONSTRUCTOR"));
return;
}
this._isReactNativeWebrtc = typeof this._pc._peerConnectionId === "number";
this._pc.oniceconnectionstatechange = () => {
this._onIceStateChange();
};
this._pc.onicegatheringstatechange = () => {
this._onIceStateChange();
};
this._pc.onconnectionstatechange = () => {
this._onConnectionStateChange();
};
this._pc.onsignalingstatechange = () => {
this._onSignalingStateChange();
};
this._pc.onicecandidate = (event) => {
this._onIceCandidate(event);
};
if (typeof this._pc.peerIdentity === "object") {
this._pc.peerIdentity.catch((err) => {
this.destroy(errCode(err, "ERR_PC_PEER_IDENTITY"));
});
}
if (this.initiator || this.channelNegotiated) {
this._setupData({
channel: this._pc.createDataChannel(this.channelName, this.channelConfig)
});
} else {
this._pc.ondatachannel = (event) => {
this._setupData(event);
};
}
if (this.streams) {
this.streams.forEach((stream) => {
this.addStream(stream);
});
}
this._pc.ontrack = (event) => {
this._onTrack(event);
};
this._debug("initial negotiation");
this._needsNegotiation();
this._onFinishBound = () => {
this._onFinish();
};
this.once("finish", this._onFinishBound);
}
get bufferSize() {
return this._channel && this._channel.bufferedAmount || 0;
}
get connected() {
return this._connected && this._channel.readyState === "open";
}
address() {
return { port: this.localPort, family: this.localFamily, address: this.localAddress };
}
signal(data) {
if (this.destroying)
return;
if (this.destroyed)
throw errCode(new Error("cannot signal after peer is destroyed"), "ERR_DESTROYED");
if (typeof data === "string") {
try {
data = JSON.parse(data);
} catch (err) {
data = {};
}
}
this._debug("signal()");
if (data.renegotiate && this.initiator) {
this._debug("got request to renegotiate");
this._needsNegotiation();
}
if (data.transceiverRequest && this.initiator) {
this._debug("got request for transceiver");
this.addTransceiver(data.transceiverRequest.kind, data.transceiverRequest.init);
}
if (data.candidate) {
if (this._pc.remoteDescription && this._pc.remoteDescription.type) {
this._addIceCandidate(data.candidate);
} else {
this._pendingCandidates.push(data.candidate);
}
}
if (data.sdp) {
this._pc.setRemoteDescription(new this._wrtc.RTCSessionDescription(data)).then(() => {
if (this.destroyed)
return;
this._pendingCandidates.forEach((candidate) => {
this._addIceCandidate(candidate);
});
this._pendingCandidates = [];
if (this._pc.remoteDescription.type === "offer")
this._createAnswer();
}).catch((err) => {
this.destroy(errCode(err, "ERR_SET_REMOTE_DESCRIPTION"));
});
}
if (!data.sdp && !data.candidate && !data.renegotiate && !data.transceiverRequest) {
this.destroy(errCode(new Error("signal() called with invalid signal data"), "ERR_SIGNALING"));
}
}
_addIceCandidate(candidate) {
const iceCandidateObj = new this._wrtc.RTCIceCandidate(candidate);
this._pc.addIceCandidate(iceCandidateObj).catch((err) => {
if (!iceCandidateObj.address || iceCandidateObj.address.endsWith(".local")) {
warn("Ignoring unsupported ICE candidate.");
} else {
this.destroy(errCode(err, "ERR_ADD_ICE_CANDIDATE"));
}
});
}
send(chunk) {
if (this.destroying)
return;
if (this.destroyed)
throw errCode(new Error("cannot send after peer is destroyed"), "ERR_DESTROYED");
this._channel.send(chunk);
}
addTransceiver(kind, init) {
if (this.destroying)
return;
if (this.destroyed)
throw errCode(new Error("cannot addTransceiver after peer is destroyed"), "ERR_DESTROYED");
this._debug("addTransceiver()");
if (this.initiator) {
try {
this._pc.addTransceiver(kind, init);
this._needsNegotiation();
} catch (err) {
this.destroy(errCode(err, "ERR_ADD_TRANSCEIVER"));
}
} else {
this.emit("signal", {
type: "transceiverRequest",
transceiverRequest: { kind, init }
});
}
}
addStream(stream) {
if (this.destroying)
return;
if (this.destroyed)
throw errCode(new Error("cannot addStream after peer is destroyed"), "ERR_DESTROYED");
this._debug("addStream()");
stream.getTracks().forEach((track) => {
this.addTrack(track, stream);
});
}
addTrack(track, stream) {
if (this.destroying)
return;
if (this.destroyed)
throw errCode(new Error("cannot addTrack after peer is destroyed"), "ERR_DESTROYED");
this._debug("addTrack()");
const submap = this._senderMap.get(track) || /* @__PURE__ */ new Map();
let sender = submap.get(stream);
if (!sender) {
sender = this._pc.addTrack(track, stream);
submap.set(stream, sender);
this._senderMap.set(track, submap);
this._needsNegotiation();
} else if (sender.removed) {
throw errCode(new Error("Track has been removed. You should enable/disable tracks that you want to re-add."), "ERR_SENDER_REMOVED");
} else {
throw errCode(new Error("Track has already been added to that stream."), "ERR_SENDER_ALREADY_ADDED");
}
}
replaceTrack(oldTrack, newTrack, stream) {
if (this.destroying)
return;
if (this.destroyed)
throw errCode(new Error("cannot replaceTrack after peer is destroyed"), "ERR_DESTROYED");
this._debug("replaceTrack()");
const submap = this._senderMap.get(oldTrack);
const sender = submap ? submap.get(stream) : null;
if (!sender) {
throw errCode(new Error("Cannot replace track that was never added."), "ERR_TRACK_NOT_ADDED");
}
if (newTrack)
this._senderMap.set(newTrack, submap);
if (sender.replaceTrack != null) {
sender.replaceTrack(newTrack);
} else {
this.destroy(errCode(new Error("replaceTrack is not supported in this browser"), "ERR_UNSUPPORTED_REPLACETRACK"));
}
}
removeTrack(track, stream) {
if (this.destroying)
return;
if (this.destroyed)
throw errCode(new Error("cannot removeTrack after peer is destroyed"), "ERR_DESTROYED");
this._debug("removeSender()");
const submap = this._senderMap.get(track);
const sender = submap ? submap.get(stream) : null;
if (!sender) {
throw errCode(new Error("Cannot remove track that was never added."), "ERR_TRACK_NOT_ADDED");
}
try {
sender.removed = true;
this._pc.removeTrack(sender);
} catch (err) {
if (err.name === "NS_ERROR_UNEXPECTED") {
this._sendersAwaitingStable.push(sender);
} else {
this.destroy(errCode(err, "ERR_REMOVE_TRACK"));
}
}
this._needsNegotiation();
}
removeStream(stream) {
if (this.destroying)
return;
if (this.destroyed)
throw errCode(new Error("cannot removeStream after peer is destroyed"), "ERR_DESTROYED");
this._debug("removeSenders()");
stream.getTracks().forEach((track) => {
this.removeTrack(track, stream);
});
}
_needsNegotiation() {
this._debug("_needsNegotiation");
if (this._batchedNegotiation)
return;
this._batchedNegotiation = true;
queueMicrotask2(() => {
this._batchedNegotiation = false;
if (this.initiator || !this._firstNegotiation) {
this._debug("starting batched negotiation");
this.negotiate();
} else {
this._debug("non-initiator initial negotiation request discarded");
}
this._firstNegotiation = false;
});
}
negotiate() {
if (this.destroying)
return;
if (this.destroyed)
throw errCode(new Error("cannot negotiate after peer is destroyed"), "ERR_DESTROYED");
if (this.initiator) {
if (this._isNegotiating) {
this._queuedNegotiation = true;
this._debug("already negotiating, queueing");
} else {
this._debug("start negotiation");
setTimeout(() => {
this._createOffer();
}, 0);
}
} else {
if (this._isNegotiating) {
this._queuedNegotiation = true;
this._debug("already negotiating, queueing");
} else {
this._debug("requesting negotiation from initiator");
this.emit("signal", {
type: "renegotiate",
renegotiate: true
});
}
}
this._isNegotiating = true;
}
destroy(err) {
this._destroy(err, () => {
});
}
_destroy(err, cb) {
if (this.destroyed || this.destroying)
return;
this.destroying = true;
this._debug("destroying (error: %s)", err && (err.message || err));
queueMicrotask2(() => {
this.destroyed = true;
this.destroying = false;
this._debug("destroy (error: %s)", err && (err.message || err));
this._connected = false;
this._pcReady = false;
this._channelReady = false;
this._remoteTracks = null;
this._remoteStreams = null;
this._senderMap = null;
clearInterval(this._closingInterval);
this._closingInterval = null;
clearInterval(this._interval);
this._interval = null;
this._chunk = null;
this._cb = null;
if (this._onFinishBound)
this.removeListener("finish", this._onFinishBound);
this._onFinishBound = null;
if (this._channel) {
try {
this._channel.close();
} catch (err2) {
}
this._channel.onmessage = null;
this._channel.onopen = null;
this._channel.onclose = null;
this._channel.onerror = null;
}
if (this._pc) {
try {
this._pc.close();
} catch (err2) {
}
this._pc.oniceconnectionstatechange = null;
this._pc.onicegatheringstatechange = null;
this._pc.onsignalingstatechange = null;
this._pc.onicecandidate = null;
this._pc.ontrack = null;
this._pc.ondatachannel = null;
}
this._pc = null;
this._channel = null;
if (err)
this.emit("error", err);
this.emit("close");
cb();
});
}
_setupData(event) {
if (!event.channel) {
return this.destroy(errCode(new Error("Data channel event is missing `channel` property"), "ERR_DATA_CHANNEL"));
}
this._channel = event.channel;
this._channel.binaryType = "arraybuffer";
if (typeof this._channel.bufferedAmountLowThreshold === "number") {
this._channel.bufferedAmountLowThreshold = MAX_BUFFERED_AMOUNT;
}
this.channelName = this._channel.label;
this._channel.onmessage = (event2) => {
this._onChannelMessage(event2);
};
this._channel.onbufferedamountlow = () => {
this._onChannelBufferedAmountLow();
};
this._channel.onopen = () => {
this._onChannelOpen();
};
this._channel.onclose = () => {
this._onChannelClose();
};
this._channel.onerror = (event2) => {
const err = event2.error instanceof Error ? event2.error : new Error(`Datachannel error: ${event2.message} ${event2.filename}:${event2.lineno}:${event2.colno}`);
this.destroy(errCode(err, "ERR_DATA_CHANNEL"));
};
let isClosing = false;
this._closingInterval = setInterval(() => {
if (this._channel && this._channel.readyState === "closing") {
if (isClosing)
this._onChannelClose();
isClosing = true;
} else {
isClosing = false;
}
}, CHANNEL_CLOSING_TIMEOUT);
}
_read() {
}
_write(chunk, encoding, cb) {
if (this.destroyed)
return cb(errCode(new Error("cannot write after peer is destroyed"), "ERR_DATA_CHANNEL"));
if (this._connected) {
try {
this.send(chunk);
} catch (err) {
return this.destroy(errCode(err, "ERR_DATA_CHANNEL"));
}
if (this._channel.bufferedAmount > MAX_BUFFERED_AMOUNT) {
this._debug("start backpressure: bufferedAmount %d", this._channel.bufferedAmount);
this._cb = cb;
} else {
cb(null);
}
} else {
this._debug("write before connect");
this._chunk = chunk;
this._cb = cb;
}
}
_onFinish() {
if (this.destroyed)
return;
const destroySoon = () => {
setTimeout(() => this.destroy(), 1e3);
};
if (this._connected) {
destroySoon();
} else {
this.once("connect", destroySoon);
}
}
_startIceCompleteTimeout() {
if (this.destroyed)
return;
if (this._iceCompleteTimer)
return;
this._debug("started iceComplete timeout");
this._iceCompleteTimer = setTimeout(() => {
if (!this._iceComplete) {
this._iceComplete = true;
this._debug("iceComplete timeout completed");
this.emit("iceTimeout");
this.emit("_iceComplete");
}
}, this.iceCompleteTimeout);
}
_createOffer() {
if (this.destroyed)
return;
this._pc.createOffer(this.offerOptions).then((offer) => {
if (this.destroyed)
return;
if (!this.trickle && !this.allowHalfTrickle)
offer.sdp = filterTrickle(offer.sdp);
offer.sdp = this.sdpTransform(offer.sdp);
const sendOffer = () => {
if (this.destroyed)
return;
const signal = this._pc.localDescription || offer;
this._debug("signal");
this.emit("signal", {
type: signal.type,
sdp: signal.sdp
});
};
const onSuccess = () => {
this._debug("createOffer success");
if (this.destroyed)
return;