@code-yeongyu/senpi 2026.9.12-3 → 2026.9.12

package/node_modules/marked/man/marked.1

@@ -1,4 +1,4 @@
-.TH "MARKED" "1" "August 2026" "18.0.10"
+.TH "MARKED" "1" "August 2026" "18.0.9"
 .SH "NAME"
 \fBmarked\fR \- a javascript markdown parser
 .SH SYNOPSIS

package/node_modules/marked/package.json

@@ -2,7 +2,7 @@
   "name": "marked",
   "description": "A markdown parser built for speed",
   "author": "Christopher Jeffrey",
-  "version": "18.0.11",
+  "version": "18.0.10",
   "type": "module",
   "main": "./lib/marked.esm.js",
   "module": "./lib/marked.esm.js",
@@ -62,7 +62,7 @@
     "dts-bundle-generator": "^9.5.1",
     "esbuild": "^0.28.2",
     "esbuild-plugin-umd-wrapper": "^3.0.0",
-    "eslint": "^10.9.0",
+    "eslint": "^10.8.1",
     "highlight.js": "^11.12.0",
     "markdown-it": "15.0.0",
     "marked-highlight": "^2.2.4",

package/node_modules/typebox/build/compile/validator.d.mts

@@ -18,7 +18,7 @@ export declare class Validator<Context extends TProperties = TProperties, Type e
     Check(value: unknown): value is Encode;
     /** Validates a value and returns it. Will throw if invalid. */
     Parse(value: unknown): Encode;
-    /** Returns an array of validation errors for the given value. */
+    /** Inspects a value and returns a detailed list of validation errors. */
     Errors(value: unknown): TLocalizedValidationError[];
     /** Cleans a value using the Validator type. */
     Clean(value: unknown): unknown;

package/node_modules/typebox/build/compile/validator.mjs

@@ -53,7 +53,7 @@ export class Validator {
             return Parser(this.Context(), this.Type(), value);
         throw new ParseError(value, this.Errors(value));
     }
-    /** Returns an array of validation errors for the given value. */
+    /** Inspects a value and returns a detailed list of validation errors. */
     Errors(value) {
         if (this.IsAccelerated() && this.Check(value))
             return [];

package/node_modules/typebox/build/format/idna/idn-hostname.mjs

@@ -14,16 +14,14 @@ function IsLabel(value) {
 // ------------------------------------------------------------------
 // NormalizeHostname
 //
-// Normalizes a hostname for label validation. Maps fullwidth
-// codepoints to their ASCII equivalent (e.g. 'ａ' U+FF41 maps to
-// 'a'), then normalizes for NFC such that equivalent codepoint
-// sequences can be uniformly compared. It also removes codepoints
-// that IDNA mapping ignores, and converts full stop variants to
-// ASCII '.' so the hostname can be split into labels.
+// Normalizes a hostname for label validation. Normalizes for NFC
+// such that equivalent codepoint sequences can be uniformly
+// compared. It also removes codepoints that IDNA mapping ignores,
+// and converts full stop variants to ASCII '.' so the hostname can
+// be split into labels.
 // ------------------------------------------------------------------
 function NormalizeHostname(value) {
     return value
-        .replace(/[\uff01-\uff5e]/g, (char) => String.fromCharCode(char.charCodeAt(0) - 0xfee0)) // RE_FULLWIDTH_MAPPING
         .normalize('NFC')
         .replace(/[\u00ad\u034f\u180b-\u180d\u200b\ufe00-\ufe0f\u{e0100}-\u{e01ef}]/gu, '') // RE_IGNORED_MAPPING
         .replace(/[\u002E\u3002\uFF0E\uFF61]/g, '.'); // RE_FULL_STOP_MAPPING

package/node_modules/typebox/build/format/iri.mjs

@@ -2,7 +2,6 @@
 const IpvFutureMatchMaxLength = 2048;
 const IpvFutureMatch = /\[[vV][0-9a-fA-F]+\.[^\]]+\]/; // Guarded By IpvFutureMatchMaxLength
 const InvalidIriChars = /[\x00-\x20<>\^`{|}\\]/;
-const InvalidPercentEncoding = /%(?![0-9a-fA-F]{2})/;
 // ------------------------------------------------------------------
 // NarrowIpvFuture
 //
@@ -27,9 +26,6 @@ export function IsIri(value) {
     // 1. Reject strings containing unencoded whitespace or illegal control characters.
     if (InvalidIriChars.test(value))
         return false;
-    // 2. Reject malformed percent-encoding triplets.
-    if (InvalidPercentEncoding.test(value))
-        return false;
-    // 3. Delegate to the native URL parser, patching the IPvFuture edge case beforehand.
+    // 2. Delegate to the native URL parser, patching the IPvFuture edge case beforehand.
     return URL.canParse(NarrowIpvFuture(value));
 }

package/node_modules/typebox/build/guard/emit.mjs

@@ -106,13 +106,15 @@ export function IsMaxLength(value, length) {
 // Array
 // --------------------------------------------------------------------------
 export function Every(value, offset, params, expression) {
-    return G.IsEqual(offset, '0') ? `${value}.every((${params[0]}, ${params[1]}) => (${expression}))` : `${value}.every((${params[0]}, ${params[1]}) => (${params[1]} < ${offset}) || (${expression}))`;
+    return G.IsEqual(offset, '0')
+        ? `${value}.every((${params[0]}, ${params[1]}) => ${expression})`
+        : `((value, callback) => { for(let index = ${offset}; index < value.length; index++) if (!callback(value[index], index)) return false; return true })(${value}, (${params[0]}, ${params[1]}) => ${expression})`;
 }
 export function Some(value, params, expression) {
     return `${value}.some((${params[0]}, ${params[1]}) => ${expression})`;
 }
 export function SomeAll(value, params, expression) {
-    return `((value) => { let result = false; value.forEach((${params[0]}, ${params[1]}) => { if (${expression}) result = true }); return result })(${value})`;
+    return `((value, callback) => { let result = false; for(let index = 0; index < value.length; index++) if (callback(value[index], index)) result = true; return result })(${value}, (${params[0]}, ${params[1]}) => ${expression})`;
 }
 export function Counted(value, params, expression) {
     return `${value}.reduce((result, ${params[0]}, ${params[1]}) => (${expression}) ? ++result : result, 0)`;

package/node_modules/typebox/build/guard/guard.mjs

@@ -140,24 +140,36 @@ export function IsMinLength(value, length) {
 // --------------------------------------------------------------------------
 /** Returns true if every element from offset satisfies the callback, short-circuiting on the first failure */
 export function Every(value, offset, callback) {
-    return value.every((item, index) => (index < offset) || callback(item, index));
+    for (let index = offset; index < value.length; index++) {
+        if (!callback(value[index], index))
+            return false;
+    }
+    return true;
 }
 /** Returns true if every element from offset satisfies the callback, using exhaustive enumeration */
 export function EveryAll(value, offset, callback) {
     let result = true;
-    value.forEach((item, index) => { if ((index >= offset) && !callback(item, index))
-        result = false; });
+    for (let index = offset; index < value.length; index++) {
+        if (!callback(value[index], index))
+            result = false;
+    }
     return result;
 }
 /** Returns true if some element satisfies the callback, short-circuiting on the first success */
 export function Some(value, callback) {
-    return value.some((value, index) => callback(value, index));
+    for (let index = 0; index < value.length; index++) {
+        if (callback(value[index], index))
+            return true;
+    }
+    return false;
 }
 /** Returns true if some element satisfies the callback, using exhaustive enumeration */
 export function SomeAll(value, callback) {
     let result = false;
-    value.forEach((item, index) => { if (callback(item, index))
-        result = true; });
+    for (let index = 0; index < value.length; index++) {
+        if (callback(value[index], index))
+            result = true;
+    }
     return result;
 }
 /** Returns the count of elements that satisfy the callback */

package/node_modules/typebox/build/guard/string.mjs

@@ -84,11 +84,10 @@ function NextGraphemeClusterIndex(value, clusterStart) {
 // IsGraphemeCodePoint
 // --------------------------------------------------------------------------
 function IsGraphemeCodePoint(value) {
-    return ((value >= 0x0300) && ( // above special range
-    IsHighSurrogate(value) ||
+    return (IsHighSurrogate(value) ||
         IsCombiningMark(value) ||
         IsVariationSelector(value) ||
-        IsZeroWidthJoiner(value)));
+        IsZeroWidthJoiner(value));
 }
 // --------------------------------------------------------------------------
 // GraphemeCount
@@ -104,22 +103,30 @@ export function GraphemeCount(value) {
     return count;
 }
 // --------------------------------------------------------------------------
-// IsMinLengthSegmented
+// IsMinLength
 // --------------------------------------------------------------------------
 /** Checks if a string has at least a minimum number of grapheme clusters */
 function IsMinLengthSegmented(value, minLength) {
-    // if (minLength === 0) return true // 0-length (unreachable)
+    // ----------------------------------------------------------------
+    // Inaccessible via public interface (review)
+    //
+    // deno-coverage-ignore-start
+    // ----------------------------------------------------------------
+    if (minLength === 0)
+        return true; // 0-length
+    // deno-coverage-ignore-stop
     let count = 0;
     let index = 0;
     while (index < value.length) {
         index = NextGraphemeClusterIndex(value, index);
-        if ((++count) >= minLength)
+        count++;
+        if (count >= minLength)
             return true;
     }
     return false;
 }
 // --------------------------------------------------------------------------
-// IsMaxLengthSegmented
+// IsMaxLength
 // --------------------------------------------------------------------------
 /** Checks if a string has at most a maximum number of grapheme clusters */
 function IsMaxLengthSegmented(value, maxLength) {
@@ -127,7 +134,8 @@ function IsMaxLengthSegmented(value, maxLength) {
     let index = 0;
     while (index < value.length) {
         index = NextGraphemeClusterIndex(value, index);
-        if ((++count) > maxLength)
+        count++;
+        if (count > maxLength)
             return false;
     }
     return true;
@@ -139,30 +147,30 @@ function IsMaxLengthSegmented(value, maxLength) {
 export function IsMinLength(value, minLength) {
     if (minLength === 0)
         return true; // 0-length
-    if (value.length < minLength)
-        return false; // length is upper bound on grapheme count
     let index = 0;
-    while (true) {
+    while (index < value.length) {
         if (IsGraphemeCodePoint(value.charCodeAt(index))) {
             return IsMinLengthSegmented(value, minLength);
         }
-        if ((++index) >= minLength)
+        index++;
+        if (index >= minLength)
             return true;
     }
+    return false;
 }
 // --------------------------------------------------------------------------
 // IsMaxLengthFast
 // --------------------------------------------------------------------------
 /** Fast check for maximum grapheme length, falls back to full check if needed */
 export function IsMaxLength(value, maxLength) {
-    if (value.length <= maxLength)
-        return true; // length is upper bound on grapheme count
     let index = 0;
-    while (true) {
+    while (index < value.length) {
         if (IsGraphemeCodePoint(value.charCodeAt(index))) {
             return IsMaxLengthSegmented(value, maxLength);
         }
-        if ((++index) > maxLength)
+        index++;
+        if (index > maxLength)
             return false;
     }
+    return true;
 }

package/node_modules/typebox/build/schema/compile.d.mts

@@ -2,9 +2,8 @@ import { type TLocalizedValidationError } from '../error/index.mjs';
 import { type Static } from '../type/types/static.mjs';
 import * as Schema from './types/index.mjs';
 export declare class Validator<const Schema extends Schema.XSchema = Schema.XSchema, Value extends unknown = Static<Schema>> {
+    private readonly buildResult;
     private readonly evaluateResult;
-    private readonly context;
-    private readonly schema;
     constructor(context: Record<string, Schema.XSchema>, schema: Schema);
     /** Returns true if this Validator is using JIT acceleration. */
     IsAccelerated(): boolean;
@@ -14,7 +13,7 @@ export declare class Validator<const Schema extends Schema.XSchema = Schema.XSch
     Check(value: unknown): value is Value;
     /** Validates a value and returns it. Will throw if invalid. */
     Parse(value: unknown): Value;
-    /** Returns an array of validation errors for the given value. */
+    /** Inspects a value and returns a detailed list of validation errors. */
     Errors(value: unknown): [result: boolean, errors: TLocalizedValidationError[]];
 }
 /** Compiles this schema into a high performance Validator */

package/node_modules/typebox/build/schema/compile.mjs

@@ -3,15 +3,14 @@
 import { Arguments } from '../system/arguments/index.mjs';
 import * as Build from './build.mjs';
 import { Errors } from './errors.mjs';
-import { ThrowParseError } from './parse.mjs';
+import { ParseError } from './parse.mjs';
 // ------------------------------------------------------------------
 // Validator
 // ------------------------------------------------------------------
 export class Validator {
     constructor(context, schema) {
-        this.evaluateResult = Build.Build(context, schema).Evaluate();
-        this.context = context;
-        this.schema = schema;
+        this.buildResult = Build.Build(context, schema);
+        this.evaluateResult = this.buildResult.Evaluate();
     }
     /** Returns true if this Validator is using JIT acceleration. */
     IsAccelerated() {
@@ -19,7 +18,7 @@ export class Validator {
     }
     /** Returns the underlying Schema used to construct this Validator. */
     Schema() {
-        return this.schema;
+        return this.buildResult.Schema();
     }
     /** Performs a type-guard check on the provided value. */
     Check(value) {
@@ -29,11 +28,12 @@ export class Validator {
     Parse(value) {
         if (this.evaluateResult.Check(value))
             return value;
-        ThrowParseError(this.context, this.schema, value);
+        const [_result, errors] = Errors(this.buildResult.Context(), this.buildResult.Schema(), value);
+        throw new ParseError(this.buildResult.Schema(), value, errors);
     }
-    /** Returns an array of validation errors for the given value. */
+    /** Inspects a value and returns a detailed list of validation errors. */
     Errors(value) {
-        return Errors(this.context, this.schema, value);
+        return Errors(this.buildResult.Context(), this.buildResult.Schema(), value);
     }
 }
 /** Compiles this schema into a high performance Validator */

package/node_modules/typebox/build/schema/engine/_context.d.mts

@@ -21,10 +21,15 @@ export declare class CheckContext {
     GetKeys(): Set<string>;
     Merge(results: CheckContext[]): true;
 }
+export type ErrorContextCallback = (error: TValidationError) => unknown;
 export declare class ErrorContext extends CheckContext {
+    private readonly callback;
+    constructor(callback: ErrorContextCallback);
+    AddError(error: TValidationError): false;
+}
+export declare class AccumulatedErrorContext extends ErrorContext {
     private readonly errors;
     constructor();
-    AtCapacity(): boolean;
     AddError(error: TValidationError): false;
     GetErrors(): TValidationError[];
 }

package/node_modules/typebox/build/schema/engine/_context.mjs

@@ -1,5 +1,4 @@
 // deno-fmt-ignore-file
-import { Settings } from '../../system/settings/index.mjs';
 import * as Schema from '../types/index.mjs';
 import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
 // ------------------------------------------------------------------
@@ -102,20 +101,26 @@ export class CheckContext {
         return true;
     }
 }
+export class ErrorContext extends CheckContext {
+    constructor(callback) {
+        super();
+        this.callback = callback;
+    }
+    AddError(error) {
+        this.callback(error);
+        return false;
+    }
+}
 // ------------------------------------------------------------------
-// ErrorContext
+// AccumulatedErrorContext
 // ------------------------------------------------------------------
-export class ErrorContext extends CheckContext {
+export class AccumulatedErrorContext extends ErrorContext {
     constructor() {
-        super();
+        super(error => this.errors.push(error));
         this.errors = [];
     }
-    AtCapacity() {
-        return this.errors.length >= Settings.Get().maxErrors;
-    }
     AddError(error) {
-        if (!this.AtCapacity())
-            this.errors.push(error);
+        this.errors.push(error);
         return false;
     }
     GetErrors() {

package/node_modules/typebox/build/schema/engine/_functions.mjs

@@ -55,7 +55,7 @@ export function GetFunctions() {
 // CreateFunction
 // ------------------------------------------------------------------
 export function CreateFunction(stack, context, schema, value) {
-    const name = CreateName(schema, stack.LexicalBaseURL());
+    const name = CreateName(schema, stack.BaseURL().href);
     const call = CreateCallExpression(context, schema, name, value);
     if (funcs.has(name))
         return call;

package/node_modules/typebox/build/schema/engine/_stack.d.mts

@@ -4,16 +4,12 @@ export declare class Stack {
     private readonly context;
     private readonly schema;
     private readonly ids;
-    private readonly resourceIds;
     private readonly anchors;
     private readonly recursiveAnchors;
     private readonly dynamicAnchors;
-    private readonly retrievedResources;
-    private readonly retrievedFrames;
-    private readonly resolvedResources;
-    private pendingResource;
     constructor(context: Record<PropertyKey, Schema.XSchema>, schema: Schema.XSchema);
-    LexicalBaseURL(): string;
+    BaseURL(): URL;
+    Base(): Schema.XSchemaObject;
     Push(schema: Schema.XSchema): void;
     Pop(schema: Schema.XSchema): void;
     Ref(ref: Schema.XRef): Schema.XSchema | undefined;

package/node_modules/typebox/build/schema/engine/_stack.mjs

@@ -4,163 +4,86 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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, _Stack_StackFrame, _Stack_ApplyRefResult, _Stack_BuildBase, _Stack_ResourceBaseURL, _Stack_ReferenceBaseURL, _Stack_LexicalSchema, _Stack_RegisterResourceAnchorArray, _Stack_UnregisterResourceAnchorArray, _Stack_RegisterResourceAnchors, _Stack_UnregisterResourceAnchors, _Stack_RegisterResource, _Stack_UnregisterResource, _Stack_EnterResolvedResource, _Stack_ExitResolvedResource;
+var _Stack_instances, _Stack_PushResourceAnchors, _Stack_PopResourceAnchors;
 import * as Schema from '../types/index.mjs';
-import { Guard } from '../../guard/index.mjs';
+import { Guard as G } from '../../guard/index.mjs';
 import { Resolve } from '../resolve/index.mjs';
-// --------------------------------------------------------------------------
-// Stack
-//
-// Tracks traversal state ($ids, $anchors, stack frames) and applies scope
-// updates. Reference resolution rules ($ref, $dynamicRef) are delegated to
-// the Resolve functions using state snapshots (Resolve.Scope).
-// --------------------------------------------------------------------------
 export class Stack {
     constructor(context, schema) {
         _Stack_instances.add(this);
         this.context = context;
         this.schema = schema;
         this.ids = [];
-        this.resourceIds = [];
         this.anchors = [];
         this.recursiveAnchors = [];
         this.dynamicAnchors = [];
-        this.retrievedResources = new Map();
-        this.retrievedFrames = [];
-        this.resolvedResources = new Map();
-        this.pendingResource = true;
     }
     // ----------------------------------------------------------------
-    // LexicalBaseURL
+    // Base
     // ----------------------------------------------------------------
-    LexicalBaseURL() {
-        return __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_BuildBase).call(this, this.ids);
+    BaseURL() {
+        return this.ids.reduce((result, schema) => new URL(schema.$id, result), Resolve.DefaultBase);
+    }
+    Base() {
+        return this.ids[this.ids.length - 1] ?? this.schema;
     }
     // ----------------------------------------------------------------
-    // Push
+    // Stack
     // ----------------------------------------------------------------
     Push(schema) {
         if (!Schema.IsSchemaObject(schema))
             return;
-        if (Schema.IsId(schema))
-            __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_RegisterResource).call(this, schema);
+        if (Schema.IsId(schema)) {
+            this.ids.push(schema);
+            __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_PushResourceAnchors).call(this, schema);
+        }
         if (Schema.IsAnchor(schema))
             this.anchors.push(schema);
         if (Schema.IsRecursiveAnchorTrue(schema))
             this.recursiveAnchors.push(schema);
         if (Schema.IsDynamicAnchor(schema))
             this.dynamicAnchors.push(schema);
-        const retrievedResource = this.retrievedResources.get(schema);
-        if (retrievedResource) {
-            this.retrievedFrames.push({
-                schema: retrievedResource.root,
-                base: retrievedResource.base,
-                idDepth: this.ids.length,
-                resourceDepth: this.resourceIds.length
-            });
-        }
     }
-    // ----------------------------------------------------------------
-    // Pop
-    // ----------------------------------------------------------------
     Pop(schema) {
         if (!Schema.IsSchemaObject(schema))
             return;
-        if (Schema.IsId(schema))
-            __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_UnregisterResource).call(this, schema);
+        if (Schema.IsId(schema)) {
+            this.ids.pop();
+            __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_PopResourceAnchors).call(this, schema);
+        }
         if (Schema.IsAnchor(schema))
             this.anchors.pop();
         if (Schema.IsRecursiveAnchorTrue(schema))
             this.recursiveAnchors.pop();
         if (Schema.IsDynamicAnchor(schema))
             this.dynamicAnchors.pop();
-        if (this.retrievedResources.has(schema))
-            this.retrievedFrames.pop();
-        __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_ExitResolvedResource).call(this, schema);
     }
     // ----------------------------------------------------------------
     // Ref
     // ----------------------------------------------------------------
     Ref(ref) {
-        const result = Resolve.ResolveRef(__classPrivateFieldGet(this, _Stack_instances, "m", _Stack_StackFrame).call(this), ref);
-        __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_ApplyRefResult).call(this, result);
-        return result.schema;
+        const root = this.schema;
+        return !ref.$ref.startsWith('#')
+            ? Resolve.Ref(this.context, root, ref.$ref)
+            : Resolve.Ref(this.context, this.Base(), ref.$ref);
     }
     // ----------------------------------------------------------------
     // RecursiveRef
     // ----------------------------------------------------------------
     RecursiveRef(recursiveRef) {
-        const result = Resolve.ResolveRecursiveRef(__classPrivateFieldGet(this, _Stack_instances, "m", _Stack_StackFrame).call(this), recursiveRef);
-        if (result)
-            this.pendingResource = true;
-        return result;
+        return Schema.IsRecursiveAnchorTrue(this.Base())
+            ? Resolve.Ref(this.context, this.recursiveAnchors[0], recursiveRef.$recursiveRef)
+            : Resolve.Ref(this.context, this.Base(), recursiveRef.$recursiveRef);
     }
     // ----------------------------------------------------------------
     // DynamicRef
     // ----------------------------------------------------------------
     DynamicRef(dynamicRef) {
-        const result = Resolve.ResolveDynamicRef(__classPrivateFieldGet(this, _Stack_instances, "m", _Stack_StackFrame).call(this), dynamicRef);
-        if (result)
-            this.pendingResource = true;
-        return result;
+        const root = this.schema;
+        return Resolve.DynamicRef(this.context, root, this.Base(), dynamicRef, this.dynamicAnchors);
     }
 }
-_Stack_instances = new WeakSet(), _Stack_StackFrame = function _Stack_StackFrame() {
-    return {
-        context: this.context,
-        root: this.schema,
-        ids: this.ids,
-        lexicalSchema: __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_LexicalSchema).call(this),
-        lexicalBase: this.LexicalBaseURL(),
-        referenceBase: __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_ReferenceBaseURL).call(this),
-        resourceBase: __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_ResourceBaseURL).call(this),
-        recursiveAnchors: this.recursiveAnchors,
-        dynamicAnchors: this.dynamicAnchors,
-        inRetrievedFrame: this.retrievedFrames.length > 0
-    };
-}, _Stack_ApplyRefResult = function _Stack_ApplyRefResult(result) {
-    if (!Guard.IsUndefined(result.schema))
-        this.pendingResource = true;
-    if (!Guard.IsUndefined(result.resolvedResource)) {
-        __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_EnterResolvedResource).call(this, result.resolvedResource.target, result.resolvedResource.resource);
-    }
-    if (!Guard.IsUndefined(result.retrievedResource)) {
-        this.retrievedResources.set(result.retrievedResource.target, {
-            base: result.retrievedResource.base,
-            root: result.retrievedResource.root
-        });
-    }
-}, _Stack_BuildBase = function _Stack_BuildBase(stack) {
-    const frame = this.retrievedFrames[this.retrievedFrames.length - 1];
-    const base = frame ? new URL(frame.base) : new URL(Resolve.DefaultBase);
-    const scoped = frame ? stack.slice(frame.idDepth) : stack;
-    return scoped.reduce((result, schema) => new URL(schema.$id, result), base).href;
-}, _Stack_ResourceBaseURL = function _Stack_ResourceBaseURL() {
-    const frame = this.retrievedFrames[this.retrievedFrames.length - 1];
-    if (!frame)
-        return __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_BuildBase).call(this, this.resourceIds);
-    return this.resourceIds.slice(frame.resourceDepth).reduce((result, schema) => new URL(schema.$id, result), new URL(frame.base)).href;
-}, _Stack_ReferenceBaseURL = function _Stack_ReferenceBaseURL() {
-    if (this.retrievedFrames.length > 0)
-        return __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_ResourceBaseURL).call(this);
-    const lexical = this.ids[this.ids.length - 1];
-    if (lexical && !/^[A-Za-z][A-Za-z0-9+.-]*:/.test(lexical.$id))
-        return this.LexicalBaseURL();
-    return __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_ResourceBaseURL).call(this);
-}, _Stack_LexicalSchema = function _Stack_LexicalSchema() {
-    const frame = this.retrievedFrames[this.retrievedFrames.length - 1];
-    if (frame)
-        return this.ids.length > frame.idDepth ? this.ids[this.ids.length - 1] : frame.schema;
-    return this.ids.length > 0 ? this.ids[this.ids.length - 1] : this.schema;
-}, _Stack_RegisterResourceAnchorArray = function _Stack_RegisterResourceAnchorArray(schema) {
-    schema.forEach((schema) => __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_RegisterResourceAnchors).call(this, schema, false));
-}, _Stack_UnregisterResourceAnchorArray = function _Stack_UnregisterResourceAnchorArray(schema) {
-    schema.forEach((schema) => __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_UnregisterResourceAnchors).call(this, schema, false));
-}, _Stack_RegisterResourceAnchors = function _Stack_RegisterResourceAnchors(schema, isRoot = true) {
-    if (Schema.IsSchemaBoolean(schema))
-        return;
-    if (Guard.IsArray(schema))
-        return __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_RegisterResourceAnchorArray).call(this, schema);
+_Stack_instances = new WeakSet(), _Stack_PushResourceAnchors = function _Stack_PushResourceAnchors(schema, isRoot = true) {
     if (!Schema.IsSchemaObject(schema))
         return;
     const current = schema;
@@ -168,13 +91,9 @@ _Stack_instances = new WeakSet(), _Stack_StackFrame = function _Stack_StackFrame
         return;
     if (!isRoot && Schema.IsDynamicAnchor(current))
         this.dynamicAnchors.push(current);
-    for (const key of Guard.Keys(current))
-        __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_RegisterResourceAnchors).call(this, current[key], false);
-}, _Stack_UnregisterResourceAnchors = function _Stack_UnregisterResourceAnchors(schema, isRoot = true) {
-    if (Schema.IsSchemaBoolean(schema))
-        return;
-    if (Guard.IsArray(schema))
-        return __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_UnregisterResourceAnchorArray).call(this, schema);
+    for (const key of G.Keys(current))
+        __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_PushResourceAnchors).call(this, current[key], false);
+}, _Stack_PopResourceAnchors = function _Stack_PopResourceAnchors(schema, isRoot = true) {
     if (!Schema.IsSchemaObject(schema))
         return;
     const current = schema;
@@ -182,28 +101,6 @@ _Stack_instances = new WeakSet(), _Stack_StackFrame = function _Stack_StackFrame
         return;
     if (!isRoot && Schema.IsDynamicAnchor(current))
         this.dynamicAnchors.pop();
-    for (const key of Guard.Keys(current))
-        __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_UnregisterResourceAnchors).call(this, current[key], false);
-}, _Stack_RegisterResource = function _Stack_RegisterResource(schema) {
-    this.ids.push(schema);
-    const isResource = this.pendingResource;
-    this.pendingResource = false;
-    if (isResource)
-        this.resourceIds.push(schema);
-    __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_RegisterResourceAnchors).call(this, schema, true);
-}, _Stack_UnregisterResource = function _Stack_UnregisterResource(schema) {
-    this.ids.pop();
-    const isResource = this.resourceIds.length > 0 && Guard.IsEqual(this.resourceIds[this.resourceIds.length - 1], schema);
-    if (isResource)
-        this.resourceIds.pop();
-    __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_UnregisterResourceAnchors).call(this, schema, true);
-}, _Stack_EnterResolvedResource = function _Stack_EnterResolvedResource(target, resource) {
-    __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_RegisterResource).call(this, resource);
-    this.resolvedResources.set(target, resource);
-}, _Stack_ExitResolvedResource = function _Stack_ExitResolvedResource(target) {
-    if (!this.resolvedResources.has(target))
-        return;
-    const resource = this.resolvedResources.get(target);
-    __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_UnregisterResource).call(this, resource);
-    this.resolvedResources.delete(target);
+    for (const key of G.Keys(current))
+        __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_PopResourceAnchors).call(this, current[key], false);
 };