@aws/nx-plugin 1.0.0-rc.49 → 1.0.0-rc.50

package/src/utils/ruff.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Rules whose fixes are applied to generated Python.
+ *
+ * `ruff_wasm`'s `check` serialises every fix without its applicability (the
+ * `Fix::applicability()` it drops is what `ruff check --fix` filters on) and
+ * ignores `unsafe-fixes`, so it cannot be asked for only the fixes the CLI would
+ * apply. Taking them all would rewrite `if x == True` to `if x`.
+ *
+ * Ruff's `fixable` setting filters inside the linter, which keeps the decision
+ * in ruff — but it selects by *rule*, and applicability is a property of each
+ * *diagnostic*: across ruff's own 1598 lint fixtures, 27 rules under the vended
+ * selection emit both safe and unsafe fixes depending on the code (one `UP008`
+ * is safe, another is unsafe when dropping the arguments would take a comment
+ * with them). So no rule list, allowing or denying, can reproduce `--fix`: for
+ * those 27 it can only take both or neither.
+ *
+ * Given that, the list stays as small as generation needs rather than reaching
+ * for an equivalence it cannot have. These four cover the import hygiene
+ * generation itself creates by merging imports into existing files, and ruff
+ * documents each of their fixes as safe — except F401 in an `__init__.py`, which
+ * is excluded below. Templates are authored free of other violations, so nothing
+ * else needs fixing here, and the user's own `lint --configuration=fix` remains
+ * the full-fidelity path. A test re-checks these against ruff's own docs.
+ */
+export declare const FIXABLE_RULES: string[];
+/**
+ * The ruff release these bindings are built from. `@astral-sh/ruff-wasm-nodejs`
+ * is published from the ruff repo on every release, so its versions track ruff's
+ * exactly — keep this in step with `PY_VERSIONS.ruff` (the ruff the vended
+ * `format` and `lint` targets run) so generated files stay `ruff format
+ * --check`-clean on disk. A test asserts the two agree.
+ */
+export declare const RUFF_WASM_VERSION: string;
+/** Ruff settings, as accepted by the WASM `Workspace` constructor. */
+export interface RuffOptions {
+    readonly 'line-length'?: number;
+    readonly 'target-version'?: string;
+    readonly lint?: {
+        readonly select?: readonly string[];
+        readonly 'extend-select'?: readonly string[];
+        readonly fixable?: readonly string[];
+        readonly unfixable?: readonly string[];
+        readonly isort?: {
+            readonly 'known-first-party'?: readonly string[];
+        };
+    };
+}
+/**
+ * Apply ruff's lint fixes and formatter to Python content, in process.
+ *
+ * Equivalent to piping the content through `ruff check --fix` then `ruff
+ * format` — the tools the vended `lint` and `format` targets run — without
+ * paying two process spawns per file.
+ */
+export declare const ruffFixAndFormat: (content: string, filePath: string, options: RuffOptions) => string;

package/src/utils/ruff.js

@@ -0,0 +1,140 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */ import { PositionEncoding, Workspace } from "@astral-sh/ruff-wasm-nodejs";
+import path from "path";
+/**
+ * Rules whose fixes are applied to generated Python.
+ *
+ * `ruff_wasm`'s `check` serialises every fix without its applicability (the
+ * `Fix::applicability()` it drops is what `ruff check --fix` filters on) and
+ * ignores `unsafe-fixes`, so it cannot be asked for only the fixes the CLI would
+ * apply. Taking them all would rewrite `if x == True` to `if x`.
+ *
+ * Ruff's `fixable` setting filters inside the linter, which keeps the decision
+ * in ruff — but it selects by *rule*, and applicability is a property of each
+ * *diagnostic*: across ruff's own 1598 lint fixtures, 27 rules under the vended
+ * selection emit both safe and unsafe fixes depending on the code (one `UP008`
+ * is safe, another is unsafe when dropping the arguments would take a comment
+ * with them). So no rule list, allowing or denying, can reproduce `--fix`: for
+ * those 27 it can only take both or neither.
+ *
+ * Given that, the list stays as small as generation needs rather than reaching
+ * for an equivalence it cannot have. These four cover the import hygiene
+ * generation itself creates by merging imports into existing files, and ruff
+ * documents each of their fixes as safe — except F401 in an `__init__.py`, which
+ * is excluded below. Templates are authored free of other violations, so nothing
+ * else needs fixing here, and the user's own `lint --configuration=fix` remains
+ * the full-fidelity path. A test re-checks these against ruff's own docs.
+ */ export const FIXABLE_RULES = [
+    'I001',
+    'F401',
+    'F811',
+    'E401'
+];
+/** Escape hatch matching ruff's own fix loop bound. */ const MAX_FIX_ITERATIONS = 100;
+/**
+ * The ruff release these bindings are built from. `@astral-sh/ruff-wasm-nodejs`
+ * is published from the ruff repo on every release, so its versions track ruff's
+ * exactly — keep this in step with `PY_VERSIONS.ruff` (the ruff the vended
+ * `format` and `lint` targets run) so generated files stay `ruff format
+ * --check`-clean on disk. A test asserts the two agree.
+ */ export const RUFF_WASM_VERSION = Workspace.version();
+/**
+ * Apply one diagnostic's fix, resolving ruff's (row, column) positions against
+ * the content. Positions are requested in UTF-16, which is how JavaScript
+ * already indexes strings, so they need no transcoding.
+ */ const applyFix = (content, edits)=>{
+    const lineStarts = [
+        0
+    ];
+    for(let i = 0; i < content.length; i++){
+        if (content[i] === '\n') {
+            lineStarts.push(i + 1);
+        }
+    }
+    // Ruff can report a position one past the last line (eg when deleting a
+    // trailing line), so clamp rather than indexing past the end.
+    const offsetOf = (location)=>(lineStarts[location.row - 1] ?? content.length) + (location.column - 1);
+    let result = '';
+    let end = 0;
+    for (const edit of [
+        ...edits
+    ].sort((a, b)=>offsetOf(a.location) - offsetOf(b.location))){
+        const start = offsetOf(edit.location);
+        if (start < end) {
+            continue;
+        }
+        result += content.slice(end, start) + (edit.content ?? '');
+        end = offsetOf(edit.end_location);
+    }
+    return result + content.slice(end);
+};
+/**
+ * Ruff treats an `__init__.py` as re-exporting its imports, so an unused import
+ * there gets a diagnostic with no fix — removing it would drop the package's
+ * public API. `ruff_wasm` lints under a fixed placeholder filename and so cannot
+ * apply this itself, making the file's real name the caller's to account for.
+ */ const isInitPy = (filePath)=>path.basename(filePath) === '__init__.py';
+/**
+ * A `Workspace` costs far more to construct than to run, and the same settings
+ * recur across every file of a project, so key them by the resolved options.
+ */ const _workspaces = new Map();
+const getWorkspace = (options)=>{
+    const key = JSON.stringify(options);
+    let workspace = _workspaces.get(key);
+    if (!workspace) {
+        workspace = new Workspace(options, PositionEncoding.Utf16);
+        _workspaces.set(key, workspace);
+    }
+    return workspace;
+};
+/**
+ * Apply ruff's lint fixes and formatter to Python content, in process.
+ *
+ * Equivalent to piping the content through `ruff check --fix` then `ruff
+ * format` — the tools the vended `lint` and `format` targets run — without
+ * paying two process spawns per file.
+ */ export const ruffFixAndFormat = (content, filePath, options)=>{
+    const workspace = getWorkspace({
+        ...options,
+        lint: {
+            ...options.lint,
+            fixable: FIXABLE_RULES,
+            // Never drop an `__init__.py` import: ruff keeps these as re-exports.
+            ...isInitPy(filePath) ? {
+                unfixable: [
+                    'F401'
+                ]
+            } : {}
+        }
+    });
+    // Apply a single fix per pass and re-lint, as ruff does until the content
+    // stabilises. Taking one fix at a time leaves ruff to decide what is
+    // applicable against the current content, rather than reproducing how it
+    // batches, orders and skips overlapping fixes within a pass.
+    for(let i = 0; i < MAX_FIX_ITERATIONS; i++){
+        let diagnostic;
+        try {
+            diagnostic = workspace.check(content).find((d)=>d.fix && d.fix.edits.length > 0);
+        } catch  {
+            break;
+        }
+        if (!diagnostic?.fix) {
+            break;
+        }
+        const fixed = applyFix(content, diagnostic.fix.edits);
+        if (fixed === content) {
+            break;
+        }
+        content = fixed;
+    }
+    try {
+        return workspace.format(content);
+    } catch  {
+        // Leave content the formatter rejects (eg a syntax error) as-is.
+        return content;
+    }
+};
+
+//# sourceMappingURL=ruff.js.map

package/src/utils/ruff.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../packages/nx-plugin/src/utils/ruff.ts"],"sourcesContent":["/**\n * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport { PositionEncoding, Workspace } from '@astral-sh/ruff-wasm-nodejs';\nimport path from 'path';\n\n/**\n * Rules whose fixes are applied to generated Python.\n *\n * `ruff_wasm`'s `check` serialises every fix without its applicability (the\n * `Fix::applicability()` it drops is what `ruff check --fix` filters on) and\n * ignores `unsafe-fixes`, so it cannot be asked for only the fixes the CLI would\n * apply. Taking them all would rewrite `if x == True` to `if x`.\n *\n * Ruff's `fixable` setting filters inside the linter, which keeps the decision\n * in ruff — but it selects by *rule*, and applicability is a property of each\n * *diagnostic*: across ruff's own 1598 lint fixtures, 27 rules under the vended\n * selection emit both safe and unsafe fixes depending on the code (one `UP008`\n * is safe, another is unsafe when dropping the arguments would take a comment\n * with them). So no rule list, allowing or denying, can reproduce `--fix`: for\n * those 27 it can only take both or neither.\n *\n * Given that, the list stays as small as generation needs rather than reaching\n * for an equivalence it cannot have. These four cover the import hygiene\n * generation itself creates by merging imports into existing files, and ruff\n * documents each of their fixes as safe — except F401 in an `__init__.py`, which\n * is excluded below. Templates are authored free of other violations, so nothing\n * else needs fixing here, and the user's own `lint --configuration=fix` remains\n * the full-fidelity path. A test re-checks these against ruff's own docs.\n */\nexport const FIXABLE_RULES = ['I001', 'F401', 'F811', 'E401'];\n\n/** Escape hatch matching ruff's own fix loop bound. */\nconst MAX_FIX_ITERATIONS = 100;\n\n/**\n * The ruff release these bindings are built from. `@astral-sh/ruff-wasm-nodejs`\n * is published from the ruff repo on every release, so its versions track ruff's\n * exactly — keep this in step with `PY_VERSIONS.ruff` (the ruff the vended\n * `format` and `lint` targets run) so generated files stay `ruff format\n * --check`-clean on disk. A test asserts the two agree.\n */\nexport const RUFF_WASM_VERSION = Workspace.version();\n\ninterface Location {\n  readonly row: number;\n  readonly column: number;\n}\n\ninterface Edit {\n  readonly content: string | null;\n  readonly location: Location;\n  readonly end_location: Location;\n}\n\ninterface Diagnostic {\n  readonly fix: { readonly edits: readonly Edit[] } | null;\n}\n\n/** Ruff settings, as accepted by the WASM `Workspace` constructor. */\nexport interface RuffOptions {\n  readonly 'line-length'?: number;\n  readonly 'target-version'?: string;\n  readonly lint?: {\n    readonly select?: readonly string[];\n    readonly 'extend-select'?: readonly string[];\n    readonly fixable?: readonly string[];\n    readonly unfixable?: readonly string[];\n    readonly isort?: { readonly 'known-first-party'?: readonly string[] };\n  };\n}\n\n/**\n * Apply one diagnostic's fix, resolving ruff's (row, column) positions against\n * the content. Positions are requested in UTF-16, which is how JavaScript\n * already indexes strings, so they need no transcoding.\n */\nconst applyFix = (content: string, edits: readonly Edit[]): string => {\n  const lineStarts = [0];\n  for (let i = 0; i < content.length; i++) {\n    if (content[i] === '\\n') {\n      lineStarts.push(i + 1);\n    }\n  }\n  // Ruff can report a position one past the last line (eg when deleting a\n  // trailing line), so clamp rather than indexing past the end.\n  const offsetOf = (location: Location): number =>\n    (lineStarts[location.row - 1] ?? content.length) + (location.column - 1);\n\n  let result = '';\n  let end = 0;\n  for (const edit of [...edits].sort(\n    (a, b) => offsetOf(a.location) - offsetOf(b.location),\n  )) {\n    const start = offsetOf(edit.location);\n    if (start < end) {\n      continue;\n    }\n    result += content.slice(end, start) + (edit.content ?? '');\n    end = offsetOf(edit.end_location);\n  }\n  return result + content.slice(end);\n};\n\n/**\n * Ruff treats an `__init__.py` as re-exporting its imports, so an unused import\n * there gets a diagnostic with no fix — removing it would drop the package's\n * public API. `ruff_wasm` lints under a fixed placeholder filename and so cannot\n * apply this itself, making the file's real name the caller's to account for.\n */\nconst isInitPy = (filePath: string): boolean =>\n  path.basename(filePath) === '__init__.py';\n\n/**\n * A `Workspace` costs far more to construct than to run, and the same settings\n * recur across every file of a project, so key them by the resolved options.\n */\nconst _workspaces = new Map<string, Workspace>();\nconst getWorkspace = (options: RuffOptions): Workspace => {\n  const key = JSON.stringify(options);\n  let workspace = _workspaces.get(key);\n  if (!workspace) {\n    workspace = new Workspace(options, PositionEncoding.Utf16);\n    _workspaces.set(key, workspace);\n  }\n  return workspace;\n};\n\n/**\n * Apply ruff's lint fixes and formatter to Python content, in process.\n *\n * Equivalent to piping the content through `ruff check --fix` then `ruff\n * format` — the tools the vended `lint` and `format` targets run — without\n * paying two process spawns per file.\n */\nexport const ruffFixAndFormat = (\n  content: string,\n  filePath: string,\n  options: RuffOptions,\n): string => {\n  const workspace = getWorkspace({\n    ...options,\n    lint: {\n      ...options.lint,\n      fixable: FIXABLE_RULES,\n      // Never drop an `__init__.py` import: ruff keeps these as re-exports.\n      ...(isInitPy(filePath) ? { unfixable: ['F401'] } : {}),\n    },\n  });\n\n  // Apply a single fix per pass and re-lint, as ruff does until the content\n  // stabilises. Taking one fix at a time leaves ruff to decide what is\n  // applicable against the current content, rather than reproducing how it\n  // batches, orders and skips overlapping fixes within a pass.\n  for (let i = 0; i < MAX_FIX_ITERATIONS; i++) {\n    let diagnostic: Diagnostic | undefined;\n    try {\n      diagnostic = (workspace.check(content) as Diagnostic[]).find(\n        (d) => d.fix && d.fix.edits.length > 0,\n      );\n    } catch {\n      // Content that does not parse has nothing to fix; still try to format it.\n      break;\n    }\n    if (!diagnostic?.fix) {\n      break;\n    }\n    const fixed = applyFix(content, diagnostic.fix.edits);\n    if (fixed === content) {\n      break;\n    }\n    content = fixed;\n  }\n\n  try {\n    return workspace.format(content);\n  } catch {\n    // Leave content the formatter rejects (eg a syntax error) as-is.\n    return content;\n  }\n};\n"],"names":["PositionEncoding","Workspace","path","FIXABLE_RULES","MAX_FIX_ITERATIONS","RUFF_WASM_VERSION","version","applyFix","content","edits","lineStarts","i","length","push","offsetOf","location","row","column","result","end","edit","sort","a","b","start","slice","end_location","isInitPy","filePath","basename","_workspaces","Map","getWorkspace","options","key","JSON","stringify","workspace","get","Utf16","set","ruffFixAndFormat","lint","fixable","unfixable","diagnostic","check","find","d","fix","fixed","format"],"mappings":"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"}

package/src/utils/toml.d.ts

@@ -12,3 +12,8 @@ export declare const updateToml: (tree: Tree, filePath: string, updater: (prev:
  * Read a toml file
  */
 export declare const readToml: (tree: Tree, filePath: string) => TOML.JsonMap;
+/**
+ * Read a toml file, treating one that is missing or cannot be parsed as absent.
+ * For callers that probe for optional configuration rather than requiring it.
+ */
+export declare const tryReadToml: (tree: Tree, filePath: string) => TOML.JsonMap | undefined;

package/src/utils/toml.js

@@ -16,5 +16,15 @@
     }
     return TOML.parse(tree.read(filePath, 'utf-8'));
 };
+/**
+ * Read a toml file, treating one that is missing or cannot be parsed as absent.
+ * For callers that probe for optional configuration rather than requiring it.
+ */ export const tryReadToml = (tree, filePath)=>{
+    try {
+        return readToml(tree, filePath);
+    } catch  {
+        return undefined;
+    }
+};
 
 //# sourceMappingURL=toml.js.map

package/src/utils/toml.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../packages/nx-plugin/src/utils/toml.ts"],"sourcesContent":["/**\n * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport TOML from '@iarna/toml';\nimport type { Tree } from '@nx/devkit';\n\n/**\n * Update a toml file\n */\nexport const updateToml = (\n  tree: Tree,\n  filePath: string,\n  updater: (prev: TOML.JsonMap) => TOML.JsonMap,\n) => {\n  const prev = readToml(tree, filePath);\n  tree.write(filePath, TOML.stringify(updater(prev)));\n};\n\n/**\n * Read a toml file\n */\nexport const readToml = (tree: Tree, filePath: string): TOML.JsonMap => {\n  if (!tree.exists(filePath)) {\n    throw new Error(`${filePath} does not exist`);\n  }\n  return TOML.parse(tree.read(filePath, 'utf-8'));\n};\n"],"names":["TOML","updateToml","tree","filePath","updater","prev","readToml","write","stringify","exists","Error","parse","read"],"mappings":"AAAA;;;CAGC,GAED,OAAOA,UAAU,cAAc;AAG/B;;CAEC,GACD,OAAO,MAAMC,aAAa,CACxBC,MACAC,UACAC;IAEA,MAAMC,OAAOC,SAASJ,MAAMC;IAC5BD,KAAKK,KAAK,CAACJ,UAAUH,KAAKQ,SAAS,CAACJ,QAAQC;AAC9C,EAAE;AAEF;;CAEC,GACD,OAAO,MAAMC,WAAW,CAACJ,MAAYC;IACnC,IAAI,CAACD,KAAKO,MAAM,CAACN,WAAW;QAC1B,MAAM,IAAIO,MAAM,GAAGP,SAAS,eAAe,CAAC;IAC9C;IACA,OAAOH,KAAKW,KAAK,CAACT,KAAKU,IAAI,CAACT,UAAU;AACxC,EAAE"}
+{"version":3,"sources":["../../../../../packages/nx-plugin/src/utils/toml.ts"],"sourcesContent":["/**\n * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n * SPDX-License-Identifier: Apache-2.0\n */\n\nimport TOML from '@iarna/toml';\nimport type { Tree } from '@nx/devkit';\n\n/**\n * Update a toml file\n */\nexport const updateToml = (\n  tree: Tree,\n  filePath: string,\n  updater: (prev: TOML.JsonMap) => TOML.JsonMap,\n) => {\n  const prev = readToml(tree, filePath);\n  tree.write(filePath, TOML.stringify(updater(prev)));\n};\n\n/**\n * Read a toml file\n */\nexport const readToml = (tree: Tree, filePath: string): TOML.JsonMap => {\n  if (!tree.exists(filePath)) {\n    throw new Error(`${filePath} does not exist`);\n  }\n  return TOML.parse(tree.read(filePath, 'utf-8'));\n};\n\n/**\n * Read a toml file, treating one that is missing or cannot be parsed as absent.\n * For callers that probe for optional configuration rather than requiring it.\n */\nexport const tryReadToml = (\n  tree: Tree,\n  filePath: string,\n): TOML.JsonMap | undefined => {\n  try {\n    return readToml(tree, filePath);\n  } catch {\n    return undefined;\n  }\n};\n"],"names":["TOML","updateToml","tree","filePath","updater","prev","readToml","write","stringify","exists","Error","parse","read","tryReadToml","undefined"],"mappings":"AAAA;;;CAGC,GAED,OAAOA,UAAU,cAAc;AAG/B;;CAEC,GACD,OAAO,MAAMC,aAAa,CACxBC,MACAC,UACAC;IAEA,MAAMC,OAAOC,SAASJ,MAAMC;IAC5BD,KAAKK,KAAK,CAACJ,UAAUH,KAAKQ,SAAS,CAACJ,QAAQC;AAC9C,EAAE;AAEF;;CAEC,GACD,OAAO,MAAMC,WAAW,CAACJ,MAAYC;IACnC,IAAI,CAACD,KAAKO,MAAM,CAACN,WAAW;QAC1B,MAAM,IAAIO,MAAM,GAAGP,SAAS,eAAe,CAAC;IAC9C;IACA,OAAOH,KAAKW,KAAK,CAACT,KAAKU,IAAI,CAACT,UAAU;AACxC,EAAE;AAEF;;;CAGC,GACD,OAAO,MAAMU,cAAc,CACzBX,MACAC;IAEA,IAAI;QACF,OAAOG,SAASJ,MAAMC;IACxB,EAAE,OAAM;QACN,OAAOW;IACT;AACF,EAAE"}

package/src/utils/warm-ruff-cache.d.ts

@@ -1,8 +0,0 @@
-/**
- * Vitest globalSetup that warms uv's tool cache once before any worker spawns,
- * installing the exact pinned ruff the formatter runs. On a cold cache the
- * first uvx call holds an exclusive lock on uv's cache, so parallel workers
- * would otherwise stall racing it. Failure is ignored — the formatter skips
- * ruff when uv is unavailable.
- */
-export default function setup(): void;

package/src/utils/warm-ruff-cache.js

@@ -1,30 +0,0 @@
-/**
- * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
- * SPDX-License-Identifier: Apache-2.0
- */ import { execFileSync } from "child_process";
-import { withPyVersions } from "./versions.js";
-/**
- * Vitest globalSetup that warms uv's tool cache once before any worker spawns,
- * installing the exact pinned ruff the formatter runs. On a cold cache the
- * first uvx call holds an exclusive lock on uv's cache, so parallel workers
- * would otherwise stall racing it. Failure is ignored — the formatter skips
- * ruff when uv is unavailable.
- */ export default function setup() {
-    const ruff = withPyVersions([
-        'ruff'
-    ])[0];
-    try {
-        execFileSync('uvx', [
-            '--from',
-            ruff,
-            'ruff',
-            '--version'
-        ], {
-            stdio: 'ignore'
-        });
-    } catch  {
-    // Ignore — the formatter skips ruff when it is unavailable
-    }
-}
-
-//# sourceMappingURL=warm-ruff-cache.js.map

package/src/utils/warm-ruff-cache.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../packages/nx-plugin/src/utils/warm-ruff-cache.ts"],"sourcesContent":["/**\n * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n * SPDX-License-Identifier: Apache-2.0\n */\nimport { execFileSync } from 'child_process';\nimport { withPyVersions } from './versions';\n\n/**\n * Vitest globalSetup that warms uv's tool cache once before any worker spawns,\n * installing the exact pinned ruff the formatter runs. On a cold cache the\n * first uvx call holds an exclusive lock on uv's cache, so parallel workers\n * would otherwise stall racing it. Failure is ignored — the formatter skips\n * ruff when uv is unavailable.\n */\nexport default function setup() {\n  const ruff = withPyVersions(['ruff'])[0];\n  try {\n    execFileSync('uvx', ['--from', ruff, 'ruff', '--version'], {\n      stdio: 'ignore',\n    });\n  } catch {\n    // Ignore — the formatter skips ruff when it is unavailable\n  }\n}\n"],"names":["execFileSync","withPyVersions","setup","ruff","stdio"],"mappings":"AAAA;;;CAGC,GACD,SAASA,YAAY,QAAQ,gBAAgB;AAC7C,SAASC,cAAc,QAAQ,gBAAa;AAE5C;;;;;;CAMC,GACD,eAAe,SAASC;IACtB,MAAMC,OAAOF,eAAe;QAAC;KAAO,CAAC,CAAC,EAAE;IACxC,IAAI;QACFD,aAAa,OAAO;YAAC;YAAUG;YAAM;YAAQ;SAAY,EAAE;YACzDC,OAAO;QACT;IACF,EAAE,OAAM;IACN,2DAA2D;IAC7D;AACF"}