????
Your IP : 3.148.192.220
// deno-fmt-ignore-file
// deno-lint-ignore-file
// This code was bundled using `deno bundle` and it's not recommended to edit it manually
// Using `deno bundle https://deno.land/std@0.168.0/testing/asserts.ts > npm/deno_asserts@0.168.0.mjs`
const { Deno } = globalThis;
const noColor = typeof Deno?.noColor === "boolean" ? Deno.noColor : true;
let enabled = !noColor;
function code(open, close) {
return {
open: `\x1b[${open.join(";")}m`,
close: `\x1b[${close}m`,
regexp: new RegExp(`\\x1b\\[${close}m`, "g")
};
}
function run(str, code) {
return enabled ? `${code.open}${str.replace(code.regexp, code.open)}${code.close}` : str;
}
function bold(str) {
return run(str, code([
1
], 22));
}
function red(str) {
return run(str, code([
31
], 39));
}
function green(str) {
return run(str, code([
32
], 39));
}
function white(str) {
return run(str, code([
37
], 39));
}
function gray(str) {
return brightBlack(str);
}
function brightBlack(str) {
return run(str, code([
90
], 39));
}
function bgRed(str) {
return run(str, code([
41
], 49));
}
function bgGreen(str) {
return run(str, code([
42
], 49));
}
const ANSI_PATTERN = new RegExp([
"[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)",
"(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))"
].join("|"), "g");
function stripColor(string) {
return string.replace(ANSI_PATTERN, "");
}
var DiffType;
(function(DiffType) {
DiffType["removed"] = "removed";
DiffType["common"] = "common";
DiffType["added"] = "added";
})(DiffType || (DiffType = {}));
const REMOVED = 1;
const COMMON = 2;
const ADDED = 3;
function createCommon(A, B, reverse) {
const common = [];
if (A.length === 0 || B.length === 0) return [];
for(let i = 0; i < Math.min(A.length, B.length); i += 1){
if (A[reverse ? A.length - i - 1 : i] === B[reverse ? B.length - i - 1 : i]) {
common.push(A[reverse ? A.length - i - 1 : i]);
} else {
return common;
}
}
return common;
}
function diff(A, B) {
const prefixCommon = createCommon(A, B);
const suffixCommon = createCommon(A.slice(prefixCommon.length), B.slice(prefixCommon.length), true).reverse();
A = suffixCommon.length ? A.slice(prefixCommon.length, -suffixCommon.length) : A.slice(prefixCommon.length);
B = suffixCommon.length ? B.slice(prefixCommon.length, -suffixCommon.length) : B.slice(prefixCommon.length);
const swapped = B.length > A.length;
[A, B] = swapped ? [
B,
A
] : [
A,
B
];
const M = A.length;
const N = B.length;
if (!M && !N && !suffixCommon.length && !prefixCommon.length) return [];
if (!N) {
return [
...prefixCommon.map((c)=>({
type: DiffType.common,
value: c
})),
...A.map((a)=>({
type: swapped ? DiffType.added : DiffType.removed,
value: a
})),
...suffixCommon.map((c)=>({
type: DiffType.common,
value: c
}))
];
}
const offset = N;
const delta = M - N;
const size = M + N + 1;
const fp = Array.from({
length: size
}, ()=>({
y: -1,
id: -1
}));
const routes = new Uint32Array((M * N + size + 1) * 2);
const diffTypesPtrOffset = routes.length / 2;
let ptr = 0;
let p = -1;
function backTrace(A, B, current, swapped) {
const M = A.length;
const N = B.length;
const result = [];
let a = M - 1;
let b = N - 1;
let j = routes[current.id];
let type = routes[current.id + diffTypesPtrOffset];
while(true){
if (!j && !type) break;
const prev = j;
if (type === 1) {
result.unshift({
type: swapped ? DiffType.removed : DiffType.added,
value: B[b]
});
b -= 1;
} else if (type === 3) {
result.unshift({
type: swapped ? DiffType.added : DiffType.removed,
value: A[a]
});
a -= 1;
} else {
result.unshift({
type: DiffType.common,
value: A[a]
});
a -= 1;
b -= 1;
}
j = routes[prev];
type = routes[prev + diffTypesPtrOffset];
}
return result;
}
function createFP(slide, down, k, M) {
if (slide && slide.y === -1 && down && down.y === -1) {
return {
y: 0,
id: 0
};
}
if (down && down.y === -1 || k === M || (slide && slide.y) > (down && down.y) + 1) {
const prev = slide.id;
ptr++;
routes[ptr] = prev;
routes[ptr + diffTypesPtrOffset] = ADDED;
return {
y: slide.y,
id: ptr
};
} else {
const prev1 = down.id;
ptr++;
routes[ptr] = prev1;
routes[ptr + diffTypesPtrOffset] = REMOVED;
return {
y: down.y + 1,
id: ptr
};
}
}
function snake(k, slide, down, _offset, A, B) {
const M = A.length;
const N = B.length;
if (k < -N || M < k) return {
y: -1,
id: -1
};
const fp = createFP(slide, down, k, M);
while(fp.y + k < M && fp.y < N && A[fp.y + k] === B[fp.y]){
const prev = fp.id;
ptr++;
fp.id = ptr;
fp.y += 1;
routes[ptr] = prev;
routes[ptr + diffTypesPtrOffset] = COMMON;
}
return fp;
}
while(fp[delta + offset].y < N){
p = p + 1;
for(let k = -p; k < delta; ++k){
fp[k + offset] = snake(k, fp[k - 1 + offset], fp[k + 1 + offset], offset, A, B);
}
for(let k1 = delta + p; k1 > delta; --k1){
fp[k1 + offset] = snake(k1, fp[k1 - 1 + offset], fp[k1 + 1 + offset], offset, A, B);
}
fp[delta + offset] = snake(delta, fp[delta - 1 + offset], fp[delta + 1 + offset], offset, A, B);
}
return [
...prefixCommon.map((c)=>({
type: DiffType.common,
value: c
})),
...backTrace(A, B, fp[delta + offset], swapped),
...suffixCommon.map((c)=>({
type: DiffType.common,
value: c
}))
];
}
function diffstr(A, B) {
function unescape(string) {
return string.replaceAll("\b", "\\b").replaceAll("\f", "\\f").replaceAll("\t", "\\t").replaceAll("\v", "\\v").replaceAll(/\r\n|\r|\n/g, (str)=>str === "\r" ? "\\r" : str === "\n" ? "\\n\n" : "\\r\\n\r\n");
}
function tokenize(string, { wordDiff =false } = {}) {
if (wordDiff) {
const tokens = string.split(/([^\S\r\n]+|[()[\]{}'"\r\n]|\b)/);
const words = /^[a-zA-Z\u{C0}-\u{FF}\u{D8}-\u{F6}\u{F8}-\u{2C6}\u{2C8}-\u{2D7}\u{2DE}-\u{2FF}\u{1E00}-\u{1EFF}]+$/u;
for(let i = 0; i < tokens.length - 1; i++){
if (!tokens[i + 1] && tokens[i + 2] && words.test(tokens[i]) && words.test(tokens[i + 2])) {
tokens[i] += tokens[i + 2];
tokens.splice(i + 1, 2);
i--;
}
}
return tokens.filter((token)=>token);
} else {
const tokens1 = [], lines = string.split(/(\n|\r\n)/);
if (!lines[lines.length - 1]) {
lines.pop();
}
for(let i1 = 0; i1 < lines.length; i1++){
if (i1 % 2) {
tokens1[tokens1.length - 1] += lines[i1];
} else {
tokens1.push(lines[i1]);
}
}
return tokens1;
}
}
function createDetails(line, tokens) {
return tokens.filter(({ type })=>type === line.type || type === DiffType.common).map((result, i, t)=>{
if (result.type === DiffType.common && t[i - 1] && t[i - 1]?.type === t[i + 1]?.type && /\s+/.test(result.value)) {
result.type = t[i - 1].type;
}
return result;
});
}
const diffResult = diff(tokenize(`${unescape(A)}\n`), tokenize(`${unescape(B)}\n`));
const added = [], removed = [];
for (const result of diffResult){
if (result.type === DiffType.added) {
added.push(result);
}
if (result.type === DiffType.removed) {
removed.push(result);
}
}
const aLines = added.length < removed.length ? added : removed;
const bLines = aLines === removed ? added : removed;
for (const a of aLines){
let tokens = [], b;
while(bLines.length){
b = bLines.shift();
tokens = diff(tokenize(a.value, {
wordDiff: true
}), tokenize(b?.value ?? "", {
wordDiff: true
}));
if (tokens.some(({ type , value })=>type === DiffType.common && value.trim().length)) {
break;
}
}
a.details = createDetails(a, tokens);
if (b) {
b.details = createDetails(b, tokens);
}
}
return diffResult;
}
function createColor(diffType, { background =false } = {}) {
background = false;
switch(diffType){
case DiffType.added:
return (s)=>background ? bgGreen(white(s)) : green(bold(s));
case DiffType.removed:
return (s)=>background ? bgRed(white(s)) : red(bold(s));
default:
return white;
}
}
function createSign(diffType) {
switch(diffType){
case DiffType.added:
return "+ ";
case DiffType.removed:
return "- ";
default:
return " ";
}
}
function buildMessage(diffResult, { stringDiff =false } = {}) {
const messages = [], diffMessages = [];
messages.push("");
messages.push("");
messages.push(` ${gray(bold("[Diff]"))} ${red(bold("Actual"))} / ${green(bold("Expected"))}`);
messages.push("");
messages.push("");
diffResult.forEach((result)=>{
const c = createColor(result.type);
const line = result.details?.map((detail)=>detail.type !== DiffType.common ? createColor(detail.type, {
background: true
})(detail.value) : detail.value).join("") ?? result.value;
diffMessages.push(c(`${createSign(result.type)}${line}`));
});
messages.push(...stringDiff ? [
diffMessages.join("")
] : diffMessages);
messages.push("");
return messages;
}
function format(v) {
const { Deno } = globalThis;
return typeof Deno?.inspect === "function" ? Deno.inspect(v, {
depth: Infinity,
sorted: true,
trailingComma: true,
compact: false,
iterableLimit: Infinity,
getters: true
}) : `"${String(v).replace(/(?=["\\])/g, "\\")}"`;
}
const CAN_NOT_DISPLAY = "[Cannot display]";
class AssertionError extends Error {
name = "AssertionError";
constructor(message){
super(message);
}
}
function isKeyedCollection(x) {
return [
Symbol.iterator,
"size"
].every((k)=>k in x);
}
function equal(c, d) {
const seen = new Map();
return function compare(a, b) {
if (a && b && (a instanceof RegExp && b instanceof RegExp || a instanceof URL && b instanceof URL)) {
return String(a) === String(b);
}
if (a instanceof Date && b instanceof Date) {
const aTime = a.getTime();
const bTime = b.getTime();
if (Number.isNaN(aTime) && Number.isNaN(bTime)) {
return true;
}
return aTime === bTime;
}
if (typeof a === "number" && typeof b === "number") {
return Number.isNaN(a) && Number.isNaN(b) || a === b;
}
if (Object.is(a, b)) {
return true;
}
if (a && typeof a === "object" && b && typeof b === "object") {
if (a && b && !constructorsEqual(a, b)) {
return false;
}
if (a instanceof WeakMap || b instanceof WeakMap) {
if (!(a instanceof WeakMap && b instanceof WeakMap)) return false;
throw new TypeError("cannot compare WeakMap instances");
}
if (a instanceof WeakSet || b instanceof WeakSet) {
if (!(a instanceof WeakSet && b instanceof WeakSet)) return false;
throw new TypeError("cannot compare WeakSet instances");
}
if (seen.get(a) === b) {
return true;
}
if (Object.keys(a || {}).length !== Object.keys(b || {}).length) {
return false;
}
seen.set(a, b);
if (isKeyedCollection(a) && isKeyedCollection(b)) {
if (a.size !== b.size) {
return false;
}
let unmatchedEntries = a.size;
for (const [aKey, aValue] of a.entries()){
for (const [bKey, bValue] of b.entries()){
if (aKey === aValue && bKey === bValue && compare(aKey, bKey) || compare(aKey, bKey) && compare(aValue, bValue)) {
unmatchedEntries--;
break;
}
}
}
return unmatchedEntries === 0;
}
const merged = {
...a,
...b
};
for (const key of [
...Object.getOwnPropertyNames(merged),
...Object.getOwnPropertySymbols(merged)
]){
if (!compare(a && a[key], b && b[key])) {
return false;
}
if (key in a && !(key in b) || key in b && !(key in a)) {
return false;
}
}
if (a instanceof WeakRef || b instanceof WeakRef) {
if (!(a instanceof WeakRef && b instanceof WeakRef)) return false;
return compare(a.deref(), b.deref());
}
return true;
}
return false;
}(c, d);
}
function constructorsEqual(a, b) {
return a.constructor === b.constructor || a.constructor === Object && !b.constructor || !a.constructor && b.constructor === Object;
}
function assert(expr, msg = "") {
if (!expr) {
throw new AssertionError(msg);
}
}
function assertFalse(expr, msg = "") {
if (expr) {
throw new AssertionError(msg);
}
}
function assertEquals(actual, expected, msg) {
if (equal(actual, expected)) {
return;
}
let message = "";
const actualString = format(actual);
const expectedString = format(expected);
try {
const stringDiff = typeof actual === "string" && typeof expected === "string";
const diffResult = stringDiff ? diffstr(actual, expected) : diff(actualString.split("\n"), expectedString.split("\n"));
const diffMsg = buildMessage(diffResult, {
stringDiff
}).join("\n");
message = `Values are not equal:\n${diffMsg}`;
} catch {
message = `\n${red(CAN_NOT_DISPLAY)} + \n\n`;
}
if (msg) {
message = msg;
}
throw new AssertionError(message);
}
function assertNotEquals(actual, expected, msg) {
if (!equal(actual, expected)) {
return;
}
let actualString;
let expectedString;
try {
actualString = String(actual);
} catch {
actualString = "[Cannot display]";
}
try {
expectedString = String(expected);
} catch {
expectedString = "[Cannot display]";
}
if (!msg) {
msg = `actual: ${actualString} expected not to be: ${expectedString}`;
}
throw new AssertionError(msg);
}
function assertStrictEquals(actual, expected, msg) {
if (Object.is(actual, expected)) {
return;
}
let message;
if (msg) {
message = msg;
} else {
const actualString = format(actual);
const expectedString = format(expected);
if (actualString === expectedString) {
const withOffset = actualString.split("\n").map((l)=>` ${l}`).join("\n");
message = `Values have the same structure but are not reference-equal:\n\n${red(withOffset)}\n`;
} else {
try {
const stringDiff = typeof actual === "string" && typeof expected === "string";
const diffResult = stringDiff ? diffstr(actual, expected) : diff(actualString.split("\n"), expectedString.split("\n"));
const diffMsg = buildMessage(diffResult, {
stringDiff
}).join("\n");
message = `Values are not strictly equal:\n${diffMsg}`;
} catch {
message = `\n${red(CAN_NOT_DISPLAY)} + \n\n`;
}
}
}
throw new AssertionError(message);
}
function assertNotStrictEquals(actual, expected, msg) {
if (!Object.is(actual, expected)) {
return;
}
throw new AssertionError(msg ?? `Expected "actual" to be strictly unequal to: ${format(actual)}\n`);
}
function assertAlmostEquals(actual, expected, tolerance = 1e-7, msg) {
if (Object.is(actual, expected)) {
return;
}
const delta = Math.abs(expected - actual);
if (delta <= tolerance) {
return;
}
const f = (n)=>Number.isInteger(n) ? n : n.toExponential();
throw new AssertionError(msg ?? `actual: "${f(actual)}" expected to be close to "${f(expected)}": \
delta "${f(delta)}" is greater than "${f(tolerance)}"`);
}
function assertInstanceOf(actual, expectedType, msg = "") {
if (!msg) {
const expectedTypeStr = expectedType.name;
let actualTypeStr = "";
if (actual === null) {
actualTypeStr = "null";
} else if (actual === undefined) {
actualTypeStr = "undefined";
} else if (typeof actual === "object") {
actualTypeStr = actual.constructor?.name ?? "Object";
} else {
actualTypeStr = typeof actual;
}
if (expectedTypeStr == actualTypeStr) {
msg = `Expected object to be an instance of "${expectedTypeStr}".`;
} else if (actualTypeStr == "function") {
msg = `Expected object to be an instance of "${expectedTypeStr}" but was not an instanced object.`;
} else {
msg = `Expected object to be an instance of "${expectedTypeStr}" but was "${actualTypeStr}".`;
}
}
assert(actual instanceof expectedType, msg);
}
function assertNotInstanceOf(actual, unexpectedType, msg = `Expected object to not be an instance of "${typeof unexpectedType}"`) {
assertFalse(actual instanceof unexpectedType, msg);
}
function assertExists(actual, msg) {
if (actual === undefined || actual === null) {
if (!msg) {
msg = `actual: "${actual}" expected to not be null or undefined`;
}
throw new AssertionError(msg);
}
}
function assertStringIncludes(actual, expected, msg) {
if (!actual.includes(expected)) {
if (!msg) {
msg = `actual: "${actual}" expected to contain: "${expected}"`;
}
throw new AssertionError(msg);
}
}
function assertArrayIncludes(actual, expected, msg) {
const missing = [];
for(let i = 0; i < expected.length; i++){
let found = false;
for(let j = 0; j < actual.length; j++){
if (equal(expected[i], actual[j])) {
found = true;
break;
}
}
if (!found) {
missing.push(expected[i]);
}
}
if (missing.length === 0) {
return;
}
if (!msg) {
msg = `actual: "${format(actual)}" expected to include: "${format(expected)}"\nmissing: ${format(missing)}`;
}
throw new AssertionError(msg);
}
function assertMatch(actual, expected, msg) {
if (!expected.test(actual)) {
if (!msg) {
msg = `actual: "${actual}" expected to match: "${expected}"`;
}
throw new AssertionError(msg);
}
}
function assertNotMatch(actual, expected, msg) {
if (expected.test(actual)) {
if (!msg) {
msg = `actual: "${actual}" expected to not match: "${expected}"`;
}
throw new AssertionError(msg);
}
}
function assertObjectMatch(actual, expected) {
function filter(a, b) {
const seen = new WeakMap();
return fn(a, b);
function fn(a, b) {
if (seen.has(a) && seen.get(a) === b) {
return a;
}
seen.set(a, b);
const filtered = {};
const entries = [
...Object.getOwnPropertyNames(a),
...Object.getOwnPropertySymbols(a)
].filter((key)=>key in b).map((key)=>[
key,
a[key]
]);
for (const [key, value] of entries){
if (Array.isArray(value)) {
const subset = b[key];
if (Array.isArray(subset)) {
filtered[key] = fn({
...value
}, {
...subset
});
continue;
}
} else if (value instanceof RegExp) {
filtered[key] = value;
continue;
} else if (typeof value === "object") {
const subset1 = b[key];
if (typeof subset1 === "object" && subset1) {
if (value instanceof Map && subset1 instanceof Map) {
filtered[key] = new Map([
...value
].filter(([k])=>subset1.has(k)).map(([k, v])=>[
k,
typeof v === "object" ? fn(v, subset1.get(k)) : v
]));
continue;
}
if (value instanceof Set && subset1 instanceof Set) {
filtered[key] = new Set([
...value
].filter((v)=>subset1.has(v)));
continue;
}
filtered[key] = fn(value, subset1);
continue;
}
}
filtered[key] = value;
}
return filtered;
}
}
return assertEquals(filter(actual, expected), filter(expected, expected));
}
function fail(msg) {
assert(false, `Failed assertion${msg ? `: ${msg}` : "."}`);
}
function assertIsError(error, ErrorClass, msgIncludes, msg) {
if (error instanceof Error === false) {
throw new AssertionError(`Expected "error" to be an Error object.`);
}
if (ErrorClass && !(error instanceof ErrorClass)) {
msg = `Expected error to be instance of "${ErrorClass.name}", but was "${typeof error === "object" ? error?.constructor?.name : "[not an object]"}"${msg ? `: ${msg}` : "."}`;
throw new AssertionError(msg);
}
if (msgIncludes && (!(error instanceof Error) || !stripColor(error.message).includes(stripColor(msgIncludes)))) {
msg = `Expected error message to include "${msgIncludes}", but got "${error instanceof Error ? error.message : "[not an Error]"}"${msg ? `: ${msg}` : "."}`;
throw new AssertionError(msg);
}
}
function assertThrows(fn, errorClassOrMsg, msgIncludesOrMsg, msg) {
let ErrorClass = undefined;
let msgIncludes = undefined;
let err;
if (typeof errorClassOrMsg !== "string") {
if (errorClassOrMsg === undefined || errorClassOrMsg.prototype instanceof Error || errorClassOrMsg.prototype === Error.prototype) {
ErrorClass = errorClassOrMsg;
msgIncludes = msgIncludesOrMsg;
} else {
msg = msgIncludesOrMsg;
}
} else {
msg = errorClassOrMsg;
}
let doesThrow = false;
const msgToAppendToError = msg ? `: ${msg}` : ".";
try {
fn();
} catch (error) {
if (ErrorClass) {
if (error instanceof Error === false) {
throw new AssertionError("A non-Error object was thrown.");
}
assertIsError(error, ErrorClass, msgIncludes, msg);
}
err = error;
doesThrow = true;
}
if (!doesThrow) {
msg = `Expected function to throw${msgToAppendToError}`;
throw new AssertionError(msg);
}
return err;
}
async function assertRejects(fn, errorClassOrMsg, msgIncludesOrMsg, msg) {
let ErrorClass = undefined;
let msgIncludes = undefined;
let err;
if (typeof errorClassOrMsg !== "string") {
if (errorClassOrMsg === undefined || errorClassOrMsg.prototype instanceof Error || errorClassOrMsg.prototype === Error.prototype) {
ErrorClass = errorClassOrMsg;
msgIncludes = msgIncludesOrMsg;
}
} else {
msg = errorClassOrMsg;
}
let doesThrow = false;
let isPromiseReturned = false;
const msgToAppendToError = msg ? `: ${msg}` : ".";
try {
const possiblePromise = fn();
if (possiblePromise && typeof possiblePromise === "object" && typeof possiblePromise.then === "function") {
isPromiseReturned = true;
await possiblePromise;
}
} catch (error) {
if (!isPromiseReturned) {
throw new AssertionError(`Function throws when expected to reject${msgToAppendToError}`);
}
if (ErrorClass) {
if (error instanceof Error === false) {
throw new AssertionError("A non-Error object was rejected.");
}
assertIsError(error, ErrorClass, msgIncludes, msg);
}
err = error;
doesThrow = true;
}
if (!doesThrow) {
throw new AssertionError(`Expected function to reject${msgToAppendToError}`);
}
return err;
}
function unimplemented(msg) {
throw new AssertionError(msg || "unimplemented");
}
function unreachable() {
throw new AssertionError("unreachable");
}
export { AssertionError as AssertionError };
export { equal as equal };
export { assert as assert };
export { assertFalse as assertFalse };
export { assertEquals as assertEquals };
export { assertNotEquals as assertNotEquals };
export { assertStrictEquals as assertStrictEquals };
export { assertNotStrictEquals as assertNotStrictEquals };
export { assertAlmostEquals as assertAlmostEquals };
export { assertInstanceOf as assertInstanceOf };
export { assertNotInstanceOf as assertNotInstanceOf };
export { assertExists as assertExists };
export { assertStringIncludes as assertStringIncludes };
export { assertArrayIncludes as assertArrayIncludes };
export { assertMatch as assertMatch };
export { assertNotMatch as assertNotMatch };
export { assertObjectMatch as assertObjectMatch };
export { fail as fail };
export { assertIsError as assertIsError };
export { assertThrows as assertThrows };
export { assertRejects as assertRejects };
export { unimplemented as unimplemented };
export { unreachable as unreachable };