@spyglassmc/mcdoc 0.3.7 → 0.3.9

package/lib/type/index.js

@@ -1,66 +1,298 @@
 import { Arrayable, Dev } from '@spyglassmc/core';
-import { localeQuote, localize } from '@spyglassmc/locales';
-import { getRangeDelimiter } from '../node/index.js';
-export const StaticIndexKeywords = Object.freeze([
-    'fallback',
-    'none',
-    'unknown',
-    'spawnitem',
-    'blockitem',
-]);
-export const EmptyUnion = Object.freeze({
-    kind: 'union',
-    members: [],
-});
+import { getRangeDelimiter, RangeKind } from '../node/index.js';
+export var Attributes;
+(function (Attributes) {
+    function equals(a, b) {
+        if (a?.length !== b?.length) {
+            return false;
+        }
+        if (!a || !b) {
+            return true;
+        }
+        for (let i = 0; i < a.length; i++) {
+            if (!Attribute.equals(a[i], b[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    Attributes.equals = equals;
+})(Attributes || (Attributes = {}));
+export var Attribute;
+(function (Attribute) {
+    function equals(a, b) {
+        if (a.name !== b.name) {
+            return false;
+        }
+        if (a.value && b.value) {
+            return AttributeValue.equals(a.value, b.value);
+        }
+        return a.value === b.value;
+    }
+    Attribute.equals = equals;
+})(Attribute || (Attribute = {}));
+export var AttributeValue;
+(function (AttributeValue) {
+    function equals(a, b) {
+        if (a.kind !== b.kind) {
+            return false;
+        }
+        if (a.kind === 'tree') {
+            if (Object.keys(a.values).length !== Object.keys(b.values).length) {
+                return false;
+            }
+            for (const kvp of Object.entries(a.values)) {
+                const other = b.values[kvp[0]];
+                if (!other) {
+                    return false;
+                }
+                if (!equals(kvp[1], other)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        else {
+            return McdocType.equals(a, b);
+        }
+    }
+    AttributeValue.equals = equals;
+})(AttributeValue || (AttributeValue = {}));
+export var NumericRange;
+(function (NumericRange) {
+    function isInRange(range, val) {
+        const { min = -Infinity, max = Infinity } = range;
+        if (RangeKind.isLeftExclusive(range.kind) ? val <= min : val < min) {
+            return false;
+        }
+        if (RangeKind.isRightExclusive(range.kind) ? val >= max : val > max) {
+            return false;
+        }
+        return true;
+    }
+    NumericRange.isInRange = isInRange;
+    function equals(a, b) {
+        return a.kind === b.kind
+            && a.min === b.min
+            && a.max === b.max;
+    }
+    NumericRange.equals = equals;
+    function intersect(a, b) {
+        const min = a.min !== undefined && b.min !== undefined
+            ? Math.max(a.min, b.min)
+            : a.min !== undefined
+                ? a.min
+                : b.min;
+        const max = a.max !== undefined && b.max !== undefined
+            ? Math.min(a.max, b.max)
+            : a.max !== undefined
+                ? a.max
+                : b.max;
+        let kind = 0b00;
+        if (min === a.min && RangeKind.isLeftExclusive(a.kind)) {
+            kind |= 0b10;
+        }
+        else if (min === b.min && RangeKind.isLeftExclusive(b.kind)) {
+            kind |= 0b10;
+        }
+        if (max === a.max && RangeKind.isRightExclusive(a.kind)) {
+            kind |= 0b01;
+        }
+        else if (max === b.max && RangeKind.isRightExclusive(b.kind)) {
+            kind |= 0b01;
+        }
+        return { kind: kind, min, max };
+    }
+    NumericRange.intersect = intersect;
+    function toString({ kind, min, max }) {
+        return min === max && kind === 0b00
+            ? min !== undefined ? `${min}` : getRangeDelimiter(kind)
+            : `${min ?? ''}${getRangeDelimiter(kind)}${max ?? ''}`;
+    }
+    NumericRange.toString = toString;
+})(NumericRange || (NumericRange = {}));
+export const StaticIndexKeywords = Object.freeze(['fallback', 'none', 'unknown', 'spawnitem', 'blockitem']);
+export var ParallelIndices;
+(function (ParallelIndices) {
+    function equals(a, b) {
+        if (a.length !== b.length) {
+            return false;
+        }
+        for (let i = 0; i < a.length; i++) {
+            const first = a[i];
+            const second = b[i];
+            if (first.kind !== second.kind) {
+                return false;
+            }
+            if (first.kind === 'static') {
+                return first.value !== second.value;
+            }
+            if (first.accessor.length !== second.accessor.length) {
+                return false;
+            }
+            for (let j = 0; j < first.accessor.length; j++) {
+                const firstAcc = first.accessor[j];
+                const secondAcc = second.accessor[j];
+                if (typeof firstAcc === 'string' || typeof secondAcc === 'string') {
+                    if (firstAcc !== secondAcc) {
+                        return false;
+                    }
+                }
+                else if (firstAcc.keyword !== secondAcc.keyword) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    ParallelIndices.equals = equals;
+})(ParallelIndices || (ParallelIndices = {}));
+export const EmptyUnion = Object.freeze({ kind: 'union', members: [] });
 export function createEmptyUnion(attributes) {
     return {
         ...EmptyUnion,
         // attributes,
     };
 }
-export const LiteralNumberSuffixes = Object.freeze([
-    'b',
-    's',
-    'l',
-    'f',
-    'd',
-]);
-export const LiteralNumberCaseInsensitiveSuffixes = Object.freeze([
-    ...LiteralNumberSuffixes,
-    'B',
-    'S',
-    'L',
-    'F',
-    'D',
-]);
-export const NumericTypeIntKinds = Object.freeze([
-    'byte',
-    'short',
-    'int',
-    'long',
-]);
+export const NumericTypeIntKinds = Object.freeze(['byte', 'short', 'int', 'long']);
 export const NumericTypeFloatKinds = Object.freeze(['float', 'double']);
-export const NumericTypeKinds = Object.freeze([
-    ...NumericTypeIntKinds,
-    ...NumericTypeFloatKinds,
-]);
-export const PrimitiveArrayValueKinds = Object.freeze([
-    'byte',
-    'int',
-    'long',
-]);
+export const NumericTypeKinds = Object.freeze([...NumericTypeIntKinds, ...NumericTypeFloatKinds]);
+export const PrimitiveArrayValueKinds = Object.freeze(['byte', 'int', 'long']);
 export const PrimitiveArrayKinds = Object.freeze(PrimitiveArrayValueKinds.map((kind) => `${kind}_array`));
 export var McdocType;
 (function (McdocType) {
+    function equals(a, b) {
+        if (a.kind !== b.kind) {
+            return false;
+        }
+        if (!Attributes.equals(a.attributes, b.attributes)) {
+            return false;
+        }
+        switch (a.kind) {
+            case 'literal':
+                return a.value.kind === b.value.kind
+                    && a.value.value === b.value.value;
+            case 'byte':
+            case 'short':
+            case 'int':
+            case 'long':
+            case 'float':
+            case 'double':
+                return a.valueRange === b.valueRange;
+            case 'string':
+                return a.lengthRange === b.lengthRange;
+            case 'byte_array':
+            case 'int_array':
+            case 'long_array':
+                return a.lengthRange === b.lengthRange
+                    && a.valueRange === b.valueRange;
+            case 'list':
+                return a.lengthRange === b.lengthRange
+                    && equals(a.item, b.item);
+            case 'tuple':
+                if (a.items.length !== b.items.length) {
+                    return false;
+                }
+                for (let i = 0; i < a.items.length; i++) {
+                    if (!equals(a.items[i], b.items[i])) {
+                        return false;
+                    }
+                }
+                return true;
+            case 'struct':
+                return a.fields.length === b.fields.length && !a.fields.some(f => {
+                    if (f.kind === 'pair') {
+                        return !b.fields.some(of => of.kind === 'pair'
+                            && f.optional === of.optional
+                            && f.deprecated === of.deprecated
+                            && Attributes.equals(f.attributes, of.attributes)
+                            && (typeof f.key === 'string' || typeof of.key === 'string'
+                                ? f.key === of.key
+                                : equals(f.key, of.key))
+                            && equals(f.type, of.type));
+                    }
+                    return !b.fields.some(of => of.kind === 'spread'
+                        && Attributes.equals(f.attributes, of.attributes)
+                        && equals(f.type, of.type));
+                });
+            case 'union':
+                if (a.members.length !== b.members.length) {
+                    return false;
+                }
+                for (let i = 0; i < a.members.length; i++) {
+                    if (!equals(a.members[i], b.members[i])) {
+                        return false;
+                    }
+                }
+                return true;
+            case 'enum':
+                if (a.enumKind !== b.enumKind
+                    || a.values.length !== b.values.length) {
+                    return false;
+                }
+                for (let i = 0; i < a.values.length; i++) {
+                    const first = a.values[i];
+                    const second = b.values[i];
+                    if (first.identifier !== second.identifier || first.value !== second.value
+                        || !Attributes.equals(first.attributes, second.attributes)) {
+                        return false;
+                    }
+                }
+                return true;
+            case 'reference':
+                return a.path === b.path;
+            case 'template':
+                if (a.typeParams.length !== b.typeParams.length) {
+                    return false;
+                }
+                for (let i = 0; i < a.typeParams.length; i++) {
+                    if (a.typeParams[i].path !== b.typeParams[i].path) {
+                        return false;
+                    }
+                }
+                return equals(a.child, b.child);
+            case 'concrete':
+                if (a.typeArgs.length !== b.typeArgs.length) {
+                    return false;
+                }
+                for (let i = 0; i < a.typeArgs.length; i++) {
+                    if (!equals(a.typeArgs[i], b.typeArgs[i])) {
+                        return false;
+                    }
+                }
+                return equals(a.child, b.child);
+            case 'indexed':
+                if (ParallelIndices.equals(a.parallelIndices, b.parallelIndices)) {
+                    return false;
+                }
+                return equals(a.child, b.child);
+            case 'dispatcher':
+                if (a.registry !== b.registry) {
+                    return false;
+                }
+                return ParallelIndices.equals(a.parallelIndices, b.parallelIndices);
+            case 'mapped':
+                if (Object.keys(a.mapping).length !== Object.keys(b.mapping).length) {
+                    return false;
+                }
+                for (const kvp of Object.entries(a.mapping)) {
+                    const other = b.mapping[kvp[0]];
+                    if (!other) {
+                        return false;
+                    }
+                    if (!equals(kvp[1], other)) {
+                        return false;
+                    }
+                }
+                return equals(a.child, b.child);
+            default:
+                return true;
+        }
+    }
+    McdocType.equals = equals;
     function toString(type) {
         const rangeToString = (range) => {
-            if (!range) {
-                return '';
-            }
-            const { kind, min, max } = range;
-            return min === max
-                ? ` @ ${min}`
-                : ` @ ${min ?? ''}${getRangeDelimiter(kind)}${max ?? ''}`;
+            return range ? ` @ ${NumericRange.toString(range)}` : '';
         };
         const indicesToString = (indices) => {
             const strings = [];
@@ -71,9 +303,7 @@ export var McdocType;
                 else {
                     strings.push(index.kind === 'static'
                         ? `[${index.value}]`
-                        : `[[${index.accessor
-                            .map((v) => (typeof v === 'string' ? v : v.keyword))
-                            .join('.')}]]`);
+                        : `[[${index.accessor.map((v) => (typeof v === 'string' ? v : v.keyword)).join('.')}]]`);
                 }
             }
             return `[${strings.join(', ')}]`;
@@ -81,405 +311,94 @@ export var McdocType;
         if (type === undefined) {
             return '<unknown>';
         }
+        let attributesString = '';
+        if (type.attributes?.length) {
+            for (const attribute of type.attributes) {
+                attributesString += `#[${attribute.name}${attribute.value ? '=<value ...>' : ''}] `;
+            }
+        }
+        let typeString;
         switch (type.kind) {
             case 'any':
             case 'boolean':
-                return type.kind;
-            case 'attributed':
-                return `#[${type.attribute.name}${type.attribute.value ? '=<value ...>' : ''}] ${toString(type.child)}`;
+                typeString = type.kind;
+                break;
             case 'byte':
-                return `byte${rangeToString(type.valueRange)}`;
+                typeString = `byte${rangeToString(type.valueRange)}`;
+                break;
             case 'byte_array':
-                return `byte${rangeToString(type.valueRange)}[]${rangeToString(type.lengthRange)}`;
+                typeString = `byte${rangeToString(type.valueRange)}[]${rangeToString(type.lengthRange)}`;
+                break;
             case 'concrete':
-                return `${toString(type.child)}${type.typeArgs.length
-                    ? `<${type.typeArgs.map(toString).join(', ')}>`
-                    : ''}`;
+                typeString = `${toString(type.child)}${type.typeArgs.length ? `<${type.typeArgs.map(toString).join(', ')}>` : ''}`;
+                break;
             case 'dispatcher':
-                return `${type.registry ?? 'spyglass:unknown'}[${indicesToString(type.parallelIndices)}]`;
+                typeString = `${type.registry ?? 'spyglass:unknown'}[${indicesToString(type.parallelIndices)}]`;
+                break;
             case 'double':
-                return `double${rangeToString(type.valueRange)}`;
+                typeString = `double${rangeToString(type.valueRange)}`;
+                break;
             case 'enum':
-                return '<enum ...>';
+                typeString = '<enum ...>';
+                break;
             case 'float':
-                return `float${rangeToString(type.valueRange)}`;
+                typeString = `float${rangeToString(type.valueRange)}`;
+                break;
             case 'indexed':
-                return `${toString(type.child)}${indicesToString(type.parallelIndices)}`;
+                typeString = `${toString(type.child)}${indicesToString(type.parallelIndices)}`;
+                break;
             case 'int':
-                return `int${rangeToString(type.valueRange)}`;
+                typeString = `int${rangeToString(type.valueRange)}`;
+                break;
             case 'int_array':
-                return `int${rangeToString(type.valueRange)}[]${rangeToString(type.lengthRange)}`;
+                typeString = `int${rangeToString(type.valueRange)}[]${rangeToString(type.lengthRange)}`;
+                break;
             case 'list':
-                return `[${toString(type.item)}]${rangeToString(type.lengthRange)}`;
+                typeString = `[${toString(type.item)}]${rangeToString(type.lengthRange)}`;
+                break;
             case 'literal':
-                return `${type.value}`;
+                typeString = `${type.value.value}`;
+                break;
             case 'long':
-                return `long${rangeToString(type.valueRange)}`;
+                typeString = `long${rangeToString(type.valueRange)}`;
+                break;
             case 'long_array':
-                return `long${rangeToString(type.valueRange)}[]${rangeToString(type.lengthRange)}`;
+                typeString = `long${rangeToString(type.valueRange)}[]${rangeToString(type.lengthRange)}`;
+                break;
+            case 'mapped':
+                typeString = toString(type.child);
+                break;
             case 'reference':
-                return type.path ?? '<unknown_reference>';
+                typeString = type.path ?? '<unknown_reference>';
+                break;
             case 'short':
-                return `short${rangeToString(type.valueRange)}`;
+                typeString = `short${rangeToString(type.valueRange)}`;
+                break;
             case 'string':
-                return `string${rangeToString(type.lengthRange)}`;
+                typeString = `string${rangeToString(type.lengthRange)}`;
+                break;
             case 'struct':
-                return '<struct ...>';
+                typeString = '<struct ...>';
+                break;
             case 'template':
-                return `${toString(type.child)}${type.typeParams.length
+                typeString = `${toString(type.child)}${type.typeParams.length
                     ? `<${type.typeParams.map((v) => `?${v.path}`).join(', ')}>`
                     : ''}`;
+                break;
             case 'tuple':
-                return `[${type.items.map((v) => toString(v)).join(',')}${type.items.length === 1 ? ',' : ''}]`;
+                typeString = `[${type.items.map((v) => toString(v)).join(',')}${type.items.length === 1 ? ',' : ''}]`;
+                break;
             case 'union':
-                return `(${type.members.map(toString).join(' | ')})`;
+                typeString = `(${type.members.map(toString).join(' | ')})`;
+                break;
             case 'unsafe':
-                return 'unsafe';
+                typeString = 'unsafe';
+                break;
             default:
-                return Dev.assertNever(type);
+                Dev.assertNever(type);
         }
+        return attributesString + typeString;
     }
     McdocType.toString = toString;
 })(McdocType || (McdocType = {}));
-var CheckResult;
-(function (CheckResult) {
-    CheckResult[CheckResult["Nah"] = 0] = "Nah";
-    CheckResult[CheckResult["Assignable"] = 1] = "Assignable";
-    CheckResult[CheckResult["StrictlyAssignable"] = 3] = "StrictlyAssignable";
-})(CheckResult || (CheckResult = {}));
-const areRangesMatch = (s, t) => {
-    if (!t) {
-        return true;
-    }
-    if (!s) {
-        return false;
-    }
-    const { min: sMin, max: sMax } = s;
-    const { min: tMin, max: tMax } = t;
-    return ((tMin === undefined || (sMin !== undefined && sMin >= tMin)) &&
-        (tMax === undefined || (sMax !== undefined && sMax <= tMax)));
-};
-export const flattenUnionType = (union) => {
-    const set = new Set();
-    const add = (data) => {
-        for (const existingMember of set) {
-            if ((check(data, existingMember) & CheckResult.StrictlyAssignable) ===
-                CheckResult.StrictlyAssignable) {
-                return;
-            }
-            if ((check(existingMember, data) & CheckResult.StrictlyAssignable) ===
-                CheckResult.StrictlyAssignable) {
-                set.delete(existingMember);
-            }
-        }
-        set.add(data);
-    };
-    for (const member of union.members) {
-        if (member.kind === 'union') {
-            flattenUnionType(member).members.forEach(add);
-        }
-        else {
-            add(member);
-        }
-    }
-    return {
-        kind: 'union',
-        members: [...set],
-    };
-};
-export const unionTypes = (a, b) => {
-    if ((check(a, b) & CheckResult.StrictlyAssignable) ===
-        CheckResult.StrictlyAssignable) {
-        return b;
-    }
-    if ((check(b, a) & CheckResult.StrictlyAssignable) ===
-        CheckResult.StrictlyAssignable) {
-        return a;
-    }
-    const ans = {
-        kind: 'union',
-        members: [
-            ...(a.kind === 'union' ? a.members : [a]),
-            ...(b.kind === 'union' ? b.members : [b]),
-        ],
-    };
-    return ans;
-};
-export const simplifyUnionType = (union) => {
-    union = flattenUnionType(union);
-    if (union.members.length === 1) {
-        return union.members[0];
-    }
-    return union;
-};
-export const simplifyListType = (list) => ({
-    kind: 'list',
-    item: simplifyType(list.item),
-    ...(list.lengthRange ? { lengthRange: { ...list.lengthRange } } : {}),
-});
-export const simplifyType = (data) => {
-    if (data.kind === 'union') {
-        data = simplifyUnionType(data);
-    }
-    else if (data.kind === 'list') {
-        data = simplifyListType(data);
-    }
-    return data;
-};
-const check = (s, t, errors = []) => {
-    const strictlyAssignableIfTrue = (value) => value ? CheckResult.StrictlyAssignable : CheckResult.Nah;
-    const assignableIfTrue = (value) => value ? CheckResult.Assignable : CheckResult.Nah;
-    let ans;
-    s = simplifyType(s);
-    t = simplifyType(t);
-    if (s.kind === 'any' || s.kind === 'reference' || t.kind === 'reference') {
-        // Reference types are treated as any for now.
-        ans = CheckResult.Assignable;
-    }
-    else if (t.kind === 'any') {
-        ans = CheckResult.StrictlyAssignable;
-    }
-    else if (s.kind === 'union') {
-        ans = assignableIfTrue(s.members.every((v) => check(v, t, errors)));
-    }
-    else if (t.kind === 'union') {
-        ans = assignableIfTrue(t.members.some((v) => check(s, v)));
-    }
-    else if (s.kind === 'boolean') {
-        ans = strictlyAssignableIfTrue(t.kind === 'boolean' || t.kind === 'byte');
-    }
-    else if (s.kind === 'byte') {
-        if (t.kind === 'boolean') {
-            ans = check(s, { kind: 'byte', valueRange: { kind: 0b00, min: 0, max: 1 } }, errors);
-        }
-        else if (t.kind === 'byte') {
-            ans = strictlyAssignableIfTrue(areRangesMatch(s.valueRange, t.valueRange));
-        }
-        else if (t.kind === 'enum') {
-            ans = assignableIfTrue(!t.enumKind || t.enumKind === 'byte');
-        }
-        else {
-            ans = CheckResult.Nah;
-        }
-    }
-    else if (s.kind === 'byte_array' ||
-        s.kind === 'int_array' ||
-        s.kind === 'long_array') {
-        ans = strictlyAssignableIfTrue(t.kind === s.kind &&
-            areRangesMatch(s.lengthRange, t.lengthRange) &&
-            areRangesMatch(s.valueRange, t.valueRange));
-    }
-    else if (s.kind === 'struct' || s.kind === 'dispatcher') {
-        ans = assignableIfTrue(t.kind === 'struct' || t.kind === 'dispatcher');
-    }
-    else if (s.kind === 'enum') {
-        ans = assignableIfTrue((t.kind === 'byte' ||
-            t.kind === 'float' ||
-            t.kind === 'double' ||
-            t.kind === 'int' ||
-            t.kind === 'long' ||
-            t.kind === 'short' ||
-            t.kind === 'string') &&
-            (!s.enumKind || s.enumKind === t.kind));
-    }
-    else if (s.kind === 'float' ||
-        s.kind === 'double' ||
-        s.kind === 'int' ||
-        s.kind === 'long' ||
-        s.kind === 'short') {
-        if (t.kind === s.kind) {
-            ans = strictlyAssignableIfTrue(areRangesMatch(s.valueRange, t.valueRange));
-        }
-        else if (t.kind === 'enum') {
-            ans = assignableIfTrue(!t.enumKind || t.enumKind === s.kind);
-        }
-        else {
-            ans = CheckResult.Nah;
-        }
-    }
-    else if (s.kind === 'list') {
-        if (t.kind === 'list' && areRangesMatch(s.lengthRange, t.lengthRange)) {
-            ans = check(s.item, t.item, errors);
-        }
-        else {
-            ans = CheckResult.Nah;
-        }
-    }
-    else if (s.kind === 'string') {
-        if (t.kind === 'string') {
-            ans = CheckResult.StrictlyAssignable;
-        }
-        else {
-            ans = assignableIfTrue(t.kind === 'enum' && (!t.enumKind || t.enumKind === 'string'));
-        }
-    }
-    else {
-        ans = CheckResult.Nah;
-    }
-    if (!ans) {
-        errors.push(localize('mcdoc.checker.type-not-assignable', localeQuote(McdocType.toString(s)), localeQuote(McdocType.toString(t))));
-    }
-    return ans;
-};
-export const checkAssignability = ({ source, target, }) => {
-    if (source === undefined || target === undefined) {
-        return { isAssignable: true };
-    }
-    const errors = [];
-    check(source, target, errors);
-    return {
-        isAssignable: errors.length === 0,
-        ...(errors.length
-            ? {
-                errorMessage: errors
-                    .reverse()
-                    .map((m, i) => `${'  '.repeat(i)}${m}`)
-                    .join('\n'),
-            }
-            : {}),
-    };
-};
-export function resolveType(inputType, ctx, value) {
-    const type = getTangibleType(inputType, ctx, value);
-    const ans = (() => {
-        if (type.kind === 'union') {
-            return {
-                kind: 'union',
-                members: type.members.map((t) => resolveType(t, ctx, value)),
-                // attributes: type.attributes,
-            };
-        }
-        else {
-            return {
-                ...type,
-                indices: undefined,
-            };
-        }
-    })();
-    // for (const parallelIndices of type.indices ?? []) {
-    // 	ans = navigateParallelIndices(ans, parallelIndices, ctx, value)
-    // }
-    return ans;
-}
-function dispatchType(type, ctx) {
-    throw '// TODO';
-}
-function dereferenceType(type, ctx) {
-    throw '// TODO';
-}
-function getTangibleType(type, ctx, value) {
-    let ans;
-    if (type.kind === 'dispatcher') {
-        const dispatchedType = dispatchType(type, ctx);
-        return getTangibleType(dispatchedType, ctx, value);
-    }
-    else if (type.kind === 'reference') {
-        const dereferencedType = dereferenceType(type, ctx);
-        return getTangibleType(dereferencedType, ctx, value);
-    }
-    else if (type.kind === 'union') {
-        ans = mapUnion(type, (t) => getTangibleType(t, ctx, value));
-    }
-    else {
-        ans = type;
-    }
-    return ans;
-}
-function navigateParallelIndices(type, indices, ctx, value) {
-    if (indices.length === 1) {
-        return navigateIndex(type, indices[0], ctx, value);
-    }
-    else {
-        return {
-            kind: 'union',
-            members: indices.map((i) => navigateIndex(type, i, ctx, value)),
-            // attributes: type.attributes,
-        };
-    }
-}
-function navigateIndex(type, index, ctx, value) {
-    if (type.kind === 'struct') {
-        const key = index.kind === 'static'
-            ? typeof index.value === 'string'
-                ? index.value
-                : undefined // Special static indices have no meaning on structs.
-            : resolveDynamicIndex(index, value);
-        if (key === undefined) {
-            // return createEmptyUnion(type.attributes)
-            return createEmptyUnion();
-        }
-        const flatStruct = flattenStruct(type, ctx, value);
-        return resolveType(flatStruct.fields[key], ctx, value);
-    }
-    else if (type.kind === 'union') {
-        return mapUnion(type, (t) => navigateIndex(t, index, ctx, value));
-    }
-    else {
-        // return createEmptyUnion(type.attributes)
-        return createEmptyUnion();
-    }
-}
-function resolveDynamicIndex(index, value) {
-    for (const key of index.accessor) {
-        if (value === undefined) {
-            break;
-        }
-        if (typeof key === 'string') {
-            value = value.getValue(key);
-        }
-        else if (key.keyword === 'key') {
-            value = value.getKeyOnParent();
-        }
-        else if (key.keyword === 'parent') {
-            value = value.getParent();
-        }
-    }
-    return value?.asString();
-}
-function mapUnion(type, mapper) {
-    const ans = {
-        kind: 'union',
-        members: type.members.map(mapper),
-        // attributes: type.attributes,
-        // indices: type.indices,
-    };
-    return ans;
-}
-function flattenStruct(type, ctx, value) {
-    const ans = {
-        kind: 'flat_struct',
-        fields: Object.create(null),
-        // attributes: type.attributes,
-        // indices: type.indices,
-    };
-    for (const field of type.fields) {
-        if (field.kind === 'spread') {
-            const target = resolveType(field.type, ctx, value);
-            // addAttributes(ans, ...target.attributes ?? [])
-            if (target.kind === 'struct') {
-                const flatTarget = flattenStruct(target, ctx, value);
-                for (const [key, value] of Object.entries(flatTarget)) {
-                    ans.fields[key] = value;
-                }
-            }
-        }
-        else {
-            if (typeof field.key === 'string') {
-                ans.fields[field.key] = field.type;
-            }
-            else {
-                // TODO: Handle map keys
-            }
-        }
-    }
-    return ans;
-}
-function addAttributes(type, ...attributes) {
-    for (const attr of attributes) {
-        // type.attributes ??= []
-        // if (!type.attributes.some(a => a.name === attr.name)) {
-        // 	type.attributes.push(attr)
-        // }
-    }
-}
 //# sourceMappingURL=index.js.map