Raven Scott
9bdecc4170
Release rolling / release (push) Successful in 11m16s
Bump published pins (compact-encoding 3, bare-fetch/tls/https/ws 3, bare-subprocess 6, bare-signals 5, corestore 7.12, protomux 3.11, hypercore-crypto 3.7, bare-runtime 1.31) and regenerate catalogs, manifests, and kernel/seeder bundles. Adapt call sites to the new APIs: - Corestore: explicit session flush before suspend(); treeCache ctor opts - bare-crypto: KeyObject.export() instead of removed ._key - Protomux 3.11: wait for fullyOpened()/fullyClosed() on chat channels - bare-fetch: surface response.type and Headers.getSetCookie - host snapshots: bare-os 3.9 / bare-posix / bare-fs.statfs frsize - bare-subprocess 6: optional IPC channel + json serialization Keep catalog sync from wiping curated pearEntries. Teach the Node test shim to stub bare-thread/bare-worker (ESM absolute paths) and chain Bare.on so bare-timers can load. Booter 479, protocol 34, seeder 14.
5290 lines
189 KiB
JavaScript
5290 lines
189 KiB
JavaScript
var __bare_os_bundle_exports__ = (() => {
|
|
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 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 __export = (target, all) => {
|
|
for (var name in all)
|
|
__defProp(target, name, { get: all[name], enumerable: true });
|
|
};
|
|
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
|
|
));
|
|
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
|
|
// ../../node_modules/bare-type/binding.js
|
|
var require_binding = __commonJS({
|
|
"../../node_modules/bare-type/binding.js"(exports, module) {
|
|
module.exports = __require.addon();
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-type/index.js
|
|
var require_bare_type = __commonJS({
|
|
"../../node_modules/bare-type/index.js"(exports, module) {
|
|
var binding = require_binding();
|
|
var t = binding.constants;
|
|
var Type = class {
|
|
constructor(type) {
|
|
this._type = type;
|
|
}
|
|
isUndefined() {
|
|
return this._type === t.UNDEFINED;
|
|
}
|
|
isNull() {
|
|
return this._type === t.NULL;
|
|
}
|
|
isBoolean() {
|
|
return this._type === t.BOOLEAN;
|
|
}
|
|
isNumber() {
|
|
return (this._type & 255) === t.NUMBER;
|
|
}
|
|
isInt32() {
|
|
return (this._type & (255 | t.INT32)) === (t.NUMBER | t.INT32);
|
|
}
|
|
isUint32() {
|
|
return (this._type & (255 | t.UINT32)) === (t.NUMBER | t.UINT32);
|
|
}
|
|
isString() {
|
|
return this._type === t.STRING;
|
|
}
|
|
isSymbol() {
|
|
return this._type === t.SYMBOL;
|
|
}
|
|
isObject() {
|
|
return (this._type & 255) === t.OBJECT;
|
|
}
|
|
isArray() {
|
|
return this._type === (t.OBJECT | t.ARRAY);
|
|
}
|
|
isArguments() {
|
|
return this._type === (t.OBJECT | t.ARGUMENTS);
|
|
}
|
|
isDate() {
|
|
return this._type === (t.OBJECT | t.DATE);
|
|
}
|
|
isRegExp() {
|
|
return this._type === (t.OBJECT | t.REGEXP);
|
|
}
|
|
isError() {
|
|
return this._type === (t.OBJECT | t.ERROR);
|
|
}
|
|
isPromise() {
|
|
return this._type === (t.OBJECT | t.PROMISE);
|
|
}
|
|
isProxy() {
|
|
return this._type === (t.OBJECT | t.PROXY);
|
|
}
|
|
isGenerator() {
|
|
return this._type === (t.OBJECT | t.GENERATOR);
|
|
}
|
|
isMap() {
|
|
return this._type === (t.OBJECT | t.MAP);
|
|
}
|
|
isSet() {
|
|
return this._type === (t.OBJECT | t.SET);
|
|
}
|
|
isWeakMap() {
|
|
return this._type === (t.OBJECT | t.WEAK_MAP);
|
|
}
|
|
isWeakSet() {
|
|
return this._type === (t.OBJECT | t.WEAK_SET);
|
|
}
|
|
isWeakRef() {
|
|
return this._type === (t.OBJECT | t.WEAK_REF);
|
|
}
|
|
isArrayBuffer() {
|
|
return this._type === (t.OBJECT | t.ARRAYBUFFER);
|
|
}
|
|
isSharedArrayBuffer() {
|
|
return this._type === (t.OBJECT | t.SHAREDARRAYBUFFER);
|
|
}
|
|
isTypedArray() {
|
|
return (this._type & 65535) === (t.OBJECT | t.TYPEDARRAY);
|
|
}
|
|
isInt8Array() {
|
|
return this._type === (t.OBJECT | t.TYPEDARRAY | t.INT8ARRAY);
|
|
}
|
|
isUint8Array() {
|
|
return this._type === (t.OBJECT | t.TYPEDARRAY | t.UINT8ARRAY);
|
|
}
|
|
isUint8ClampedArray() {
|
|
return this._type === (t.OBJECT | t.TYPEDARRAY | t.UINT8CLAMPEDARRAY);
|
|
}
|
|
isInt16Array() {
|
|
return this._type === (t.OBJECT | t.TYPEDARRAY | t.INT16ARRAY);
|
|
}
|
|
isUint16Array() {
|
|
return this._type === (t.OBJECT | t.TYPEDARRAY | t.UINT16ARRAY);
|
|
}
|
|
isInt32Array() {
|
|
return this._type === (t.OBJECT | t.TYPEDARRAY | t.INT32ARRAY);
|
|
}
|
|
isUint32Array() {
|
|
return this._type === (t.OBJECT | t.TYPEDARRAY | t.UINT32ARRAY);
|
|
}
|
|
isFloat16Array() {
|
|
return this._type === (t.OBJECT | t.TYPEDARRAY | t.FLOAT16ARRAY);
|
|
}
|
|
isFloat32Array() {
|
|
return this._type === (t.OBJECT | t.TYPEDARRAY | t.FLOAT32ARRAY);
|
|
}
|
|
isFloat64Array() {
|
|
return this._type === (t.OBJECT | t.TYPEDARRAY | t.FLOAT64ARRAY);
|
|
}
|
|
isBigInt64Array() {
|
|
return this._type === (t.OBJECT | t.TYPEDARRAY | t.BIGINT64ARRAY);
|
|
}
|
|
isBigUint64Array() {
|
|
return this._type === (t.OBJECT | t.TYPEDARRAY | t.BIGUINT64ARRAY);
|
|
}
|
|
isDataView() {
|
|
return this._type === (t.OBJECT | t.DATAVIEW);
|
|
}
|
|
isModuleNamespace() {
|
|
return this._type === (t.OBJECT | t.MODULE_NAMESPACE);
|
|
}
|
|
isFunction() {
|
|
return (this._type & 255) === t.FUNCTION;
|
|
}
|
|
isAsyncFunction() {
|
|
return (this._type & (255 | t.ASYNC_FUNCTION)) === (t.FUNCTION | t.ASYNC_FUNCTION);
|
|
}
|
|
isGeneratorFunction() {
|
|
return (this._type & (255 | t.GENERATOR_FUNCTION)) === (t.FUNCTION | t.GENERATOR_FUNCTION);
|
|
}
|
|
isExternal() {
|
|
return this._type === t.EXTERNAL;
|
|
}
|
|
isBigInt() {
|
|
return this._type === t.BIGINT;
|
|
}
|
|
};
|
|
module.exports = exports = function type(value) {
|
|
switch (typeof value) {
|
|
case "undefined":
|
|
return new Type(t.UNDEFINED);
|
|
case "boolean":
|
|
return new Type(t.BOOLEAN);
|
|
case "number":
|
|
return new Type(
|
|
Number.isSafeInteger(value) ? binding.type(value) : t.NUMBER
|
|
);
|
|
case "string":
|
|
return new Type(t.STRING);
|
|
case "symbol":
|
|
return new Type(t.SYMBOL);
|
|
case "object":
|
|
return new Type(value === null ? t.NULL : binding.type(value));
|
|
case "function":
|
|
return new Type(binding.type(value));
|
|
case "bigint":
|
|
return new Type(t.BIGINT);
|
|
}
|
|
};
|
|
exports.createTag = function createTag(...components) {
|
|
const tag = new Uint32Array(4);
|
|
for (let i = 0; i < 4; i++) tag[i] = components[i] || 0;
|
|
return tag;
|
|
};
|
|
exports.addTag = function addTag(object, tag) {
|
|
binding.addTag(object, tag);
|
|
};
|
|
exports.checkTag = function checkTag(object, tag) {
|
|
return binding.checkTag(object, tag);
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-path/binding.js
|
|
var require_binding2 = __commonJS({
|
|
"../../node_modules/bare-path/binding.js"(exports, module) {
|
|
module.exports = __require.addon();
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-path/lib/constants.js
|
|
var require_constants = __commonJS({
|
|
"../../node_modules/bare-path/lib/constants.js"(exports, module) {
|
|
module.exports = {
|
|
CHAR_UPPERCASE_A: 65,
|
|
CHAR_LOWERCASE_A: 97,
|
|
CHAR_UPPERCASE_Z: 90,
|
|
CHAR_LOWERCASE_Z: 122,
|
|
CHAR_DOT: 46,
|
|
CHAR_FORWARD_SLASH: 47,
|
|
CHAR_BACKWARD_SLASH: 92,
|
|
CHAR_COLON: 58,
|
|
CHAR_QUESTION_MARK: 63
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-path/lib/shared.js
|
|
var require_shared = __commonJS({
|
|
"../../node_modules/bare-path/lib/shared.js"(exports) {
|
|
var { CHAR_DOT, CHAR_FORWARD_SLASH } = require_constants();
|
|
exports.validateString = function validateString(value, name) {
|
|
if (typeof value !== "string") {
|
|
throw new TypeError(
|
|
`The "${name}" argument must be of type string. Received type ${typeof value}`
|
|
);
|
|
}
|
|
};
|
|
exports.normalizeString = function normalizeString(path, allowAboveRoot, separator, isPathSeparator) {
|
|
let res = "";
|
|
let lastSegmentLength = 0;
|
|
let lastSlash = -1;
|
|
let dots = 0;
|
|
let code = 0;
|
|
for (let i = 0; i <= path.length; ++i) {
|
|
if (i < path.length) {
|
|
code = path.charCodeAt(i);
|
|
} else if (isPathSeparator(code)) {
|
|
break;
|
|
} else {
|
|
code = CHAR_FORWARD_SLASH;
|
|
}
|
|
if (isPathSeparator(code)) {
|
|
if (lastSlash === i - 1 || dots === 1) ;
|
|
else if (dots === 2) {
|
|
if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== CHAR_DOT || res.charCodeAt(res.length - 2) !== CHAR_DOT) {
|
|
if (res.length > 2) {
|
|
const lastSlashIndex = res.lastIndexOf(separator);
|
|
if (lastSlashIndex === -1) {
|
|
res = "";
|
|
lastSegmentLength = 0;
|
|
} else {
|
|
res = res.substring(0, lastSlashIndex);
|
|
lastSegmentLength = res.length - 1 - res.lastIndexOf(separator);
|
|
}
|
|
lastSlash = i;
|
|
dots = 0;
|
|
continue;
|
|
} else if (res.length !== 0) {
|
|
res = "";
|
|
lastSegmentLength = 0;
|
|
lastSlash = i;
|
|
dots = 0;
|
|
continue;
|
|
}
|
|
}
|
|
if (allowAboveRoot) {
|
|
res += res.length > 0 ? `${separator}..` : "..";
|
|
lastSegmentLength = 2;
|
|
}
|
|
} else {
|
|
if (res.length > 0) {
|
|
res += `${separator}${path.substring(lastSlash + 1, i)}`;
|
|
} else {
|
|
res = path.substring(lastSlash + 1, i);
|
|
}
|
|
lastSegmentLength = i - lastSlash - 1;
|
|
}
|
|
lastSlash = i;
|
|
dots = 0;
|
|
} else if (code === CHAR_DOT && dots !== -1) {
|
|
++dots;
|
|
} else {
|
|
dots = -1;
|
|
}
|
|
}
|
|
return res;
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-path/lib/posix.js
|
|
var require_posix = __commonJS({
|
|
"../../node_modules/bare-path/lib/posix.js"(exports) {
|
|
var binding = require_binding2();
|
|
var { normalizeString, validateString } = require_shared();
|
|
var { CHAR_DOT, CHAR_FORWARD_SLASH } = require_constants();
|
|
function isPosixPathSeparator(code) {
|
|
return code === CHAR_FORWARD_SLASH;
|
|
}
|
|
exports.win32 = require_win32();
|
|
exports.posix = exports;
|
|
exports.sep = "/";
|
|
exports.delimiter = ":";
|
|
exports.resolve = function resolve(...args) {
|
|
let resolvedPath = "";
|
|
let resolvedAbsolute = false;
|
|
for (let i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {
|
|
const path = i >= 0 ? args[i] : binding.cwd();
|
|
if (i >= 0) validateString(path, `paths[${i}]`);
|
|
if (path.length === 0) {
|
|
continue;
|
|
}
|
|
resolvedPath = `${path}/${resolvedPath}`;
|
|
resolvedAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
|
|
}
|
|
resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute, "/", isPosixPathSeparator);
|
|
if (resolvedAbsolute) {
|
|
return `/${resolvedPath}`;
|
|
}
|
|
return resolvedPath.length > 0 ? resolvedPath : ".";
|
|
};
|
|
exports.normalize = function normalize(path) {
|
|
validateString(path, "path");
|
|
if (path.length === 0) return ".";
|
|
const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
|
|
const trailingSeparator = path.charCodeAt(path.length - 1) === CHAR_FORWARD_SLASH;
|
|
path = normalizeString(path, !isAbsolute, "/", isPosixPathSeparator);
|
|
if (path.length === 0) {
|
|
if (isAbsolute) return "/";
|
|
return trailingSeparator ? "./" : ".";
|
|
}
|
|
if (trailingSeparator) path += "/";
|
|
return isAbsolute ? `/${path}` : path;
|
|
};
|
|
exports.isAbsolute = function isAbsolute(path) {
|
|
validateString(path, "path");
|
|
return path.length > 0 && path.charCodeAt(0) === CHAR_FORWARD_SLASH;
|
|
};
|
|
exports.join = function join(...args) {
|
|
if (args.length === 0) return ".";
|
|
let joined;
|
|
for (let i = 0; i < args.length; ++i) {
|
|
const arg = args[i];
|
|
validateString(arg, "path");
|
|
if (arg.length > 0) {
|
|
if (joined === void 0) joined = arg;
|
|
else joined += `/${arg}`;
|
|
}
|
|
}
|
|
if (joined === void 0) return ".";
|
|
return exports.normalize(joined);
|
|
};
|
|
exports.relative = function relative(from, to) {
|
|
validateString(from, "from");
|
|
validateString(to, "to");
|
|
if (from === to) return "";
|
|
from = exports.resolve(from);
|
|
to = exports.resolve(to);
|
|
if (from === to) return "";
|
|
const fromStart = 1;
|
|
const fromEnd = from.length;
|
|
const fromLen = fromEnd - fromStart;
|
|
const toStart = 1;
|
|
const toLen = to.length - toStart;
|
|
const length = fromLen < toLen ? fromLen : toLen;
|
|
let lastCommonSep = -1;
|
|
let i = 0;
|
|
for (; i < length; i++) {
|
|
const fromCode = from.charCodeAt(fromStart + i);
|
|
if (fromCode !== to.charCodeAt(toStart + i)) {
|
|
break;
|
|
} else if (fromCode === CHAR_FORWARD_SLASH) {
|
|
lastCommonSep = i;
|
|
}
|
|
}
|
|
if (i === length) {
|
|
if (toLen > length) {
|
|
if (to.charCodeAt(toStart + i) === CHAR_FORWARD_SLASH) {
|
|
return to.substring(toStart + i + 1);
|
|
}
|
|
if (i === 0) {
|
|
return to.substring(toStart + i);
|
|
}
|
|
} else if (fromLen > length) {
|
|
if (from.charCodeAt(fromStart + i) === CHAR_FORWARD_SLASH) {
|
|
lastCommonSep = i;
|
|
} else if (i === 0) {
|
|
lastCommonSep = 0;
|
|
}
|
|
}
|
|
}
|
|
let out = "";
|
|
for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
|
|
if (i === fromEnd || from.charCodeAt(i) === CHAR_FORWARD_SLASH) {
|
|
out += out.length === 0 ? ".." : "/..";
|
|
}
|
|
}
|
|
return `${out}${to.substring(toStart + lastCommonSep)}`;
|
|
};
|
|
exports.toNamespacedPath = function toNamespacedPath(path) {
|
|
return path;
|
|
};
|
|
exports.dirname = function dirname(path) {
|
|
validateString(path, "path");
|
|
if (path.length === 0) return ".";
|
|
const hasRoot = path.charCodeAt(0) === CHAR_FORWARD_SLASH;
|
|
let end = -1;
|
|
let matchedSlash = true;
|
|
for (let i = path.length - 1; i >= 1; --i) {
|
|
if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {
|
|
if (!matchedSlash) {
|
|
end = i;
|
|
break;
|
|
}
|
|
} else {
|
|
matchedSlash = false;
|
|
}
|
|
}
|
|
if (end === -1) return hasRoot ? "/" : ".";
|
|
if (hasRoot && end === 1) return "//";
|
|
return path.substring(0, end);
|
|
};
|
|
exports.basename = function basename(path, suffix) {
|
|
if (suffix !== void 0) validateString(suffix, "suffix");
|
|
validateString(path, "path");
|
|
let start = 0;
|
|
let end = -1;
|
|
let matchedSlash = true;
|
|
if (suffix !== void 0 && suffix.length > 0 && suffix.length <= path.length) {
|
|
if (suffix === path) {
|
|
return "";
|
|
}
|
|
let extIdx = suffix.length - 1;
|
|
let firstNonSlashEnd = -1;
|
|
for (let i = path.length - 1; i >= 0; --i) {
|
|
const code = path.charCodeAt(i);
|
|
if (code === CHAR_FORWARD_SLASH) {
|
|
if (!matchedSlash) {
|
|
start = i + 1;
|
|
break;
|
|
}
|
|
} else {
|
|
if (firstNonSlashEnd === -1) {
|
|
matchedSlash = false;
|
|
firstNonSlashEnd = i + 1;
|
|
}
|
|
if (extIdx >= 0) {
|
|
if (code === suffix.charCodeAt(extIdx)) {
|
|
if (--extIdx === -1) {
|
|
end = i;
|
|
}
|
|
} else {
|
|
extIdx = -1;
|
|
end = firstNonSlashEnd;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (start === end) end = firstNonSlashEnd;
|
|
else if (end === -1) end = path.length;
|
|
return path.substring(start, end);
|
|
}
|
|
for (let i = path.length - 1; i >= 0; --i) {
|
|
if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {
|
|
if (!matchedSlash) {
|
|
start = i + 1;
|
|
break;
|
|
}
|
|
} else if (end === -1) {
|
|
matchedSlash = false;
|
|
end = i + 1;
|
|
}
|
|
}
|
|
if (end === -1) return "";
|
|
return path.substring(start, end);
|
|
};
|
|
exports.extname = function extname(path) {
|
|
validateString(path, "path");
|
|
let startDot = -1;
|
|
let startPart = 0;
|
|
let end = -1;
|
|
let matchedSlash = true;
|
|
let preDotState = 0;
|
|
for (let i = path.length - 1; i >= 0; --i) {
|
|
const code = path.charCodeAt(i);
|
|
if (code === CHAR_FORWARD_SLASH) {
|
|
if (!matchedSlash) {
|
|
startPart = i + 1;
|
|
break;
|
|
}
|
|
continue;
|
|
}
|
|
if (end === -1) {
|
|
matchedSlash = false;
|
|
end = i + 1;
|
|
}
|
|
if (code === CHAR_DOT) {
|
|
if (startDot === -1) startDot = i;
|
|
else if (preDotState !== 1) preDotState = 1;
|
|
} else if (startDot !== -1) {
|
|
preDotState = -1;
|
|
}
|
|
}
|
|
if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
|
|
return "";
|
|
}
|
|
return path.substring(startDot, end);
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-path/lib/win32.js
|
|
var require_win32 = __commonJS({
|
|
"../../node_modules/bare-path/lib/win32.js"(exports) {
|
|
var binding = require_binding2();
|
|
var { normalizeString, validateString } = require_shared();
|
|
var {
|
|
CHAR_UPPERCASE_A,
|
|
CHAR_LOWERCASE_A,
|
|
CHAR_UPPERCASE_Z,
|
|
CHAR_LOWERCASE_Z,
|
|
CHAR_DOT,
|
|
CHAR_FORWARD_SLASH,
|
|
CHAR_BACKWARD_SLASH,
|
|
CHAR_COLON,
|
|
CHAR_QUESTION_MARK
|
|
} = require_constants();
|
|
function isWindowsPathSeparator(code) {
|
|
return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
|
|
}
|
|
function isWindowsDeviceRoot(code) {
|
|
return code >= CHAR_UPPERCASE_A && code <= CHAR_UPPERCASE_Z || code >= CHAR_LOWERCASE_A && code <= CHAR_LOWERCASE_Z;
|
|
}
|
|
exports.posix = require_posix();
|
|
exports.win32 = exports;
|
|
exports.sep = "\\";
|
|
exports.delimiter = ";";
|
|
exports.resolve = function resolve(...args) {
|
|
let resolvedDevice = "";
|
|
let resolvedTail = "";
|
|
let resolvedAbsolute = false;
|
|
for (let i = args.length - 1; i >= -1; i--) {
|
|
let path;
|
|
if (i >= 0) {
|
|
path = args[i];
|
|
validateString(path, `paths[${i}]`);
|
|
if (path.length === 0) continue;
|
|
} else if (resolvedDevice.length === 0) {
|
|
path = binding.cwd();
|
|
} else {
|
|
path = binding.cwd(resolvedDevice);
|
|
if (path === void 0 || path.substring(0, 2).toLowerCase() !== resolvedDevice.toLowerCase() && path.charCodeAt(2) === CHAR_BACKWARD_SLASH) {
|
|
path = `${resolvedDevice}\\`;
|
|
}
|
|
}
|
|
const len = path.length;
|
|
let rootEnd = 0;
|
|
let device = "";
|
|
let isAbsolute = false;
|
|
const code = path.charCodeAt(0);
|
|
if (len === 1) {
|
|
if (isWindowsPathSeparator(code)) {
|
|
rootEnd = 1;
|
|
isAbsolute = true;
|
|
}
|
|
} else if (isWindowsPathSeparator(code)) {
|
|
isAbsolute = true;
|
|
if (isWindowsPathSeparator(path.charCodeAt(1))) {
|
|
let j = 2;
|
|
let last = j;
|
|
while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) {
|
|
j++;
|
|
}
|
|
if (j < len && j !== last) {
|
|
const firstPart = path.substring(last, j);
|
|
last = j;
|
|
while (j < len && isWindowsPathSeparator(path.charCodeAt(j))) {
|
|
j++;
|
|
}
|
|
if (j < len && j !== last) {
|
|
last = j;
|
|
while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) {
|
|
j++;
|
|
}
|
|
if (j === len || j !== last) {
|
|
device = `\\\\${firstPart}\\${path.substring(last, j)}`;
|
|
rootEnd = j;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
rootEnd = 1;
|
|
}
|
|
} else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) {
|
|
device = path.substring(0, 2);
|
|
rootEnd = 2;
|
|
if (len > 2 && isWindowsPathSeparator(path.charCodeAt(2))) {
|
|
isAbsolute = true;
|
|
rootEnd = 3;
|
|
}
|
|
}
|
|
if (device.length > 0) {
|
|
if (resolvedDevice.length > 0) {
|
|
if (device.toLowerCase() !== resolvedDevice.toLowerCase()) {
|
|
continue;
|
|
}
|
|
} else {
|
|
resolvedDevice = device;
|
|
}
|
|
}
|
|
if (resolvedAbsolute) {
|
|
if (resolvedDevice.length > 0) {
|
|
break;
|
|
}
|
|
} else {
|
|
resolvedTail = `${path.substring(rootEnd)}\\${resolvedTail}`;
|
|
resolvedAbsolute = isAbsolute;
|
|
if (isAbsolute && resolvedDevice.length > 0) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
resolvedTail = normalizeString(resolvedTail, !resolvedAbsolute, "\\", isWindowsPathSeparator);
|
|
return resolvedAbsolute ? `${resolvedDevice}\\${resolvedTail}` : `${resolvedDevice}${resolvedTail}` || ".";
|
|
};
|
|
exports.normalize = function normalize(path) {
|
|
validateString(path, "path");
|
|
const len = path.length;
|
|
if (len === 0) return ".";
|
|
let rootEnd = 0;
|
|
let device;
|
|
let isAbsolute = false;
|
|
const code = path.charCodeAt(0);
|
|
if (len === 1) {
|
|
return code === CHAR_FORWARD_SLASH ? "\\" : path;
|
|
}
|
|
if (isWindowsPathSeparator(code)) {
|
|
isAbsolute = true;
|
|
if (isWindowsPathSeparator(path.charCodeAt(1))) {
|
|
let j = 2;
|
|
let last = j;
|
|
while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) {
|
|
j++;
|
|
}
|
|
if (j < len && j !== last) {
|
|
const firstPart = path.substring(last, j);
|
|
last = j;
|
|
while (j < len && isWindowsPathSeparator(path.charCodeAt(j))) {
|
|
j++;
|
|
}
|
|
if (j < len && j !== last) {
|
|
last = j;
|
|
while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) {
|
|
j++;
|
|
}
|
|
if (j === len) {
|
|
return `\\\\${firstPart}\\${path.substring(last)}\\`;
|
|
}
|
|
if (j !== last) {
|
|
device = `\\\\${firstPart}\\${path.substring(last, j)}`;
|
|
rootEnd = j;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
rootEnd = 1;
|
|
}
|
|
} else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) {
|
|
device = path.substring(0, 2);
|
|
rootEnd = 2;
|
|
if (len > 2 && isWindowsPathSeparator(path.charCodeAt(2))) {
|
|
isAbsolute = true;
|
|
rootEnd = 3;
|
|
}
|
|
}
|
|
let tail = rootEnd < len ? normalizeString(path.substring(rootEnd), !isAbsolute, "\\", isWindowsPathSeparator) : "";
|
|
if (tail.length === 0 && !isAbsolute) {
|
|
tail = ".";
|
|
}
|
|
if (tail.length > 0 && isWindowsPathSeparator(path.charCodeAt(len - 1))) {
|
|
tail += "\\";
|
|
}
|
|
if (device === void 0) {
|
|
return isAbsolute ? `\\${tail}` : tail;
|
|
}
|
|
return isAbsolute ? `${device}\\${tail}` : `${device}${tail}`;
|
|
};
|
|
exports.isAbsolute = function isAbsolute(path) {
|
|
validateString(path, "path");
|
|
const len = path.length;
|
|
if (len === 0) return false;
|
|
const code = path.charCodeAt(0);
|
|
return isWindowsPathSeparator(code) || len > 2 && isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON && isWindowsPathSeparator(path.charCodeAt(2));
|
|
};
|
|
exports.join = function join(...args) {
|
|
if (args.length === 0) return ".";
|
|
let joined;
|
|
let firstPart;
|
|
for (let i = 0; i < args.length; ++i) {
|
|
const arg = args[i];
|
|
validateString(arg, "path");
|
|
if (arg.length > 0) {
|
|
if (joined === void 0) joined = firstPart = arg;
|
|
else joined += `\\${arg}`;
|
|
}
|
|
}
|
|
if (joined === void 0) return ".";
|
|
let needsReplace = true;
|
|
let slashCount = 0;
|
|
if (isWindowsPathSeparator(firstPart.charCodeAt(0))) {
|
|
++slashCount;
|
|
const firstLen = firstPart.length;
|
|
if (firstLen > 1 && isWindowsPathSeparator(firstPart.charCodeAt(1))) {
|
|
++slashCount;
|
|
if (firstLen > 2) {
|
|
if (isWindowsPathSeparator(firstPart.charCodeAt(2))) {
|
|
++slashCount;
|
|
} else {
|
|
needsReplace = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (needsReplace) {
|
|
while (slashCount < joined.length && isWindowsPathSeparator(joined.charCodeAt(slashCount))) {
|
|
slashCount++;
|
|
}
|
|
if (slashCount >= 2) {
|
|
joined = `\\${joined.substring(slashCount)}`;
|
|
}
|
|
}
|
|
return exports.normalize(joined);
|
|
};
|
|
exports.relative = function relative(from, to) {
|
|
validateString(from, "from");
|
|
validateString(to, "to");
|
|
if (from === to) return "";
|
|
const fromOrig = exports.resolve(from);
|
|
const toOrig = exports.resolve(to);
|
|
if (fromOrig === toOrig) return "";
|
|
from = fromOrig.toLowerCase();
|
|
to = toOrig.toLowerCase();
|
|
if (from === to) return "";
|
|
let fromStart = 0;
|
|
while (fromStart < from.length && from.charCodeAt(fromStart) === CHAR_BACKWARD_SLASH) {
|
|
fromStart++;
|
|
}
|
|
let fromEnd = from.length;
|
|
while (fromEnd - 1 > fromStart && from.charCodeAt(fromEnd - 1) === CHAR_BACKWARD_SLASH) {
|
|
fromEnd--;
|
|
}
|
|
const fromLen = fromEnd - fromStart;
|
|
let toStart = 0;
|
|
while (toStart < to.length && to.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) {
|
|
toStart++;
|
|
}
|
|
let toEnd = to.length;
|
|
while (toEnd - 1 > toStart && to.charCodeAt(toEnd - 1) === CHAR_BACKWARD_SLASH) {
|
|
toEnd--;
|
|
}
|
|
const toLen = toEnd - toStart;
|
|
const length = fromLen < toLen ? fromLen : toLen;
|
|
let lastCommonSep = -1;
|
|
let i = 0;
|
|
for (; i < length; i++) {
|
|
const fromCode = from.charCodeAt(fromStart + i);
|
|
if (fromCode !== to.charCodeAt(toStart + i)) {
|
|
break;
|
|
} else if (fromCode === CHAR_BACKWARD_SLASH) {
|
|
lastCommonSep = i;
|
|
}
|
|
}
|
|
if (i !== length) {
|
|
if (lastCommonSep === -1) return toOrig;
|
|
} else {
|
|
if (toLen > length) {
|
|
if (to.charCodeAt(toStart + i) === CHAR_BACKWARD_SLASH) {
|
|
return toOrig.substring(toStart + i + 1);
|
|
}
|
|
if (i === 2) {
|
|
return toOrig.substring(toStart + i);
|
|
}
|
|
}
|
|
if (fromLen > length) {
|
|
if (from.charCodeAt(fromStart + i) === CHAR_BACKWARD_SLASH) {
|
|
lastCommonSep = i;
|
|
} else if (i === 2) {
|
|
lastCommonSep = 3;
|
|
}
|
|
}
|
|
if (lastCommonSep === -1) lastCommonSep = 0;
|
|
}
|
|
let out = "";
|
|
for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
|
|
if (i === fromEnd || from.charCodeAt(i) === CHAR_BACKWARD_SLASH) {
|
|
out += out.length === 0 ? ".." : "\\..";
|
|
}
|
|
}
|
|
toStart += lastCommonSep;
|
|
if (out.length > 0) {
|
|
return `${out}${toOrig.substring(toStart, toEnd)}`;
|
|
}
|
|
if (toOrig.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) {
|
|
++toStart;
|
|
}
|
|
return toOrig.substring(toStart, toEnd);
|
|
};
|
|
exports.toNamespacedPath = function toNamespacedPath(path) {
|
|
if (typeof path !== "string" || path.length === 0) return path;
|
|
const resolvedPath = exports.resolve(path);
|
|
if (resolvedPath.length <= 2) return path;
|
|
if (resolvedPath.charCodeAt(0) === CHAR_BACKWARD_SLASH) {
|
|
if (resolvedPath.charCodeAt(1) === CHAR_BACKWARD_SLASH) {
|
|
const code = resolvedPath.charCodeAt(2);
|
|
if (code !== CHAR_QUESTION_MARK && code !== CHAR_DOT) {
|
|
return `\\\\?\\UNC\\${resolvedPath.substring(2)}`;
|
|
}
|
|
}
|
|
} else if (isWindowsDeviceRoot(resolvedPath.charCodeAt(0)) && resolvedPath.charCodeAt(1) === CHAR_COLON && resolvedPath.charCodeAt(2) === CHAR_BACKWARD_SLASH) {
|
|
return `\\\\?\\${resolvedPath}`;
|
|
}
|
|
return path;
|
|
};
|
|
exports.dirname = function dirname(path) {
|
|
validateString(path, "path");
|
|
const len = path.length;
|
|
if (len === 0) return ".";
|
|
let rootEnd = -1;
|
|
let offset = 0;
|
|
const code = path.charCodeAt(0);
|
|
if (len === 1) {
|
|
return isWindowsPathSeparator(code) ? path : ".";
|
|
}
|
|
if (isWindowsPathSeparator(code)) {
|
|
rootEnd = offset = 1;
|
|
if (isWindowsPathSeparator(path.charCodeAt(1))) {
|
|
let j = 2;
|
|
let last = j;
|
|
while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) {
|
|
j++;
|
|
}
|
|
if (j < len && j !== last) {
|
|
last = j;
|
|
while (j < len && isWindowsPathSeparator(path.charCodeAt(j))) {
|
|
j++;
|
|
}
|
|
if (j < len && j !== last) {
|
|
last = j;
|
|
while (j < len && !isWindowsPathSeparator(path.charCodeAt(j))) {
|
|
j++;
|
|
}
|
|
if (j === len) {
|
|
return path;
|
|
}
|
|
if (j !== last) {
|
|
rootEnd = offset = j + 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else if (isWindowsDeviceRoot(code) && path.charCodeAt(1) === CHAR_COLON) {
|
|
rootEnd = len > 2 && isWindowsPathSeparator(path.charCodeAt(2)) ? 3 : 2;
|
|
offset = rootEnd;
|
|
}
|
|
let end = -1;
|
|
let matchedSlash = true;
|
|
for (let i = len - 1; i >= offset; --i) {
|
|
if (isWindowsPathSeparator(path.charCodeAt(i))) {
|
|
if (!matchedSlash) {
|
|
end = i;
|
|
break;
|
|
}
|
|
} else {
|
|
matchedSlash = false;
|
|
}
|
|
}
|
|
if (end === -1) {
|
|
if (rootEnd === -1) return ".";
|
|
end = rootEnd;
|
|
}
|
|
return path.substring(0, end);
|
|
};
|
|
exports.basename = function basename(path, suffix) {
|
|
if (suffix !== void 0) validateString(suffix, "suffix");
|
|
validateString(path, "path");
|
|
let start = 0;
|
|
let end = -1;
|
|
let matchedSlash = true;
|
|
if (path.length >= 2 && isWindowsDeviceRoot(path.charCodeAt(0)) && path.charCodeAt(1) === CHAR_COLON) {
|
|
start = 2;
|
|
}
|
|
if (suffix !== void 0 && suffix.length > 0 && suffix.length <= path.length) {
|
|
if (suffix === path) return "";
|
|
let extIdx = suffix.length - 1;
|
|
let firstNonSlashEnd = -1;
|
|
for (let i = path.length - 1; i >= start; --i) {
|
|
const code = path.charCodeAt(i);
|
|
if (isWindowsPathSeparator(code)) {
|
|
if (!matchedSlash) {
|
|
start = i + 1;
|
|
break;
|
|
}
|
|
} else {
|
|
if (firstNonSlashEnd === -1) {
|
|
matchedSlash = false;
|
|
firstNonSlashEnd = i + 1;
|
|
}
|
|
if (extIdx >= 0) {
|
|
if (code === suffix.charCodeAt(extIdx)) {
|
|
if (--extIdx === -1) {
|
|
end = i;
|
|
}
|
|
} else {
|
|
extIdx = -1;
|
|
end = firstNonSlashEnd;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (start === end) end = firstNonSlashEnd;
|
|
else if (end === -1) end = path.length;
|
|
return path.substring(start, end);
|
|
}
|
|
for (let i = path.length - 1; i >= start; --i) {
|
|
if (isWindowsPathSeparator(path.charCodeAt(i))) {
|
|
if (!matchedSlash) {
|
|
start = i + 1;
|
|
break;
|
|
}
|
|
} else if (end === -1) {
|
|
matchedSlash = false;
|
|
end = i + 1;
|
|
}
|
|
}
|
|
if (end === -1) return "";
|
|
return path.substring(start, end);
|
|
};
|
|
exports.extname = function extname(path) {
|
|
validateString(path, "path");
|
|
let start = 0;
|
|
let startDot = -1;
|
|
let startPart = 0;
|
|
let end = -1;
|
|
let matchedSlash = true;
|
|
let preDotState = 0;
|
|
if (path.length >= 2 && path.charCodeAt(1) === CHAR_COLON && isWindowsDeviceRoot(path.charCodeAt(0))) {
|
|
start = startPart = 2;
|
|
}
|
|
for (let i = path.length - 1; i >= start; --i) {
|
|
const code = path.charCodeAt(i);
|
|
if (isWindowsPathSeparator(code)) {
|
|
if (!matchedSlash) {
|
|
startPart = i + 1;
|
|
break;
|
|
}
|
|
continue;
|
|
}
|
|
if (end === -1) {
|
|
matchedSlash = false;
|
|
end = i + 1;
|
|
}
|
|
if (code === CHAR_DOT) {
|
|
if (startDot === -1) startDot = i;
|
|
else if (preDotState !== 1) preDotState = 1;
|
|
} else if (startDot !== -1) {
|
|
preDotState = -1;
|
|
}
|
|
}
|
|
if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
|
|
return "";
|
|
}
|
|
return path.substring(startDot, end);
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-path/index.js
|
|
var require_bare_path = __commonJS({
|
|
"../../node_modules/bare-path/index.js"(exports, module) {
|
|
if (Bare.platform === "win32") {
|
|
module.exports = require_win32();
|
|
} else {
|
|
module.exports = require_posix();
|
|
}
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-url/binding.js
|
|
var require_binding3 = __commonJS({
|
|
"../../node_modules/bare-url/binding.js"(exports, module) {
|
|
module.exports = __require.addon();
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-url/lib/errors.js
|
|
var require_errors = __commonJS({
|
|
"../../node_modules/bare-url/lib/errors.js"(exports, module) {
|
|
module.exports = class URLError extends Error {
|
|
constructor(msg, fn = URLError, code = fn.name) {
|
|
super(`${code}: ${msg}`);
|
|
this.code = code;
|
|
if (Error.captureStackTrace) Error.captureStackTrace(this, fn);
|
|
}
|
|
get name() {
|
|
return "URLError";
|
|
}
|
|
static INVALID_URL(msg, input) {
|
|
const err = new URLError(msg, URLError.INVALID_URL);
|
|
err.input = input;
|
|
return err;
|
|
}
|
|
static INVALID_URL_SCHEME(msg = "Invalid URL") {
|
|
return new URLError(msg, URLError.INVALID_URL_SCHEME);
|
|
}
|
|
static INVALID_FILE_URL_HOST(msg = "Invalid file: URL host") {
|
|
return new URLError(msg, URLError.INVALID_FILE_URL_HOST);
|
|
}
|
|
static INVALID_FILE_URL_PATH(msg = "Invalid file: URL path") {
|
|
return new URLError(msg, URLError.INVALID_FILE_URL_PATH);
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-url/lib/url-search-params.js
|
|
var require_url_search_params = __commonJS({
|
|
"../../node_modules/bare-url/lib/url-search-params.js"(exports, module) {
|
|
var kind = Symbol.for("bare.url.search-params.kind");
|
|
var URLSearchParams = class _URLSearchParams {
|
|
static _urls = /* @__PURE__ */ new WeakMap();
|
|
static get [kind]() {
|
|
return 0;
|
|
}
|
|
// https://url.spec.whatwg.org/#dom-urlsearchparams-urlsearchparams
|
|
constructor(init, url = null) {
|
|
this._params = null;
|
|
if (url) _URLSearchParams._urls.set(this, url);
|
|
if (typeof init === "string") {
|
|
this._parse(init);
|
|
} else {
|
|
this._params = /* @__PURE__ */ new Map();
|
|
if (init) {
|
|
for (const [name, value] of typeof init[Symbol.iterator] === "function" ? init : Object.entries(init)) {
|
|
this.append(name, value);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
get [kind]() {
|
|
return _URLSearchParams[kind];
|
|
}
|
|
// https://url.spec.whatwg.org/#dom-urlsearchparams-size
|
|
get size() {
|
|
let size = 0;
|
|
for (const values of this._params.values()) size += values.length;
|
|
return size;
|
|
}
|
|
// https://url.spec.whatwg.org/#dom-urlsearchparams-append
|
|
append(name, value = null) {
|
|
if (value === null) return;
|
|
let list = this._params.get(name);
|
|
if (list === void 0) {
|
|
list = [];
|
|
this._params.set(name, list);
|
|
}
|
|
list.push(value);
|
|
this._update();
|
|
}
|
|
// https://url.spec.whatwg.org/#dom-urlsearchparams-delete
|
|
delete(name, value = null) {
|
|
if (value === null) this._params.delete(name);
|
|
else {
|
|
let list = this._params.get(name);
|
|
if (list === void 0) return;
|
|
list = list.filter((found) => found !== value);
|
|
if (list.length === 0) this._params.delete(name);
|
|
else this._params.set(name, list);
|
|
}
|
|
this._update();
|
|
}
|
|
// https://url.spec.whatwg.org/#dom-urlsearchparams-get
|
|
get(name) {
|
|
const list = this._params.get(name);
|
|
if (list === void 0) return null;
|
|
return list[0];
|
|
}
|
|
// https://url.spec.whatwg.org/#dom-urlsearchparams-getall
|
|
getAll(name) {
|
|
const list = this._params.get(name);
|
|
if (list === void 0) return [];
|
|
return Array.from(list);
|
|
}
|
|
// https://url.spec.whatwg.org/#dom-urlsearchparams-has
|
|
has(name, value = null) {
|
|
const list = this._params.get(name);
|
|
if (list === void 0) return false;
|
|
if (value === null) return true;
|
|
return list.includes(value);
|
|
}
|
|
// https://url.spec.whatwg.org/#dom-urlsearchparams-set
|
|
set(name, value = null) {
|
|
if (value === null) this._params.delete(name);
|
|
else this._params.set(name, [value]);
|
|
this._update();
|
|
}
|
|
toString() {
|
|
return this._serialize();
|
|
}
|
|
toJSON() {
|
|
return [...this];
|
|
}
|
|
*[Symbol.iterator]() {
|
|
for (const [name, values] of this._params) {
|
|
for (const value of values) yield [name, value];
|
|
}
|
|
}
|
|
[Symbol.for("bare.inspect")]() {
|
|
const object = {
|
|
__proto__: { constructor: _URLSearchParams }
|
|
};
|
|
for (const [name, values] of this._params) {
|
|
if (values.length === 1) object[name] = values[0];
|
|
else object[name] = values;
|
|
}
|
|
return object;
|
|
}
|
|
// https://url.spec.whatwg.org/#concept-urlsearchparams-update
|
|
_update() {
|
|
const url = _URLSearchParams._urls.get(this);
|
|
if (url === void 0) return;
|
|
url.search = this._serialize();
|
|
}
|
|
// https://url.spec.whatwg.org/#concept-urlencoded-parser
|
|
_parse(input) {
|
|
const params = /* @__PURE__ */ new Map();
|
|
this._params = params;
|
|
const len = input.length;
|
|
let start = input.charCodeAt(0) === 63 ? 1 : 0;
|
|
while (start < len) {
|
|
let end = input.indexOf("&", start);
|
|
if (end === -1) end = len;
|
|
if (end !== start) {
|
|
let split = input.indexOf("=", start);
|
|
if (split === -1 || split > end) split = end;
|
|
const name = decode(input.slice(start, split));
|
|
const value = split === end ? "" : decode(input.slice(split + 1, end));
|
|
const list = params.get(name);
|
|
if (list === void 0) params.set(name, [value]);
|
|
else list.push(value);
|
|
}
|
|
start = end + 1;
|
|
}
|
|
}
|
|
// https://url.spec.whatwg.org/#concept-urlencoded-serializer
|
|
_serialize() {
|
|
let result = "";
|
|
let separator = "";
|
|
for (const [name, values] of this._params) {
|
|
const encoded = encode(String(name));
|
|
for (const value of values) {
|
|
result += separator + encoded + "=" + encode(String(value));
|
|
separator = "&";
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
};
|
|
module.exports = exports = URLSearchParams;
|
|
exports.isURLSearchParams = function isURLSearchParams(value) {
|
|
if (value instanceof URLSearchParams) return true;
|
|
return typeof value === "object" && value !== null && value[kind] === URLSearchParams[kind];
|
|
};
|
|
var unencoded = /^[\w*.-]*$/;
|
|
var spaced = /^[\w*. -]*$/;
|
|
var extra = /[!'()~]/;
|
|
var extraAll = /[!'()~]/g;
|
|
var escapes = {
|
|
"!": "%21",
|
|
"'": "%27",
|
|
"(": "%28",
|
|
")": "%29",
|
|
"~": "%7E"
|
|
};
|
|
var lone = /[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/g;
|
|
function encode(component) {
|
|
if (unencoded.test(component)) return component;
|
|
if (spaced.test(component)) return component.replaceAll(" ", "+");
|
|
let encoded;
|
|
try {
|
|
encoded = encodeURIComponent(component);
|
|
} catch {
|
|
encoded = encodeURIComponent(component.replace(lone, "\uFFFD"));
|
|
}
|
|
if (encoded.includes("%20")) encoded = encoded.replaceAll("%20", "+");
|
|
if (extra.test(encoded)) encoded = encoded.replace(extraAll, (match) => escapes[match]);
|
|
return encoded;
|
|
}
|
|
function decode(component) {
|
|
if (component.indexOf("+") !== -1) component = component.replaceAll("+", " ");
|
|
if (component.indexOf("%") === -1) return component;
|
|
return decodeURIComponent(component);
|
|
}
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-url/index.js
|
|
var require_bare_url = __commonJS({
|
|
"../../node_modules/bare-url/index.js"(exports, module) {
|
|
var path = require_bare_path();
|
|
var binding = require_binding3();
|
|
var errors = require_errors();
|
|
var URLSearchParams = require_url_search_params();
|
|
var kind = Symbol.for("bare.url.kind");
|
|
var isWindows = Bare.platform === "win32";
|
|
var components = new Uint32Array(8);
|
|
var unset = 4294967295;
|
|
var reserved = isWindows ? /[%#?\n\r\t]/ : /[%#?\n\r\t\\]/;
|
|
var URL2 = class _URL {
|
|
static get [kind]() {
|
|
return 0;
|
|
}
|
|
constructor(input, base, opts = {}) {
|
|
if (arguments.length === 0) throw errors.INVALID_URL();
|
|
input = String(input);
|
|
if (base !== void 0) base = String(base);
|
|
this._href = void 0;
|
|
this._schemeEnd = 0;
|
|
this._usernameEnd = 0;
|
|
this._hostStart = 0;
|
|
this._hostEnd = 0;
|
|
this._pathStart = 0;
|
|
this._queryStart = 0;
|
|
this._fragmentStart = 0;
|
|
this._params = null;
|
|
this._parse(input, base, opts.throw !== false);
|
|
}
|
|
get [kind]() {
|
|
return _URL[kind];
|
|
}
|
|
// https://url.spec.whatwg.org/#dom-url-href
|
|
get href() {
|
|
return this._href;
|
|
}
|
|
set href(value) {
|
|
this._update(value);
|
|
if (this._params) this._params._parse(this.search);
|
|
}
|
|
// https://url.spec.whatwg.org/#dom-url-protocol
|
|
get protocol() {
|
|
return this._slice(0, this._schemeEnd) + ":";
|
|
}
|
|
set protocol(value) {
|
|
this._update(this._replace(value.replace(/:+$/, ""), 0, this._schemeEnd));
|
|
}
|
|
// https://url.spec.whatwg.org/#dom-url-username
|
|
get username() {
|
|
return this._slice(this._schemeEnd + 3, this._usernameEnd);
|
|
}
|
|
set username(value) {
|
|
if (cannotHaveCredentialsOrPort(this)) {
|
|
return;
|
|
}
|
|
if (this.username === "") value += "@";
|
|
this._update(this._replace(value, this._schemeEnd + 3, this._usernameEnd));
|
|
}
|
|
// https://url.spec.whatwg.org/#dom-url-password
|
|
get password() {
|
|
return this._href.slice(
|
|
this._usernameEnd + 1,
|
|
this._hostStart - 1
|
|
/* @ */
|
|
);
|
|
}
|
|
set password(value) {
|
|
if (cannotHaveCredentialsOrPort(this)) {
|
|
return;
|
|
}
|
|
let start = this._usernameEnd + 1;
|
|
let end = this._hostStart - 1;
|
|
if (this.password === "") {
|
|
value = ":" + value;
|
|
start--;
|
|
}
|
|
if (this.username === "") {
|
|
value += "@";
|
|
end++;
|
|
}
|
|
this._update(this._replace(value, start, end));
|
|
}
|
|
// https://url.spec.whatwg.org/#dom-url-host
|
|
get host() {
|
|
return this._slice(this._hostStart, this._pathStart);
|
|
}
|
|
set host(value) {
|
|
if (hasOpaquePath(this)) {
|
|
return;
|
|
}
|
|
this._update(
|
|
this._replace(value, this._hostStart, value.includes(":") ? this._pathStart : this._hostEnd)
|
|
);
|
|
}
|
|
// https://url.spec.whatwg.org/#dom-url-hostname
|
|
get hostname() {
|
|
return this._slice(this._hostStart, this._hostEnd);
|
|
}
|
|
set hostname(value) {
|
|
if (hasOpaquePath(this)) {
|
|
return;
|
|
}
|
|
this._update(this._replace(value, this._hostStart, this._hostEnd));
|
|
}
|
|
// https://url.spec.whatwg.org/#dom-url-port
|
|
get port() {
|
|
return this._slice(this._hostEnd + 1, this._pathStart);
|
|
}
|
|
set port(value) {
|
|
if (cannotHaveCredentialsOrPort(this)) {
|
|
return;
|
|
}
|
|
let start = this._hostEnd + 1;
|
|
if (this.port === "") {
|
|
value = ":" + value;
|
|
start--;
|
|
}
|
|
this._update(this._replace(value, start, this._pathStart));
|
|
}
|
|
// https://url.spec.whatwg.org/#dom-url-pathname
|
|
get pathname() {
|
|
return this._slice(
|
|
this._pathStart,
|
|
this._queryStart - 1
|
|
/* ? */
|
|
);
|
|
}
|
|
set pathname(value) {
|
|
if (hasOpaquePath(this)) {
|
|
return;
|
|
}
|
|
if (value[0] !== "/" && value[0] !== "\\") {
|
|
value = "/" + value;
|
|
}
|
|
this._update(this._replace(
|
|
value,
|
|
this._pathStart,
|
|
this._queryStart - 1
|
|
/* ? */
|
|
));
|
|
}
|
|
// https://url.spec.whatwg.org/#dom-url-search
|
|
get search() {
|
|
return this._slice(
|
|
this._queryStart - 1,
|
|
this._fragmentStart - 1
|
|
/* # */
|
|
);
|
|
}
|
|
set search(value) {
|
|
if (value && value[0] !== "?") value = "?" + value;
|
|
this._update(
|
|
this._replace(
|
|
value,
|
|
this._queryStart - 1,
|
|
this._fragmentStart - 1
|
|
/* # */
|
|
)
|
|
);
|
|
if (this._params) this._params._parse(this.search);
|
|
}
|
|
// https://url.spec.whatwg.org/#dom-url-searchparams
|
|
get searchParams() {
|
|
if (this._params === null) {
|
|
this._params = new URLSearchParams(this.search, this);
|
|
}
|
|
return this._params;
|
|
}
|
|
// https://url.spec.whatwg.org/#dom-url-hash
|
|
get hash() {
|
|
return this._slice(
|
|
this._fragmentStart - 1
|
|
/* # */
|
|
);
|
|
}
|
|
set hash(value) {
|
|
if (value && value[0] !== "#") value = "#" + value;
|
|
this._update(this._replace(
|
|
value,
|
|
this._fragmentStart - 1
|
|
/* # */
|
|
));
|
|
}
|
|
toString() {
|
|
return this._href;
|
|
}
|
|
toJSON() {
|
|
return this._href;
|
|
}
|
|
[Symbol.for("bare.inspect")]() {
|
|
return {
|
|
__proto__: { constructor: _URL },
|
|
href: this.href,
|
|
protocol: this.protocol,
|
|
username: this.username,
|
|
password: this.password,
|
|
host: this.host,
|
|
hostname: this.hostname,
|
|
port: this.port,
|
|
pathname: this.pathname,
|
|
search: this.search,
|
|
searchParams: this.searchParams,
|
|
hash: this.hash
|
|
};
|
|
}
|
|
_slice(start, end = this._href.length) {
|
|
return this._href.slice(start, end);
|
|
}
|
|
_replace(replacement, start, end = this._href.length) {
|
|
return this._slice(0, start) + replacement + this._slice(end);
|
|
}
|
|
_parse(input, base, shouldThrow) {
|
|
let href;
|
|
try {
|
|
href = binding.parse(input, base || null, components, shouldThrow);
|
|
} catch (err) {
|
|
if (err instanceof TypeError) throw err;
|
|
throw errors.INVALID_URL(`Invalid URL '${input}'`, input);
|
|
}
|
|
if (href === void 0) return;
|
|
this._href = href;
|
|
this._schemeEnd = components[0];
|
|
this._usernameEnd = components[1];
|
|
this._hostStart = components[2];
|
|
this._hostEnd = components[3];
|
|
this._pathStart = components[5];
|
|
const queryStart = components[6];
|
|
const fragmentStart = components[7];
|
|
const end = href.length + 1;
|
|
this._queryStart = queryStart === unset ? end : queryStart;
|
|
this._fragmentStart = fragmentStart === unset ? end : fragmentStart;
|
|
}
|
|
_update(input) {
|
|
try {
|
|
this._parse(input, null, true);
|
|
} catch (err) {
|
|
if (err instanceof TypeError) throw err;
|
|
}
|
|
}
|
|
};
|
|
module.exports = exports = URL2;
|
|
function hasOpaquePath(url) {
|
|
return url.pathname[0] !== "/";
|
|
}
|
|
function cannotHaveCredentialsOrPort(url) {
|
|
return url.hostname === "" || url.protocol === "file:";
|
|
}
|
|
exports.URL = URL2;
|
|
exports.URLSearchParams = URLSearchParams;
|
|
exports.errors = errors;
|
|
exports.isURL = function isURL(value) {
|
|
if (value instanceof URL2) return true;
|
|
return typeof value === "object" && value !== null && value[kind] === URL2[kind];
|
|
};
|
|
exports.isURLSearchParams = URLSearchParams.isURLSearchParams;
|
|
exports.parse = function parse(input, base) {
|
|
const url = new URL2(input, base, { throw: false });
|
|
return url._href ? url : null;
|
|
};
|
|
exports.canParse = function canParse(input, base) {
|
|
return binding.canParse(String(input), base ? String(base) : null);
|
|
};
|
|
exports.fileURLToPath = function fileURLToPath(url) {
|
|
if (typeof url === "string") {
|
|
url = new URL2(url);
|
|
}
|
|
if (url.protocol !== "file:") {
|
|
throw errors.INVALID_URL_SCHEME("The URL must use the file: protocol");
|
|
}
|
|
if (!isWindows && url.hostname) {
|
|
throw errors.INVALID_FILE_URL_HOST("The file: URL host must be 'localhost' or empty");
|
|
}
|
|
const encoded = url.pathname;
|
|
const hasEncoded = encoded.includes("%");
|
|
if (hasEncoded) {
|
|
if (isWindows) {
|
|
if (/%2f|%5c/i.test(encoded)) {
|
|
throw errors.INVALID_FILE_URL_PATH(
|
|
"The file: URL path must not include encoded \\ or / characters"
|
|
);
|
|
}
|
|
} else if (/%2f/i.test(encoded)) {
|
|
throw errors.INVALID_FILE_URL_PATH("The file: URL path must not include encoded / characters");
|
|
}
|
|
if (/%00/i.test(encoded)) {
|
|
throw errors.INVALID_FILE_URL_PATH(
|
|
"The file: URL path must not include encoded NUL characters"
|
|
);
|
|
}
|
|
}
|
|
const pathname = path.normalize(hasEncoded ? decodeURIComponent(encoded) : encoded);
|
|
if (isWindows) {
|
|
if (url.hostname) return "\\\\" + url.hostname + pathname;
|
|
const letter = pathname.charCodeAt(1) | 32;
|
|
if (letter < 97 || letter > 122 || pathname.charCodeAt(2) !== 58) {
|
|
throw errors.INVALID_FILE_URL_PATH("The file: URL path must be absolute");
|
|
}
|
|
return pathname.slice(1);
|
|
}
|
|
return pathname;
|
|
};
|
|
exports.pathToFileURL = function pathToFileURL(pathname) {
|
|
let resolved = path.resolve(pathname);
|
|
if (pathname[pathname.length - 1] === "/") {
|
|
resolved += "/";
|
|
} else if (isWindows && pathname[pathname.length - 1] === "\\") {
|
|
resolved += "\\";
|
|
}
|
|
if (reserved.test(resolved)) {
|
|
resolved = resolved.replaceAll("%", "%25").replaceAll("#", "%23").replaceAll("?", "%3f").replaceAll("\n", "%0a").replaceAll("\r", "%0d").replaceAll(" ", "%09");
|
|
if (!isWindows) {
|
|
resolved = resolved.replaceAll("\\", "%5c");
|
|
}
|
|
}
|
|
return new URL2("file:" + resolved);
|
|
};
|
|
exports.format = function format(parts) {
|
|
const { protocol, auth, host, hostname, port, pathname, search, query, hash, slashes } = parts;
|
|
let result = "";
|
|
if (typeof protocol === "string") {
|
|
result += protocol;
|
|
if (protocol[protocol.length - 1] !== ":") {
|
|
result += ":";
|
|
}
|
|
if (slashes === true || /https?|ftp|gopher|file/.test(protocol)) {
|
|
result += "//";
|
|
}
|
|
}
|
|
if (typeof auth === "string") {
|
|
if (host || hostname) result += auth + "@";
|
|
}
|
|
if (typeof host === "string") result += host;
|
|
else {
|
|
result += hostname;
|
|
if (port) result += ":" + port;
|
|
}
|
|
if (typeof pathname === "string" && pathname !== "") {
|
|
if (pathname[0] !== "/") result += "/";
|
|
result += pathname;
|
|
}
|
|
if (typeof search === "string") {
|
|
if (search[0] !== "?") result += "?";
|
|
result += search;
|
|
} else if (typeof query === "object" && query !== null) {
|
|
result += "?" + new URLSearchParams(query);
|
|
}
|
|
if (typeof hash === "string") {
|
|
if (hash[0] !== "#") result += "#";
|
|
result += hash;
|
|
}
|
|
return result;
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-buffer/binding.js
|
|
var require_binding4 = __commonJS({
|
|
"../../node_modules/bare-buffer/binding.js"(exports, module) {
|
|
module.exports = __require.addon();
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-buffer/lib/constants.js
|
|
var require_constants2 = __commonJS({
|
|
"../../node_modules/bare-buffer/lib/constants.js"(exports, module) {
|
|
var binding = require_binding4();
|
|
module.exports = binding.constants;
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-buffer/lib/ascii.js
|
|
var require_ascii = __commonJS({
|
|
"../../node_modules/bare-buffer/lib/ascii.js"(exports) {
|
|
var binding = require_binding4();
|
|
exports.byteLength = function byteLength(string) {
|
|
return string.length;
|
|
};
|
|
exports.toString = function toString(buffer, start = 0, end = buffer.byteLength) {
|
|
const offset = buffer.byteOffset + start;
|
|
const len = end - start;
|
|
if (binding.validateAscii(buffer.buffer, offset, len)) {
|
|
return binding.toStringLatin1(buffer.buffer, offset, len);
|
|
}
|
|
let result = "";
|
|
for (let i = start; i < end; i++) {
|
|
result += String.fromCharCode(buffer[i] & 127);
|
|
}
|
|
return result;
|
|
};
|
|
exports.write = function write(buffer, string, start = 0, end = buffer.byteLength) {
|
|
return binding.writeLatin1(buffer.buffer, buffer.byteOffset + start, end - start, string);
|
|
};
|
|
exports.validate = function validate(buffer) {
|
|
return binding.validateAscii(buffer.buffer, buffer.byteOffset, buffer.byteLength);
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-buffer/lib/base64.js
|
|
var require_base64 = __commonJS({
|
|
"../../node_modules/bare-buffer/lib/base64.js"(exports) {
|
|
var binding = require_binding4();
|
|
exports.byteLength = function byteLength(string) {
|
|
let len = string.length;
|
|
if (string.charCodeAt(len - 1) === 61) len--;
|
|
if (len > 1 && string.charCodeAt(len - 1) === 61) len--;
|
|
return len * 3 >>> 2;
|
|
};
|
|
exports.toString = function toString(buffer, start = 0, end = buffer.byteLength) {
|
|
return binding.toStringBase64(buffer.buffer, buffer.byteOffset + start, end - start);
|
|
};
|
|
exports.write = function write(buffer, string, start = 0, end = buffer.byteLength) {
|
|
return binding.writeBase64(buffer.buffer, buffer.byteOffset + start, end - start, string);
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-buffer/lib/base64url.js
|
|
var require_base64url = __commonJS({
|
|
"../../node_modules/bare-buffer/lib/base64url.js"(exports) {
|
|
var binding = require_binding4();
|
|
exports.byteLength = function byteLength(string) {
|
|
let len = string.length;
|
|
if (string.charCodeAt(len - 1) === 61) len--;
|
|
if (len > 1 && string.charCodeAt(len - 1) === 61) len--;
|
|
return len * 3 >>> 2;
|
|
};
|
|
exports.toString = function toString(buffer, start = 0, end = buffer.byteLength) {
|
|
return binding.toStringBase64URL(buffer.buffer, buffer.byteOffset + start, end - start);
|
|
};
|
|
exports.write = function write(buffer, string, start = 0, end = buffer.byteLength) {
|
|
return binding.writeBase64(buffer.buffer, buffer.byteOffset + start, end - start, string);
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-buffer/lib/hex.js
|
|
var require_hex = __commonJS({
|
|
"../../node_modules/bare-buffer/lib/hex.js"(exports) {
|
|
var binding = require_binding4();
|
|
exports.byteLength = function byteLength(string) {
|
|
return string.length >>> 1;
|
|
};
|
|
exports.toString = function toString(buffer, start = 0, end = buffer.byteLength) {
|
|
return binding.toStringHex(buffer.buffer, buffer.byteOffset + start, end - start);
|
|
};
|
|
exports.write = function write(buffer, string, start = 0, end = buffer.byteLength) {
|
|
return binding.writeHex(buffer.buffer, buffer.byteOffset + start, end - start, string);
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-buffer/lib/utf8.js
|
|
var require_utf8 = __commonJS({
|
|
"../../node_modules/bare-buffer/lib/utf8.js"(exports) {
|
|
var binding = require_binding4();
|
|
exports.byteLength = function byteLength(string) {
|
|
return binding.byteLengthUTF8(string);
|
|
};
|
|
exports.toString = function toString(buffer, start = 0, end = buffer.byteLength) {
|
|
return binding.toStringUTF8(buffer.buffer, buffer.byteOffset + start, end - start);
|
|
};
|
|
exports.write = function write(buffer, string, start = 0, end = buffer.byteLength) {
|
|
return binding.writeUTF8(buffer.buffer, buffer.byteOffset + start, end - start, string);
|
|
};
|
|
exports.validate = function validate(buffer) {
|
|
return binding.validateUTF8(buffer.buffer, buffer.byteOffset, buffer.byteLength);
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-buffer/lib/utf16le.js
|
|
var require_utf16le = __commonJS({
|
|
"../../node_modules/bare-buffer/lib/utf16le.js"(exports) {
|
|
var binding = require_binding4();
|
|
exports.byteLength = function byteLength(string) {
|
|
return string.length * 2;
|
|
};
|
|
exports.toString = function toString(buffer, start = 0, end = buffer.byteLength) {
|
|
return binding.toStringUTF16LE(buffer.buffer, buffer.byteOffset + start, end - start);
|
|
};
|
|
exports.write = function write(buffer, string, start = 0, end = buffer.byteLength) {
|
|
return binding.writeUTF16LE(buffer.buffer, buffer.byteOffset + start, end - start, string);
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-buffer/lib/latin1.js
|
|
var require_latin1 = __commonJS({
|
|
"../../node_modules/bare-buffer/lib/latin1.js"(exports) {
|
|
var binding = require_binding4();
|
|
exports.byteLength = function byteLength(string) {
|
|
return string.length;
|
|
};
|
|
exports.toString = function toString(buffer, start = 0, end = buffer.byteLength) {
|
|
return binding.toStringLatin1(buffer.buffer, buffer.byteOffset + start, end - start);
|
|
};
|
|
exports.write = function write(buffer, string, start = 0, end = buffer.byteLength) {
|
|
return binding.writeLatin1(buffer.buffer, buffer.byteOffset + start, end - start, string);
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-buffer/index.js
|
|
var require_bare_buffer = __commonJS({
|
|
"../../node_modules/bare-buffer/index.js"(exports, module) {
|
|
var constants = require_constants2();
|
|
var ascii = require_ascii();
|
|
var base64 = require_base64();
|
|
var base64url = require_base64url();
|
|
var hex = require_hex();
|
|
var utf8 = require_utf8();
|
|
var utf16le = require_utf16le();
|
|
var latin1 = require_latin1();
|
|
var binding = require_binding4();
|
|
var kind = Symbol.for("bare.buffer.kind");
|
|
var SWAP_MIN_LENGTH = 128;
|
|
var poolSize = 65536;
|
|
var pool = null;
|
|
var poolLength = 0;
|
|
var poolOffset = 0;
|
|
var Buffer2 = class _Buffer extends Uint8Array {
|
|
static get [kind]() {
|
|
return 0;
|
|
}
|
|
static get poolSize() {
|
|
return poolSize;
|
|
}
|
|
static set poolSize(value) {
|
|
poolSize = Math.max(0, value);
|
|
}
|
|
constructor(arrayBuffer, offset, length, opts = {}) {
|
|
if (typeof arrayBuffer === "number") {
|
|
opts = offset || {};
|
|
const { uninitialized = false } = opts;
|
|
offset = 0;
|
|
length = arrayBuffer;
|
|
if (Number.isNaN(length) || length < 0 || length > constants.MAX_LENGTH) {
|
|
throw new RangeError(`Buffer length must be between 0 and ${constants.MAX_LENGTH}`);
|
|
}
|
|
arrayBuffer = uninitialized ? binding.allocUnsafe(length) : binding.alloc(length);
|
|
} else {
|
|
if (length > constants.MAX_LENGTH) {
|
|
throw new RangeError(`Buffer length must be at most ${constants.MAX_LENGTH}`);
|
|
}
|
|
if (typeof offset === "object" && offset !== null) {
|
|
opts = offset;
|
|
offset = 0;
|
|
length = arrayBuffer.byteLength;
|
|
} else if (typeof length === "object" && length !== null) {
|
|
opts = length;
|
|
length = arrayBuffer.byteLength - offset;
|
|
}
|
|
}
|
|
super(arrayBuffer, offset, length);
|
|
}
|
|
get [kind]() {
|
|
return _Buffer[kind];
|
|
}
|
|
copy(target, targetStart = 0, sourceStart = 0, sourceEnd = this.byteLength) {
|
|
const source = this;
|
|
if (targetStart < 0) targetStart = 0;
|
|
if (targetStart >= target.byteLength) return 0;
|
|
const targetLength = target.byteLength - targetStart;
|
|
if (sourceStart < 0) sourceStart = 0;
|
|
if (sourceStart >= source.byteLength) return 0;
|
|
if (sourceEnd <= sourceStart) return 0;
|
|
if (sourceEnd > source.byteLength) sourceEnd = source.byteLength;
|
|
if (sourceEnd - sourceStart > targetLength) {
|
|
sourceEnd = sourceStart + targetLength;
|
|
}
|
|
const sourceLength = sourceEnd - sourceStart;
|
|
if (source === target) {
|
|
target.copyWithin(targetStart, sourceStart, sourceEnd);
|
|
} else if (sourceStart === 0 && sourceEnd === source.byteLength) {
|
|
target.set(source, targetStart);
|
|
} else {
|
|
target.set(
|
|
new Uint8Array(source.buffer, source.byteOffset + sourceStart, sourceLength),
|
|
targetStart
|
|
);
|
|
}
|
|
return sourceLength;
|
|
}
|
|
equals(target) {
|
|
const source = this;
|
|
if (source === target) return true;
|
|
if (source.byteLength !== target.byteLength) return false;
|
|
return binding.compare(
|
|
source.buffer,
|
|
source.byteOffset,
|
|
source.byteLength,
|
|
target.buffer,
|
|
target.byteOffset,
|
|
target.byteLength
|
|
) === 0;
|
|
}
|
|
compare(target, targetStart = 0, targetEnd = target.byteLength, sourceStart = 0, sourceEnd = this.byteLength) {
|
|
const source = this;
|
|
if (source === target) return 0;
|
|
if (arguments.length === 1) {
|
|
targetStart = 0;
|
|
targetEnd = target.byteLength;
|
|
sourceStart = 0;
|
|
sourceEnd = source.byteLength;
|
|
} else {
|
|
if (targetStart < 0) targetStart = 0;
|
|
if (targetStart > target.byteLength) targetStart = target.byteLength;
|
|
if (targetEnd < targetStart) targetEnd = targetStart;
|
|
if (targetEnd > target.byteLength) targetEnd = target.byteLength;
|
|
if (sourceStart < 0) sourceStart = 0;
|
|
if (sourceStart > source.byteLength) sourceStart = source.byteLength;
|
|
if (sourceEnd < sourceStart) sourceEnd = sourceStart;
|
|
if (sourceEnd > source.byteLength) sourceEnd = source.byteLength;
|
|
}
|
|
return binding.compare(
|
|
source.buffer,
|
|
source.byteOffset + sourceStart,
|
|
sourceEnd - sourceStart,
|
|
target.buffer,
|
|
target.byteOffset + targetStart,
|
|
targetEnd - targetStart
|
|
);
|
|
}
|
|
fill(value, offset = 0, end = this.byteLength, encoding = "utf8") {
|
|
if (typeof value === "string") {
|
|
if (typeof offset === "string") {
|
|
encoding = offset;
|
|
offset = 0;
|
|
end = this.byteLength;
|
|
} else if (typeof end === "string") {
|
|
encoding = end;
|
|
end = this.byteLength;
|
|
}
|
|
} else if (typeof value === "number") {
|
|
value = value & 255;
|
|
} else if (typeof value === "boolean") {
|
|
value = +value;
|
|
}
|
|
if (offset < 0) offset = 0;
|
|
if (offset >= this.byteLength) return this;
|
|
if (end <= offset) return this;
|
|
if (end > this.byteLength) end = this.byteLength;
|
|
if (typeof value === "number") return super.fill(value, offset, end);
|
|
if (typeof value === "string") value = exports.from(value, encoding);
|
|
const length = value.byteLength;
|
|
if (length === 0) return super.fill(0, offset, end);
|
|
if (length === 1) return super.fill(value[0], offset, end);
|
|
return fillPattern(this, value, length, offset, end);
|
|
}
|
|
includes(value, offset, encoding) {
|
|
return this.indexOf(value, offset, encoding) !== -1;
|
|
}
|
|
indexOf(value, offset = 0, encoding) {
|
|
if (typeof value === "boolean") value = +value;
|
|
if (typeof value === "number") {
|
|
return super.indexOf(value & 255, offset);
|
|
}
|
|
return bidirectionalIndexOf(
|
|
this,
|
|
value,
|
|
offset,
|
|
encoding,
|
|
true
|
|
/* first */
|
|
);
|
|
}
|
|
lastIndexOf(value, offset = this.byteLength - 1, encoding) {
|
|
if (typeof value === "boolean") value = +value;
|
|
if (typeof value === "number") {
|
|
return super.lastIndexOf(value & 255, offset);
|
|
}
|
|
return bidirectionalIndexOf(
|
|
this,
|
|
value,
|
|
offset,
|
|
encoding,
|
|
false
|
|
/* last */
|
|
);
|
|
}
|
|
swap16() {
|
|
const length = this.byteLength;
|
|
if (length % 2 !== 0) {
|
|
throw new RangeError("Buffer size must be a multiple of 16-bits");
|
|
}
|
|
if (length < SWAP_MIN_LENGTH) {
|
|
for (let i = 0; i < length; i += 2) swap(this, i, i + 1);
|
|
} else {
|
|
binding.swap16(this.buffer, this.byteOffset, length);
|
|
}
|
|
return this;
|
|
}
|
|
swap32() {
|
|
const length = this.byteLength;
|
|
if (length % 4 !== 0) {
|
|
throw new RangeError("Buffer size must be a multiple of 32-bits");
|
|
}
|
|
if (length < SWAP_MIN_LENGTH) {
|
|
for (let i = 0; i < length; i += 4) {
|
|
swap(this, i, i + 3);
|
|
swap(this, i + 1, i + 2);
|
|
}
|
|
} else {
|
|
binding.swap32(this.buffer, this.byteOffset, length);
|
|
}
|
|
return this;
|
|
}
|
|
swap64() {
|
|
const length = this.byteLength;
|
|
if (length % 8 !== 0) {
|
|
throw new RangeError("Buffer size must be a multiple of 64-bits");
|
|
}
|
|
if (length < SWAP_MIN_LENGTH) {
|
|
for (let i = 0; i < length; i += 8) {
|
|
swap(this, i, i + 7);
|
|
swap(this, i + 1, i + 6);
|
|
swap(this, i + 2, i + 5);
|
|
swap(this, i + 3, i + 4);
|
|
}
|
|
} else {
|
|
binding.swap64(this.buffer, this.byteOffset, length);
|
|
}
|
|
return this;
|
|
}
|
|
toString(encoding = "utf8", start = 0, end = this.byteLength) {
|
|
if (arguments.length === 0) return utf8.toString(this);
|
|
if (arguments.length === 1) return codecFor(encoding).toString(this);
|
|
if (start < 0) start = 0;
|
|
if (start >= this.byteLength) return "";
|
|
if (end <= start) return "";
|
|
if (end > this.byteLength) end = this.byteLength;
|
|
return codecFor(encoding).toString(this, start, end);
|
|
}
|
|
toJSON() {
|
|
const length = this.byteLength;
|
|
const data = new Array(length);
|
|
for (let i = 0; i < length; i++) data[i] = this[i];
|
|
return data;
|
|
}
|
|
write(string, offset = 0, length = this.byteLength - offset, encoding = "utf8") {
|
|
if (arguments.length === 1) return utf8.write(this, string);
|
|
if (typeof offset === "string") {
|
|
encoding = offset;
|
|
offset = 0;
|
|
length = this.byteLength;
|
|
} else if (typeof length === "string") {
|
|
encoding = length;
|
|
length = this.byteLength - offset;
|
|
}
|
|
length = Math.min(length, exports.byteLength(string, encoding));
|
|
let start = offset;
|
|
if (start < 0) start = 0;
|
|
if (start >= this.byteLength) return 0;
|
|
let end = offset + length;
|
|
if (end <= start) return 0;
|
|
if (end > this.byteLength) end = this.byteLength;
|
|
return codecFor(encoding).write(this, string, start, end);
|
|
}
|
|
readBigInt64BE(offset = 0) {
|
|
if (!Number.isInteger(offset)) offsetError(offset);
|
|
return viewOf(this).getBigInt64(offset, false);
|
|
}
|
|
readBigInt64LE(offset = 0) {
|
|
if (!Number.isInteger(offset)) offsetError(offset);
|
|
return viewOf(this).getBigInt64(offset, true);
|
|
}
|
|
readBigUint64BE(offset = 0) {
|
|
if (!Number.isInteger(offset)) offsetError(offset);
|
|
return viewOf(this).getBigUint64(offset, false);
|
|
}
|
|
readBigUint64LE(offset = 0) {
|
|
if (!Number.isInteger(offset)) offsetError(offset);
|
|
return viewOf(this).getBigUint64(offset, true);
|
|
}
|
|
readDoubleBE(offset = 0) {
|
|
if (!Number.isInteger(offset)) offsetError(offset);
|
|
return viewOf(this).getFloat64(offset, false);
|
|
}
|
|
readDoubleLE(offset = 0) {
|
|
if (!Number.isInteger(offset)) offsetError(offset);
|
|
return viewOf(this).getFloat64(offset, true);
|
|
}
|
|
readFloatBE(offset = 0) {
|
|
if (!Number.isInteger(offset)) offsetError(offset);
|
|
return viewOf(this).getFloat32(offset, false);
|
|
}
|
|
readFloatLE(offset = 0) {
|
|
if (!Number.isInteger(offset)) offsetError(offset);
|
|
return viewOf(this).getFloat32(offset, true);
|
|
}
|
|
readInt8(offset = 0) {
|
|
if (!Number.isInteger(offset)) offsetError(offset);
|
|
const value = this[offset];
|
|
if (value === void 0) boundsError();
|
|
return value << 24 >> 24;
|
|
}
|
|
readInt16BE(offset = 0) {
|
|
if (!Number.isInteger(offset)) offsetError(offset);
|
|
const first = this[offset];
|
|
const last = this[offset + 1];
|
|
if (first === void 0 || last === void 0) boundsError();
|
|
return (first << 8 | last) << 16 >> 16;
|
|
}
|
|
readInt16LE(offset = 0) {
|
|
if (!Number.isInteger(offset)) offsetError(offset);
|
|
const first = this[offset];
|
|
const last = this[offset + 1];
|
|
if (first === void 0 || last === void 0) boundsError();
|
|
return (last << 8 | first) << 16 >> 16;
|
|
}
|
|
readInt32BE(offset = 0) {
|
|
if (!Number.isInteger(offset)) offsetError(offset);
|
|
const first = this[offset];
|
|
const last = this[offset + 3];
|
|
if (first === void 0 || last === void 0) boundsError();
|
|
return first << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | last;
|
|
}
|
|
readInt32LE(offset = 0) {
|
|
if (!Number.isInteger(offset)) offsetError(offset);
|
|
const first = this[offset];
|
|
const last = this[offset + 3];
|
|
if (first === void 0 || last === void 0) boundsError();
|
|
return first | this[offset + 1] << 8 | this[offset + 2] << 16 | last << 24;
|
|
}
|
|
readIntBE(offset, byteLength) {
|
|
if (!Number.isInteger(offset)) offsetError(offset);
|
|
if (byteLength === 6) return readInt48BE(this, offset);
|
|
if (byteLength === 5) return readInt40BE(this, offset);
|
|
if (byteLength === 3) return readInt24BE(this, offset);
|
|
if (byteLength === 4) return this.readInt32BE(offset);
|
|
if (byteLength === 2) return this.readInt16BE(offset);
|
|
if (byteLength === 1) return this.readInt8(offset);
|
|
throw new RangeError(`Byte length must be between 1 and 6`);
|
|
}
|
|
readIntLE(offset, byteLength) {
|
|
if (!Number.isInteger(offset)) offsetError(offset);
|
|
if (byteLength === 6) return readInt48LE(this, offset);
|
|
if (byteLength === 5) return readInt40LE(this, offset);
|
|
if (byteLength === 3) return readInt24LE(this, offset);
|
|
if (byteLength === 4) return this.readInt32LE(offset);
|
|
if (byteLength === 2) return this.readInt16LE(offset);
|
|
if (byteLength === 1) return this.readInt8(offset);
|
|
throw new RangeError(`Byte length must be between 1 and 6`);
|
|
}
|
|
readUint8(offset = 0) {
|
|
if (!Number.isInteger(offset)) offsetError(offset);
|
|
const value = this[offset];
|
|
if (value === void 0) boundsError();
|
|
return value;
|
|
}
|
|
readUint16BE(offset = 0) {
|
|
if (!Number.isInteger(offset)) offsetError(offset);
|
|
const first = this[offset];
|
|
const last = this[offset + 1];
|
|
if (first === void 0 || last === void 0) boundsError();
|
|
return first << 8 | last;
|
|
}
|
|
readUint16LE(offset = 0) {
|
|
if (!Number.isInteger(offset)) offsetError(offset);
|
|
const first = this[offset];
|
|
const last = this[offset + 1];
|
|
if (first === void 0 || last === void 0) boundsError();
|
|
return last << 8 | first;
|
|
}
|
|
readUint32BE(offset = 0) {
|
|
if (!Number.isInteger(offset)) offsetError(offset);
|
|
const first = this[offset];
|
|
const last = this[offset + 3];
|
|
if (first === void 0 || last === void 0) boundsError();
|
|
return first * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | last);
|
|
}
|
|
readUint32LE(offset = 0) {
|
|
if (!Number.isInteger(offset)) offsetError(offset);
|
|
const first = this[offset];
|
|
const last = this[offset + 3];
|
|
if (first === void 0 || last === void 0) boundsError();
|
|
return last * 16777216 + (this[offset + 2] << 16 | this[offset + 1] << 8 | first);
|
|
}
|
|
readUintBE(offset, byteLength) {
|
|
if (!Number.isInteger(offset)) offsetError(offset);
|
|
if (byteLength === 6) return readUint48BE(this, offset);
|
|
if (byteLength === 5) return readUint40BE(this, offset);
|
|
if (byteLength === 3) return readUint24BE(this, offset);
|
|
if (byteLength === 4) return this.readUint32BE(offset);
|
|
if (byteLength === 2) return this.readUint16BE(offset);
|
|
if (byteLength === 1) return this.readUint8(offset);
|
|
throw new RangeError(`Byte length must be between 1 and 6`);
|
|
}
|
|
readUintLE(offset, byteLength) {
|
|
if (!Number.isInteger(offset)) offsetError(offset);
|
|
if (byteLength === 6) return readUint48LE(this, offset);
|
|
if (byteLength === 5) return readUint40LE(this, offset);
|
|
if (byteLength === 3) return readUint24LE(this, offset);
|
|
if (byteLength === 4) return this.readUint32LE(offset);
|
|
if (byteLength === 2) return this.readUint16LE(offset);
|
|
if (byteLength === 1) return this.readUint8(offset);
|
|
throw new RangeError(`Byte length must be between 1 and 6`);
|
|
}
|
|
writeBigInt64BE(value, offset = 0) {
|
|
if (!Number.isInteger(offset)) offsetError(offset);
|
|
viewOf(this).setBigInt64(offset, value, false);
|
|
return offset + 8;
|
|
}
|
|
writeBigInt64LE(value, offset = 0) {
|
|
if (!Number.isInteger(offset)) offsetError(offset);
|
|
viewOf(this).setBigInt64(offset, value, true);
|
|
return offset + 8;
|
|
}
|
|
writeBigUint64BE(value, offset = 0) {
|
|
if (!Number.isInteger(offset)) offsetError(offset);
|
|
viewOf(this).setBigUint64(offset, value, false);
|
|
return offset + 8;
|
|
}
|
|
writeBigUint64LE(value, offset = 0) {
|
|
if (!Number.isInteger(offset)) offsetError(offset);
|
|
viewOf(this).setBigUint64(offset, value, true);
|
|
return offset + 8;
|
|
}
|
|
writeDoubleBE(value, offset = 0) {
|
|
if (!Number.isInteger(offset)) offsetError(offset);
|
|
viewOf(this).setFloat64(offset, value, false);
|
|
return offset + 8;
|
|
}
|
|
writeDoubleLE(value, offset = 0) {
|
|
if (!Number.isInteger(offset)) offsetError(offset);
|
|
viewOf(this).setFloat64(offset, value, true);
|
|
return offset + 8;
|
|
}
|
|
writeFloatBE(value, offset = 0) {
|
|
if (!Number.isInteger(offset)) offsetError(offset);
|
|
viewOf(this).setFloat32(offset, value, false);
|
|
return offset + 4;
|
|
}
|
|
writeFloatLE(value, offset = 0) {
|
|
if (!Number.isInteger(offset)) offsetError(offset);
|
|
viewOf(this).setFloat32(offset, value, true);
|
|
return offset + 4;
|
|
}
|
|
writeInt8(value, offset = 0) {
|
|
return this.writeUint8(value, offset);
|
|
}
|
|
writeInt16BE(value, offset = 0) {
|
|
return this.writeUint16BE(value, offset);
|
|
}
|
|
writeInt16LE(value, offset = 0) {
|
|
return this.writeUint16LE(value, offset);
|
|
}
|
|
writeInt32BE(value, offset = 0) {
|
|
return this.writeUint32BE(value, offset);
|
|
}
|
|
writeInt32LE(value, offset = 0) {
|
|
return this.writeUint32LE(value, offset);
|
|
}
|
|
writeIntBE(value, offset, byteLength) {
|
|
if (!Number.isInteger(offset)) offsetError(offset);
|
|
if (byteLength === 6) return writeInt48BE(this, value, offset);
|
|
if (byteLength === 5) return writeInt40BE(this, value, offset);
|
|
if (byteLength === 3) return writeInt24BE(this, value, offset);
|
|
if (byteLength === 4) return this.writeInt32BE(value, offset);
|
|
if (byteLength === 2) return this.writeInt16BE(value, offset);
|
|
if (byteLength === 1) return this.writeInt8(value, offset);
|
|
throw new RangeError(`Byte length must be between 1 and 6`);
|
|
}
|
|
writeIntLE(value, offset, byteLength) {
|
|
if (!Number.isInteger(offset)) offsetError(offset);
|
|
if (byteLength === 6) return writeInt48LE(this, value, offset);
|
|
if (byteLength === 5) return writeInt40LE(this, value, offset);
|
|
if (byteLength === 3) return writeInt24LE(this, value, offset);
|
|
if (byteLength === 4) return this.writeInt32LE(value, offset);
|
|
if (byteLength === 2) return this.writeInt16LE(value, offset);
|
|
if (byteLength === 1) return this.writeInt8(value, offset);
|
|
throw new RangeError(`Byte length must be between 1 and 6`);
|
|
}
|
|
writeUint8(value, offset = 0) {
|
|
if (!Number.isInteger(offset)) offsetError(offset);
|
|
if (this[offset] === void 0) boundsError();
|
|
this[offset] = value;
|
|
return offset + 1;
|
|
}
|
|
writeUint16BE(value, offset = 0) {
|
|
if (!Number.isInteger(offset)) offsetError(offset);
|
|
if (this[offset] === void 0 || this[offset + 1] === void 0) boundsError();
|
|
this[offset] = value >>> 8;
|
|
this[offset + 1] = value;
|
|
return offset + 2;
|
|
}
|
|
writeUint16LE(value, offset = 0) {
|
|
if (!Number.isInteger(offset)) offsetError(offset);
|
|
if (this[offset] === void 0 || this[offset + 1] === void 0) boundsError();
|
|
this[offset] = value;
|
|
this[offset + 1] = value >>> 8;
|
|
return offset + 2;
|
|
}
|
|
writeUint32LE(value, offset = 0) {
|
|
if (!Number.isInteger(offset)) offsetError(offset);
|
|
if (this[offset] === void 0 || this[offset + 3] === void 0) boundsError();
|
|
this[offset] = value;
|
|
this[offset + 1] = value >>> 8;
|
|
this[offset + 2] = value >>> 16;
|
|
this[offset + 3] = value >>> 24;
|
|
return offset + 4;
|
|
}
|
|
writeUint32BE(value, offset = 0) {
|
|
if (!Number.isInteger(offset)) offsetError(offset);
|
|
if (this[offset] === void 0 || this[offset + 3] === void 0) boundsError();
|
|
this[offset] = value >>> 24;
|
|
this[offset + 1] = value >>> 16;
|
|
this[offset + 2] = value >>> 8;
|
|
this[offset + 3] = value;
|
|
return offset + 4;
|
|
}
|
|
writeUintBE(value, offset, byteLength) {
|
|
if (!Number.isInteger(offset)) offsetError(offset);
|
|
if (byteLength === 6) return writeUint48BE(this, value, offset);
|
|
if (byteLength === 5) return writeUint40BE(this, value, offset);
|
|
if (byteLength === 3) return writeUint24BE(this, value, offset);
|
|
if (byteLength === 4) return this.writeUint32BE(value, offset);
|
|
if (byteLength === 2) return this.writeUint16BE(value, offset);
|
|
if (byteLength === 1) return this.writeUint8(value, offset);
|
|
throw new RangeError(`Byte length must be between 1 and 6`);
|
|
}
|
|
writeUintLE(value, offset, byteLength) {
|
|
if (!Number.isInteger(offset)) offsetError(offset);
|
|
if (byteLength === 6) return writeUint48LE(this, value, offset);
|
|
if (byteLength === 5) return writeUint40LE(this, value, offset);
|
|
if (byteLength === 3) return writeUint24LE(this, value, offset);
|
|
if (byteLength === 4) return this.writeUint32LE(value, offset);
|
|
if (byteLength === 2) return this.writeUint16LE(value, offset);
|
|
if (byteLength === 1) return this.writeUint8(value, offset);
|
|
throw new RangeError(`Byte length must be between 1 and 6`);
|
|
}
|
|
};
|
|
for (const [alias, name] of [
|
|
["readBigUInt64BE", "readBigUint64BE"],
|
|
["readBigUInt64LE", "readBigUint64LE"],
|
|
["readUInt8", "readUint8"],
|
|
["readUInt16BE", "readUint16BE"],
|
|
["readUInt16LE", "readUint16LE"],
|
|
["readUInt32BE", "readUint32BE"],
|
|
["readUInt32LE", "readUint32LE"],
|
|
["readUIntBE", "readUintBE"],
|
|
["readUIntLE", "readUintLE"],
|
|
["writeBigUInt64BE", "writeBigUint64BE"],
|
|
["writeBigUInt64LE", "writeBigUint64LE"],
|
|
["writeUInt8", "writeUint8"],
|
|
["writeUInt16BE", "writeUint16BE"],
|
|
["writeUInt16LE", "writeUint16LE"],
|
|
["writeUInt32BE", "writeUint32BE"],
|
|
["writeUInt32LE", "writeUint32LE"],
|
|
["writeUIntBE", "writeUintBE"],
|
|
["writeUIntLE", "writeUintLE"]
|
|
]) {
|
|
Object.defineProperty(Buffer2.prototype, alias, {
|
|
value: Buffer2.prototype[name],
|
|
writable: true,
|
|
configurable: true
|
|
});
|
|
}
|
|
module.exports = exports = Buffer2;
|
|
exports.Buffer = Buffer2;
|
|
exports.constants = constants;
|
|
var codecs = /* @__PURE__ */ Object.create(null);
|
|
codecs.ascii = ascii;
|
|
codecs.base64 = base64;
|
|
codecs.base64url = base64url;
|
|
codecs.hex = hex;
|
|
codecs.utf8 = codecs["utf-8"] = utf8;
|
|
codecs.utf16le = codecs.ucs2 = codecs["utf-16le"] = codecs["ucs-2"] = utf16le;
|
|
codecs.latin1 = codecs.binary = latin1;
|
|
function codecFor(encoding) {
|
|
if (encoding === void 0) return utf8;
|
|
let codec = codecs[encoding];
|
|
if (codec !== void 0) return codec;
|
|
codec = codecs[encoding.toLowerCase()];
|
|
if (codec !== void 0) return codec;
|
|
throw new Error(`Unknown encoding '${encoding}'`);
|
|
}
|
|
var views = /* @__PURE__ */ new WeakMap();
|
|
function viewOf(buffer) {
|
|
let view = views.get(buffer);
|
|
if (view === void 0) {
|
|
view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
|
|
views.set(buffer, view);
|
|
}
|
|
return view;
|
|
}
|
|
exports.isBuffer = function isBuffer(value) {
|
|
if (value instanceof Buffer2) return true;
|
|
return typeof value === "object" && value !== null && value[kind] === Buffer2[kind];
|
|
};
|
|
exports.isEncoding = function isEncoding(encoding) {
|
|
try {
|
|
codecFor(encoding);
|
|
return true;
|
|
} catch {
|
|
return false;
|
|
}
|
|
};
|
|
exports.isASCII = function isASCII(buffer) {
|
|
return ascii.validate(buffer);
|
|
};
|
|
exports.isAscii = exports.isASCII;
|
|
exports.isUTF8 = function isUTF8(buffer) {
|
|
return utf8.validate(buffer);
|
|
};
|
|
exports.isUtf8 = exports.isUTF8;
|
|
exports.alloc = function alloc(size, fill, encoding) {
|
|
if (fill !== void 0 && fill !== 0) {
|
|
const buffer = new Buffer2(size, { uninitialized: true });
|
|
return buffer.fill(fill, 0, buffer.byteLength, encoding);
|
|
}
|
|
return new Buffer2(size);
|
|
};
|
|
exports.allocUnsafe = function allocUnsafe(size) {
|
|
return allocate(size);
|
|
};
|
|
exports.allocUnsafeSlow = function allocUnsafeSlow(size) {
|
|
return new Buffer2(size, { uninitialized: true });
|
|
};
|
|
exports.byteLength = function byteLength(string, encoding) {
|
|
if (typeof string === "string") {
|
|
return codecFor(encoding).byteLength(string);
|
|
}
|
|
return string.byteLength;
|
|
};
|
|
exports.compare = function compare(a, b) {
|
|
return binding.compare(a.buffer, a.byteOffset, a.byteLength, b.buffer, b.byteOffset, b.byteLength);
|
|
};
|
|
exports.concat = function concat(buffers, length) {
|
|
const n = buffers.length;
|
|
if (length === void 0) {
|
|
length = 0;
|
|
for (let i = 0; i < n; i++) length += buffers[i].byteLength;
|
|
}
|
|
const result = allocate(length);
|
|
let offset = 0;
|
|
for (let i = 0; i < n; i++) {
|
|
const buffer = buffers[i];
|
|
if (offset + buffer.byteLength > length) {
|
|
result.set(new Uint8Array(buffer.buffer, buffer.byteOffset, length - offset), offset);
|
|
return result;
|
|
}
|
|
result.set(buffer, offset);
|
|
offset += buffer.byteLength;
|
|
}
|
|
if (offset < length) result.fill(0, offset, length);
|
|
return result;
|
|
};
|
|
exports.coerce = function coerce(buffer) {
|
|
if (exports.isBuffer(buffer)) return buffer;
|
|
return new Buffer2(buffer.buffer, buffer.byteOffset, buffer.byteLength);
|
|
};
|
|
exports.copyBytesFrom = function copyBytesFrom(view, offset = 0, length = view.length - offset) {
|
|
if (offset + length > view.length) {
|
|
throw new RangeError("View length is out of range");
|
|
}
|
|
if (offset !== 0 || length !== view.length) {
|
|
view = view.subarray(offset, offset + length);
|
|
}
|
|
return new Buffer2(view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength));
|
|
};
|
|
exports.from = function from(value, encodingOrOffset, length) {
|
|
if (typeof value === "string") return fromString(value, encodingOrOffset);
|
|
if (Array.isArray(value)) return fromArray(value);
|
|
if (ArrayBuffer.isView(value)) return fromBuffer(value);
|
|
return fromArrayBuffer(value, encodingOrOffset, length);
|
|
};
|
|
function fromString(string, encoding) {
|
|
const codec = codecFor(encoding);
|
|
const length = codec.byteLength(string);
|
|
const buffer = allocate(length);
|
|
const written = codec.write(buffer, string, 0, length);
|
|
if (written < length) return buffer.subarray(0, written);
|
|
return buffer;
|
|
}
|
|
function fromArray(array) {
|
|
const buffer = allocate(array.length);
|
|
buffer.set(array);
|
|
return buffer;
|
|
}
|
|
function fromBuffer(buffer) {
|
|
const copy = allocate(buffer.byteLength);
|
|
copy.set(buffer);
|
|
return copy;
|
|
}
|
|
function fromArrayBuffer(arrayBuffer, offset, length) {
|
|
return new Buffer2(arrayBuffer, offset, length);
|
|
}
|
|
function bidirectionalIndexOf(buffer, value, offset, encoding, first) {
|
|
if (buffer.byteLength === 0) return -1;
|
|
if (typeof offset === "string") {
|
|
encoding = offset;
|
|
offset = 0;
|
|
} else if (offset === void 0) {
|
|
offset = first ? 0 : buffer.byteLength - 1;
|
|
} else if (offset < 0) {
|
|
offset += buffer.byteLength;
|
|
}
|
|
if (offset >= buffer.byteLength) {
|
|
if (first) return -1;
|
|
else offset = buffer.byteLength - 1;
|
|
} else if (offset < 0) {
|
|
if (first) offset = 0;
|
|
else return -1;
|
|
}
|
|
if (typeof value === "string") value = exports.from(value, encoding);
|
|
const needleLength = value.byteLength;
|
|
if (needleLength === 0) return -1;
|
|
const length = buffer.byteLength;
|
|
const last = length - needleLength;
|
|
if (first) {
|
|
if (offset > last) return -1;
|
|
} else {
|
|
if (offset > last) offset = last;
|
|
if (offset < 0) return -1;
|
|
}
|
|
let j = 0;
|
|
while (j < needleLength && buffer[offset + j] === value[j]) j++;
|
|
if (j === needleLength) return offset;
|
|
if (first) {
|
|
if (offset === last) return -1;
|
|
return binding.indexOf(
|
|
buffer.buffer,
|
|
buffer.byteOffset,
|
|
length,
|
|
value.buffer,
|
|
value.byteOffset,
|
|
needleLength,
|
|
offset + 1
|
|
);
|
|
}
|
|
if (offset === 0) return -1;
|
|
return binding.lastIndexOf(
|
|
buffer.buffer,
|
|
buffer.byteOffset,
|
|
length,
|
|
value.buffer,
|
|
value.byteOffset,
|
|
needleLength,
|
|
offset - 1
|
|
);
|
|
}
|
|
function fillPattern(buffer, value, length, offset, end) {
|
|
const n = end - offset;
|
|
if (n < 64) {
|
|
for (let i = 0; i < n; i++) buffer[offset + i] = value[i % length];
|
|
return buffer;
|
|
}
|
|
let filled = length < n ? length : n;
|
|
for (let i = 0; i < filled; i++) buffer[offset + i] = value[i];
|
|
while (filled < n) {
|
|
const copy = filled < n - filled ? filled : n - filled;
|
|
buffer.copyWithin(offset + filled, offset, offset + copy);
|
|
filled += copy;
|
|
}
|
|
return buffer;
|
|
}
|
|
function allocate(size) {
|
|
if (Number.isNaN(size) || size <= 0 || size >= poolSize >>> 1) {
|
|
return new Buffer2(size, { uninitialized: true });
|
|
}
|
|
if (pool === null || poolLength !== poolSize || poolLength - poolOffset < size) {
|
|
pool = binding.allocUnsafe(poolSize);
|
|
poolLength = poolSize;
|
|
poolOffset = 0;
|
|
}
|
|
const buffer = new Buffer2(pool, poolOffset, size);
|
|
poolOffset = poolOffset + size + 7 & ~7;
|
|
return buffer;
|
|
}
|
|
function swap(buffer, n, m) {
|
|
const i = buffer[n];
|
|
buffer[n] = buffer[m];
|
|
buffer[m] = i;
|
|
}
|
|
exports.atob = function atob(data) {
|
|
return Buffer2.from(data, "base64").toString("latin1");
|
|
};
|
|
exports.btoa = function btoa(data) {
|
|
if (typeof data !== "string") data = String(data);
|
|
return Buffer2.from(data, "latin1").toString("base64");
|
|
};
|
|
exports.transcode = function transcode(buffer, from, to) {
|
|
return Buffer2.from(buffer.toString(from), to);
|
|
};
|
|
function boundsError() {
|
|
throw new RangeError("Offset is outside the bounds of the buffer");
|
|
}
|
|
function offsetError(offset) {
|
|
if (typeof offset !== "number") {
|
|
throw new TypeError(`Offset must be a number, received type ${typeof offset}`);
|
|
}
|
|
throw new RangeError("Offset is outside the bounds of the buffer");
|
|
}
|
|
function readInt48BE(buffer, offset) {
|
|
const value = readUint48BE(buffer, offset);
|
|
return value >= 140737488355328 ? value - 281474976710656 : value;
|
|
}
|
|
function readInt48LE(buffer, offset) {
|
|
const value = readUint48LE(buffer, offset);
|
|
return value >= 140737488355328 ? value - 281474976710656 : value;
|
|
}
|
|
function readInt40BE(buffer, offset) {
|
|
const value = readUint40BE(buffer, offset);
|
|
return value >= 549755813888 ? value - 1099511627776 : value;
|
|
}
|
|
function readInt40LE(buffer, offset) {
|
|
const value = readUint40LE(buffer, offset);
|
|
return value >= 549755813888 ? value - 1099511627776 : value;
|
|
}
|
|
function readInt24BE(buffer, offset) {
|
|
const value = readUint24BE(buffer, offset);
|
|
return value & 8388608 ? value - 16777216 : value;
|
|
}
|
|
function readInt24LE(buffer, offset) {
|
|
const value = readUint24LE(buffer, offset);
|
|
return value & 8388608 ? value - 16777216 : value;
|
|
}
|
|
function readUint48BE(buffer, offset) {
|
|
const first = buffer[offset];
|
|
const last = buffer[offset + 5];
|
|
if (first === void 0 || last === void 0) boundsError();
|
|
return (first * 256 + buffer[offset + 1]) * 4294967296 + (buffer[offset + 2] << 24 >>> 0) + (buffer[offset + 3] << 16) + (buffer[offset + 4] << 8) + last;
|
|
}
|
|
function readUint48LE(buffer, offset) {
|
|
const first = buffer[offset];
|
|
const last = buffer[offset + 5];
|
|
if (first === void 0 || last === void 0) boundsError();
|
|
return (buffer[offset + 4] + last * 256) * 4294967296 + (buffer[offset + 3] << 24 >>> 0) + (buffer[offset + 2] << 16) + (buffer[offset + 1] << 8) + first;
|
|
}
|
|
function readUint40BE(buffer, offset) {
|
|
const first = buffer[offset];
|
|
const last = buffer[offset + 4];
|
|
if (first === void 0 || last === void 0) boundsError();
|
|
return first * 4294967296 + (buffer[offset + 1] << 24 >>> 0) + (buffer[offset + 2] << 16) + (buffer[offset + 3] << 8) + last;
|
|
}
|
|
function readUint40LE(buffer, offset) {
|
|
const first = buffer[offset];
|
|
const last = buffer[offset + 4];
|
|
if (first === void 0 || last === void 0) boundsError();
|
|
return last * 4294967296 + (buffer[offset + 3] << 24 >>> 0) + (buffer[offset + 2] << 16) + (buffer[offset + 1] << 8) + first;
|
|
}
|
|
function readUint24BE(buffer, offset) {
|
|
const first = buffer[offset];
|
|
const last = buffer[offset + 2];
|
|
if (first === void 0 || last === void 0) boundsError();
|
|
return first << 16 | buffer[offset + 1] << 8 | last;
|
|
}
|
|
function readUint24LE(buffer, offset) {
|
|
const first = buffer[offset];
|
|
const last = buffer[offset + 2];
|
|
if (first === void 0 || last === void 0) boundsError();
|
|
return last << 16 | buffer[offset + 1] << 8 | first;
|
|
}
|
|
function writeInt48BE(buffer, value, offset) {
|
|
if (value < 0) value += 281474976710656;
|
|
return writeUint48BE(buffer, value, offset);
|
|
}
|
|
function writeInt48LE(buffer, value, offset) {
|
|
if (value < 0) value += 281474976710656;
|
|
return writeUint48LE(buffer, value, offset);
|
|
}
|
|
function writeInt40BE(buffer, value, offset) {
|
|
if (value < 0) value += 1099511627776;
|
|
return writeUint40BE(buffer, value, offset);
|
|
}
|
|
function writeInt40LE(buffer, value, offset) {
|
|
if (value < 0) value += 1099511627776;
|
|
return writeUint40LE(buffer, value, offset);
|
|
}
|
|
function writeInt24BE(buffer, value, offset) {
|
|
if (value < 0) value += 16777216;
|
|
return writeUint24BE(buffer, value, offset);
|
|
}
|
|
function writeInt24LE(buffer, value, offset) {
|
|
if (value < 0) value += 16777216;
|
|
return writeUint24LE(buffer, value, offset);
|
|
}
|
|
function writeUint48BE(buffer, value, offset) {
|
|
if (buffer[offset] === void 0 || buffer[offset + 5] === void 0) boundsError();
|
|
const hi = Math.floor(value / 4294967296);
|
|
const lo = value >>> 0;
|
|
buffer[offset] = hi >>> 8;
|
|
buffer[offset + 1] = hi;
|
|
buffer[offset + 2] = lo >>> 24;
|
|
buffer[offset + 3] = lo >>> 16;
|
|
buffer[offset + 4] = lo >>> 8;
|
|
buffer[offset + 5] = lo;
|
|
return offset + 6;
|
|
}
|
|
function writeUint48LE(buffer, value, offset) {
|
|
if (buffer[offset] === void 0 || buffer[offset + 5] === void 0) boundsError();
|
|
const hi = Math.floor(value / 4294967296);
|
|
const lo = value >>> 0;
|
|
buffer[offset] = lo;
|
|
buffer[offset + 1] = lo >>> 8;
|
|
buffer[offset + 2] = lo >>> 16;
|
|
buffer[offset + 3] = lo >>> 24;
|
|
buffer[offset + 4] = hi;
|
|
buffer[offset + 5] = hi >>> 8;
|
|
return offset + 6;
|
|
}
|
|
function writeUint40BE(buffer, value, offset) {
|
|
if (buffer[offset] === void 0 || buffer[offset + 4] === void 0) boundsError();
|
|
const lo = value >>> 0;
|
|
buffer[offset] = Math.floor(value / 4294967296);
|
|
buffer[offset + 1] = lo >>> 24;
|
|
buffer[offset + 2] = lo >>> 16;
|
|
buffer[offset + 3] = lo >>> 8;
|
|
buffer[offset + 4] = lo;
|
|
return offset + 5;
|
|
}
|
|
function writeUint40LE(buffer, value, offset) {
|
|
if (buffer[offset] === void 0 || buffer[offset + 4] === void 0) boundsError();
|
|
const lo = value >>> 0;
|
|
buffer[offset] = lo;
|
|
buffer[offset + 1] = lo >>> 8;
|
|
buffer[offset + 2] = lo >>> 16;
|
|
buffer[offset + 3] = lo >>> 24;
|
|
buffer[offset + 4] = Math.floor(value / 4294967296);
|
|
return offset + 5;
|
|
}
|
|
function writeUint24BE(buffer, value, offset) {
|
|
if (buffer[offset] === void 0 || buffer[offset + 2] === void 0) boundsError();
|
|
buffer[offset] = value >>> 16;
|
|
buffer[offset + 1] = value >>> 8;
|
|
buffer[offset + 2] = value;
|
|
return offset + 3;
|
|
}
|
|
function writeUint24LE(buffer, value, offset) {
|
|
if (buffer[offset] === void 0 || buffer[offset + 2] === void 0) boundsError();
|
|
buffer[offset] = value;
|
|
buffer[offset + 1] = value >>> 8;
|
|
buffer[offset + 2] = value >>> 16;
|
|
return offset + 3;
|
|
}
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/b4a/index.js
|
|
var require_b4a = __commonJS({
|
|
"../../node_modules/b4a/index.js"(exports, module) {
|
|
function isBuffer(value) {
|
|
return Buffer.isBuffer(value) || value instanceof Uint8Array;
|
|
}
|
|
function isEncoding(encoding) {
|
|
return Buffer.isEncoding(encoding);
|
|
}
|
|
function alloc(size, fill2, encoding) {
|
|
return Buffer.alloc(size, fill2, encoding);
|
|
}
|
|
function allocUnsafe(size) {
|
|
return Buffer.allocUnsafe(size);
|
|
}
|
|
function allocUnsafeSlow(size) {
|
|
return Buffer.allocUnsafeSlow(size);
|
|
}
|
|
function byteLength(string, encoding) {
|
|
return Buffer.byteLength(string, encoding);
|
|
}
|
|
function compare(a, b) {
|
|
return Buffer.compare(a, b);
|
|
}
|
|
function concat(buffers, totalLength) {
|
|
return Buffer.concat(buffers, totalLength);
|
|
}
|
|
function copy(source, target, targetStart, start, end) {
|
|
return toBuffer(source).copy(target, targetStart, start, end);
|
|
}
|
|
function equals(a, b) {
|
|
return toBuffer(a).equals(b);
|
|
}
|
|
function fill(buffer, value, offset, end, encoding) {
|
|
return toBuffer(buffer).fill(value, offset, end, encoding);
|
|
}
|
|
function from(value, encodingOrOffset, length) {
|
|
return Buffer.from(value, encodingOrOffset, length);
|
|
}
|
|
function includes(buffer, value, byteOffset, encoding) {
|
|
return toBuffer(buffer).includes(value, byteOffset, encoding);
|
|
}
|
|
function indexOf(buffer, value, byfeOffset, encoding) {
|
|
return toBuffer(buffer).indexOf(value, byfeOffset, encoding);
|
|
}
|
|
function lastIndexOf(buffer, value, byteOffset, encoding) {
|
|
return toBuffer(buffer).lastIndexOf(value, byteOffset, encoding);
|
|
}
|
|
function swap16(buffer) {
|
|
return toBuffer(buffer).swap16();
|
|
}
|
|
function swap32(buffer) {
|
|
return toBuffer(buffer).swap32();
|
|
}
|
|
function swap64(buffer) {
|
|
return toBuffer(buffer).swap64();
|
|
}
|
|
function toBuffer(buffer) {
|
|
if (Buffer.isBuffer(buffer)) return buffer;
|
|
return Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength);
|
|
}
|
|
function toString(buffer, encoding, start, end) {
|
|
return toBuffer(buffer).toString(encoding, start, end);
|
|
}
|
|
function write(buffer, string, offset, length, encoding) {
|
|
return toBuffer(buffer).write(string, offset, length, encoding);
|
|
}
|
|
function readDoubleBE(buffer, offset) {
|
|
return toBuffer(buffer).readDoubleBE(offset);
|
|
}
|
|
function readDoubleLE(buffer, offset) {
|
|
return toBuffer(buffer).readDoubleLE(offset);
|
|
}
|
|
function readFloatBE(buffer, offset) {
|
|
return toBuffer(buffer).readFloatBE(offset);
|
|
}
|
|
function readFloatLE(buffer, offset) {
|
|
return toBuffer(buffer).readFloatLE(offset);
|
|
}
|
|
function readInt32BE(buffer, offset) {
|
|
return toBuffer(buffer).readInt32BE(offset);
|
|
}
|
|
function readInt32LE(buffer, offset) {
|
|
return toBuffer(buffer).readInt32LE(offset);
|
|
}
|
|
function readUInt32BE(buffer, offset) {
|
|
return toBuffer(buffer).readUInt32BE(offset);
|
|
}
|
|
function readUInt32LE(buffer, offset) {
|
|
return toBuffer(buffer).readUInt32LE(offset);
|
|
}
|
|
function writeDoubleBE(buffer, value, offset) {
|
|
return toBuffer(buffer).writeDoubleBE(value, offset);
|
|
}
|
|
function writeDoubleLE(buffer, value, offset) {
|
|
return toBuffer(buffer).writeDoubleLE(value, offset);
|
|
}
|
|
function writeFloatBE(buffer, value, offset) {
|
|
return toBuffer(buffer).writeFloatBE(value, offset);
|
|
}
|
|
function writeFloatLE(buffer, value, offset) {
|
|
return toBuffer(buffer).writeFloatLE(value, offset);
|
|
}
|
|
function writeInt32BE(buffer, value, offset) {
|
|
return toBuffer(buffer).writeInt32BE(value, offset);
|
|
}
|
|
function writeInt32LE(buffer, value, offset) {
|
|
return toBuffer(buffer).writeInt32LE(value, offset);
|
|
}
|
|
function writeUInt32BE(buffer, value, offset) {
|
|
return toBuffer(buffer).writeUInt32BE(value, offset);
|
|
}
|
|
function writeUInt32LE(buffer, value, offset) {
|
|
return toBuffer(buffer).writeUInt32LE(value, offset);
|
|
}
|
|
module.exports = {
|
|
isBuffer,
|
|
isEncoding,
|
|
alloc,
|
|
allocUnsafe,
|
|
allocUnsafeSlow,
|
|
byteLength,
|
|
compare,
|
|
concat,
|
|
copy,
|
|
equals,
|
|
fill,
|
|
from,
|
|
includes,
|
|
indexOf,
|
|
lastIndexOf,
|
|
swap16,
|
|
swap32,
|
|
swap64,
|
|
toBuffer,
|
|
toString,
|
|
write,
|
|
readDoubleBE,
|
|
readDoubleLE,
|
|
readFloatBE,
|
|
readFloatLE,
|
|
readInt32BE,
|
|
readInt32LE,
|
|
readUInt32BE,
|
|
readUInt32LE,
|
|
writeDoubleBE,
|
|
writeDoubleLE,
|
|
writeFloatBE,
|
|
writeFloatLE,
|
|
writeInt32BE,
|
|
writeInt32LE,
|
|
writeUInt32BE,
|
|
writeUInt32LE
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-structured-clone/node_modules/compact-encoding/endian.js
|
|
var require_endian = __commonJS({
|
|
"../../node_modules/bare-structured-clone/node_modules/compact-encoding/endian.js"(exports) {
|
|
var LE = exports.LE = new Uint8Array(new Uint16Array([255]).buffer)[0] === 255;
|
|
exports.BE = !LE;
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-structured-clone/node_modules/compact-encoding/raw.js
|
|
var require_raw = __commonJS({
|
|
"../../node_modules/bare-structured-clone/node_modules/compact-encoding/raw.js"(exports, module) {
|
|
var b4a = require_b4a();
|
|
var { BE } = require_endian();
|
|
exports = module.exports = {
|
|
preencode(state, b) {
|
|
state.end += b.byteLength;
|
|
},
|
|
encode(state, b) {
|
|
state.buffer.set(b, state.start);
|
|
state.start += b.byteLength;
|
|
},
|
|
decode(state) {
|
|
const b = state.buffer.subarray(state.start, state.end);
|
|
state.start = state.end;
|
|
return b;
|
|
}
|
|
};
|
|
var buffer = exports.buffer = {
|
|
preencode(state, b) {
|
|
uint8array.preencode(state, b);
|
|
},
|
|
encode(state, b) {
|
|
uint8array.encode(state, b);
|
|
},
|
|
decode(state) {
|
|
const b = state.buffer.subarray(state.start);
|
|
state.start = state.end;
|
|
return b;
|
|
}
|
|
};
|
|
exports.binary = {
|
|
...buffer,
|
|
preencode(state, b) {
|
|
if (typeof b === "string") utf8.preencode(state, b);
|
|
else buffer.preencode(state, b);
|
|
},
|
|
encode(state, b) {
|
|
if (typeof b === "string") utf8.encode(state, b);
|
|
else buffer.encode(state, b);
|
|
}
|
|
};
|
|
exports.arraybuffer = {
|
|
preencode(state, b) {
|
|
state.end += b.byteLength;
|
|
},
|
|
encode(state, b) {
|
|
const view = new Uint8Array(b);
|
|
state.buffer.set(view, state.start);
|
|
state.start += b.byteLength;
|
|
},
|
|
decode(state) {
|
|
const b = new ArrayBuffer(state.end - state.start);
|
|
const view = new Uint8Array(b);
|
|
view.set(state.buffer.subarray(state.start));
|
|
state.start = state.end;
|
|
return b;
|
|
}
|
|
};
|
|
function typedarray(TypedArray, swap) {
|
|
const n = TypedArray.BYTES_PER_ELEMENT;
|
|
return {
|
|
preencode(state, b) {
|
|
state.end += b.byteLength;
|
|
},
|
|
encode(state, b) {
|
|
const view = new Uint8Array(b.buffer, b.byteOffset, b.byteLength);
|
|
if (BE && swap) swap(view);
|
|
state.buffer.set(view, state.start);
|
|
state.start += b.byteLength;
|
|
},
|
|
decode(state) {
|
|
let b = state.buffer.subarray(state.start);
|
|
if (b.byteOffset % n !== 0) b = new Uint8Array(b);
|
|
if (BE && swap) swap(b);
|
|
state.start = state.end;
|
|
return new TypedArray(b.buffer, b.byteOffset, b.byteLength / n);
|
|
}
|
|
};
|
|
}
|
|
var uint8array = exports.uint8array = typedarray(Uint8Array);
|
|
exports.uint16array = typedarray(Uint16Array, b4a.swap16);
|
|
exports.uint32array = typedarray(Uint32Array, b4a.swap32);
|
|
exports.int8array = typedarray(Int8Array);
|
|
exports.int16array = typedarray(Int16Array, b4a.swap16);
|
|
exports.int32array = typedarray(Int32Array, b4a.swap32);
|
|
exports.biguint64array = typedarray(BigUint64Array, b4a.swap64);
|
|
exports.bigint64array = typedarray(BigInt64Array, b4a.swap64);
|
|
exports.float32array = typedarray(Float32Array, b4a.swap32);
|
|
exports.float64array = typedarray(Float64Array, b4a.swap64);
|
|
function string(encoding) {
|
|
return {
|
|
preencode(state, s) {
|
|
state.end += b4a.byteLength(s, encoding);
|
|
},
|
|
encode(state, s) {
|
|
state.start += b4a.write(state.buffer, s, state.start, encoding);
|
|
},
|
|
decode(state) {
|
|
const s = b4a.toString(state.buffer, encoding, state.start);
|
|
state.start = state.end;
|
|
return s;
|
|
}
|
|
};
|
|
}
|
|
var utf8 = exports.string = exports.utf8 = string("utf-8");
|
|
exports.ascii = string("ascii");
|
|
exports.hex = string("hex");
|
|
exports.base64 = string("base64");
|
|
exports.ucs2 = exports.utf16le = string("utf16le");
|
|
exports.array = function array(enc) {
|
|
return {
|
|
preencode(state, list) {
|
|
for (const value of list) enc.preencode(state, value);
|
|
},
|
|
encode(state, list) {
|
|
for (const value of list) enc.encode(state, value);
|
|
},
|
|
decode(state) {
|
|
const arr = [];
|
|
while (state.start < state.end) arr.push(enc.decode(state));
|
|
return arr;
|
|
}
|
|
};
|
|
};
|
|
exports.json = {
|
|
preencode(state, v) {
|
|
utf8.preencode(state, JSON.stringify(v));
|
|
},
|
|
encode(state, v) {
|
|
utf8.encode(state, JSON.stringify(v));
|
|
},
|
|
decode(state) {
|
|
return JSON.parse(utf8.decode(state));
|
|
}
|
|
};
|
|
exports.ndjson = {
|
|
preencode(state, v) {
|
|
utf8.preencode(state, JSON.stringify(v) + "\n");
|
|
},
|
|
encode(state, v) {
|
|
utf8.encode(state, JSON.stringify(v) + "\n");
|
|
},
|
|
decode(state) {
|
|
return JSON.parse(utf8.decode(state));
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-structured-clone/node_modules/compact-encoding/lexint.js
|
|
var require_lexint = __commonJS({
|
|
"../../node_modules/bare-structured-clone/node_modules/compact-encoding/lexint.js"(exports, module) {
|
|
module.exports = {
|
|
preencode,
|
|
encode,
|
|
decode
|
|
};
|
|
function preencode(state, num) {
|
|
if (num < 251) {
|
|
state.end++;
|
|
} else if (num < 256) {
|
|
state.end += 2;
|
|
} else if (num < 65536) {
|
|
state.end += 3;
|
|
} else if (num < 16777216) {
|
|
state.end += 4;
|
|
} else if (num < 4294967296) {
|
|
state.end += 5;
|
|
} else {
|
|
state.end++;
|
|
const exp = Math.floor(Math.log(num) / Math.log(2)) - 32;
|
|
preencode(state, exp);
|
|
state.end += 6;
|
|
}
|
|
}
|
|
function encode(state, num) {
|
|
const max = 251;
|
|
const x = num - max;
|
|
if (num < max) {
|
|
state.buffer[state.start++] = num;
|
|
} else if (num < 256) {
|
|
state.buffer[state.start++] = max;
|
|
state.buffer[state.start++] = x;
|
|
} else if (num < 65536) {
|
|
state.buffer[state.start++] = max + 1;
|
|
state.buffer[state.start++] = x >> 8 & 255;
|
|
state.buffer[state.start++] = x & 255;
|
|
} else if (num < 16777216) {
|
|
state.buffer[state.start++] = max + 2;
|
|
state.buffer[state.start++] = x >> 16;
|
|
state.buffer[state.start++] = x >> 8 & 255;
|
|
state.buffer[state.start++] = x & 255;
|
|
} else if (num < 4294967296) {
|
|
state.buffer[state.start++] = max + 3;
|
|
state.buffer[state.start++] = x >> 24;
|
|
state.buffer[state.start++] = x >> 16 & 255;
|
|
state.buffer[state.start++] = x >> 8 & 255;
|
|
state.buffer[state.start++] = x & 255;
|
|
} else {
|
|
const exp = Math.floor(Math.log(x) / Math.log(2)) - 32;
|
|
state.buffer[state.start++] = 255;
|
|
encode(state, exp);
|
|
const rem = x / Math.pow(2, exp - 11);
|
|
for (let i = 5; i >= 0; i--) {
|
|
state.buffer[state.start++] = rem / Math.pow(2, 8 * i) & 255;
|
|
}
|
|
}
|
|
}
|
|
function decode(state) {
|
|
const max = 251;
|
|
if (state.end - state.start < 1) throw new Error("Out of bounds");
|
|
const flag = state.buffer[state.start++];
|
|
if (flag < max) return flag;
|
|
if (state.end - state.start < flag - max + 1) {
|
|
throw new Error("Out of bounds.");
|
|
}
|
|
if (flag < 252) {
|
|
return state.buffer[state.start++] + max;
|
|
}
|
|
if (flag < 253) {
|
|
return (state.buffer[state.start++] << 8) + state.buffer[state.start++] + max;
|
|
}
|
|
if (flag < 254) {
|
|
return (state.buffer[state.start++] << 16) + (state.buffer[state.start++] << 8) + state.buffer[state.start++] + max;
|
|
}
|
|
if (flag < 255) {
|
|
return state.buffer[state.start++] * 16777216 + (state.buffer[state.start++] << 16) + (state.buffer[state.start++] << 8) + state.buffer[state.start++] + max;
|
|
}
|
|
const exp = decode(state);
|
|
if (state.end - state.start < 6) throw new Error("Out of bounds");
|
|
let rem = 0;
|
|
for (let i = 5; i >= 0; i--) {
|
|
rem += state.buffer[state.start++] * Math.pow(2, 8 * i);
|
|
}
|
|
return rem * Math.pow(2, exp - 11) + max;
|
|
}
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-structured-clone/node_modules/compact-encoding/index.js
|
|
var require_compact_encoding = __commonJS({
|
|
"../../node_modules/bare-structured-clone/node_modules/compact-encoding/index.js"(exports) {
|
|
var b4a = require_b4a();
|
|
var { BE } = require_endian();
|
|
exports.state = function(start = 0, end = 0, buffer2 = null) {
|
|
return { start, end, buffer: buffer2 };
|
|
};
|
|
var raw = exports.raw = require_raw();
|
|
var uint = exports.uint = {
|
|
preencode(state, n) {
|
|
state.end += n <= 252 ? 1 : n <= 65535 ? 3 : n <= 4294967295 ? 5 : 9;
|
|
},
|
|
encode(state, n) {
|
|
if (n <= 252) uint8.encode(state, n);
|
|
else if (n <= 65535) {
|
|
state.buffer[state.start++] = 253;
|
|
uint16.encode(state, n);
|
|
} else if (n <= 4294967295) {
|
|
state.buffer[state.start++] = 254;
|
|
uint32.encode(state, n);
|
|
} else {
|
|
state.buffer[state.start++] = 255;
|
|
uint64.encode(state, n);
|
|
}
|
|
},
|
|
decode(state) {
|
|
const a = uint8.decode(state);
|
|
if (a <= 252) return a;
|
|
if (a === 253) return uint16.decode(state);
|
|
if (a === 254) return uint32.decode(state);
|
|
return uint64.decode(state);
|
|
}
|
|
};
|
|
var uint8 = exports.uint8 = {
|
|
preencode(state, n) {
|
|
state.end += 1;
|
|
},
|
|
encode(state, n) {
|
|
validateUint(n);
|
|
state.buffer[state.start++] = n;
|
|
},
|
|
decode(state) {
|
|
if (state.start >= state.end) throw new Error("Out of bounds");
|
|
return state.buffer[state.start++];
|
|
}
|
|
};
|
|
var uint16 = exports.uint16 = {
|
|
preencode(state, n) {
|
|
state.end += 2;
|
|
},
|
|
encode(state, n) {
|
|
validateUint(n);
|
|
state.buffer[state.start++] = n;
|
|
state.buffer[state.start++] = n >>> 8;
|
|
},
|
|
decode(state) {
|
|
if (state.end - state.start < 2) throw new Error("Out of bounds");
|
|
return state.buffer[state.start++] + state.buffer[state.start++] * 256;
|
|
}
|
|
};
|
|
var uint24 = exports.uint24 = {
|
|
preencode(state, n) {
|
|
state.end += 3;
|
|
},
|
|
encode(state, n) {
|
|
validateUint(n);
|
|
state.buffer[state.start++] = n;
|
|
state.buffer[state.start++] = n >>> 8;
|
|
state.buffer[state.start++] = n >>> 16;
|
|
},
|
|
decode(state) {
|
|
if (state.end - state.start < 3) throw new Error("Out of bounds");
|
|
return state.buffer[state.start++] + state.buffer[state.start++] * 256 + state.buffer[state.start++] * 65536;
|
|
}
|
|
};
|
|
var uint32 = exports.uint32 = {
|
|
preencode(state, n) {
|
|
state.end += 4;
|
|
},
|
|
encode(state, n) {
|
|
validateUint(n);
|
|
state.buffer[state.start++] = n;
|
|
state.buffer[state.start++] = n >>> 8;
|
|
state.buffer[state.start++] = n >>> 16;
|
|
state.buffer[state.start++] = n >>> 24;
|
|
},
|
|
decode(state) {
|
|
if (state.end - state.start < 4) throw new Error("Out of bounds");
|
|
return state.buffer[state.start++] + state.buffer[state.start++] * 256 + state.buffer[state.start++] * 65536 + state.buffer[state.start++] * 16777216;
|
|
}
|
|
};
|
|
var uint32be = exports.uint32be = {
|
|
preencode(state, n) {
|
|
state.end += 4;
|
|
},
|
|
encode(state, n) {
|
|
validateUint(n);
|
|
state.buffer[state.start++] = n >>> 24;
|
|
state.buffer[state.start++] = n >>> 16;
|
|
state.buffer[state.start++] = n >>> 8;
|
|
state.buffer[state.start++] = n;
|
|
},
|
|
decode(state) {
|
|
if (state.end - state.start < 4) throw new Error("Out of bounds");
|
|
return state.buffer[state.start++] * 16777216 + state.buffer[state.start++] * 65536 + state.buffer[state.start++] * 256 + state.buffer[state.start++];
|
|
}
|
|
};
|
|
var uint40 = exports.uint40 = {
|
|
preencode(state, n) {
|
|
state.end += 5;
|
|
},
|
|
encode(state, n) {
|
|
validateUint(n);
|
|
const r = Math.floor(n / 256);
|
|
uint8.encode(state, n);
|
|
uint32.encode(state, r);
|
|
},
|
|
decode(state) {
|
|
if (state.end - state.start < 5) throw new Error("Out of bounds");
|
|
return uint8.decode(state) + 256 * uint32.decode(state);
|
|
}
|
|
};
|
|
var uint48 = exports.uint48 = {
|
|
preencode(state, n) {
|
|
state.end += 6;
|
|
},
|
|
encode(state, n) {
|
|
validateUint(n);
|
|
const r = Math.floor(n / 65536);
|
|
uint16.encode(state, n);
|
|
uint32.encode(state, r);
|
|
},
|
|
decode(state) {
|
|
if (state.end - state.start < 6) throw new Error("Out of bounds");
|
|
return uint16.decode(state) + 65536 * uint32.decode(state);
|
|
}
|
|
};
|
|
var uint56 = exports.uint56 = {
|
|
preencode(state, n) {
|
|
state.end += 7;
|
|
},
|
|
encode(state, n) {
|
|
validateUint(n);
|
|
const r = Math.floor(n / 16777216);
|
|
uint24.encode(state, n);
|
|
uint32.encode(state, r);
|
|
},
|
|
decode(state) {
|
|
if (state.end - state.start < 7) throw new Error("Out of bounds");
|
|
return validateSafeUint(
|
|
uint24.decode(state) + 16777216 * uint32.decode(state)
|
|
);
|
|
}
|
|
};
|
|
var uint64 = exports.uint64 = {
|
|
preencode(state, n) {
|
|
state.end += 8;
|
|
},
|
|
encode(state, n) {
|
|
validateUint(n);
|
|
const r = Math.floor(n / 4294967296);
|
|
uint32.encode(state, n);
|
|
uint32.encode(state, r);
|
|
},
|
|
decode(state) {
|
|
if (state.end - state.start < 8) throw new Error("Out of bounds");
|
|
return validateSafeUint(
|
|
uint32.decode(state) + 4294967296 * uint32.decode(state)
|
|
);
|
|
}
|
|
};
|
|
exports.uint64be = {
|
|
preencode(state, n) {
|
|
state.end += 8;
|
|
},
|
|
encode(state, n) {
|
|
validateUint(n);
|
|
const r = Math.floor(n / 4294967296);
|
|
uint32be.encode(state, r);
|
|
uint32be.encode(state, n);
|
|
},
|
|
decode(state) {
|
|
if (state.end - state.start < 8) throw new Error("Out of bounds");
|
|
return validateSafeUint(
|
|
4294967296 * uint32be.decode(state) + uint32be.decode(state)
|
|
);
|
|
}
|
|
};
|
|
var int = exports.int = zigZagInt(uint);
|
|
exports.int8 = zigZagInt(uint8);
|
|
exports.int16 = zigZagInt(uint16);
|
|
exports.int24 = zigZagInt(uint24);
|
|
exports.int32 = zigZagInt(uint32);
|
|
exports.int40 = zigZagInt(uint40);
|
|
exports.int48 = zigZagInt(uint48);
|
|
exports.int56 = zigZagInt(uint56);
|
|
exports.int64 = zigZagInt(uint64);
|
|
var biguint64 = exports.biguint64 = {
|
|
preencode(state, n) {
|
|
state.end += 8;
|
|
},
|
|
encode(state, n) {
|
|
const view = new DataView(
|
|
state.buffer.buffer,
|
|
state.start + state.buffer.byteOffset,
|
|
8
|
|
);
|
|
view.setBigUint64(0, n, true);
|
|
state.start += 8;
|
|
},
|
|
decode(state) {
|
|
if (state.end - state.start < 8) throw new Error("Out of bounds");
|
|
const view = new DataView(
|
|
state.buffer.buffer,
|
|
state.start + state.buffer.byteOffset,
|
|
8
|
|
);
|
|
const n = view.getBigUint64(0, true);
|
|
state.start += 8;
|
|
return n;
|
|
}
|
|
};
|
|
exports.bigint64 = zigZagBigInt(biguint64);
|
|
var biguint = exports.biguint = {
|
|
preencode(state, n) {
|
|
let len = 0;
|
|
for (let m = n; m; m = m >> 64n) len++;
|
|
uint.preencode(state, len);
|
|
state.end += 8 * len;
|
|
},
|
|
encode(state, n) {
|
|
let len = 0;
|
|
for (let m = n; m; m = m >> 64n) len++;
|
|
uint.encode(state, len);
|
|
const view = new DataView(
|
|
state.buffer.buffer,
|
|
state.start + state.buffer.byteOffset,
|
|
8 * len
|
|
);
|
|
for (let m = n, i = 0; m; m = m >> 64n, i += 8) {
|
|
view.setBigUint64(i, BigInt.asUintN(64, m), true);
|
|
}
|
|
state.start += 8 * len;
|
|
},
|
|
decode(state) {
|
|
const len = uint.decode(state);
|
|
if (state.end - state.start < 8 * len) throw new Error("Out of bounds");
|
|
const view = new DataView(
|
|
state.buffer.buffer,
|
|
state.start + state.buffer.byteOffset,
|
|
8 * len
|
|
);
|
|
let n = 0n;
|
|
for (let i = len - 1; i >= 0; i--)
|
|
n = (n << 64n) + view.getBigUint64(i * 8, true);
|
|
state.start += 8 * len;
|
|
return n;
|
|
}
|
|
};
|
|
exports.bigint = zigZagBigInt(biguint);
|
|
exports.lexint = require_lexint();
|
|
exports.float32 = {
|
|
preencode(state, n) {
|
|
state.end += 4;
|
|
},
|
|
encode(state, n) {
|
|
const view = new DataView(
|
|
state.buffer.buffer,
|
|
state.start + state.buffer.byteOffset,
|
|
4
|
|
);
|
|
view.setFloat32(0, n, true);
|
|
state.start += 4;
|
|
},
|
|
decode(state) {
|
|
if (state.end - state.start < 4) throw new Error("Out of bounds");
|
|
const view = new DataView(
|
|
state.buffer.buffer,
|
|
state.start + state.buffer.byteOffset,
|
|
4
|
|
);
|
|
const float = view.getFloat32(0, true);
|
|
state.start += 4;
|
|
return float;
|
|
}
|
|
};
|
|
exports.float64 = {
|
|
preencode(state, n) {
|
|
state.end += 8;
|
|
},
|
|
encode(state, n) {
|
|
const view = new DataView(
|
|
state.buffer.buffer,
|
|
state.start + state.buffer.byteOffset,
|
|
8
|
|
);
|
|
view.setFloat64(0, n, true);
|
|
state.start += 8;
|
|
},
|
|
decode(state) {
|
|
if (state.end - state.start < 8) throw new Error("Out of bounds");
|
|
const view = new DataView(
|
|
state.buffer.buffer,
|
|
state.start + state.buffer.byteOffset,
|
|
8
|
|
);
|
|
const float = view.getFloat64(0, true);
|
|
state.start += 8;
|
|
return float;
|
|
}
|
|
};
|
|
var buffer = exports.buffer = {
|
|
preencode(state, b) {
|
|
uint8array.preencode(state, b);
|
|
},
|
|
encode(state, b) {
|
|
uint8array.encode(state, b);
|
|
},
|
|
decode(state) {
|
|
const len = uint.decode(state);
|
|
if (state.end - state.start < len) throw new Error("Out of bounds");
|
|
return state.buffer.subarray(state.start, state.start += len);
|
|
}
|
|
};
|
|
exports.optionalBuffer = {
|
|
preencode(state, b) {
|
|
if (b) uint8array.preencode(state, b);
|
|
else state.end++;
|
|
},
|
|
encode(state, b) {
|
|
if (b) uint8array.encode(state, b);
|
|
else state.buffer[state.start++] = 0;
|
|
},
|
|
decode(state) {
|
|
const len = uint.decode(state);
|
|
if (len === 0) return null;
|
|
if (state.end - state.start < len) throw new Error("Out of bounds");
|
|
return state.buffer.subarray(state.start, state.start += len);
|
|
}
|
|
};
|
|
exports.binary = {
|
|
...buffer,
|
|
preencode(state, b) {
|
|
if (typeof b === "string") utf8.preencode(state, b);
|
|
else buffer.preencode(state, b);
|
|
},
|
|
encode(state, b) {
|
|
if (typeof b === "string") utf8.encode(state, b);
|
|
else buffer.encode(state, b);
|
|
}
|
|
};
|
|
exports.arraybuffer = {
|
|
preencode(state, b) {
|
|
uint.preencode(state, b.byteLength);
|
|
state.end += b.byteLength;
|
|
},
|
|
encode(state, b) {
|
|
uint.encode(state, b.byteLength);
|
|
const view = new Uint8Array(b);
|
|
state.buffer.set(view, state.start);
|
|
state.start += b.byteLength;
|
|
},
|
|
decode(state) {
|
|
const len = uint.decode(state);
|
|
const b = new ArrayBuffer(len);
|
|
const view = new Uint8Array(b);
|
|
view.set(state.buffer.subarray(state.start, state.start += len));
|
|
return b;
|
|
}
|
|
};
|
|
function typedarray(TypedArray, swap) {
|
|
const n = TypedArray.BYTES_PER_ELEMENT;
|
|
return {
|
|
preencode(state, b) {
|
|
uint.preencode(state, b.length);
|
|
state.end += b.byteLength;
|
|
},
|
|
encode(state, b) {
|
|
uint.encode(state, b.length);
|
|
const view = new Uint8Array(b.buffer, b.byteOffset, b.byteLength);
|
|
if (BE && swap) swap(view);
|
|
state.buffer.set(view, state.start);
|
|
state.start += b.byteLength;
|
|
},
|
|
decode(state) {
|
|
const len = uint.decode(state);
|
|
let b = state.buffer.subarray(state.start, state.start += len * n);
|
|
if (b.byteLength !== len * n) throw new Error("Out of bounds");
|
|
if (b.byteOffset % n !== 0) b = new Uint8Array(b);
|
|
if (BE && swap) swap(b);
|
|
return new TypedArray(b.buffer, b.byteOffset, b.byteLength / n);
|
|
}
|
|
};
|
|
}
|
|
var uint8array = exports.uint8array = typedarray(Uint8Array);
|
|
exports.uint16array = typedarray(Uint16Array, b4a.swap16);
|
|
exports.uint32array = typedarray(Uint32Array, b4a.swap32);
|
|
exports.int8array = typedarray(Int8Array);
|
|
exports.int16array = typedarray(Int16Array, b4a.swap16);
|
|
exports.int32array = typedarray(Int32Array, b4a.swap32);
|
|
exports.biguint64array = typedarray(BigUint64Array, b4a.swap64);
|
|
exports.bigint64array = typedarray(BigInt64Array, b4a.swap64);
|
|
exports.float32array = typedarray(Float32Array, b4a.swap32);
|
|
exports.float64array = typedarray(Float64Array, b4a.swap64);
|
|
function string(encoding) {
|
|
return {
|
|
preencode(state, s) {
|
|
const len = b4a.byteLength(s, encoding);
|
|
uint.preencode(state, len);
|
|
state.end += len;
|
|
},
|
|
encode(state, s) {
|
|
const len = b4a.byteLength(s, encoding);
|
|
uint.encode(state, len);
|
|
b4a.write(state.buffer, s, state.start, encoding);
|
|
state.start += len;
|
|
},
|
|
decode(state) {
|
|
const len = uint.decode(state);
|
|
if (state.end - state.start < len) throw new Error("Out of bounds");
|
|
return b4a.toString(
|
|
state.buffer,
|
|
encoding,
|
|
state.start,
|
|
state.start += len
|
|
);
|
|
},
|
|
fixed(n) {
|
|
return {
|
|
preencode(state) {
|
|
state.end += n;
|
|
},
|
|
encode(state, s) {
|
|
b4a.write(state.buffer, s, state.start, n, encoding);
|
|
state.start += n;
|
|
},
|
|
decode(state) {
|
|
if (state.end - state.start < n) throw new Error("Out of bounds");
|
|
return b4a.toString(
|
|
state.buffer,
|
|
encoding,
|
|
state.start,
|
|
state.start += n
|
|
);
|
|
}
|
|
};
|
|
}
|
|
};
|
|
}
|
|
var utf8 = exports.string = exports.utf8 = string("utf-8");
|
|
exports.ascii = string("ascii");
|
|
exports.hex = string("hex");
|
|
exports.base64 = string("base64");
|
|
exports.ucs2 = exports.utf16le = string("utf16le");
|
|
exports.bool = {
|
|
preencode(state, b) {
|
|
state.end++;
|
|
},
|
|
encode(state, b) {
|
|
state.buffer[state.start++] = b ? 1 : 0;
|
|
},
|
|
decode(state) {
|
|
if (state.start >= state.end) throw Error("Out of bounds");
|
|
return state.buffer[state.start++] === 1;
|
|
}
|
|
};
|
|
var fixed = exports.fixed = function fixed2(n) {
|
|
return {
|
|
preencode(state, s) {
|
|
if (s.byteLength !== n) throw new Error("Incorrect buffer size");
|
|
state.end += n;
|
|
},
|
|
encode(state, s) {
|
|
state.buffer.set(s, state.start);
|
|
state.start += n;
|
|
},
|
|
decode(state) {
|
|
if (state.end - state.start < n) throw new Error("Out of bounds");
|
|
return state.buffer.subarray(state.start, state.start += n);
|
|
}
|
|
};
|
|
};
|
|
exports.fixed32 = fixed(32);
|
|
exports.fixed64 = fixed(64);
|
|
exports.array = function array(enc) {
|
|
return {
|
|
preencode(state, list) {
|
|
uint.preencode(state, list.length);
|
|
for (let i = 0; i < list.length; i++) enc.preencode(state, list[i]);
|
|
},
|
|
encode(state, list) {
|
|
uint.encode(state, list.length);
|
|
for (let i = 0; i < list.length; i++) enc.encode(state, list[i]);
|
|
},
|
|
decode(state) {
|
|
const len = uint.decode(state);
|
|
if (len > 1048576) throw new Error("Array is too big");
|
|
const arr = new Array(len);
|
|
for (let i = 0; i < len; i++) arr[i] = enc.decode(state);
|
|
return arr;
|
|
}
|
|
};
|
|
};
|
|
exports.frame = function frame(enc) {
|
|
const dummy = exports.state();
|
|
return {
|
|
preencode(state, m) {
|
|
const end = state.end;
|
|
enc.preencode(state, m);
|
|
uint.preencode(state, state.end - end);
|
|
},
|
|
encode(state, m) {
|
|
dummy.end = 0;
|
|
enc.preencode(dummy, m);
|
|
uint.encode(state, dummy.end);
|
|
enc.encode(state, m);
|
|
},
|
|
decode(state) {
|
|
const end = state.end;
|
|
const len = uint.decode(state);
|
|
state.end = state.start + len;
|
|
const m = enc.decode(state);
|
|
state.start = state.end;
|
|
state.end = end;
|
|
return m;
|
|
}
|
|
};
|
|
};
|
|
exports.date = {
|
|
preencode(state, d) {
|
|
int.preencode(state, d.getTime());
|
|
},
|
|
encode(state, d) {
|
|
int.encode(state, d.getTime());
|
|
},
|
|
decode(state, d) {
|
|
return new Date(int.decode(state));
|
|
}
|
|
};
|
|
exports.json = {
|
|
preencode(state, v) {
|
|
utf8.preencode(state, JSON.stringify(v));
|
|
},
|
|
encode(state, v) {
|
|
utf8.encode(state, JSON.stringify(v));
|
|
},
|
|
decode(state) {
|
|
return JSON.parse(utf8.decode(state));
|
|
}
|
|
};
|
|
exports.ndjson = {
|
|
preencode(state, v) {
|
|
utf8.preencode(state, JSON.stringify(v) + "\n");
|
|
},
|
|
encode(state, v) {
|
|
utf8.encode(state, JSON.stringify(v) + "\n");
|
|
},
|
|
decode(state) {
|
|
return JSON.parse(utf8.decode(state));
|
|
}
|
|
};
|
|
exports.none = {
|
|
preencode(state, n) {
|
|
},
|
|
encode(state, n) {
|
|
},
|
|
decode(state) {
|
|
return null;
|
|
}
|
|
};
|
|
var anyArray = {
|
|
preencode(state, arr) {
|
|
uint.preencode(state, arr.length);
|
|
for (let i = 0; i < arr.length; i++) {
|
|
any.preencode(state, arr[i]);
|
|
}
|
|
},
|
|
encode(state, arr) {
|
|
uint.encode(state, arr.length);
|
|
for (let i = 0; i < arr.length; i++) {
|
|
any.encode(state, arr[i]);
|
|
}
|
|
},
|
|
decode(state) {
|
|
const arr = [];
|
|
let len = uint.decode(state);
|
|
while (len-- > 0) {
|
|
arr.push(any.decode(state));
|
|
}
|
|
return arr;
|
|
}
|
|
};
|
|
var anyObject = {
|
|
preencode(state, o) {
|
|
const keys = Object.keys(o);
|
|
uint.preencode(state, keys.length);
|
|
for (const key of keys) {
|
|
utf8.preencode(state, key);
|
|
any.preencode(state, o[key]);
|
|
}
|
|
},
|
|
encode(state, o) {
|
|
const keys = Object.keys(o);
|
|
uint.encode(state, keys.length);
|
|
for (const key of keys) {
|
|
utf8.encode(state, key);
|
|
any.encode(state, o[key]);
|
|
}
|
|
},
|
|
decode(state) {
|
|
let len = uint.decode(state);
|
|
const o = {};
|
|
while (len-- > 0) {
|
|
const key = utf8.decode(state);
|
|
o[key] = any.decode(state);
|
|
}
|
|
return o;
|
|
}
|
|
};
|
|
var anyTypes = [
|
|
exports.none,
|
|
exports.bool,
|
|
exports.string,
|
|
exports.buffer,
|
|
exports.uint,
|
|
exports.int,
|
|
exports.float64,
|
|
anyArray,
|
|
anyObject,
|
|
exports.date
|
|
];
|
|
var any = exports.any = {
|
|
preencode(state, o) {
|
|
const t = getType(o);
|
|
uint.preencode(state, t);
|
|
anyTypes[t].preencode(state, o);
|
|
},
|
|
encode(state, o) {
|
|
const t = getType(o);
|
|
uint.encode(state, t);
|
|
anyTypes[t].encode(state, o);
|
|
},
|
|
decode(state) {
|
|
const t = uint.decode(state);
|
|
if (t >= anyTypes.length) throw new Error("Unknown type: " + t);
|
|
return anyTypes[t].decode(state);
|
|
}
|
|
};
|
|
var port = exports.port = uint16;
|
|
var address = (host, family) => {
|
|
return {
|
|
preencode(state, m) {
|
|
host.preencode(state, m.host);
|
|
port.preencode(state, m.port);
|
|
},
|
|
encode(state, m) {
|
|
host.encode(state, m.host);
|
|
port.encode(state, m.port);
|
|
},
|
|
decode(state) {
|
|
return {
|
|
host: host.decode(state),
|
|
family,
|
|
port: port.decode(state)
|
|
};
|
|
}
|
|
};
|
|
};
|
|
var ipv4 = exports.ipv4 = {
|
|
preencode(state) {
|
|
state.end += 4;
|
|
},
|
|
encode(state, string2) {
|
|
const start = state.start;
|
|
const end = start + 4;
|
|
let i = 0;
|
|
while (i < string2.length) {
|
|
let n = 0;
|
|
let c;
|
|
while (i < string2.length && (c = string2.charCodeAt(i++)) !== /* . */
|
|
46) {
|
|
n = n * 10 + (c - /* 0 */
|
|
48);
|
|
}
|
|
state.buffer[state.start++] = n;
|
|
}
|
|
state.start = end;
|
|
},
|
|
decode(state) {
|
|
if (state.end - state.start < 4) throw new Error("Out of bounds");
|
|
return state.buffer[state.start++] + "." + state.buffer[state.start++] + "." + state.buffer[state.start++] + "." + state.buffer[state.start++];
|
|
}
|
|
};
|
|
exports.ipv4Address = address(ipv4, 4);
|
|
var ipv6 = exports.ipv6 = {
|
|
preencode(state) {
|
|
state.end += 16;
|
|
},
|
|
encode(state, string2) {
|
|
const start = state.start;
|
|
const end = start + 16;
|
|
let i = 0;
|
|
let split = null;
|
|
while (i < string2.length) {
|
|
let n = 0;
|
|
let c;
|
|
while (i < string2.length && (c = string2.charCodeAt(i++)) !== /* : */
|
|
58) {
|
|
if (c >= 48 && c <= 57) n = n * 16 + (c - /* 0 */
|
|
48);
|
|
else if (c >= 65 && c <= 70) n = n * 16 + (c - /* A */
|
|
65 + 10);
|
|
else if (c >= 97 && c <= 102) n = n * 16 + (c - /* a */
|
|
97 + 10);
|
|
}
|
|
state.buffer[state.start++] = n >>> 8;
|
|
state.buffer[state.start++] = n;
|
|
if (i < string2.length && string2.charCodeAt(i) === /* : */
|
|
58) {
|
|
i++;
|
|
split = state.start;
|
|
}
|
|
}
|
|
if (split !== null) {
|
|
const offset = end - state.start;
|
|
state.buffer.copyWithin(split + offset, split).fill(0, split, split + offset);
|
|
}
|
|
state.start = end;
|
|
},
|
|
decode(state) {
|
|
if (state.end - state.start < 16) throw new Error("Out of bounds");
|
|
return (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ":" + (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ":" + (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ":" + (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ":" + (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ":" + (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ":" + (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ":" + (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16);
|
|
}
|
|
};
|
|
exports.ipv6Address = address(ipv6, 6);
|
|
var ip = exports.ip = {
|
|
preencode(state, string2) {
|
|
const family = string2.includes(":") ? 6 : 4;
|
|
uint8.preencode(state, family);
|
|
if (family === 4) ipv4.preencode(state);
|
|
else ipv6.preencode(state);
|
|
},
|
|
encode(state, string2) {
|
|
const family = string2.includes(":") ? 6 : 4;
|
|
uint8.encode(state, family);
|
|
if (family === 4) ipv4.encode(state, string2);
|
|
else ipv6.encode(state, string2);
|
|
},
|
|
decode(state) {
|
|
const family = uint8.decode(state);
|
|
if (family === 4) return ipv4.decode(state);
|
|
else return ipv6.decode(state);
|
|
}
|
|
};
|
|
exports.ipAddress = {
|
|
preencode(state, m) {
|
|
ip.preencode(state, m.host);
|
|
port.preencode(state, m.port);
|
|
},
|
|
encode(state, m) {
|
|
ip.encode(state, m.host);
|
|
port.encode(state, m.port);
|
|
},
|
|
decode(state) {
|
|
const family = uint8.decode(state);
|
|
return {
|
|
host: family === 4 ? ipv4.decode(state) : ipv6.decode(state),
|
|
family,
|
|
port: port.decode(state)
|
|
};
|
|
}
|
|
};
|
|
var record = exports.record = function(keyEncoding, valueEncoding) {
|
|
return {
|
|
preencode(state, v) {
|
|
const keys = Object.keys(v);
|
|
uint.preencode(state, keys.length);
|
|
for (const k of keys) {
|
|
keyEncoding.preencode(state, k);
|
|
valueEncoding.preencode(state, v[k]);
|
|
}
|
|
},
|
|
encode(state, v) {
|
|
const keys = Object.keys(v);
|
|
uint.encode(state, keys.length);
|
|
for (const k of keys) {
|
|
keyEncoding.encode(state, k);
|
|
valueEncoding.encode(state, v[k]);
|
|
}
|
|
},
|
|
decode(state) {
|
|
const out = /* @__PURE__ */ Object.create(null);
|
|
const keys = uint.decode(state);
|
|
for (let i = 0; i < keys; i++) {
|
|
out[keyEncoding.decode(state)] = valueEncoding.decode(state);
|
|
}
|
|
return out;
|
|
}
|
|
};
|
|
};
|
|
exports.stringRecord = record(utf8, utf8);
|
|
function getType(o) {
|
|
if (o === null || o === void 0) return 0;
|
|
if (typeof o === "boolean") return 1;
|
|
if (typeof o === "string") return 2;
|
|
if (b4a.isBuffer(o)) return 3;
|
|
if (typeof o === "number") {
|
|
if (Number.isInteger(o)) return o >= 0 ? 4 : 5;
|
|
return 6;
|
|
}
|
|
if (Array.isArray(o)) return 7;
|
|
if (o instanceof Date) return 9;
|
|
if (typeof o === "object") return 8;
|
|
throw new Error("Unsupported type for " + o);
|
|
}
|
|
exports.from = function from(enc) {
|
|
if (typeof enc === "string") return fromNamed(enc);
|
|
if (enc.preencode) return enc;
|
|
if (enc.encodingLength) return fromAbstractEncoder(enc);
|
|
return fromCodec(enc);
|
|
};
|
|
function fromNamed(enc) {
|
|
switch (enc) {
|
|
case "ascii":
|
|
return raw.ascii;
|
|
case "utf-8":
|
|
case "utf8":
|
|
return raw.utf8;
|
|
case "hex":
|
|
return raw.hex;
|
|
case "base64":
|
|
return raw.base64;
|
|
case "utf16-le":
|
|
case "utf16le":
|
|
case "ucs-2":
|
|
case "ucs2":
|
|
return raw.ucs2;
|
|
case "ndjson":
|
|
return raw.ndjson;
|
|
case "json":
|
|
return raw.json;
|
|
case "binary":
|
|
default:
|
|
return raw.binary;
|
|
}
|
|
}
|
|
function fromCodec(enc) {
|
|
let tmpM = null;
|
|
let tmpBuf = null;
|
|
return {
|
|
preencode(state, m) {
|
|
tmpM = m;
|
|
tmpBuf = enc.encode(m);
|
|
state.end += tmpBuf.byteLength;
|
|
},
|
|
encode(state, m) {
|
|
raw.encode(state, m === tmpM ? tmpBuf : enc.encode(m));
|
|
tmpM = tmpBuf = null;
|
|
},
|
|
decode(state) {
|
|
return enc.decode(raw.decode(state));
|
|
}
|
|
};
|
|
}
|
|
function fromAbstractEncoder(enc) {
|
|
return {
|
|
preencode(state, m) {
|
|
state.end += enc.encodingLength(m);
|
|
},
|
|
encode(state, m) {
|
|
enc.encode(m, state.buffer, state.start);
|
|
state.start += enc.encode.bytes;
|
|
},
|
|
decode(state) {
|
|
const m = enc.decode(state.buffer, state.start, state.end);
|
|
state.start += enc.decode.bytes;
|
|
return m;
|
|
}
|
|
};
|
|
}
|
|
exports.encode = function encode(enc, m) {
|
|
const state = exports.state();
|
|
enc.preencode(state, m);
|
|
state.buffer = b4a.allocUnsafe(state.end);
|
|
enc.encode(state, m);
|
|
return state.buffer;
|
|
};
|
|
exports.decode = function decode(enc, buffer2) {
|
|
return enc.decode(exports.state(0, buffer2.byteLength, buffer2));
|
|
};
|
|
function zigZagInt(enc) {
|
|
return {
|
|
preencode(state, n) {
|
|
enc.preencode(state, zigZagEncodeInt(n));
|
|
},
|
|
encode(state, n) {
|
|
enc.encode(state, zigZagEncodeInt(n));
|
|
},
|
|
decode(state) {
|
|
return zigZagDecodeInt(enc.decode(state));
|
|
}
|
|
};
|
|
}
|
|
function zigZagDecodeInt(n) {
|
|
return n === 0 ? n : (n & 1) === 0 ? n / 2 : -(n + 1) / 2;
|
|
}
|
|
function zigZagEncodeInt(n) {
|
|
return n < 0 ? 2 * -n - 1 : n === 0 ? 0 : 2 * n;
|
|
}
|
|
function zigZagBigInt(enc) {
|
|
return {
|
|
preencode(state, n) {
|
|
enc.preencode(state, zigZagEncodeBigInt(n));
|
|
},
|
|
encode(state, n) {
|
|
enc.encode(state, zigZagEncodeBigInt(n));
|
|
},
|
|
decode(state) {
|
|
return zigZagDecodeBigInt(enc.decode(state));
|
|
}
|
|
};
|
|
}
|
|
function zigZagDecodeBigInt(n) {
|
|
return n === 0n ? n : (n & 1n) === 0n ? n / 2n : -(n + 1n) / 2n;
|
|
}
|
|
function zigZagEncodeBigInt(n) {
|
|
return n < 0n ? 2n * -n - 1n : n === 0n ? 0n : 2n * n;
|
|
}
|
|
function validateSafeUint(n) {
|
|
if (n > Number.MAX_SAFE_INTEGER)
|
|
throw new Error(
|
|
"uint is greater than the maximum safe integer, use biguint/bigint"
|
|
);
|
|
return n;
|
|
}
|
|
function validateUint(n) {
|
|
if (n >= 0 === false)
|
|
throw new Error("uint must be positive");
|
|
if (n > Number.MAX_SAFE_INTEGER)
|
|
throw new Error(
|
|
"integer is greater than the maximum safe integer, use biguint/bigint"
|
|
);
|
|
}
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-structured-clone/lib/constants.js
|
|
var require_constants3 = __commonJS({
|
|
"../../node_modules/bare-structured-clone/lib/constants.js"(exports, module) {
|
|
module.exports = {
|
|
VERSION: 0,
|
|
type: {
|
|
// Primitive types
|
|
UNDEFINED: 0,
|
|
NULL: 1,
|
|
TRUE: 2,
|
|
FALSE: 3,
|
|
NUMBER: 4,
|
|
BIGINT: 5,
|
|
STRING: 6,
|
|
// Builtin objects
|
|
DATE: 7,
|
|
REGEXP: 8,
|
|
ERROR: 9,
|
|
// Builtin binary data objects
|
|
ARRAYBUFFER: 10,
|
|
RESIZABLEARRAYBUFFER: 11,
|
|
SHAREDARRAYBUFFER: 12,
|
|
GROWABLESHAREDARRAYBUFFER: 13,
|
|
TYPEDARRAY: 14,
|
|
DATAVIEW: 15,
|
|
// Builtin composite objects
|
|
MAP: 16,
|
|
SET: 17,
|
|
ARRAY: 18,
|
|
OBJECT: 19,
|
|
// Object references
|
|
REFERENCE: 20,
|
|
// Object transfers
|
|
TRANSFER: 21,
|
|
// Platform objects
|
|
URL: 22,
|
|
BUFFER: 23,
|
|
EXTERNAL: 24,
|
|
SERIALIZABLE: 25,
|
|
TRANSFERABLE: 26,
|
|
typedarray: {
|
|
UINT8ARRAY: 1,
|
|
UINT8CLAMPEDARRAY: 2,
|
|
INT8ARRAY: 3,
|
|
UINT16ARRAY: 4,
|
|
INT16ARRAY: 5,
|
|
UINT32ARRAY: 6,
|
|
INT32ARRAY: 7,
|
|
BIGUINT64ARRAY: 8,
|
|
BIGINT64ARRAY: 9,
|
|
FLOAT16ARRAY: 12,
|
|
FLOAT32ARRAY: 10,
|
|
FLOAT64ARRAY: 11
|
|
},
|
|
error: {
|
|
AGGREGATE: 1,
|
|
EVAL: 2,
|
|
RANGE: 3,
|
|
REFERENCE: 4,
|
|
SYNTAX: 5,
|
|
TYPE: 6,
|
|
URI: 7
|
|
}
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-structured-clone/lib/errors.js
|
|
var require_errors2 = __commonJS({
|
|
"../../node_modules/bare-structured-clone/lib/errors.js"(exports, module) {
|
|
module.exports = class DataCloneError extends Error {
|
|
constructor(msg, code, fn = DataCloneError) {
|
|
super(`${code}: ${msg}`);
|
|
this.code = code;
|
|
if (Error.captureStackTrace) {
|
|
Error.captureStackTrace(this, fn);
|
|
}
|
|
}
|
|
get name() {
|
|
return "DataCloneError";
|
|
}
|
|
static INVALID_VERSION(msg) {
|
|
return new DataCloneError(msg, "INVALID_VERSION", DataCloneError.INVALID_VERSION);
|
|
}
|
|
static UNSERIALIZABLE_TYPE(msg) {
|
|
return new DataCloneError(msg, "UNSERIALIZABLE_TYPE", DataCloneError.UNSERIALIZABLE_TYPE);
|
|
}
|
|
static UNTRANSFERABLE_TYPE(msg) {
|
|
return new DataCloneError(msg, "UNTRANSFERABLE_TYPE", DataCloneError.UNTRANSFERABLE_TYPE);
|
|
}
|
|
static ALREADY_TRANSFERRED(msg) {
|
|
return new DataCloneError(msg, "ALREADY_TRANSFERRED", DataCloneError.ALREADY_TRANSFERRED);
|
|
}
|
|
static INVALID_REFERENCE(msg) {
|
|
return new DataCloneError(msg, "INVALID_REFERENCE", DataCloneError.INVALID_REFERENCE);
|
|
}
|
|
static INVALID_INTERFACE(msg) {
|
|
return new DataCloneError(msg, "INVALID_INTERFACE", DataCloneError.INVALID_INTERFACE);
|
|
}
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-structured-clone/binding.js
|
|
var require_binding5 = __commonJS({
|
|
"../../node_modules/bare-structured-clone/binding.js"(exports, module) {
|
|
module.exports = __require.addon();
|
|
}
|
|
});
|
|
|
|
// ../../node_modules/bare-structured-clone/index.js
|
|
var require_bare_structured_clone = __commonJS({
|
|
"../../node_modules/bare-structured-clone/index.js"(exports, module) {
|
|
var getType = require_bare_type();
|
|
var { isURL } = require_bare_url();
|
|
var { isBuffer } = require_bare_buffer();
|
|
var c = require_compact_encoding();
|
|
var constants = require_constants3();
|
|
var errors = require_errors2();
|
|
var binding = require_binding5();
|
|
var t = constants.type;
|
|
module.exports = exports = function structuredClone(value2, opts = {}) {
|
|
return exports.deserializeWithTransfer(
|
|
exports.serializeWithTransfer(value2, opts.transfer, opts.interfaces),
|
|
opts.interfaces
|
|
);
|
|
};
|
|
exports.serialize = function serialize(value2, forStorage = false, interfaces = []) {
|
|
return serializeValue(value2, forStorage, new InterfaceMap(interfaces), new ReferenceMap());
|
|
};
|
|
exports.serializeWithTransfer = function serializeWithTransfer(value2, transferList = [], interfaces = []) {
|
|
return serializeValueWithTransfer(value2, transferList, new InterfaceMap(interfaces));
|
|
};
|
|
exports.deserialize = function deserialize(serialized, interfaces = []) {
|
|
return deserializeValue(serialized, new InterfaceMap(interfaces), /* @__PURE__ */ new Map());
|
|
};
|
|
exports.deserializeWithTransfer = function deserializeWithTransfer(serialized, interfaces = []) {
|
|
return deserializeValueWithTransfer(serialized, new InterfaceMap(interfaces));
|
|
};
|
|
exports.constants = constants;
|
|
exports.errors = errors;
|
|
exports.symbols = {
|
|
serialize: Symbol.for("bare.serialize"),
|
|
deserialize: Symbol.for("bare.deserialize"),
|
|
detach: Symbol.for("bare.detach"),
|
|
attach: Symbol.for("bare.attach"),
|
|
interface: Symbol.for("bare.interface")
|
|
};
|
|
exports.Serializable = class Serializable {
|
|
[exports.symbols.serialize](forStorage) {
|
|
}
|
|
static [exports.symbols.deserialize](serialized) {
|
|
}
|
|
};
|
|
exports.Transferable = class Transferable {
|
|
constructor() {
|
|
this.detached = false;
|
|
}
|
|
[exports.symbols.detach]() {
|
|
this.detached = true;
|
|
}
|
|
static [exports.symbols.attach](serialized) {
|
|
}
|
|
};
|
|
var InterfaceMap = class {
|
|
constructor(interfaces) {
|
|
this.ids = /* @__PURE__ */ new WeakMap();
|
|
this.keys = /* @__PURE__ */ new Map();
|
|
this.interfaces = /* @__PURE__ */ new Map();
|
|
let nextId = 1;
|
|
for (const constructor of interfaces) {
|
|
const id = nextId++;
|
|
this.ids.set(constructor, id);
|
|
const key = constructor[exports.symbols.interface];
|
|
if (key !== void 0) this.keys.set(key, id);
|
|
this.interfaces.set(id, constructor);
|
|
}
|
|
}
|
|
id(constructor) {
|
|
let id = this.ids.get(constructor);
|
|
if (id) return id;
|
|
const key = constructor[exports.symbols.interface];
|
|
if (key !== void 0) {
|
|
id = this.keys.get(key);
|
|
if (id) {
|
|
this.ids.set(constructor, id);
|
|
return id;
|
|
}
|
|
}
|
|
throw errors.INVALID_INTERFACE(
|
|
`Class '${constructor.name}' is not registered as a serializable or transferable interface`
|
|
);
|
|
}
|
|
get(id) {
|
|
const constructor = this.interfaces.get(id);
|
|
if (!constructor) {
|
|
throw errors.INVALID_INTERFACE(`Interface with ID '${id}' was not found`);
|
|
}
|
|
return constructor;
|
|
}
|
|
};
|
|
var ReferenceMap = class {
|
|
constructor() {
|
|
this.ids = /* @__PURE__ */ new WeakMap();
|
|
this.nextId = 1;
|
|
}
|
|
id(object) {
|
|
let id = this.ids.get(object);
|
|
if (id) return id;
|
|
id = this.nextId++;
|
|
this.ids.set(object, id);
|
|
return id;
|
|
}
|
|
has(object) {
|
|
return this.ids.has(object);
|
|
}
|
|
};
|
|
function serializeValue(value2, forStorage, interfaces, references) {
|
|
const type = getType(value2);
|
|
if (type.isUndefined()) return { type: t.UNDEFINED };
|
|
if (type.isNull()) return { type: t.NULL };
|
|
if (type.isBoolean()) return { type: value2 ? t.TRUE : t.FALSE };
|
|
if (type.isNumber()) return { type: t.NUMBER, value: value2 };
|
|
if (type.isBigInt()) return { type: t.BIGINT, value: value2 };
|
|
if (type.isString()) return serializeString(value2);
|
|
if (type.isSymbol()) return serializeSymbol(value2);
|
|
if (type.isObject()) {
|
|
return serializeReferenceable(type, value2, forStorage, interfaces, references);
|
|
}
|
|
if (type.isFunction()) return serializeFunction(value2);
|
|
if (type.isExternal()) return serializeExternal(value2, forStorage, references);
|
|
}
|
|
function serializeString(value2) {
|
|
return { type: t.STRING, value: value2 };
|
|
}
|
|
function serializeSymbol(value2) {
|
|
throw errors.UNSERIALIZABLE_TYPE(`Symbol '${value2.description}' cannot be serialized`);
|
|
}
|
|
function serializeFunction(value2) {
|
|
throw errors.UNSERIALIZABLE_TYPE(`Function '${value2.name}' cannot be serialized`);
|
|
}
|
|
function serializeReferenceable(type, value2, forStorage, interfaces, references) {
|
|
if (references.has(value2)) return serializeReference(value2, references);
|
|
if (isURL(value2)) return serializeURL(value2, references);
|
|
if (isBuffer(value2)) return serializeBuffer(value2, forStorage, interfaces, references);
|
|
if (type.isArray()) return serializeArray(value2, forStorage, interfaces, references);
|
|
if (type.isDate()) return serializeDate(value2, references);
|
|
if (type.isRegExp()) return serializeRegExp(value2, references);
|
|
if (type.isError()) return serializeError(value2, forStorage, interfaces, references);
|
|
if (type.isMap()) return serializeMap(value2, forStorage, interfaces, references);
|
|
if (type.isSet()) return serializeSet(value2, forStorage, interfaces, references);
|
|
if (type.isArrayBuffer()) return serializeArrayBuffer(value2, references);
|
|
if (type.isSharedArrayBuffer()) return serializeSharedArrayBuffer(value2, forStorage, references);
|
|
if (type.isTypedArray()) {
|
|
return serializeTypedArray(type, value2, forStorage, interfaces, references);
|
|
}
|
|
if (type.isDataView()) return serializeDataView(value2, forStorage, interfaces, references);
|
|
if (type.isPromise() || type.isProxy() || type.isWeakMap() || type.isWeakSet() || type.isWeakRef()) {
|
|
throw errors.UNSERIALIZABLE_TYPE(`${value2.constructor.name} cannot be serialized`);
|
|
}
|
|
const serialize = value2[Symbol.for("bare.serialize")];
|
|
if (serialize) return serializeSerializable(value2, serialize, forStorage, interfaces, references);
|
|
return serializeObject(value2, forStorage, interfaces, references);
|
|
}
|
|
function serializeReference(value2, references) {
|
|
return { type: t.REFERENCE, id: references.id(value2) };
|
|
}
|
|
function serializeDate(value2, references) {
|
|
return { type: t.DATE, id: references.id(value2), value: value2.getTime() };
|
|
}
|
|
function serializeRegExp(value2, references) {
|
|
return {
|
|
type: t.REGEXP,
|
|
id: references.id(value2),
|
|
source: value2.source,
|
|
flags: value2.flags
|
|
};
|
|
}
|
|
function serializeError(value2, forStorage, interfaces, references) {
|
|
let name = 0;
|
|
switch (value2.name) {
|
|
case "AggregateError":
|
|
name = t.error.AGGREGATE;
|
|
break;
|
|
case "EvalError":
|
|
name = t.error.EVAL;
|
|
break;
|
|
case "RangeError":
|
|
name = t.error.RANGE;
|
|
break;
|
|
case "ReferenceError":
|
|
name = t.error.REFERENCE;
|
|
break;
|
|
case "SyntaxError":
|
|
name = t.error.SYNTAX;
|
|
break;
|
|
case "TypeError":
|
|
name = t.error.TYPE;
|
|
break;
|
|
case "URIError":
|
|
name = t.error.URI;
|
|
break;
|
|
}
|
|
const serialized = {
|
|
type: t.ERROR,
|
|
id: references.id(value2),
|
|
name,
|
|
message: value2.message.toString(),
|
|
stack: serializeValue(value2.stack, forStorage, interfaces, references)
|
|
};
|
|
if ("cause" in value2) {
|
|
serialized.cause = serializeValue(value2.cause, forStorage, interfaces, references);
|
|
}
|
|
if (name === t.error.AGGREGATE) {
|
|
serialized.errors = value2.errors.map(
|
|
(err) => serializeValue(err, forStorage, interfaces, references)
|
|
);
|
|
}
|
|
return serialized;
|
|
}
|
|
function serializeArrayBuffer(value2, references) {
|
|
if (value2.detached) {
|
|
throw errors.UNSERIALIZABLE_TYPE("Detached ArrayBuffer cannot be serialized");
|
|
}
|
|
const id = references.id(value2);
|
|
if (value2.resizable) {
|
|
return {
|
|
type: t.RESIZABLEARRAYBUFFER,
|
|
id,
|
|
owned: false,
|
|
data: value2,
|
|
maxByteLength: value2.maxByteLength
|
|
};
|
|
}
|
|
return {
|
|
type: t.ARRAYBUFFER,
|
|
id,
|
|
owned: false,
|
|
data: value2
|
|
};
|
|
}
|
|
function serializeSharedArrayBuffer(value2, forStorage, references) {
|
|
if (forStorage) {
|
|
throw errors.UNSERIALIZABLE_TYPE("SharedArrayBuffer cannot be serialized to storage");
|
|
}
|
|
const id = references.id(value2);
|
|
const backingStore = binding.getSharedArrayBufferBackingStore(value2);
|
|
if (value2.growable) {
|
|
return {
|
|
type: t.GROWABLESHAREDARRAYBUFFER,
|
|
id,
|
|
backingStore,
|
|
maxByteLength: value2.maxByteLength
|
|
};
|
|
}
|
|
return {
|
|
type: t.SHAREDARRAYBUFFER,
|
|
id,
|
|
backingStore
|
|
};
|
|
}
|
|
function serializeTypedArray(type, value2, forStorage, interfaces, references) {
|
|
let view;
|
|
if (type.isUint8Array()) {
|
|
view = t.typedarray.UINT8ARRAY;
|
|
} else if (type.isUint8ClampedArray()) {
|
|
view = t.typedarray.UINT8CLAMPEDARRAY;
|
|
} else if (type.isInt8Array()) {
|
|
view = t.typedarray.INT8ARRAY;
|
|
} else if (type.isUint16Array()) {
|
|
view = t.typedarray.UINT16ARRAY;
|
|
} else if (type.isInt16Array()) {
|
|
view = t.typedarray.INT16ARRAY;
|
|
} else if (type.isUint32Array()) {
|
|
view = t.typedarray.UINT32ARRAY;
|
|
} else if (type.isInt32Array()) {
|
|
view = t.typedarray.INT32ARRAY;
|
|
} else if (type.isBigUint64Array()) {
|
|
view = t.typedarray.BIGUINT64ARRAY;
|
|
} else if (type.isBigInt64Array()) {
|
|
view = t.typedarray.BIGINT64ARRAY;
|
|
} else if (type.isFloat16Array()) {
|
|
view = t.typedarray.FLOAT16ARRAY;
|
|
} else if (type.isFloat32Array()) {
|
|
view = t.typedarray.FLOAT32ARRAY;
|
|
} else if (type.isFloat64Array()) {
|
|
view = t.typedarray.FLOAT64ARRAY;
|
|
}
|
|
return {
|
|
type: t.TYPEDARRAY,
|
|
id: references.id(value2),
|
|
view,
|
|
buffer: serializeValue(value2.buffer, forStorage, interfaces, references),
|
|
byteOffset: value2.byteOffset,
|
|
byteLength: value2.byteLength,
|
|
length: value2.length
|
|
};
|
|
}
|
|
function serializeDataView(value2, forStorage, interfaces, references) {
|
|
return {
|
|
type: t.DATAVIEW,
|
|
id: references.id(references),
|
|
buffer: serializeValue(value2.buffer, forStorage, interfaces, references),
|
|
byteOffset: value2.byteOffset,
|
|
byteLength: value2.byteLength
|
|
};
|
|
}
|
|
function serializeMap(value2, forStorage, interfaces, references) {
|
|
const id = references.id(value2);
|
|
const data = [];
|
|
for (const entry2 of value2) {
|
|
const [key, value3] = entry2;
|
|
data.push({
|
|
key: serializeValue(key, forStorage, interfaces, references),
|
|
value: serializeValue(value3, forStorage, interfaces, references)
|
|
});
|
|
}
|
|
return { type: t.MAP, id, data };
|
|
}
|
|
function serializeSet(value2, forStorage, interfaces, references) {
|
|
const id = references.id(value2);
|
|
const data = [];
|
|
for (const entry2 of value2) {
|
|
data.push(serializeValue(entry2, forStorage, interfaces, references));
|
|
}
|
|
return { type: t.SET, id, data };
|
|
}
|
|
function serializeArray(value2, forStorage, interfaces, references) {
|
|
const id = references.id(value2);
|
|
const properties2 = [];
|
|
for (const entry2 of Object.entries(value2)) {
|
|
const [key, value3] = entry2;
|
|
properties2.push({
|
|
key,
|
|
value: serializeValue(value3, forStorage, interfaces, references)
|
|
});
|
|
}
|
|
return { type: t.ARRAY, id, length: value2.length, properties: properties2 };
|
|
}
|
|
function serializeObject(value2, forStorage, interfaces, references) {
|
|
const id = references.id(value2);
|
|
const properties2 = [];
|
|
for (const entry2 of Object.entries(value2)) {
|
|
const [key, value3] = entry2;
|
|
properties2.push({
|
|
key,
|
|
value: serializeValue(value3, forStorage, interfaces, references)
|
|
});
|
|
}
|
|
return { type: t.OBJECT, id, properties: properties2 };
|
|
}
|
|
function serializeURL(value2, references) {
|
|
return { type: t.URL, id: references.id(value2), href: value2.href };
|
|
}
|
|
function serializeBuffer(value2, forStorage, interfaces, references) {
|
|
if (value2.detached) {
|
|
throw errors.UNSERIALIZABLE_TYPE("Detached Buffer cannot be serialized");
|
|
}
|
|
return {
|
|
type: t.BUFFER,
|
|
id: references.id(value2),
|
|
buffer: serializeValue(value2.buffer, forStorage, interfaces, references),
|
|
byteOffset: value2.byteOffset,
|
|
byteLength: value2.byteLength
|
|
};
|
|
}
|
|
function serializeExternal(value2, forStorage) {
|
|
if (forStorage) {
|
|
throw errors.UNSERIALIZABLE_TYPE("External pointer cannot be serialized to storage");
|
|
}
|
|
return {
|
|
type: t.EXTERNAL,
|
|
pointer: binding.getExternal(value2)
|
|
};
|
|
}
|
|
function serializeSerializable(value2, serializer, forStorage, interfaces, references) {
|
|
return {
|
|
type: t.SERIALIZABLE,
|
|
id: references.id(value2),
|
|
interface: interfaces.id(value2.constructor),
|
|
value: serializeValue(serializer.call(value2, forStorage), forStorage, interfaces, references)
|
|
};
|
|
}
|
|
function serializeValueWithTransfer(value2, transferList, interfaces) {
|
|
const references = new ReferenceMap();
|
|
for (const transferable of transferList) {
|
|
const type = getType(transferable);
|
|
if (type.isArrayBuffer()) {
|
|
if (transferable.detached) {
|
|
throw errors.UNTRANSFERABLE_TYPE("Detached 'ArrayBuffer' cannot be transferred");
|
|
}
|
|
if (references.has(transferable)) {
|
|
throw errors.ALREADY_TRANSFERRED("'ArrayBuffer' has already been transferred");
|
|
}
|
|
references.id(transferable);
|
|
} else {
|
|
const detach = transferable[exports.symbols.detach];
|
|
if (detach) {
|
|
if (transferable.detached) {
|
|
throw errors.UNTRANSFERABLE_TYPE(
|
|
`Detached '${transferable.constructor.name}' cannot be transferred`
|
|
);
|
|
}
|
|
if (references.has(transferable)) {
|
|
throw errors.ALREADY_TRANSFERRED(
|
|
`'${transferable.constructor.name}' has already been transferred`
|
|
);
|
|
}
|
|
references.id(transferable);
|
|
} else {
|
|
throw errors.UNTRANSFERABLE_TYPE("Value cannot be transferred");
|
|
}
|
|
}
|
|
}
|
|
const serialized = serializeValue(value2, false, interfaces, references);
|
|
const transfers2 = [];
|
|
for (const transferable of transferList) {
|
|
const type = getType(transferable);
|
|
if (type.isArrayBuffer()) {
|
|
if (transferable.detached) {
|
|
throw errors.UNTRANSFERABLE_TYPE("Detached ArrayBuffer cannot be transferred");
|
|
}
|
|
const backingStore = binding.getArrayBufferBackingStore(transferable);
|
|
const id = references.id(transferable);
|
|
let transfer2;
|
|
if (value2.resizable) {
|
|
transfer2 = {
|
|
type: t.RESIZABLEARRAYBUFFER,
|
|
id,
|
|
backingStore,
|
|
maxByteLength: value2.maxByteLength
|
|
};
|
|
} else {
|
|
transfer2 = { type: t.ARRAYBUFFER, id, backingStore };
|
|
}
|
|
transfers2.push(transfer2);
|
|
binding.detachArrayBuffer(transferable);
|
|
} else {
|
|
if (transferable.detached) {
|
|
throw errors.UNTRANSFERABLE_TYPE(
|
|
`Detached '${transferable.constructor.name}' cannot be transferred`
|
|
);
|
|
}
|
|
const detach = transferable[exports.symbols.detach];
|
|
const transfer2 = {
|
|
type: t.TRANSFERABLE,
|
|
id: references.id(transferable),
|
|
interface: interfaces.id(transferable.constructor),
|
|
value: serializeValue(detach.call(transferable), false, interfaces, references)
|
|
};
|
|
transfers2.push(transfer2);
|
|
}
|
|
}
|
|
return { type: t.TRANSFER, transfers: transfers2, value: serialized };
|
|
}
|
|
function deserializeValue(serialized, interfaces, references) {
|
|
let value2;
|
|
switch (serialized.type) {
|
|
case t.UNDEFINED:
|
|
return void 0;
|
|
case t.NULL:
|
|
return null;
|
|
case t.TRUE:
|
|
return true;
|
|
case t.FALSE:
|
|
return false;
|
|
case t.NUMBER:
|
|
case t.BIGINT:
|
|
case t.STRING:
|
|
return serialized.value;
|
|
case t.EXTERNAL:
|
|
return binding.createExternal(serialized.pointer);
|
|
case t.DATE:
|
|
value2 = new Date(serialized.value);
|
|
break;
|
|
case t.REGEXP:
|
|
value2 = new RegExp(serialized.source, serialized.flags);
|
|
break;
|
|
case t.ERROR: {
|
|
const options = {};
|
|
if ("cause" in serialized) {
|
|
options.case = deserializeValue(serialized.cause, interfaces, references);
|
|
}
|
|
switch (serialized.name) {
|
|
case t.error.AGGREGATE:
|
|
value2 = new AggregateError(
|
|
serialized.errors.map((err) => deserializeValue(err, interfaces, references)),
|
|
serialized.message,
|
|
options
|
|
);
|
|
break;
|
|
case t.error.EVAL:
|
|
value2 = new EvalError(serialized.message, options);
|
|
break;
|
|
case t.error.RANGE:
|
|
value2 = new RangeError(serialized.message, options);
|
|
break;
|
|
case t.error.REFERENCE:
|
|
value2 = new ReferenceError(serialized.message, options);
|
|
break;
|
|
case t.error.SYNTAX:
|
|
value2 = new SyntaxError(serialized.message, options);
|
|
break;
|
|
case t.error.TYPE:
|
|
value2 = new TypeError(serialized.message, options);
|
|
break;
|
|
default:
|
|
value2 = new Error(serialized.message, options);
|
|
}
|
|
value2.stack = deserializeValue(serialized.stack, interfaces, references);
|
|
break;
|
|
}
|
|
case t.ARRAYBUFFER:
|
|
if (serialized.owned) value2 = serialized.data;
|
|
else {
|
|
value2 = new ArrayBuffer(serialized.data.byteLength);
|
|
Buffer.from(value2).set(Buffer.from(serialized.data));
|
|
}
|
|
break;
|
|
case t.RESIZABLEARRAYBUFFER:
|
|
if (serialized.owned) value2 = serialized.data;
|
|
else {
|
|
value2 = new ArrayBuffer(serialized.data.byteLength, {
|
|
maxByteLength: serialized.maxByteLength
|
|
});
|
|
Buffer.from(value2).set(Buffer.from(serialized.data));
|
|
}
|
|
break;
|
|
case t.SHAREDARRAYBUFFER:
|
|
case t.GROWABLESHAREDARRAYBUFFER:
|
|
value2 = binding.createSharedArrayBuffer(serialized.backingStore);
|
|
Buffer.from(serialized.backingStore).fill(0);
|
|
break;
|
|
case t.TYPEDARRAY: {
|
|
const buffer = deserializeValue(serialized.buffer, interfaces, references);
|
|
switch (serialized.view) {
|
|
case t.typedarray.UINT8ARRAY:
|
|
value2 = new Uint8Array(buffer, serialized.byteOffset, serialized.length);
|
|
break;
|
|
case t.typedarray.UINT8CLAMPEDARRAY:
|
|
value2 = new Uint8ClampedArray(buffer, serialized.byteOffset, serialized.length);
|
|
break;
|
|
case t.typedarray.INT8ARRAY:
|
|
value2 = new Int8Array(buffer, serialized.byteOffset, serialized.length);
|
|
break;
|
|
case t.typedarray.UINT16ARRAY:
|
|
value2 = new Uint16Array(buffer, serialized.byteOffset, serialized.length);
|
|
break;
|
|
case t.typedarray.INT16ARRAY:
|
|
value2 = new Int16Array(buffer, serialized.byteOffset, serialized.length);
|
|
break;
|
|
case t.typedarray.UINT32ARRAY:
|
|
value2 = new Uint32Array(buffer, serialized.byteOffset, serialized.length);
|
|
break;
|
|
case t.typedarray.INT32ARRAY:
|
|
value2 = new Int32Array(buffer, serialized.byteOffset, serialized.length);
|
|
break;
|
|
case t.typedarray.BIGUINT64ARRAY:
|
|
value2 = new BigUint64Array(buffer, serialized.byteOffset, serialized.length);
|
|
break;
|
|
case t.typedarray.BIGINT64ARRAY:
|
|
value2 = new BigInt64Array(buffer, serialized.byteOffset, serialized.length);
|
|
break;
|
|
case t.typedarray.FLOAT16ARRAY:
|
|
value2 = new Float16Array(buffer, serialized.byteOffset, serialized.length);
|
|
break;
|
|
case t.typedarray.FLOAT32ARRAY:
|
|
value2 = new Float32Array(buffer, serialized.byteOffset, serialized.length);
|
|
break;
|
|
case t.typedarray.FLOAT64ARRAY:
|
|
value2 = new Float64Array(buffer, serialized.byteOffset, serialized.length);
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case t.DATAVIEW:
|
|
value2 = new DataView(
|
|
deserializeValue(serialized.buffer, interfaces, references),
|
|
serialized.byteOffset,
|
|
serialized.byteLength
|
|
);
|
|
break;
|
|
case t.MAP:
|
|
value2 = /* @__PURE__ */ new Map();
|
|
break;
|
|
case t.SET:
|
|
value2 = /* @__PURE__ */ new Set();
|
|
break;
|
|
case t.ARRAY:
|
|
value2 = new Array(serialized.length);
|
|
break;
|
|
case t.OBJECT:
|
|
value2 = {};
|
|
break;
|
|
case t.REFERENCE:
|
|
if (references.has(serialized.id)) value2 = references.get(serialized.id);
|
|
else {
|
|
throw errors.INVALID_REFERENCE(`Object with ID '${serialized.id}' was not found`);
|
|
}
|
|
return value2;
|
|
case t.URL:
|
|
return new URL(serialized.href);
|
|
case t.BUFFER:
|
|
value2 = Buffer.from(
|
|
deserializeValue(serialized.buffer, interfaces, references),
|
|
serialized.byteOffset,
|
|
serialized.byteLength
|
|
);
|
|
break;
|
|
case t.SERIALIZABLE: {
|
|
const constructor = interfaces.get(serialized.interface);
|
|
const deserialize = constructor[exports.symbols.deserialize];
|
|
value2 = deserialize.call(
|
|
constructor,
|
|
deserializeValue(serialized.value, interfaces, references)
|
|
);
|
|
break;
|
|
}
|
|
}
|
|
references.set(serialized.id, value2);
|
|
switch (serialized.type) {
|
|
case t.MAP:
|
|
for (const entry2 of serialized.data) {
|
|
value2.set(
|
|
deserializeValue(entry2.key, interfaces, references),
|
|
deserializeValue(entry2.value, interfaces, references)
|
|
);
|
|
}
|
|
break;
|
|
case t.SET:
|
|
for (const entry2 of serialized.data) {
|
|
value2.add(deserializeValue(entry2, interfaces, references));
|
|
}
|
|
break;
|
|
case t.ARRAY:
|
|
case t.OBJECT:
|
|
for (const entry2 of serialized.properties) {
|
|
value2[entry2.key] = deserializeValue(entry2.value, interfaces, references);
|
|
}
|
|
break;
|
|
}
|
|
return value2;
|
|
}
|
|
function deserializeValueWithTransfer(serialized, interfaces) {
|
|
const references = /* @__PURE__ */ new Map();
|
|
for (const transfer2 of serialized.transfers) {
|
|
switch (transfer2.type) {
|
|
case t.ARRAYBUFFER:
|
|
case t.RESIZABLEARRAYBUFFER:
|
|
references.set(transfer2.id, binding.createArrayBuffer(transfer2.backingStore));
|
|
break;
|
|
case t.TRANSFERABLE: {
|
|
const constructor = interfaces.get(transfer2.interface);
|
|
const attach = constructor[exports.symbols.attach];
|
|
references.set(
|
|
transfer2.id,
|
|
attach.call(constructor, deserializeValue(transfer2.value, interfaces, references))
|
|
);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return deserializeValue(serialized.value, interfaces, references);
|
|
}
|
|
var header = {
|
|
preencode(state) {
|
|
c.uint.preencode(state, constants.VERSION);
|
|
c.uint.preencode(state, 0);
|
|
},
|
|
encode(state) {
|
|
c.uint.encode(state, constants.VERSION);
|
|
c.uint.encode(state, 0);
|
|
},
|
|
decode(state) {
|
|
const version = c.uint.decode(state);
|
|
if (version !== constants.VERSION) {
|
|
throw errors.INVALID_VERSION(`Invalid ABI version '${version}'`);
|
|
}
|
|
c.uint.decode(state);
|
|
}
|
|
};
|
|
var property = {
|
|
preencode(state, m) {
|
|
c.string.preencode(state, m.key);
|
|
value.preencode(state, m.value);
|
|
},
|
|
encode(state, m) {
|
|
c.string.encode(state, m.key);
|
|
value.encode(state, m.value);
|
|
},
|
|
decode(state) {
|
|
return {
|
|
key: c.string.decode(state),
|
|
value: value.decode(state)
|
|
};
|
|
}
|
|
};
|
|
var properties = c.array(property);
|
|
var entry = {
|
|
preencode(state, m) {
|
|
value.preencode(state, m.key);
|
|
value.preencode(state, m.value);
|
|
},
|
|
encode(state, m) {
|
|
value.encode(state, m.key);
|
|
value.encode(state, m.value);
|
|
},
|
|
decode(state) {
|
|
return {
|
|
key: value.decode(state),
|
|
value: value.decode(state)
|
|
};
|
|
}
|
|
};
|
|
var entries = c.array(entry);
|
|
var transfer = {
|
|
preencode(state, m) {
|
|
c.uint.preencode(state, m.type);
|
|
c.uint.preencode(state, m.id);
|
|
switch (m.type) {
|
|
case t.ARRAYBUFFER:
|
|
c.arraybuffer.preencode(state, m.backingStore);
|
|
break;
|
|
case t.RESIZABLEARRAYBUFFER:
|
|
c.arraybuffer.preencode(state, m.backingStore);
|
|
c.uint.preencode(state, m.maxByteLength);
|
|
break;
|
|
case t.TRANSFERABLE:
|
|
c.uint.preencode(state, m.interface);
|
|
value.preencode(state, m.value);
|
|
break;
|
|
}
|
|
},
|
|
encode(state, m) {
|
|
c.uint.encode(state, m.type);
|
|
c.uint.encode(state, m.id);
|
|
switch (m.type) {
|
|
case t.ARRAYBUFFER:
|
|
c.arraybuffer.encode(state, m.backingStore);
|
|
break;
|
|
case t.RESIZABLEARRAYBUFFER:
|
|
c.arraybuffer.encode(state, m.backingStore);
|
|
c.uint.encode(state, m.maxByteLength);
|
|
break;
|
|
case t.TRANSFERABLE:
|
|
c.uint.encode(state, m.interface);
|
|
value.encode(state, m.value);
|
|
break;
|
|
}
|
|
},
|
|
decode(state) {
|
|
const type = c.uint.decode(state);
|
|
const id = c.uint.decode(state);
|
|
switch (type) {
|
|
case t.ARRAYBUFFER:
|
|
return {
|
|
type,
|
|
id,
|
|
backingStore: c.arraybuffer.decode(state)
|
|
};
|
|
case t.RESIZABLEARRAYBUFFER:
|
|
return {
|
|
type,
|
|
id,
|
|
backingStore: c.arraybuffer.decode(state),
|
|
maxByteLength: c.uint.decode(state)
|
|
};
|
|
case t.TRANSFERABLE:
|
|
return {
|
|
type,
|
|
id,
|
|
interface: c.uint.decode(state),
|
|
value: value.decode(state)
|
|
};
|
|
}
|
|
}
|
|
};
|
|
var transfers = c.array(transfer);
|
|
var value = {
|
|
preencode(state, m) {
|
|
c.uint.preencode(state, m.type);
|
|
switch (m.type) {
|
|
case t.UNDEFINED:
|
|
case t.NULL:
|
|
case t.TRUE:
|
|
case t.FALSE:
|
|
return;
|
|
case t.NUMBER:
|
|
return c.float64.preencode(state, m.value);
|
|
case t.BIGINT:
|
|
return c.bigint.preencode(state, m.value);
|
|
case t.STRING:
|
|
return c.string.preencode(state, m.value);
|
|
case t.EXTERNAL:
|
|
return c.arraybuffer.preencode(state, m.pointer);
|
|
case t.TRANSFER:
|
|
transfers.preencode(state, m.transfers);
|
|
value.preencode(state, m.value);
|
|
return;
|
|
}
|
|
c.uint.preencode(state, m.type);
|
|
switch (m.type) {
|
|
case t.DATE:
|
|
c.int.preencode(state, m.value);
|
|
break;
|
|
case t.REGEXP:
|
|
c.string.preencode(state, m.source);
|
|
c.string.preencode(state, m.flags);
|
|
break;
|
|
case t.ERROR:
|
|
c.uint.preencode(state, 0);
|
|
c.uint.preencode(state, m.name);
|
|
c.string.preencode(state, m.message);
|
|
value.preencode(state, m.stack);
|
|
if ("cause" in m) value.preencode(state, m.cause);
|
|
if (m.name === t.error.AGGREGATE) values.preencode(state, m.errors);
|
|
break;
|
|
case t.ARRAYBUFFER:
|
|
c.arraybuffer.preencode(state, m.data);
|
|
break;
|
|
case t.RESIZABLEARRAYBUFFER:
|
|
c.arraybuffer.preencode(state, m.data);
|
|
c.uint.preencode(state, m.maxByteLength);
|
|
break;
|
|
case t.SHAREDARRAYBUFFER:
|
|
c.arraybuffer.preencode(state, m.backingStore);
|
|
break;
|
|
case t.GROWABLESHAREDARRAYBUFFER:
|
|
c.arraybuffer.preencode(state, m.backingStore);
|
|
c.uint.preencode(state, m.maxByteLength);
|
|
break;
|
|
case t.TYPEDARRAY:
|
|
c.uint.preencode(state, m.view);
|
|
value.preencode(state, m.buffer);
|
|
c.uint.preencode(state, m.byteOffset);
|
|
c.uint.preencode(state, m.byteLength);
|
|
c.uint.preencode(state, m.length);
|
|
break;
|
|
case t.DATAVIEW:
|
|
value.preencode(state, m.buffer);
|
|
c.uint.preencode(state, m.byteOffset);
|
|
c.uint.preencode(state, m.byteLength);
|
|
break;
|
|
case t.MAP:
|
|
entries.preencode(state, m.data);
|
|
break;
|
|
case t.SET:
|
|
values.preencode(state, m.data);
|
|
break;
|
|
case t.ARRAY:
|
|
c.uint.preencode(state, m.length);
|
|
properties.preencode(state, m.properties);
|
|
break;
|
|
case t.OBJECT:
|
|
properties.preencode(state, m.properties);
|
|
break;
|
|
case t.REFERENCE:
|
|
break;
|
|
case t.URL:
|
|
c.string.preencode(state, m.href);
|
|
break;
|
|
case t.BUFFER:
|
|
value.preencode(state, m.buffer);
|
|
c.uint.preencode(state, m.byteOffset);
|
|
c.uint.preencode(state, m.byteLength);
|
|
break;
|
|
case t.SERIALIZABLE:
|
|
c.uint.preencode(state, m.interface);
|
|
value.preencode(state, m.value);
|
|
break;
|
|
}
|
|
},
|
|
encode(state, m) {
|
|
c.uint.encode(state, m.type);
|
|
switch (m.type) {
|
|
case t.UNDEFINED:
|
|
case t.NULL:
|
|
case t.TRUE:
|
|
case t.FALSE:
|
|
return;
|
|
case t.NUMBER:
|
|
return c.float64.encode(state, m.value);
|
|
case t.BIGINT:
|
|
return c.bigint.encode(state, m.value);
|
|
case t.STRING:
|
|
return c.string.encode(state, m.value);
|
|
case t.EXTERNAL:
|
|
return c.arraybuffer.encode(state, m.pointer);
|
|
case t.TRANSFER:
|
|
transfers.encode(state, m.transfers);
|
|
value.encode(state, m.value);
|
|
return;
|
|
}
|
|
c.uint.encode(state, m.id);
|
|
switch (m.type) {
|
|
case t.DATE:
|
|
c.int.encode(state, m.value);
|
|
break;
|
|
case t.REGEXP:
|
|
c.string.encode(state, m.source);
|
|
c.string.encode(state, m.flags);
|
|
break;
|
|
case t.ERROR:
|
|
c.uint.encode(state, "cause" in m ? 1 : 0);
|
|
c.uint.encode(state, m.name);
|
|
c.string.encode(state, m.message);
|
|
value.encode(state, m.stack);
|
|
if ("cause" in m) value.encode(state, m.cause);
|
|
if (m.name === t.error.AGGREGATE) values.encode(state, m.errors);
|
|
break;
|
|
case t.ARRAYBUFFER:
|
|
c.arraybuffer.encode(state, m.data);
|
|
break;
|
|
case t.RESIZABLEARRAYBUFFER:
|
|
c.arraybuffer.encode(state, m.data);
|
|
c.uint.encode(state, m.maxByteLength);
|
|
break;
|
|
case t.SHAREDARRAYBUFFER:
|
|
c.arraybuffer.encode(state, m.backingStore);
|
|
break;
|
|
case t.GROWABLESHAREDARRAYBUFFER:
|
|
c.arraybuffer.encode(state, m.backingStore);
|
|
c.uint.encode(state, m.maxByteLength);
|
|
break;
|
|
case t.TYPEDARRAY:
|
|
c.uint.encode(state, m.view);
|
|
value.encode(state, m.buffer);
|
|
c.uint.encode(state, m.byteOffset);
|
|
c.uint.encode(state, m.byteLength);
|
|
c.uint.encode(state, m.length);
|
|
break;
|
|
case t.DATAVIEW:
|
|
value.encode(state, m.buffer);
|
|
c.uint.encode(state, m.byteOffset);
|
|
c.uint.encode(state, m.byteLength);
|
|
break;
|
|
case t.MAP:
|
|
entries.encode(state, m.data);
|
|
break;
|
|
case t.SET:
|
|
values.encode(state, m.data);
|
|
break;
|
|
case t.ARRAY:
|
|
c.uint.encode(state, m.length);
|
|
properties.encode(state, m.properties);
|
|
break;
|
|
case t.OBJECT:
|
|
properties.encode(state, m.properties);
|
|
break;
|
|
case t.REFERENCE:
|
|
break;
|
|
case t.URL:
|
|
c.string.encode(state, m.href);
|
|
break;
|
|
case t.BUFFER:
|
|
value.encode(state, m.buffer);
|
|
c.uint.encode(state, m.byteOffset);
|
|
c.uint.encode(state, m.byteLength);
|
|
break;
|
|
case t.SERIALIZABLE:
|
|
c.uint.encode(state, m.interface);
|
|
value.encode(state, m.value);
|
|
break;
|
|
}
|
|
},
|
|
decode(state) {
|
|
const type = c.uint.decode(state);
|
|
switch (type) {
|
|
case t.UNDEFINED:
|
|
case t.NULL:
|
|
case t.TRUE:
|
|
case t.FALSE:
|
|
return {
|
|
type
|
|
};
|
|
case t.NUMBER:
|
|
return {
|
|
type,
|
|
value: c.float64.decode(state)
|
|
};
|
|
case t.BIGINT:
|
|
return {
|
|
type,
|
|
value: c.bigint.decode(state)
|
|
};
|
|
case t.STRING:
|
|
return {
|
|
type,
|
|
value: c.string.decode(state)
|
|
};
|
|
case t.EXTERNAL:
|
|
return {
|
|
type,
|
|
pointer: c.arraybuffer.decode(state)
|
|
};
|
|
case t.TRANSFER:
|
|
return {
|
|
type,
|
|
transfers: transfers.decode(state),
|
|
value: value.decode(state)
|
|
};
|
|
}
|
|
const id = c.uint.decode(state);
|
|
switch (type) {
|
|
case t.DATE:
|
|
return {
|
|
type,
|
|
id,
|
|
value: c.int.decode(state)
|
|
};
|
|
case t.REGEXP:
|
|
return {
|
|
type,
|
|
id,
|
|
source: c.string.decode(state),
|
|
flags: c.string.decode(state)
|
|
};
|
|
case t.ERROR: {
|
|
const flags = c.uint.decode(state);
|
|
const hasCause = (flags & 1) !== 0;
|
|
const m = {
|
|
type,
|
|
id,
|
|
name: c.uint.decode(state),
|
|
message: c.string.decode(state),
|
|
stack: value.decode(state)
|
|
};
|
|
if (hasCause) m.cause = value.decode(state);
|
|
if (m.name === t.error.AGGREGATE) m.errors = values.decode(state);
|
|
return m;
|
|
}
|
|
case t.ARRAYBUFFER:
|
|
return {
|
|
type,
|
|
id,
|
|
owned: true,
|
|
data: c.arraybuffer.decode(state)
|
|
};
|
|
case t.RESIZABLEARRAYBUFFER:
|
|
return {
|
|
type,
|
|
id,
|
|
owned: true,
|
|
data: c.arraybuffer.decode(state),
|
|
maxByteLength: c.uint.decode(state)
|
|
};
|
|
case t.SHAREDARRAYBUFFER:
|
|
return {
|
|
type,
|
|
id,
|
|
backingStore: c.arraybuffer.decode(state)
|
|
};
|
|
case t.GROWABLESHAREDARRAYBUFFER:
|
|
return {
|
|
type,
|
|
id,
|
|
backingStore: c.arraybuffer.decode(state),
|
|
maxByteLength: c.uint.decode(state)
|
|
};
|
|
case t.TYPEDARRAY:
|
|
return {
|
|
type,
|
|
id,
|
|
view: c.uint.decode(state),
|
|
buffer: value.decode(state),
|
|
byteOffset: c.uint.decode(state),
|
|
byteLength: c.uint.decode(state),
|
|
length: c.uint.decode(state)
|
|
};
|
|
case t.DATAVIEW:
|
|
return {
|
|
type,
|
|
id,
|
|
buffer: value.decode(state),
|
|
byteOffset: c.uint.decode(state),
|
|
byteLength: c.uint.decode(state)
|
|
};
|
|
case t.MAP:
|
|
return {
|
|
type,
|
|
id,
|
|
data: entries.decode(state)
|
|
};
|
|
case t.SET:
|
|
return {
|
|
type,
|
|
id,
|
|
data: values.decode(state)
|
|
};
|
|
case t.ARRAY:
|
|
return {
|
|
type,
|
|
id,
|
|
length: c.uint.decode(state),
|
|
properties: properties.decode(state)
|
|
};
|
|
case t.OBJECT:
|
|
return {
|
|
type,
|
|
id,
|
|
properties: properties.decode(state)
|
|
};
|
|
case t.REFERENCE:
|
|
return {
|
|
type,
|
|
id
|
|
};
|
|
case t.URL:
|
|
return {
|
|
type,
|
|
id,
|
|
href: c.string.decode(state)
|
|
};
|
|
case t.BUFFER:
|
|
return {
|
|
type,
|
|
id,
|
|
buffer: value.decode(state),
|
|
byteOffset: c.uint.decode(state),
|
|
byteLength: c.uint.decode(state)
|
|
};
|
|
case t.SERIALIZABLE:
|
|
return {
|
|
type,
|
|
id,
|
|
interface: c.uint.decode(state),
|
|
value: value.decode(state)
|
|
};
|
|
}
|
|
}
|
|
};
|
|
var values = c.array(value);
|
|
exports.preencode = function preencode(state, m) {
|
|
header.preencode(state);
|
|
value.preencode(state, m);
|
|
};
|
|
exports.encode = function encode(state, m) {
|
|
header.encode(state);
|
|
value.encode(state, m);
|
|
};
|
|
exports.decode = function decode(state) {
|
|
header.decode(state);
|
|
return value.decode(state);
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../bare-lib-entry-bareStructuredClone.js
|
|
var bare_lib_entry_bareStructuredClone_exports = {};
|
|
__export(bare_lib_entry_bareStructuredClone_exports, {
|
|
default: () => bare_lib_entry_bareStructuredClone_default
|
|
});
|
|
var import_bare_structured_clone = __toESM(require_bare_structured_clone());
|
|
var bare_lib_entry_bareStructuredClone_default = import_bare_structured_clone.default;
|
|
return __toCommonJS(bare_lib_entry_bareStructuredClone_exports);
|
|
})();
|
|
;(function(){var g=globalThis;var s="__bare_os_stdlib__";g[s]=g[s]||{};var e=typeof __bare_os_bundle_exports__!=="undefined"?__bare_os_bundle_exports__:void 0;var v=e!=null&&typeof e==="object"&&Object.prototype.hasOwnProperty.call(e,"default")?e.default:e;g[s]["bareStructuredClone"]=v;})();
|