"use strict"; (() => { 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 __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, { get: (a, b) => (typeof require !== "undefined" ? require : a)[b] }) : x)(function(x) { if (typeof require !== "undefined") return require.apply(this, arguments); throw new Error('Dynamic require of "' + x + '" is not supported'); }); var __commonJS = (cb, mod) => function __require2() { 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( // If the importer is in node compatibility mode or this is not an ESM // file that has been converted to a CommonJS file using a Babel- // compatible transform (i.e. "__esModule" has not been set), then set // "default" to the CommonJS "module.exports" for node compatibility. isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod )); // node_modules/@msgpack/msgpack/dist/utils/int.js var require_int = __commonJS({ "node_modules/@msgpack/msgpack/dist/utils/int.js"(exports) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.getUint64 = exports.getInt64 = exports.setInt64 = exports.setUint64 = exports.UINT32_MAX = void 0; exports.UINT32_MAX = 4294967295; function setUint64(view, offset, value) { const high = value / 4294967296; const low = value; view.setUint32(offset, high); view.setUint32(offset + 4, low); } exports.setUint64 = setUint64; function setInt64(view, offset, value) { const high = Math.floor(value / 4294967296); const low = value; view.setUint32(offset, high); view.setUint32(offset + 4, low); } exports.setInt64 = setInt64; function getInt64(view, offset) { const high = view.getInt32(offset); const low = view.getUint32(offset + 4); return high * 4294967296 + low; } exports.getInt64 = getInt64; function getUint64(view, offset) { const high = view.getUint32(offset); const low = view.getUint32(offset + 4); return high * 4294967296 + low; } exports.getUint64 = getUint64; } }); // node_modules/@msgpack/msgpack/dist/utils/utf8.js var require_utf8 = __commonJS({ "node_modules/@msgpack/msgpack/dist/utils/utf8.js"(exports) { "use strict"; var _a; var _b; var _c; Object.defineProperty(exports, "__esModule", { value: true }); exports.utf8DecodeTD = exports.TEXT_DECODER_THRESHOLD = exports.utf8DecodeJs = exports.utf8EncodeTE = exports.TEXT_ENCODER_THRESHOLD = exports.utf8EncodeJs = exports.utf8Count = void 0; var int_1 = require_int(); var TEXT_ENCODING_AVAILABLE = (typeof process === "undefined" || ((_a = process === null || process === void 0 ? void 0 : process.env) === null || _a === void 0 ? void 0 : _a["TEXT_ENCODING"]) !== "never") && typeof TextEncoder !== "undefined" && typeof TextDecoder !== "undefined"; function utf8Count(str) { const strLength = str.length; let byteLength = 0; let pos = 0; while (pos < strLength) { let value = str.charCodeAt(pos++); if ((value & 4294967168) === 0) { byteLength++; continue; } else if ((value & 4294965248) === 0) { byteLength += 2; } else { if (value >= 55296 && value <= 56319) { if (pos < strLength) { const extra = str.charCodeAt(pos); if ((extra & 64512) === 56320) { ++pos; value = ((value & 1023) << 10) + (extra & 1023) + 65536; } } } if ((value & 4294901760) === 0) { byteLength += 3; } else { byteLength += 4; } } } return byteLength; } exports.utf8Count = utf8Count; function utf8EncodeJs(str, output, outputOffset) { const strLength = str.length; let offset = outputOffset; let pos = 0; while (pos < strLength) { let value = str.charCodeAt(pos++); if ((value & 4294967168) === 0) { output[offset++] = value; continue; } else if ((value & 4294965248) === 0) { output[offset++] = value >> 6 & 31 | 192; } else { if (value >= 55296 && value <= 56319) { if (pos < strLength) { const extra = str.charCodeAt(pos); if ((extra & 64512) === 56320) { ++pos; value = ((value & 1023) << 10) + (extra & 1023) + 65536; } } } if ((value & 4294901760) === 0) { output[offset++] = value >> 12 & 15 | 224; output[offset++] = value >> 6 & 63 | 128; } else { output[offset++] = value >> 18 & 7 | 240; output[offset++] = value >> 12 & 63 | 128; output[offset++] = value >> 6 & 63 | 128; } } output[offset++] = value & 63 | 128; } } exports.utf8EncodeJs = utf8EncodeJs; var sharedTextEncoder = TEXT_ENCODING_AVAILABLE ? new TextEncoder() : void 0; exports.TEXT_ENCODER_THRESHOLD = !TEXT_ENCODING_AVAILABLE ? int_1.UINT32_MAX : typeof process !== "undefined" && ((_b = process === null || process === void 0 ? void 0 : process.env) === null || _b === void 0 ? void 0 : _b["TEXT_ENCODING"]) !== "force" ? 200 : 0; function utf8EncodeTEencode(str, output, outputOffset) { output.set(sharedTextEncoder.encode(str), outputOffset); } function utf8EncodeTEencodeInto(str, output, outputOffset) { sharedTextEncoder.encodeInto(str, output.subarray(outputOffset)); } exports.utf8EncodeTE = (sharedTextEncoder === null || sharedTextEncoder === void 0 ? void 0 : sharedTextEncoder.encodeInto) ? utf8EncodeTEencodeInto : utf8EncodeTEencode; var CHUNK_SIZE = 4096; function utf8DecodeJs(bytes, inputOffset, byteLength) { let offset = inputOffset; const end = offset + byteLength; const units = []; let result = ""; while (offset < end) { const byte1 = bytes[offset++]; if ((byte1 & 128) === 0) { units.push(byte1); } else if ((byte1 & 224) === 192) { const byte2 = bytes[offset++] & 63; units.push((byte1 & 31) << 6 | byte2); } else if ((byte1 & 240) === 224) { const byte2 = bytes[offset++] & 63; const byte3 = bytes[offset++] & 63; units.push((byte1 & 31) << 12 | byte2 << 6 | byte3); } else if ((byte1 & 248) === 240) { const byte2 = bytes[offset++] & 63; const byte3 = bytes[offset++] & 63; const byte4 = bytes[offset++] & 63; let unit = (byte1 & 7) << 18 | byte2 << 12 | byte3 << 6 | byte4; if (unit > 65535) { unit -= 65536; units.push(unit >>> 10 & 1023 | 55296); unit = 56320 | unit & 1023; } units.push(unit); } else { units.push(byte1); } if (units.length >= CHUNK_SIZE) { result += String.fromCharCode(...units); units.length = 0; } } if (units.length > 0) { result += String.fromCharCode(...units); } return result; } exports.utf8DecodeJs = utf8DecodeJs; var sharedTextDecoder = TEXT_ENCODING_AVAILABLE ? new TextDecoder() : null; exports.TEXT_DECODER_THRESHOLD = !TEXT_ENCODING_AVAILABLE ? int_1.UINT32_MAX : typeof process !== "undefined" && ((_c = process === null || process === void 0 ? void 0 : process.env) === null || _c === void 0 ? void 0 : _c["TEXT_DECODER"]) !== "force" ? 200 : 0; function utf8DecodeTD(bytes, inputOffset, byteLength) { const stringBytes = bytes.subarray(inputOffset, inputOffset + byteLength); return sharedTextDecoder.decode(stringBytes); } exports.utf8DecodeTD = utf8DecodeTD; } }); // node_modules/@msgpack/msgpack/dist/ExtData.js var require_ExtData = __commonJS({ "node_modules/@msgpack/msgpack/dist/ExtData.js"(exports) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.ExtData = void 0; var ExtData = class { constructor(type, data) { this.type = type; this.data = data; } }; exports.ExtData = ExtData; } }); // node_modules/@msgpack/msgpack/dist/DecodeError.js var require_DecodeError = __commonJS({ "node_modules/@msgpack/msgpack/dist/DecodeError.js"(exports) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.DecodeError = void 0; var DecodeError = class extends Error { constructor(message) { super(message); const proto = Object.create(DecodeError.prototype); Object.setPrototypeOf(this, proto); Object.defineProperty(this, "name", { configurable: true, enumerable: false, value: DecodeError.name }); } }; exports.DecodeError = DecodeError; } }); // node_modules/@msgpack/msgpack/dist/timestamp.js var require_timestamp = __commonJS({ "node_modules/@msgpack/msgpack/dist/timestamp.js"(exports) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.timestampExtension = exports.decodeTimestampExtension = exports.decodeTimestampToTimeSpec = exports.encodeTimestampExtension = exports.encodeDateToTimeSpec = exports.encodeTimeSpecToTimestamp = exports.EXT_TIMESTAMP = void 0; var DecodeError_1 = require_DecodeError(); var int_1 = require_int(); exports.EXT_TIMESTAMP = -1; var TIMESTAMP32_MAX_SEC = 4294967296 - 1; var TIMESTAMP64_MAX_SEC = 17179869184 - 1; function encodeTimeSpecToTimestamp({ sec, nsec }) { if (sec >= 0 && nsec >= 0 && sec <= TIMESTAMP64_MAX_SEC) { if (nsec === 0 && sec <= TIMESTAMP32_MAX_SEC) { const rv = new Uint8Array(4); const view = new DataView(rv.buffer); view.setUint32(0, sec); return rv; } else { const secHigh = sec / 4294967296; const secLow = sec & 4294967295; const rv = new Uint8Array(8); const view = new DataView(rv.buffer); view.setUint32(0, nsec << 2 | secHigh & 3); view.setUint32(4, secLow); return rv; } } else { const rv = new Uint8Array(12); const view = new DataView(rv.buffer); view.setUint32(0, nsec); (0, int_1.setInt64)(view, 4, sec); return rv; } } exports.encodeTimeSpecToTimestamp = encodeTimeSpecToTimestamp; function encodeDateToTimeSpec(date) { const msec = date.getTime(); const sec = Math.floor(msec / 1e3); const nsec = (msec - sec * 1e3) * 1e6; const nsecInSec = Math.floor(nsec / 1e9); return { sec: sec + nsecInSec, nsec: nsec - nsecInSec * 1e9 }; } exports.encodeDateToTimeSpec = encodeDateToTimeSpec; function encodeTimestampExtension(object) { if (object instanceof Date) { const timeSpec = encodeDateToTimeSpec(object); return encodeTimeSpecToTimestamp(timeSpec); } else { return null; } } exports.encodeTimestampExtension = encodeTimestampExtension; function decodeTimestampToTimeSpec(data) { const view = new DataView(data.buffer, data.byteOffset, data.byteLength); switch (data.byteLength) { case 4: { const sec = view.getUint32(0); const nsec = 0; return { sec, nsec }; } case 8: { const nsec30AndSecHigh2 = view.getUint32(0); const secLow32 = view.getUint32(4); const sec = (nsec30AndSecHigh2 & 3) * 4294967296 + secLow32; const nsec = nsec30AndSecHigh2 >>> 2; return { sec, nsec }; } case 12: { const sec = (0, int_1.getInt64)(view, 4); const nsec = view.getUint32(0); return { sec, nsec }; } default: throw new DecodeError_1.DecodeError(`Unrecognized data size for timestamp (expected 4, 8, or 12): ${data.length}`); } } exports.decodeTimestampToTimeSpec = decodeTimestampToTimeSpec; function decodeTimestampExtension(data) { const timeSpec = decodeTimestampToTimeSpec(data); return new Date(timeSpec.sec * 1e3 + timeSpec.nsec / 1e6); } exports.decodeTimestampExtension = decodeTimestampExtension; exports.timestampExtension = { type: exports.EXT_TIMESTAMP, encode: encodeTimestampExtension, decode: decodeTimestampExtension }; } }); // node_modules/@msgpack/msgpack/dist/ExtensionCodec.js var require_ExtensionCodec = __commonJS({ "node_modules/@msgpack/msgpack/dist/ExtensionCodec.js"(exports) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.ExtensionCodec = void 0; var ExtData_1 = require_ExtData(); var timestamp_1 = require_timestamp(); var ExtensionCodec = class { constructor() { this.builtInEncoders = []; this.builtInDecoders = []; this.encoders = []; this.decoders = []; this.register(timestamp_1.timestampExtension); } register({ type, encode: encode2, decode: decode2 }) { if (type >= 0) { this.encoders[type] = encode2; this.decoders[type] = decode2; } else { const index = 1 + type; this.builtInEncoders[index] = encode2; this.builtInDecoders[index] = decode2; } } tryToEncode(object, context) { for (let i = 0; i < this.builtInEncoders.length; i++) { const encodeExt = this.builtInEncoders[i]; if (encodeExt != null) { const data = encodeExt(object, context); if (data != null) { const type = -1 - i; return new ExtData_1.ExtData(type, data); } } } for (let i = 0; i < this.encoders.length; i++) { const encodeExt = this.encoders[i]; if (encodeExt != null) { const data = encodeExt(object, context); if (data != null) { const type = i; return new ExtData_1.ExtData(type, data); } } } if (object instanceof ExtData_1.ExtData) { return object; } return null; } decode(data, type, context) { const decodeExt = type < 0 ? this.builtInDecoders[-1 - type] : this.decoders[type]; if (decodeExt) { return decodeExt(data, type, context); } else { return new ExtData_1.ExtData(type, data); } } }; exports.ExtensionCodec = ExtensionCodec; ExtensionCodec.defaultCodec = new ExtensionCodec(); } }); // node_modules/@msgpack/msgpack/dist/utils/typedArrays.js var require_typedArrays = __commonJS({ "node_modules/@msgpack/msgpack/dist/utils/typedArrays.js"(exports) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.createDataView = exports.ensureUint8Array = void 0; function ensureUint8Array(buffer) { if (buffer instanceof Uint8Array) { return buffer; } else if (ArrayBuffer.isView(buffer)) { return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength); } else if (buffer instanceof ArrayBuffer) { return new Uint8Array(buffer); } else { return Uint8Array.from(buffer); } } exports.ensureUint8Array = ensureUint8Array; function createDataView(buffer) { if (buffer instanceof ArrayBuffer) { return new DataView(buffer); } const bufferView = ensureUint8Array(buffer); return new DataView(bufferView.buffer, bufferView.byteOffset, bufferView.byteLength); } exports.createDataView = createDataView; } }); // node_modules/@msgpack/msgpack/dist/Encoder.js var require_Encoder = __commonJS({ "node_modules/@msgpack/msgpack/dist/Encoder.js"(exports) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.Encoder = exports.DEFAULT_INITIAL_BUFFER_SIZE = exports.DEFAULT_MAX_DEPTH = void 0; var utf8_1 = require_utf8(); var ExtensionCodec_1 = require_ExtensionCodec(); var int_1 = require_int(); var typedArrays_1 = require_typedArrays(); exports.DEFAULT_MAX_DEPTH = 100; exports.DEFAULT_INITIAL_BUFFER_SIZE = 2048; var Encoder = class { constructor(extensionCodec = ExtensionCodec_1.ExtensionCodec.defaultCodec, context = void 0, maxDepth = exports.DEFAULT_MAX_DEPTH, initialBufferSize = exports.DEFAULT_INITIAL_BUFFER_SIZE, sortKeys = false, forceFloat32 = false, ignoreUndefined = false, forceIntegerToFloat = false) { this.extensionCodec = extensionCodec; this.context = context; this.maxDepth = maxDepth; this.initialBufferSize = initialBufferSize; this.sortKeys = sortKeys; this.forceFloat32 = forceFloat32; this.ignoreUndefined = ignoreUndefined; this.forceIntegerToFloat = forceIntegerToFloat; this.pos = 0; this.view = new DataView(new ArrayBuffer(this.initialBufferSize)); this.bytes = new Uint8Array(this.view.buffer); } reinitializeState() { this.pos = 0; } /** * This is almost equivalent to {@link Encoder#encode}, but it returns an reference of the encoder's internal buffer and thus much faster than {@link Encoder#encode}. * * @returns Encodes the object and returns a shared reference the encoder's internal buffer. */ encodeSharedRef(object) { this.reinitializeState(); this.doEncode(object, 1); return this.bytes.subarray(0, this.pos); } /** * @returns Encodes the object and returns a copy of the encoder's internal buffer. */ encode(object) { this.reinitializeState(); this.doEncode(object, 1); return this.bytes.slice(0, this.pos); } doEncode(object, depth) { if (depth > this.maxDepth) { throw new Error(`Too deep objects in depth ${depth}`); } if (object == null) { this.encodeNil(); } else if (typeof object === "boolean") { this.encodeBoolean(object); } else if (typeof object === "number") { this.encodeNumber(object); } else if (typeof object === "string") { this.encodeString(object); } else { this.encodeObject(object, depth); } } ensureBufferSizeToWrite(sizeToWrite) { const requiredSize = this.pos + sizeToWrite; if (this.view.byteLength < requiredSize) { this.resizeBuffer(requiredSize * 2); } } resizeBuffer(newSize) { const newBuffer = new ArrayBuffer(newSize); const newBytes = new Uint8Array(newBuffer); const newView = new DataView(newBuffer); newBytes.set(this.bytes); this.view = newView; this.bytes = newBytes; } encodeNil() { this.writeU8(192); } encodeBoolean(object) { if (object === false) { this.writeU8(194); } else { this.writeU8(195); } } encodeNumber(object) { if (Number.isSafeInteger(object) && !this.forceIntegerToFloat) { if (object >= 0) { if (object < 128) { this.writeU8(object); } else if (object < 256) { this.writeU8(204); this.writeU8(object); } else if (object < 65536) { this.writeU8(205); this.writeU16(object); } else if (object < 4294967296) { this.writeU8(206); this.writeU32(object); } else { this.writeU8(207); this.writeU64(object); } } else { if (object >= -32) { this.writeU8(224 | object + 32); } else if (object >= -128) { this.writeU8(208); this.writeI8(object); } else if (object >= -32768) { this.writeU8(209); this.writeI16(object); } else if (object >= -2147483648) { this.writeU8(210); this.writeI32(object); } else { this.writeU8(211); this.writeI64(object); } } } else { if (this.forceFloat32) { this.writeU8(202); this.writeF32(object); } else { this.writeU8(203); this.writeF64(object); } } } writeStringHeader(byteLength) { if (byteLength < 32) { this.writeU8(160 + byteLength); } else if (byteLength < 256) { this.writeU8(217); this.writeU8(byteLength); } else if (byteLength < 65536) { this.writeU8(218); this.writeU16(byteLength); } else if (byteLength < 4294967296) { this.writeU8(219); this.writeU32(byteLength); } else { throw new Error(`Too long string: ${byteLength} bytes in UTF-8`); } } encodeString(object) { const maxHeaderSize = 1 + 4; const strLength = object.length; if (strLength > utf8_1.TEXT_ENCODER_THRESHOLD) { const byteLength = (0, utf8_1.utf8Count)(object); this.ensureBufferSizeToWrite(maxHeaderSize + byteLength); this.writeStringHeader(byteLength); (0, utf8_1.utf8EncodeTE)(object, this.bytes, this.pos); this.pos += byteLength; } else { const byteLength = (0, utf8_1.utf8Count)(object); this.ensureBufferSizeToWrite(maxHeaderSize + byteLength); this.writeStringHeader(byteLength); (0, utf8_1.utf8EncodeJs)(object, this.bytes, this.pos); this.pos += byteLength; } } encodeObject(object, depth) { const ext = this.extensionCodec.tryToEncode(object, this.context); if (ext != null) { this.encodeExtension(ext); } else if (Array.isArray(object)) { this.encodeArray(object, depth); } else if (ArrayBuffer.isView(object)) { this.encodeBinary(object); } else if (typeof object === "object") { this.encodeMap(object, depth); } else { throw new Error(`Unrecognized object: ${Object.prototype.toString.apply(object)}`); } } encodeBinary(object) { const size = object.byteLength; if (size < 256) { this.writeU8(196); this.writeU8(size); } else if (size < 65536) { this.writeU8(197); this.writeU16(size); } else if (size < 4294967296) { this.writeU8(198); this.writeU32(size); } else { throw new Error(`Too large binary: ${size}`); } const bytes = (0, typedArrays_1.ensureUint8Array)(object); this.writeU8a(bytes); } encodeArray(object, depth) { const size = object.length; if (size < 16) { this.writeU8(144 + size); } else if (size < 65536) { this.writeU8(220); this.writeU16(size); } else if (size < 4294967296) { this.writeU8(221); this.writeU32(size); } else { throw new Error(`Too large array: ${size}`); } for (const item of object) { this.doEncode(item, depth + 1); } } countWithoutUndefined(object, keys) { let count = 0; for (const key of keys) { if (object[key] !== void 0) { count++; } } return count; } encodeMap(object, depth) { const keys = Object.keys(object); if (this.sortKeys) { keys.sort(); } const size = this.ignoreUndefined ? this.countWithoutUndefined(object, keys) : keys.length; if (size < 16) { this.writeU8(128 + size); } else if (size < 65536) { this.writeU8(222); this.writeU16(size); } else if (size < 4294967296) { this.writeU8(223); this.writeU32(size); } else { throw new Error(`Too large map object: ${size}`); } for (const key of keys) { const value = object[key]; if (!(this.ignoreUndefined && value === void 0)) { this.encodeString(key); this.doEncode(value, depth + 1); } } } encodeExtension(ext) { const size = ext.data.length; if (size === 1) { this.writeU8(212); } else if (size === 2) { this.writeU8(213); } else if (size === 4) { this.writeU8(214); } else if (size === 8) { this.writeU8(215); } else if (size === 16) { this.writeU8(216); } else if (size < 256) { this.writeU8(199); this.writeU8(size); } else if (size < 65536) { this.writeU8(200); this.writeU16(size); } else if (size < 4294967296) { this.writeU8(201); this.writeU32(size); } else { throw new Error(`Too large extension object: ${size}`); } this.writeI8(ext.type); this.writeU8a(ext.data); } writeU8(value) { this.ensureBufferSizeToWrite(1); this.view.setUint8(this.pos, value); this.pos++; } writeU8a(values) { const size = values.length; this.ensureBufferSizeToWrite(size); this.bytes.set(values, this.pos); this.pos += size; } writeI8(value) { this.ensureBufferSizeToWrite(1); this.view.setInt8(this.pos, value); this.pos++; } writeU16(value) { this.ensureBufferSizeToWrite(2); this.view.setUint16(this.pos, value); this.pos += 2; } writeI16(value) { this.ensureBufferSizeToWrite(2); this.view.setInt16(this.pos, value); this.pos += 2; } writeU32(value) { this.ensureBufferSizeToWrite(4); this.view.setUint32(this.pos, value); this.pos += 4; } writeI32(value) { this.ensureBufferSizeToWrite(4); this.view.setInt32(this.pos, value); this.pos += 4; } writeF32(value) { this.ensureBufferSizeToWrite(4); this.view.setFloat32(this.pos, value); this.pos += 4; } writeF64(value) { this.ensureBufferSizeToWrite(8); this.view.setFloat64(this.pos, value); this.pos += 8; } writeU64(value) { this.ensureBufferSizeToWrite(8); (0, int_1.setUint64)(this.view, this.pos, value); this.pos += 8; } writeI64(value) { this.ensureBufferSizeToWrite(8); (0, int_1.setInt64)(this.view, this.pos, value); this.pos += 8; } }; exports.Encoder = Encoder; } }); // node_modules/@msgpack/msgpack/dist/encode.js var require_encode = __commonJS({ "node_modules/@msgpack/msgpack/dist/encode.js"(exports) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.encode = void 0; var Encoder_1 = require_Encoder(); var defaultEncodeOptions = {}; function encode2(value, options = defaultEncodeOptions) { const encoder = new Encoder_1.Encoder(options.extensionCodec, options.context, options.maxDepth, options.initialBufferSize, options.sortKeys, options.forceFloat32, options.ignoreUndefined, options.forceIntegerToFloat); return encoder.encodeSharedRef(value); } exports.encode = encode2; } }); // node_modules/@msgpack/msgpack/dist/utils/prettyByte.js var require_prettyByte = __commonJS({ "node_modules/@msgpack/msgpack/dist/utils/prettyByte.js"(exports) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.prettyByte = void 0; function prettyByte(byte) { return `${byte < 0 ? "-" : ""}0x${Math.abs(byte).toString(16).padStart(2, "0")}`; } exports.prettyByte = prettyByte; } }); // node_modules/@msgpack/msgpack/dist/CachedKeyDecoder.js var require_CachedKeyDecoder = __commonJS({ "node_modules/@msgpack/msgpack/dist/CachedKeyDecoder.js"(exports) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.CachedKeyDecoder = void 0; var utf8_1 = require_utf8(); var DEFAULT_MAX_KEY_LENGTH = 16; var DEFAULT_MAX_LENGTH_PER_KEY = 16; var CachedKeyDecoder = class { constructor(maxKeyLength = DEFAULT_MAX_KEY_LENGTH, maxLengthPerKey = DEFAULT_MAX_LENGTH_PER_KEY) { this.maxKeyLength = maxKeyLength; this.maxLengthPerKey = maxLengthPerKey; this.hit = 0; this.miss = 0; this.caches = []; for (let i = 0; i < this.maxKeyLength; i++) { this.caches.push([]); } } canBeCached(byteLength) { return byteLength > 0 && byteLength <= this.maxKeyLength; } find(bytes, inputOffset, byteLength) { const records = this.caches[byteLength - 1]; FIND_CHUNK: for (const record of records) { const recordBytes = record.bytes; for (let j = 0; j < byteLength; j++) { if (recordBytes[j] !== bytes[inputOffset + j]) { continue FIND_CHUNK; } } return record.str; } return null; } store(bytes, value) { const records = this.caches[bytes.length - 1]; const record = { bytes, str: value }; if (records.length >= this.maxLengthPerKey) { records[Math.random() * records.length | 0] = record; } else { records.push(record); } } decode(bytes, inputOffset, byteLength) { const cachedValue = this.find(bytes, inputOffset, byteLength); if (cachedValue != null) { this.hit++; return cachedValue; } this.miss++; const str = (0, utf8_1.utf8DecodeJs)(bytes, inputOffset, byteLength); const slicedCopyOfBytes = Uint8Array.prototype.slice.call(bytes, inputOffset, inputOffset + byteLength); this.store(slicedCopyOfBytes, str); return str; } }; exports.CachedKeyDecoder = CachedKeyDecoder; } }); // node_modules/@msgpack/msgpack/dist/Decoder.js var require_Decoder = __commonJS({ "node_modules/@msgpack/msgpack/dist/Decoder.js"(exports) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.Decoder = exports.DataViewIndexOutOfBoundsError = void 0; var prettyByte_1 = require_prettyByte(); var ExtensionCodec_1 = require_ExtensionCodec(); var int_1 = require_int(); var utf8_1 = require_utf8(); var typedArrays_1 = require_typedArrays(); var CachedKeyDecoder_1 = require_CachedKeyDecoder(); var DecodeError_1 = require_DecodeError(); var isValidMapKeyType = (key) => { const keyType = typeof key; return keyType === "string" || keyType === "number"; }; var HEAD_BYTE_REQUIRED = -1; var EMPTY_VIEW = new DataView(new ArrayBuffer(0)); var EMPTY_BYTES = new Uint8Array(EMPTY_VIEW.buffer); exports.DataViewIndexOutOfBoundsError = (() => { try { EMPTY_VIEW.getInt8(0); } catch (e) { return e.constructor; } throw new Error("never reached"); })(); var MORE_DATA = new exports.DataViewIndexOutOfBoundsError("Insufficient data"); var sharedCachedKeyDecoder = new CachedKeyDecoder_1.CachedKeyDecoder(); var Decoder = class { constructor(extensionCodec = ExtensionCodec_1.ExtensionCodec.defaultCodec, context = void 0, maxStrLength = int_1.UINT32_MAX, maxBinLength = int_1.UINT32_MAX, maxArrayLength = int_1.UINT32_MAX, maxMapLength = int_1.UINT32_MAX, maxExtLength = int_1.UINT32_MAX, keyDecoder = sharedCachedKeyDecoder) { this.extensionCodec = extensionCodec; this.context = context; this.maxStrLength = maxStrLength; this.maxBinLength = maxBinLength; this.maxArrayLength = maxArrayLength; this.maxMapLength = maxMapLength; this.maxExtLength = maxExtLength; this.keyDecoder = keyDecoder; this.totalPos = 0; this.pos = 0; this.view = EMPTY_VIEW; this.bytes = EMPTY_BYTES; this.headByte = HEAD_BYTE_REQUIRED; this.stack = []; } reinitializeState() { this.totalPos = 0; this.headByte = HEAD_BYTE_REQUIRED; this.stack.length = 0; } setBuffer(buffer) { this.bytes = (0, typedArrays_1.ensureUint8Array)(buffer); this.view = (0, typedArrays_1.createDataView)(this.bytes); this.pos = 0; } appendBuffer(buffer) { if (this.headByte === HEAD_BYTE_REQUIRED && !this.hasRemaining(1)) { this.setBuffer(buffer); } else { const remainingData = this.bytes.subarray(this.pos); const newData = (0, typedArrays_1.ensureUint8Array)(buffer); const newBuffer = new Uint8Array(remainingData.length + newData.length); newBuffer.set(remainingData); newBuffer.set(newData, remainingData.length); this.setBuffer(newBuffer); } } hasRemaining(size) { return this.view.byteLength - this.pos >= size; } createExtraByteError(posToShow) { const { view, pos } = this; return new RangeError(`Extra ${view.byteLength - pos} of ${view.byteLength} byte(s) found at buffer[${posToShow}]`); } /** * @throws {@link DecodeError} * @throws {@link RangeError} */ decode(buffer) { this.reinitializeState(); this.setBuffer(buffer); const object = this.doDecodeSync(); if (this.hasRemaining(1)) { throw this.createExtraByteError(this.pos); } return object; } *decodeMulti(buffer) { this.reinitializeState(); this.setBuffer(buffer); while (this.hasRemaining(1)) { yield this.doDecodeSync(); } } async decodeAsync(stream) { let decoded = false; let object; for await (const buffer of stream) { if (decoded) { throw this.createExtraByteError(this.totalPos); } this.appendBuffer(buffer); try { object = this.doDecodeSync(); decoded = true; } catch (e) { if (!(e instanceof exports.DataViewIndexOutOfBoundsError)) { throw e; } } this.totalPos += this.pos; } if (decoded) { if (this.hasRemaining(1)) { throw this.createExtraByteError(this.totalPos); } return object; } const { headByte, pos, totalPos } = this; throw new RangeError(`Insufficient data in parsing ${(0, prettyByte_1.prettyByte)(headByte)} at ${totalPos} (${pos} in the current buffer)`); } decodeArrayStream(stream) { return this.decodeMultiAsync(stream, true); } decodeStream(stream) { return this.decodeMultiAsync(stream, false); } async *decodeMultiAsync(stream, isArray) { let isArrayHeaderRequired = isArray; let arrayItemsLeft = -1; for await (const buffer of stream) { if (isArray && arrayItemsLeft === 0) { throw this.createExtraByteError(this.totalPos); } this.appendBuffer(buffer); if (isArrayHeaderRequired) { arrayItemsLeft = this.readArraySize(); isArrayHeaderRequired = false; this.complete(); } try { while (true) { yield this.doDecodeSync(); if (--arrayItemsLeft === 0) { break; } } } catch (e) { if (!(e instanceof exports.DataViewIndexOutOfBoundsError)) { throw e; } } this.totalPos += this.pos; } } doDecodeSync() { DECODE: while (true) { const headByte = this.readHeadByte(); let object; if (headByte >= 224) { object = headByte - 256; } else if (headByte < 192) { if (headByte < 128) { object = headByte; } else if (headByte < 144) { const size = headByte - 128; if (size !== 0) { this.pushMapState(size); this.complete(); continue DECODE; } else { object = {}; } } else if (headByte < 160) { const size = headByte - 144; if (size !== 0) { this.pushArrayState(size); this.complete(); continue DECODE; } else { object = []; } } else { const byteLength = headByte - 160; object = this.decodeUtf8String(byteLength, 0); } } else if (headByte === 192) { object = null; } else if (headByte === 194) { object = false; } else if (headByte === 195) { object = true; } else if (headByte === 202) { object = this.readF32(); } else if (headByte === 203) { object = this.readF64(); } else if (headByte === 204) { object = this.readU8(); } else if (headByte === 205) { object = this.readU16(); } else if (headByte === 206) { object = this.readU32(); } else if (headByte === 207) { object = this.readU64(); } else if (headByte === 208) { object = this.readI8(); } else if (headByte === 209) { object = this.readI16(); } else if (headByte === 210) { object = this.readI32(); } else if (headByte === 211) { object = this.readI64(); } else if (headByte === 217) { const byteLength = this.lookU8(); object = this.decodeUtf8String(byteLength, 1); } else if (headByte === 218) { const byteLength = this.lookU16(); object = this.decodeUtf8String(byteLength, 2); } else if (headByte === 219) { const byteLength = this.lookU32(); object = this.decodeUtf8String(byteLength, 4); } else if (headByte === 220) { const size = this.readU16(); if (size !== 0) { this.pushArrayState(size); this.complete(); continue DECODE; } else { object = []; } } else if (headByte === 221) { const size = this.readU32(); if (size !== 0) { this.pushArrayState(size); this.complete(); continue DECODE; } else { object = []; } } else if (headByte === 222) { const size = this.readU16(); if (size !== 0) { this.pushMapState(size); this.complete(); continue DECODE; } else { object = {}; } } else if (headByte === 223) { const size = this.readU32(); if (size !== 0) { this.pushMapState(size); this.complete(); continue DECODE; } else { object = {}; } } else if (headByte === 196) { const size = this.lookU8(); object = this.decodeBinary(size, 1); } else if (headByte === 197) { const size = this.lookU16(); object = this.decodeBinary(size, 2); } else if (headByte === 198) { const size = this.lookU32(); object = this.decodeBinary(size, 4); } else if (headByte === 212) { object = this.decodeExtension(1, 0); } else if (headByte === 213) { object = this.decodeExtension(2, 0); } else if (headByte === 214) { object = this.decodeExtension(4, 0); } else if (headByte === 215) { object = this.decodeExtension(8, 0); } else if (headByte === 216) { object = this.decodeExtension(16, 0); } else if (headByte === 199) { const size = this.lookU8(); object = this.decodeExtension(size, 1); } else if (headByte === 200) { const size = this.lookU16(); object = this.decodeExtension(size, 2); } else if (headByte === 201) { const size = this.lookU32(); object = this.decodeExtension(size, 4); } else { throw new DecodeError_1.DecodeError(`Unrecognized type byte: ${(0, prettyByte_1.prettyByte)(headByte)}`); } this.complete(); const stack = this.stack; while (stack.length > 0) { const state = stack[stack.length - 1]; if (state.type === 0) { state.array[state.position] = object; state.position++; if (state.position === state.size) { stack.pop(); object = state.array; } else { continue DECODE; } } else if (state.type === 1) { if (!isValidMapKeyType(object)) { throw new DecodeError_1.DecodeError("The type of key must be string or number but " + typeof object); } if (object === "__proto__") { throw new DecodeError_1.DecodeError("The key __proto__ is not allowed"); } state.key = object; state.type = 2; continue DECODE; } else { state.map[state.key] = object; state.readCount++; if (state.readCount === state.size) { stack.pop(); object = state.map; } else { state.key = null; state.type = 1; continue DECODE; } } } return object; } } readHeadByte() { if (this.headByte === HEAD_BYTE_REQUIRED) { this.headByte = this.readU8(); } return this.headByte; } complete() { this.headByte = HEAD_BYTE_REQUIRED; } readArraySize() { const headByte = this.readHeadByte(); switch (headByte) { case 220: return this.readU16(); case 221: return this.readU32(); default: { if (headByte < 160) { return headByte - 144; } else { throw new DecodeError_1.DecodeError(`Unrecognized array type byte: ${(0, prettyByte_1.prettyByte)(headByte)}`); } } } } pushMapState(size) { if (size > this.maxMapLength) { throw new DecodeError_1.DecodeError(`Max length exceeded: map length (${size}) > maxMapLengthLength (${this.maxMapLength})`); } this.stack.push({ type: 1, size, key: null, readCount: 0, map: {} }); } pushArrayState(size) { if (size > this.maxArrayLength) { throw new DecodeError_1.DecodeError(`Max length exceeded: array length (${size}) > maxArrayLength (${this.maxArrayLength})`); } this.stack.push({ type: 0, size, array: new Array(size), position: 0 }); } decodeUtf8String(byteLength, headerOffset) { var _a; if (byteLength > this.maxStrLength) { throw new DecodeError_1.DecodeError(`Max length exceeded: UTF-8 byte length (${byteLength}) > maxStrLength (${this.maxStrLength})`); } if (this.bytes.byteLength < this.pos + headerOffset + byteLength) { throw MORE_DATA; } const offset = this.pos + headerOffset; let object; if (this.stateIsMapKey() && ((_a = this.keyDecoder) === null || _a === void 0 ? void 0 : _a.canBeCached(byteLength))) { object = this.keyDecoder.decode(this.bytes, offset, byteLength); } else if (byteLength > utf8_1.TEXT_DECODER_THRESHOLD) { object = (0, utf8_1.utf8DecodeTD)(this.bytes, offset, byteLength); } else { object = (0, utf8_1.utf8DecodeJs)(this.bytes, offset, byteLength); } this.pos += headerOffset + byteLength; return object; } stateIsMapKey() { if (this.stack.length > 0) { const state = this.stack[this.stack.length - 1]; return state.type === 1; } return false; } decodeBinary(byteLength, headOffset) { if (byteLength > this.maxBinLength) { throw new DecodeError_1.DecodeError(`Max length exceeded: bin length (${byteLength}) > maxBinLength (${this.maxBinLength})`); } if (!this.hasRemaining(byteLength + headOffset)) { throw MORE_DATA; } const offset = this.pos + headOffset; const object = this.bytes.subarray(offset, offset + byteLength); this.pos += headOffset + byteLength; return object; } decodeExtension(size, headOffset) { if (size > this.maxExtLength) { throw new DecodeError_1.DecodeError(`Max length exceeded: ext length (${size}) > maxExtLength (${this.maxExtLength})`); } const extType = this.view.getInt8(this.pos + headOffset); const data = this.decodeBinary( size, headOffset + 1 /* extType */ ); return this.extensionCodec.decode(data, extType, this.context); } lookU8() { return this.view.getUint8(this.pos); } lookU16() { return this.view.getUint16(this.pos); } lookU32() { return this.view.getUint32(this.pos); } readU8() { const value = this.view.getUint8(this.pos); this.pos++; return value; } readI8() { const value = this.view.getInt8(this.pos); this.pos++; return value; } readU16() { const value = this.view.getUint16(this.pos); this.pos += 2; return value; } readI16() { const value = this.view.getInt16(this.pos); this.pos += 2; return value; } readU32() { const value = this.view.getUint32(this.pos); this.pos += 4; return value; } readI32() { const value = this.view.getInt32(this.pos); this.pos += 4; return value; } readU64() { const value = (0, int_1.getUint64)(this.view, this.pos); this.pos += 8; return value; } readI64() { const value = (0, int_1.getInt64)(this.view, this.pos); this.pos += 8; return value; } readF32() { const value = this.view.getFloat32(this.pos); this.pos += 4; return value; } readF64() { const value = this.view.getFloat64(this.pos); this.pos += 8; return value; } }; exports.Decoder = Decoder; } }); // node_modules/@msgpack/msgpack/dist/decode.js var require_decode = __commonJS({ "node_modules/@msgpack/msgpack/dist/decode.js"(exports) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.decodeMulti = exports.decode = exports.defaultDecodeOptions = void 0; var Decoder_1 = require_Decoder(); exports.defaultDecodeOptions = {}; function decode2(buffer, options = exports.defaultDecodeOptions) { const decoder = new Decoder_1.Decoder(options.extensionCodec, options.context, options.maxStrLength, options.maxBinLength, options.maxArrayLength, options.maxMapLength, options.maxExtLength); return decoder.decode(buffer); } exports.decode = decode2; function decodeMulti(buffer, options = exports.defaultDecodeOptions) { const decoder = new Decoder_1.Decoder(options.extensionCodec, options.context, options.maxStrLength, options.maxBinLength, options.maxArrayLength, options.maxMapLength, options.maxExtLength); return decoder.decodeMulti(buffer); } exports.decodeMulti = decodeMulti; } }); // node_modules/@msgpack/msgpack/dist/utils/stream.js var require_stream = __commonJS({ "node_modules/@msgpack/msgpack/dist/utils/stream.js"(exports) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.ensureAsyncIterable = exports.asyncIterableFromStream = exports.isAsyncIterable = void 0; function isAsyncIterable(object) { return object[Symbol.asyncIterator] != null; } exports.isAsyncIterable = isAsyncIterable; function assertNonNull(value) { if (value == null) { throw new Error("Assertion Failure: value must not be null nor undefined"); } } async function* asyncIterableFromStream(stream) { const reader = stream.getReader(); try { while (true) { const { done, value } = await reader.read(); if (done) { return; } assertNonNull(value); yield value; } } finally { reader.releaseLock(); } } exports.asyncIterableFromStream = asyncIterableFromStream; function ensureAsyncIterable(streamLike) { if (isAsyncIterable(streamLike)) { return streamLike; } else { return asyncIterableFromStream(streamLike); } } exports.ensureAsyncIterable = ensureAsyncIterable; } }); // node_modules/@msgpack/msgpack/dist/decodeAsync.js var require_decodeAsync = __commonJS({ "node_modules/@msgpack/msgpack/dist/decodeAsync.js"(exports) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.decodeStream = exports.decodeMultiStream = exports.decodeArrayStream = exports.decodeAsync = void 0; var Decoder_1 = require_Decoder(); var stream_1 = require_stream(); var decode_1 = require_decode(); async function decodeAsync(streamLike, options = decode_1.defaultDecodeOptions) { const stream = (0, stream_1.ensureAsyncIterable)(streamLike); const decoder = new Decoder_1.Decoder(options.extensionCodec, options.context, options.maxStrLength, options.maxBinLength, options.maxArrayLength, options.maxMapLength, options.maxExtLength); return decoder.decodeAsync(stream); } exports.decodeAsync = decodeAsync; function decodeArrayStream(streamLike, options = decode_1.defaultDecodeOptions) { const stream = (0, stream_1.ensureAsyncIterable)(streamLike); const decoder = new Decoder_1.Decoder(options.extensionCodec, options.context, options.maxStrLength, options.maxBinLength, options.maxArrayLength, options.maxMapLength, options.maxExtLength); return decoder.decodeArrayStream(stream); } exports.decodeArrayStream = decodeArrayStream; function decodeMultiStream(streamLike, options = decode_1.defaultDecodeOptions) { const stream = (0, stream_1.ensureAsyncIterable)(streamLike); const decoder = new Decoder_1.Decoder(options.extensionCodec, options.context, options.maxStrLength, options.maxBinLength, options.maxArrayLength, options.maxMapLength, options.maxExtLength); return decoder.decodeStream(stream); } exports.decodeMultiStream = decodeMultiStream; function decodeStream(streamLike, options = decode_1.defaultDecodeOptions) { return decodeMultiStream(streamLike, options); } exports.decodeStream = decodeStream; } }); // node_modules/@msgpack/msgpack/dist/index.js var require_dist = __commonJS({ "node_modules/@msgpack/msgpack/dist/index.js"(exports) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.decodeTimestampExtension = exports.encodeTimestampExtension = exports.decodeTimestampToTimeSpec = exports.encodeTimeSpecToTimestamp = exports.encodeDateToTimeSpec = exports.EXT_TIMESTAMP = exports.ExtData = exports.ExtensionCodec = exports.Encoder = exports.DataViewIndexOutOfBoundsError = exports.DecodeError = exports.Decoder = exports.decodeStream = exports.decodeMultiStream = exports.decodeArrayStream = exports.decodeAsync = exports.decodeMulti = exports.decode = exports.encode = void 0; var encode_1 = require_encode(); Object.defineProperty(exports, "encode", { enumerable: true, get: function() { return encode_1.encode; } }); var decode_1 = require_decode(); Object.defineProperty(exports, "decode", { enumerable: true, get: function() { return decode_1.decode; } }); Object.defineProperty(exports, "decodeMulti", { enumerable: true, get: function() { return decode_1.decodeMulti; } }); var decodeAsync_1 = require_decodeAsync(); Object.defineProperty(exports, "decodeAsync", { enumerable: true, get: function() { return decodeAsync_1.decodeAsync; } }); Object.defineProperty(exports, "decodeArrayStream", { enumerable: true, get: function() { return decodeAsync_1.decodeArrayStream; } }); Object.defineProperty(exports, "decodeMultiStream", { enumerable: true, get: function() { return decodeAsync_1.decodeMultiStream; } }); Object.defineProperty(exports, "decodeStream", { enumerable: true, get: function() { return decodeAsync_1.decodeStream; } }); var Decoder_1 = require_Decoder(); Object.defineProperty(exports, "Decoder", { enumerable: true, get: function() { return Decoder_1.Decoder; } }); Object.defineProperty(exports, "DataViewIndexOutOfBoundsError", { enumerable: true, get: function() { return Decoder_1.DataViewIndexOutOfBoundsError; } }); var DecodeError_1 = require_DecodeError(); Object.defineProperty(exports, "DecodeError", { enumerable: true, get: function() { return DecodeError_1.DecodeError; } }); var Encoder_1 = require_Encoder(); Object.defineProperty(exports, "Encoder", { enumerable: true, get: function() { return Encoder_1.Encoder; } }); var ExtensionCodec_1 = require_ExtensionCodec(); Object.defineProperty(exports, "ExtensionCodec", { enumerable: true, get: function() { return ExtensionCodec_1.ExtensionCodec; } }); var ExtData_1 = require_ExtData(); Object.defineProperty(exports, "ExtData", { enumerable: true, get: function() { return ExtData_1.ExtData; } }); var timestamp_1 = require_timestamp(); Object.defineProperty(exports, "EXT_TIMESTAMP", { enumerable: true, get: function() { return timestamp_1.EXT_TIMESTAMP; } }); Object.defineProperty(exports, "encodeDateToTimeSpec", { enumerable: true, get: function() { return timestamp_1.encodeDateToTimeSpec; } }); Object.defineProperty(exports, "encodeTimeSpecToTimestamp", { enumerable: true, get: function() { return timestamp_1.encodeTimeSpecToTimestamp; } }); Object.defineProperty(exports, "decodeTimestampToTimeSpec", { enumerable: true, get: function() { return timestamp_1.decodeTimestampToTimeSpec; } }); Object.defineProperty(exports, "encodeTimestampExtension", { enumerable: true, get: function() { return timestamp_1.encodeTimestampExtension; } }); Object.defineProperty(exports, "decodeTimestampExtension", { enumerable: true, get: function() { return timestamp_1.decodeTimestampExtension; } }); } }); // webR/error.ts var WebRError = class extends Error { constructor(msg) { super(msg); this.name = this.constructor.name; Object.setPrototypeOf(this, new.target.prototype); } }; var WebRChannelError = class extends WebRError { }; // webR/compat.ts var IN_NODE = typeof process !== "undefined" && process.release && process.release.name === "node"; var loadScript; if (globalThis.document) { loadScript = (url) => new Promise((resolve, reject) => { const script = document.createElement("script"); script.src = url; script.onload = () => resolve(); script.onerror = reject; document.head.appendChild(script); }); } else if (globalThis.importScripts) { loadScript = async (url) => { try { globalThis.importScripts(url); } catch (e) { if (e instanceof TypeError) { await Promise.resolve().then(() => __toESM(__require(url))); } else { throw e; } } }; } else if (IN_NODE) { loadScript = async (url) => { const nodePathMod = (await Promise.resolve().then(() => __toESM(__require("path")))).default; await Promise.resolve().then(() => __toESM(__require(nodePathMod.resolve(url)))); }; } else { throw new WebRError("Cannot determine runtime environment"); } // webR/utils.ts function promiseHandles() { const out = { resolve: (_value) => { }, reject: (_reason) => { }, promise: null }; const promise = new Promise((resolve, reject) => { out.resolve = resolve; out.reject = reject; }); out.promise = promise; return out; } // webR/chan/serviceworker.ts var import_msgpack = __toESM(require_dist()); var requests = {}; function handleInstall() { console.log("webR service worker installed"); self.skipWaiting(); } function handleActivate(event) { console.log("webR service worker activating"); event.waitUntil(self.clients.claim()); } async function sendRequest(clientId, uuid) { const client = await self.clients.get(clientId); if (!client) { throw new WebRChannelError("Service worker client not found"); } if (!(uuid in requests)) { requests[uuid] = promiseHandles(); client.postMessage({ type: "request", data: uuid }); } const response = await requests[uuid].promise; const headers = { "Cross-Origin-Embedder-Policy": "require-corp" }; return new Response((0, import_msgpack.encode)(response), { headers }); } function handleFetch(event) { const wasmMatch = /__wasm__\/webr-fetch-request\//.exec(event.request.url); if (!wasmMatch) { return false; } const requestBody = event.request.arrayBuffer(); const requestReponse = requestBody.then(async (body) => { const data = (0, import_msgpack.decode)(body); return await sendRequest(data.clientId, data.uuid); }); event.waitUntil(requestReponse); event.respondWith(requestReponse); return true; } function handleMessage(event) { switch (event.data.type) { case "register-client-main": { self.clients.claim(); const source = event.source; self.clients.get(source.id).then((client) => { if (!client) { throw new WebRChannelError("Can't respond to client in service worker message handler"); } client.postMessage({ type: "registration-successful", clientId: source.id }); }); break; } case "wasm-webr-fetch-response": { if (event.data.uuid in requests) { requests[event.data.uuid].resolve(event.data.response); delete requests[event.data.uuid]; } break; } default: return false; } return true; } var webRHandlers = { handleInstall, handleActivate, handleFetch, handleMessage }; self.addEventListener("install", webRHandlers.handleInstall); self.addEventListener("activate", webRHandlers.handleActivate); self.addEventListener("fetch", webRHandlers.handleFetch); self.addEventListener("message", webRHandlers.handleMessage); })(); //# sourceMappingURL=webr-serviceworker.js.map