@sandstone-mc/mcdoc-ts-generator 0.1.0

package/dist/typegen/mcdoc/multi/struct.d.ts

@@ -0,0 +1,31 @@
+import ts from 'typescript';
+import * as mcdoc from '@spyglassmc/mcdoc';
+import { TypeHandlers, type NonEmptyList } from '..';
+type ResolvedSpreadType = ReturnType<ReturnType<(typeof TypeHandlers[('reference' | 'dispatcher' | 'concrete' | 'template')])>>['type'];
+type ResolvedIndexSignatureType = ts.ParenthesizedTypeNode | ts.TypeReferenceNode;
+type StructIntersection = ResolvedSpreadType | ResolvedIndexSignatureType;
+declare function mcdoc_struct(type: mcdoc.McdocType): (args: Record<string, unknown>) => {
+    readonly type: ts.TypeLiteralNode | ts.TypeAliasDeclaration | StructIntersection;
+} | {
+    readonly child_dispatcher: [parent_count: number, property: string][] & {
+        0: [parent_count: number, property: string];
+    };
+    readonly type: ts.TypeLiteralNode | ts.TypeAliasDeclaration | StructIntersection;
+} | {
+    readonly imports: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+    readonly type: ts.TypeLiteralNode | ts.TypeAliasDeclaration | StructIntersection;
+} | {
+    readonly imports: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+    readonly child_dispatcher: [parent_count: number, property: string][] & {
+        0: [parent_count: number, property: string];
+    };
+    readonly type: ts.TypeLiteralNode | ts.TypeAliasDeclaration | StructIntersection;
+};
+export declare const McdocStruct: typeof mcdoc_struct;
+export {};

package/dist/typegen/mcdoc/multi/tuple.d.ts

@@ -0,0 +1,62 @@
+import ts from 'typescript';
+import * as mcdoc from '@spyglassmc/mcdoc';
+import { type NonEmptyList } from '..';
+declare function mcdoc_tuple(type: mcdoc.McdocType): (args: Record<string, unknown>) => {
+    readonly type: ts.TupleTypeNode;
+} | {
+    readonly child_dispatcher: [parent_count: number, property: string][] & {
+        0: [parent_count: number, property: string];
+    };
+    readonly type: ts.TupleTypeNode;
+} | {
+    readonly docs: (string | [string])[] & {
+        0: string | [string];
+    };
+    readonly type: ts.TupleTypeNode;
+} | {
+    readonly docs: (string | [string])[] & {
+        0: string | [string];
+    };
+    readonly child_dispatcher: [parent_count: number, property: string][] & {
+        0: [parent_count: number, property: string];
+    };
+    readonly type: ts.TupleTypeNode;
+} | {
+    readonly imports: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+    readonly type: ts.TupleTypeNode;
+} | {
+    readonly imports: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+    readonly child_dispatcher: [parent_count: number, property: string][] & {
+        0: [parent_count: number, property: string];
+    };
+    readonly type: ts.TupleTypeNode;
+} | {
+    readonly imports: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+    readonly docs: (string | [string])[] & {
+        0: string | [string];
+    };
+    readonly type: ts.TupleTypeNode;
+} | {
+    readonly imports: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+    readonly docs: (string | [string])[] & {
+        0: string | [string];
+    };
+    readonly child_dispatcher: [parent_count: number, property: string][] & {
+        0: [parent_count: number, property: string];
+    };
+    readonly type: ts.TupleTypeNode;
+};
+export declare const McdocTuple: typeof mcdoc_tuple;
+export {};

package/dist/typegen/mcdoc/multi/union.d.ts

@@ -0,0 +1,62 @@
+import ts from 'typescript';
+import * as mcdoc from '@spyglassmc/mcdoc';
+import { type NonEmptyList } from '..';
+declare function mcdoc_union(type: mcdoc.McdocType): (args: Record<string, unknown>) => {
+    readonly type: ts.TypeNode;
+} | {
+    readonly child_dispatcher: [number, string][] & {
+        0: [number, string];
+    };
+    readonly type: ts.TypeNode;
+} | {
+    readonly docs: (string | [string])[] & {
+        0: string | [string];
+    };
+    readonly type: ts.TypeNode;
+} | {
+    readonly docs: (string | [string])[] & {
+        0: string | [string];
+    };
+    readonly child_dispatcher: [number, string][] & {
+        0: [number, string];
+    };
+    readonly type: ts.TypeNode;
+} | {
+    readonly imports: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+    readonly type: ts.TypeNode;
+} | {
+    readonly imports: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+    readonly child_dispatcher: [number, string][] & {
+        0: [number, string];
+    };
+    readonly type: ts.TypeNode;
+} | {
+    readonly imports: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+    readonly docs: (string | [string])[] & {
+        0: string | [string];
+    };
+    readonly type: ts.TypeNode;
+} | {
+    readonly imports: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+    readonly docs: (string | [string])[] & {
+        0: string | [string];
+    };
+    readonly child_dispatcher: [number, string][] & {
+        0: [number, string];
+    };
+    readonly type: ts.TypeNode;
+};
+export declare const McdocUnion: typeof mcdoc_union;
+export {};

package/dist/typegen/mcdoc/primitives/any.d.ts

@@ -0,0 +1,7 @@
+import ts from 'typescript';
+import * as mcdoc from '@spyglassmc/mcdoc';
+declare function mcdoc_any(type: mcdoc.McdocType): (args: Record<string, unknown>) => {
+    readonly type: ts.KeywordTypeNode<ts.SyntaxKind.UnknownKeyword>;
+};
+export declare const McdocAny: typeof mcdoc_any;
+export {};

package/dist/typegen/mcdoc/primitives/boolean.d.ts

@@ -0,0 +1,7 @@
+import ts from 'typescript';
+import * as mcdoc from '@spyglassmc/mcdoc';
+declare function mcdoc_boolean(type: mcdoc.McdocType): (args: Record<string, unknown>) => {
+    readonly type: ts.KeywordTypeNode<ts.SyntaxKind.BooleanKeyword>;
+};
+export declare const McdocBoolean: typeof mcdoc_boolean;
+export {};

package/dist/typegen/mcdoc/primitives/byte.d.ts

@@ -0,0 +1,19 @@
+import ts from 'typescript';
+import * as mcdoc from '@spyglassmc/mcdoc';
+import type { NonEmptyList } from '..';
+declare function mcdoc_byte(type: mcdoc.McdocType): (args: Record<string, unknown>) => {
+    readonly type: ts.TypeReferenceNode;
+    readonly docs: NonEmptyList<string>;
+    readonly imports: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+} | {
+    readonly type: ts.TypeReferenceNode;
+    readonly imports: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+};
+export declare const McdocByte: typeof mcdoc_byte;
+export {};

package/dist/typegen/mcdoc/primitives/concrete.d.ts

@@ -0,0 +1,37 @@
+import ts from 'typescript';
+import * as mcdoc from '@spyglassmc/mcdoc';
+import { type NonEmptyList } from '..';
+/**
+ * Handles `concrete` types which are type references with generic arguments.
+ *
+ * A concrete type has:
+ * - `child`: The base type being referenced (always a `reference` or `dispatcher` type)
+ * - `typeArgs`: The generic arguments being passed to the template
+ *
+ * Example: `SomeTemplate<boolean, string>` would have child=reference to SomeTemplate, typeArgs=[boolean, string]
+ */
+declare function mcdoc_concrete(type: mcdoc.McdocType): (args: Record<string, unknown>) => {
+    readonly type: ts.TypeNode | ts.TypeReferenceNode | ts.ParenthesizedTypeNode;
+} | {
+    readonly child_dispatcher: [number, string][] & {
+        0: [number, string];
+    };
+    readonly type: ts.TypeNode | ts.TypeReferenceNode | ts.ParenthesizedTypeNode;
+} | {
+    readonly imports: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+    readonly type: ts.TypeNode | ts.TypeReferenceNode | ts.ParenthesizedTypeNode;
+} | {
+    readonly imports: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+    readonly child_dispatcher: [number, string][] & {
+        0: [number, string];
+    };
+    readonly type: ts.TypeNode | ts.TypeReferenceNode | ts.ParenthesizedTypeNode;
+};
+export declare const McdocConcrete: typeof mcdoc_concrete;
+export {};

package/dist/typegen/mcdoc/primitives/double.d.ts

@@ -0,0 +1,27 @@
+import * as mcdoc from '@spyglassmc/mcdoc';
+import ts from 'typescript';
+import type { NonEmptyList } from '..';
+declare function mcdoc_double(type: mcdoc.McdocType): (args: Record<string, unknown>) => {
+    readonly type: ts.ParenthesizedTypeNode;
+    readonly docs: NonEmptyList<string>;
+    readonly imports: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+} | {
+    readonly type: ts.ParenthesizedTypeNode;
+    readonly imports: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+};
+export declare const McdocDouble: typeof mcdoc_double;
+export declare function non_integral_generic<TYPE extends string, JS_NUMBER_ALLOWED extends (true | undefined)>(range: mcdoc.NumericRange, type: TYPE, allow_js_number?: JS_NUMBER_ALLOWED): {
+    readonly type: JS_NUMBER_ALLOWED extends true ? ts.ParenthesizedTypeNode : ts.TypeReferenceNode;
+    readonly docs: NonEmptyList<string>;
+    readonly imports: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+};
+export {};

package/dist/typegen/mcdoc/primitives/float.d.ts

@@ -0,0 +1,19 @@
+import * as mcdoc from '@spyglassmc/mcdoc';
+import ts from 'typescript';
+import type { NonEmptyList } from '..';
+declare function mcdoc_float(type: mcdoc.McdocType): (args: Record<string, unknown>) => {
+    readonly type: ts.TypeReferenceNode | ts.ParenthesizedTypeNode;
+    readonly docs: NonEmptyList<string>;
+    readonly imports: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+} | {
+    readonly type: ts.TypeReferenceNode;
+    readonly imports: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+};
+export declare const McdocFloat: typeof mcdoc_float;
+export {};

package/dist/typegen/mcdoc/primitives/index.d.ts

@@ -0,0 +1,12 @@
+export { McdocAny } from './any';
+export { McdocBoolean } from './boolean';
+export { McdocByte } from './byte';
+export { McdocConcrete } from './concrete';
+export { McdocDouble } from './double';
+export { McdocFloat } from './float';
+export { McdocInt } from './int';
+export { McdocLiteral } from './literal';
+export { McdocLong } from './long';
+export { McdocReference } from './reference';
+export { McdocShort } from './short';
+export { McdocString } from './string';

package/dist/typegen/mcdoc/primitives/int.d.ts

@@ -0,0 +1,35 @@
+import * as mcdoc from '@spyglassmc/mcdoc';
+import ts from 'typescript';
+import type { NonEmptyList } from '..';
+declare function mcdoc_int(type: mcdoc.McdocType): (args: Record<string, unknown>) => {
+    readonly type: ts.TypeReferenceNode;
+    readonly docs: NonEmptyList<string>;
+    readonly imports: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+} | {
+    readonly type: ts.TypeReferenceNode;
+    readonly imports: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+};
+export declare const McdocInt: typeof mcdoc_int;
+/**
+ *
+ */
+export declare function whole_number_generic<TYPE extends string>(range: mcdoc.NumericRange, type: TYPE): {
+    readonly type: ts.TypeReferenceNode;
+    readonly docs: NonEmptyList<string>;
+    readonly imports: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+};
+/**
+ * Returns the number of valid values within the range.
+ * Lower value must actually be lower than the upper
+ */
+export declare function integer_range_size(lower: number, upper: number): number;
+export {};

package/dist/typegen/mcdoc/primitives/literal.d.ts

@@ -0,0 +1,14 @@
+import ts from 'typescript';
+import * as mcdoc from '@spyglassmc/mcdoc';
+import type { NonEmptyList } from '..';
+declare function mcdoc_literal(type: mcdoc.McdocType): (args: Record<string, unknown>) => {
+    readonly type: ts.LiteralTypeNode;
+} | {
+    readonly type: ts.TypeReferenceNode;
+    readonly imports: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+};
+export declare const McdocLiteral: typeof mcdoc_literal;
+export {};

package/dist/typegen/mcdoc/primitives/long.d.ts

@@ -0,0 +1,19 @@
+import ts from 'typescript';
+import * as mcdoc from '@spyglassmc/mcdoc';
+import type { NonEmptyList } from '..';
+declare function mcdoc_long(type: mcdoc.McdocType): (args: Record<string, unknown>) => {
+    readonly type: ts.TypeReferenceNode;
+    readonly docs: NonEmptyList<string>;
+    readonly imports: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+} | {
+    readonly type: ts.TypeReferenceNode;
+    readonly imports: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+};
+export declare const McdocLong: typeof mcdoc_long;
+export {};

package/dist/typegen/mcdoc/primitives/reference.d.ts

@@ -0,0 +1,54 @@
+import ts from 'typescript';
+import * as mcdoc from '@spyglassmc/mcdoc';
+import type { NonEmptyList } from '..';
+declare function mcdoc_reference(type: mcdoc.McdocType): (args: Record<string, unknown>) => {
+    readonly type: ts.TypeReferenceNode | ts.ParenthesizedTypeNode;
+} | {
+    readonly child_dispatcher: [[0, string]];
+    readonly type: ts.TypeReferenceNode | ts.ParenthesizedTypeNode;
+} | {
+    readonly docs: (string | [string])[] & {
+        0: string | [string];
+    };
+    readonly type: ts.TypeReferenceNode | ts.ParenthesizedTypeNode;
+} | {
+    readonly docs: (string | [string])[] & {
+        0: string | [string];
+    };
+    readonly child_dispatcher: [[0, string]];
+    readonly type: ts.TypeReferenceNode | ts.ParenthesizedTypeNode;
+} | {
+    readonly imports: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+    readonly type: ts.TypeReferenceNode | ts.ParenthesizedTypeNode;
+} | {
+    readonly imports: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+    readonly child_dispatcher: [[0, string]];
+    readonly type: ts.TypeReferenceNode | ts.ParenthesizedTypeNode;
+} | {
+    readonly imports: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+    readonly docs: (string | [string])[] & {
+        0: string | [string];
+    };
+    readonly type: ts.TypeReferenceNode | ts.ParenthesizedTypeNode;
+} | {
+    readonly imports: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+    readonly docs: (string | [string])[] & {
+        0: string | [string];
+    };
+    readonly child_dispatcher: [[0, string]];
+    readonly type: ts.TypeReferenceNode | ts.ParenthesizedTypeNode;
+};
+export declare const McdocReference: typeof mcdoc_reference;
+export {};

package/dist/typegen/mcdoc/primitives/short.d.ts

@@ -0,0 +1,19 @@
+import ts from 'typescript';
+import * as mcdoc from '@spyglassmc/mcdoc';
+import type { NonEmptyList } from '..';
+declare function mcdoc_short(type: mcdoc.McdocType): (args: Record<string, unknown>) => {
+    readonly type: ts.TypeReferenceNode;
+    readonly docs: NonEmptyList<string>;
+    readonly imports: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+} | {
+    readonly type: ts.TypeReferenceNode;
+    readonly imports: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+};
+export declare const McdocShort: typeof mcdoc_short;
+export {};

package/dist/typegen/mcdoc/primitives/string.d.ts

@@ -0,0 +1,28 @@
+import ts from 'typescript';
+import * as mcdoc from '@spyglassmc/mcdoc';
+import type { NonEmptyList } from '..';
+/**
+ * This only handles strings as value types, not struct keys
+ */
+declare function mcdoc_string(type: mcdoc.McdocType): ((args: Record<string, unknown>) => {
+    readonly type: ts.KeywordTypeNode<ts.SyntaxKind.StringKeyword>;
+}) | ((args: Record<string, unknown>) => {
+    readonly type: ts.TemplateLiteralTypeNode;
+}) | ((args: Record<string, unknown>) => {
+    readonly type: ts.TemplateLiteralTypeNode;
+    readonly docs: NonEmptyList<string>;
+    readonly imports?: never;
+} | {
+    readonly type: ts.TypeNode;
+    readonly imports: {
+        ordered: NonEmptyList<string>;
+        check: Map<string, number>;
+    };
+    readonly docs?: never;
+}) | ((args: Record<string, unknown>) => {
+    readonly type: ts.UnionTypeNode;
+}) | ((args: Record<string, unknown>) => {
+    readonly type: ts.ParenthesizedTypeNode;
+});
+export declare const McdocString: typeof mcdoc_string;
+export {};

package/dist/typegen/mcdoc/utils.d.ts

@@ -0,0 +1,20 @@
+import type { SymbolUtil } from '@spyglassmc/core';
+import type { TypeHandlerResult } from '.';
+export type NonEmptyList<T> = T[] & {
+    0: T;
+};
+/**
+ * Check if a registry has entries in the symbol table.
+ * @param symbols The symbol utility
+ * @param registry_id The registry ID with minecraft: prefix (e.g., 'minecraft:block')
+ * @returns true if the registry is non-empty
+ */
+export declare function is_valid_registry(symbols: SymbolUtil | undefined, registry_id: string): boolean;
+export declare function add_import(imports: TypeHandlerResult['imports'], add_import: string): NonNullable<TypeHandlerResult['imports']>;
+export declare function merge_imports(imports: TypeHandlerResult['imports'], new_imports: NonNullable<TypeHandlerResult['imports']>): NonNullable<TypeHandlerResult['imports']>;
+type GetConstructorArgs<T> = T extends new (...args: infer U) => any ? U : never;
+export declare class Set<T> extends global.Set<T> {
+    constructor(...args: GetConstructorArgs<typeof global.Set<T>>);
+    has(value: unknown): boolean;
+}
+export {};

package/dist/util/config.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/util/fetch.d.ts

@@ -0,0 +1,18 @@
+/**
+ * A non-spec-compliant, non-complete implementation of the Cache Web API for use in Spyglass.
+ * This class stores the cached response on the file system under the cache root.
+ */
+declare class HttpCache implements Cache {
+    #private;
+    constructor(cacheRoot: string | undefined);
+    match(request: RequestInfo | URL, _options?: CacheQueryOptions | undefined): Promise<Response | undefined>;
+    put(request: RequestInfo | URL, response: Response): Promise<void>;
+    add(): Promise<void>;
+    addAll(): Promise<void>;
+    delete(): Promise<boolean>;
+    keys(): Promise<readonly Request[]>;
+    matchAll(): Promise<readonly Response[]>;
+}
+export declare const cache: HttpCache;
+export declare function fetchWithCache(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+export {};

package/dist/util/index.d.ts

@@ -0,0 +1,22 @@
+export declare function errorMessage(e: unknown): string;
+export declare const join: (...paths: string[]) => string;
+export declare function pascal_case(name: string): string;
+export declare function camel_case(name: string): string;
+export declare function pluralize(name: string): string;
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+type LastOf<T> = UnionToIntersection<T extends any ? () => T : never> extends () => (infer R) ? R : never;
+type Push<T extends any[], V> = [...T, V];
+type UnionToTuple<T, L = LastOf<T>, N = [T] extends [never] ? true : false> = true extends N ? [] : Push<UnionToTuple<Exclude<T, L>>, L>;
+type PowerSet<T, Keys extends any[] = UnionToTuple<keyof T>> = Keys extends [infer Head, ...infer Rest] ? PowerSet<T, Rest> | (Head extends keyof T ? {
+    [K in Head]: NonNullable<T[K]>;
+} & PowerSet<T, Rest> : never) : Record<string, never>;
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+/**
+ * Helper to add key-value pairs to an object if the values are not undefined.
+ *
+ * @returns An object with the key-value pairs if the values are not undefined, otherwise an empty object.
+ */
+export declare function add<O extends Record<string, any>>(obj: O): Prettify<PowerSet<O>>;
+export {};

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@sandstone-mc/mcdoc-ts-generator",
+  "version": "0.1.0",
+  "description": "Generate TypeScript types from Minecraft mcdoc definitions",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "mcdoc-ts-generator": "./dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "compile": "bun run ./src/index.ts",
+    "build": "bun run build:bundle && bun run build:types",
+    "build:bundle": "bun build ./src/cli.ts --outfile ./dist/cli.js --target node --format esm --packages external && bun build ./src/index.ts --outfile ./dist/index.js --target node --format esm --packages external",
+    "build:types": "tsc --emitDeclarationOnly --declaration --outDir ./dist",
+    "prepublishOnly": "bun run build"
+  },
+  "keywords": [
+    "minecraft",
+    "mcdoc",
+    "typescript",
+    "types",
+    "generator",
+    "datapack",
+    "resourcepack"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sandstone-mc/mcdoc-ts-generator"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "@seahax/eslint-plugin-wrap": "^0.6.10",
+    "@spyglassmc/core": "^0.4.39",
+    "@spyglassmc/java-edition": "^0.3.51",
+    "@spyglassmc/mcdoc": "^0.3.43",
+    "@stylistic/eslint-plugin": "^5.6.1",
+    "@typescript-eslint/parser": "^8.49.0",
+    "eslint": "^9.39.2",
+    "ts-pattern": "^5.9.0"
+  }
+}