@agntn/harnesses 0.1.1 → 0.2.0

package/dist/_chunks/libs/typebox.mjs

@@ -1,3 +1,4 @@
+import "node:module";
 var __defProp = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
 	let target = {};
@@ -15,89 +16,20 @@ const Metrics = {
 	discard: 0,
 	update: 0
 };
-function IsBetween(value, min, max) {
-	return value >= min && value <= max;
-}
-function IsZeroWidthJoiner(value) {
-	return value === 8205;
-}
-function IsHighSurrogate(value) {
-	return IsBetween(value, 55296, 56319);
-}
-function IsRegionalIndicator(value) {
-	return IsBetween(value, 127462, 127487);
-}
-function IsVariationSelector(value) {
-	return IsBetween(value, 65024, 65039);
-}
-function IsCombiningMark(value) {
-	return IsBetween(value, 768, 879) || IsBetween(value, 6832, 6911) || IsBetween(value, 7616, 7679) || IsBetween(value, 65056, 65071);
-}
-function CodePointLength(value) {
-	return value > 65535 ? 2 : 1;
-}
-function ConsumeModifiers(value, index) {
+function CodePointCount$1(value) {
+	let result = 0, index = 0, prev = 0;
 	while (index < value.length) {
-		const point = value.codePointAt(index);
-		if (IsCombiningMark(point) || IsVariationSelector(point)) index += CodePointLength(point);
-		else break;
+		const next = value.charCodeAt(index++) >> 10;
+		result += +((prev << 8 | next) !== 13879);
+		prev = next;
 	}
-	return index;
-}
-function NextGraphemeClusterIndex(value, clusterStart) {
-	const startCP = value.codePointAt(clusterStart);
-	let clusterEnd = clusterStart + CodePointLength(startCP);
-	clusterEnd = ConsumeModifiers(value, clusterEnd);
-	while (clusterEnd < value.length - 1 && IsZeroWidthJoiner(value.codePointAt(clusterEnd))) {
-		const nextCP = value.codePointAt(clusterEnd + 1);
-		clusterEnd += 1 + CodePointLength(nextCP);
-		clusterEnd = ConsumeModifiers(value, clusterEnd);
-	}
-	if (IsRegionalIndicator(startCP) && clusterEnd < value.length && IsRegionalIndicator(value.codePointAt(clusterEnd))) clusterEnd += CodePointLength(value.codePointAt(clusterEnd));
-	return clusterEnd;
-}
-function IsGraphemeCodePoint(value) {
-	return IsHighSurrogate(value) || IsCombiningMark(value) || IsVariationSelector(value) || IsZeroWidthJoiner(value);
-}
-function IsMinLengthSegmented(value, minLength) {
-	if (minLength === 0) return true;
-	let count = 0;
-	let index = 0;
-	while (index < value.length) {
-		index = NextGraphemeClusterIndex(value, index);
-		count++;
-		if (count >= minLength) return true;
-	}
-	return false;
+	return result;
 }
-function IsMaxLengthSegmented(value, maxLength) {
-	let count = 0;
-	let index = 0;
-	while (index < value.length) {
-		index = NextGraphemeClusterIndex(value, index);
-		count++;
-		if (count > maxLength) return false;
-	}
-	return true;
+function IsMaxLength$2(value, maxLength) {
+	return value.length <= maxLength || value.length <= maxLength << 1 && CodePointCount$1(value) <= maxLength;
 }
 function IsMinLength$2(value, minLength) {
-	if (minLength === 0) return true;
-	let index = 0;
-	while (index < value.length) {
-		if (IsGraphemeCodePoint(value.charCodeAt(index))) return IsMinLengthSegmented(value, minLength);
-		index++;
-		if (index >= minLength) return true;
-	}
-	return false;
-}
-function IsMaxLength$2(value, maxLength) {
-	let index = 0;
-	while (index < value.length) {
-		if (IsGraphemeCodePoint(value.charCodeAt(index))) return IsMaxLengthSegmented(value, maxLength);
-		index++;
-		if (index > maxLength) return false;
-	}
-	return true;
+	return value.length >= minLength << 1 || value.length >= minLength && CodePointCount$1(value) >= minLength;
 }
 function IsArray$1(value) {
 	return Array.isArray(value);
@@ -174,28 +106,30 @@ function IsClassInstance(value) {
 function IsValueLike(value) {
 	return IsBigInt$1(value) || IsBoolean$2(value) || IsNull$1(value) || IsNumber$2(value) || IsString$2(value) || IsUndefined$1(value);
 }
-function IsMaxLength$1(value, length) {
-	return IsMaxLength$2(value, length);
+function IsMaxLength$1(value, maxLength) {
+	return IsMaxLength$2(value, maxLength);
 }
-function IsMinLength$1(value, length) {
-	return IsMinLength$2(value, length);
+function IsMinLength$1(value, minLength) {
+	return IsMinLength$2(value, minLength);
 }
 function Every(value, offset, callback) {
-	for (let index = offset; index < value.length; index++) if (!callback(value[index], index)) return false;
-	return true;
+	return value.every((item, index) => index < offset || callback(item, index));
 }
 function EveryAll(value, offset, callback) {
 	let result = true;
-	for (let index = offset; index < value.length; index++) if (!callback(value[index], index)) result = false;
+	value.forEach((item, index) => {
+		if (index >= offset && !callback(item, index)) result = false;
+	});
 	return result;
 }
 function Some(value, callback) {
-	for (let index = 0; index < value.length; index++) if (callback(value[index], index)) return true;
-	return false;
+	return value.some((value, index) => callback(value, index));
 }
 function SomeAll(value, callback) {
 	let result = false;
-	for (let index = 0; index < value.length; index++) if (callback(value[index], index)) result = true;
+	value.forEach((item, index) => {
+		if (callback(item, index)) result = true;
+	});
 	return result;
 }
 function Counted(value, callback) {
@@ -260,6 +194,7 @@ function IsMap(value) {
 const settings = {
 	immutableTypes: false,
 	maxErrors: 8,
+	maxParseErrors: 1,
 	maxInstantiationCount: 128,
 	useAcceleration: true,
 	exactOptionalPropertyTypes: false,
@@ -291,7 +226,7 @@ function FromSchemaObject(value) {
 	for (const key of Keys(value)) {
 		if (IsUnsafePropertyKey(key)) continue;
 		const descriptor = Object.getOwnPropertyDescriptor(value, key);
-		descriptor.value = FromValue$2(descriptor.value);
+		descriptor.value = FromValue$1(descriptor.value);
 		if (IsEqual(descriptor.enumerable, true)) result[key] = descriptor.value;
 		else Object.defineProperty(result, key, descriptor);
 	}
@@ -301,16 +236,16 @@ function FromPlainObject(value) {
 	const result = {};
 	for (const key of Keys(value)) {
 		if (IsUnsafePropertyKey(key)) continue;
-		result[key] = FromValue$2(value[key]);
+		result[key] = FromValue$1(value[key]);
 	}
-	for (const key of Symbols(value)) result[key] = FromValue$2(value[key]);
+	for (const key of Symbols(value)) result[key] = FromValue$1(value[key]);
 	return result;
 }
-function FromObject$13(value) {
+function FromObject$12(value) {
 	return IsClassInstance(value) ? FromClassInstance(value) : IsSchemaObject$1(value) ? FromSchemaObject(value) : FromPlainObject(value);
 }
-function FromArray$9(value) {
-	return value.map((element) => FromValue$2(element));
+function FromArray$8(value) {
+	return value.map((element) => FromValue$1(element));
 }
 function FromTypedArray(value) {
 	return value.slice();
@@ -319,17 +254,17 @@ function FromRegExp$1(value) {
 	return new RegExp(value.source, value.flags);
 }
 function FromMap(value) {
-	return new Map(FromValue$2([...value.entries()]));
+	return new Map(FromValue$1([...value.entries()]));
 }
 function FromSet(value) {
-	return new Set(FromValue$2([...value.values()]));
+	return new Set(FromValue$1([...value.values()]));
 }
-function FromValue$2(value) {
-	return IsTypeArray(value) ? FromTypedArray(value) : IsRegExp(value) ? FromRegExp$1(value) : IsMap(value) ? FromMap(value) : IsSet(value) ? FromSet(value) : IsArray$1(value) ? FromArray$9(value) : IsObject$1(value) ? FromObject$13(value) : value;
+function FromValue$1(value) {
+	return IsTypeArray(value) ? FromTypedArray(value) : IsRegExp(value) ? FromRegExp$1(value) : IsMap(value) ? FromMap(value) : IsSet(value) ? FromSet(value) : IsArray$1(value) ? FromArray$8(value) : IsObject$1(value) ? FromObject$12(value) : value;
 }
 function Clone$1(value) {
 	Metrics.clone += 1;
-	return FromValue$2(value);
+	return FromValue$1(value);
 }
 function MergeHidden(left, right) {
 	for (const key of Object.keys(right)) Object.defineProperty(left, key, {
@@ -674,9 +609,9 @@ function FNV1A64_OP(byte) {
 	Accumulator = Accumulator ^ Bytes[byte];
 	Accumulator = Accumulator * Prime % Size;
 }
-function FromArray$8(value) {
+function FromArray$7(value) {
 	FNV1A64_OP(ByteMarker.Array);
-	for (const item of value) FromValue$1(item);
+	for (const item of value) FromValue(item);
 }
 function FromBigInt$5(value) {
 	FNV1A64_OP(ByteMarker.BigInt);
@@ -689,15 +624,15 @@ function FromBoolean$5(value) {
 }
 function FromConstructor(value) {
 	FNV1A64_OP(ByteMarker.Constructor);
-	FromValue$1(value.toString());
+	FromValue(value.toString());
 }
 function FromDate(value) {
 	FNV1A64_OP(ByteMarker.Date);
-	FromValue$1(value.getTime());
+	FromValue(value.getTime());
 }
 function FromFunction(value) {
 	FNV1A64_OP(ByteMarker.Function);
-	FromValue$1(value.toString());
+	FromValue(value.toString());
 }
 function FromNull$1(_value) {
 	FNV1A64_OP(ByteMarker.Null);
@@ -707,11 +642,11 @@ function FromNumber$4(value) {
 	F64In.setFloat64(0, value, true);
 	for (const byte of F64Out) FNV1A64_OP(byte);
 }
-function FromObject$12(value) {
+function FromObject$11(value) {
 	FNV1A64_OP(ByteMarker.Object);
 	for (const key of InstanceKeys(value).sort()) {
-		FromValue$1(key);
-		FromValue$1(value[key]);
+		FromValue(key);
+		FromValue(value[key]);
 	}
 }
 function FromRegExp(value) {
@@ -725,7 +660,7 @@ function FromString$6(value) {
 }
 function FromSymbol(value) {
 	FNV1A64_OP(ByteMarker.Symbol);
-	FromValue$1(value.toString());
+	FromValue(value.toString());
 }
 function FromTypeArray(value) {
 	FNV1A64_OP(ByteMarker.TypeArray);
@@ -735,12 +670,12 @@ function FromTypeArray(value) {
 function FromUndefined$1(_value) {
 	return FNV1A64_OP(ByteMarker.Undefined);
 }
-function FromValue$1(value) {
-	return IsTypeArray(value) ? FromTypeArray(value) : IsDate$1(value) ? FromDate(value) : IsRegExp(value) ? FromRegExp(value) : IsBoolean$1(value) ? FromBoolean$5(value.valueOf()) : IsString$1(value) ? FromString$6(value.valueOf()) : IsNumber$1(value) ? FromNumber$4(value.valueOf()) : IsIEEE754(value) ? FromNumber$4(value) : IsArray$1(value) ? FromArray$8(value) : IsBoolean$2(value) ? FromBoolean$5(value) : IsBigInt$1(value) ? FromBigInt$5(value) : IsConstructor$1(value) ? FromConstructor(value) : IsNull$1(value) ? FromNull$1(value) : IsObject$1(value) ? FromObject$12(value) : IsString$2(value) ? FromString$6(value) : IsSymbol$1(value) ? FromSymbol(value) : IsUndefined$1(value) ? FromUndefined$1(value) : IsFunction$1(value) ? FromFunction(value) : Unreachable$1();
+function FromValue(value) {
+	return IsTypeArray(value) ? FromTypeArray(value) : IsDate$1(value) ? FromDate(value) : IsRegExp(value) ? FromRegExp(value) : IsBoolean$1(value) ? FromBoolean$5(value.valueOf()) : IsString$1(value) ? FromString$6(value.valueOf()) : IsNumber$1(value) ? FromNumber$4(value.valueOf()) : IsIEEE754(value) ? FromNumber$4(value) : IsArray$1(value) ? FromArray$7(value) : IsBoolean$2(value) ? FromBoolean$5(value) : IsBigInt$1(value) ? FromBigInt$5(value) : IsConstructor$1(value) ? FromConstructor(value) : IsNull$1(value) ? FromNull$1(value) : IsObject$1(value) ? FromObject$11(value) : IsString$2(value) ? FromString$6(value) : IsSymbol$1(value) ? FromSymbol(value) : IsUndefined$1(value) ? FromUndefined$1(value) : IsFunction$1(value) ? FromFunction(value) : Unreachable$1();
 }
 function HashCode(value) {
 	Accumulator = BigInt("14695981039346656037");
-	FromValue$1(value);
+	FromValue(value);
 	return Accumulator;
 }
 function Hash(value) {
@@ -2029,13 +1964,13 @@ const Extends$1 = (input) => If(If(If(Const("extends", input), ([_0, input]) =>
 	_4,
 	_5
 ], input])))))), ([_0, input]) => [_0, input], () => If([[], input], ([_0, input]) => [_0, input], () => [])), ([_0, input]) => [ExtendsMapping(_0), input]);
-const Base = (input) => If(If(If(Const("(", input), ([_0, input]) => If(Type(input), ([_1, input]) => If(Const(")", input), ([_2, input]) => [[
+const Base$1 = (input) => If(If(If(Const("(", input), ([_0, input]) => If(Type(input), ([_1, input]) => If(Const(")", input), ([_2, input]) => [[
 	_0,
 	_1,
 	_2
 ], input]))), ([_0, input]) => [_0, input], () => If(KeywordString(input), ([_0, input]) => [_0, input], () => If(KeywordNumber(input), ([_0, input]) => [_0, input], () => If(KeywordBoolean(input), ([_0, input]) => [_0, input], () => If(KeywordUndefined(input), ([_0, input]) => [_0, input], () => If(KeywordNull(input), ([_0, input]) => [_0, input], () => If(KeywordInteger(input), ([_0, input]) => [_0, input], () => If(KeywordBigInt(input), ([_0, input]) => [_0, input], () => If(KeywordUnknown(input), ([_0, input]) => [_0, input], () => If(KeywordAny(input), ([_0, input]) => [_0, input], () => If(KeywordObject(input), ([_0, input]) => [_0, input], () => If(KeywordNever(input), ([_0, input]) => [_0, input], () => If(KeywordSymbol(input), ([_0, input]) => [_0, input], () => If(KeywordVoid(input), ([_0, input]) => [_0, input], () => If(KeywordThis(input), ([_0, input]) => [_0, input], () => If(LiteralBigInt(input), ([_0, input]) => [_0, input], () => If(LiteralBoolean(input), ([_0, input]) => [_0, input], () => If(LiteralNumber(input), ([_0, input]) => [_0, input], () => If(LiteralString(input), ([_0, input]) => [_0, input], () => If(TemplateLiteral$1(input), ([_0, input]) => [_0, input], () => If(Dependent(input), ([_0, input]) => [_0, input], () => If(_Object_(input), ([_0, input]) => [_0, input], () => If(_Tuple_(input), ([_0, input]) => [_0, input], () => If(_Constructor_(input), ([_0, input]) => [_0, input], () => If(_Function_(input), ([_0, input]) => [_0, input], () => If(_Mapped_(input), ([_0, input]) => [_0, input], () => If(GenericCall(input), ([_0, input]) => [_0, input], () => If(Reference(input), ([_0, input]) => [_0, input], () => [])))))))))))))))))))))))))))), ([_0, input]) => [BaseMapping(_0), input]);
 const With$1 = (input) => If(If(If(Const("with", input), ([_0, input]) => If(WithObject(input), ([_1, input]) => [[_0, _1], input])), ([_0, input]) => [_0, input], () => If([[], input], ([_0, input]) => [_0, input], () => [])), ([_0, input]) => [WithMapping(_0), input]);
-const Factor = (input) => If(If(KeyOf$1(input), ([_0, input]) => If(Base(input), ([_1, input]) => If(IndexArray(input), ([_2, input]) => If(Extends$1(input), ([_3, input]) => If(With$1(input), ([_4, input]) => [[
+const Factor = (input) => If(If(KeyOf$1(input), ([_0, input]) => If(Base$1(input), ([_1, input]) => If(IndexArray(input), ([_2, input]) => If(Extends$1(input), ([_3, input]) => If(With$1(input), ([_4, input]) => [[
 	_0,
 	_1,
 	_2,
@@ -2581,14 +2516,14 @@ function ExtendsObjectToRecord(inferred, properties, _pattern, value) {
 function ExtendsObject(inferred, left, right) {
 	return IsRecord(right) ? ExtendsObjectToRecord(inferred, left, RecordPattern(right), RecordValue(right)) : IsObject(right) ? ExtendsObjectToObject(inferred, left, right.properties) : ExtendsRight(inferred, _Object_$1(left), right);
 }
-function FromObject$11(inferred, properties) {
+function FromObject$10(inferred, properties) {
 	return IsEqual(Keys(properties).length, 0) ? ExtendsTrue(inferred) : ExtendsFalse();
 }
 function FromRecord$5(inferred, _leftKey, leftValue, _rightKey, rightValue) {
 	return ExtendsLeft(inferred, leftValue, rightValue);
 }
 function ExtendsRecord(inferred, leftPattern, leftValue, right) {
-	return IsRecord(right) ? FromRecord$5(inferred, RecordPatternToType(leftPattern), leftValue, RecordPatternToType(RecordPattern(right)), RecordValue(right)) : IsObject(right) ? FromObject$11(inferred, right.properties) : IsAny(right) ? ExtendsTrue(inferred) : IsUnknown(right) ? ExtendsTrue(inferred) : ExtendsFalse();
+	return IsRecord(right) ? FromRecord$5(inferred, RecordPatternToType(leftPattern), leftValue, RecordPatternToType(RecordPattern(right)), RecordValue(right)) : IsObject(right) ? FromObject$10(inferred, right.properties) : IsAny(right) ? ExtendsTrue(inferred) : IsUnknown(right) ? ExtendsTrue(inferred) : ExtendsFalse();
 }
 function ExtendsString(inferred, left, right) {
 	return IsString(right) ? ExtendsTrue(inferred) : ExtendsRight(inferred, left, right);
@@ -2614,8 +2549,13 @@ function TryRestInferable(type) {
 function TryInferable(type) {
 	return IsInfer(type) ? Inferrable(type.name, type.extends) : void 0;
 }
-function TryInferResults(rest, right, result = []) {
-	return ShiftLeft(rest, (head, tail) => Match$1(ExtendsLeft({}, head, right), () => TryInferResults(tail, right, [...result, head]), () => void 0), () => result);
+function TryInferResults(rest, right) {
+	const result = [];
+	for (const head of rest) {
+		if (!IsExtendsTrueLike(ExtendsLeft({}, head, right))) return void 0;
+		result.push(head);
+	}
+	return result;
 }
 function InferTupleResult(inferred, name, left, right) {
 	const results = TryInferResults(left, right);
@@ -2653,9 +2593,17 @@ function ExtendsTupleToTuple(inferred, left, right) {
 	const reversed = Reversed(instantiatedRight);
 	return Elements(inferred, reversed, ApplyReverse(left, reversed), ApplyReverse(instantiatedRight, reversed));
 }
+function ExtendsTupleToArrayReduce(inferred, left, right) {
+	for (const head of left) {
+		const result = ExtendsLeft(inferred, head, right);
+		if (!IsExtendsTrueLike(result)) return result;
+		inferred = result.inferred;
+	}
+	return ExtendsTrue(inferred);
+}
 function ExtendsTupleToArray(inferred, left, right) {
 	const inferrable = TryInferable(right);
-	return IsInferable(inferrable) ? InferUnionResult(inferred, inferrable["name"], left, inferrable["type"]) : ShiftLeft(left, (head, tail) => Match$1(ExtendsLeft(inferred, head, right), (inferred) => ExtendsTupleToArray(inferred, tail, right), () => ExtendsFalse()), () => ExtendsTrue(inferred));
+	return IsInferable(inferrable) ? InferUnionResult(inferred, inferrable["name"], left, inferrable["type"]) : ExtendsTupleToArrayReduce(inferred, left, right);
 }
 function ExtendsTuple(inferred, left, right) {
 	const instantiatedLeft = InstantiateElements(inferred, State([], []), left);
@@ -3149,7 +3097,7 @@ function FromIntersect$8(types) {
 		return CollapseIntersectProperties(result, FromType$15(left));
 	}, {});
 }
-function FromObject$10(properties) {
+function FromObject$9(properties) {
 	return properties;
 }
 function FromTuple$7(types) {
@@ -3170,7 +3118,7 @@ function FromUnion$9(types) {
 	return ShiftLeft(types, (left, right) => ReduceVariants(right, FromType$15(left)), () => Unreachable$1());
 }
 function FromType$15(type) {
-	return IsCyclic(type) ? FromCyclic$8(type.$defs, type.$ref) : IsDependent(type) ? FromDependent$4(type.if, type.then, type.else) : IsIntersect(type) ? FromIntersect$8(type.allOf) : IsUnion(type) ? FromUnion$9(type.anyOf) : IsTuple(type) ? FromTuple$7(type.items) : IsObject(type) ? FromObject$10(type.properties) : {};
+	return IsCyclic(type) ? FromCyclic$8(type.$defs, type.$ref) : IsDependent(type) ? FromDependent$4(type.if, type.then, type.else) : IsIntersect(type) ? FromIntersect$8(type.allOf) : IsUnion(type) ? FromUnion$9(type.anyOf) : IsTuple(type) ? FromTuple$7(type.items) : IsObject(type) ? FromObject$9(type.properties) : {};
 }
 function CollapseToObject(type) {
 	return _Object_$1(FromType$15(type));
@@ -3189,7 +3137,7 @@ function NormalizeIndexerTypes(types) {
 function NormalizeIndexer(type) {
 	return IsIntersect(type) ? Intersect(NormalizeIndexerTypes(type.allOf)) : IsUnion(type) ? Union(NormalizeIndexerTypes(type.anyOf)) : IsLiteral(type) ? NormalizeLiteral(type.const) : type;
 }
-function FromArray$7(type, indexer) {
+function FromArray$6(type, indexer) {
 	return IsExtendsTrueLike(Extends({}, NormalizeIndexer(indexer), Number$2())) ? type : IsLiteral(indexer) && IsEqual(indexer.const, "length") ? Number$2() : Never();
 }
 function FromCyclic$7(defs, ref) {
@@ -3248,7 +3196,7 @@ function NumericKeys(keys) {
 function FromIndexerNumber(properties) {
 	return EvaluateUnion(IndexProperties(properties, NumericKeys(PropertyKeys(properties))));
 }
-function FromObject$9(properties, indexer) {
+function FromObject$8(properties, indexer) {
 	return IsNumber(indexer) ? FromIndexerNumber(properties) : FromIndexer(properties, indexer);
 }
 function ConvertLiteral(value) {
@@ -3275,7 +3223,7 @@ function FromTuple$6(types, indexer) {
 	return IsLiteral(indexer) && IsEqual(indexer.const, "length") ? Literal(types.length) : IsNumber(indexer) || IsInteger(indexer) ? FromTupleWithoutIndexer(types) : FromTupleWithIndexer(types, indexer);
 }
 function FromType$12(type, indexer) {
-	return IsArray(type) ? FromArray$7(type.items, indexer) : IsObject(type) ? FromObject$9(type.properties, indexer) : IsTuple(type) ? FromTuple$6(type.items, indexer) : Never();
+	return IsArray(type) ? FromArray$6(type.items, indexer) : IsObject(type) ? FromObject$8(type.properties, indexer) : IsTuple(type) ? FromTuple$6(type.items, indexer) : Never();
 }
 function NormalizeType$1(type) {
 	return IsCyclic(type) || IsDependent(type) || IsIntersect(type) || IsUnion(type) ? CollapseToObject(type) : type;
@@ -3314,7 +3262,7 @@ function FromAny() {
 		Symbol$1()
 	]);
 }
-function FromArray$6(_type) {
+function FromArray$5(_type) {
 	return Number$2();
 }
 function FromPropertyKeys(keys) {
@@ -3322,7 +3270,7 @@ function FromPropertyKeys(keys) {
 		return IsLiteralValue(left) ? [...result, Literal(ConvertToIntegerKey(left))] : Unreachable$1();
 	}, []);
 }
-function FromObject$8(properties) {
+function FromObject$7(properties) {
 	return EvaluateUnionFast(FromPropertyKeys(Keys(properties)));
 }
 function FromRecord$4(type) {
@@ -3332,7 +3280,7 @@ function FromTuple$5(types) {
 	return EvaluateUnionFast(types.map((_, index) => Literal(index)));
 }
 function FromType$11(type) {
-	return IsAny(type) ? FromAny() : IsArray(type) ? FromArray$6(type.items) : IsObject(type) ? FromObject$8(type.properties) : IsRecord(type) ? FromRecord$4(type) : IsTuple(type) ? FromTuple$5(type.items) : Never();
+	return IsAny(type) ? FromAny() : IsArray(type) ? FromArray$5(type.items) : IsObject(type) ? FromObject$7(type.properties) : IsRecord(type) ? FromRecord$4(type) : IsTuple(type) ? FromTuple$5(type.items) : Never();
 }
 function NormalizeType(type) {
 	return IsCyclic(type) || IsDependent(type) || IsIntersect(type) || IsUnion(type) ? CollapseToObject(type) : type;
@@ -3509,7 +3457,7 @@ function FromIntersect$6(types) {
 function FromUnion$6(types) {
 	return Union(types.map((type) => FromType$8(type)));
 }
-function FromObject$7(properties) {
+function FromObject$6(properties) {
 	return _Object_$1(Keys(properties).reduce((result, left) => {
 		return {
 			...result,
@@ -3518,7 +3466,7 @@ function FromObject$7(properties) {
 	}, {}));
 }
 function FromType$8(type) {
-	return IsCyclic(type) ? FromCyclic$6(type.$defs, type.$ref) : IsDependent(type) ? FromDependent$2(type.if, type.then, type.else) : IsIntersect(type) ? FromIntersect$6(type.allOf) : IsUnion(type) ? FromUnion$6(type.anyOf) : IsObject(type) ? FromObject$7(type.properties) : _Object_$1({});
+	return IsCyclic(type) ? FromCyclic$6(type.$defs, type.$ref) : IsDependent(type) ? FromDependent$2(type.if, type.then, type.else) : IsIntersect(type) ? FromIntersect$6(type.allOf) : IsUnion(type) ? FromUnion$6(type.anyOf) : IsObject(type) ? FromObject$6(type.properties) : _Object_$1({});
 }
 function PartialAction(type, options) {
 	return CanInstantiate([type]) ? Update$1(FromType$8(type), {}, options) : PartialDeferred(type, options);
@@ -3553,7 +3501,7 @@ function ReadonlyObject(type, options = {}) {
 	return ReadonlyObjectAction(type, options);
 }
 const ReadonlyType = ReadonlyObject;
-function FromArray$5(type) {
+function FromArray$4(type) {
 	return AddImmutable(_Array_(type));
 }
 function FromCyclic$5(defs, ref) {
@@ -3566,7 +3514,7 @@ function FromDependent$1(if_, then_, else_) {
 function FromIntersect$5(types) {
 	return FromType$6(EvaluateIntersect(types));
 }
-function FromObject$6(properties) {
+function FromObject$5(properties) {
 	return _Object_$1(Keys(properties).reduce((result, left) => {
 		return {
 			...result,
@@ -3581,7 +3529,7 @@ function FromUnion$5(types) {
 	return Union(types.map((type) => FromType$6(type)));
 }
 function FromType$6(type) {
-	return IsArray(type) ? FromArray$5(type.items) : IsCyclic(type) ? FromCyclic$5(type.$defs, type.$ref) : IsDependent(type) ? FromDependent$1(type.if, type.then, type.else) : IsIntersect(type) ? FromIntersect$5(type.allOf) : IsObject(type) ? FromObject$6(type.properties) : IsTuple(type) ? FromTuple$4(type.items) : IsUnion(type) ? FromUnion$5(type.anyOf) : type;
+	return IsArray(type) ? FromArray$4(type.items) : IsCyclic(type) ? FromCyclic$5(type.$defs, type.$ref) : IsDependent(type) ? FromDependent$1(type.if, type.then, type.else) : IsIntersect(type) ? FromIntersect$5(type.allOf) : IsObject(type) ? FromObject$5(type.properties) : IsTuple(type) ? FromTuple$4(type.items) : IsUnion(type) ? FromUnion$5(type.anyOf) : type;
 }
 function ReadonlyObjectAction(type, options) {
 	return CanInstantiate([type]) ? Update$1(FromType$6(type), {}, options) : ReadonlyObjectDeferred(type);
@@ -3605,7 +3553,7 @@ function FromIntersect$4(types) {
 function FromUnion$4(types) {
 	return Union(types.map((type) => FromType$5(type)));
 }
-function FromObject$5(properties) {
+function FromObject$4(properties) {
 	return _Object_$1(Keys(properties).reduce((result, left) => {
 		return {
 			...result,
@@ -3614,7 +3562,7 @@ function FromObject$5(properties) {
 	}, {}));
 }
 function FromType$5(type) {
-	return IsCyclic(type) ? FromCyclic$4(type.$defs, type.$ref) : IsDependent(type) ? FromDependent(type.if, type.then, type.else) : IsIntersect(type) ? FromIntersect$4(type.allOf) : IsUnion(type) ? FromUnion$4(type.anyOf) : IsObject(type) ? FromObject$5(type.properties) : _Object_$1({});
+	return IsCyclic(type) ? FromCyclic$4(type.$defs, type.$ref) : IsDependent(type) ? FromDependent(type.if, type.then, type.else) : IsIntersect(type) ? FromIntersect$4(type.allOf) : IsUnion(type) ? FromUnion$4(type.anyOf) : IsObject(type) ? FromObject$4(type.properties) : _Object_$1({});
 }
 function RequiredDeferred(type, options = {}) {
 	return Deferred("Required", [type], options);
@@ -4080,44 +4028,137 @@ var CheckContext = class {
 	}
 };
 var ErrorContext = class extends CheckContext {
-	constructor(callback) {
+	constructor() {
 		super();
-		this.callback = callback;
+		this.errors = [];
 	}
-	AddError(error) {
-		this.callback(error);
-		return false;
+	AtCapacity() {
+		return this.errors.length >= Get$2().maxErrors;
 	}
-};
-var AccumulatedErrorContext = class extends ErrorContext {
-	constructor() {
-		super((error) => this.errors.push(error));
-		this.errors = [];
+	AddError(keyword, schemaPath, instancePath, params) {
+		return this.AddErrorObject({
+			keyword,
+			schemaPath,
+			instancePath,
+			params
+		});
 	}
-	AddError(error) {
-		this.errors.push(error);
+	AddErrors(error) {
+		error.forEach((error) => this.AddErrorObject(error));
 		return false;
 	}
 	GetErrors() {
 		return this.errors;
 	}
+	AddErrorObject(error) {
+		if (!this.AtCapacity()) this.errors.push(error);
+		return false;
+	}
 };
 function CheckRefine(_stack, _context, schema, value) {
 	return Every(schema["~refine"], 0, (refinement, _) => refinement.check(value));
 }
 function ErrorRefine(_stack, context, schemaPath, instancePath, schema, value) {
 	return EveryAll(schema["~refine"], 0, (refinement, index) => {
-		return refinement.check(value) || context.AddError({
-			keyword: "~refine",
-			schemaPath,
-			instancePath,
-			params: {
-				index,
-				message: refinement.error(value)
-			}
+		return refinement.check(value) || context.AddError("~refine", schemaPath, instancePath, {
+			index,
+			message: refinement.error(value)
 		});
 	});
 }
+const DefaultUri = "urn:typebox:root";
+function NextUri(ref, base) {
+	return URL.canParse(ref, base) ? new URL(ref, base) : IsEqual(base, "urn:typebox:root") ? new URL(`${base}:${ref}`) : new URL(`${base.slice(0, base.lastIndexOf(":"))}:${ref}`);
+}
+function Stack(context, schema) {
+	const base = IsSchemaObject(schema) && IsId(schema) ? NextUri(schema.$id, DefaultUri).href : DefaultUri;
+	return {
+		context,
+		schema,
+		lexicalSchema: schema,
+		lexicalBase: base,
+		resourceBase: base,
+		referenceBase: base,
+		ids: [],
+		useResourceBaseForReference: true,
+		recursiveAnchor: void 0,
+		dynamicAnchors: [],
+		resourceEntries: /* @__PURE__ */ new Map(),
+		pendingResource: true,
+		enteredResource: false
+	};
+}
+function RegisterResourceAnchors(anchors, schema, isRoot = true) {
+	if (IsSchemaBoolean(schema)) return anchors;
+	if (Array.isArray(schema)) return schema.reduce((result, item) => RegisterResourceAnchors(result, item, false), anchors);
+	if (!IsSchemaObject(schema)) return anchors;
+	if (!isRoot && IsId(schema)) return anchors;
+	const next = !isRoot && IsDynamicAnchor(schema) ? [...anchors, schema] : anchors;
+	return Object.keys(schema).reduce((result, key) => RegisterResourceAnchors(result, schema[key], false), next);
+}
+function ResourceEntry(stack, schema) {
+	return stack.resourceEntries.get(schema);
+}
+function NextEnteredResource(stack, schema) {
+	return stack.enteredResource || ResourceEntry(stack, schema) !== void 0;
+}
+function IsRelativeId(schema) {
+	return !/^[A-Za-z][A-Za-z0-9+.-]*:/.test(schema.$id);
+}
+function NextIds(stack, schema) {
+	return IsId(schema) ? [...stack.ids, schema] : stack.ids;
+}
+function NextRecursiveAnchor(stack, schema) {
+	return stack.recursiveAnchor ?? (IsRecursiveAnchorTrue(schema) ? schema : void 0);
+}
+function NextDynamicAnchors(stack, schema) {
+	const registered = IsId(schema) ? RegisterResourceAnchors(stack.dynamicAnchors, schema) : stack.dynamicAnchors;
+	return IsDynamicAnchor(schema) ? [...registered, schema] : registered;
+}
+function NextPendingResource(stack, schema) {
+	return IsId(schema) ? false : stack.pendingResource;
+}
+function NextLexicalBase(stack, schema) {
+	const entry = ResourceEntry(stack, schema);
+	if (entry) return entry.base;
+	return IsId(schema) ? NextUri(schema.$id, stack.lexicalBase).href : stack.lexicalBase;
+}
+function NextResourceBase(stack, schema) {
+	const entry = ResourceEntry(stack, schema);
+	if (entry) return entry.base;
+	return IsId(schema) && stack.pendingResource ? NextUri(schema.$id, stack.resourceBase).href : stack.resourceBase;
+}
+function NextUseResourceBaseForReference(stack, schema) {
+	return IsId(schema) ? !IsRelativeId(schema) : stack.useResourceBaseForReference;
+}
+function NextReferenceBase(stack, schema) {
+	const isRetrieved = NextEnteredResource(stack, schema);
+	const useResourceBaseForReference = NextUseResourceBaseForReference(stack, schema);
+	return isRetrieved || useResourceBaseForReference ? NextResourceBase(stack, schema) : NextLexicalBase(stack, schema);
+}
+function NextLexicalSchema(stack, schema) {
+	const entry = ResourceEntry(stack, schema);
+	if (entry) return entry.root;
+	return IsId(schema) ? schema : stack.lexicalSchema;
+}
+function HasStackKeywords(stack, schema) {
+	return IsSchemaObject(schema) && (IsId(schema) || IsDynamicAnchor(schema) || IsUndefined$1(stack.recursiveAnchor) && IsRecursiveAnchorTrue(schema) || !IsUndefined$1(ResourceEntry(stack, schema)));
+}
+function NextStack(stack, schema) {
+	return HasStackKeywords(stack, schema) ? {
+		...stack,
+		ids: NextIds(stack, schema),
+		dynamicAnchors: NextDynamicAnchors(stack, schema),
+		recursiveAnchor: NextRecursiveAnchor(stack, schema),
+		pendingResource: NextPendingResource(stack, schema),
+		lexicalBase: NextLexicalBase(stack, schema),
+		resourceBase: NextResourceBase(stack, schema),
+		useResourceBaseForReference: NextUseResourceBaseForReference(stack, schema),
+		referenceBase: NextReferenceBase(stack, schema),
+		lexicalSchema: NextLexicalSchema(stack, schema),
+		enteredResource: NextEnteredResource(stack, schema)
+	} : stack;
+}
 function IsValid$4(schema) {
 	return IsItems(schema) && IsArray$1(schema.items);
 }
@@ -4159,16 +4200,10 @@ function ErrorAdditionalProperties(stack, context, schemaPath, instancePath, sch
 	return EveryAll(Keys(value), 0, (key, _index) => {
 		const nextSchemaPath = `${schemaPath}/additionalProperties`;
 		const nextInstancePath = `${instancePath}/${key}`;
-		const nextContext = new AccumulatedErrorContext();
-		const isAdditionalProperty = regexp.test(key) || ErrorSchemaPushStack(stack, nextContext, nextSchemaPath, nextInstancePath, schema.additionalProperties, value[key]) && context.AddKey(key);
+		const isAdditionalProperty = regexp.test(key) || ErrorSchemaPushStack(stack, context, nextSchemaPath, nextInstancePath, schema.additionalProperties, value[key]) && context.AddKey(key);
 		if (!isAdditionalProperty) additionalProperties.push(key);
 		return isAdditionalProperty;
-	}) || context.AddError({
-		keyword: "additionalProperties",
-		schemaPath,
-		instancePath,
-		params: { additionalProperties }
-	});
+	}) || context.AddError("additionalProperties", schemaPath, instancePath, { additionalProperties });
 }
 function CheckAllOf(stack, context, schema, value) {
 	const results = schema.allOf.reduce((result, schema) => {
@@ -4181,13 +4216,13 @@ function ErrorAllOf(stack, context, schemaPath, instancePath, schema, value) {
 	const failedContexts = [];
 	const results = schema.allOf.reduce((result, schema, index) => {
 		const nextSchemaPath = `${schemaPath}/allOf/${index}`;
-		const nextContext = new AccumulatedErrorContext();
+		const nextContext = new ErrorContext();
 		const isSchema = ErrorSchema(stack, nextContext, nextSchemaPath, instancePath, schema, value);
 		if (!isSchema) failedContexts.push(nextContext);
 		return isSchema ? [...result, nextContext] : result;
 	}, []);
 	const isAllOf = IsEqual(results.length, schema.allOf.length) && context.Merge(results);
-	if (!isAllOf) failedContexts.forEach((failed) => failed.GetErrors().forEach((error) => context.AddError(error)));
+	if (!isAllOf) failedContexts.forEach((failed) => context.AddErrors(failed.GetErrors()));
 	return isAllOf;
 }
 function CheckAnyOf(stack, context, schema, value) {
@@ -4200,41 +4235,26 @@ function CheckAnyOf(stack, context, schema, value) {
 function ErrorAnyOf(stack, context, schemaPath, instancePath, schema, value) {
 	const failedContexts = [];
 	const results = schema.anyOf.reduce((result, schema, index) => {
-		const nextContext = new AccumulatedErrorContext();
+		const nextContext = new ErrorContext();
 		const isSchema = ErrorSchema(stack, nextContext, `${schemaPath}/anyOf/${index}`, instancePath, schema, value);
 		if (!isSchema) failedContexts.push(nextContext);
 		return isSchema ? [...result, nextContext] : result;
 	}, []);
 	const isAnyOf = IsGreaterThan(results.length, 0) && context.Merge(results);
-	if (!isAnyOf) failedContexts.forEach((failed) => failed.GetErrors().forEach((error) => context.AddError(error)));
-	return isAnyOf || context.AddError({
-		keyword: "anyOf",
-		schemaPath,
-		instancePath,
-		params: {}
-	});
+	if (!isAnyOf) failedContexts.forEach((failed) => context.AddErrors(failed.GetErrors()));
+	return isAnyOf || context.AddError("anyOf", schemaPath, instancePath, {});
 }
 function CheckSchemaBoolean(_stack, _context, schema, _value) {
 	return schema;
 }
 function ErrorSchemaBoolean(stack, context, schemaPath, instancePath, schema, value) {
-	return CheckSchemaBoolean(stack, context, schema, value) || context.AddError({
-		keyword: "boolean",
-		schemaPath,
-		instancePath,
-		params: {}
-	});
+	return CheckSchemaBoolean(stack, context, schema, value) || context.AddError("boolean", schemaPath, instancePath, {});
 }
 function CheckConst(_stack, _context, schema, value) {
 	return IsValueLike(schema.const) ? IsEqual(value, schema.const) : IsDeepEqual(value, schema.const);
 }
 function ErrorConst(stack, context, schemaPath, instancePath, schema, value) {
-	return CheckConst(stack, context, schema, value) || context.AddError({
-		keyword: "const",
-		schemaPath,
-		instancePath,
-		params: { allowedValue: schema.const }
-	});
+	return CheckConst(stack, context, schema, value) || context.AddError("const", schemaPath, instancePath, { allowedValue: schema.const });
 }
 function IsValid$3(schema) {
 	return !(IsMinContains(schema) && IsEqual(schema.minContains, 0));
@@ -4246,12 +4266,7 @@ function CheckContains(stack, context, schema, value) {
 	});
 }
 function ErrorContains(stack, context, schemaPath, instancePath, schema, value) {
-	return CheckContains(stack, context, schema, value) || context.AddError({
-		keyword: "contains",
-		schemaPath,
-		instancePath,
-		params: { minContains: 1 }
-	});
+	return CheckContains(stack, context, schema, value) || context.AddError("contains", schemaPath, instancePath, { minContains: 1 });
 }
 function CheckDependencies(stack, context, schema, value) {
 	const isLength = IsEqual(Keys(value).length, 0);
@@ -4264,14 +4279,9 @@ function ErrorDependencies(stack, context, schemaPath, instancePath, schema, val
 	const isLength = IsEqual(Keys(value).length, 0);
 	const isEvery = EveryAll(Entries(schema.dependencies), 0, ([key, schema]) => {
 		const nextSchemaPath = `${schemaPath}/dependencies/${key}`;
-		return !HasPropertyKey(value, key) || (IsArray$1(schema) ? schema.every((dependency) => HasPropertyKey(value, dependency) || context.AddError({
-			keyword: "dependencies",
-			schemaPath,
-			instancePath,
-			params: {
-				property: key,
-				dependencies: schema
-			}
+		return !HasPropertyKey(value, key) || (IsArray$1(schema) ? schema.every((dependency) => HasPropertyKey(value, dependency) || context.AddError("dependencies", schemaPath, instancePath, {
+			property: key,
+			dependencies: schema
 		})) : ErrorSchema(stack, context, nextSchemaPath, instancePath, schema, value));
 	});
 	return isLength || isEvery;
@@ -4286,14 +4296,9 @@ function CheckDependentRequired(_stack, _context, schema, value) {
 function ErrorDependentRequired(_stack, context, schemaPath, instancePath, schema, value) {
 	const isLength = IsEqual(Keys(value).length, 0);
 	const isEveryEntry = EveryAll(Entries(schema.dependentRequired), 0, ([key, keys]) => {
-		return !HasPropertyKey(value, key) || EveryAll(keys, 0, (dependency) => HasPropertyKey(value, dependency) || context.AddError({
-			keyword: "dependentRequired",
-			schemaPath,
-			instancePath,
-			params: {
-				property: key,
-				dependencies: keys
-			}
+		return !HasPropertyKey(value, key) || EveryAll(keys, 0, (dependency) => HasPropertyKey(value, dependency) || context.AddError("dependentRequired", schemaPath, instancePath, {
+			property: key,
+			dependencies: keys
 		}));
 	});
 	return isLength || isEveryEntry;
@@ -4313,51 +4318,258 @@ function ErrorDependentSchemas(stack, context, schemaPath, instancePath, schema,
 	});
 	return isLength || isEvery;
 }
-function CheckDynamicRef(stack, context, schema, value) {
-	const target = stack.DynamicRef(schema) ?? false;
-	return IsSchema(target) && CheckSchema(stack, context, target, value);
+function Indices(pointer) {
+	const indices = pointer.split("/").map((index) => index.replace(/~1/g, "/").replace(/~0/g, "~"));
+	return indices[0] === "" ? indices.slice(1) : indices;
+}
+function Get(value, pointer) {
+	let current = value;
+	for (const index of Indices(pointer)) {
+		if (!IsObject$1(current) || IsUnsafePropertyKey(index)) return void 0;
+		current = current[index];
+	}
+	return current;
+}
+function RelativeBase(schema, base) {
+	return IsSchemaObject(schema) && IsId(schema) ? NextUri(schema.$id, base.href) : base;
+}
+function AbsoluteBase(base) {
+	return NextUri(base, DefaultUri);
+}
+function CanonicalHref(url) {
+	return url.href.split("#")[0];
+}
+function Base(schema, base, target) {
+	return SearchBase(schema, AbsoluteBase(base), target);
+}
+function RefRoot(stack, ref) {
+	return ref.$ref.startsWith("#") || stack.enteredResource ? stack.lexicalSchema : stack.schema;
+}
+function IsPointerFragment(fragment) {
+	return fragment.startsWith("#/");
+}
+function SearchDynamicAnchor(schema, name) {
+	if (IsObject$1(schema) && IsDynamicAnchor(schema) && IsEqual(schema.$dynamicAnchor, name)) return schema;
+	if (IsObject$1(schema)) for (const key of Keys(schema)) {
+		const result = SearchDynamicAnchor(schema[key], name);
+		if (result) return result;
+	}
+}
+function SearchBase(schema, base, target) {
+	if (IsEqual(schema, target)) return base.href;
+	const nextBase = RelativeBase(schema, base);
+	if (IsArray$1(schema)) for (const item of schema) {
+		const result = SearchBase(item, nextBase, target);
+		if (!IsUndefined$1(result)) return result;
+	}
+	else if (IsObject$1(schema)) for (const key of Keys(schema)) {
+		const result = SearchBase(schema[key], nextBase, target);
+		if (!IsUndefined$1(result)) return result;
+	}
+}
+function MatchWithHash(schema, ref) {
+	if (ref.href.endsWith("#")) return schema;
+	if (!ref.hash.startsWith("#")) return void 0;
+	const fragment = decodeURIComponent(ref.hash.slice(1));
+	if (!fragment.startsWith("/")) return void 0;
+	return Get(schema, fragment);
+}
+function MatchWithId(schema, base, ref) {
+	if (!IsId(schema)) return void 0;
+	if (IsEqual(schema.$id, ref.hash)) return schema;
+	const absoluteRef = new URL(ref.href, base.href);
+	if (IsEqual(base.pathname, absoluteRef.pathname)) return ref.hash.startsWith("#") ? MatchWithHash(schema, ref) : schema;
+}
+function MatchWithAnchor(schema, base, ref) {
+	if (!IsAnchor(schema)) return void 0;
+	const absoluteAnchor = new URL(`#${schema.$anchor}`, base.href);
+	const absoluteRef = new URL(ref.href, base.href);
+	return IsEqual(absoluteAnchor.href, absoluteRef.href) ? schema : void 0;
+}
+function MatchWithDynamicAnchor(schema, base, ref) {
+	if (!IsDynamicAnchor(schema)) return void 0;
+	const absoluteAnchor = new URL(`#${schema.$dynamicAnchor}`, base.href);
+	const absoluteRef = new URL(ref.href, base.href);
+	return IsEqual(absoluteAnchor.href, absoluteRef.href) ? schema : void 0;
+}
+function MatchSchemaObject(schema, base, ref) {
+	if (!IsSchemaObject(schema)) return void 0;
+	return MatchWithId(schema, base, ref) ?? MatchWithAnchor(schema, base, ref) ?? MatchWithDynamicAnchor(schema, base, ref) ?? MatchWithHash(schema, ref);
+}
+function MatchFromArray(schema, base, ref) {
+	if (!IsArray$1(schema)) return void 0;
+	return schema.reduce((result, item) => {
+		const match = Match(item, base, ref);
+		return !IsUndefined$1(match) ? match : result;
+	}, void 0);
+}
+function MatchFromObject(schema, base, ref) {
+	if (!IsObject$1(schema)) return void 0;
+	return Keys(schema).reduce((result, key) => {
+		if (IsEqual(key, "const") || IsEqual(key, "enum")) return result;
+		const match = Match(schema[key], base, ref);
+		return !IsUndefined$1(match) ? match : result;
+	}, void 0);
+}
+function Match(schema, base, ref) {
+	const relativeBase = RelativeBase(schema, base);
+	return MatchSchemaObject(schema, relativeBase, ref) ?? MatchFromArray(schema, relativeBase, ref) ?? MatchFromObject(schema, relativeBase, ref);
+}
+function Resource(context, schema, base, ref) {
+	const result = RefInternal(context, schema, base, ref);
+	return IsSchemaObject(result) && IsId(result) ? result : void 0;
+}
+function FindDeferredResourceLegacy(stack, ref, schema) {
+	if (!ref.$ref.startsWith("#")) return void 0;
+	if (!IsSchemaObject(stack.schema) || HasPropertyKey(stack.schema, "$schema")) return void 0;
+	const targetBase = Base(stack.lexicalSchema, stack.referenceBase, schema);
+	if (IsUndefined$1(targetBase) || IsEqual(targetBase, stack.referenceBase)) return void 0;
+	return {
+		target: schema,
+		base: targetBase,
+		root: stack.lexicalSchema
+	};
+}
+function FindDeferredResourceModern(stack, canonical, schema) {
+	const remoteRoot = stack.context[canonical];
+	if (!IsSchemaObject(remoteRoot)) return void 0;
+	return {
+		target: schema,
+		base: canonical,
+		root: remoteRoot
+	};
+}
+function FindDeferredResource(stack, ref, schema, canonical, isRemote) {
+	const remote = isRemote ? FindDeferredResourceModern(stack, canonical, schema) : void 0;
+	return IsUndefined$1(remote) ? FindDeferredResourceLegacy(stack, ref, schema) : remote;
 }
-function ErrorDynamicRef(stack, context, _schemaPath, instancePath, schema, value) {
-	const target = stack.DynamicRef(schema) ?? false;
-	return IsSchema(target) && ErrorSchema(stack, context, "#", instancePath, target, value);
+function FindResolvedResource(stack, canonical, schema) {
+	if (IsId(schema)) return void 0;
+	const resource = Resource(stack.context, stack.schema, stack.referenceBase, canonical);
+	if (!resource || stack.ids.includes(resource)) return void 0;
+	return { resource };
+}
+function RefInternalWithContext(context, ref) {
+	return HasPropertyKey(context, ref) ? context[ref] : void 0;
+}
+function RefInternalWithLocal(schema, base, ref) {
+	return Match(schema, base, ref);
+}
+function RefInternalWithRemote(context, base, ref) {
+	const canonicalHref = CanonicalHref(ref);
+	if (!HasPropertyKey(context, canonicalHref) || IsEqual(canonicalHref, CanonicalHref(base))) return void 0;
+	const remoteSchema = context[canonicalHref];
+	const remoteBase = RelativeBase(remoteSchema, new URL(canonicalHref));
+	return IsEqual(ref.hash, "") ? remoteSchema : Match(remoteSchema, remoteBase, ref);
+}
+function RefInternal(context, schema, base, ref) {
+	const absoluteBase = AbsoluteBase(base);
+	const target = NextUri(ref, absoluteBase.href);
+	return RefInternalWithContext(context, ref) ?? RefInternalWithLocal(schema, absoluteBase, target) ?? RefInternalWithRemote(context, absoluteBase, target);
+}
+function RefNextStackDeferred(stack, deferredResource) {
+	if (!deferredResource) return stack;
+	const resourceEntries = new Map(stack.resourceEntries);
+	resourceEntries.set(deferredResource.target, {
+		base: deferredResource.base,
+		root: deferredResource.root
+	});
+	return {
+		...stack,
+		resourceEntries
+	};
+}
+function RefNextStackResolved(stack, resolvedResource) {
+	return resolvedResource ? NextStack(stack, resolvedResource.resource) : stack;
+}
+function RefNextStack(stack, pendingResource, deferredResource, resolvedResource) {
+	return RefNextStackResolved(RefNextStackDeferred({
+		...stack,
+		pendingResource
+	}, deferredResource), resolvedResource);
+}
+function RefResultFound(stack, ref, schema) {
+	const canonical = CanonicalHref(NextUri(ref.$ref, stack.referenceBase));
+	const isRemote = !IsEqual(canonical, stack.resourceBase);
+	return {
+		schema,
+		stack: RefNextStack(stack, true, FindDeferredResource(stack, ref, schema, canonical, isRemote), isRemote ? FindResolvedResource(stack, canonical, schema) : void 0)
+	};
+}
+function RefResultNotFound(stack, schema) {
+	return {
+		schema,
+		stack: RefNextStack(stack, !IsUndefined$1(schema))
+	};
+}
+function Ref(stack, ref) {
+	const schema = RefInternal(stack.context, RefRoot(stack, ref), stack.referenceBase, ref.$ref);
+	return IsSchemaObject(schema) ? RefResultFound(stack, ref, schema) : RefResultNotFound(stack, schema);
+}
+function IsRecursiveAnchorInScope(stack) {
+	return IsSchemaObject(stack.lexicalSchema) && IsRecursiveAnchorTrue(stack.lexicalSchema);
+}
+function RecursiveRef(stack, recursiveRef) {
+	const schema = IsRecursiveAnchorInScope(stack) ? stack.recursiveAnchor : stack.lexicalSchema;
+	return RefInternal(stack.context, schema, stack.lexicalBase, recursiveRef.$recursiveRef);
+}
+function DynamicRefFragment(stack, dynamicRef) {
+	return NextUri(dynamicRef.$dynamicRef, AbsoluteBase(stack.lexicalBase).href).hash;
+}
+function FindScopedDynamicAnchor(stack, name) {
+	return stack.dynamicAnchors.find((anchor) => IsEqual(anchor.$dynamicAnchor, name)) ?? SearchDynamicAnchor(stack.schema, name);
+}
+function DynamicRefWhenFound(stack, dynamicRef, fragmentTarget) {
+	if (!IsSchemaObject(fragmentTarget) || !IsDynamicAnchor(fragmentTarget)) return fragmentTarget;
+	return IsPointerFragment(DynamicRefFragment(stack, dynamicRef)) ? fragmentTarget : FindScopedDynamicAnchor(stack, fragmentTarget.$dynamicAnchor);
+}
+function DynamicRefWhenNotFound(stack, dynamicRef) {
+	const fragment = DynamicRefFragment(stack, dynamicRef);
+	return FindScopedDynamicAnchor(stack, decodeURIComponent(fragment.slice(1)));
+}
+function DynamicRef(stack, dynamicRef) {
+	const fragmentRoot = dynamicRef.$dynamicRef.startsWith("#") ? stack.lexicalSchema : stack.schema;
+	const fragmentTarget = RefInternal(stack.context, fragmentRoot, stack.lexicalBase, dynamicRef.$dynamicRef);
+	return IsUndefined$1(fragmentTarget) ? DynamicRefWhenNotFound(stack, dynamicRef) : DynamicRefWhenFound(stack, dynamicRef, fragmentTarget);
+}
+function CheckDynamicRef(stack, context, schema, value) {
+	const target = DynamicRef(stack, schema) ?? false;
+	const nextStack = target ? {
+		...stack,
+		pendingResource: true
+	} : stack;
+	return IsSchema(target) && CheckSchema(nextStack, context, target, value);
+}
+function ErrorDynamicRef(stack, context, schemaPath, instancePath, schema, value) {
+	const target = DynamicRef(stack, schema) ?? false;
+	const nextStack = target ? {
+		...stack,
+		pendingResource: true
+	} : stack;
+	return IsSchema(target) && ErrorSchema(nextStack, context, schemaPath, instancePath, target, value);
 }
 function CheckEnum(_stack, _context, schema, value) {
 	return Some(schema.enum, (option) => IsValueLike(option) ? IsEqual(value, option) : IsDeepEqual(value, option));
 }
 function ErrorEnum(stack, context, schemaPath, instancePath, schema, value) {
-	return CheckEnum(stack, context, schema, value) || context.AddError({
-		keyword: "enum",
-		schemaPath,
-		instancePath,
-		params: { allowedValues: schema.enum }
-	});
+	return CheckEnum(stack, context, schema, value) || context.AddError("enum", schemaPath, instancePath, { allowedValues: schema.enum });
 }
 function CheckExclusiveMaximum(_stack, _context, schema, value) {
 	return IsLessThan(value, schema.exclusiveMaximum);
 }
 function ErrorExclusiveMaximum(stack, context, schemaPath, instancePath, schema, value) {
-	return CheckExclusiveMaximum(stack, context, schema, value) || context.AddError({
-		keyword: "exclusiveMaximum",
-		schemaPath,
-		instancePath,
-		params: {
-			comparison: "<",
-			limit: schema.exclusiveMaximum
-		}
+	return CheckExclusiveMaximum(stack, context, schema, value) || context.AddError("exclusiveMaximum", schemaPath, instancePath, {
+		comparison: "<",
+		limit: schema.exclusiveMaximum
 	});
 }
 function CheckExclusiveMinimum(_stack, _context, schema, value) {
 	return IsGreaterThan(value, schema.exclusiveMinimum);
 }
 function ErrorExclusiveMinimum(stack, context, schemaPath, instancePath, schema, value) {
-	return CheckExclusiveMinimum(stack, context, schema, value) || context.AddError({
-		keyword: "exclusiveMinimum",
-		schemaPath,
-		instancePath,
-		params: {
-			comparison: ">",
-			limit: schema.exclusiveMinimum
-		}
+	return CheckExclusiveMinimum(stack, context, schema, value) || context.AddError("exclusiveMinimum", schemaPath, instancePath, {
+		comparison: ">",
+		limit: schema.exclusiveMinimum
 	});
 }
 const DAYS = [
@@ -4702,15 +4914,12 @@ const MalformedScheme = /^[a-zA-Z][a-zA-Z0-9+\-.]*\/\//;
 function IsIriReference(value) {
 	return !InvalidIriChars$1.test(value) && !MalformedScheme.test(value) && URL.canParse(value, "http://example.com");
 }
-const IpvFutureMatchMaxLength = 2048;
-const IpvFutureMatch = /\[[vV][0-9a-fA-F]+\.[^\]]+\]/;
 const InvalidIriChars = /[\x00-\x20<>\^`{|}\\]/;
-function NarrowIpvFuture(value) {
-	return value.length < IpvFutureMatchMaxLength ? value.replace(IpvFutureMatch, "[::1]") : value;
-}
+const InvalidPercentEncoding = /%(?![0-9a-fA-F]{2})/;
 function IsIri(value) {
 	if (InvalidIriChars.test(value)) return false;
-	return URL.canParse(NarrowIpvFuture(value));
+	if (InvalidPercentEncoding.test(value)) return false;
+	return URL.canParse(value);
 }
 const JsonPointerUriFragment = /^#(?:\/(?:[a-z0-9_\-.!$&'()*+,;:=@]|%[0-9a-f]{2}|~0|~1)*)*$/i;
 function IsJsonPointerUriFragment(value) {
@@ -4787,12 +4996,7 @@ function CheckFormat(_stack, _context, schema, value) {
 	return Test(schema.format, value);
 }
 function ErrorFormat(stack, context, schemaPath, instancePath, schema, value) {
-	return CheckFormat(stack, context, schema, value) || context.AddError({
-		keyword: "format",
-		schemaPath,
-		instancePath,
-		params: { format: schema.format }
-	});
+	return CheckFormat(stack, context, schema, value) || context.AddError("format", schemaPath, instancePath, { format: schema.format });
 }
 function CheckIf(stack, context, schema, value) {
 	const thenSchema = IsThen(schema) ? schema.then : true;
@@ -4802,18 +5006,8 @@ function CheckIf(stack, context, schema, value) {
 function ErrorIf(stack, context, schemaPath, instancePath, schema, value) {
 	const thenSchema = IsThen(schema) ? schema.then : true;
 	const elseSchema = IsElse(schema) ? schema.else : true;
-	const trueContext = new AccumulatedErrorContext();
-	const isIf = ErrorSchema(stack, trueContext, `${schemaPath}/if`, instancePath, schema.if, value) ? ErrorSchema(stack, trueContext, `${schemaPath}/then`, instancePath, thenSchema, value) || context.AddError({
-		keyword: "if",
-		schemaPath,
-		instancePath,
-		params: { failingKeyword: "then" }
-	}) : ErrorSchema(stack, context, `${schemaPath}/else`, instancePath, elseSchema, value) || context.AddError({
-		keyword: "if",
-		schemaPath,
-		instancePath,
-		params: { failingKeyword: "else" }
-	});
+	const trueContext = new ErrorContext();
+	const isIf = ErrorSchema(stack, trueContext, `${schemaPath}/if`, instancePath, schema.if, value) ? ErrorSchema(stack, trueContext, `${schemaPath}/then`, instancePath, thenSchema, value) || context.AddError("if", schemaPath, instancePath, { failingKeyword: "then" }) : ErrorSchema(stack, context, `${schemaPath}/else`, instancePath, elseSchema, value) || context.AddError("if", schemaPath, instancePath, { failingKeyword: "else" });
 	if (isIf) context.Merge([trueContext]);
 	return isIf;
 }
@@ -4854,62 +5048,37 @@ function CheckMaxContains(stack, context, schema, value) {
 }
 function ErrorMaxContains(stack, context, schemaPath, instancePath, schema, value) {
 	const minContains = IsMinContains(schema) ? schema.minContains : 1;
-	return CheckMaxContains(stack, context, schema, value) || context.AddError({
-		keyword: "contains",
-		schemaPath,
-		instancePath,
-		params: {
-			minContains,
-			maxContains: schema.maxContains
-		}
+	return CheckMaxContains(stack, context, schema, value) || context.AddError("contains", schemaPath, instancePath, {
+		minContains,
+		maxContains: schema.maxContains
 	});
 }
 function CheckMaximum(_stack, _context, schema, value) {
 	return IsLessEqualThan(value, schema.maximum);
 }
 function ErrorMaximum(stack, context, schemaPath, instancePath, schema, value) {
-	return CheckMaximum(stack, context, schema, value) || context.AddError({
-		keyword: "maximum",
-		schemaPath,
-		instancePath,
-		params: {
-			comparison: "<=",
-			limit: schema.maximum
-		}
+	return CheckMaximum(stack, context, schema, value) || context.AddError("maximum", schemaPath, instancePath, {
+		comparison: "<=",
+		limit: schema.maximum
 	});
 }
 function CheckMaxItems(_stack, _context, schema, value) {
 	return IsLessEqualThan(value.length, schema.maxItems);
 }
 function ErrorMaxItems(stack, context, schemaPath, instancePath, schema, value) {
-	return CheckMaxItems(stack, context, schema, value) || context.AddError({
-		keyword: "maxItems",
-		schemaPath,
-		instancePath,
-		params: { limit: schema.maxItems }
-	});
+	return CheckMaxItems(stack, context, schema, value) || context.AddError("maxItems", schemaPath, instancePath, { limit: schema.maxItems });
 }
 function CheckMaxLength(_stack, _context, schema, value) {
 	return IsMaxLength$1(value, schema.maxLength);
 }
 function ErrorMaxLength(stack, context, schemaPath, instancePath, schema, value) {
-	return CheckMaxLength(stack, context, schema, value) || context.AddError({
-		keyword: "maxLength",
-		schemaPath,
-		instancePath,
-		params: { limit: schema.maxLength }
-	});
+	return CheckMaxLength(stack, context, schema, value) || context.AddError("maxLength", schemaPath, instancePath, { limit: schema.maxLength });
 }
 function CheckMaxProperties(_stack, _context, schema, value) {
 	return IsLessEqualThan(Keys(value).length, schema.maxProperties);
 }
 function ErrorMaxProperties(stack, context, schemaPath, instancePath, schema, value) {
-	return CheckMaxProperties(stack, context, schema, value) || context.AddError({
-		keyword: "maxProperties",
-		schemaPath,
-		instancePath,
-		params: { limit: schema.maxProperties }
-	});
+	return CheckMaxProperties(stack, context, schema, value) || context.AddError("maxProperties", schemaPath, instancePath, { limit: schema.maxProperties });
 }
 function IsValid$1(schema) {
 	return IsContains(schema);
@@ -4919,82 +5088,47 @@ function CheckMinContains(stack, context, schema, value) {
 	return IsGreaterEqualThan(Counted(value, (item, index) => CheckSchema(stack, context, schema.contains, item) && context.AddIndex(index)), schema.minContains);
 }
 function ErrorMinContains(stack, context, schemaPath, instancePath, schema, value) {
-	return CheckMinContains(stack, context, schema, value) || context.AddError({
-		keyword: "contains",
-		schemaPath,
-		instancePath,
-		params: { minContains: schema.minContains }
-	});
+	return CheckMinContains(stack, context, schema, value) || context.AddError("contains", schemaPath, instancePath, { minContains: schema.minContains });
 }
 function CheckMinimum(_stack, _context, schema, value) {
 	return IsGreaterEqualThan(value, schema.minimum);
 }
 function ErrorMinimum(stack, context, schemaPath, instancePath, schema, value) {
-	return CheckMinimum(stack, context, schema, value) || context.AddError({
-		keyword: "minimum",
-		schemaPath,
-		instancePath,
-		params: {
-			comparison: ">=",
-			limit: schema.minimum
-		}
+	return CheckMinimum(stack, context, schema, value) || context.AddError("minimum", schemaPath, instancePath, {
+		comparison: ">=",
+		limit: schema.minimum
 	});
 }
 function CheckMinItems(_stack, _context, schema, value) {
 	return IsGreaterEqualThan(value.length, schema.minItems);
 }
 function ErrorMinItems(stack, context, schemaPath, instancePath, schema, value) {
-	return CheckMinItems(stack, context, schema, value) || context.AddError({
-		keyword: "minItems",
-		schemaPath,
-		instancePath,
-		params: { limit: schema.minItems }
-	});
+	return CheckMinItems(stack, context, schema, value) || context.AddError("minItems", schemaPath, instancePath, { limit: schema.minItems });
 }
 function CheckMinLength(_stack, _context, schema, value) {
 	return IsMinLength$1(value, schema.minLength);
 }
 function ErrorMinLength(stack, context, schemaPath, instancePath, schema, value) {
-	return CheckMinLength(stack, context, schema, value) || context.AddError({
-		keyword: "minLength",
-		schemaPath,
-		instancePath,
-		params: { limit: schema.minLength }
-	});
+	return CheckMinLength(stack, context, schema, value) || context.AddError("minLength", schemaPath, instancePath, { limit: schema.minLength });
 }
 function CheckMinProperties(_stack, _context, schema, value) {
 	return IsGreaterEqualThan(Keys(value).length, schema.minProperties);
 }
 function ErrorMinProperties(stack, context, schemaPath, instancePath, schema, value) {
-	return CheckMinProperties(stack, context, schema, value) || context.AddError({
-		keyword: "minProperties",
-		schemaPath,
-		instancePath,
-		params: { limit: schema.minProperties }
-	});
+	return CheckMinProperties(stack, context, schema, value) || context.AddError("minProperties", schemaPath, instancePath, { limit: schema.minProperties });
 }
 function CheckMultipleOf(_stack, _context, schema, value) {
 	return IsMultipleOf$1(value, schema.multipleOf);
 }
 function ErrorMultipleOf(stack, context, schemaPath, instancePath, schema, value) {
-	return CheckMultipleOf(stack, context, schema, value) || context.AddError({
-		keyword: "multipleOf",
-		schemaPath,
-		instancePath,
-		params: { multipleOf: schema.multipleOf }
-	});
+	return CheckMultipleOf(stack, context, schema, value) || context.AddError("multipleOf", schemaPath, instancePath, { multipleOf: schema.multipleOf });
 }
 function CheckNot(stack, context, schema, value) {
 	const nextContext = new CheckContext();
 	return !CheckSchema(stack, nextContext, schema.not, value) && context.Merge([nextContext]);
 }
 function ErrorNot(stack, context, schemaPath, instancePath, schema, value) {
-	return CheckNot(stack, context, schema, value) || context.AddError({
-		keyword: "not",
-		schemaPath,
-		instancePath,
-		params: {}
-	});
+	return CheckNot(stack, context, schema, value) || context.AddError("not", schemaPath, instancePath, {});
 }
 function CheckOneOf(stack, context, schema, value) {
 	const passedContexts = schema.oneOf.reduce((result, schema) => {
@@ -5007,31 +5141,21 @@ function ErrorOneOf(stack, context, schemaPath, instancePath, schema, value) {
 	const failedContexts = [];
 	const passingSchemas = [];
 	const passedContexts = schema.oneOf.reduce((result, schema, index) => {
-		const nextContext = new AccumulatedErrorContext();
+		const nextContext = new ErrorContext();
 		const isSchema = ErrorSchema(stack, nextContext, `${schemaPath}/oneOf/${index}`, instancePath, schema, value);
 		if (isSchema) passingSchemas.push(index);
 		if (!isSchema) failedContexts.push(nextContext);
 		return isSchema ? [...result, nextContext] : result;
 	}, []);
 	const isOneOf = IsEqual(passedContexts.length, 1) && context.Merge(passedContexts);
-	if (!isOneOf && IsEqual(passingSchemas.length, 0)) failedContexts.forEach((failed) => failed.GetErrors().forEach((error) => context.AddError(error)));
-	return isOneOf || context.AddError({
-		keyword: "oneOf",
-		schemaPath,
-		instancePath,
-		params: { passingSchemas }
-	});
+	if (!isOneOf && IsEqual(passingSchemas.length, 0)) failedContexts.forEach((failed) => context.AddErrors(failed.GetErrors()));
+	return isOneOf || context.AddError("oneOf", schemaPath, instancePath, { passingSchemas });
 }
 function CheckPattern(_stack, _context, schema, value) {
 	return (IsString$2(schema.pattern) ? UnicodeRegExp(schema.pattern) : schema.pattern).test(value);
 }
 function ErrorPattern(stack, context, schemaPath, instancePath, schema, value) {
-	return CheckPattern(stack, context, schema, value) || context.AddError({
-		keyword: "pattern",
-		schemaPath,
-		instancePath,
-		params: { pattern: schema.pattern }
-	});
+	return CheckPattern(stack, context, schema, value) || context.AddError("pattern", schemaPath, instancePath, { pattern: schema.pattern });
 }
 function CheckPatternProperties(stack, context, schema, value) {
 	return Every(Entries(schema.patternProperties), 0, ([pattern, schema]) => {
@@ -5092,39 +5216,43 @@ function ErrorPropertyNames(stack, context, schemaPath, instancePath, schema, va
 	const propertyNames = [];
 	return EveryAll(Keys(value), 0, (key, _index) => {
 		const nextInstancePath = `${instancePath}/${key}`;
-		const nextSchemaPath = `${schemaPath}/propertyNames`;
-		const isPropertyName = ErrorSchema(stack, new AccumulatedErrorContext(), nextSchemaPath, nextInstancePath, schema.propertyNames, key);
+		const isPropertyName = ErrorSchema(stack, context, `${schemaPath}/propertyNames`, nextInstancePath, schema.propertyNames, key);
 		if (!isPropertyName) propertyNames.push(key);
 		return isPropertyName;
-	}) || context.AddError({
-		keyword: "propertyNames",
-		schemaPath,
-		instancePath,
-		params: { propertyNames }
-	});
+	}) || context.AddError("propertyNames", schemaPath, instancePath, { propertyNames });
 }
 function CheckRecursiveRef(stack, context, schema, value) {
-	const target = stack.RecursiveRef(schema) ?? false;
-	return IsSchema(target) && CheckSchema(stack, context, target, value);
-}
-function ErrorRecursiveRef(stack, context, _schemaPath, instancePath, schema, value) {
-	const target = stack.RecursiveRef(schema) ?? false;
-	return IsSchema(target) && ErrorSchema(stack, context, "#", instancePath, target, value);
+	const target = RecursiveRef(stack, schema) ?? false;
+	const nextStack = target ? {
+		...stack,
+		pendingResource: true
+	} : stack;
+	return IsSchema(target) && CheckSchema(nextStack, context, target, value);
+}
+function ErrorRecursiveRef(stack, context, schemaPath, instancePath, schema, value) {
+	const target = RecursiveRef(stack, schema) ?? false;
+	const nextStack = target ? {
+		...stack,
+		pendingResource: true
+	} : stack;
+	return IsSchema(target) && ErrorSchema(nextStack, context, schemaPath, instancePath, target, value);
 }
 function CheckRef(stack, context, schema, value) {
-	const target = stack.Ref(schema) ?? false;
+	const result = Ref(stack, schema);
+	const target = result.schema ?? false;
 	const nextContext = new CheckContext();
-	const result = IsSchema(target) && CheckSchema(stack, nextContext, target, value);
-	if (result) context.Merge([nextContext]);
-	return result;
-}
-function ErrorRef(stack, context, _schemaPath, instancePath, schema, value) {
-	const target = stack.Ref(schema) ?? false;
-	const nextContext = new AccumulatedErrorContext();
-	const result = IsSchema(target) && ErrorSchema(stack, nextContext, "#", instancePath, target, value);
-	if (result) context.Merge([nextContext]);
-	if (!result) nextContext.GetErrors().forEach((error) => context.AddError(error));
-	return result;
+	const valid = IsSchema(target) && CheckSchema(result.stack, nextContext, target, value);
+	if (valid) context.Merge([nextContext]);
+	return valid;
+}
+function ErrorRef(stack, context, schemaPath, instancePath, schema, value) {
+	const result = Ref(stack, schema);
+	const target = result.schema ?? false;
+	const nextContext = new ErrorContext();
+	const valid = IsSchema(target) && ErrorSchema(result.stack, nextContext, schemaPath, instancePath, target, value);
+	if (valid) context.Merge([nextContext]);
+	if (!valid) context.AddErrors(nextContext.GetErrors());
+	return valid;
 }
 function CheckRequired(_stack, _context, schema, value) {
 	return Every(schema.required, 0, (key) => HasPropertyKey(value, key));
@@ -5135,12 +5263,7 @@ function ErrorRequired(_stack, context, schemaPath, instancePath, schema, value)
 		const hasKey = HasPropertyKey(value, key);
 		if (!hasKey) requiredProperties.push(key);
 		return hasKey;
-	}) || context.AddError({
-		keyword: "required",
-		schemaPath,
-		instancePath,
-		params: { requiredProperties }
-	});
+	}) || context.AddError("required", schemaPath, instancePath, { requiredProperties });
 }
 function CheckTypeName(_stack, _context, type, _schema, value) {
 	return IsEqual(type, "object") ? IsObjectNotArray(value) : IsEqual(type, "array") ? IsArray$1(value) : IsEqual(type, "boolean") ? IsBoolean$2(value) : IsEqual(type, "integer") ? IsInteger$1(value) : IsEqual(type, "number") ? IsNumber$2(value) : IsEqual(type, "null") ? IsNull$1(value) : IsEqual(type, "string") ? IsString$2(value) : IsEqual(type, "bigint") ? IsBigInt$1(value) : IsEqual(type, "constructor") ? IsConstructor$1(value) : IsEqual(type, "function") ? IsFunction$1(value) : IsEqual(type, "symbol") ? IsSymbol$1(value) : IsEqual(type, "undefined") ? IsUndefined$1(value) : IsEqual(type, "void") ? IsUndefined$1(value) : true;
@@ -5152,12 +5275,7 @@ function CheckType(stack, context, schema, value) {
 	return IsArray$1(schema.type) ? CheckTypeNames(stack, context, schema.type, schema, value) : CheckTypeName(stack, context, schema.type, schema, value);
 }
 function ErrorType(stack, context, schemaPath, instancePath, schema, value) {
-	return (IsArray$1(schema.type) ? CheckTypeNames(stack, context, schema.type, schema, value) : CheckTypeName(stack, context, schema.type, schema, value)) || context.AddError({
-		keyword: "type",
-		schemaPath,
-		instancePath,
-		params: { type: schema.type }
-	});
+	return (IsArray$1(schema.type) ? CheckTypeNames(stack, context, schema.type, schema, value) : CheckTypeName(stack, context, schema.type, schema, value)) || context.AddError("type", schemaPath, instancePath, { type: schema.type });
 }
 function CheckUnevaluatedItems(stack, context, schema, value) {
 	const indices = context.GetIndices();
@@ -5169,16 +5287,11 @@ function ErrorUnevaluatedItems(stack, context, schemaPath, instancePath, schema,
 	const indices = context.GetIndices();
 	const unevaluatedItems = [];
 	return EveryAll(value, 0, (item, index) => {
-		const nextContext = new AccumulatedErrorContext();
+		const nextContext = new ErrorContext();
 		const isEvaluatedItem = (indices.has(index) || ErrorSchema(stack, nextContext, schemaPath, instancePath, schema.unevaluatedItems, item)) && context.AddIndex(index);
 		if (!isEvaluatedItem) unevaluatedItems.push(index);
 		return isEvaluatedItem;
-	}) || context.AddError({
-		keyword: "unevaluatedItems",
-		schemaPath,
-		instancePath,
-		params: { unevaluatedItems }
-	});
+	}) || context.AddError("unevaluatedItems", schemaPath, instancePath, { unevaluatedItems });
 }
 function CheckUnevaluatedProperties(stack, context, schema, value) {
 	const keys = context.GetKeys();
@@ -5190,16 +5303,11 @@ function ErrorUnevaluatedProperties(stack, context, schemaPath, instancePath, sc
 	const keys = context.GetKeys();
 	const unevaluatedProperties = [];
 	return EveryAll(Entries(value), 0, ([key, prop]) => {
-		const nextContext = new AccumulatedErrorContext();
+		const nextContext = new ErrorContext();
 		const isEvaluatedProperty = keys.has(key) || ErrorSchema(stack, nextContext, schemaPath, instancePath, schema.unevaluatedProperties, prop) && context.AddKey(key);
 		if (!isEvaluatedProperty) unevaluatedProperties.push(key);
 		return isEvaluatedProperty;
-	}) || context.AddError({
-		keyword: "unevaluatedProperties",
-		schemaPath,
-		instancePath,
-		params: { unevaluatedProperties }
-	});
+	}) || context.AddError("unevaluatedProperties", schemaPath, instancePath, { unevaluatedProperties });
 }
 function IsValid(schema) {
 	return !IsEqual(schema.uniqueItems, false);
@@ -5219,206 +5327,23 @@ function ErrorUniqueItems(_stack, context, schemaPath, instancePath, schema, val
 		set.add(hash);
 		return result;
 	}, []);
-	return IsEqual(duplicateItems.length, 0) || context.AddError({
-		keyword: "uniqueItems",
-		schemaPath,
-		instancePath,
-		params: { duplicateItems }
-	});
+	return IsEqual(duplicateItems.length, 0) || context.AddError("uniqueItems", schemaPath, instancePath, { duplicateItems });
 }
 function CheckSchemaPushStack(stack, context, schema, value) {
 	return context.Push() && CheckSchema(stack, context, schema, value) && context.Pop();
 }
 function CheckSchema(stack, context, schema, value) {
-	stack.Push(schema);
-	const result = IsSchemaBoolean(schema) ? CheckSchemaBoolean(stack, context, schema, value) : (!IsType(schema) || CheckType(stack, context, schema, value)) && (!(IsObject$1(value) && !IsArray$1(value)) || (!IsRequired(schema) || CheckRequired(stack, context, schema, value)) && (!IsAdditionalProperties(schema) || CheckAdditionalProperties(stack, context, schema, value)) && (!IsDependencies(schema) || CheckDependencies(stack, context, schema, value)) && (!IsDependentRequired(schema) || CheckDependentRequired(stack, context, schema, value)) && (!IsDependentSchemas(schema) || CheckDependentSchemas(stack, context, schema, value)) && (!IsPatternProperties(schema) || CheckPatternProperties(stack, context, schema, value)) && (!IsProperties(schema) || CheckProperties(stack, context, schema, value)) && (!IsPropertyNames(schema) || CheckPropertyNames(stack, context, schema, value)) && (!IsMinProperties(schema) || CheckMinProperties(stack, context, schema, value)) && (!IsMaxProperties(schema) || CheckMaxProperties(stack, context, schema, value))) && (!IsArray$1(value) || (!IsAdditionalItems(schema) || CheckAdditionalItems(stack, context, schema, value)) && (!IsContains(schema) || CheckContains(stack, context, schema, value)) && (!IsItems(schema) || CheckItems(stack, context, schema, value)) && (!IsMaxContains(schema) || CheckMaxContains(stack, context, schema, value)) && (!IsMaxItems(schema) || CheckMaxItems(stack, context, schema, value)) && (!IsMinContains(schema) || CheckMinContains(stack, context, schema, value)) && (!IsMinItems(schema) || CheckMinItems(stack, context, schema, value)) && (!IsPrefixItems(schema) || CheckPrefixItems(stack, context, schema, value)) && (!IsUniqueItems(schema) || CheckUniqueItems(stack, context, schema, value))) && (!IsString$2(value) || (!IsMaxLength(schema) || CheckMaxLength(stack, context, schema, value)) && (!IsMinLength(schema) || CheckMinLength(stack, context, schema, value)) && (!IsFormat(schema) || CheckFormat(stack, context, schema, value)) && (!IsPattern(schema) || CheckPattern(stack, context, schema, value))) && (!(IsNumber$2(value) || IsBigInt$1(value)) || (!IsExclusiveMaximum(schema) || CheckExclusiveMaximum(stack, context, schema, value)) && (!IsExclusiveMinimum(schema) || CheckExclusiveMinimum(stack, context, schema, value)) && (!IsMaximum(schema) || CheckMaximum(stack, context, schema, value)) && (!IsMinimum(schema) || CheckMinimum(stack, context, schema, value)) && (!IsMultipleOf(schema) || CheckMultipleOf(stack, context, schema, value))) && (!IsRef(schema) || CheckRef(stack, context, schema, value)) && (!IsRecursiveRef(schema) || CheckRecursiveRef(stack, context, schema, value)) && (!IsDynamicRef(schema) || CheckDynamicRef(stack, context, schema, value)) && (!IsConst(schema) || CheckConst(stack, context, schema, value)) && (!IsEnum(schema) || CheckEnum(stack, context, schema, value)) && (!IsIf(schema) || CheckIf(stack, context, schema, value)) && (!IsNot(schema) || CheckNot(stack, context, schema, value)) && (!IsAllOf(schema) || CheckAllOf(stack, context, schema, value)) && (!IsAnyOf(schema) || CheckAnyOf(stack, context, schema, value)) && (!IsOneOf(schema) || CheckOneOf(stack, context, schema, value)) && (!IsUnevaluatedItems(schema) || !IsArray$1(value) || CheckUnevaluatedItems(stack, context, schema, value)) && (!IsUnevaluatedProperties(schema) || !IsObject$1(value) || CheckUnevaluatedProperties(stack, context, schema, value)) && (!IsRefine(schema) || CheckRefine(stack, context, schema, value));
-	stack.Pop(schema);
-	return result;
+	const current = NextStack(stack, schema);
+	return IsSchemaBoolean(schema) ? CheckSchemaBoolean(current, context, schema, value) : (!IsType(schema) || CheckType(current, context, schema, value)) && (!(IsObject$1(value) && !IsArray$1(value)) || (!IsRequired(schema) || CheckRequired(current, context, schema, value)) && (!IsAdditionalProperties(schema) || CheckAdditionalProperties(current, context, schema, value)) && (!IsDependencies(schema) || CheckDependencies(current, context, schema, value)) && (!IsDependentRequired(schema) || CheckDependentRequired(current, context, schema, value)) && (!IsDependentSchemas(schema) || CheckDependentSchemas(current, context, schema, value)) && (!IsPatternProperties(schema) || CheckPatternProperties(current, context, schema, value)) && (!IsProperties(schema) || CheckProperties(current, context, schema, value)) && (!IsPropertyNames(schema) || CheckPropertyNames(current, context, schema, value)) && (!IsMinProperties(schema) || CheckMinProperties(current, context, schema, value)) && (!IsMaxProperties(schema) || CheckMaxProperties(current, context, schema, value))) && (!IsArray$1(value) || (!IsAdditionalItems(schema) || CheckAdditionalItems(current, context, schema, value)) && (!IsContains(schema) || CheckContains(current, context, schema, value)) && (!IsItems(schema) || CheckItems(current, context, schema, value)) && (!IsMinContains(schema) || CheckMinContains(current, context, schema, value)) && (!IsMaxContains(schema) || CheckMaxContains(current, context, schema, value)) && (!IsMinItems(schema) || CheckMinItems(current, context, schema, value)) && (!IsMaxItems(schema) || CheckMaxItems(current, context, schema, value)) && (!IsPrefixItems(schema) || CheckPrefixItems(current, context, schema, value)) && (!IsUniqueItems(schema) || CheckUniqueItems(current, context, schema, value))) && (!IsString$2(value) || (!IsMinLength(schema) || CheckMinLength(current, context, schema, value)) && (!IsMaxLength(schema) || CheckMaxLength(current, context, schema, value)) && (!IsFormat(schema) || CheckFormat(current, context, schema, value)) && (!IsPattern(schema) || CheckPattern(current, context, schema, value))) && (!(IsNumber$2(value) || IsBigInt$1(value)) || (!IsExclusiveMinimum(schema) || CheckExclusiveMinimum(current, context, schema, value)) && (!IsExclusiveMaximum(schema) || CheckExclusiveMaximum(current, context, schema, value)) && (!IsMinimum(schema) || CheckMinimum(current, context, schema, value)) && (!IsMaximum(schema) || CheckMaximum(current, context, schema, value)) && (!IsMultipleOf(schema) || CheckMultipleOf(current, context, schema, value))) && (!IsRef(schema) || CheckRef(current, context, schema, value)) && (!IsRecursiveRef(schema) || CheckRecursiveRef(current, context, schema, value)) && (!IsDynamicRef(schema) || CheckDynamicRef(current, context, schema, value)) && (!IsConst(schema) || CheckConst(current, context, schema, value)) && (!IsEnum(schema) || CheckEnum(current, context, schema, value)) && (!IsIf(schema) || CheckIf(current, context, schema, value)) && (!IsNot(schema) || CheckNot(current, context, schema, value)) && (!IsAllOf(schema) || CheckAllOf(current, context, schema, value)) && (!IsAnyOf(schema) || CheckAnyOf(current, context, schema, value)) && (!IsOneOf(schema) || CheckOneOf(current, context, schema, value)) && (!IsUnevaluatedItems(schema) || !IsArray$1(value) || CheckUnevaluatedItems(current, context, schema, value)) && (!IsUnevaluatedProperties(schema) || !IsObject$1(value) || CheckUnevaluatedProperties(current, context, schema, value)) && (!IsRefine(schema) || CheckRefine(current, context, schema, value));
 }
 function ErrorSchemaPushStack(stack, context, schemaPath, instancePath, schema, value) {
 	return context.Push() && ErrorSchema(stack, context, schemaPath, instancePath, schema, value) && context.Pop();
 }
 function ErrorSchema(stack, context, schemaPath, instancePath, schema, value) {
-	stack.Push(schema);
-	const result = IsSchemaBoolean(schema) ? ErrorSchemaBoolean(stack, context, schemaPath, instancePath, schema, value) : !!(+(!IsType(schema) || ErrorType(stack, context, schemaPath, instancePath, schema, value)) & +(!(IsObject$1(value) && !IsArray$1(value)) || !!(+(!IsRequired(schema) || ErrorRequired(stack, context, schemaPath, instancePath, schema, value)) & +(!IsAdditionalProperties(schema) || ErrorAdditionalProperties(stack, context, schemaPath, instancePath, schema, value)) & +(!IsDependencies(schema) || ErrorDependencies(stack, context, schemaPath, instancePath, schema, value)) & +(!IsDependentRequired(schema) || ErrorDependentRequired(stack, context, schemaPath, instancePath, schema, value)) & +(!IsDependentSchemas(schema) || ErrorDependentSchemas(stack, context, schemaPath, instancePath, schema, value)) & +(!IsPatternProperties(schema) || ErrorPatternProperties(stack, context, schemaPath, instancePath, schema, value)) & +(!IsProperties(schema) || ErrorProperties(stack, context, schemaPath, instancePath, schema, value)) & +(!IsPropertyNames(schema) || ErrorPropertyNames(stack, context, schemaPath, instancePath, schema, value)) & +(!IsMinProperties(schema) || ErrorMinProperties(stack, context, schemaPath, instancePath, schema, value)) & +(!IsMaxProperties(schema) || ErrorMaxProperties(stack, context, schemaPath, instancePath, schema, value)))) & +(!IsArray$1(value) || !!(+(!IsAdditionalItems(schema) || ErrorAdditionalItems(stack, context, schemaPath, instancePath, schema, value)) & +(!IsContains(schema) || ErrorContains(stack, context, schemaPath, instancePath, schema, value)) & +(!IsItems(schema) || ErrorItems(stack, context, schemaPath, instancePath, schema, value)) & +(!IsMaxContains(schema) || ErrorMaxContains(stack, context, schemaPath, instancePath, schema, value)) & +(!IsMaxItems(schema) || ErrorMaxItems(stack, context, schemaPath, instancePath, schema, value)) & +(!IsMinContains(schema) || ErrorMinContains(stack, context, schemaPath, instancePath, schema, value)) & +(!IsMinItems(schema) || ErrorMinItems(stack, context, schemaPath, instancePath, schema, value)) & +(!IsPrefixItems(schema) || ErrorPrefixItems(stack, context, schemaPath, instancePath, schema, value)) & +(!IsUniqueItems(schema) || ErrorUniqueItems(stack, context, schemaPath, instancePath, schema, value)))) & +(!IsString$2(value) || !!(+(!IsMaxLength(schema) || ErrorMaxLength(stack, context, schemaPath, instancePath, schema, value)) & +(!IsMinLength(schema) || ErrorMinLength(stack, context, schemaPath, instancePath, schema, value)) & +(!IsFormat(schema) || ErrorFormat(stack, context, schemaPath, instancePath, schema, value)) & +(!IsPattern(schema) || ErrorPattern(stack, context, schemaPath, instancePath, schema, value)))) & +(!(IsNumber$2(value) || IsBigInt$1(value)) || !!(+(!IsExclusiveMaximum(schema) || ErrorExclusiveMaximum(stack, context, schemaPath, instancePath, schema, value)) & +(!IsExclusiveMinimum(schema) || ErrorExclusiveMinimum(stack, context, schemaPath, instancePath, schema, value)) & +(!IsMaximum(schema) || ErrorMaximum(stack, context, schemaPath, instancePath, schema, value)) & +(!IsMinimum(schema) || ErrorMinimum(stack, context, schemaPath, instancePath, schema, value)) & +(!IsMultipleOf(schema) || ErrorMultipleOf(stack, context, schemaPath, instancePath, schema, value)))) & +(!IsRef(schema) || ErrorRef(stack, context, schemaPath, instancePath, schema, value)) & +(!IsRecursiveRef(schema) || ErrorRecursiveRef(stack, context, schemaPath, instancePath, schema, value)) & +(!IsDynamicRef(schema) || ErrorDynamicRef(stack, context, schemaPath, instancePath, schema, value)) & +(!IsConst(schema) || ErrorConst(stack, context, schemaPath, instancePath, schema, value)) & +(!IsEnum(schema) || ErrorEnum(stack, context, schemaPath, instancePath, schema, value)) & +(!IsIf(schema) || ErrorIf(stack, context, schemaPath, instancePath, schema, value)) & +(!IsNot(schema) || ErrorNot(stack, context, schemaPath, instancePath, schema, value)) & +(!IsAllOf(schema) || ErrorAllOf(stack, context, schemaPath, instancePath, schema, value)) & +(!IsAnyOf(schema) || ErrorAnyOf(stack, context, schemaPath, instancePath, schema, value)) & +(!IsOneOf(schema) || ErrorOneOf(stack, context, schemaPath, instancePath, schema, value)) & +(!IsUnevaluatedItems(schema) || !IsArray$1(value) || ErrorUnevaluatedItems(stack, context, schemaPath, instancePath, schema, value)) & +(!IsUnevaluatedProperties(schema) || !IsObject$1(value) || ErrorUnevaluatedProperties(stack, context, schemaPath, instancePath, schema, value))) && (!IsRefine(schema) || ErrorRefine(stack, context, schemaPath, instancePath, schema, value));
-	stack.Pop(schema);
-	return result;
+	if (context.AtCapacity()) return false;
+	const current = NextStack(stack, schema);
+	return IsSchemaBoolean(schema) ? ErrorSchemaBoolean(current, context, schemaPath, instancePath, schema, value) : !!(+(!IsType(schema) || ErrorType(current, context, schemaPath, instancePath, schema, value)) & +(!(IsObject$1(value) && !IsArray$1(value)) || !!(+(!IsRequired(schema) || ErrorRequired(current, context, schemaPath, instancePath, schema, value)) & +(!IsAdditionalProperties(schema) || ErrorAdditionalProperties(current, context, schemaPath, instancePath, schema, value)) & +(!IsDependencies(schema) || ErrorDependencies(current, context, schemaPath, instancePath, schema, value)) & +(!IsDependentRequired(schema) || ErrorDependentRequired(current, context, schemaPath, instancePath, schema, value)) & +(!IsDependentSchemas(schema) || ErrorDependentSchemas(current, context, schemaPath, instancePath, schema, value)) & +(!IsPatternProperties(schema) || ErrorPatternProperties(current, context, schemaPath, instancePath, schema, value)) & +(!IsProperties(schema) || ErrorProperties(current, context, schemaPath, instancePath, schema, value)) & +(!IsPropertyNames(schema) || ErrorPropertyNames(current, context, schemaPath, instancePath, schema, value)) & +(!IsMinProperties(schema) || ErrorMinProperties(current, context, schemaPath, instancePath, schema, value)) & +(!IsMaxProperties(schema) || ErrorMaxProperties(current, context, schemaPath, instancePath, schema, value)))) & +(!IsArray$1(value) || !!(+(!IsAdditionalItems(schema) || ErrorAdditionalItems(current, context, schemaPath, instancePath, schema, value)) & +(!IsContains(schema) || ErrorContains(current, context, schemaPath, instancePath, schema, value)) & +(!IsItems(schema) || ErrorItems(current, context, schemaPath, instancePath, schema, value)) & +(!IsMinContains(schema) || ErrorMinContains(current, context, schemaPath, instancePath, schema, value)) & +(!IsMaxContains(schema) || ErrorMaxContains(current, context, schemaPath, instancePath, schema, value)) & +(!IsMinItems(schema) || ErrorMinItems(current, context, schemaPath, instancePath, schema, value)) & +(!IsMaxItems(schema) || ErrorMaxItems(current, context, schemaPath, instancePath, schema, value)) & +(!IsPrefixItems(schema) || ErrorPrefixItems(current, context, schemaPath, instancePath, schema, value)) & +(!IsUniqueItems(schema) || ErrorUniqueItems(current, context, schemaPath, instancePath, schema, value)))) & +(!IsString$2(value) || !!(+(!IsMinLength(schema) || ErrorMinLength(current, context, schemaPath, instancePath, schema, value)) & +(!IsMaxLength(schema) || ErrorMaxLength(current, context, schemaPath, instancePath, schema, value)) & +(!IsFormat(schema) || ErrorFormat(current, context, schemaPath, instancePath, schema, value)) & +(!IsPattern(schema) || ErrorPattern(current, context, schemaPath, instancePath, schema, value)))) & +(!(IsNumber$2(value) || IsBigInt$1(value)) || !!(+(!IsExclusiveMinimum(schema) || ErrorExclusiveMinimum(current, context, schemaPath, instancePath, schema, value)) & +(!IsExclusiveMaximum(schema) || ErrorExclusiveMaximum(current, context, schemaPath, instancePath, schema, value)) & +(!IsMinimum(schema) || ErrorMinimum(current, context, schemaPath, instancePath, schema, value)) & +(!IsMaximum(schema) || ErrorMaximum(current, context, schemaPath, instancePath, schema, value)) & +(!IsMultipleOf(schema) || ErrorMultipleOf(current, context, schemaPath, instancePath, schema, value)))) & +(!IsRef(schema) || ErrorRef(current, context, schemaPath, instancePath, schema, value)) & +(!IsRecursiveRef(schema) || ErrorRecursiveRef(current, context, schemaPath, instancePath, schema, value)) & +(!IsDynamicRef(schema) || ErrorDynamicRef(current, context, schemaPath, instancePath, schema, value)) & +(!IsConst(schema) || ErrorConst(current, context, schemaPath, instancePath, schema, value)) & +(!IsEnum(schema) || ErrorEnum(current, context, schemaPath, instancePath, schema, value)) & +(!IsIf(schema) || ErrorIf(current, context, schemaPath, instancePath, schema, value)) & +(!IsNot(schema) || ErrorNot(current, context, schemaPath, instancePath, schema, value)) & +(!IsAllOf(schema) || ErrorAllOf(current, context, schemaPath, instancePath, schema, value)) & +(!IsAnyOf(schema) || ErrorAnyOf(current, context, schemaPath, instancePath, schema, value)) & +(!IsOneOf(schema) || ErrorOneOf(current, context, schemaPath, instancePath, schema, value)) & +(!IsUnevaluatedItems(schema) || !IsArray$1(value) || ErrorUnevaluatedItems(current, context, schemaPath, instancePath, schema, value)) & +(!IsUnevaluatedProperties(schema) || !IsObject$1(value) || ErrorUnevaluatedProperties(current, context, schemaPath, instancePath, schema, value))) && (!IsRefine(schema) || ErrorRefine(current, context, schemaPath, instancePath, schema, value));
 }
-function GetIndex(index, value) {
-	return IsObject$1(value) && !IsUnsafePropertyKey(index) ? value[index] : void 0;
-}
-function GetIndices(indices, value) {
-	return indices.reduce((value, index) => GetIndex(index, value), value);
-}
-function Indices(pointer) {
-	if (IsEqual(pointer.length, 0)) return [];
-	const indices = pointer.split("/").map((index) => index.replace(/~1/g, "/").replace(/~0/g, "~"));
-	return indices.length > 0 && indices[0] === "" ? indices.slice(1) : indices;
-}
-function Get(value, pointer) {
-	return GetIndices(Indices(pointer), value);
-}
-const DefaultBase = new URL("https://json-schema.org");
-function MatchId(schema, base, ref) {
-	if (schema.$id === ref.hash) return schema;
-	const absoluteId = new URL(schema.$id, base.href);
-	const absoluteRef = new URL(ref.href, base.href);
-	if (IsEqual(absoluteId.pathname, absoluteRef.pathname)) return ref.hash.startsWith("#") ? MatchHash(schema, base, ref) : schema;
-}
-function MatchAnchor(schema, base, ref) {
-	const absoluteAnchor = new URL(`#${schema.$anchor}`, base.href);
-	const absoluteRef = new URL(ref.href, base.href);
-	return IsEqual(absoluteAnchor.href, absoluteRef.href) ? schema : void 0;
-}
-function MatchDynamicAnchor(schema, base, ref) {
-	const absoluteAnchor = new URL(`#${schema.$dynamicAnchor}`, base.href);
-	const absoluteRef = new URL(ref.href, base.href);
-	return IsEqual(absoluteAnchor.href, absoluteRef.href) ? schema : void 0;
-}
-function MatchHash(schema, _base, ref) {
-	if (ref.href.endsWith("#")) return schema;
-	if (!ref.hash.startsWith("#")) return void 0;
-	const fragment = decodeURIComponent(ref.hash.slice(1));
-	if (!fragment.startsWith("/")) return void 0;
-	return Get(schema, fragment);
-}
-function Match(schema, base, ref) {
-	if (IsId(schema)) {
-		const result = MatchId(schema, base, ref);
-		if (!IsUndefined$1(result)) return result;
-	}
-	if (IsAnchor(schema)) {
-		const result = MatchAnchor(schema, base, ref);
-		if (!IsUndefined$1(result)) return result;
-	}
-	if (IsDynamicAnchor(schema)) {
-		const result = MatchDynamicAnchor(schema, base, ref);
-		if (!IsUndefined$1(result)) return result;
-	}
-	return MatchHash(schema, base, ref);
-}
-function FromArray$4(schema, base, ref) {
-	return schema.reduce((result, item) => {
-		const match = FromValue(item, base, ref);
-		return !IsUndefined$1(match) ? match : result;
-	}, void 0);
-}
-function SkipProperty(key) {
-	return IsEqual(key, "const") || IsEqual(key, "enum");
-}
-function FromObject$4(schema, base, ref) {
-	return Keys(schema).reduce((result, key) => {
-		if (SkipProperty(key)) return result;
-		const match = FromValue(schema[key], base, ref);
-		return !IsUndefined$1(match) ? match : result;
-	}, void 0);
-}
-function FromValue(schema, base, ref) {
-	const nextBase = IsSchemaObject(schema) && IsId(schema) ? new URL(schema.$id, base.href) : base;
-	if (IsSchemaObject(schema)) {
-		const result = Match(schema, nextBase, ref);
-		if (!IsUndefined$1(result)) return result;
-	}
-	if (IsArray$1(schema)) return FromArray$4(schema, nextBase, ref);
-	if (IsObject$1(schema)) return FromObject$4(schema, nextBase, ref);
-}
-function CanonicalHref(url) {
-	return url.href.split("#")[0];
-}
-function RefContext(context, ref) {
-	return HasPropertyKey(context, ref) ? context[ref] : void 0;
-}
-function RefLocal(schema, base, ref) {
-	return FromValue(schema, base, ref);
-}
-function RefRemote(context, base, ref) {
-	const targetDocumentHref = CanonicalHref(ref);
-	if (IsEqual(targetDocumentHref, CanonicalHref(base))) return void 0;
-	if (!HasPropertyKey(context, targetDocumentHref)) return void 0;
-	const remoteSchema = context[targetDocumentHref];
-	return FromValue(remoteSchema, IsSchemaObject(remoteSchema) && IsId(remoteSchema) ? new URL(remoteSchema.$id, DefaultBase.href) : new URL(targetDocumentHref), ref);
-}
-function Ref(context, schema, ref) {
-	const initialBase = IsId(schema) ? new URL(schema.$id, DefaultBase.href) : DefaultBase;
-	const initialRef = new URL(ref, initialBase.href);
-	return RefContext(context, ref) ?? RefLocal(schema, initialBase, initialRef) ?? RefRemote(context, initialBase, initialRef);
-}
-function DynamicRef(context, root, base, dynamicRef, dynamicAnchors) {
-	const fragmentTarget = dynamicRef.$dynamicRef.startsWith("#") ? Ref(context, base, dynamicRef.$dynamicRef) : Ref(context, root, dynamicRef.$dynamicRef);
-	if (IsUndefined$1(fragmentTarget)) return void 0;
-	if (!IsSchemaObject(fragmentTarget) || !IsDynamicAnchor(fragmentTarget)) return fragmentTarget;
-	if (new URL(dynamicRef.$dynamicRef, DefaultBase).hash.startsWith("#/")) return fragmentTarget;
-	return dynamicAnchors.find((anchor) => anchor.$dynamicAnchor === fragmentTarget.$dynamicAnchor) ?? fragmentTarget;
-}
-var __classPrivateFieldGet = function(receiver, state, kind, f) {
-	if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-	if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-	return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _Stack_instances;
-var _Stack_PushResourceAnchors;
-var _Stack_PopResourceAnchors;
-var Stack = class {
-	constructor(context, schema) {
-		_Stack_instances.add(this);
-		this.context = context;
-		this.schema = schema;
-		this.ids = [];
-		this.anchors = [];
-		this.recursiveAnchors = [];
-		this.dynamicAnchors = [];
-	}
-	BaseURL() {
-		return this.ids.reduce((result, schema) => new URL(schema.$id, result), DefaultBase);
-	}
-	Base() {
-		return this.ids[this.ids.length - 1] ?? this.schema;
-	}
-	Push(schema) {
-		if (!IsSchemaObject(schema)) return;
-		if (IsId(schema)) {
-			this.ids.push(schema);
-			__classPrivateFieldGet(this, _Stack_instances, "m", _Stack_PushResourceAnchors).call(this, schema);
-		}
-		if (IsAnchor(schema)) this.anchors.push(schema);
-		if (IsRecursiveAnchorTrue(schema)) this.recursiveAnchors.push(schema);
-		if (IsDynamicAnchor(schema)) this.dynamicAnchors.push(schema);
-	}
-	Pop(schema) {
-		if (!IsSchemaObject(schema)) return;
-		if (IsId(schema)) {
-			this.ids.pop();
-			__classPrivateFieldGet(this, _Stack_instances, "m", _Stack_PopResourceAnchors).call(this, schema);
-		}
-		if (IsAnchor(schema)) this.anchors.pop();
-		if (IsRecursiveAnchorTrue(schema)) this.recursiveAnchors.pop();
-		if (IsDynamicAnchor(schema)) this.dynamicAnchors.pop();
-	}
-	Ref(ref) {
-		const root = this.schema;
-		return !ref.$ref.startsWith("#") ? Ref(this.context, root, ref.$ref) : Ref(this.context, this.Base(), ref.$ref);
-	}
-	RecursiveRef(recursiveRef) {
-		return IsRecursiveAnchorTrue(this.Base()) ? Ref(this.context, this.recursiveAnchors[0], recursiveRef.$recursiveRef) : Ref(this.context, this.Base(), recursiveRef.$recursiveRef);
-	}
-	DynamicRef(dynamicRef) {
-		const root = this.schema;
-		return DynamicRef(this.context, root, this.Base(), dynamicRef, this.dynamicAnchors);
-	}
-};
-_Stack_instances = /* @__PURE__ */ new WeakSet(), _Stack_PushResourceAnchors = function _Stack_PushResourceAnchors(schema, isRoot = true) {
-	if (!IsSchemaObject(schema)) return;
-	const current = schema;
-	if (!isRoot && IsId(current)) return;
-	if (!isRoot && IsDynamicAnchor(current)) this.dynamicAnchors.push(current);
-	for (const key of Keys(current)) __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_PushResourceAnchors).call(this, current[key], false);
-}, _Stack_PopResourceAnchors = function _Stack_PopResourceAnchors(schema, isRoot = true) {
-	if (!IsSchemaObject(schema)) return;
-	const current = schema;
-	if (!isRoot && IsId(current)) return;
-	if (!isRoot && IsDynamicAnchor(current)) this.dynamicAnchors.pop();
-	for (const key of Keys(current)) __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_PopResourceAnchors).call(this, current[key], false);
-};
 function Errors$1(...args) {
 	const [context, schema, value] = Match$3(args, {
 		3: (context, schema, value) => [
@@ -5432,16 +5357,15 @@ function Errors$1(...args) {
 			value
 		]
 	});
-	const settings = Get$2();
+	const stack = Stack(context, schema);
+	const errorContext = new ErrorContext();
+	const result = ErrorSchema(stack, errorContext, "#", "", schema, value);
+	const errors = errorContext.GetErrors();
 	const locale = Get$1();
-	const errors = [];
-	return [ErrorSchema(new Stack(context, schema), new ErrorContext((error) => {
-		if (IsGreaterEqualThan(errors.length, settings.maxErrors)) return;
-		return errors.push({
-			...error,
-			message: locale(error)
-		});
-	}), "#", "", schema, value), errors];
+	return [result, errors.map((error) => ({
+		...error,
+		message: locale(error)
+	}))];
 }
 function Check$1(...args) {
 	const [context, schema, value] = Match$3(args, {
@@ -5456,7 +5380,7 @@ function Check$1(...args) {
 			value
 		]
 	});
-	return CheckSchema(new Stack(context, schema), new CheckContext(), schema, value);
+	return CheckSchema(Stack(context, schema), new CheckContext(), schema, value);
 }
 function Check(...args) {
 	const [context, type, value] = Match$3(args, {