@spyglassmc/core 0.4.0 → 0.4.1

package/lib/parser/string.js

@@ -22,7 +22,9 @@ export function string(options) {
                     const cStart = src.cursor;
                     src.skip();
                     const c2 = src.read();
-                    if (c2 === '\\' || c2 === currentQuote || EscapeChar.is(options.escapable.characters, c2)) {
+                    if (c2 === '\\' ||
+                        c2 === currentQuote ||
+                        EscapeChar.is(options.escapable.characters, c2)) {
                         ans.valueMap.push({
                             inner: Range.create(ans.value.length, ans.value.length + 1),
                             outer: Range.create(cStart, src),
@@ -73,7 +75,8 @@ export function string(options) {
             start = contentStart;
         }
         else if (options.unquotable) {
-            while (src.canRead() && isAllowedCharacter(src.peek(), options.unquotable)) {
+            while (src.canRead() &&
+                isAllowedCharacter(src.peek(), options.unquotable)) {
                 ans.value += src.read();
             }
             if (!ans.value && !options.unquotable.allowEmpty) {
@@ -105,14 +108,79 @@ export function parseStringValue(parser, value, map, ctx) {
     return parser(valueSrc, valueCtx);
 }
 export const BrigadierUnquotableCharacters = Object.freeze([
-    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
-    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
-    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
-    '_', '.', '+', '-',
+    '0',
+    '1',
+    '2',
+    '3',
+    '4',
+    '5',
+    '6',
+    '7',
+    '8',
+    '9',
+    'A',
+    'B',
+    'C',
+    'D',
+    'E',
+    'F',
+    'G',
+    'H',
+    'I',
+    'J',
+    'K',
+    'L',
+    'M',
+    'N',
+    'O',
+    'P',
+    'Q',
+    'R',
+    'S',
+    'T',
+    'U',
+    'V',
+    'W',
+    'X',
+    'Y',
+    'Z',
+    'a',
+    'b',
+    'c',
+    'd',
+    'e',
+    'f',
+    'g',
+    'h',
+    'i',
+    'j',
+    'k',
+    'l',
+    'm',
+    'n',
+    'o',
+    'p',
+    'q',
+    'r',
+    's',
+    't',
+    'u',
+    'v',
+    'w',
+    'x',
+    'y',
+    'z',
+    '_',
+    '.',
+    '+',
+    '-',
 ]);
 export const BrigadierUnquotableCharacterSet = new Set(BrigadierUnquotableCharacters);
 export const BrigadierUnquotablePattern = /^[0-9A-Za-z_\.\+\-]*$/;
-export const BrigadierUnquotableOption = { allowEmpty: true, allowList: BrigadierUnquotableCharacterSet };
+export const BrigadierUnquotableOption = {
+    allowEmpty: true,
+    allowList: BrigadierUnquotableCharacterSet,
+};
 export const BrigadierStringOptions = {
     escapable: {},
     quotes: ['"', "'"],

package/lib/parser/util.js

@@ -84,7 +84,8 @@ export function any(parsers, out) {
         const results = parsers
             .map((parser, i) => ({ attempt: attempt(parser, src, ctx), index: i }))
             .filter(({ attempt }) => attempt.result !== Failure)
-            .sort((a, b) => (b.attempt.endCursor - a.attempt.endCursor) || (a.attempt.errorAmount - b.attempt.errorAmount));
+            .sort((a, b) => b.attempt.endCursor - a.attempt.endCursor ||
+            a.attempt.errorAmount - b.attempt.errorAmount);
         if (results.length === 0) {
             if (out) {
                 out.index = -1;
@@ -151,7 +152,10 @@ export function recover(parser, defaultValue) {
 export function select(cases) {
     return (src, ctx) => {
         for (const { predicate, prefix, parser, regex } of cases) {
-            if (predicate?.(src) ?? (prefix !== undefined ? src.tryPeek(prefix) : undefined) ?? (regex && src.matchPattern(regex)) ?? true) {
+            if (predicate?.(src) ??
+                (prefix !== undefined ? src.tryPeek(prefix) : undefined) ??
+                (regex && src.matchPattern(regex)) ??
+                true) {
                 const callableParser = typeof parser === 'object' ? parser.get() : parser;
                 return callableParser(src, ctx);
             }
@@ -170,7 +174,7 @@ export function map(parser, fn) {
     };
 }
 export function setType(type, parser) {
-    return map(parser, res => {
+    return map(parser, (res) => {
         const { type: _type, ...restResult } = res;
         const ans = {
             type,

package/lib/processor/ColorInfoProvider.js

@@ -119,19 +119,32 @@ export var ColorPresentation;
         const round = (num) => parseFloat(num.toFixed(3));
         switch (format) {
             case ColorFormat.DecRGBA:
-                return color.map(c => round(c)).join(' ');
+                return color.map((c) => round(c)).join(' ');
             case ColorFormat.DecRGB:
-                return color.slice(0, 3).map(c => round(c)).join(' ');
+                return color
+                    .slice(0, 3)
+                    .map((c) => round(c))
+                    .join(' ');
             case ColorFormat.IntRGBA:
-                return color.map(c => Math.round(c * 255)).join(' ');
+                return color.map((c) => Math.round(c * 255)).join(' ');
             case ColorFormat.IntRGB:
-                return color.slice(0, 3).map(c => Math.round(c * 255)).join(' ');
+                return color
+                    .slice(0, 3)
+                    .map((c) => Math.round(c * 255))
+                    .join(' ');
             case ColorFormat.HexRGBA:
-                return `#${Math.round((color[0] * 255 << 24) + (color[1] * 255 << 16) + (color[2] * 255) << 8 + color[3] * 255).toString(16).padStart(8, '0')}`;
+                return `#${Math.round((((color[0] * 255) << 24) +
+                    ((color[1] * 255) << 16) +
+                    color[2] * 255) <<
+                    (8 + color[3] * 255))
+                    .toString(16)
+                    .padStart(8, '0')}`;
             case ColorFormat.HexRGB:
-                return `#${Math.round((color[0] * 255 << 16) + (color[1] * 255 << 8) + color[2] * 255).toString(16).padStart(6, '0')}`;
+                return `#${Math.round(((color[0] * 255) << 16) + ((color[1] * 255) << 8) + color[2] * 255)
+                    .toString(16)
+                    .padStart(6, '0')}`;
             case ColorFormat.CompositeInt:
-                return `${Math.round((color[0] * 255 << 16) + (color[1] * 255 << 8) + color[2] * 255)}`;
+                return `${Math.round(((color[0] * 255) << 16) + ((color[1] * 255) << 8) + color[2] * 255)}`;
         }
     }
 })(ColorPresentation || (ColorPresentation = {}));

package/lib/processor/binder/builtin.js

@@ -13,7 +13,7 @@ export function attempt(binder, node, ctx) {
     const processAfterBinder = () => {
         StateProxy.undoChanges(node);
         const totalErrorSpan = tempCtx.err.errors
-            .map(e => e.range.end - e.range.start)
+            .map((e) => e.range.end - e.range.start)
             .reduce((a, b) => a + b, 0);
         return {
             errorAmount: tempCtx.err.errors.length,
@@ -44,15 +44,14 @@ export function any(binders) {
     if (binders.every(SyncBinder.is)) {
         return SyncBinder.create((node, ctx) => {
             const attempts = binders
-                .map(binder => attempt(binder, node, ctx))
+                .map((binder) => attempt(binder, node, ctx))
                 .sort(attemptSorter);
             attempts[0].updateNodeAndCtx();
         });
     }
     else {
         return AsyncBinder.create(async (node, ctx) => {
-            const attempts = (await Promise.all(binders.map(binder => attempt(binder, node, ctx))))
-                .sort(attemptSorter);
+            const attempts = (await Promise.all(binders.map((binder) => attempt(binder, node, ctx)))).sort(attemptSorter);
             attempts[0].updateNodeAndCtx();
         });
     }
@@ -66,7 +65,7 @@ export const noop = SyncBinder.create(() => { });
  */
 export const fallback = AsyncBinder.create(async (node, ctx) => {
     const promises = [];
-    traversePreOrder(node, node => !ctx.meta.hasBinder(node.type), node => ctx.meta.hasBinder(node.type), node => {
+    traversePreOrder(node, (node) => !ctx.meta.hasBinder(node.type), (node) => ctx.meta.hasBinder(node.type), (node) => {
         const binder = ctx.meta.getBinder(node.type);
         const result = binder(node, ctx);
         if (result instanceof Promise) {
@@ -84,18 +83,23 @@ export const dispatchSync = SyncBinder.create((node, ctx) => {
     }
 });
 export const resourceLocation = SyncBinder.create((node, ctx) => {
+    const raw = ResourceLocationNode.toString(node, 'full');
+    const sanitizedRaw = ResourceLocation.lengthen(node.options.namespacePathSep === '.'
+        ? raw.replace(/\./g, ResourceLocation.NamespacePathSep)
+        : raw);
     if (node.options.category) {
-        const raw = ResourceLocationNode.toString(node, 'full');
-        const sanitizedRaw = ResourceLocation.lengthen(node.options.namespacePathSep === '.'
-            ? raw.replace('.', ResourceLocation.NamespacePathSep)
-            : raw);
         ctx.symbols
             .query(ctx.doc, node.isTag ? `tag/${node.options.category}` : node.options.category, sanitizedRaw)
-            .enter({ usage: { type: node.options.usageType, node, accessType: node.options.accessType } });
+            .enter({
+            usage: {
+                type: node.options.usageType,
+                node,
+                accessType: node.options.accessType,
+            },
+        });
     }
-    const full = ResourceLocationNode.toString(node, 'full');
-    if (node.options.pool) {
-        if (!node.options.pool.includes(full)) {
+    if (node.options.pool && !node.options.allowUnknown) {
+        if (!node.options.pool.includes(sanitizedRaw)) {
             ctx.err.report(localize('expected', node.options.pool), node, 3 /* ErrorSeverity.Error */);
         }
         return;
@@ -103,10 +107,16 @@ export const resourceLocation = SyncBinder.create((node, ctx) => {
 });
 export const symbol = SyncBinder.create((node, ctx) => {
     if (node.value) {
-        const path = node.options.parentPath ? [...node.options.parentPath, node.value] : [node.value];
-        ctx.symbols
-            .query(ctx.doc, node.options.category, ...path)
-            .enter({ usage: { type: node.options.usageType, node: node, accessType: node.options.accessType } });
+        const path = node.options.parentPath
+            ? [...node.options.parentPath, node.value]
+            : [node.value];
+        ctx.symbols.query(ctx.doc, node.options.category, ...path).enter({
+            usage: {
+                type: node.options.usageType,
+                node: node,
+                accessType: node.options.accessType,
+            },
+        });
     }
 });
 export function registerBinders(meta) {

package/lib/processor/checker/builtin.d.ts

@@ -1,5 +1,4 @@
-import type { AstNode, SymbolBaseNode } from '../../node/index.js';
-import { ResourceLocationNode } from '../../node/index.js';
+import type { AstNode, ResourceLocationNode, SymbolBaseNode } from '../../node/index.js';
 import type { CheckerContext, MetaRegistry } from '../../service/index.js';
 import type { Checker, SyncChecker } from './Checker.js';
 export declare type AttemptResult = {

package/lib/processor/checker/builtin.js

@@ -1,6 +1,4 @@
-import { localize } from '@spyglassmc/locales';
 import { StateProxy } from '../../common/index.js';
-import { ResourceLocationNode } from '../../node/index.js';
 import { ErrorReporter } from '../../service/index.js';
 import { traversePreOrder } from '../util.js';
 export function attempt(checker, node, ctx) {
@@ -13,7 +11,7 @@ export function attempt(checker, node, ctx) {
     checker(node, tempCtx);
     StateProxy.undoChanges(node);
     const totalErrorSpan = tempCtx.err.errors
-        .map(e => e.range.end - e.range.start)
+        .map((e) => e.range.end - e.range.start)
         .reduce((a, b) => a + b, 0);
     return {
         errorAmount: tempCtx.err.errors.length,
@@ -31,7 +29,7 @@ export function any(checkers) {
     }
     return (node, ctx) => {
         const attempts = checkers
-            .map(checker => attempt(checker, node, ctx))
+            .map((checker) => attempt(checker, node, ctx))
             .sort((a, b) => a.errorAmount - b.errorAmount || a.totalErrorSpan - b.totalErrorSpan);
         attempts[0].updateNodeAndCtx();
     };
@@ -45,7 +43,7 @@ export const noop = () => { };
  */
 export const fallback = async (node, ctx) => {
     const promises = [];
-    traversePreOrder(node, node => !ctx.meta.hasChecker(node.type), node => ctx.meta.hasChecker(node.type), node => {
+    traversePreOrder(node, (node) => !ctx.meta.hasChecker(node.type), (node) => ctx.meta.hasChecker(node.type), (node) => {
         const checker = ctx.meta.getChecker(node.type);
         const result = checker(node, ctx);
         if (result instanceof Promise) {
@@ -63,13 +61,13 @@ export const dispatchSync = (node, ctx) => {
     }
 };
 export const resourceLocation = (node, ctx) => {
-    const full = ResourceLocationNode.toString(node, 'full');
-    if (node.options.pool) {
-        if (!node.options.pool.includes(full)) {
-            ctx.err.report(localize('expected', node.options.pool), node, 3 /* ErrorSeverity.Error */);
-        }
-        return;
-    }
+    // const full = ResourceLocationNode.toString(node, 'full')
+    // if (node.options.pool) {
+    // 	if (!node.options.pool.includes(full)) {
+    // 		ctx.err.report(localize('expected', node.options.pool), node, ErrorSeverity.Error)
+    // 	}
+    // 	return
+    // }
 };
 export const symbol = (_node, _ctx) => {
     // TODO

package/lib/processor/colorizer/builtin.js

@@ -6,27 +6,28 @@ import { ColorToken } from './Colorizer.js';
  */
 export const fallback = (node, ctx) => {
     const ans = [];
-    traversePreOrder(node, node => !ctx.meta.hasColorizer(node.type) && (!ctx.range || Range.intersects(node.range, ctx.range)), node => ctx.meta.hasColorizer(node.type), node => {
+    traversePreOrder(node, (node) => !ctx.meta.hasColorizer(node.type) &&
+        (!ctx.range || Range.intersects(node.range, ctx.range)), (node) => ctx.meta.hasColorizer(node.type), (node) => {
         const colorizer = ctx.meta.getColorizer(node.type);
         const result = colorizer(node, ctx);
         ans.push(...result);
     });
     return Object.freeze(ans);
 };
-export const boolean = node => {
+export const boolean = (node) => {
     return [ColorToken.create(node, 'literal')];
 };
-export const comment = node => {
+export const comment = (node) => {
     return [ColorToken.create(node, 'comment')];
 };
-export const error = node => {
+export const error = (node) => {
     // return [ColorToken.create(node, 'error')]
     return [];
 };
-export const literal = node => {
+export const literal = (node) => {
     return [ColorToken.create(node, node.options.colorTokenType ?? 'literal')];
 };
-export const number = node => {
+export const number = (node) => {
     return [ColorToken.create(node, 'number')];
 };
 export const resourceLocation = (node, _ctx) => {
@@ -53,7 +54,7 @@ export const string = (node, ctx) => {
         return [ColorToken.create(node, node.options.colorTokenType ?? 'string')];
     }
 };
-export const symbol = node => {
+export const symbol = (node) => {
     // TODO: Set the modifiers according to `node.symbol`.
     return [ColorToken.create(node, 'variable')];
 };

package/lib/processor/completer/Completer.js

@@ -17,7 +17,7 @@ export var CompletionItem;
             ...other,
             label,
             range: Range.get(range),
-            ...shouldEscape ? { insertText: escape(label) } : {},
+            ...(shouldEscape ? { insertText: escape(label) } : {}),
         };
     }
     CompletionItem.create = create;
@@ -51,7 +51,9 @@ export class InsertTextBuilder {
             this.#ans += `$\{${this.#nextPlaceholder}:${CompletionItem.escape(defaultValues[0])}}`;
         }
         else {
-            this.#ans += `$\{${this.#nextPlaceholder}|${defaultValues.map(v => v.replace(/([\\$},|])/g, '\\$1')).join(',')}|}`;
+            this.#ans += `$\{${this.#nextPlaceholder}|${defaultValues
+                .map((v) => v.replace(/([\\$},|])/g, '\\$1'))
+                .join(',')}|}`;
         }
         this.#nextPlaceholder += 1;
         return this;

package/lib/processor/completer/builtin.js

@@ -12,11 +12,9 @@ export const dispatch = (node, ctx) => {
         node: node,
         needle: ctx.offset,
         endInclusive: true,
-        predicate: n => ctx.meta.hasCompleter(n.type),
+        predicate: (n) => ctx.meta.hasCompleter(n.type),
     });
-    return child
-        ? ctx.meta.getCompleter(child.type)(child, ctx)
-        : [];
+    return child ? ctx.meta.getCompleter(child.type)(child, ctx) : [];
 };
 export const fallback = dispatch;
 export const boolean = (node, ctx) => {
@@ -32,7 +30,7 @@ export const file = (node, ctx) => {
     const completer = ctx.meta.getCompleterForLanguageID(ctx.doc.languageId);
     return completer(node.children[0], ctx);
 };
-export const literal = node => {
+export const literal = (node) => {
     const kind = new Map([
         ['enum', 13 /* CompletionKind.Enum */],
         ['enumMember', 20 /* CompletionKind.EnumMember */],
@@ -45,7 +43,7 @@ export const literal = node => {
         ['resourceLocation', 17 /* CompletionKind.File */],
         ['variable', 6 /* CompletionKind.Variable */],
     ]).get(node.options.colorTokenType ?? 'keyword') ?? 14 /* CompletionKind.Keyword */;
-    return node.options.pool.map(v => CompletionItem.create(v, node, { kind })) ?? [];
+    return (node.options.pool.map((v) => CompletionItem.create(v, node, { kind })) ?? []);
 };
 export const noop = () => [];
 export function record(o) {
@@ -57,12 +55,12 @@ export function record(o) {
         const completePairs = (pair) => o.key(node, pair, ctx, pair ?? ctx.offset, true, hasNextPair || !!pair?.end, existingKeys);
         const existingKeys = node.children
             .filter((n) => !!n.key)
-            .map(n => n.key);
+            .map((n) => n.key);
         const index = binarySearch(node.children, ctx.offset, (n, o) => n.end
             ? Range.compareOffset(Range.translate(n, 0, -1), o, true)
             : Range.compareOffset(n.range, o, true));
         const pair = index >= 0 ? node.children[index] : undefined;
-        const hasNextPair = !!node.children.find(n => n.range.start > ctx.offset);
+        const hasNextPair = !!node.children.find((n) => n.range.start > ctx.offset);
         if (!pair) {
             return completePairs(undefined);
         }
@@ -70,14 +68,18 @@ export function record(o) {
         if (!key && !sep && !value) {
             return completePairs(undefined);
         }
-        if ((key && Range.contains(key, ctx.offset, true)) || (sep && ctx.offset <= sep.start) || (value && ctx.offset < value.range.start)) {
+        if ((key && Range.contains(key, ctx.offset, true)) ||
+            (sep && ctx.offset <= sep.start) ||
+            (value && ctx.offset < value.range.start)) {
             // Selected key.
             if (!value || Range.isEmpty(value.range)) {
                 return completePairs(pair);
             }
             return completeKeys(pair);
         }
-        if ((value && Range.contains(value, ctx.offset, true)) || (sep && ctx.offset >= sep.end) || (key && ctx.offset > key.range.end)) {
+        if ((value && Range.contains(value, ctx.offset, true)) ||
+            (sep && ctx.offset >= sep.end) ||
+            (key && ctx.offset > key.range.end)) {
             // Selected value.
             return o.value(node, pair, ctx);
         }
@@ -104,12 +106,16 @@ export const resourceLocation = (node, ctx) => {
         }
         const ans = [
             ...otherIds,
-            ...includeDefaultNamespace ? defaultNsIds : [],
-            ...excludeDefaultNamespace ? defaultNsIds.map(id => id.slice(defaultNsPrefix.length)) : [],
-            ...includeEmptyNamespace ? defaultNsIds.map(id => id.slice(ResourceLocation.DefaultNamespace.length)) : [],
+            ...(includeDefaultNamespace ? defaultNsIds : []),
+            ...(excludeDefaultNamespace
+                ? defaultNsIds.map((id) => id.slice(defaultNsPrefix.length))
+                : []),
+            ...(includeEmptyNamespace
+                ? defaultNsIds.map((id) => id.slice(ResourceLocation.DefaultNamespace.length))
+                : []),
         ];
         if (node.options.namespacePathSep === '.') {
-            return ans.map(v => v.replace(ResourceLocation.NamespacePathSep, '.'));
+            return ans.map((v) => v.replace(ResourceLocation.NamespacePathSep, '.'));
         }
         return ans;
     };
@@ -117,12 +123,11 @@ export const resourceLocation = (node, ctx) => {
         ? optimizePool(node.options.pool)
         : [
             ...getPool(node.options.category),
-            ...node.options.allowTag
-                ? getPool(`tag/${node.options.category}`)
-                    .map(v => `${ResourceLocation.TagPrefix}${v}`)
-                : [],
+            ...(node.options.allowTag
+                ? getPool(`tag/${node.options.category}`).map((v) => `${ResourceLocation.TagPrefix}${v}`)
+                : []),
         ];
-    return pool.map(v => CompletionItem.create(v, node, { kind: 3 /* CompletionKind.Function */ }));
+    return pool.map((v) => CompletionItem.create(v, node, { kind: 3 /* CompletionKind.Function */ }));
 };
 export const string = (node, ctx) => {
     if (node.children?.length) {
@@ -130,7 +135,7 @@ export const string = (node, ctx) => {
         return dispatch(node.children[0], ctx);
     }
     if (node.options.quotes && node.value === '') {
-        return node.options.quotes.map(q => CompletionItem.create(`${q}${q}`, node, {
+        return node.options.quotes.map((q) => CompletionItem.create(`${q}${q}`, node, {
             insertText: `${q}$1${q}`,
             kind: 12 /* CompletionKind.Value */,
         }));
@@ -138,9 +143,7 @@ export const string = (node, ctx) => {
     return [];
 };
 export const symbol = (node, ctx) => {
-    return Object
-        .keys(ctx.symbols.query(ctx.doc, node.options.category, ...node.options.parentPath ?? []).visibleMembers)
-        .map(v => CompletionItem.create(v, node, { kind: 6 /* CompletionKind.Variable */ }));
+    return Object.keys(ctx.symbols.query(ctx.doc, node.options.category, ...(node.options.parentPath ?? [])).visibleMembers).map((v) => CompletionItem.create(v, node, { kind: 6 /* CompletionKind.Variable */ }));
 };
 export function registerCompleters(meta) {
     meta.registerCompleter('boolean', boolean);

package/lib/processor/formatter/builtin.js

@@ -1,34 +1,36 @@
 import { ResourceLocationNode } from '../../node/index.js';
-export const fallback = node => {
+export const fallback = (node) => {
     throw new Error(`No formatter registered for type ${node.type}`);
 };
 export const file = (node, ctx) => {
-    return node.children.map(child => {
+    return node.children
+        .map((child) => {
         return ctx.meta.getFormatter(child.type)(child, ctx);
-    }).join('');
+    })
+        .join('');
 };
-export const boolean = node => {
+export const boolean = (node) => {
     return node.value ? 'true' : 'false';
 };
-export const comment = node => {
+export const comment = (node) => {
     return '#' + node.comment;
 };
-export const float = node => {
+export const float = (node) => {
     return node.value.toString();
 };
-export const integer = node => {
+export const integer = (node) => {
     return node.value.toFixed();
 };
-export const literal = node => {
+export const literal = (node) => {
     return node.value;
 };
-export const long = node => {
+export const long = (node) => {
     return node.value.toString();
 };
-export const resourceLocation = node => {
-    return ResourceLocationNode.toString(node, 'origin');
+export const resourceLocation = (node) => {
+    return ResourceLocationNode.toString(node, 'origin', true);
 };
-export const string = node => {
+export const string = (node) => {
     // FIXME: escape this value according to the node's IndexMap and context
     return `"${node.value}"`;
 };

package/lib/processor/linter/builtin/undeclaredSymbol.js

@@ -1,24 +1,37 @@
-import { localeQuote, localize } from '@spyglassmc/locales';
 import { Arrayable, ResourceLocation } from '../../../common/index.js';
-import { LinterSeverity, SymbolLinterConfig as Config } from '../../../service/index.js';
-import { SymbolUtil } from '../../../symbol/index.js';
+import { SymbolLinterConfig as Config } from '../../../service/index.js';
+// import { localeQuote, localize } from '@spyglassmc/locales'
+// import type { DeepReadonly } from '../../../common/index.js'
+// import { Arrayable, ResourceLocation } from '../../../common/index.js'
+// import type { AstNode } from '../../../node/index.js'
+// import type { LinterContext } from '../../../service/index.js'
+// import { LinterSeverity, SymbolLinterConfig as Config } from '../../../service/index.js'
+// import type { Symbol } from '../../../symbol/index.js'
+// import { SymbolUtil, SymbolVisibility } from '../../../symbol/index.js'
+// import type { Linter } from '../Linter.js'
 export const undeclaredSymbol = (node, ctx) => {
-    if (!node.symbol || SymbolUtil.isDeclared(node.symbol)) {
-        return;
-    }
-    const action = getAction(ctx.ruleValue, node.symbol, ctx);
-    if (Config.Action.isDeclare(action)) {
-        ctx.symbols
-            .query({ doc: ctx.doc, node }, node.symbol.category, ...node.symbol.path)
-            .amend({
-            data: { visibility: getVisibility(action.declare) },
-            usage: { type: 'declaration', node },
-        });
-    }
-    if (Config.Action.isReport(action)) {
-        const severityOverride = action.report === 'inherit' ? undefined : LinterSeverity.toErrorSeverity(action.report);
-        ctx.err.lint(localize('linter.undeclared-symbol.message', node.symbol.category, localeQuote(node.symbol.identifier)), node, undefined, severityOverride);
-    }
+    // if (!node.symbol || SymbolUtil.isDeclared(node.symbol)) {
+    // 	return
+    // }
+    // const action = getAction(ctx.ruleValue as Config, node.symbol, ctx)
+    // if (Config.Action.isDeclare(action)) {
+    // 	ctx.symbols
+    // 		.query({ doc: ctx.doc, node }, node.symbol.category, ...node.symbol.path)
+    // 		.amend({
+    // 			data: { visibility: getVisibility(action.declare) },
+    // 			usage: { type: 'declaration', node },
+    // 		})
+    // }
+    // if (Config.Action.isReport(action)) {
+    // 	const severityOverride = action.report === 'inherit' ? undefined : LinterSeverity.toErrorSeverity(action.report)
+    // 	ctx.err.lint(
+    // 		localize('linter.undeclared-symbol.message',
+    // 			node.symbol.category,
+    // 			localeQuote(node.symbol.identifier)
+    // 		),
+    // 		node, undefined, severityOverride
+    // 	)
+    // }
 };
 function getAction(config, symbol, ctx) {
     if (Config.Action.is(config)) {
@@ -28,11 +41,21 @@ function getAction(config, symbol, ctx) {
         function testSingleCondition(condition) {
             const resourceLocation = ResourceLocation.lengthen(symbol.identifier);
             const namespace = resourceLocation.slice(0, resourceLocation.indexOf(ResourceLocation.NamespacePathSep));
-            return ((condition.category ? Arrayable.toArray(condition.category).includes(symbol.category) : true) &&
-                (condition.namespace ? Arrayable.toArray(condition.namespace).includes(namespace) : true) &&
-                (condition.excludeNamespace ? !Arrayable.toArray(condition.excludeNamespace).includes(namespace) : true) &&
-                (condition.pattern ? Arrayable.toArray(condition.pattern).some(p => new RegExp(p).test(symbol.identifier)) : true) &&
-                (condition.excludePattern ? !Arrayable.toArray(condition.excludePattern).some(p => new RegExp(p).test(symbol.identifier)) : true));
+            return ((condition.category
+                ? Arrayable.toArray(condition.category).includes(symbol.category)
+                : true) &&
+                (condition.namespace
+                    ? Arrayable.toArray(condition.namespace).includes(namespace)
+                    : true) &&
+                (condition.excludeNamespace
+                    ? !Arrayable.toArray(condition.excludeNamespace).includes(namespace)
+                    : true) &&
+                (condition.pattern
+                    ? Arrayable.toArray(condition.pattern).some((p) => new RegExp(p).test(symbol.identifier))
+                    : true) &&
+                (condition.excludePattern
+                    ? !Arrayable.toArray(condition.excludePattern).some((p) => new RegExp(p).test(symbol.identifier))
+                    : true));
         }
         try {
             return Arrayable.toArray(conditions).some(testSingleCondition);