@spyglassmc/mcdoc 0.3.7 → 0.3.9

package/lib/runtime/attribute/index.d.ts

@@ -0,0 +1,22 @@
+import * as core from '@spyglassmc/core';
+import type { Attribute, StructTypePairField } from '../../type/index.js';
+import type { McdocCheckerContext, SimplifiedMcdocType, SimplifiedMcdocTypeNoUnion } from '../checker/index.js';
+import type { McdocCompleterContext } from '../completer/index.js';
+import type { McdocAttributeValidator } from './validator.js';
+export * as validator from './validator.js';
+export interface McdocAttribute<C = unknown> {
+    checkInferred?: <T>(config: C, inferred: SimplifiedMcdocTypeNoUnion, ctx: McdocCheckerContext<T>) => boolean;
+    mapType?: <T>(config: C, typeDef: SimplifiedMcdocType, ctx: McdocCheckerContext<T>) => SimplifiedMcdocType;
+    mapField?: <T>(config: C, field: StructTypePairField, ctx: McdocCheckerContext<T>) => StructTypePairField;
+    filterElement?: (config: C, ctx: core.ContextBase) => boolean;
+    stringParser?: <T>(config: C, typeDef: SimplifiedMcdocTypeNoUnion, ctx: McdocCheckerContext<T>) => core.InfallibleParser<core.AstNode | undefined> | undefined;
+    stringMocker?: (config: C, typeDef: core.DeepReadonly<SimplifiedMcdocTypeNoUnion>, ctx: McdocCompleterContext) => core.AstNode | undefined;
+}
+export declare function registerAttribute<C extends core.Returnable>(meta: core.MetaRegistry, name: string, validator: McdocAttributeValidator<C>, attribute: McdocAttribute<C>): void;
+interface AttributeInfo {
+    validator: McdocAttributeValidator<core.Returnable>;
+    attribute: McdocAttribute;
+}
+export declare function getAttribute(meta: core.MetaRegistry, name: string): AttributeInfo | undefined;
+export declare function handleAttributes(attributes: core.DeepReadonly<Attribute[]> | undefined, ctx: core.ContextBase, fn: <C>(handler: McdocAttribute<C>, config: C) => void): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/runtime/attribute/index.js

@@ -0,0 +1,22 @@
+import * as core from '@spyglassmc/core';
+export * as validator from './validator.js';
+export function registerAttribute(meta, name, validator, attribute) {
+    meta.registerCustom('mcdoc:attribute', name, { validator, attribute });
+}
+export function getAttribute(meta, name) {
+    return meta.getCustom('mcdoc:attribute')?.get(name);
+}
+export function handleAttributes(attributes, ctx, fn) {
+    for (const { name, value } of attributes ?? []) {
+        const handler = getAttribute(ctx.meta, name);
+        if (!handler) {
+            continue;
+        }
+        const config = handler.validator(value, ctx);
+        if (config === core.Failure) {
+            continue;
+        }
+        fn(handler.attribute, config);
+    }
+}
+//# sourceMappingURL=index.js.map

package/lib/runtime/attribute/validator.d.ts

@@ -0,0 +1,16 @@
+import * as core from '@spyglassmc/core';
+import type { AttributeValue } from '../../type/index.js';
+export type McdocAttributeValidator<C extends core.Returnable> = (value: core.DeepReadonly<AttributeValue> | undefined, ctx: core.ContextBase) => core.Result<C>;
+export declare const string: McdocAttributeValidator<string>;
+export declare const number: McdocAttributeValidator<number>;
+export declare const boolean: McdocAttributeValidator<boolean>;
+export declare function options<C extends string>(...options: C[]): McdocAttributeValidator<C>;
+export declare function tree<C extends {
+    [K in keyof C]: core.Returnable;
+}>(properties: {
+    [K in keyof C]: McdocAttributeValidator<C[K]>;
+}): McdocAttributeValidator<C>;
+export declare function optional<C extends core.Returnable>(validator: McdocAttributeValidator<C>): McdocAttributeValidator<C | undefined>;
+export declare function map<C extends core.Returnable, D extends core.Returnable>(validator: McdocAttributeValidator<C>, mapper: (value: C) => D | typeof core.Failure): McdocAttributeValidator<D>;
+export declare function alternatives<C extends core.Returnable>(...validators: McdocAttributeValidator<C>[]): McdocAttributeValidator<C>;
+//# sourceMappingURL=validator.d.ts.map

package/lib/runtime/attribute/validator.js

@@ -0,0 +1,85 @@
+import * as core from '@spyglassmc/core';
+export const string = (value) => {
+    if (value === undefined) {
+        return core.Failure;
+    }
+    if (value.kind === 'literal' && value.value.kind === 'string') {
+        return value.value.value;
+    }
+    if (value.kind === 'reference' && value.path) {
+        return value.path.replace(/.*::/, '');
+    }
+    return core.Failure;
+};
+export const number = (value) => {
+    if (value === undefined) {
+        return core.Failure;
+    }
+    if (value.kind === 'literal' && typeof value.value.value === 'number') {
+        return value.value.value;
+    }
+    return core.Failure;
+};
+export const boolean = (value) => {
+    if (value === undefined) {
+        return core.Failure;
+    }
+    if (value.kind === 'literal' && value.value.kind === 'boolean') {
+        return value.value.value;
+    }
+    return core.Failure;
+};
+export function options(...options) {
+    return (value, ctx) => {
+        const stringValue = string(value, ctx);
+        if (stringValue === core.Failure) {
+            return core.Failure;
+        }
+        if (options.includes(stringValue)) {
+            return stringValue;
+        }
+        return core.Failure;
+    };
+}
+export function tree(properties) {
+    return (value, ctx) => {
+        if (value?.kind !== 'tree') {
+            return core.Failure;
+        }
+        const result = {};
+        for (const key in properties) {
+            const validator = properties[key];
+            const propValue = value.values[key];
+            const property = validator(propValue, ctx);
+            if (property === core.Failure) {
+                return core.Failure;
+            }
+            result[key] = property;
+        }
+        return result;
+    };
+}
+export function optional(validator) {
+    return (value, ctx) => {
+        const config = validator(value, ctx);
+        return config === core.Failure ? undefined : config;
+    };
+}
+export function map(validator, mapper) {
+    return (value, ctx) => {
+        const config = validator(value, ctx);
+        return config === core.Failure ? core.Failure : mapper(config);
+    };
+}
+export function alternatives(...validators) {
+    return (value, ctx) => {
+        for (const validator of validators) {
+            const result = validator(value, ctx);
+            if (result !== core.Failure) {
+                return result;
+            }
+        }
+        return core.Failure;
+    };
+}
+//# sourceMappingURL=validator.js.map

package/lib/runtime/checker/context.d.ts

@@ -0,0 +1,34 @@
+import type * as core from '@spyglassmc/core';
+import type { Attribute, EnumType, LiteralType, McdocType, UnionType } from '../../type/index.js';
+import type { McdocRuntimeError } from './error.js';
+import type { SimplifiedMcdocType, SimplifiedMcdocTypeNoUnion } from './index.js';
+export type RuntimeUnion<T> = RuntimeNode<T>[] | RuntimePair<T>;
+export interface RuntimeNode<T> {
+    originalNode: T;
+    inferredType: Exclude<McdocType, UnionType>;
+}
+export interface RuntimePair<T> {
+    attributes?: Attribute[];
+    key: RuntimeNode<T>;
+    possibleValues: RuntimeNode<T>[];
+}
+export type NodeEquivalenceChecker = (inferredNode: Exclude<SimplifiedMcdocTypeNoUnion, LiteralType | EnumType>, definition: Exclude<SimplifiedMcdocTypeNoUnion, LiteralType | EnumType>) => boolean;
+export type TypeInfoAttacher<T> = (node: T, definition: SimplifiedMcdocType, description?: string) => void;
+export type StringAttacher<T> = (node: T, attacher: (node: core.StringBaseNode) => void) => void;
+export type ChildrenGetter<T> = (node: T, simplified: SimplifiedMcdocTypeNoUnion) => RuntimeUnion<T>[];
+export type ErrorReporter<T> = (error: McdocRuntimeError<T>) => void;
+export interface McdocCheckerContext<T> extends core.CheckerContext {
+    allowMissingKeys: boolean;
+    requireCanonical: boolean;
+    isEquivalent: NodeEquivalenceChecker;
+    getChildren: ChildrenGetter<T>;
+    reportError: ErrorReporter<T>;
+    attachTypeInfo?: TypeInfoAttacher<T>;
+    stringAttacher?: StringAttacher<T>;
+}
+type McdocCheckerContextOptions<T> = Partial<McdocCheckerContext<T>>;
+export declare namespace McdocCheckerContext {
+    function create<T>(ctx: core.CheckerContext, options: McdocCheckerContextOptions<T>): McdocCheckerContext<T>;
+}
+export {};
+//# sourceMappingURL=context.d.ts.map

package/lib/runtime/checker/context.js

@@ -0,0 +1,17 @@
+export var McdocCheckerContext;
+(function (McdocCheckerContext) {
+    function create(ctx, options) {
+        return {
+            ...ctx,
+            allowMissingKeys: options.allowMissingKeys ?? false,
+            requireCanonical: options.requireCanonical ?? false,
+            isEquivalent: options.isEquivalent ?? (() => false),
+            getChildren: options.getChildren ?? (() => []),
+            reportError: options.reportError ?? (() => { }),
+            attachTypeInfo: options.attachTypeInfo,
+            stringAttacher: options.stringAttacher,
+        };
+    }
+    McdocCheckerContext.create = create;
+})(McdocCheckerContext || (McdocCheckerContext = {}));
+//# sourceMappingURL=context.js.map

package/lib/runtime/checker/error.d.ts

@@ -0,0 +1,70 @@
+import type { AstNode, CheckerContext, Range } from '@spyglassmc/core';
+import { NumericRange } from '../../type/index.js';
+import type { CheckerTreeDefinitionGroupNode, CheckerTreeDefinitionNode, ErrorReporter, RuntimeNode, SimplifiedMcdocTypeNoUnion } from './index.js';
+export type McdocRuntimeError<T> = SimpleError<T> | UnknownKeyError<T> | RangeError<T> | TypeMismatchError<T> | MissingKeyError<T>;
+export interface McdocRuntimeBaseError<T> {
+    node: RuntimeNode<T>;
+    /**
+     * This is set when this error may not need to be fixed if another error of the same kind is
+     * fixed instead. This contains a list of nodes with conflicting
+     */
+    nodesWithConflictingErrors?: RuntimeNode<T>[];
+}
+export interface SimpleError<T> extends McdocRuntimeBaseError<T> {
+    kind: 'duplicate_key' | 'unknown_key' | 'expected_key_value_pair' | 'unknown_tuple_element' | 'internal';
+}
+export declare namespace SimpleError {
+    function is<T>(error: McdocRuntimeError<T> | undefined): error is SimpleError<T>;
+}
+export interface UnknownKeyError<T> extends McdocRuntimeBaseError<T> {
+    kind: 'unknown_key';
+}
+export declare namespace UnknownKeyError {
+    function is<T>(error: McdocRuntimeError<T> | undefined): error is UnknownKeyError<T>;
+}
+export interface RangeError<T> extends McdocRuntimeBaseError<T> {
+    kind: 'invalid_collection_length' | 'invalid_string_length' | 'number_out_of_range';
+    /**
+     * A list of multiple mean the number (or length) has to be within one of these ranges. This is
+     * a result of merging errors from two conflicting definitions for the same value.
+     */
+    ranges: NumericRange[];
+}
+export declare namespace RangeError {
+    function is<T>(error: McdocRuntimeError<T> | undefined): error is RangeError<T>;
+}
+export interface MissingKeyError<T> extends McdocRuntimeBaseError<T> {
+    kind: 'missing_key';
+    /**
+     * A list of multiple are an alternative, and at least on e needs to be fixed, not neccessarily
+     * all of them.
+     *
+     * In case there are multiple non-conflicting missing keys, multiple errors will be reported on
+     * the same node instead.
+     *
+     * If this has a length > 1, there is at least one error that needs to be fixed, and at least one
+     * error that does not neccassarily need to be fixed.
+     */
+    keys: string[];
+}
+export declare namespace MissingKeyError {
+    function is<T>(error: McdocRuntimeError<T> | undefined): error is MissingKeyError<T>;
+}
+export interface TypeMismatchError<T> extends McdocRuntimeBaseError<T> {
+    kind: 'type_mismatch';
+    /**
+     * These are all valid definitions. The node needs to only fullfill one of them.
+     */
+    expected: SimplifiedMcdocTypeNoUnion[];
+}
+export declare namespace TypeMismatchError {
+    function is<T>(error: McdocRuntimeError<T> | undefined): error is TypeMismatchError<T>;
+}
+export interface ErrorCondensingDefinition<T> {
+    definition: CheckerTreeDefinitionNode<T>;
+    errors: McdocRuntimeError<T>[];
+}
+export declare function condenseAndPropagate<T>(definitionGroup: CheckerTreeDefinitionGroupNode<T>, definitionErrors: ErrorCondensingDefinition<T>[]): void;
+export declare function getDefaultErrorRange<T extends AstNode>(node: RuntimeNode<T>, error: McdocRuntimeError<T>['kind']): Range;
+export declare function getDefaultErrorReporter<T>(ctx: CheckerContext, getErrorRange: (node: RuntimeNode<T>, error: McdocRuntimeError<T>['kind']) => Range): ErrorReporter<T>;
+//# sourceMappingURL=error.d.ts.map

package/lib/runtime/checker/error.js

@@ -0,0 +1,352 @@
+import { ResourceLocation } from '@spyglassmc/core';
+import { arrayToMessage, localeQuote, localize } from '@spyglassmc/locales';
+import { RangeKind } from '../../node/index.js';
+import { McdocType, NumericRange } from '../../type/index.js';
+export var SimpleError;
+(function (SimpleError) {
+    function is(error) {
+        return error?.kind === 'duplicate_key'
+            || error?.kind === 'unknown_key'
+            || error?.kind === 'expected_key_value_pair'
+            || error?.kind === 'unknown_tuple_element'
+            || error?.kind === 'internal';
+    }
+    SimpleError.is = is;
+})(SimpleError || (SimpleError = {}));
+export var UnknownKeyError;
+(function (UnknownKeyError) {
+    function is(error) {
+        return error?.kind === 'unknown_key';
+    }
+    UnknownKeyError.is = is;
+})(UnknownKeyError || (UnknownKeyError = {}));
+export var RangeError;
+(function (RangeError) {
+    function is(error) {
+        return error?.kind === 'invalid_collection_length'
+            || error?.kind === 'invalid_string_length'
+            || error?.kind === 'number_out_of_range';
+    }
+    RangeError.is = is;
+})(RangeError || (RangeError = {}));
+export var MissingKeyError;
+(function (MissingKeyError) {
+    function is(error) {
+        return error?.kind === 'missing_key';
+    }
+    MissingKeyError.is = is;
+})(MissingKeyError || (MissingKeyError = {}));
+export var TypeMismatchError;
+(function (TypeMismatchError) {
+    function is(error) {
+        return error?.kind === 'type_mismatch';
+    }
+    TypeMismatchError.is = is;
+})(TypeMismatchError || (TypeMismatchError = {}));
+export function condenseAndPropagate(definitionGroup, definitionErrors) {
+    const queue = [{ node: definitionGroup, errorsOnLayer: definitionErrors, depth: 0 }];
+    while (queue.length) {
+        const { node, errorsOnLayer, depth } = queue.shift();
+        const stillValidDefinitions = [];
+        const { definitions, condensedErrors } = condenseErrorsAndFilterSiblings(errorsOnLayer);
+        stillValidDefinitions.push(...definitions);
+        node.condensedErrors.push(condensedErrors);
+        if (node.validDefinitions.length !== stillValidDefinitions.length) {
+            filterChildDefinitions(node.validDefinitions.filter(d => !stillValidDefinitions.includes(d)), node.runtimeNode.children);
+            node.validDefinitions = stillValidDefinitions;
+        }
+        const parents = node.parents
+            .filter(parent => {
+            const lastDefWithNode = parent.groupNode.validDefinitions
+                .findLast(d => d.children.includes(node));
+            if (lastDefWithNode !== parent) {
+                // Wait for last definition that leads to this parent
+                return false;
+            }
+            const lastChild = parent.groupNode.validDefinitions
+                .flatMap(d => d.children)
+                .findLast(v => {
+                if (v.condensedErrors.length > depth) {
+                    return true;
+                }
+                let children = [v];
+                for (let i = 0; i < depth; i++) {
+                    children = children.flatMap(v => v.validDefinitions).flatMap(v => v.children);
+                }
+                return children.length > 0;
+            });
+            if (lastChild !== node) {
+                // Wait for all siblings to be evaluated first
+                return false;
+            }
+            return true;
+        })
+            .map(parent => ({
+            node: parent.groupNode,
+            depth: depth + 1,
+            errorsOnLayer: parent.groupNode.validDefinitions
+                .flatMap(d => ({
+                definition: d,
+                errors: d.children
+                    .flatMap(c => c.condensedErrors.length > depth
+                    ? c.condensedErrors[depth]
+                    : []),
+            })),
+        }));
+        queue.push(...parents);
+    }
+}
+function filterChildDefinitions(removedDefs, children) {
+    for (const child of children) {
+        for (const childValue of child.possibleValues) {
+            const removedChildDefs = [];
+            for (let i = 0; i < childValue.definitionsByParent.length; i++) {
+                const definitionGroup = childValue.definitionsByParent[i];
+                definitionGroup.parents = definitionGroup.parents.filter(p => !removedDefs.includes(p));
+                if (definitionGroup.parents.length === 0) {
+                    removedChildDefs.push(...definitionGroup.validDefinitions);
+                    childValue.definitionsByParent.splice(i, 1);
+                    i--;
+                }
+            }
+            if (removedChildDefs.length > 0) {
+                filterChildDefinitions(removedChildDefs, childValue.children);
+            }
+        }
+    }
+}
+function condenseErrorsAndFilterSiblings(definitions) {
+    if (definitions.length === 0) {
+        return { definitions: [], condensedErrors: [] };
+    }
+    let validDefinitions = definitions;
+    const errors = [];
+    const typeMismatchResult = condense(validDefinitions, TypeMismatchError.is, (a, b) => a.expected.length === b.expected.length
+        && !a.expected.some(d => !b.expected.some(od => McdocType.equals(d, od))), errors => ({
+        kind: 'type_mismatch',
+        node: errors[0].node,
+        expected: deduplicateGroups(errors.map(e => e.expected), McdocType.equals),
+    }));
+    validDefinitions = typeMismatchResult.filteredDefinitions;
+    errors.push(...typeMismatchResult.condensedErrors);
+    for (const kind of [
+        'unknown_key',
+        'expected_key_value_pair',
+        'unknown_tuple_element',
+    ]) {
+        const simpleErrorResult = condense(validDefinitions, (e) => e.kind === kind, _ => true);
+        validDefinitions = simpleErrorResult.filteredDefinitions;
+        errors.push(...simpleErrorResult.condensedErrors);
+    }
+    const missingKeyResult = condense(validDefinitions, MissingKeyError.is, (a, b) => !a.keys.some(k => !b.keys.includes(k)), errors => ({
+        kind: 'missing_key',
+        node: errors[0].node,
+        keys: deduplicateGroups(errors.map(e => e.keys)),
+    }));
+    validDefinitions = missingKeyResult.filteredDefinitions;
+    errors.push(...missingKeyResult.condensedErrors);
+    for (const kind of [
+        'invalid_collection_length',
+        'invalid_string_length',
+        'number_out_of_range',
+    ]) {
+        const rangeErrorResult = condense(validDefinitions, (e) => e.kind === kind, (a, b) => a.ranges.length === b.ranges.length
+            && !a.ranges.some(r => !b.ranges.some(or => NumericRange.equals(r, or))), 
+        // TODO merge overlapping ranges better?
+        errors => ({
+            kind,
+            node: errors[0].node,
+            ranges: deduplicateGroups(errors.map(e => e.ranges), NumericRange.equals),
+        }));
+        validDefinitions = rangeErrorResult.filteredDefinitions;
+        errors.push(...rangeErrorResult.condensedErrors);
+    }
+    // No condensing needed for duplicate key. If a key is a duplicate in one definition, it really
+    // should have been reported by all of them
+    validDefinitions[0].errors.filter(e => e.kind === 'duplicate_key');
+    const internalErrorResult = condense(validDefinitions, (e) => e.kind === 'internal', _ => false);
+    validDefinitions = internalErrorResult.filteredDefinitions;
+    errors.push(...internalErrorResult.condensedErrors);
+    return {
+        definitions: validDefinitions.map(d => d.definition),
+        condensedErrors: errors,
+    };
+}
+function condense(validDefinitions, is, equals, combineAlternatives) {
+    // TODO a lot of O(n^2) in this function, may need optimization
+    const errorsOfType = validDefinitions
+        .map(def => ({ def, errors: def.errors.filter(is) }));
+    const definitionsWithoutError = errorsOfType
+        .filter(d => d.errors.length === 0)
+        .map(e => e.def);
+    if (definitionsWithoutError.length > 0) {
+        return { condensedErrors: [], filteredDefinitions: definitionsWithoutError };
+    }
+    const distinctErrorsPerNode = errorsOfType
+        .flatMap(d => d.errors.map(e => ({ definition: d.def, error: e })))
+        .reduce((entries, e) => {
+        const entry = entries.find(oe => oe.errors[0].error.node === e.error.node);
+        if (entry) {
+            const error = entry.errors.find(oe => equals(e.error, oe.error));
+            if (error) {
+                error.definitions.push(e.definition);
+            }
+            else {
+                entry.errors.push({ error: e.error, definitions: [e.definition] });
+            }
+        }
+        else {
+            entries.push({ errors: [{ error: e.error, definitions: [e.definition] }] });
+        }
+        return entries;
+    }, []);
+    const distinctErrors = distinctErrorsPerNode.flatMap(e => e.errors);
+    const commonErrors = distinctErrors
+        .filter(e => e.definitions.length == validDefinitions.length)
+        .map(e => e.error);
+    const definitionsWithUncommonErrors = distinctErrors
+        .filter(e => e.definitions.length < validDefinitions.length)
+        .flatMap(e => e.definitions);
+    const definitionsWithOnlyCommonErrors = validDefinitions
+        .filter(d => !definitionsWithUncommonErrors.includes(d));
+    if (definitionsWithOnlyCommonErrors.length > 0) {
+        return {
+            filteredDefinitions: definitionsWithOnlyCommonErrors,
+            condensedErrors: commonErrors,
+        };
+    }
+    const combinedErrors = combineAlternatives
+        ? distinctErrorsPerNode
+            .map(e => {
+            const uniqueDefinitions = deduplicateGroups(e.errors.map(e => e.definitions), (a, b) => McdocType.equals(a.definition.typeDef, b.definition.typeDef));
+            const ans = {
+                definitions: uniqueDefinitions,
+                error: combineAlternatives(e.errors
+                    .filter(e => !commonErrors.includes(e.error))
+                    .map(e => e.error)),
+            };
+            ans.error.nodesWithConflictingErrors = deduplicateGroups(e.errors.map(e => e.error.nodesWithConflictingErrors ?? []));
+            if (ans.error.nodesWithConflictingErrors.length === 0) {
+                ans.error.nodesWithConflictingErrors = undefined;
+            }
+            return ans;
+        })
+        : distinctErrorsPerNode.flatMap(e => e.errors
+            .map(ee => ({ definitions: ee.definitions, error: ee.error })));
+    const conflictingErrors = combinedErrors
+        .filter(e => e.definitions.length < validDefinitions.length);
+    const nodesWithConflictingErrors = conflictingErrors
+        .map(e => e.error.node)
+        .filter((n, i, arr) => arr.indexOf(n) === i);
+    for (const error of conflictingErrors) {
+        error.error.nodesWithConflictingErrors = nodesWithConflictingErrors;
+    }
+    return {
+        filteredDefinitions: validDefinitions,
+        condensedErrors: [...commonErrors, ...combinedErrors.map(e => e.error)],
+    };
+}
+/**
+ * Deduplicates groups assuming:
+ * - There are no duplicates within a group
+ * - A group with 1 element implies there is no duplicated group of length 1 with the same element
+ *
+ * When calling {@link condense}, if a group stems from an error, this should automatically be the
+ * case.
+ */
+function deduplicateGroups(definitionGroups, predicate) {
+    const definitions = [];
+    for (let i = 0; i < definitionGroups.length; i++) {
+        const group = definitionGroups[i];
+        if (group.length === 1) {
+            definitions.push(group[0]);
+            continue;
+        }
+        definitions.push(...group
+            .filter(v => !definitionGroups.some((og, oi) => (oi > i || og.length === 1)
+            && predicate
+            ? og.some(ov => predicate(v, ov))
+            : og.includes(v))));
+    }
+    return definitions;
+}
+export function getDefaultErrorRange(node, error) {
+    const { range } = node.originalNode;
+    if (error === 'missing_key' || error === 'invalid_collection_length') {
+        return { start: range.start, end: range.start + 1 };
+    }
+    return range;
+}
+export function getDefaultErrorReporter(ctx, getErrorRange) {
+    return (error) => {
+        const defaultTranslationKey = error.kind.replaceAll('_', '-');
+        let localizedText;
+        let severity = 3 /* ErrorSeverity.Error */;
+        switch (error.kind) {
+            case 'unknown_tuple_element':
+                localizedText = localize('expected', localize('nothing'));
+                break;
+            case 'unknown_key':
+                if (error.nodesWithConflictingErrors) {
+                    localizedText = localize('invalid-key-combination', arrayToMessage(error.nodesWithConflictingErrors.map(n => McdocType.toString(n.inferredType)), true, 'and'));
+                }
+                else {
+                    localizedText = localize(defaultTranslationKey, error.node.inferredType.kind === 'literal'
+                        ? localeQuote(error.node.inferredType.value.value.toString())
+                        : `<${localize(`mcdoc.type.${error.node.inferredType.kind}`)}>`);
+                    severity = 2 /* ErrorSeverity.Warning */;
+                }
+                break;
+            case 'missing_key':
+                if (error.keys.length === 1) {
+                    localizedText = localize(defaultTranslationKey, localeQuote(error.keys[0]));
+                }
+                else {
+                    localizedText = localize('mcdoc.runtime.checker.some-missing-keys', arrayToMessage(error.keys));
+                }
+                break;
+            case 'invalid_collection_length':
+            case 'invalid_string_length':
+            case 'number_out_of_range':
+                const baseKey = error.kind === 'invalid_collection_length'
+                    ? 'mcdoc.runtime.checker.range.collection'
+                    : error.kind === 'invalid_string_length'
+                        ? 'mcdoc.runtime.checker.range.string'
+                        : 'mcdoc.runtime.checker.range.number';
+                const rangeMessages = error.ranges.map(r => {
+                    const left = r.min !== undefined
+                        ? localize(RangeKind.isLeftExclusive(r.kind)
+                            ? 'mcdoc.runtime.checker.range.left-exclusive'
+                            : 'mcdoc.runtime.checker.range.left-inclusive', r.min)
+                        : undefined;
+                    const right = r.max !== undefined
+                        ? localize(RangeKind.isLeftExclusive(r.kind)
+                            ? 'mcdoc.runtime.checker.range.right-exclusive'
+                            : 'mcdoc.runtime.checker.range.right-inclusive', r.max)
+                        : undefined;
+                    if (left !== undefined && right !== undefined) {
+                        return localize('mcdoc.runtime.checker.range.concat', left, right);
+                    }
+                    return left ?? right;
+                }).filter(r => r !== undefined);
+                localizedText = localize('expected', localize(baseKey, arrayToMessage(rangeMessages, false)));
+                break;
+            case 'type_mismatch':
+                localizedText = localize('expected', arrayToMessage(error.expected.map(e => e.kind === 'enum'
+                    ? arrayToMessage(e.values.map(v => ResourceLocation.shorten(v.value.toString())))
+                    : e.kind === 'literal'
+                        ? localeQuote(e.value.value.toString())
+                        : localize(`mcdoc.type.${e.kind}`)), false));
+                break;
+            case 'expected_key_value_pair':
+                localizedText = localize(`mcdoc.runtime.checker.${defaultTranslationKey}`);
+                break;
+            case 'internal':
+                break;
+            default:
+                localizedText = localize(defaultTranslationKey);
+        }
+        ctx.err.report(localizedText, getErrorRange(error.node, error.kind), severity);
+    };
+}
+//# sourceMappingURL=error.js.map