@altopelago/aeon-finalize 0.9.0

package/dist/json.js

@@ -0,0 +1,811 @@
+import { formatPath } from '@altopelago/aeon-aes';
+import { finalizeMap } from './finalize.js';
+import { formatReferencePath } from './reference-path.js';
+import { createProjectionState, shouldIncludeProjectedPath } from './projection.js';
+import { formatDatatypeAnnotation } from './datatype.js';
+function toDiagnostic(level, message, path, span) {
+    return {
+        level,
+        message,
+        ...(path !== undefined ? { path } : {}),
+        ...(span !== undefined ? { span: span } : {}),
+    };
+}
+const RESERVED_OBJECT_KEYS = new Set(['@', '$', '$node', '$children', '__proto__', 'constructor']);
+const PROTOTYPE_POLLUTING_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+const IDENTIFIER_PATH_SEGMENT = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function appendMemberPath(basePath, key) {
+    return IDENTIFIER_PATH_SEGMENT.test(key)
+        ? `${basePath}.${key}`
+        : `${basePath}.[${JSON.stringify(key)}]`;
+}
+function appendAttributePath(basePath, key) {
+    return IDENTIFIER_PATH_SEGMENT.test(key)
+        ? `${basePath}@${key}`
+        : `${basePath}@[${JSON.stringify(key)}]`;
+}
+function hasSafeOwnProperty(container, key) {
+    return !PROTOTYPE_POLLUTING_KEYS.has(key) && Object.prototype.hasOwnProperty.call(container, key);
+}
+export function finalizeJson(aes, options = {}) {
+    return finalizeJsonInternal(aes, options, 'tokens');
+}
+export function finalizeLinkedJson(aes, options = {}) {
+    return finalizeJsonInternal(aes, options, 'link-pointers');
+}
+function finalizeJsonInternal(aes, options, referenceStrategy) {
+    const strict = (options.mode ?? 'strict') === 'strict';
+    const scope = options.scope ?? 'payload';
+    const errors = [];
+    const warnings = [];
+    const pathToIndex = new Map();
+    for (let i = 0; i < aes.length; i++) {
+        pathToIndex.set(formatPath(aes[i].path), i);
+    }
+    const mapResult = finalizeMap(aes, options);
+    if (mapResult.meta?.errors)
+        errors.push(...mapResult.meta.errors);
+    if (mapResult.meta?.warnings)
+        warnings.push(...mapResult.meta.warnings);
+    const ctx = {
+        strict,
+        errors,
+        warnings,
+        referenceStrategy,
+        aes,
+        pathToIndex,
+        ...(options.maxMaterializedWeight !== undefined ? { maxMaterializedWeight: options.maxMaterializedWeight } : {}),
+        ...(options.maxReferenceDepth !== undefined ? { maxReferenceDepth: options.maxReferenceDepth } : {}),
+        materializedWeight: 0,
+        materializedWeightCache: new Map(),
+        activeClonePaths: [],
+    };
+    const projection = createProjectionState(options.includePaths, options.materialization);
+    const payload = payloadToJson(aes, ctx, projection, scope, options.header);
+    const header = headerToJson(options.header, ctx, projection, scope);
+    const document = scopeToJsonDocument(scope, header, payload);
+    if (referenceStrategy === 'link-pointers') {
+        linkPointerReferences(document, aes, ctx, projection, scope, options.header);
+    }
+    const meta = {
+        ...(errors.length > 0 ? { errors } : {}),
+        ...(warnings.length > 0 ? { warnings } : {}),
+    };
+    return Object.keys(meta).length > 0 ? { document, meta } : { document };
+}
+function payloadToJson(aes, ctx, projection, scope, header) {
+    if (scope === 'header')
+        return {};
+    const document = {};
+    const documentAttrs = {};
+    for (const event of aes) {
+        if (!isTopLevel(event.path))
+            continue;
+        const segment = event.path.segments[1];
+        if (!segment || segment.type !== 'member')
+            continue;
+        const key = segment.key;
+        if (isHeaderEventKey(key, header)) {
+            continue;
+        }
+        const eventPath = scopedTopLevelPath(scope, 'payload', key);
+        if (!shouldIncludeProjectedPath(eventPath, projection))
+            continue;
+        if (isReservedObjectKey(key)) {
+            ctx.errors.push(toDiagnostic('error', `Reserved key: ${key}`, eventPath, event.span));
+            continue;
+        }
+        if (Object.prototype.hasOwnProperty.call(document, key)) {
+            const diag = toDiagnostic(ctx.strict ? 'error' : 'warning', `Duplicate top-level key during JSON finalization: ${key}`, eventPath, event.span);
+            if (ctx.strict)
+                ctx.errors.push(diag);
+            else
+                ctx.warnings.push(diag);
+            if (ctx.strict)
+                continue;
+        }
+        document[key] = valueToJson(event.value, ctx, eventPath, projection, event.datatype);
+        const attrJson = mergeAttributeJsonObjects(annotationsToJson(event.annotations, ctx, eventPath, projection), indexedChildAnnotationsToJson(event.value, ctx, eventPath, projection));
+        if (attrJson) {
+            documentAttrs[key] = attrJson;
+        }
+    }
+    if (Object.keys(documentAttrs).length > 0) {
+        document['@'] = documentAttrs;
+    }
+    return document;
+}
+function headerToJson(header, ctx, projection, scope) {
+    if (scope === 'payload' || !header)
+        return {};
+    const document = {};
+    for (const [key, value] of header.fields) {
+        const fieldPath = scopedTopLevelPath(scope, 'header', key);
+        if (!shouldIncludeProjectedPath(fieldPath, projection))
+            continue;
+        document[key] = valueToJson(value, ctx, fieldPath, projection);
+    }
+    return document;
+}
+function scopeToJsonDocument(scope, header, payload) {
+    if (scope === 'header')
+        return header;
+    if (scope === 'full') {
+        return {
+            header,
+            payload,
+        };
+    }
+    return payload;
+}
+function isTopLevel(path) {
+    return path.segments.length === 2 && path.segments[0]?.type === 'root';
+}
+function valueToJson(value, ctx, path, projection, datatype) {
+    switch (value.type) {
+        case 'TypedValue':
+            return valueToJson(value.value, ctx, path, projection, value.datatype ? formatDatatypeAnnotation(value.datatype) : datatype);
+        case 'StringLiteral':
+            return value.value;
+        case 'NumberLiteral': {
+            const normalized = value.value.replace(/_/g, '');
+            const numeric = Number(normalized);
+            if (Number.isNaN(numeric)) {
+                ctx[ctx.strict ? 'errors' : 'warnings'].push({
+                    ...toDiagnostic(ctx.strict ? 'error' : 'warning', `Invalid numeric literal for JSON output: ${value.value}`, path, value.span),
+                    code: 'FINALIZE_UNSAFE_NUMBER',
+                });
+                return value.value;
+            }
+            if (!Number.isFinite(numeric) || Math.abs(numeric) > Number.MAX_SAFE_INTEGER) {
+                ctx[ctx.strict ? 'errors' : 'warnings'].push({
+                    ...toDiagnostic(ctx.strict ? 'error' : 'warning', `Numeric literal exceeds JSON safe range: ${value.value}`, path, value.span),
+                    code: 'FINALIZE_UNSAFE_NUMBER',
+                });
+                return value.value;
+            }
+            return numeric;
+        }
+        case 'InfinityLiteral':
+            ctx[ctx.strict ? 'errors' : 'warnings'].push({
+                ...toDiagnostic(ctx.strict ? 'error' : 'warning', `Infinity literal is not representable in the strict JSON profile: ${value.value}`, path, value.span),
+                code: 'FINALIZE_JSON_PROFILE_INFINITY',
+            });
+            return value.value;
+        case 'NaNLiteral':
+            ctx[ctx.strict ? 'errors' : 'warnings'].push({
+                ...toDiagnostic(ctx.strict ? 'error' : 'warning', `NaN literal is not representable in the strict JSON profile: ${value.value}`, path, value.span),
+                code: 'FINALIZE_JSON_PROFILE_NAN',
+            });
+            return value.value;
+        case 'NullLiteral':
+            if (value.mode === 'reserved' && value.value === 'none') {
+                return null;
+            }
+            ctx[ctx.strict ? 'errors' : 'warnings'].push({
+                ...toDiagnostic(ctx.strict ? 'error' : 'warning', `Null literal is not losslessly representable in the strict JSON profile: ${value.raw}`, path, value.span),
+                code: 'FINALIZE_JSON_PROFILE_NULL',
+            });
+            return value.raw;
+        case 'BooleanLiteral':
+            return value.value;
+        case 'ToggleLiteral':
+            return value.value === 'yes' || value.value === 'on';
+        case 'HexLiteral':
+            return value.value.replace(/_/g, '');
+        case 'RadixLiteral': {
+            const normalized = value.value.replace(/_/g, '');
+            const radixBase = declaredRadixBase(datatype ?? datatypeForPath(path, ctx));
+            if (radixBase != null && exceedsDeclaredRadix(normalized, radixBase)) {
+                ctx[ctx.strict ? 'errors' : 'warnings'].push({
+                    ...toDiagnostic(ctx.strict ? 'error' : 'warning', `Radix literal exceeds declared radix ${radixBase}: %${value.value}`, path, value.span),
+                    code: 'FINALIZE_INVALID_RADIX_BASE',
+                });
+            }
+            return normalized;
+        }
+        case 'EncodingLiteral':
+        case 'SeparatorLiteral':
+        case 'DateLiteral':
+        case 'DateTimeLiteral':
+        case 'TimeLiteral':
+            return value.value;
+        case 'ObjectNode':
+            return objectToJson(value.bindings, ctx, path, projection);
+        case 'ListNode':
+            return value.elements.flatMap((element, index) => {
+                const elementPath = `${path}[${index}]`;
+                return shouldIncludeProjectedPath(elementPath, projection)
+                    ? [valueToJson(element, ctx, elementPath, projection)]
+                    : [];
+            });
+        case 'TupleLiteral':
+            return value.elements.flatMap((element, index) => {
+                const elementPath = `${path}[${index}]`;
+                return shouldIncludeProjectedPath(elementPath, projection)
+                    ? [valueToJson(element, ctx, elementPath, projection)]
+                    : [];
+            });
+        case 'NodeLiteral': {
+            const nodeAttrs = attributesToJson(value.attributes, ctx, `${path}@`, projection);
+            return {
+                $node: value.tag,
+                ...(nodeAttrs ? { '@': nodeAttrs } : {}),
+                $children: value.children.map((child, index) => valueToJson(child, ctx, `${path}[${index}]`, projection)),
+            };
+        }
+        case 'CloneReference': {
+            const resolved = resolveCloneReference(value.path, ctx);
+            if (resolved) {
+                if (ctx.activeClonePaths.includes(resolved.targetPath)) {
+                    pushReferenceDiagnostic(ctx, `Reference cycle detected during JSON finalization: '${resolved.targetPath}'`, 'REFERENCE_CYCLE', path, value.span);
+                    return referenceToJson('~', value.path, ctx, path, value.span, false);
+                }
+                const observedDepth = ctx.activeClonePaths.length + 1;
+                if (ctx.maxReferenceDepth !== undefined && observedDepth > ctx.maxReferenceDepth) {
+                    pushReferenceDiagnostic(ctx, `Reference materialization depth ${observedDepth} exceeds maxReferenceDepth ${ctx.maxReferenceDepth}`, 'FINALIZE_REFERENCE_DEPTH_EXCEEDED', path, value.span);
+                    return referenceToJson('~', value.path, ctx, path, value.span, false);
+                }
+                if (!consumeCloneBudget(resolved.targetPath, resolved.value, ctx, path, value.span)) {
+                    return referenceToJson('~', value.path, ctx, path, value.span, false);
+                }
+                ctx.activeClonePaths.push(resolved.targetPath);
+                try {
+                    return valueToJson(resolved.value, ctx, path, projection, datatype);
+                }
+                finally {
+                    ctx.activeClonePaths.pop();
+                }
+            }
+            return referenceToJson('~', value.path, ctx, path, value.span);
+        }
+        case 'PointerReference':
+            return referenceToJson('~>', value.path, ctx, path, value.span, ctx.referenceStrategy === 'tokens');
+        default:
+            return null;
+    }
+}
+function objectToJson(bindings, ctx, basePath, projection) {
+    const obj = {};
+    const attrEntries = {};
+    for (const binding of bindings) {
+        const key = binding.key;
+        const entryPath = appendMemberPath(basePath, key);
+        if (!shouldIncludeProjectedPath(entryPath, projection)) {
+            continue;
+        }
+        if (isReservedObjectKey(key)) {
+            ctx.errors.push(toDiagnostic('error', `Reserved key: ${key}`, entryPath, binding.span));
+            continue;
+        }
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            const diag = toDiagnostic(ctx.strict ? 'error' : 'warning', `Duplicate object key during JSON finalization: ${key}`, entryPath, binding.span);
+            if (ctx.strict)
+                ctx.errors.push(diag);
+            else
+                ctx.warnings.push(diag);
+            if (ctx.strict)
+                continue;
+        }
+        obj[key] = valueToJson(binding.value, ctx, entryPath, projection);
+        const attrJson = mergeAttributeJsonObjects(attributesToJson(binding.attributes, ctx, entryPath, projection), indexedChildAnnotationsToJson(binding.value, ctx, entryPath, projection));
+        if (attrJson) {
+            attrEntries[key] = attrJson;
+        }
+    }
+    if (Object.keys(attrEntries).length > 0) {
+        obj['@'] = attrEntries;
+    }
+    return obj;
+}
+function isReservedObjectKey(key) {
+    return RESERVED_OBJECT_KEYS.has(key);
+}
+function referenceToJson(prefix, pathParts, ctx, path, span, emitDiagnostic = true) {
+    const token = `${prefix}${formatReferencePath(pathParts)}`;
+    if (!emitDiagnostic) {
+        return token;
+    }
+    const diag = toDiagnostic(ctx.strict ? 'error' : 'warning', `Reference left unresolved during JSON finalization: ${token}`, path, span);
+    const coded = { ...diag, code: 'FINALIZE_UNRESOLVED_REFERENCE' };
+    if (ctx.strict)
+        ctx.errors.push(coded);
+    else
+        ctx.warnings.push(coded);
+    return token;
+}
+function pushReferenceDiagnostic(ctx, message, code, path, span) {
+    ctx.errors.push({
+        ...toDiagnostic('error', message, path, span),
+        code,
+    });
+}
+function resolveCloneReference(pathParts, ctx) {
+    const targetPath = formatCloneTargetPath(pathParts);
+    for (let split = pathParts.length; split >= 1; split--) {
+        const prefix = pathParts.slice(0, split);
+        if (prefix.some((part) => typeof part === 'object' && part !== null && 'type' in part && part.type === 'attr')) {
+            continue;
+        }
+        const prefixPath = formatCloneTargetPath(prefix);
+        const targetIndex = ctx.pathToIndex.get(prefixPath);
+        if (targetIndex === undefined)
+            continue;
+        const target = ctx.aes[targetIndex];
+        if (!target)
+            return null;
+        const remainder = pathParts.slice(split);
+        if (remainder.length === 0) {
+            return { value: target.value, targetPath };
+        }
+        const resolved = resolveReferenceSubpath(target, remainder);
+        if (resolved) {
+            return { value: resolved, targetPath };
+        }
+    }
+    return null;
+}
+function consumeCloneBudget(targetPath, value, ctx, path, span) {
+    if (ctx.maxMaterializedWeight === undefined) {
+        return true;
+    }
+    const weight = measureMaterializedWeight(value, ctx, targetPath, new Set());
+    const nextWeight = ctx.materializedWeight + weight;
+    if (nextWeight <= ctx.maxMaterializedWeight) {
+        ctx.materializedWeight = nextWeight;
+        return true;
+    }
+    pushReferenceDiagnostic(ctx, `Reference materialization budget exceeded for '${targetPath}' (budget=maxMaterializedWeight, observed=${nextWeight}, limit=${ctx.maxMaterializedWeight})`, 'FINALIZE_REFERENCE_BUDGET_EXCEEDED', path, span);
+    return false;
+}
+function measureMaterializedWeight(value, ctx, currentPath, stack) {
+    if (stack.has(currentPath)) {
+        return 1;
+    }
+    switch (value.type) {
+        case 'TypedValue':
+            return measureMaterializedWeight(value.value, ctx, currentPath, stack);
+        case 'StringLiteral':
+        case 'NumberLiteral':
+        case 'InfinityLiteral':
+        case 'NaNLiteral':
+        case 'NullLiteral':
+        case 'BooleanLiteral':
+        case 'ToggleLiteral':
+        case 'HexLiteral':
+        case 'RadixLiteral':
+        case 'EncodingLiteral':
+        case 'SeparatorLiteral':
+        case 'DateLiteral':
+        case 'DateTimeLiteral':
+        case 'TimeLiteral':
+        case 'PointerReference':
+            return 1;
+        case 'CloneReference': {
+            const resolved = resolveCloneReference(value.path, ctx);
+            if (!resolved) {
+                return 1;
+            }
+            if (ctx.materializedWeightCache.has(resolved.targetPath)) {
+                return ctx.materializedWeightCache.get(resolved.targetPath);
+            }
+            const nextStack = new Set(stack);
+            nextStack.add(currentPath);
+            const weight = measureMaterializedWeight(resolved.value, ctx, resolved.targetPath, nextStack);
+            ctx.materializedWeightCache.set(resolved.targetPath, weight);
+            return weight;
+        }
+        case 'ObjectNode':
+            return value.bindings.reduce((sum, binding) => {
+                const childPath = appendMemberPath(currentPath, binding.key);
+                return sum
+                    + measureMaterializedWeight(binding.value, ctx, childPath, stack)
+                    + measureAttributeWeight(binding.attributes, ctx, childPath, stack);
+            }, 0);
+        case 'ListNode':
+        case 'TupleLiteral':
+            return value.elements.reduce((sum, element, index) => {
+                const childPath = `${currentPath}[${index}]`;
+                return sum + measureMaterializedWeight(element, ctx, childPath, stack);
+            }, 0) + measureAttributeWeight(value.attributes, ctx, currentPath, stack);
+        case 'NodeLiteral':
+            return 1
+                + measureAttributeWeight(value.attributes, ctx, currentPath, stack)
+                + value.children.reduce((sum, child, index) => {
+                    const childPath = `${currentPath}<${index}>`;
+                    return sum + measureMaterializedWeight(child, ctx, childPath, stack);
+                }, 0);
+        default:
+            return 1;
+    }
+}
+function measureAttributeWeight(attributes, ctx, currentPath, stack) {
+    if (!attributes)
+        return 0;
+    if (Array.isArray(attributes)) {
+        let total = 0;
+        for (const attr of attributes) {
+            for (const [key, entry] of attr.entries) {
+                const entryPath = appendAttributePath(currentPath, key);
+                total += measureMaterializedWeight(entry.value, ctx, entryPath, stack);
+                total += measureAttributeWeight(entry.attributes, ctx, entryPath, stack);
+            }
+        }
+        return total;
+    }
+    let total = 0;
+    for (const [key, entry] of attributes.entries()) {
+        const entryPath = appendAttributePath(currentPath, key);
+        total += measureMaterializedWeight(entry.value, ctx, entryPath, stack);
+        total += measureAttributeWeight(entry.annotations, ctx, entryPath, stack);
+    }
+    return total;
+}
+function resolveReferenceSubpath(event, remainder) {
+    let currentValue = event.value;
+    let currentAnnotations = event.annotations;
+    for (const part of remainder) {
+        if (typeof part === 'object' && part !== null && 'type' in part && part.type === 'attr') {
+            const entry = currentAnnotations?.get(part.key);
+            if (!entry)
+                return null;
+            currentValue = entry.value;
+            currentAnnotations = entry.annotations;
+            continue;
+        }
+        if (typeof part === 'string') {
+            if (currentValue.type !== 'ObjectNode')
+                return null;
+            const binding = currentValue.bindings.find((candidate) => candidate.key === part);
+            if (!binding)
+                return null;
+            currentValue = binding.value;
+            currentAnnotations = buildAnnotationEntries(binding.attributes);
+            continue;
+        }
+        if (typeof part === 'number') {
+            if (currentValue.type !== 'ListNode' && currentValue.type !== 'TupleLiteral')
+                return null;
+            const element = currentValue.elements[part];
+            if (!element)
+                return null;
+            currentValue = element;
+            currentAnnotations = undefined;
+            continue;
+        }
+        return null;
+    }
+    return currentValue;
+}
+function formatCloneTargetPath(pathParts) {
+    if (pathParts.length === 0)
+        return '$';
+    let result = '$';
+    for (const part of pathParts) {
+        if (typeof part === 'number') {
+            result += `[${part}]`;
+        }
+        else if (typeof part === 'string') {
+            result = appendMemberPath(result, part);
+        }
+        else {
+            result = appendAttributePath(result, part.key);
+        }
+    }
+    return result;
+}
+function buildAnnotationEntries(attributes) {
+    if (!attributes || attributes.length === 0)
+        return undefined;
+    const result = new Map();
+    for (const attribute of attributes) {
+        for (const [key, entry] of attribute.entries) {
+            const mapped = { value: entry.value };
+            const nested = buildAnnotationEntries(entry.attributes);
+            if (nested) {
+                mapped.annotations = nested;
+            }
+            result.set(key, mapped);
+        }
+    }
+    return result;
+}
+function attributesToJson(attributes, ctx, path, projection) {
+    if (!attributes || attributes.length === 0)
+        return null;
+    const obj = {};
+    const nestedAttrEntries = {};
+    for (const attr of attributes) {
+        for (const [key, entry] of attr.entries) {
+            const entryPath = appendAttributePath(path, key);
+            if (!shouldIncludeProjectedPath(entryPath, projection)) {
+                continue;
+            }
+            obj[key] = valueToJson(entry.value, ctx, entryPath, projection, entry.datatype ? formatDatatypeAnnotation(entry.datatype) : undefined);
+            const nested = attributesToJson(entry.attributes, ctx, entryPath, projection);
+            if (nested) {
+                nestedAttrEntries[key] = nested;
+            }
+        }
+    }
+    if (Object.keys(nestedAttrEntries).length > 0) {
+        obj['@'] = nestedAttrEntries;
+    }
+    return Object.keys(obj).length > 0 ? obj : null;
+}
+function indexedChildAnnotationsToJson(value, ctx, path, projection) {
+    const children = value.type === 'ListNode' || value.type === 'TupleLiteral'
+        ? value.elements
+        : value.type === 'NodeLiteral'
+            ? value.children
+            : null;
+    if (!children)
+        return null;
+    const itemAttrs = {};
+    for (const [index, child] of children.entries()) {
+        if (child.type !== 'TypedValue' || child.attributes.length === 0) {
+            continue;
+        }
+        const childPath = `${path}[${index}]`;
+        const attrJson = attributesToJson(child.attributes, ctx, childPath, projection);
+        if (attrJson) {
+            itemAttrs[String(index)] = attrJson;
+        }
+    }
+    return Object.keys(itemAttrs).length > 0 ? { '@items': itemAttrs } : null;
+}
+function mergeAttributeJsonObjects(left, right) {
+    if (left && right) {
+        return { ...left, ...right };
+    }
+    return left ?? right;
+}
+function datatypeForPath(path, ctx) {
+    const canonicalPath = canonicalFinalizePath(path);
+    const index = ctx.pathToIndex.get(canonicalPath);
+    return index === undefined ? undefined : ctx.aes[index]?.datatype;
+}
+function canonicalFinalizePath(path) {
+    if (path === '$.payload' || path === '$.header')
+        return '$';
+    if (path.startsWith('$.payload.'))
+        return `$.${path.slice('$.payload.'.length)}`;
+    if (path.startsWith('$.payload@'))
+        return `$.${path.slice('$.payload'.length)}`;
+    if (path.startsWith('$.header.'))
+        return `$.${path.slice('$.header.'.length)}`;
+    if (path.startsWith('$.header@'))
+        return `$.${path.slice('$.header'.length)}`;
+    return path;
+}
+function declaredRadixBase(datatype) {
+    if (!datatype)
+        return null;
+    const trimmed = datatype.trim();
+    if (trimmed === 'radix2')
+        return 2;
+    if (trimmed === 'radix6')
+        return 6;
+    if (trimmed === 'radix8')
+        return 8;
+    if (trimmed === 'radix12')
+        return 12;
+    const match = /^radix\[(\d+)\]$/.exec(trimmed);
+    if (!match)
+        return null;
+    const base = Number(match[1]);
+    return Number.isInteger(base) && base >= 2 && base <= 64 ? base : null;
+}
+function exceedsDeclaredRadix(value, base) {
+    for (const ch of value) {
+        if (ch === '+' || ch === '-' || ch === '.')
+            continue;
+        const digit = radixDigitValue(ch);
+        if (digit == null || digit >= base) {
+            return true;
+        }
+    }
+    return false;
+}
+function radixDigitValue(ch) {
+    if (ch >= '0' && ch <= '9')
+        return ch.charCodeAt(0) - 48;
+    if (ch >= 'A' && ch <= 'Z')
+        return ch.charCodeAt(0) - 55;
+    if (ch >= 'a' && ch <= 'z')
+        return ch.charCodeAt(0) - 61;
+    if (ch === '&')
+        return 62;
+    if (ch === '!')
+        return 63;
+    return null;
+}
+function annotationsToJson(annotations, ctx, path, projection) {
+    if (!annotations || annotations.size === 0)
+        return null;
+    const obj = {};
+    const nestedAttrEntries = {};
+    for (const [key, entry] of annotations.entries()) {
+        const entryPath = appendAttributePath(path, key);
+        if (!shouldIncludeProjectedPath(entryPath, projection)) {
+            continue;
+        }
+        obj[key] = valueToJson(entry.value, ctx, entryPath, projection);
+        const nested = annotationsToJson(entry.annotations, ctx, entryPath, projection);
+        if (nested) {
+            nestedAttrEntries[key] = nested;
+        }
+    }
+    if (Object.keys(nestedAttrEntries).length > 0) {
+        obj['@'] = nestedAttrEntries;
+    }
+    return Object.keys(obj).length > 0 ? obj : null;
+}
+function scopedTopLevelPath(scope, branch, key) {
+    const basePath = scope === 'full' ? `$.${branch}` : '$';
+    return appendMemberPath(basePath, key);
+}
+function isHeaderEventKey(key, header) {
+    if (key === 'aeon:header')
+        return true;
+    if (!header || !key.startsWith('aeon:'))
+        return false;
+    return header.fields.has(key.slice('aeon:'.length));
+}
+function linkPointerReferences(document, aes, ctx, projection, scope, header) {
+    if (scope === 'header') {
+        return;
+    }
+    const payloadRoot = scope === 'full' ? document.payload : document;
+    if (!isContainer(payloadRoot)) {
+        return;
+    }
+    for (const event of aes) {
+        if (event.value.type !== 'PointerReference')
+            continue;
+        const topLevelKey = topLevelPayloadMemberKey(event);
+        if (topLevelKey && isHeaderEventKey(topLevelKey, header)) {
+            continue;
+        }
+        const sourcePath = scope === 'full'
+            ? `$.payload${formatPath(event.path).slice(1)}`
+            : formatPath(event.path);
+        if (!shouldIncludeProjectedPath(sourcePath, projection)) {
+            continue;
+        }
+        const sourceEndpoint = endpointFromCanonicalPath(payloadRoot, event.path.segments.slice(1));
+        if (!sourceEndpoint) {
+            pushLinkDiagnostic(ctx, `Pointer source path could not be materialized: ${sourcePath}`, 'POINTER_SOURCE_NOT_MATERIALIZED', sourcePath, event.span);
+            continue;
+        }
+        const targetEndpoint = endpointFromReferencePath(payloadRoot, event.value.path);
+        if (!targetEndpoint) {
+            pushLinkDiagnostic(ctx, `Pointer target could not be materialized: ~>${formatReferencePath(event.value.path)}`, 'POINTER_TARGET_NOT_MATERIALIZED', sourcePath, event.span);
+            continue;
+        }
+        Object.defineProperty(sourceEndpoint.owner, sourceEndpoint.key, {
+            enumerable: true,
+            configurable: true,
+            get() {
+                return readContainerValue(targetEndpoint.owner, targetEndpoint.key);
+            },
+            set(next) {
+                writeContainerValue(targetEndpoint.owner, targetEndpoint.key, next);
+            },
+        });
+    }
+}
+function pushLinkDiagnostic(ctx, message, code, path, span) {
+    const diag = {
+        ...toDiagnostic(ctx.strict ? 'error' : 'warning', message, path, span),
+        code,
+    };
+    if (ctx.strict)
+        ctx.errors.push(diag);
+    else
+        ctx.warnings.push(diag);
+}
+function topLevelPayloadMemberKey(event) {
+    const segment = event.path.segments[1];
+    if (!segment || segment.type !== 'member')
+        return null;
+    return segment.key;
+}
+function endpointFromCanonicalPath(root, segments) {
+    if (segments.length === 0)
+        return null;
+    const parentSegments = segments.slice(0, -1);
+    const last = segments[segments.length - 1];
+    if (!last || last.type === 'root')
+        return null;
+    const owner = traverseCanonicalSegments(root, parentSegments);
+    if (!owner)
+        return null;
+    return last.type === 'member'
+        ? { owner, key: last.key }
+        : { owner, key: last.index };
+}
+function endpointFromReferencePath(root, pathParts) {
+    if (pathParts.length === 0)
+        return null;
+    const parentParts = pathParts.slice(0, -1);
+    const last = pathParts[pathParts.length - 1];
+    if (last === undefined || typeof last === 'object') {
+        return null;
+    }
+    if (typeof last === 'string' && PROTOTYPE_POLLUTING_KEYS.has(last)) {
+        return null;
+    }
+    const owner = traverseReferenceParts(root, parentParts);
+    if (!owner)
+        return null;
+    return { owner, key: last };
+}
+function traverseCanonicalSegments(current, segments) {
+    let node = current;
+    for (const segment of segments) {
+        if (segment.type === 'root')
+            continue;
+        if (!isContainer(node))
+            return null;
+        const next = segment.type === 'member'
+            ? readContainerValue(node, segment.key)
+            : readContainerValue(node, segment.index);
+        if (next === undefined)
+            return null;
+        node = next;
+    }
+    return isContainer(node) ? node : null;
+}
+function traverseReferenceParts(current, parts) {
+    let node = current;
+    for (const part of parts) {
+        if (typeof part === 'object') {
+            return null;
+        }
+        if (!isContainer(node))
+            return null;
+        const next = readContainerValue(node, part);
+        if (next === undefined)
+            return null;
+        node = next;
+    }
+    return isContainer(node) ? node : null;
+}
+function isContainer(value) {
+    return Array.isArray(value) || (!!value && typeof value === 'object');
+}
+function readContainerValue(container, key) {
+    return typeof key === 'number'
+        ? container[key]
+        : hasSafeOwnProperty(container, key)
+            ? container[key]
+            : undefined;
+}
+function writeContainerValue(container, key, value) {
+    if (typeof key === 'number') {
+        container[key] = value;
+        return;
+    }
+    if (!hasSafeOwnProperty(container, key)) {
+        return;
+    }
+    const descriptor = Object.getOwnPropertyDescriptor(container, key);
+    if (!descriptor) {
+        return;
+    }
+    if (typeof descriptor.set === 'function') {
+        descriptor.set.call(container, value);
+        return;
+    }
+    if (!Object.prototype.hasOwnProperty.call(descriptor, 'value')) {
+        return;
+    }
+    Object.defineProperty(container, key, {
+        value,
+        writable: descriptor.writable ?? true,
+        enumerable: descriptor.enumerable ?? true,
+        configurable: descriptor.configurable ?? true,
+    });
+}
+//# sourceMappingURL=json.js.map