@dan-uni/dan-any
Version:
A danmaku transformer lib, supporting danmaku from different platforms.
981 lines (980 loc) • 618 kB
JavaScript
/*! For license information please see index.min.js.LICENSE.txt */
import { __webpack_require__ } from "./rslib-runtime.min.js";
import "reflect-metadata/lite";
import { IsDate, IsEmail, IsEnum, IsInt, IsNotEmpty, IsNumber, IsOptional, IsString, Max, Min, isEmail, isJSON, isObject, isString, validateOrReject } from "class-validator";
import { XMLBuilder, XMLParser } from "fast-xml-parser";
import json_bigint from "json-bigint";
import { create, fromBinary, toBinary } from "@bufbuild/protobuf";
import { file_google_protobuf_timestamp, timestampDate, timestampFromDate, timestampNow } from "@bufbuild/protobuf/wkt";
import { Expose, plainToInstance } from "class-transformer";
import hh_mm_ss from "hh-mm-ss";
import jssha from "jssha";
import { decode, encode as external_base16384_encode } from "base16384";
import { fileDesc, messageDesc as codegenv2_messageDesc } from "@bufbuild/protobuf/codegenv2";
__webpack_require__.add({
"../../node_modules/.pnpm/assert@2.1.0/node_modules/assert/build/assert.js" (module, __unused_rspack_exports, __webpack_require__) {
var process = __webpack_require__("../../node_modules/.pnpm/process@0.11.10/node_modules/process/browser.js");
function _typeof(o) {
return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
return typeof o;
} : function(o) {
return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
}, _typeof(o);
}
function _defineProperties(target, props) {
for(var i = 0; i < props.length; i++){
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
}
}
function _createClass(Constructor, protoProps, staticProps) {
if (protoProps) _defineProperties(Constructor.prototype, protoProps);
if (staticProps) _defineProperties(Constructor, staticProps);
Object.defineProperty(Constructor, "prototype", {
writable: false
});
return Constructor;
}
function _toPropertyKey(arg) {
var key = _toPrimitive(arg, "string");
return "symbol" === _typeof(key) ? key : String(key);
}
function _toPrimitive(input, hint) {
if ("object" !== _typeof(input) || null === input) return input;
var prim = input[Symbol.toPrimitive];
if (void 0 !== prim) {
var res = prim.call(input, hint || "default");
if ("object" !== _typeof(res)) return res;
throw new TypeError("@@toPrimitive must return a primitive value.");
}
return ("string" === hint ? String : Number)(input);
}
function _classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
}
var _require = __webpack_require__("../../node_modules/.pnpm/assert@2.1.0/node_modules/assert/build/internal/errors.js"), _require$codes = _require.codes, ERR_AMBIGUOUS_ARGUMENT = _require$codes.ERR_AMBIGUOUS_ARGUMENT, ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE, ERR_INVALID_ARG_VALUE = _require$codes.ERR_INVALID_ARG_VALUE, ERR_INVALID_RETURN_VALUE = _require$codes.ERR_INVALID_RETURN_VALUE, ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS;
var AssertionError = __webpack_require__("../../node_modules/.pnpm/assert@2.1.0/node_modules/assert/build/internal/assert/assertion_error.js");
var _require2 = __webpack_require__("../../node_modules/.pnpm/util@0.12.5/node_modules/util/util.js"), inspect = _require2.inspect;
var _require$types = __webpack_require__("../../node_modules/.pnpm/util@0.12.5/node_modules/util/util.js").types, isPromise = _require$types.isPromise, isRegExp = _require$types.isRegExp;
var objectAssign = __webpack_require__("../../node_modules/.pnpm/object.assign@4.1.7/node_modules/object.assign/polyfill.js")();
var objectIs = __webpack_require__("../../node_modules/.pnpm/object-is@1.1.6/node_modules/object-is/polyfill.js")();
var RegExpPrototypeTest = __webpack_require__("../../node_modules/.pnpm/call-bind@1.0.8/node_modules/call-bind/callBound.js")('RegExp.prototype.test');
new Map();
var isDeepEqual;
var isDeepStrictEqual;
function lazyLoadComparison() {
var comparison = __webpack_require__("../../node_modules/.pnpm/assert@2.1.0/node_modules/assert/build/internal/util/comparisons.js");
isDeepEqual = comparison.isDeepEqual;
isDeepStrictEqual = comparison.isDeepStrictEqual;
}
var warned = false;
var assert = module.exports = ok;
var NO_EXCEPTION_SENTINEL = {};
function innerFail(obj) {
if (obj.message instanceof Error) throw obj.message;
throw new AssertionError(obj);
}
function fail(actual, expected, message, operator, stackStartFn) {
var argsLen = arguments.length;
var internalMessage;
if (0 === argsLen) internalMessage = 'Failed';
else if (1 === argsLen) {
message = actual;
actual = void 0;
} else {
if (false === warned) {
warned = true;
var warn = process.emitWarning ? process.emitWarning : console.warn.bind(console);
warn("assert.fail() with more than one argument is deprecated. Please use assert.strictEqual() instead or only pass a message.", 'DeprecationWarning', 'DEP0094');
}
if (2 === argsLen) operator = '!=';
}
if (message instanceof Error) throw message;
var errArgs = {
actual: actual,
expected: expected,
operator: void 0 === operator ? 'fail' : operator,
stackStartFn: stackStartFn || fail
};
if (void 0 !== message) errArgs.message = message;
var err = new AssertionError(errArgs);
if (internalMessage) {
err.message = internalMessage;
err.generatedMessage = true;
}
throw err;
}
assert.fail = fail;
assert.AssertionError = AssertionError;
function innerOk(fn, argLen, value, message) {
if (!value) {
var generatedMessage = false;
if (0 === argLen) {
generatedMessage = true;
message = 'No value argument passed to `assert.ok()`';
} else if (message instanceof Error) throw message;
var err = new AssertionError({
actual: value,
expected: true,
message: message,
operator: '==',
stackStartFn: fn
});
err.generatedMessage = generatedMessage;
throw err;
}
}
function ok() {
for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++)args[_key] = arguments[_key];
innerOk.apply(void 0, [
ok,
args.length
].concat(args));
}
assert.ok = ok;
assert.equal = function equal(actual, expected, message) {
if (arguments.length < 2) throw new ERR_MISSING_ARGS('actual', 'expected');
if (actual != expected) innerFail({
actual: actual,
expected: expected,
message: message,
operator: '==',
stackStartFn: equal
});
};
assert.notEqual = function notEqual(actual, expected, message) {
if (arguments.length < 2) throw new ERR_MISSING_ARGS('actual', 'expected');
if (actual == expected) innerFail({
actual: actual,
expected: expected,
message: message,
operator: '!=',
stackStartFn: notEqual
});
};
assert.deepEqual = function deepEqual(actual, expected, message) {
if (arguments.length < 2) throw new ERR_MISSING_ARGS('actual', 'expected');
if (void 0 === isDeepEqual) lazyLoadComparison();
if (!isDeepEqual(actual, expected)) innerFail({
actual: actual,
expected: expected,
message: message,
operator: 'deepEqual',
stackStartFn: deepEqual
});
};
assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
if (arguments.length < 2) throw new ERR_MISSING_ARGS('actual', 'expected');
if (void 0 === isDeepEqual) lazyLoadComparison();
if (isDeepEqual(actual, expected)) innerFail({
actual: actual,
expected: expected,
message: message,
operator: 'notDeepEqual',
stackStartFn: notDeepEqual
});
};
assert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {
if (arguments.length < 2) throw new ERR_MISSING_ARGS('actual', 'expected');
if (void 0 === isDeepEqual) lazyLoadComparison();
if (!isDeepStrictEqual(actual, expected)) innerFail({
actual: actual,
expected: expected,
message: message,
operator: 'deepStrictEqual',
stackStartFn: deepStrictEqual
});
};
assert.notDeepStrictEqual = notDeepStrictEqual;
function notDeepStrictEqual(actual, expected, message) {
if (arguments.length < 2) throw new ERR_MISSING_ARGS('actual', 'expected');
if (void 0 === isDeepEqual) lazyLoadComparison();
if (isDeepStrictEqual(actual, expected)) innerFail({
actual: actual,
expected: expected,
message: message,
operator: 'notDeepStrictEqual',
stackStartFn: notDeepStrictEqual
});
}
assert.strictEqual = function strictEqual(actual, expected, message) {
if (arguments.length < 2) throw new ERR_MISSING_ARGS('actual', 'expected');
if (!objectIs(actual, expected)) innerFail({
actual: actual,
expected: expected,
message: message,
operator: 'strictEqual',
stackStartFn: strictEqual
});
};
assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
if (arguments.length < 2) throw new ERR_MISSING_ARGS('actual', 'expected');
if (objectIs(actual, expected)) innerFail({
actual: actual,
expected: expected,
message: message,
operator: 'notStrictEqual',
stackStartFn: notStrictEqual
});
};
var Comparison = /*#__PURE__*/ _createClass(function Comparison(obj, keys, actual) {
var _this = this;
_classCallCheck(this, Comparison);
keys.forEach(function(key) {
if (key in obj) if (void 0 !== actual && 'string' == typeof actual[key] && isRegExp(obj[key]) && RegExpPrototypeTest(obj[key], actual[key])) _this[key] = actual[key];
else _this[key] = obj[key];
});
});
function compareExceptionKey(actual, expected, key, message, keys, fn) {
if (!(key in actual) || !isDeepStrictEqual(actual[key], expected[key])) {
if (!message) {
var a = new Comparison(actual, keys);
var b = new Comparison(expected, keys, actual);
var err = new AssertionError({
actual: a,
expected: b,
operator: 'deepStrictEqual',
stackStartFn: fn
});
err.actual = actual;
err.expected = expected;
err.operator = fn.name;
throw err;
}
innerFail({
actual: actual,
expected: expected,
message: message,
operator: fn.name,
stackStartFn: fn
});
}
}
function expectedException(actual, expected, msg, fn) {
if ('function' != typeof expected) {
if (isRegExp(expected)) return RegExpPrototypeTest(expected, actual);
if (2 === arguments.length) throw new ERR_INVALID_ARG_TYPE('expected', [
'Function',
'RegExp'
], expected);
if ('object' !== _typeof(actual) || null === actual) {
var err = new AssertionError({
actual: actual,
expected: expected,
message: msg,
operator: 'deepStrictEqual',
stackStartFn: fn
});
err.operator = fn.name;
throw err;
}
var keys = Object.keys(expected);
if (expected instanceof Error) keys.push('name', 'message');
else if (0 === keys.length) throw new ERR_INVALID_ARG_VALUE('error', expected, 'may not be an empty object');
if (void 0 === isDeepEqual) lazyLoadComparison();
keys.forEach(function(key) {
if ('string' == typeof actual[key] && isRegExp(expected[key]) && RegExpPrototypeTest(expected[key], actual[key])) return;
compareExceptionKey(actual, expected, key, msg, keys, fn);
});
return true;
}
if (void 0 !== expected.prototype && actual instanceof expected) return true;
if (Error.isPrototypeOf(expected)) return false;
return true === expected.call({}, actual);
}
function getActual(fn) {
if ('function' != typeof fn) throw new ERR_INVALID_ARG_TYPE('fn', 'Function', fn);
try {
fn();
} catch (e) {
return e;
}
return NO_EXCEPTION_SENTINEL;
}
function checkIsPromise(obj) {
return isPromise(obj) || null !== obj && 'object' === _typeof(obj) && 'function' == typeof obj.then && 'function' == typeof obj.catch;
}
function waitForActual(promiseFn) {
return Promise.resolve().then(function() {
var resultPromise;
if ('function' == typeof promiseFn) {
resultPromise = promiseFn();
if (!checkIsPromise(resultPromise)) throw new ERR_INVALID_RETURN_VALUE('instance of Promise', 'promiseFn', resultPromise);
} else if (checkIsPromise(promiseFn)) resultPromise = promiseFn;
else throw new ERR_INVALID_ARG_TYPE('promiseFn', [
'Function',
'Promise'
], promiseFn);
return Promise.resolve().then(function() {
return resultPromise;
}).then(function() {
return NO_EXCEPTION_SENTINEL;
}).catch(function(e) {
return e;
});
});
}
function expectsError(stackStartFn, actual, error, message) {
if ('string' == typeof error) {
if (4 === arguments.length) throw new ERR_INVALID_ARG_TYPE('error', [
'Object',
'Error',
'Function',
'RegExp'
], error);
if ('object' === _typeof(actual) && null !== actual) {
if (actual.message === error) throw new ERR_AMBIGUOUS_ARGUMENT('error/message', "The error message \"".concat(actual.message, "\" is identical to the message."));
} else if (actual === error) throw new ERR_AMBIGUOUS_ARGUMENT('error/message', "The error \"".concat(actual, "\" is identical to the message."));
message = error;
error = void 0;
} else if (null != error && 'object' !== _typeof(error) && 'function' != typeof error) throw new ERR_INVALID_ARG_TYPE('error', [
'Object',
'Error',
'Function',
'RegExp'
], error);
if (actual === NO_EXCEPTION_SENTINEL) {
var details = '';
if (error && error.name) details += " (".concat(error.name, ")");
details += message ? ": ".concat(message) : '.';
var fnType = 'rejects' === stackStartFn.name ? 'rejection' : 'exception';
innerFail({
actual: void 0,
expected: error,
operator: stackStartFn.name,
message: "Missing expected ".concat(fnType).concat(details),
stackStartFn: stackStartFn
});
}
if (error && !expectedException(actual, error, message, stackStartFn)) throw actual;
}
function expectsNoError(stackStartFn, actual, error, message) {
if (actual === NO_EXCEPTION_SENTINEL) return;
if ('string' == typeof error) {
message = error;
error = void 0;
}
if (!error || expectedException(actual, error)) {
var details = message ? ": ".concat(message) : '.';
var fnType = 'doesNotReject' === stackStartFn.name ? 'rejection' : 'exception';
innerFail({
actual: actual,
expected: error,
operator: stackStartFn.name,
message: "Got unwanted ".concat(fnType).concat(details, "\n") + "Actual message: \"".concat(actual && actual.message, "\""),
stackStartFn: stackStartFn
});
}
throw actual;
}
assert.throws = function throws(promiseFn) {
for(var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++)args[_key2 - 1] = arguments[_key2];
expectsError.apply(void 0, [
throws,
getActual(promiseFn)
].concat(args));
};
assert.rejects = function rejects(promiseFn) {
for(var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++)args[_key3 - 1] = arguments[_key3];
return waitForActual(promiseFn).then(function(result) {
return expectsError.apply(void 0, [
rejects,
result
].concat(args));
});
};
assert.doesNotThrow = function doesNotThrow(fn) {
for(var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++)args[_key4 - 1] = arguments[_key4];
expectsNoError.apply(void 0, [
doesNotThrow,
getActual(fn)
].concat(args));
};
assert.doesNotReject = function doesNotReject(fn) {
for(var _len5 = arguments.length, args = new Array(_len5 > 1 ? _len5 - 1 : 0), _key5 = 1; _key5 < _len5; _key5++)args[_key5 - 1] = arguments[_key5];
return waitForActual(fn).then(function(result) {
return expectsNoError.apply(void 0, [
doesNotReject,
result
].concat(args));
});
};
assert.ifError = function ifError(err) {
if (null != err) {
var message = 'ifError got unwanted exception: ';
if ('object' === _typeof(err) && 'string' == typeof err.message) if (0 === err.message.length && err.constructor) message += err.constructor.name;
else message += err.message;
else message += inspect(err);
var newErr = new AssertionError({
actual: err,
expected: null,
operator: 'ifError',
message: message,
stackStartFn: ifError
});
var origStack = err.stack;
if ('string' == typeof origStack) {
var tmp2 = origStack.split('\n');
tmp2.shift();
var tmp1 = newErr.stack.split('\n');
for(var i = 0; i < tmp2.length; i++){
var pos = tmp1.indexOf(tmp2[i]);
if (-1 !== pos) {
tmp1 = tmp1.slice(0, pos);
break;
}
}
newErr.stack = "".concat(tmp1.join('\n'), "\n").concat(tmp2.join('\n'));
}
throw newErr;
}
};
function internalMatch(string, regexp, message, fn, fnName) {
if (!isRegExp(regexp)) throw new ERR_INVALID_ARG_TYPE('regexp', 'RegExp', regexp);
var match = 'match' === fnName;
if ('string' != typeof string || RegExpPrototypeTest(regexp, string) !== match) {
if (message instanceof Error) throw message;
var generatedMessage = !message;
message = message || ('string' != typeof string ? 'The "string" argument must be of type string. Received type ' + "".concat(_typeof(string), " (").concat(inspect(string), ")") : (match ? 'The input did not match the regular expression ' : 'The input was expected to not match the regular expression ') + "".concat(inspect(regexp), ". Input:\n\n").concat(inspect(string), "\n"));
var err = new AssertionError({
actual: string,
expected: regexp,
message: message,
operator: fnName,
stackStartFn: fn
});
err.generatedMessage = generatedMessage;
throw err;
}
}
assert.match = function match(string, regexp, message) {
internalMatch(string, regexp, message, match, 'match');
};
assert.doesNotMatch = function doesNotMatch(string, regexp, message) {
internalMatch(string, regexp, message, doesNotMatch, 'doesNotMatch');
};
function strict() {
for(var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++)args[_key6] = arguments[_key6];
innerOk.apply(void 0, [
strict,
args.length
].concat(args));
}
assert.strict = objectAssign(strict, assert, {
equal: assert.strictEqual,
deepEqual: assert.deepStrictEqual,
notEqual: assert.notStrictEqual,
notDeepEqual: assert.notDeepStrictEqual
});
assert.strict.strict = assert.strict;
},
"../../node_modules/.pnpm/assert@2.1.0/node_modules/assert/build/internal/assert/assertion_error.js" (module, __unused_rspack_exports, __webpack_require__) {
var process = __webpack_require__("../../node_modules/.pnpm/process@0.11.10/node_modules/process/browser.js");
function ownKeys(e, r) {
var t = Object.keys(e);
if (Object.getOwnPropertySymbols) {
var o = Object.getOwnPropertySymbols(e);
r && (o = o.filter(function(r) {
return Object.getOwnPropertyDescriptor(e, r).enumerable;
})), t.push.apply(t, o);
}
return t;
}
function _objectSpread(e) {
for(var r = 1; r < arguments.length; r++){
var t = null != arguments[r] ? arguments[r] : {};
r % 2 ? ownKeys(Object(t), !0).forEach(function(r) {
_defineProperty(e, r, t[r]);
}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r) {
Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
});
}
return e;
}
function _defineProperty(obj, key, value) {
key = _toPropertyKey(key);
if (key in obj) Object.defineProperty(obj, key, {
value: value,
enumerable: true,
configurable: true,
writable: true
});
else obj[key] = value;
return obj;
}
function _classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
}
function _defineProperties(target, props) {
for(var i = 0; i < props.length; i++){
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
}
}
function _createClass(Constructor, protoProps, staticProps) {
if (protoProps) _defineProperties(Constructor.prototype, protoProps);
if (staticProps) _defineProperties(Constructor, staticProps);
Object.defineProperty(Constructor, "prototype", {
writable: false
});
return Constructor;
}
function _toPropertyKey(arg) {
var key = _toPrimitive(arg, "string");
return "symbol" === _typeof(key) ? key : String(key);
}
function _toPrimitive(input, hint) {
if ("object" !== _typeof(input) || null === input) return input;
var prim = input[Symbol.toPrimitive];
if (void 0 !== prim) {
var res = prim.call(input, hint || "default");
if ("object" !== _typeof(res)) return res;
throw new TypeError("@@toPrimitive must return a primitive value.");
}
return ("string" === hint ? String : Number)(input);
}
function _inherits(subClass, superClass) {
if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function");
subClass.prototype = Object.create(superClass && superClass.prototype, {
constructor: {
value: subClass,
writable: true,
configurable: true
}
});
Object.defineProperty(subClass, "prototype", {
writable: false
});
if (superClass) _setPrototypeOf(subClass, superClass);
}
function _createSuper(Derived) {
var hasNativeReflectConstruct = _isNativeReflectConstruct();
return function() {
var Super = _getPrototypeOf(Derived), result;
if (hasNativeReflectConstruct) {
var NewTarget = _getPrototypeOf(this).constructor;
result = Reflect.construct(Super, arguments, NewTarget);
} else result = Super.apply(this, arguments);
return _possibleConstructorReturn(this, result);
};
}
function _possibleConstructorReturn(self1, call) {
if (call && ("object" === _typeof(call) || "function" == typeof call)) return call;
if (void 0 !== call) throw new TypeError("Derived constructors may only return object or undefined");
return _assertThisInitialized(self1);
}
function _assertThisInitialized(self1) {
if (void 0 === self1) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
return self1;
}
function _wrapNativeSuper(Class) {
var _cache = "function" == typeof Map ? new Map() : void 0;
_wrapNativeSuper = function(Class) {
if (null === Class || !_isNativeFunction(Class)) return Class;
if ("function" != typeof Class) throw new TypeError("Super expression must either be null or a function");
if (void 0 !== _cache) {
if (_cache.has(Class)) return _cache.get(Class);
_cache.set(Class, Wrapper);
}
function Wrapper() {
return _construct(Class, arguments, _getPrototypeOf(this).constructor);
}
Wrapper.prototype = Object.create(Class.prototype, {
constructor: {
value: Wrapper,
enumerable: false,
writable: true,
configurable: true
}
});
return _setPrototypeOf(Wrapper, Class);
};
return _wrapNativeSuper(Class);
}
function _construct(Parent, args, Class) {
_construct = _isNativeReflectConstruct() ? Reflect.construct.bind() : function(Parent, args, Class) {
var a = [
null
];
a.push.apply(a, args);
var Constructor = Function.bind.apply(Parent, a);
var instance = new Constructor();
if (Class) _setPrototypeOf(instance, Class.prototype);
return instance;
};
return _construct.apply(null, arguments);
}
function _isNativeReflectConstruct() {
if ("u" < typeof Reflect || !Reflect.construct) return false;
if (Reflect.construct.sham) return false;
if ("function" == typeof Proxy) return true;
try {
Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
return true;
} catch (e) {
return false;
}
}
function _isNativeFunction(fn) {
return -1 !== Function.toString.call(fn).indexOf("[native code]");
}
function _setPrototypeOf(o, p) {
_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(o, p) {
o.__proto__ = p;
return o;
};
return _setPrototypeOf(o, p);
}
function _getPrototypeOf(o) {
_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(o) {
return o.__proto__ || Object.getPrototypeOf(o);
};
return _getPrototypeOf(o);
}
function _typeof(o) {
return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
return typeof o;
} : function(o) {
return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
}, _typeof(o);
}
var _require = __webpack_require__("../../node_modules/.pnpm/util@0.12.5/node_modules/util/util.js"), inspect = _require.inspect;
var _require2 = __webpack_require__("../../node_modules/.pnpm/assert@2.1.0/node_modules/assert/build/internal/errors.js"), ERR_INVALID_ARG_TYPE = _require2.codes.ERR_INVALID_ARG_TYPE;
function endsWith(str, search, this_len) {
if (void 0 === this_len || this_len > str.length) this_len = str.length;
return str.substring(this_len - search.length, this_len) === search;
}
function repeat(str, count) {
count = Math.floor(count);
if (0 == str.length || 0 == count) return '';
var maxCount = str.length * count;
count = Math.floor(Math.log(count) / Math.log(2));
while(count){
str += str;
count--;
}
str += str.substring(0, maxCount - str.length);
return str;
}
var blue = '';
var green = '';
var red = '';
var white = '';
var kReadableOperator = {
deepStrictEqual: 'Expected values to be strictly deep-equal:',
strictEqual: 'Expected values to be strictly equal:',
strictEqualObject: 'Expected "actual" to be reference-equal to "expected":',
deepEqual: 'Expected values to be loosely deep-equal:',
equal: 'Expected values to be loosely equal:',
notDeepStrictEqual: 'Expected "actual" not to be strictly deep-equal to:',
notStrictEqual: 'Expected "actual" to be strictly unequal to:',
notStrictEqualObject: 'Expected "actual" not to be reference-equal to "expected":',
notDeepEqual: 'Expected "actual" not to be loosely deep-equal to:',
notEqual: 'Expected "actual" to be loosely unequal to:',
notIdentical: 'Values identical but not reference-equal:'
};
var kMaxShortLength = 10;
function copyError(source) {
var keys = Object.keys(source);
var target = Object.create(Object.getPrototypeOf(source));
keys.forEach(function(key) {
target[key] = source[key];
});
Object.defineProperty(target, 'message', {
value: source.message
});
return target;
}
function inspectValue(val) {
return inspect(val, {
compact: false,
customInspect: false,
depth: 1000,
maxArrayLength: 1 / 0,
showHidden: false,
breakLength: 1 / 0,
showProxy: false,
sorted: true,
getters: true
});
}
function createErrDiff(actual, expected, operator) {
var other = '';
var res = '';
var lastPos = 0;
var end = '';
var skipped = false;
var actualInspected = inspectValue(actual);
var actualLines = actualInspected.split('\n');
var expectedLines = inspectValue(expected).split('\n');
var i = 0;
var indicator = '';
if ('strictEqual' === operator && 'object' === _typeof(actual) && 'object' === _typeof(expected) && null !== actual && null !== expected) operator = 'strictEqualObject';
if (1 === actualLines.length && 1 === expectedLines.length && actualLines[0] !== expectedLines[0]) {
var inputLength = actualLines[0].length + expectedLines[0].length;
if (inputLength <= kMaxShortLength) {
if (('object' !== _typeof(actual) || null === actual) && ('object' !== _typeof(expected) || null === expected) && (0 !== actual || 0 !== expected)) return "".concat(kReadableOperator[operator], "\n\n") + "".concat(actualLines[0], " !== ").concat(expectedLines[0], "\n");
} else if ('strictEqualObject' !== operator) {
var maxLength = process.stderr && process.stderr.isTTY ? process.stderr.columns : 80;
if (inputLength < maxLength) {
while(actualLines[0][i] === expectedLines[0][i])i++;
if (i > 2) {
indicator = "\n ".concat(repeat(' ', i), "^");
i = 0;
}
}
}
}
var a = actualLines[actualLines.length - 1];
var b = expectedLines[expectedLines.length - 1];
while(a === b){
if (i++ < 2) end = "\n ".concat(a).concat(end);
else other = a;
actualLines.pop();
expectedLines.pop();
if (0 === actualLines.length || 0 === expectedLines.length) break;
a = actualLines[actualLines.length - 1];
b = expectedLines[expectedLines.length - 1];
}
var maxLines = Math.max(actualLines.length, expectedLines.length);
if (0 === maxLines) {
var _actualLines = actualInspected.split('\n');
if (_actualLines.length > 30) {
_actualLines[26] = "".concat(blue, "...").concat(white);
while(_actualLines.length > 27)_actualLines.pop();
}
return "".concat(kReadableOperator.notIdentical, "\n\n").concat(_actualLines.join('\n'), "\n");
}
if (i > 3) {
end = "\n".concat(blue, "...").concat(white).concat(end);
skipped = true;
}
if ('' !== other) {
end = "\n ".concat(other).concat(end);
other = '';
}
var printedLines = 0;
var msg = kReadableOperator[operator] + "\n".concat(green, "+ actual").concat(white, " ").concat(red, "- expected").concat(white);
var skippedMsg = " ".concat(blue, "...").concat(white, " Lines skipped");
for(i = 0; i < maxLines; i++){
var cur = i - lastPos;
if (actualLines.length < i + 1) {
if (cur > 1 && i > 2) {
if (cur > 4) {
res += "\n".concat(blue, "...").concat(white);
skipped = true;
} else if (cur > 3) {
res += "\n ".concat(expectedLines[i - 2]);
printedLines++;
}
res += "\n ".concat(expectedLines[i - 1]);
printedLines++;
}
lastPos = i;
other += "\n".concat(red, "-").concat(white, " ").concat(expectedLines[i]);
printedLines++;
} else if (expectedLines.length < i + 1) {
if (cur > 1 && i > 2) {
if (cur > 4) {
res += "\n".concat(blue, "...").concat(white);
skipped = true;
} else if (cur > 3) {
res += "\n ".concat(actualLines[i - 2]);
printedLines++;
}
res += "\n ".concat(actualLines[i - 1]);
printedLines++;
}
lastPos = i;
res += "\n".concat(green, "+").concat(white, " ").concat(actualLines[i]);
printedLines++;
} else {
var expectedLine = expectedLines[i];
var actualLine = actualLines[i];
var divergingLines = actualLine !== expectedLine && (!endsWith(actualLine, ',') || actualLine.slice(0, -1) !== expectedLine);
if (divergingLines && endsWith(expectedLine, ',') && expectedLine.slice(0, -1) === actualLine) {
divergingLines = false;
actualLine += ',';
}
if (divergingLines) {
if (cur > 1 && i > 2) {
if (cur > 4) {
res += "\n".concat(blue, "...").concat(white);
skipped = true;
} else if (cur > 3) {
res += "\n ".concat(actualLines[i - 2]);
printedLines++;
}
res += "\n ".concat(actualLines[i - 1]);
printedLines++;
}
lastPos = i;
res += "\n".concat(green, "+").concat(white, " ").concat(actualLine);
other += "\n".concat(red, "-").concat(white, " ").concat(expectedLine);
printedLines += 2;
} else {
res += other;
other = '';
if (1 === cur || 0 === i) {
res += "\n ".concat(actualLine);
printedLines++;
}
}
}
if (printedLines > 20 && i < maxLines - 2) return "".concat(msg).concat(skippedMsg, "\n").concat(res, "\n").concat(blue, "...").concat(white).concat(other, "\n") + "".concat(blue, "...").concat(white);
}
return "".concat(msg).concat(skipped ? skippedMsg : '', "\n").concat(res).concat(other).concat(end).concat(indicator);
}
var AssertionError = /*#__PURE__*/ function(_Error, _inspect$custom) {
_inherits(AssertionError, _Error);
var _super = _createSuper(AssertionError);
function AssertionError(options) {
var _this;
_classCallCheck(this, AssertionError);
if ('object' !== _typeof(options) || null === options) throw new ERR_INVALID_ARG_TYPE('options', 'Object', options);
var message = options.message, operator = options.operator, stackStartFn = options.stackStartFn;
var actual = options.actual, expected = options.expected;
var limit = Error.stackTraceLimit;
Error.stackTraceLimit = 0;
if (null != message) _this = _super.call(this, String(message));
else {
if (process.stderr && process.stderr.isTTY) if (process.stderr && process.stderr.getColorDepth && 1 !== process.stderr.getColorDepth()) {
blue = "\x1B[34m";
green = "\x1B[32m";
white = "\x1B[39m";
red = "\x1B[31m";
} else {
blue = '';
green = '';
white = '';
red = '';
}
if ('object' === _typeof(actual) && null !== actual && 'object' === _typeof(expected) && null !== expected && 'stack' in actual && actual instanceof Error && 'stack' in expected && expected instanceof Error) {
actual = copyError(actual);
expected = copyError(expected);
}
if ('deepStrictEqual' === operator || 'strictEqual' === operator) _this = _super.call(this, createErrDiff(actual, expected, operator));
else if ('notDeepStrictEqual' === operator || 'notStrictEqual' === operator) {
var base = kReadableOperator[operator];
var res = inspectValue(actual).split('\n');
if ('notStrictEqual' === operator && 'object' === _typeof(actual) && null !== actual) base = kReadableOperator.notStrictEqualObject;
if (res.length > 30) {
res[26] = "".concat(blue, "...").concat(white);
while(res.length > 27)res.pop();
}
_this = 1 === res.length ? _super.call(this, "".concat(base, " ").concat(res[0])) : _super.call(this, "".concat(base, "\n\n").concat(res.join('\n'), "\n"));
} else {
var _res = inspectValue(actual);
var other = '';
var knownOperators = kReadableOperator[operator];
if ('notDeepEqual' === operator || 'notEqual' === operator) {
_res = "".concat(kReadableOperator[operator], "\n\n").concat(_res);
if (_res.length > 1024) _res = "".concat(_res.slice(0, 1021), "...");
} else {
other = "".concat(inspectValue(expected));
if (_res.length > 512) _res = "".concat(_res.slice(0, 509), "...");
if (other.length > 512) other = "".concat(other.slice(0, 509), "...");
if ('deepEqual' === operator || 'equal' === operator) _res = "".concat(knownOperators, "\n\n").concat(_res, "\n\nshould equal\n\n");
else other = " ".concat(operator, " ").concat(other);
}
_this = _super.call(this, "".concat(_res).concat(other));
}
}
Error.stackTraceLimit = limit;
_this.generatedMessage = !message;
Object.defineProperty(_assertThisInitialized(_this), 'name', {
value: 'AssertionError [ERR_ASSERTION]',
enumerable: false,
writable: true,
configurable: true
});
_this.code = 'ERR_ASSERTION';
_this.actual = actual;
_this.expected = expected;
_this.operator = operator;
if (Error.captureStackTrace) Error.captureStackTrace(_assertThisInitialized(_this), stackStartFn);
_this.stack;
_this.name = 'AssertionError';
return _possibleConstructorReturn(_this);
}
_createClass(AssertionError, [
{
key: "toString",
value: function() {
return "".concat(this.name, " [").concat(this.code, "]: ").concat(this.message);
}
},
{
key: _inspect$custom,
value: function(recurseTimes, ctx) {
return inspect(this, _objectSpread(_objectSpread({}, ctx), {}, {
customInspect: false,
depth: 0
}));
}
}
]);
return AssertionError;
}(/*#__PURE__*/ _wrapNativeSuper(Error), inspect.custom);
module.exports = AssertionError;
},
"../../node_modules/.pnpm/assert@2.1.0/node_modules/assert/build/internal/errors.js" (module, __unused_rspack_exports, __webpack_require__) {
function _typeof(o) {
return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
return typeof o;
} : function(o) {
return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
}, _typeof(o);
}
function _defineProperties(target, props) {
for(var i = 0; i < props.length; i++){
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
}
}
function _createClass(Constructor, protoProps, staticProps) {
if (protoProps) _defineProperties(Constructor.prototype, protoProps);
if (staticProps) _defineProperties(Constructor, staticProps);
Object.defineProperty(Constructor, "prototype", {
writable: false
});
return Constructor;
}
function _toPropertyKey(arg) {
var key = _toPrimitive(arg, "string");
return "symbol" === _typeof(key) ? key : String(key);
}
function _toPrimitive(input, hint) {
if ("object" !== _typeof(input) || null === input) return input;
var prim = input[Symbol.toPrimitive];
if (void 0 !== prim) {
var res = prim.call(input, hint || "default");
if ("object" !== _typeof(res)) return res;
throw new TypeError("@@toPrimitive must return a primitive value.");
}
return ("string" === hint ? String : Number)(input);
}
function _classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
}
function _inherits(subClass, superClass) {
if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function");
subClass.prototype = Object.create(superClass && superClass.prototype, {
constructor: {
value: subClass,
writable: true,
configurable: true
}
});
Object.defineProperty(subClass, "prototype", {
writable: false
});