@fedify/fedify 1.6.0-dev.814 → 1.6.0

package/dist/node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/check/runner/utils/RunDetailsFormatter.js

@@ -0,0 +1,135 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { SError, SMap, safeMapGet, safePush, safeReplace } from "../../../utils/globals.js";
+import { VerbosityLevel } from "../configuration/VerbosityLevel.js";
+import { possiblyAsyncStringify, stringify } from "../../../utils/stringify.js";
+import { ExecutionStatus } from "../reporter/ExecutionStatus.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/check/runner/utils/RunDetailsFormatter.js
+const safeObjectAssign = Object.assign;
+function formatHints(hints) {
+	if (hints.length === 1) return `Hint: ${hints[0]}`;
+	return hints.map((h, idx) => `Hint (${idx + 1}): ${h}`).join("\n");
+}
+function formatFailures(failures, stringifyOne) {
+	return `Encountered failures were:\n- ${failures.map(stringifyOne).join("\n- ")}`;
+}
+function formatExecutionSummary(executionTrees, stringifyOne) {
+	const summaryLines = [];
+	const remainingTreesAndDepth = [];
+	for (const tree of executionTrees.slice().reverse()) remainingTreesAndDepth.push({
+		depth: 1,
+		tree
+	});
+	while (remainingTreesAndDepth.length !== 0) {
+		const currentTreeAndDepth = remainingTreesAndDepth.pop();
+		const currentTree = currentTreeAndDepth.tree;
+		const currentDepth = currentTreeAndDepth.depth;
+		const statusIcon = currentTree.status === ExecutionStatus.Success ? "\x1B[32m√\x1B[0m" : currentTree.status === ExecutionStatus.Failure ? "\x1B[31m×\x1B[0m" : "\x1B[33m!\x1B[0m";
+		const leftPadding = Array(currentDepth).join(". ");
+		summaryLines.push(`${leftPadding}${statusIcon} ${stringifyOne(currentTree.value)}`);
+		for (const tree of currentTree.children.slice().reverse()) remainingTreesAndDepth.push({
+			depth: currentDepth + 1,
+			tree
+		});
+	}
+	return `Execution summary:\n${summaryLines.join("\n")}`;
+}
+function preFormatTooManySkipped(out, stringifyOne) {
+	const message = `Failed to run property, too many pre-condition failures encountered\n{ seed: ${out.seed} }\n\nRan ${out.numRuns} time(s)\nSkipped ${out.numSkips} time(s)`;
+	let details = null;
+	const hints = ["Try to reduce the number of rejected values by combining map, flatMap and built-in arbitraries", "Increase failure tolerance by setting maxSkipsPerRun to an higher value"];
+	if (out.verbose >= VerbosityLevel.VeryVerbose) details = formatExecutionSummary(out.executionSummary, stringifyOne);
+	else safePush(hints, "Enable verbose mode at level VeryVerbose in order to check all generated values and their associated status");
+	return {
+		message,
+		details,
+		hints
+	};
+}
+function preFormatFailure(out, stringifyOne) {
+	const noErrorInMessage = out.runConfiguration.errorWithCause;
+	const messageErrorPart = noErrorInMessage ? "" : `\nGot ${safeReplace(out.error, /^Error: /, "error: ")}`;
+	const message = `Property failed after ${out.numRuns} tests\n{ seed: ${out.seed}, path: "${out.counterexamplePath}", endOnFailure: true }\nCounterexample: ${stringifyOne(out.counterexample)}\nShrunk ${out.numShrinks} time(s)${messageErrorPart}`;
+	let details = null;
+	const hints = [];
+	if (out.verbose >= VerbosityLevel.VeryVerbose) details = formatExecutionSummary(out.executionSummary, stringifyOne);
+	else if (out.verbose === VerbosityLevel.Verbose) details = formatFailures(out.failures, stringifyOne);
+	else safePush(hints, "Enable verbose mode in order to have the list of all failing values encountered during the run");
+	return {
+		message,
+		details,
+		hints
+	};
+}
+function preFormatEarlyInterrupted(out, stringifyOne) {
+	const message = `Property interrupted after ${out.numRuns} tests\n{ seed: ${out.seed} }`;
+	let details = null;
+	const hints = [];
+	if (out.verbose >= VerbosityLevel.VeryVerbose) details = formatExecutionSummary(out.executionSummary, stringifyOne);
+	else safePush(hints, "Enable verbose mode at level VeryVerbose in order to check all generated values and their associated status");
+	return {
+		message,
+		details,
+		hints
+	};
+}
+function defaultReportMessageInternal(out, stringifyOne) {
+	if (!out.failed) return;
+	const { message, details, hints } = out.counterexamplePath === null ? out.interrupted ? preFormatEarlyInterrupted(out, stringifyOne) : preFormatTooManySkipped(out, stringifyOne) : preFormatFailure(out, stringifyOne);
+	let errorMessage = message;
+	if (details != null) errorMessage += `\n\n${details}`;
+	if (hints.length > 0) errorMessage += `\n\n${formatHints(hints)}`;
+	return errorMessage;
+}
+function defaultReportMessage(out) {
+	return defaultReportMessageInternal(out, stringify);
+}
+async function asyncDefaultReportMessage(out) {
+	const pendingStringifieds = [];
+	function stringifyOne(value) {
+		const stringified = possiblyAsyncStringify(value);
+		if (typeof stringified === "string") return stringified;
+		pendingStringifieds.push(Promise.all([value, stringified]));
+		return "…";
+	}
+	const firstTryMessage = defaultReportMessageInternal(out, stringifyOne);
+	if (pendingStringifieds.length === 0) return firstTryMessage;
+	const registeredValues = new SMap(await Promise.all(pendingStringifieds));
+	function stringifySecond(value) {
+		const asyncStringifiedIfRegistered = safeMapGet(registeredValues, value);
+		if (asyncStringifiedIfRegistered !== void 0) return asyncStringifiedIfRegistered;
+		return stringify(value);
+	}
+	return defaultReportMessageInternal(out, stringifySecond);
+}
+function buildError(errorMessage, out) {
+	if (!out.runConfiguration.errorWithCause) throw new SError(errorMessage);
+	const ErrorWithCause = SError;
+	const error = new ErrorWithCause(errorMessage, { cause: out.errorInstance });
+	if (!("cause" in error)) safeObjectAssign(error, { cause: out.errorInstance });
+	return error;
+}
+function throwIfFailed(out) {
+	if (!out.failed) return;
+	throw buildError(defaultReportMessage(out), out);
+}
+async function asyncThrowIfFailed(out) {
+	if (!out.failed) return;
+	throw buildError(await asyncDefaultReportMessage(out), out);
+}
+function reportRunDetails(out) {
+	if (out.runConfiguration.asyncReporter) return out.runConfiguration.asyncReporter(out);
+	else if (out.runConfiguration.reporter) return out.runConfiguration.reporter(out);
+	else return throwIfFailed(out);
+}
+async function asyncReportRunDetails(out) {
+	if (out.runConfiguration.asyncReporter) return out.runConfiguration.asyncReporter(out);
+	else if (out.runConfiguration.reporter) return out.runConfiguration.reporter(out);
+	else return asyncThrowIfFailed(out);
+}
+
+//#endregion
+export { asyncDefaultReportMessage, asyncReportRunDetails, defaultReportMessage, reportRunDetails };

package/dist/node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/check/symbols.js

@@ -0,0 +1,15 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/check/symbols.js
+const cloneMethod = Symbol.for("fast-check/cloneMethod");
+function hasCloneMethod(instance) {
+	return instance !== null && (typeof instance === "object" || typeof instance === "function") && cloneMethod in instance && typeof instance[cloneMethod] === "function";
+}
+function cloneIfNeeded(instance) {
+	return hasCloneMethod(instance) ? instance[cloneMethod]() : instance;
+}
+
+//#endregion
+export { cloneIfNeeded, cloneMethod, hasCloneMethod };

package/dist/node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/random/generator/Random.js

@@ -0,0 +1,48 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { unsafeUniformArrayIntDistribution } from "../../../../../../../pure-rand@6.1.0/node_modules/pure-rand/lib/esm/distribution/UnsafeUniformArrayIntDistribution.js";
+import { unsafeUniformBigIntDistribution } from "../../../../../../../pure-rand@6.1.0/node_modules/pure-rand/lib/esm/distribution/UnsafeUniformBigIntDistribution.js";
+import { unsafeUniformIntDistribution } from "../../../../../../../pure-rand@6.1.0/node_modules/pure-rand/lib/esm/distribution/UnsafeUniformIntDistribution.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/random/generator/Random.js
+var Random = class Random {
+	constructor(sourceRng) {
+		this.internalRng = sourceRng.clone();
+	}
+	clone() {
+		return new Random(this.internalRng);
+	}
+	next(bits) {
+		return unsafeUniformIntDistribution(0, (1 << bits) - 1, this.internalRng);
+	}
+	nextBoolean() {
+		return unsafeUniformIntDistribution(0, 1, this.internalRng) == 1;
+	}
+	nextInt(min, max) {
+		return unsafeUniformIntDistribution(min == null ? Random.MIN_INT : min, max == null ? Random.MAX_INT : max, this.internalRng);
+	}
+	nextBigInt(min, max) {
+		return unsafeUniformBigIntDistribution(min, max, this.internalRng);
+	}
+	nextArrayInt(min, max) {
+		return unsafeUniformArrayIntDistribution(min, max, this.internalRng);
+	}
+	nextDouble() {
+		const a = this.next(26);
+		const b = this.next(27);
+		return (a * Random.DBL_FACTOR + b) * Random.DBL_DIVISOR;
+	}
+	getState() {
+		if ("getState" in this.internalRng && typeof this.internalRng.getState === "function") return this.internalRng.getState();
+		return void 0;
+	}
+};
+Random.MIN_INT = -2147483648;
+Random.MAX_INT = 2147483647;
+Random.DBL_FACTOR = Math.pow(2, 27);
+Random.DBL_DIVISOR = Math.pow(2, -53);
+
+//#endregion
+export { Random };

package/dist/node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/stream/LazyIterableIterator.js

@@ -0,0 +1,24 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/stream/LazyIterableIterator.js
+var LazyIterableIterator = class {
+	constructor(producer) {
+		this.producer = producer;
+	}
+	[Symbol.iterator]() {
+		if (this.it === void 0) this.it = this.producer();
+		return this.it;
+	}
+	next() {
+		if (this.it === void 0) this.it = this.producer();
+		return this.it.next();
+	}
+};
+function makeLazy(producer) {
+	return new LazyIterableIterator(producer);
+}
+
+//#endregion
+export { makeLazy };

package/dist/node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/stream/Stream.js

@@ -0,0 +1,84 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { filterHelper, flatMapHelper, joinHelper, mapHelper, nilHelper, takeNHelper, takeWhileHelper } from "./StreamHelpers.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/stream/Stream.js
+const safeSymbolIterator = Symbol.iterator;
+var Stream = class Stream {
+	static nil() {
+		return new Stream(nilHelper());
+	}
+	static of(...elements) {
+		return new Stream(elements[safeSymbolIterator]());
+	}
+	constructor(g) {
+		this.g = g;
+	}
+	next() {
+		return this.g.next();
+	}
+	[Symbol.iterator]() {
+		return this.g;
+	}
+	map(f) {
+		return new Stream(mapHelper(this.g, f));
+	}
+	flatMap(f) {
+		return new Stream(flatMapHelper(this.g, f));
+	}
+	dropWhile(f) {
+		let foundEligible = false;
+		function* helper(v) {
+			if (foundEligible || !f(v)) {
+				foundEligible = true;
+				yield v;
+			}
+		}
+		return this.flatMap(helper);
+	}
+	drop(n) {
+		if (n <= 0) return this;
+		let idx = 0;
+		function helper() {
+			return idx++ < n;
+		}
+		return this.dropWhile(helper);
+	}
+	takeWhile(f) {
+		return new Stream(takeWhileHelper(this.g, f));
+	}
+	take(n) {
+		return new Stream(takeNHelper(this.g, n));
+	}
+	filter(f) {
+		return new Stream(filterHelper(this.g, f));
+	}
+	every(f) {
+		for (const v of this.g) if (!f(v)) return false;
+		return true;
+	}
+	has(f) {
+		for (const v of this.g) if (f(v)) return [true, v];
+		return [false, null];
+	}
+	join(...others) {
+		return new Stream(joinHelper(this.g, others));
+	}
+	getNthOrLast(nth) {
+		let remaining = nth;
+		let last = null;
+		for (const v of this.g) {
+			if (remaining-- === 0) return v;
+			last = v;
+		}
+		return last;
+	}
+};
+function stream(g) {
+	return new Stream(g);
+}
+
+//#endregion
+export { Stream, stream };

package/dist/node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/stream/StreamHelpers.js

@@ -0,0 +1,50 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/stream/StreamHelpers.js
+var Nil = class {
+	[Symbol.iterator]() {
+		return this;
+	}
+	next(value) {
+		return {
+			value,
+			done: true
+		};
+	}
+};
+Nil.nil = new Nil();
+function nilHelper() {
+	return Nil.nil;
+}
+function* mapHelper(g, f) {
+	for (const v of g) yield f(v);
+}
+function* flatMapHelper(g, f) {
+	for (const v of g) yield* f(v);
+}
+function* filterHelper(g, f) {
+	for (const v of g) if (f(v)) yield v;
+}
+function* takeNHelper(g, n) {
+	for (let i = 0; i < n; ++i) {
+		const cur = g.next();
+		if (cur.done) break;
+		yield cur.value;
+	}
+}
+function* takeWhileHelper(g, f) {
+	let cur = g.next();
+	while (!cur.done && f(cur.value)) {
+		yield cur.value;
+		cur = g.next();
+	}
+}
+function* joinHelper(g, others) {
+	for (let cur = g.next(); !cur.done; cur = g.next()) yield cur.value;
+	for (const s of others) for (let cur = s.next(); !cur.done; cur = s.next()) yield cur.value;
+}
+
+//#endregion
+export { filterHelper, flatMapHelper, joinHelper, mapHelper, nilHelper, takeNHelper, takeWhileHelper };

package/dist/node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/utils/apply.js

@@ -0,0 +1,28 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/utils/apply.js
+const untouchedApply = Function.prototype.apply;
+const ApplySymbol = Symbol("apply");
+function safeExtractApply(f) {
+	try {
+		return f.apply;
+	} catch (err) {
+		return void 0;
+	}
+}
+function safeApplyHacky(f, instance, args) {
+	const ff = f;
+	ff[ApplySymbol] = untouchedApply;
+	const out = ff[ApplySymbol](instance, args);
+	delete ff[ApplySymbol];
+	return out;
+}
+function safeApply(f, instance, args) {
+	if (safeExtractApply(f) === untouchedApply) return f.apply(instance, args);
+	return safeApplyHacky(f, instance, args);
+}
+
+//#endregion
+export { safeApply };

package/dist/node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/utils/globals.js

@@ -0,0 +1,309 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { safeApply } from "./apply.js";
+
+//#region node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/utils/globals.js
+const SArray = typeof Array !== "undefined" ? Array : void 0;
+const SBigInt = typeof BigInt !== "undefined" ? BigInt : void 0;
+const SBoolean = typeof Boolean !== "undefined" ? Boolean : void 0;
+const SDate = typeof Date !== "undefined" ? Date : void 0;
+const SError = typeof Error !== "undefined" ? Error : void 0;
+const SFloat32Array = typeof Float32Array !== "undefined" ? Float32Array : void 0;
+const SFloat64Array = typeof Float64Array !== "undefined" ? Float64Array : void 0;
+const SInt8Array = typeof Int8Array !== "undefined" ? Int8Array : void 0;
+const SInt16Array = typeof Int16Array !== "undefined" ? Int16Array : void 0;
+const SInt32Array = typeof Int32Array !== "undefined" ? Int32Array : void 0;
+const SNumber = typeof Number !== "undefined" ? Number : void 0;
+const SString = typeof String !== "undefined" ? String : void 0;
+const SSet = typeof Set !== "undefined" ? Set : void 0;
+const SUint8Array = typeof Uint8Array !== "undefined" ? Uint8Array : void 0;
+const SUint8ClampedArray = typeof Uint8ClampedArray !== "undefined" ? Uint8ClampedArray : void 0;
+const SUint16Array = typeof Uint16Array !== "undefined" ? Uint16Array : void 0;
+const SUint32Array = typeof Uint32Array !== "undefined" ? Uint32Array : void 0;
+const SMap = Map;
+const SSymbol = Symbol;
+const untouchedForEach = Array.prototype.forEach;
+const untouchedIndexOf = Array.prototype.indexOf;
+const untouchedJoin = Array.prototype.join;
+const untouchedMap = Array.prototype.map;
+const untouchedFilter = Array.prototype.filter;
+const untouchedPush = Array.prototype.push;
+const untouchedPop = Array.prototype.pop;
+const untouchedSplice = Array.prototype.splice;
+const untouchedSlice = Array.prototype.slice;
+const untouchedSort = Array.prototype.sort;
+const untouchedEvery = Array.prototype.every;
+function extractForEach(instance) {
+	try {
+		return instance.forEach;
+	} catch (err) {
+		return void 0;
+	}
+}
+function extractIndexOf(instance) {
+	try {
+		return instance.indexOf;
+	} catch (err) {
+		return void 0;
+	}
+}
+function extractJoin(instance) {
+	try {
+		return instance.join;
+	} catch (err) {
+		return void 0;
+	}
+}
+function extractMap(instance) {
+	try {
+		return instance.map;
+	} catch (err) {
+		return void 0;
+	}
+}
+function extractFilter(instance) {
+	try {
+		return instance.filter;
+	} catch (err) {
+		return void 0;
+	}
+}
+function extractPush(instance) {
+	try {
+		return instance.push;
+	} catch (err) {
+		return void 0;
+	}
+}
+function extractPop(instance) {
+	try {
+		return instance.pop;
+	} catch (err) {
+		return void 0;
+	}
+}
+function extractSlice(instance) {
+	try {
+		return instance.slice;
+	} catch (err) {
+		return void 0;
+	}
+}
+function extractEvery(instance) {
+	try {
+		return instance.every;
+	} catch (err) {
+		return void 0;
+	}
+}
+function safeForEach(instance, fn) {
+	if (extractForEach(instance) === untouchedForEach) return instance.forEach(fn);
+	return safeApply(untouchedForEach, instance, [fn]);
+}
+function safeIndexOf(instance, ...args) {
+	if (extractIndexOf(instance) === untouchedIndexOf) return instance.indexOf(...args);
+	return safeApply(untouchedIndexOf, instance, args);
+}
+function safeJoin(instance, ...args) {
+	if (extractJoin(instance) === untouchedJoin) return instance.join(...args);
+	return safeApply(untouchedJoin, instance, args);
+}
+function safeMap(instance, fn) {
+	if (extractMap(instance) === untouchedMap) return instance.map(fn);
+	return safeApply(untouchedMap, instance, [fn]);
+}
+function safeFilter(instance, predicate) {
+	if (extractFilter(instance) === untouchedFilter) return instance.filter(predicate);
+	return safeApply(untouchedFilter, instance, [predicate]);
+}
+function safePush(instance, ...args) {
+	if (extractPush(instance) === untouchedPush) return instance.push(...args);
+	return safeApply(untouchedPush, instance, args);
+}
+function safePop(instance) {
+	if (extractPop(instance) === untouchedPop) return instance.pop();
+	return safeApply(untouchedPop, instance, []);
+}
+function safeSlice(instance, ...args) {
+	if (extractSlice(instance) === untouchedSlice) return instance.slice(...args);
+	return safeApply(untouchedSlice, instance, args);
+}
+function safeEvery(instance, ...args) {
+	if (extractEvery(instance) === untouchedEvery) return instance.every(...args);
+	return safeApply(untouchedEvery, instance, args);
+}
+const untouchedGetTime = Date.prototype.getTime;
+const untouchedToISOString = Date.prototype.toISOString;
+function extractGetTime(instance) {
+	try {
+		return instance.getTime;
+	} catch (err) {
+		return void 0;
+	}
+}
+function extractToISOString(instance) {
+	try {
+		return instance.toISOString;
+	} catch (err) {
+		return void 0;
+	}
+}
+function safeGetTime(instance) {
+	if (extractGetTime(instance) === untouchedGetTime) return instance.getTime();
+	return safeApply(untouchedGetTime, instance, []);
+}
+function safeToISOString(instance) {
+	if (extractToISOString(instance) === untouchedToISOString) return instance.toISOString();
+	return safeApply(untouchedToISOString, instance, []);
+}
+const untouchedAdd = Set.prototype.add;
+const untouchedHas = Set.prototype.has;
+function extractAdd(instance) {
+	try {
+		return instance.add;
+	} catch (err) {
+		return void 0;
+	}
+}
+function extractHas(instance) {
+	try {
+		return instance.has;
+	} catch (err) {
+		return void 0;
+	}
+}
+function safeAdd(instance, value) {
+	if (extractAdd(instance) === untouchedAdd) return instance.add(value);
+	return safeApply(untouchedAdd, instance, [value]);
+}
+function safeHas(instance, value) {
+	if (extractHas(instance) === untouchedHas) return instance.has(value);
+	return safeApply(untouchedHas, instance, [value]);
+}
+const untouchedSet = WeakMap.prototype.set;
+const untouchedGet = WeakMap.prototype.get;
+function extractSet(instance) {
+	try {
+		return instance.set;
+	} catch (err) {
+		return void 0;
+	}
+}
+function extractGet(instance) {
+	try {
+		return instance.get;
+	} catch (err) {
+		return void 0;
+	}
+}
+function safeSet(instance, key, value) {
+	if (extractSet(instance) === untouchedSet) return instance.set(key, value);
+	return safeApply(untouchedSet, instance, [key, value]);
+}
+function safeGet(instance, key) {
+	if (extractGet(instance) === untouchedGet) return instance.get(key);
+	return safeApply(untouchedGet, instance, [key]);
+}
+const untouchedMapSet = Map.prototype.set;
+const untouchedMapGet = Map.prototype.get;
+function extractMapSet(instance) {
+	try {
+		return instance.set;
+	} catch (err) {
+		return void 0;
+	}
+}
+function extractMapGet(instance) {
+	try {
+		return instance.get;
+	} catch (err) {
+		return void 0;
+	}
+}
+function safeMapSet(instance, key, value) {
+	if (extractMapSet(instance) === untouchedMapSet) return instance.set(key, value);
+	return safeApply(untouchedMapSet, instance, [key, value]);
+}
+function safeMapGet(instance, key) {
+	if (extractMapGet(instance) === untouchedMapGet) return instance.get(key);
+	return safeApply(untouchedMapGet, instance, [key]);
+}
+const untouchedSplit = String.prototype.split;
+const untouchedStartsWith = String.prototype.startsWith;
+const untouchedEndsWith = String.prototype.endsWith;
+const untouchedSubstring = String.prototype.substring;
+const untouchedToLowerCase = String.prototype.toLowerCase;
+const untouchedToUpperCase = String.prototype.toUpperCase;
+const untouchedPadStart = String.prototype.padStart;
+const untouchedCharCodeAt = String.prototype.charCodeAt;
+const untouchedNormalize = String.prototype.normalize;
+const untouchedReplace = String.prototype.replace;
+function extractSplit(instance) {
+	try {
+		return instance.split;
+	} catch (err) {
+		return void 0;
+	}
+}
+function extractSubstring(instance) {
+	try {
+		return instance.substring;
+	} catch (err) {
+		return void 0;
+	}
+}
+function extractCharCodeAt(instance) {
+	try {
+		return instance.charCodeAt;
+	} catch (err) {
+		return void 0;
+	}
+}
+function extractNormalize(instance) {
+	try {
+		return instance.normalize;
+	} catch (err) {
+		return void 0;
+	}
+}
+function extractReplace(instance) {
+	try {
+		return instance.replace;
+	} catch (err) {
+		return void 0;
+	}
+}
+function safeSplit(instance, ...args) {
+	if (extractSplit(instance) === untouchedSplit) return instance.split(...args);
+	return safeApply(untouchedSplit, instance, args);
+}
+function safeSubstring(instance, ...args) {
+	if (extractSubstring(instance) === untouchedSubstring) return instance.substring(...args);
+	return safeApply(untouchedSubstring, instance, args);
+}
+function safeCharCodeAt(instance, index) {
+	if (extractCharCodeAt(instance) === untouchedCharCodeAt) return instance.charCodeAt(index);
+	return safeApply(untouchedCharCodeAt, instance, [index]);
+}
+function safeNormalize(instance, form) {
+	if (extractNormalize(instance) === untouchedNormalize) return instance.normalize(form);
+	return safeApply(untouchedNormalize, instance, [form]);
+}
+function safeReplace(instance, pattern, replacement) {
+	if (extractReplace(instance) === untouchedReplace) return instance.replace(pattern, replacement);
+	return safeApply(untouchedReplace, instance, [pattern, replacement]);
+}
+const untouchedNumberToString = Number.prototype.toString;
+const untouchedHasOwnProperty = Object.prototype.hasOwnProperty;
+const untouchedToString = Object.prototype.toString;
+function safeHasOwnProperty(instance, v) {
+	return safeApply(untouchedHasOwnProperty, instance, [v]);
+}
+function safeToString(instance) {
+	return safeApply(untouchedToString, instance, []);
+}
+
+//#endregion
+export { SArray, SBigInt, SBoolean, SDate, SError, SFloat32Array, SFloat64Array, SInt16Array, SInt32Array, SInt8Array, SMap, SNumber, SSet, SString, SSymbol, SUint16Array, SUint32Array, SUint8Array, SUint8ClampedArray, safeAdd, safeCharCodeAt, safeEvery, safeFilter, safeForEach, safeGet, safeGetTime, safeHas, safeHasOwnProperty, safeIndexOf, safeJoin, safeMap, safeMapGet, safeMapSet, safeNormalize, safePop, safePush, safeReplace, safeSet, safeSlice, safeSplit, safeSubstring, safeToISOString, safeToString };