@antelopejs/tooling-configs 0.2.6 → 0.2.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,433 @@
1
+ import { c as trackedManifests, s as resolveRevision } from "./files-BMxKg5IR.mjs";
2
+ import { i as parseManifest } from "./package-Dtjt_lSa.mjs";
3
+ import { a as revisionSuppressions, n as countSuppressions } from "./suppressions-C3AE6_I-.mjs";
4
+ import { createRequire } from "node:module";
5
+ import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
6
+ import { dirname, join, matchesGlob, relative, resolve, sep } from "node:path";
7
+ import { execFileSync, spawnSync } from "node:child_process";
8
+ import { tmpdir } from "node:os";
9
+ //#region src/guardrails/added-entries.ts
10
+ function createAddedPolicy(globs) {
11
+ return {
12
+ globs,
13
+ verdicts: /* @__PURE__ */ new Map(),
14
+ allowed: /* @__PURE__ */ new Map(),
15
+ problems: /* @__PURE__ */ new Set()
16
+ };
17
+ }
18
+ function entryKey(directory, subpath) {
19
+ return `${directory}\0${subpath}`;
20
+ }
21
+ function allowedByGlob(policy, subpath) {
22
+ return policy.globs.some((glob) => matchesGlob(subpath, glob));
23
+ }
24
+ /** Substitutes each export star in order with its capture, as the published target pattern did. */
25
+ function fillStars(pattern, captures, format = (capture) => capture) {
26
+ let index = 0;
27
+ return pattern.replaceAll("*", () => format(captures[index++] ?? captures[0] ?? ""));
28
+ }
29
+ const INTERNAL_TAG = /@internal\b/u;
30
+ const MODULE_TAG = /@(?:packageDocumentation|module|fileoverview)\b/u;
31
+ function exportedLocalNames(compiler, source) {
32
+ const names = /* @__PURE__ */ new Set();
33
+ for (const statement of source.statements) {
34
+ if (compiler.isExportDeclaration(statement) && statement.moduleSpecifier === void 0 && statement.exportClause !== void 0 && compiler.isNamedExports(statement.exportClause)) for (const element of statement.exportClause.elements) names.add((element.propertyName ?? element.name).text);
35
+ if (compiler.isExportAssignment(statement) && compiler.isIdentifier(statement.expression)) names.add(statement.expression.text);
36
+ }
37
+ return names;
38
+ }
39
+ function declaredNames(compiler, statement) {
40
+ if (compiler.isVariableStatement(statement)) return statement.declarationList.declarations.flatMap((declaration) => compiler.isIdentifier(declaration.name) ? [declaration.name.text] : []);
41
+ if ((compiler.isFunctionDeclaration(statement) || compiler.isClassDeclaration(statement) || compiler.isInterfaceDeclaration(statement) || compiler.isTypeAliasDeclaration(statement) || compiler.isEnumDeclaration(statement) || compiler.isModuleDeclaration(statement)) && statement.name !== void 0 && compiler.isIdentifier(statement.name)) return [statement.name.text];
42
+ return [];
43
+ }
44
+ function isExportedDeclaration(compiler, statement, locals) {
45
+ if (compiler.isExportAssignment(statement)) return !compiler.isIdentifier(statement.expression);
46
+ if ((compiler.canHaveModifiers(statement) ? compiler.getModifiers(statement) : void 0)?.some((modifier) => modifier.kind === compiler.SyntaxKind.ExportKeyword)) return true;
47
+ return declaredNames(compiler, statement).some((name) => locals.has(name));
48
+ }
49
+ function hasInternalTag(compiler, statement) {
50
+ return compiler.getJSDocTags(statement).some((tag) => tag.tagName.text === "internal");
51
+ }
52
+ /** Whether a module's text carries `@internal` on the module (with `@packageDocumentation`, `@module` or `@fileoverview`) or on every exported declaration. */
53
+ function isInternalModule(compiler, text) {
54
+ const source = compiler.createSourceFile("module.ts", text, compiler.ScriptTarget.Latest, true);
55
+ if ((compiler.getLeadingCommentRanges(text, 0) ?? []).map((range) => text.slice(range.pos, range.end)).some((comment) => comment.startsWith("/**") && INTERNAL_TAG.test(comment) && MODULE_TAG.test(comment))) return true;
56
+ const locals = exportedLocalNames(compiler, source);
57
+ const exported = source.statements.filter((statement) => isExportedDeclaration(compiler, statement, locals));
58
+ return exported.length > 0 && exported.every((statement) => hasInternalTag(compiler, statement));
59
+ }
60
+ /** Records why an allowed added entry is not internal, or `undefined` when its module is. */
61
+ function recordVerdict(policy, compiler, entry) {
62
+ const internal = isInternalModule(compiler, readFileSync(entry.module, "utf8"));
63
+ policy.verdicts.set(entryKey(entry.directory, entry.subpath), internal ? void 0 : `${entry.label}: added entry ./${entry.subpath} is allowed by --allow-added but is not marked @internal. Add a leading "/** @internal @packageDocumentation */" comment to the file, or tag every exported declaration with "/** @internal */".`);
64
+ }
65
+ /** Lets matching, `@internal` additions through by removing them from the head output; returns how many files were removed. */
66
+ function applyAllowance(policy, base, head, remove) {
67
+ const existing = new Set(base.map(({ path }) => path));
68
+ let removed = 0;
69
+ for (const entry of head) {
70
+ if (existing.has(entry.path) || !allowedByGlob(policy, entry.subpath)) continue;
71
+ const key = entryKey(entry.directory, entry.subpath);
72
+ const problem = policy.verdicts.has(key) ? policy.verdicts.get(key) : `${entry.directory}: added entry ./${entry.subpath} has no emitted declaration, so @internal cannot be verified.`;
73
+ if (problem !== void 0) {
74
+ policy.problems.add(problem);
75
+ continue;
76
+ }
77
+ remove(entry.path);
78
+ removed += 1;
79
+ policy.allowed.set(key, {
80
+ directory: entry.directory,
81
+ subpath: entry.subpath
82
+ });
83
+ }
84
+ return removed;
85
+ }
86
+ /** The "Added (allowed)" list with its count when anything was allowed, and the problems that kept additions from passing; empty when there is nothing to report. */
87
+ function describeAllowance(policy) {
88
+ const lines = [...policy.allowed.values()].map(({ directory, subpath }) => ` ${directory}: ./${subpath}\n`).sort();
89
+ return `${lines.length ? `Added (allowed): ${lines.length}\n${lines.join("")}` : ""}${[...policy.problems].map((problem) => `Not internal: ${problem}\n`).join("")}`;
90
+ }
91
+ //#endregion
92
+ //#region src/guardrails/revisions.ts
93
+ const DIRECTORY_LINK = process.platform === "win32" ? "junction" : "dir";
94
+ function linkDependencies(root, worktree) {
95
+ const directories = /* @__PURE__ */ new Set([".", ...trackedManifests(root).map(dirname)]);
96
+ for (const directory of directories) {
97
+ const source = join(root, directory, "node_modules");
98
+ const target = join(worktree, directory, "node_modules");
99
+ if (existsSync(source) && existsSync(dirname(target)) && !existsSync(target)) symlinkSync(source, target, DIRECTORY_LINK);
100
+ }
101
+ }
102
+ /** Compares isolated committed revisions and removes both worktrees even when compilation fails; a policy lets matching `@internal` additions through. */
103
+ function compareRevisions(root, baseRef, label, emit, policy) {
104
+ const temporary = mkdtempSync(join(tmpdir(), "antelope-proof-"));
105
+ const worktrees = [];
106
+ const results = [];
107
+ try {
108
+ for (const [side, ref] of [["base", baseRef], ["head", "HEAD"]]) {
109
+ const revision = execFileSync("git", [
110
+ "rev-parse",
111
+ "--verify",
112
+ "--end-of-options",
113
+ `${ref}^{commit}`
114
+ ], {
115
+ cwd: root,
116
+ encoding: "utf8",
117
+ stdio: [
118
+ "ignore",
119
+ "pipe",
120
+ "pipe"
121
+ ]
122
+ }).trim();
123
+ const worktree = join(temporary, "worktrees", side);
124
+ execFileSync("git", [
125
+ "worktree",
126
+ "add",
127
+ "--quiet",
128
+ "--detach",
129
+ worktree,
130
+ revision
131
+ ], {
132
+ cwd: root,
133
+ stdio: [
134
+ "ignore",
135
+ "pipe",
136
+ "pipe"
137
+ ]
138
+ });
139
+ worktrees.push(worktree);
140
+ linkDependencies(root, worktree);
141
+ const output = join(temporary, side);
142
+ mkdirSync(output, { recursive: true });
143
+ results.push(emit(worktree, output, join(temporary, "emit", side)));
144
+ }
145
+ const allowedAdditions = policy === void 0 ? 0 : applyAllowance(policy, results[0].published ?? [], results[1].published ?? [], (path) => rmSync(join(temporary, "head", path), { force: true }));
146
+ const diff = spawnSync("git", [
147
+ "diff",
148
+ "--no-index",
149
+ "--no-color",
150
+ "--no-renames",
151
+ "--no-ext-diff",
152
+ "--no-textconv",
153
+ "--",
154
+ "base",
155
+ "head"
156
+ ], {
157
+ cwd: temporary,
158
+ encoding: "utf8",
159
+ maxBuffer: 67108864
160
+ });
161
+ if (diff.error) throw diff.error;
162
+ if (diff.status !== 0 && diff.status !== 1) throw new Error(diff.stderr || "Could not compare revision outputs.");
163
+ const packages = new Set(results.flatMap((result) => result.packages)).size;
164
+ return {
165
+ different: diff.status === 1,
166
+ output: diff.status === 1 ? `${label}: differences against ${baseRef} (committed HEAD).\n${diff.stdout}` : `${label}: ${packages} packages, ${results[1].entries - allowedAdditions} entries unchanged against ${baseRef} (committed HEAD).\n`
167
+ };
168
+ } finally {
169
+ for (const worktree of worktrees.reverse()) execFileSync("git", [
170
+ "worktree",
171
+ "remove",
172
+ "--force",
173
+ worktree
174
+ ], {
175
+ cwd: root,
176
+ stdio: "pipe"
177
+ });
178
+ rmSync(temporary, {
179
+ recursive: true,
180
+ force: true
181
+ });
182
+ }
183
+ }
184
+ function countRows(base, head) {
185
+ const total = (counts) => Object.values(counts.rules).reduce((sum, count) => sum + count, 0);
186
+ const rules = [.../* @__PURE__ */ new Set([...Object.keys(base.rules), ...Object.keys(head.rules)])].sort((a, b) => a.localeCompare(b));
187
+ return [
188
+ [
189
+ "Lint suppressions, all rules",
190
+ total(base),
191
+ total(head)
192
+ ],
193
+ ...rules.map((rule) => [
194
+ `Lint suppressions, \`${rule}\``,
195
+ base.rules[rule] ?? 0,
196
+ head.rules[rule] ?? 0
197
+ ]),
198
+ [
199
+ "`@ts-expect-error`",
200
+ base.tsExpectError,
201
+ head.tsExpectError
202
+ ],
203
+ [
204
+ "`@ts-ignore`",
205
+ base.tsIgnore,
206
+ head.tsIgnore
207
+ ],
208
+ [
209
+ "`SAFETY:` comments",
210
+ base.safety,
211
+ head.safety
212
+ ]
213
+ ];
214
+ }
215
+ /** Counts suppressions in authored code files at the base and at committed HEAD with the shared suppression counter, so a PR body copies them instead of typing them. */
216
+ function revisionCounts(root, baseRef) {
217
+ const [base, head] = [baseRef, "HEAD"].map((ref) => countSuppressions(revisionSuppressions(root, resolveRevision(root, ref))));
218
+ return `\nSuppressions in authored code files (${baseRef} and committed HEAD). A lint directive counts once per rule it names; \`*\` is a directive naming none.\n| Suppressions | base | HEAD |\n| --- | ---: | ---: |\n${countRows(base, head).map(([label, before, after]) => `| ${label} | ${before} | ${after} |`).join("\n")}\n`;
219
+ }
220
+ //#endregion
221
+ //#region src/guardrails/declared-typescript.ts
222
+ const DEPENDENCY_FIELDS = [
223
+ "dependencies",
224
+ "devDependencies",
225
+ "peerDependencies",
226
+ "optionalDependencies"
227
+ ];
228
+ function readManifest(directory) {
229
+ const file = join(directory, "package.json");
230
+ return existsSync(file) ? parseManifest(readFileSync(file, "utf8")) : void 0;
231
+ }
232
+ function declares(manifest) {
233
+ return DEPENDENCY_FIELDS.some((field) => manifest?.[field]?.typescript !== void 0);
234
+ }
235
+ /** The nearest manifest at or above `directory` that configures a workspace, never leaving the repository that contains it. */
236
+ function workspaceManifest(directory) {
237
+ for (let current = directory;; current = dirname(current)) {
238
+ const manifest = readManifest(current);
239
+ if (manifest !== void 0 && (manifest.workspaces !== void 0 || existsSync(join(current, "pnpm-workspace.yaml")))) return manifest;
240
+ if (existsSync(join(current, ".git")) || dirname(current) === current) return void 0;
241
+ }
242
+ }
243
+ /** Whether the package at `directory`, or the workspace root above it, declares `typescript` as a dependency of any kind. */
244
+ function declaresTypeScript(directory) {
245
+ return declares(readManifest(directory)) || declares(workspaceManifest(directory));
246
+ }
247
+ /** The directory of the package relative to the repository that contains it, `.` for the repository root; the same for every revision of the repository. */
248
+ function repositoryDirectory(directory) {
249
+ for (let current = directory;; current = dirname(current)) if (existsSync(join(current, ".git")) || dirname(current) === current) return relative(current, directory).split("\\").join("/") || ".";
250
+ }
251
+ /** The package as an error names it: its `name` when it has one, and its directory. */
252
+ function describePackage(directory) {
253
+ const name = readManifest(directory)?.name;
254
+ const where = repositoryDirectory(directory);
255
+ return name === void 0 ? where : `${name} (${where})`;
256
+ }
257
+ //#endregion
258
+ //#region src/guardrails/typescript.ts
259
+ /** A proof analyses only packages that publish something: not private, and declaring at least one of `exports`, `main`, `types`, `typings` or `typesVersions`. */
260
+ function unpublishedReason(manifest) {
261
+ if (manifest.private === true) return "private";
262
+ return [
263
+ manifest.exports,
264
+ manifest.main,
265
+ manifest.types,
266
+ manifest.typings,
267
+ manifest.typesVersions
268
+ ].some((field) => field != null) ? void 0 : "no exports, main or types";
269
+ }
270
+ function trackedPackages(root) {
271
+ return trackedManifests(root).flatMap((file) => {
272
+ const directory = dirname(file);
273
+ if (!existsSync(join(root, directory, "tsconfig.json"))) return [];
274
+ return [{
275
+ directory,
276
+ manifest: JSON.parse(readFileSync(join(root, file), "utf8"))
277
+ }];
278
+ });
279
+ }
280
+ function packagesAt(root, publishedOnly) {
281
+ return trackedPackages(root).filter(({ manifest }) => !publishedOnly || unpublishedReason(manifest) === void 0);
282
+ }
283
+ /** The packages a published-only proof leaves out, each with the reason, so a skip is reported rather than silent. */
284
+ function unpublishedAt(root) {
285
+ return trackedPackages(root).flatMap(({ directory, manifest }) => {
286
+ const reason = unpublishedReason(manifest);
287
+ return reason === void 0 ? [] : [{
288
+ directory,
289
+ reason
290
+ }];
291
+ });
292
+ }
293
+ function packageRoot(file) {
294
+ let directory = dirname(file);
295
+ while (!existsSync(join(directory, "package.json"))) {
296
+ const parent = dirname(directory);
297
+ if (parent === directory) return dirname(file);
298
+ directory = parent;
299
+ }
300
+ return directory;
301
+ }
302
+ function resolveTypeScript(directory) {
303
+ try {
304
+ return {
305
+ file: createRequire(join(directory, "package.json")).resolve("typescript"),
306
+ fallback: false
307
+ };
308
+ } catch (error) {
309
+ if (declaresTypeScript(directory)) throw new Error(`${describePackage(directory)} declares typescript but it cannot be resolved from the package directory, so the compiler it builds with is not available. Install dependencies (run pnpm install) and retry.`, { cause: error });
310
+ return {
311
+ file: createRequire(createRequire(import.meta.url).resolve("dts-bundle-generator")).resolve("typescript"),
312
+ fallback: true
313
+ };
314
+ }
315
+ }
316
+ /** Loads the compiler a package builds with, including a package-local installation in a workspace. A package that declares `typescript` (itself or through its workspace root) but cannot resolve it is an error; only a package that declares none falls back to the one `dts-bundle-generator` brings, with a `notice`. A TypeScript without the programmatic API (7 and later) is an error rather than a crash. */
317
+ function loadTypeScript(directory) {
318
+ const { file, fallback } = resolveTypeScript(directory);
319
+ const compiler = createRequire(file)("typescript");
320
+ const root = packageRoot(file);
321
+ if (compiler.sys === void 0 || !("createProgram" in compiler)) throw new Error(`TypeScript ${compiler.version} at ${root} has no programmatic compiler API (sys, createProgram), so this package cannot be analysed. Build it with a TypeScript that has one, or mark the package private.`);
322
+ return {
323
+ compiler,
324
+ root,
325
+ notice: fallback ? `${repositoryDirectory(directory)}: declares no typescript; using the pack's TypeScript ${compiler.version}\n` : void 0
326
+ };
327
+ }
328
+ const TEST_SOURCE_GLOBS = [
329
+ "**/*.test.*",
330
+ "**/*.spec.*",
331
+ "**/__tests__/**",
332
+ "test/**",
333
+ "tests/**"
334
+ ];
335
+ function isTestSource(root, file) {
336
+ const path = relative(root, file).split("\\").join("/");
337
+ return TEST_SOURCE_GLOBS.some((pattern) => matchesGlob(path, pattern));
338
+ }
339
+ function failDiagnostics(compiler, diagnostics) {
340
+ const errors = diagnostics.filter((item) => item.category === compiler.DiagnosticCategory.Error);
341
+ if (errors.length) throw new Error(compiler.formatDiagnostics(errors, {
342
+ getCanonicalFileName: (file) => file,
343
+ getCurrentDirectory: () => process.cwd(),
344
+ getNewLine: () => "\n"
345
+ }));
346
+ }
347
+ /** Declaration inputs are part of the local closure but TypeScript does not emit copies of them. */
348
+ function copyDeclarations(program, directory, output) {
349
+ const sources = program.getSourceFiles().filter((source) => !program.isSourceFileDefaultLibrary(source) && !program.isSourceFileFromExternalLibrary(source) && !relative(directory, source.fileName).startsWith(`..${sep}`) && !isTestSource(directory, source.fileName));
350
+ const authored = sources.filter((source) => !source.isDeclarationFile);
351
+ let root = dirname((authored[0] ?? sources[0])?.fileName ?? join(directory, "index.ts"));
352
+ for (const source of authored.length ? authored : sources) while (relative(root, source.fileName).startsWith(`..${sep}`)) root = dirname(root);
353
+ root = program.getCompilerOptions().rootDir ?? root;
354
+ const files = [];
355
+ for (const source of sources) {
356
+ if (!source.isDeclarationFile) continue;
357
+ const path = relative(root, source.fileName);
358
+ if (path.startsWith(`..${sep}`)) continue;
359
+ const target = join(output, path);
360
+ mkdirSync(dirname(target), { recursive: true });
361
+ writeFileSync(target, source.text);
362
+ files.push(target);
363
+ }
364
+ return files;
365
+ }
366
+ function parseConfig(directory) {
367
+ const { compiler, root, notice } = loadTypeScript(directory);
368
+ const config = compiler.readConfigFile(join(directory, "tsconfig.json"), compiler.sys.readFile);
369
+ if (config.error) failDiagnostics(compiler, [config.error]);
370
+ const parsed = compiler.parseJsonConfigFileContent(config.config, compiler.sys, directory);
371
+ failDiagnostics(compiler, parsed.errors);
372
+ return {
373
+ compiler,
374
+ root,
375
+ notice,
376
+ parsed
377
+ };
378
+ }
379
+ /** The configured `outDir`, the root under which the declaration half already judges a built path as test output. */
380
+ function outputRoot(directory) {
381
+ return resolve(directory, parseConfig(directory).parsed.options.outDir ?? ".");
382
+ }
383
+ /** Emits with the package's compiler and config; test roots and outputs never enter either proof. `modules` maps each emitted file to its source module. */
384
+ function emitPackage(directory, output, declarations) {
385
+ const { compiler, root, notice, parsed } = parseConfig(directory);
386
+ const options = {
387
+ ...parsed.options,
388
+ rootDir: parsed.options.rootDir ?? (parsed.options.outDir ? void 0 : directory),
389
+ outDir: output,
390
+ declarationDir: declarations ? output : void 0,
391
+ declaration: declarations,
392
+ emitDeclarationOnly: declarations,
393
+ removeComments: true,
394
+ declarationMap: false,
395
+ sourceMap: false,
396
+ inlineSourceMap: false,
397
+ noEmit: false,
398
+ noEmitOnError: false,
399
+ composite: false,
400
+ incremental: false,
401
+ tsBuildInfoFile: void 0,
402
+ outFile: void 0,
403
+ allowImportingTsExtensions: declarations ? parsed.options.allowImportingTsExtensions : false
404
+ };
405
+ const program = compiler.createProgram({
406
+ rootNames: parsed.fileNames.filter((file) => !isTestSource(directory, file)),
407
+ options,
408
+ projectReferences: parsed.projectReferences
409
+ });
410
+ if (declarations) failDiagnostics(compiler, compiler.getPreEmitDiagnostics(program));
411
+ const files = [];
412
+ const modules = /* @__PURE__ */ new Map();
413
+ const result = program.emit(void 0, (file, text, _bom, _onError, sources) => {
414
+ if (sources?.some((source) => isTestSource(directory, source.fileName))) return;
415
+ if (declarations ? !/\.d\.[cm]?ts$/.test(file) : !/\.[cm]?jsx?$/.test(file)) return;
416
+ mkdirSync(dirname(file), { recursive: true });
417
+ writeFileSync(file, text);
418
+ files.push(file);
419
+ if (sources?.[0] !== void 0) modules.set(resolve(file), sources[0].fileName);
420
+ });
421
+ if (declarations) failDiagnostics(compiler, result.diagnostics);
422
+ if (declarations) files.push(...copyDeclarations(program, directory, output));
423
+ return {
424
+ compiler,
425
+ compilerRoot: root,
426
+ notice,
427
+ files,
428
+ modules,
429
+ options: parsed.options
430
+ };
431
+ }
432
+ //#endregion
433
+ export { unpublishedAt as a, revisionCounts as c, describeAllowance as d, fillStars as f, packagesAt as i, allowedByGlob as l, isTestSource as n, DIRECTORY_LINK as o, recordVerdict as p, outputRoot as r, compareRevisions as s, emitPackage as t, createAddedPolicy as u };
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@antelopejs/tooling-configs",
3
- "version": "0.2.6",
3
+ "version": "0.2.8",
4
4
  "description": "Shared tooling presets for AntelopeJS repositories: oxlint (with the vendored anti-slop rules), oxfmt, ESLint for Nuxt layers, Knip, and an interface range check",
5
5
  "keywords": [
6
6
  "antelopejs",
@@ -27,6 +27,7 @@
27
27
  "antelopejs-checks": "./dist/bin/checks.mjs",
28
28
  "antelopejs-comment-proof": "./dist/bin/comment-proof.mjs",
29
29
  "antelopejs-ratchet": "./dist/bin/ratchet.mjs",
30
+ "antelopejs-suppressions": "./dist/bin/suppressions.mjs",
30
31
  "antelopejs-sync": "./dist/bin/sync.mjs"
31
32
  },
32
33
  "files": [
@@ -60,11 +61,14 @@
60
61
  "prepare": "if git rev-parse --is-inside-work-tree >/dev/null 2>&1 && command -v lefthook >/dev/null 2>&1; then lefthook install; fi",
61
62
  "sync": "node src/bin/sync.ts",
62
63
  "sync:check": "node src/bin/sync.ts --check",
63
- "knip": "knip"
64
+ "knip": "knip",
65
+ "suppressions": "node src/bin/suppressions.ts",
66
+ "suppressions:update": "node src/bin/suppressions.ts --update"
64
67
  },
65
68
  "dependencies": {
66
69
  "@oxlint/plugins": "1.81.0",
67
70
  "dts-bundle-generator": "^9.5.1",
71
+ "typescript": "^5.9.3",
68
72
  "yaml": "^2.9.1"
69
73
  },
70
74
  "devDependencies": {
@@ -78,8 +82,7 @@
78
82
  "oxlint-tsgolint": "^7.0.2001",
79
83
  "release-it": "^19.2.4",
80
84
  "release-it-changelogen": "^0.1.0",
81
- "tsdown": "^0.22.14",
82
- "typescript": "^5.9.3"
85
+ "tsdown": "^0.22.14"
83
86
  },
84
87
  "peerDependencies": {
85
88
  "@nuxt/eslint-config": ">=1.2.0",