@code-yeongyu/senpi 2026.9.11 → 2026.9.12-3

package/node_modules/marked/man/marked.1

@@ -1,4 +1,4 @@
-.TH "MARKED" "1" "August 2026" "18.0.9"
+.TH "MARKED" "1" "August 2026" "18.0.10"
 .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.10",
+  "version": "18.0.11",
   "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.8.1",
+    "eslint": "^10.9.0",
     "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;
-    /** Inspects a value and returns a detailed list of validation errors. */
+    /** Returns an array of validation errors for the given value. */
     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));
     }
-    /** Inspects a value and returns a detailed list of validation errors. */
+    /** Returns an array of validation errors for the given value. */
     Errors(value) {
         if (this.IsAccelerated() && this.Check(value))
             return [];

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

@@ -14,14 +14,16 @@ function IsLabel(value) {
 // ------------------------------------------------------------------
 // NormalizeHostname
 //
-// 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.
+// 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.
 // ------------------------------------------------------------------
 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,6 +2,7 @@
 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
 //
@@ -26,6 +27,9 @@ export function IsIri(value) {
     // 1. Reject strings containing unencoded whitespace or illegal control characters.
     if (InvalidIriChars.test(value))
         return false;
-    // 2. Delegate to the native URL parser, patching the IPvFuture edge case beforehand.
+    // 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.
     return URL.canParse(NarrowIpvFuture(value));
 }

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

@@ -106,15 +106,13 @@ 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, callback) => { for(let index = ${offset}; index < value.length; index++) if (!callback(value[index], index)) return false; return true })(${value}, (${params[0]}, ${params[1]}) => ${expression})`;
+    return G.IsEqual(offset, '0') ? `${value}.every((${params[0]}, ${params[1]}) => (${expression}))` : `${value}.every((${params[0]}, ${params[1]}) => (${params[1]} < ${offset}) || (${expression}))`;
 }
 export function Some(value, params, expression) {
     return `${value}.some((${params[0]}, ${params[1]}) => ${expression})`;
 }
 export function SomeAll(value, params, expression) {
-    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})`;
+    return `((value) => { let result = false; value.forEach((${params[0]}, ${params[1]}) => { if (${expression}) result = true }); return result })(${value})`;
 }
 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,36 +140,24 @@ 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) {
-    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));
 }
 /** Returns true if every element from offset satisfies the callback, using exhaustive enumeration */
 export 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;
 }
 /** Returns true if some element satisfies the callback, short-circuiting on the first success */
 export 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));
 }
 /** Returns true if some element satisfies the callback, using exhaustive enumeration */
 export 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;
 }
 /** Returns the count of elements that satisfy the callback */

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

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

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

@@ -2,8 +2,9 @@ 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;
@@ -13,7 +14,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;
-    /** Inspects a value and returns a detailed list of validation errors. */
+    /** Returns an array of validation errors for the given value. */
     Errors(value: unknown): [result: boolean, errors: TLocalizedValidationError[]];
 }
 /** Compiles this schema into a high performance Validator */

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

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

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

@@ -21,15 +21,10 @@ 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,4 +1,5 @@
 // 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';
 // ------------------------------------------------------------------
@@ -101,26 +102,20 @@ export class CheckContext {
         return true;
     }
 }
-export class ErrorContext extends CheckContext {
-    constructor(callback) {
-        super();
-        this.callback = callback;
-    }
-    AddError(error) {
-        this.callback(error);
-        return false;
-    }
-}
 // ------------------------------------------------------------------
-// AccumulatedErrorContext
+// ErrorContext
 // ------------------------------------------------------------------
-export class AccumulatedErrorContext extends ErrorContext {
+export class ErrorContext extends CheckContext {
     constructor() {
-        super(error => this.errors.push(error));
+        super();
         this.errors = [];
     }
+    AtCapacity() {
+        return this.errors.length >= Settings.Get().maxErrors;
+    }
     AddError(error) {
-        this.errors.push(error);
+        if (!this.AtCapacity())
+            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.BaseURL().href);
+    const name = CreateName(schema, stack.LexicalBaseURL());
     const call = CreateCallExpression(context, schema, name, value);
     if (funcs.has(name))
         return call;

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

@@ -4,12 +4,16 @@ 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);
-    BaseURL(): URL;
-    Base(): Schema.XSchemaObject;
+    LexicalBaseURL(): string;
     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,86 +4,163 @@ 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_PushResourceAnchors, _Stack_PopResourceAnchors;
+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;
 import * as Schema from '../types/index.mjs';
-import { Guard as G } from '../../guard/index.mjs';
+import { Guard } 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;
     }
     // ----------------------------------------------------------------
-    // Base
+    // LexicalBaseURL
     // ----------------------------------------------------------------
-    BaseURL() {
-        return this.ids.reduce((result, schema) => new URL(schema.$id, result), Resolve.DefaultBase);
-    }
-    Base() {
-        return this.ids[this.ids.length - 1] ?? this.schema;
+    LexicalBaseURL() {
+        return __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_BuildBase).call(this, this.ids);
     }
     // ----------------------------------------------------------------
-    // Stack
+    // Push
     // ----------------------------------------------------------------
     Push(schema) {
         if (!Schema.IsSchemaObject(schema))
             return;
-        if (Schema.IsId(schema)) {
-            this.ids.push(schema);
-            __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_PushResourceAnchors).call(this, schema);
-        }
+        if (Schema.IsId(schema))
+            __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_RegisterResource).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)) {
-            this.ids.pop();
-            __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_PopResourceAnchors).call(this, schema);
-        }
+        if (Schema.IsId(schema))
+            __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_UnregisterResource).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 root = this.schema;
-        return !ref.$ref.startsWith('#')
-            ? Resolve.Ref(this.context, root, ref.$ref)
-            : Resolve.Ref(this.context, this.Base(), 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;
     }
     // ----------------------------------------------------------------
     // RecursiveRef
     // ----------------------------------------------------------------
     RecursiveRef(recursiveRef) {
-        return Schema.IsRecursiveAnchorTrue(this.Base())
-            ? Resolve.Ref(this.context, this.recursiveAnchors[0], recursiveRef.$recursiveRef)
-            : Resolve.Ref(this.context, this.Base(), recursiveRef.$recursiveRef);
+        const result = Resolve.ResolveRecursiveRef(__classPrivateFieldGet(this, _Stack_instances, "m", _Stack_StackFrame).call(this), recursiveRef);
+        if (result)
+            this.pendingResource = true;
+        return result;
     }
     // ----------------------------------------------------------------
     // DynamicRef
     // ----------------------------------------------------------------
     DynamicRef(dynamicRef) {
-        const root = this.schema;
-        return Resolve.DynamicRef(this.context, root, this.Base(), dynamicRef, this.dynamicAnchors);
+        const result = Resolve.ResolveDynamicRef(__classPrivateFieldGet(this, _Stack_instances, "m", _Stack_StackFrame).call(this), dynamicRef);
+        if (result)
+            this.pendingResource = true;
+        return result;
     }
 }
-_Stack_instances = new WeakSet(), _Stack_PushResourceAnchors = function _Stack_PushResourceAnchors(schema, isRoot = true) {
+_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);
     if (!Schema.IsSchemaObject(schema))
         return;
     const current = schema;
@@ -91,9 +168,13 @@ _Stack_instances = new WeakSet(), _Stack_PushResourceAnchors = function _Stack_P
         return;
     if (!isRoot && Schema.IsDynamicAnchor(current))
         this.dynamicAnchors.push(current);
-    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) {
+    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);
     if (!Schema.IsSchemaObject(schema))
         return;
     const current = schema;
@@ -101,6 +182,28 @@ _Stack_instances = new WeakSet(), _Stack_PushResourceAnchors = function _Stack_P
         return;
     if (!isRoot && Schema.IsDynamicAnchor(current))
         this.dynamicAnchors.pop();
-    for (const key of G.Keys(current))
-        __classPrivateFieldGet(this, _Stack_instances, "m", _Stack_PopResourceAnchors).call(this, current[key], false);
+    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);
 };