@mittwald/flow-codemods 1.2.0-next.9 → 1.2.0

package/dist/catalog/entries.d.ts

@@ -14,4 +14,3 @@ export declare const allEntries: CatalogEntry[];
  * rather than kept in sync by hand in both places.
  */
 export declare const unknownCodemodMessage: (id: string) => string;
-//# sourceMappingURL=entries.d.ts.map

package/dist/catalog/select.d.ts

@@ -25,4 +25,3 @@ export declare const sortBySince: (entries: CatalogEntry[]) => CatalogEntry[];
  * of the gate hiding it.
  */
 export declare const selectEntries: (entries: CatalogEntry[], target: string) => CatalogEntry[];
-//# sourceMappingURL=select.d.ts.map

package/dist/catalog/types.d.ts

@@ -45,4 +45,3 @@ export interface MigrationEntry {
     /** The guide entry as Markdown. Headings inside it start at level 4. */
     body: string;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/cli/args.d.ts

@@ -19,4 +19,3 @@ export interface ParsedCommand {
     allowDirty: boolean;
 }
 export declare const parseArguments: (argv: string[]) => ParsedCommand;
-//# sourceMappingURL=args.d.ts.map

package/dist/cli/choose.d.ts

@@ -28,4 +28,3 @@ export interface CreateChooseInput {
  * distinguishes a human from an unattended runner there.
  */
 export declare const createChoose: ({ yes, isTTY, isCI, prompt, onCancel, }: CreateChooseInput) => ((entries: CatalogEntry[]) => Promise<CatalogEntry[]>);
-//# sourceMappingURL=choose.d.ts.map

package/dist/cli/codemod.d.ts

@@ -37,4 +37,3 @@ export interface CodemodCommandDeps {
     run?: typeof runCodemod;
 }
 export declare const runSingleCodemod: (parsed: ParsedCommand, { cwd, log, run }: CodemodCommandDeps) => Promise<number>;
-//# sourceMappingURL=codemod.d.ts.map

package/dist/cli/list.d.ts

@@ -97,4 +97,3 @@ export declare const defaultListDeps: (cwd: string) => ListDeps;
  * and prints "Nothing to migrate in that range.").
  */
 export declare const runList: (parsed: ParsedCommand, deps: ListDeps) => Promise<number>;
-//# sourceMappingURL=list.d.ts.map

package/dist/cli/upgrade.d.ts

@@ -13,6 +13,13 @@ export interface UpgradeDeps {
     isDirty: (cwd: string) => boolean;
     readInstalledVersion: (cwd: string, name: string) => string | undefined;
     log: (message: string) => void;
+    /**
+     * Emit ANSI colour in the by-hand list. Off by default so a test sees plain
+     * text.
+     */
+    color?: boolean;
+    /** Terminal width to wrap the by-hand list's prose to. */
+    width?: number;
 }
 export declare const defaultUpgradeDeps: (cwd: string) => UpgradeDeps;
 /**
@@ -31,4 +38,3 @@ export declare const defaultUpgradeDeps: (cwd: string) => UpgradeDeps;
  * genuinely have nothing to do.
  */
 export declare const runUpgrade: (parsed: ParsedCommand, deps: UpgradeDeps) => Promise<number>;
-//# sourceMappingURL=upgrade.d.ts.map

package/dist/cli/upgrade.js

@@ -187,26 +187,20 @@ export const runUpgrade = async (parsed, deps) => {
             log(`  ${entry.id}: ${result.changed} file(s) changed`);
         }
     }
-    // Selection has no lower bound (see `selectEntries`), so this loop can run
-    // every codemod in the catalogue on a project that never crossed a version
-    // at all — "N run, 0 changed" is the confirmation that there was nothing to
-    // catch up on, not a list of new work.
-    if (ranCount > 0) {
-        log(`\n${ranCount} codemod${ranCount === 1 ? "" : "s"} run, ${changedCount} changed something.`);
-    }
     if (byHand.length > 0) {
         log(`\n${byHand.length} migration(s) in this range have no codemod — apply them by hand:\n`);
-        // `frame: false` — this already printed the heading above and, further
-        // down, its own aggregate ("N codemods run, N changed something");
-        // renderList's own frame (the range/legend on top, the counts at the
-        // bottom) would just repeat both for the same list. `range` is still
-        // passed so each entry gets its catch-up mark — a manual entry that
-        // shipped at or before `current` may already be done, and the mark is
-        // the only thing left that says so now that hiding it is gone.
+        // `frame: false` — this already printed the heading above, and the
+        // closing summaries below cover the same aggregate ("N codemods run, N
+        // changed something") renderList's own frame would otherwise repeat.
+        // `range` is still passed so each entry gets its catch-up mark — a manual
+        // entry that shipped at or before `current` may already be done, and the
+        // mark is the only thing left that says so now that hiding it is gone.
         log(renderList({
             entries: byHand,
             range: { from: current, to: target },
             json: false,
+            color: deps.color,
+            width: deps.width,
             // The same path this run used, so a command copied out of the by-hand
             // block works instead of falling back to a hardcoded `src`.
             path: displaySourcePath(parsed.path, cwd),
@@ -217,6 +211,16 @@ export const runUpgrade = async (parsed, deps) => {
     else {
         log("\nNo migration in this range required a change by hand.");
     }
+    // Both closing summaries trail everything else, not just each other: a
+    // multi-screen by-hand list would otherwise scroll them out of sight before
+    // the reader reaches the end — exactly when they want the counts. Selection
+    // has no lower bound (see `selectEntries`), so this loop can run every
+    // codemod in the catalogue on a project that never crossed a version at
+    // all — "N run, 0 changed" is the confirmation that there was nothing to
+    // catch up on, not a list of new work.
+    if (ranCount > 0) {
+        log(`\n${ranCount} codemod${ranCount === 1 ? "" : "s"} run, ${changedCount} changed something.`);
+    }
     if (incomplete.length > 0) {
         log(`\n${incomplete.length} codemod(s) did not complete: ${incomplete.join(", ")}`);
     }

package/dist/cli.d.ts

@@ -1,3 +1,2 @@
 #!/usr/bin/env node
 export {};
-//# sourceMappingURL=cli.d.ts.map

package/dist/cli.js

@@ -107,6 +107,10 @@ const main = async () => {
             return runUpgrade(parsed, {
                 ...defaultUpgradeDeps(process.cwd()),
                 choose,
+                // Same rule as `list`: colour only for a person at a real terminal,
+                // off under `NO_COLOR` or a pipe so the output stays greppable.
+                color: process.stdout.isTTY === true && process.env.NO_COLOR === undefined,
+                width: Math.min(Math.max(process.stdout.columns ?? 80, 60), 100),
             });
         }
         default:

package/dist/flowPackages.generated.d.ts

@@ -1,3 +1,2 @@
 /** Every package published from the Flow monorepo, which all share one version. */
 export declare const flowPackages: string[];
-//# sourceMappingURL=flowPackages.generated.d.ts.map

package/dist/git.d.ts

@@ -10,4 +10,3 @@
  * would block a legitimate run for a reason the consumer cannot fix.
  */
 export declare const hasUncommittedChanges: (cwd: string) => boolean;
-//# sourceMappingURL=git.d.ts.map

package/dist/install.d.ts

@@ -133,4 +133,3 @@ export declare const runInstall: InstallRunner;
  * can run.
  */
 export declare const resolveInvoke: (cwd: string, pkg?: string) => Promise<string>;
-//# sourceMappingURL=install.d.ts.map

package/dist/manifest.d.ts

@@ -42,4 +42,3 @@ export declare const applyTarget: <T extends Manifest>(manifest: T, target: stri
  * `imports-to-package-root` needed an explicit leave-alone set to earn this.
  */
 export declare const detectCurrentVersion: (dependencies: FlowDependency[], readInstalledVersion: (name: string) => string | undefined) => string | undefined;
-//# sourceMappingURL=manifest.d.ts.map

package/dist/migrations/action-prop-to-on-action/transform.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 /**
- * Renames the `action` prop to `onAction` on `Action`.
+ * Renames the `action` prop to `onAction` on `Action`, and wraps a bare
+ * function reference passed to it in an inline call.
  *
  * The scope is deliberately narrow. Only JSX elements that resolve to `Action`
  * — imported (named or as a namespace) from `@mittwald/flow-react-components`
@@ -14,6 +15,44 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * An element that already carries `onAction` keeps it and only loses the stale
  * `action` prop, which mirrors what the runtime fallback does: an explicit
  * `onAction` wins.
+ *
+ * ## Why the wrap is unconditional
+ *
+ * `onAction` is typed `ActionFn` (`(...args: unknown[]) => unknown`), so a
+ * reference to a function declaring a parameter of any narrower type — the
+ * usual case being `controller.close`, typed `(options?: CloseOverlayOptions)
+ * => void` — does not type-check. Whether a given reference declares such a
+ * parameter needs type information and is not decidable from the source, which
+ * is why this transform used to leave every reference alone and `apply` asked
+ * for a manual pass over all of them.
+ *
+ * Deciding _whether_ to wrap needs the type. _Performing_ the wrap does not:
+ * `() => fn()` calls exactly what `fn` would have been called with by `Action`,
+ * minus the arguments — and `onAction` is documented as taking none. So the
+ * wrap fixes the reference that needed it and is a no-op for the rest, which
+ * makes the decision unnecessary.
+ *
+ * Two cases it can still change, neither decidable from the source:
+ *
+ * - A handler that reads the argument `Action` forwards (the trigger's event,
+ *   e.g. a `PressEvent` from the `Button` inside) and declares it optional or
+ *   as a rest parameter, so that it type-checks both before and after. It stops
+ *   receiving that argument, silently. Nothing in Flow documents `onAction` as
+ *   receiving one.
+ * - A possibly-undefined reference, `onAction={props.onAction}`. `undefined` is a
+ *   valid value for the prop, but calling it is not, so the wrap turns
+ *   something TypeScript accepted into something it rejects — loudly, at the
+ *   call site, which is why this is a compile error to fix rather than a
+ *   regression to find.
+ *
+ * `apply` names both.
+ *
+ * Only a bare reference is wrapped: a plain identifier or a member expression.
+ * An arrow function and a function expression already are the handler. A call
+ * (`makeHandler()`, `close.bind(controller)`) _produces_ the handler, so
+ * wrapping it would call the factory on every trigger and throw its result
+ * away. A conditional, a `??` chain or an optional member expression is not a
+ * reference to one function, so wrapping would be a guess.
  */
 const actionPropToOnActionTransform = (fileInfo, { j }) => {
     const flowPackages = [
@@ -22,6 +61,27 @@ const actionPropToOnActionTransform = (fileInfo, { j }) => {
     ];
     const affectedComponents = new Set(["Action"]);
     const isFlowImport = (source) => flowPackages.some((pkg) => source === pkg || source.startsWith(`${pkg}/`));
+    /**
+     * Whether a member expression is rooted in a plain reference —
+     * `controller.close`, `this.handleSave`, `store.modal.controller.close` —
+     * rather than in something evaluated, as `makeController().close` is.
+     *
+     * An optional link disqualifies the chain. `controller?.close` parses as
+     * `OptionalMemberExpression` and never reaches here at all; walking the chain
+     * catches a mixed one like `(a?.b).c`. Declining is deliberate: `() =>
+     * controller?.close()` short-circuits differently from the value it would
+     * replace, and the spelling says the reference may not be there.
+     */
+    const hasPlainObjectChain = (expression) => {
+        const object = expression.object;
+        if (!object || typeof object !== "object" || !("type" in object)) {
+            return false;
+        }
+        const typed = object;
+        return (typed.type === "ThisExpression" ||
+            typed.type === "Identifier" ||
+            (typed.type === "MemberExpression" && hasPlainObjectChain(typed)));
+    };
     const root = j(fileInfo.source, { parser: "tsx" });
     // Local JSX identifier -> canonical component name (resolves `as` aliases).
     const localToComponent = new Map();
@@ -69,12 +129,38 @@ const actionPropToOnActionTransform = (fileInfo, { j }) => {
         const hasOnAction = attributes.some((attribute) => isNamed(attribute, "onAction"));
         if (hasOnAction) {
             path.node.attributes = attributes.filter((attribute) => !isNamed(attribute, "action"));
-            return;
         }
-        for (const attribute of attributes) {
-            if (isNamed(attribute, "action") && attribute.type === "JSXAttribute") {
-                attribute.name.name = "onAction";
+        else {
+            for (const attribute of attributes) {
+                if (isNamed(attribute, "action") && attribute.type === "JSXAttribute") {
+                    attribute.name.name = "onAction";
+                }
+            }
+        }
+        // Whatever the prop was called before, the surviving `onAction` is the one
+        // that needs the wrap — including one the consumer had already renamed by
+        // hand, which carries the same type error.
+        for (const attribute of path.node.attributes ?? []) {
+            if (attribute.type !== "JSXAttribute" ||
+                !isNamed(attribute, "onAction")) {
+                continue;
+            }
+            const container = attribute.value;
+            if (container?.type !== "JSXExpressionContainer") {
+                continue;
+            }
+            // A bare reference is an identifier or a member expression. Everything
+            // else either is the handler already or is a way of producing one.
+            const expression = container.expression;
+            if (expression.type !== "Identifier" &&
+                expression.type !== "MemberExpression") {
+                continue;
+            }
+            if (expression.type === "MemberExpression" &&
+                !hasPlainObjectChain(expression)) {
+                continue;
             }
+            attribute.value = j.jsxExpressionContainer(j.arrowFunctionExpression([], j.callExpression(expression, [])));
         }
     });
     return root.toSource();

package/dist/migrations/imports-to-package-root/transform.js

@@ -29,6 +29,7 @@ const keptSubpaths = new Set([
     // the current export surface
     "internal",
     "flr-universal",
+    "tunnel",
     "nextjs",
     "react-hook-form",
     "mittwald-password-tools-js",
@@ -39,6 +40,21 @@ const keptSubpaths = new Set([
     // owned by password-tools-subpath-renamed
     "password-tools",
 ]);
+/**
+ * Splits a bundler's asset query or fragment off a specifier. `all.css?url` is
+ * the subpath `all.css`, requested as a URL — not a subpath named
+ * `all.css?url`. Matching the whole string carried the suffix past the
+ * leave-alone set and into the catch-all below, which rewrote `import
+ * flowStyles from "…/all.css?url"` into a named import of a JS export that does
+ * not exist, and `import "…/all-layered.css?inline"` into a side-effect import
+ * of the package root — stylesheet gone, no error anywhere.
+ */
+const splitAssetSuffix = (subpath) => {
+    const suffixAt = subpath.search(/[?#]/);
+    return suffixAt === -1
+        ? [subpath, ""]
+        : [subpath.slice(0, suffixAt), subpath.slice(suffixAt)];
+};
 const importsToPackageRootTransform = (fileInfo, { j }) => {
     const flowPackage = "@mittwald/flow-react-components";
     const root = j(fileInfo.source, {
@@ -50,14 +66,21 @@ const importsToPackageRootTransform = (fileInfo, { j }) => {
         .forEach((i) => {
         const specifiers = i.node.specifiers ?? [];
         const importPath = String(i.node.source.value);
-        const importRelativePath = importPath.slice(flowPackage.length + 1);
+        const [importRelativePath, assetSuffix] = splitAssetSuffix(importPath.slice(flowPackage.length + 1));
         if (keptSubpaths.has(importRelativePath)) {
             return;
         }
         if (importRelativePath === "all.css" ||
             importRelativePath === "globals.css" ||
             importRelativePath === "global.css") {
-            i.node.source.value = `${flowPackage}/all.css`;
+            i.node.source.value = `${flowPackage}/all.css${assetSuffix}`;
+            return;
+        }
+        // Everything below rewrites a *module* import: it moves the specifier
+        // onto a JS entry and turns a default specifier into a named one. An
+        // asset import survives neither, and a suffix reaching this point names a
+        // path this transform cannot resolve to an export — leave it to a human.
+        if (assetSuffix !== "") {
             return;
         }
         if (importRelativePath.startsWith("react-hook-form")) {

package/dist/migrations/password-tools-rule/transform.js

@@ -23,11 +23,22 @@ const passwordToolsRuleTransform = (fileInfo, { j }) => {
     const flowPackages = [
         "@mittwald/flow-react-components/mittwald-password-tools-js",
     ];
+    /**
+     * The same entry under the name it had when this change shipped. It was
+     * renamed later (alpha.1000, `password-tools-subpath-renamed`), and `since`
+     * puts that rename _after_ this transform — so a consumer coming from before
+     * alpha.802 still spells the import `password-tools` when this runs, and
+     * matching only the current name left `AsyncRule` untouched for the rename to
+     * carry onto an entry that does not export it. Kept out of `flowPackages`
+     * because `remoteScope.test.ts` holds every name in there against the export
+     * map the packages have _today_, where this one is gone.
+     */
+    const renamedFlowPackage = "@mittwald/flow-react-components/password-tools";
     const renames = new Map([
         ["AsyncRule", "Rule"],
         ["SyncRule", "Rule"],
     ]);
-    const isFlowImport = (source) => flowPackages.includes(source);
+    const isFlowImport = (source) => flowPackages.includes(source) || source === renamedFlowPackage;
     // ast-types models `importKind` on the declaration only, while babel also
     // puts it on the specifier — which is where a per-specifier `type X` lives.
     const isTypeOnly = (specifier) => specifier.importKind === "type";

package/dist/migrations/popover-open-state-props/transform.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Renames the `defaultOpen` prop to `isDefaultOpen` on `Popover`,
+ * `ContextualHelp` and `ContextMenu`.
+ *
+ * The scope is deliberately narrow, and here that is not only about same-named
+ * components from other packages. `defaultOpen` is react-aria's own prop and
+ * Flow passes it straight through on `Select`, `MenuTrigger`, `Tooltip`,
+ * `TooltipTrigger`, `DialogTrigger`, `DatePicker` and `DateRangePicker`, where
+ * it did not change — renaming it there would remove a working prop.
+ *
+ * Only JSX elements that resolve to one of the three — imported (named or as a
+ * namespace) from `@mittwald/flow-react-components` or
+ * `@mittwald/flow-remote-react-components`, including their subpath entries —
+ * are touched.
+ *
+ * An element that already carries `isDefaultOpen` keeps it and only loses the
+ * stale `defaultOpen`, which mirrors the runtime: `isDefaultOpen` wins.
+ *
+ * The other two changes of this migration are not here. `isOpen` and
+ * `onOpenChange` changed behaviour, not spelling: whether a given `isOpen` is
+ * meant to control the popover, and whether an `onOpenChange` handler performed
+ * or suppressed the close, is not decidable from the source. `apply` asks for
+ * those by hand.
+ */
+const popoverOpenStatePropsTransform = (fileInfo, { j }) => {
+    const flowPackages = [
+        "@mittwald/flow-react-components",
+        "@mittwald/flow-remote-react-components",
+    ];
+    const affectedComponents = new Set([
+        "Popover",
+        "ContextualHelp",
+        "ContextMenu",
+    ]);
+    const isFlowImport = (source) => flowPackages.some((pkg) => source === pkg || source.startsWith(`${pkg}/`));
+    const root = j(fileInfo.source, { parser: "tsx" });
+    // Local JSX identifier -> canonical component name (resolves `as` aliases).
+    const localToComponent = new Map();
+    // Local names of `import * as Flow` namespace imports from a Flow package.
+    const flowNamespaces = new Set();
+    root
+        .find(j.ImportDeclaration)
+        .filter((path) => isFlowImport(String(path.node.source.value)))
+        .forEach((path) => {
+        for (const specifier of path.node.specifiers ?? []) {
+            if (specifier.type === "ImportSpecifier" &&
+                specifier.imported.type === "Identifier" &&
+                affectedComponents.has(specifier.imported.name)) {
+                localToComponent.set(String(specifier.local?.name ?? specifier.imported.name), String(specifier.imported.name));
+            }
+            else if (specifier.type === "ImportNamespaceSpecifier" &&
+                specifier.local) {
+                flowNamespaces.add(String(specifier.local.name));
+            }
+        }
+    });
+    if (localToComponent.size === 0 && flowNamespaces.size === 0) {
+        return fileInfo.source;
+    }
+    let changed = false;
+    root.find(j.JSXOpeningElement).forEach((path) => {
+        const name = path.node.name;
+        let isAffected = false;
+        if (name.type === "JSXIdentifier") {
+            isAffected = localToComponent.has(name.name);
+        }
+        else if (name.type === "JSXMemberExpression" &&
+            name.object.type === "JSXIdentifier" &&
+            name.property.type === "JSXIdentifier") {
+            isAffected =
+                flowNamespaces.has(name.object.name) &&
+                    affectedComponents.has(name.property.name);
+        }
+        if (!isAffected) {
+            return;
+        }
+        const attributes = path.node.attributes ?? [];
+        const isNamed = (attribute, key) => attribute.type === "JSXAttribute" &&
+            attribute.name.type === "JSXIdentifier" &&
+            attribute.name.name === key;
+        if (!attributes.some((attribute) => isNamed(attribute, "defaultOpen"))) {
+            return;
+        }
+        changed = true;
+        if (attributes.some((attribute) => isNamed(attribute, "isDefaultOpen"))) {
+            path.node.attributes = attributes.filter((attribute) => !isNamed(attribute, "defaultOpen"));
+            return;
+        }
+        for (const attribute of attributes) {
+            if (isNamed(attribute, "defaultOpen") &&
+                attribute.type === "JSXAttribute" &&
+                attribute.name.type === "JSXIdentifier") {
+                attribute.name.name = "isDefaultOpen";
+            }
+        }
+    });
+    return changed ? root.toSource() : fileInfo.source;
+};
+exports.default = popoverOpenStatePropsTransform;

package/dist/migrations/renamed-css-export/transform.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const oldPath = "@mittwald/flow-react-components/styles";
+const newPath = "@mittwald/flow-react-components/all.css";
+/**
+ * Rewrites the module specifier `@mittwald/flow-react-components/styles` to
+ * `@mittwald/flow-react-components/all.css` (alpha.292).
+ *
+ * The same shape as `password-tools-subpath-renamed`: one exact specifier, in
+ * every form that names a module — `import`, `import type`, `export … from`, a
+ * side-effect import, `import()` and `require()`. In practice it is nearly
+ * always the side-effect form (`import "…/styles"`), which is why that case is
+ * the one the fixtures lead with.
+ *
+ * Exact match on the path, not a prefix: `./styles` was a single export with
+ * nothing underneath it, so there is no deeper path to rewrite and no risk of
+ * touching an unrelated `styles` of someone else's. A bundler query or fragment
+ * (`?url`, `?inline`) is split off before that comparison and carried over — it
+ * addresses the export, it does not name a different one.
+ *
+ * What this cannot reach is an `@import` in a `.css` or `.scss` file —
+ * jscodeshift only walks the JavaScript and TypeScript extensions. `apply` says
+ * so.
+ */
+const renamedCssExportTransform = (fileInfo, { j }) => {
+    const root = j(fileInfo.source, { parser: "tsx" });
+    let changed = false;
+    // A bundler addresses an asset through a query or fragment on the specifier,
+    // so `…/styles?url` is the old export requested as a URL. The rename applies
+    // to it just the same: match the path, carry the suffix over. Comparing the
+    // whole string leaves it pointing at an export the package no longer has.
+    const rewrite = (node) => {
+        if (typeof node.value !== "string") {
+            return;
+        }
+        const suffixAt = node.value.search(/[?#]/);
+        const [path, suffix] = suffixAt === -1
+            ? [node.value, ""]
+            : [node.value.slice(0, suffixAt), node.value.slice(suffixAt)];
+        if (path !== oldPath) {
+            return;
+        }
+        node.value = `${newPath}${suffix}`;
+        changed = true;
+    };
+    // import … from "…", import "…"
+    root.find(j.ImportDeclaration).forEach((path) => rewrite(path.node.source));
+    // export … from "…", export * from "…"
+    root
+        .find(j.ExportNamedDeclaration)
+        .forEach((path) => path.node.source && rewrite(path.node.source));
+    root
+        .find(j.ExportAllDeclaration)
+        .forEach((path) => rewrite(path.node.source));
+    // import("…") and require("…")
+    root
+        .find(j.CallExpression)
+        .filter((path) => {
+        const callee = path.node.callee;
+        return (callee.type === "Import" ||
+            (callee.type === "Identifier" && callee.name === "require"));
+    })
+        .forEach((path) => {
+        const [argument] = path.node.arguments;
+        if (argument &&
+            (argument.type === "StringLiteral" || argument.type === "Literal")) {
+            rewrite(argument);
+        }
+    });
+    // Returning the source untouched keeps this file out of the "changed" count.
+    return changed ? root.toSource() : fileInfo.source;
+};
+exports.default = renamedCssExportTransform;

package/dist/migrations/table-column-width-props/transform.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Drops `maxWidth` from `TableColumn`, and drops `width`/`minWidth` where they
+ * were `null` (alpha.956).
+ *
+ * Two changes with different decidability, which is why the transform covers
+ * both but not equally:
+ *
+ * - **`maxWidth` always goes.** The prop was removed from the type, so an
+ *   explicit `maxWidth` attribute is wrong whatever its value is —
+ *   `maxWidth={400}` and `maxWidth={computed}` alike. Removing it does change
+ *   the rendered column (there is no maximum any more); that is the migration,
+ *   not a side effect.
+ * - **`width` and `minWidth` only go when the source says `null`.** The type
+ *   dropped `null`, and `null` meant "no explicit width", which is what
+ *   omitting the prop means now. Only the literal is decidable:
+ *   `width={maybeNull}` could be anything at runtime and is left alone, the way
+ *   `accent-box-color-to-background-color` leaves `color={expression}`.
+ *
+ * The scope is the same as its neighbours': only JSX elements that resolve to
+ * `TableColumn` — imported named, aliased, or through a namespace, from
+ * `@mittwald/flow-react-components` or
+ * `@mittwald/flow-remote-react-components`, including their subpath entries.
+ *
+ * A spread (`<TableColumn {...props} />`) carrying `maxWidth` is invisible
+ * here. The explicit attributes beside it are still handled; `apply` names the
+ * gap.
+ */
+const tableColumnWidthPropsTransform = (fileInfo, { j }) => {
+    const flowPackages = [
+        "@mittwald/flow-react-components",
+        "@mittwald/flow-remote-react-components",
+    ];
+    const affectedComponents = new Set(["TableColumn"]);
+    /** Removed from the type — an explicit attribute is wrong at any value. */
+    const removedProps = new Set(["maxWidth"]);
+    /** Retyped without `null` — remove only where the source literally says so. */
+    const nullableProps = new Set(["width", "minWidth"]);
+    const isFlowImport = (source) => flowPackages.some((pkg) => source === pkg || source.startsWith(`${pkg}/`));
+    /**
+     * Whether this JSX attribute value is the literal `null`.
+     *
+     * Both spellings, because which one appears depends on the parser: babel
+     * emits `NullLiteral`, esprima-style parsers a `Literal` whose `value` is
+     * `null`. Anything else — an identifier, a call, a ternary — is not decidable
+     * from the source and stays.
+     */
+    const isNullLiteral = (value) => {
+        if (!value || typeof value !== "object" || !("type" in value)) {
+            return false;
+        }
+        const container = value;
+        if (container.type !== "JSXExpressionContainer") {
+            return false;
+        }
+        const expression = container.expression;
+        if (!expression ||
+            typeof expression !== "object" ||
+            !("type" in expression)) {
+            return false;
+        }
+        const typed = expression;
+        return (typed.type === "NullLiteral" ||
+            (typed.type === "Literal" && typed.value === null));
+    };
+    const root = j(fileInfo.source, { parser: "tsx" });
+    // Local JSX identifier -> canonical component name (resolves `as` aliases).
+    const localToComponent = new Map();
+    // Local names of `import * as Flow` namespace imports from a Flow package.
+    const flowNamespaces = new Set();
+    root
+        .find(j.ImportDeclaration)
+        .filter((path) => isFlowImport(String(path.node.source.value)))
+        .forEach((path) => {
+        for (const specifier of path.node.specifiers ?? []) {
+            if (specifier.type === "ImportSpecifier" &&
+                specifier.imported.type === "Identifier" &&
+                affectedComponents.has(specifier.imported.name)) {
+                localToComponent.set(String(specifier.local?.name ?? specifier.imported.name), String(specifier.imported.name));
+            }
+            else if (specifier.type === "ImportNamespaceSpecifier" &&
+                specifier.local) {
+                flowNamespaces.add(String(specifier.local.name));
+            }
+        }
+    });
+    if (localToComponent.size === 0 && flowNamespaces.size === 0) {
+        return fileInfo.source;
+    }
+    let changed = false;
+    root.find(j.JSXOpeningElement).forEach((path) => {
+        const name = path.node.name;
+        let isAffected = false;
+        if (name.type === "JSXIdentifier") {
+            isAffected = localToComponent.has(name.name);
+        }
+        else if (name.type === "JSXMemberExpression" &&
+            name.object.type === "JSXIdentifier" &&
+            name.property.type === "JSXIdentifier") {
+            isAffected =
+                flowNamespaces.has(name.object.name) &&
+                    affectedComponents.has(name.property.name);
+        }
+        if (!isAffected) {
+            return;
+        }
+        const attributes = path.node.attributes ?? [];
+        const kept = attributes.filter((attribute) => {
+            if (attribute.type !== "JSXAttribute" ||
+                attribute.name.type !== "JSXIdentifier") {
+                return true;
+            }
+            const attributeName = attribute.name.name;
+            if (removedProps.has(attributeName)) {
+                return false;
+            }
+            if (nullableProps.has(attributeName) && isNullLiteral(attribute.value)) {
+                return false;
+            }
+            return true;
+        });
+        if (kept.length !== attributes.length) {
+            path.node.attributes = kept;
+            changed = true;
+        }
+    });
+    // Returning the source untouched keeps this file out of the "changed" count.
+    return changed ? root.toSource() : fileInfo.source;
+};
+exports.default = tableColumnWidthPropsTransform;

package/dist/migrations.generated.d.ts

@@ -1,4 +1,3 @@
 import type { MigrationEntry } from "./catalog/types.js";
 /** Every migration, newest first. Bodies live in `src/migrations`. */
 export declare const migrations: Omit<MigrationEntry, "body">[];
-//# sourceMappingURL=migrations.generated.d.ts.map

package/dist/migrations.generated.js

@@ -3,6 +3,33 @@
 // Source: packages/codemods/src/migrations/<id>/entry.md
 /** Every migration, newest first. Bodies live in `src/migrations`. */
 export const migrations = [
+    {
+        id: "popover-open-state-props",
+        since: "1.1.47",
+        title: "Popover: `defaultOpen` renamed, `isOpen` and `onOpenChange` now work",
+        kind: "migration",
+        action: "codemod",
+        remotePackage: true,
+        apply: "Rename `defaultOpen` to `isDefaultOpen` on `Popover`, `ContextualHelp` and `ContextMenu` — a codemod does it, scoped to those three. Leave `defaultOpen` alone on `Select`, `MenuTrigger`, `Tooltip`, `TooltipTrigger`, `DialogTrigger`, `DatePicker` and `DateRangePicker`, where it is react-aria's own prop and unchanged. Then check every `isOpen` and `onOpenChange` passed to those three by hand, because both changed behaviour and neither is mechanically decidable. `isOpen` used to be ignored and now controls the popover: a value that is not kept up to date through `onOpenChange` keeps the popover closed. `onOpenChange` used to take over the open state and now only reports it, so a handler that performed the close itself — `onOpenChange={(open) => controller.setOpen(open)}` — can drop that call, and a handler that relied on the prop to *suppress* the close no longer does; use the controller's `onClose` for that.",
+    },
+    {
+        id: "tabler-icons-no-longer-transitive",
+        since: "1.1.40",
+        title: "@tabler/icons-react is no longer installed alongside Flow",
+        kind: "migration",
+        action: "manual",
+        remotePackage: true,
+        apply: "Only affects code that imports from `@tabler/icons-react` — typically a `<Icon><IconSomething /></Icon>` using an icon that is not in Flow's own set. Add the package to your own dependencies (`npm i @tabler/icons-react`); the imports themselves stay unchanged. Flow's own `Icon*` components are unaffected, keep their names, and render exactly as before.",
+    },
+    {
+        id: "option-value-inferred-from-mixed-children",
+        since: "1.1.12",
+        title: "Option: value is inferred from mixed children",
+        kind: "migration",
+        action: "none",
+        remotePackage: true,
+        apply: "No code change required for the option itself. An `Option` whose children are text plus an element — text and a `Badge`, text and an icon — now carries that text as its key, where it previously fell back to react-aria's generated `react-aria-N`. Check anywhere such a key was read back: a stored or server-side selection, a `defaultValue`/`value` matched against it, or a test asserting on it. Pass an explicit `value` to pin the key to something other than the display text.",
+    },
     {
         id: "use-design-tokens-build-metadata-removed",
         since: "1.0.16",
@@ -89,9 +116,9 @@ export const migrations = [
         since: "0.2.0-alpha.956",
         title: "TableColumn: `maxWidth` removed, `width` and `minWidth` retyped",
         kind: "migration",
-        action: "manual",
+        action: "codemod",
         remotePackage: true,
-        apply: "Remove `maxWidth` from every `TableColumn`. Where `width` or `minWidth` was `null`, omit the prop instead — the type no longer accepts `null`, only `number | string`.",
+        apply: "Remove `maxWidth` from every `TableColumn`. Where `width` or `minWidth` was `null`, omit the prop instead — the type no longer accepts `null`, only `number | string`. A codemod does both for the cases it can decide from the source. Two it declines: a `width`/`minWidth` whose value is an expression (`width={maybeNull}`), and a spread that might carry `maxWidth` (`<TableColumn {...props} />`). Check those by hand.",
     },
     {
         id: "table-render-prop-removed",
@@ -199,7 +226,7 @@ export const migrations = [
         kind: "migration",
         action: "codemod",
         remotePackage: true,
-        apply: "Rename the `action` prop on `Action` to `onAction`. Not only a rename: the new prop is typed `ActionFn` (`(...args: unknown[]) => unknown`), so a function *reference* that declares a parameter no longer type-checks and needs wrapping — `onAction={() => controller.close()}` rather than `onAction={controller.close}`. Check every site where you passed a reference rather than an inline arrow; the codemod renames the prop but cannot decide this one from the source.",
+        apply: "Rename the `action` prop on `Action` to `onAction`. Not only a rename: the new prop is typed `ActionFn` (`(...args: unknown[]) => unknown`), so a function *reference* that declares a parameter no longer type-checks and needs wrapping — `onAction={() => controller.close()}` rather than `onAction={controller.close}`. A codemod does both. It wraps every bare reference (`close`, `controller.close`), because the wrap is a no-op for a reference that did not need it. It leaves a value that already is the handler or produces one — an arrow function, a function expression, a call like `makeHandler()` or `close.bind(controller)` — and anything that is not one reference, such as `isOpen ? close : open` or `controller?.close`. Two wraps to look at afterwards: a handler that read the event `Action` forwards stops receiving it, and a possibly-undefined reference (`onAction={props.onAction}`) becomes a call TypeScript rejects — add the guard it asks for.",
     },
     {
         id: "button-props-interfaces",
@@ -217,15 +244,15 @@ export const migrations = [
         kind: "migration",
         action: "codemod",
         remotePackage: false,
-        apply: 'Rewrite every subdirectory import from `@mittwald/flow-react-components` to the package root, except `react-hook-form` and `nextjs`, which move to `@mittwald/flow-react-components/react-hook-form` and `@mittwald/flow-react-components/nextjs`. If you hit missing module errors, set `"module": "esnext"` in `tsconfig.json`.',
+        apply: 'Rewrite every subdirectory import from `@mittwald/flow-react-components` to the package root, except `react-hook-form` and `nextjs`, which move to `@mittwald/flow-react-components/react-hook-form` and `@mittwald/flow-react-components/nextjs`. Asset imports are not part of this: a CSS specifier stays a CSS specifier — `all.css` and `all-layered.css` unchanged, a stale `global.css` or `globals.css` rewritten to `all.css` — and keeps any bundler query it carries (`?url`, `?inline`, `?raw`). It never becomes a named import from the package root, which has no JS binding behind a stylesheet. If you hit missing module errors, set `"module": "esnext"` in `tsconfig.json`.',
     },
     {
         id: "renamed-css-export",
         since: "0.1.0-alpha.292",
         title: "Renamed CSS export",
         kind: "migration",
-        action: "manual",
+        action: "codemod",
         remotePackage: false,
-        apply: "Replace the import `@mittwald/flow-react-components/styles` with `@mittwald/flow-react-components/all.css`.",
+        apply: "Replace the import `@mittwald/flow-react-components/styles` with `@mittwald/flow-react-components/all.css`, keeping any bundler query the specifier carries (`.../styles?url` becomes `.../all.css?url`). A codemod does this for JavaScript and TypeScript files. An `@import` of the old path inside a `.css` or `.scss` file is not covered — search for it by hand.",
     },
 ];

package/dist/resolve/range.d.ts

@@ -47,4 +47,3 @@ export type RangeResult = ResolvedRange | UnresolvedRange;
  * fine; two callers computing the fact differently is how they drift.
  */
 export declare const resolveRange: (revision: string, deps: RangeDeps) => Promise<RangeResult>;
-//# sourceMappingURL=range.d.ts.map

package/dist/resolve/registry.d.ts

@@ -30,4 +30,3 @@ export declare const fetchAllVersions: (names: string[], fetchOne: (name: string
  * the intersection, not any single package's list.
  */
 export declare const intersectVersions: (packages: PackageVersions[]) => string[];
-//# sourceMappingURL=registry.d.ts.map

package/dist/resolve/target.d.ts

@@ -60,4 +60,3 @@ export type ResolveTargetResult = {
  * stable line never drifts onto the collection branch.
  */
 export declare const resolveTarget: ({ revision, current, versions, distTags, }: ResolveTargetInput) => ResolveTargetResult;
-//# sourceMappingURL=target.d.ts.map

package/dist/run/jscodeshift.d.ts

@@ -42,4 +42,3 @@ export interface CodemodResult {
  * load does not predict, so the flag keeps its deliberately vague name.
  */
 export declare const runCodemod: ({ id, path, dry, print, }: CodemodOptions) => Promise<CodemodResult>;
-//# sourceMappingURL=jscodeshift.d.ts.map

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@mittwald/flow-codemods",
-  "version": "1.2.0-next.9",
+  "version": "1.2.0",
   "type": "module",
   "description": "Codemods and an upgrade CLI for consumers of Flow, mittwald's design system",
   "homepage": "https://flow.mittwald.de",
   "repository": "https://github.com/mittwald/flow",
+  "license": "MIT",
   "bin": {
     "flow-codemods": "dist/cli.js"
   },
@@ -37,5 +38,5 @@
     "vitest": "^4.1.11",
     "yaml": "^2.8.1"
   },
-  "gitHead": "f63082035b7e221f573463c84fea6b7b4a89f56d"
+  "gitHead": "f259c3a6cc103d2f765165fd706a530f87788754"
 }

package/dist/catalog/entries.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"entries.d.ts","sourceRoot":"","sources":["../../src/catalog/entries.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,IAAI,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC;AAExD,eAAO,MAAM,UAAU,EAAE,YAAY,EAAe,CAAC;AAErD;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,OAAQ,MAAM,KAAG,MAC+C,CAAC"}

package/dist/catalog/select.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"select.d.ts","sourceRoot":"","sources":["../../src/catalog/select.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD;;;GAGG;AACH,eAAO,MAAM,WAAW,YAAa,YAAY,EAAE,KAAG,YAAY,EAG/D,CAAC;AAEJ;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,aAAa,YACf,YAAY,EAAE,UACf,MAAM,KACb,YAAY,EACmD,CAAC"}

package/dist/catalog/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/catalog/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,aAAa,GAAG,WAAW,GAAG,aAAa,CAAC;AAExD;;;;;;;GAOG;AACH,MAAM,MAAM,eAAe,GAAG,SAAS,GAAG,QAAQ,GAAG,MAAM,CAAC;AAE5D,MAAM,WAAW,cAAc;IAC7B;;;;OAIG;IACH,EAAE,EAAE,MAAM,CAAC;IACX,+CAA+C;IAC/C,KAAK,EAAE,MAAM,CAAC;IACd,kCAAkC;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,aAAa,CAAC;IACpB,MAAM,EAAE,eAAe,CAAC;IACxB;;;;OAIG;IACH,aAAa,EAAE,OAAO,CAAC;IACvB,iEAAiE;IACjE,KAAK,EAAE,MAAM,CAAC;IACd,wEAAwE;IACxE,IAAI,EAAE,MAAM,CAAC;CACd"}

package/dist/cli/args.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"args.d.ts","sourceRoot":"","sources":["../../src/cli/args.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,OAAO,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAAC;AAE1E,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,OAAO,CAAC;IACjB;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,sBAAsB;IACtB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,8DAA8D;IAC9D,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,OAAO,CAAC;IACd,GAAG,EAAE,OAAO,CAAC;IACb,GAAG,EAAE,OAAO,CAAC;IACb,KAAK,EAAE,OAAO,CAAC;IACf,UAAU,EAAE,OAAO,CAAC;CACrB;AAQD,eAAO,MAAM,cAAc,SAAU,MAAM,EAAE,KAAG,aAqD/C,CAAC"}

package/dist/cli/choose.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"choose.d.ts","sourceRoot":"","sources":["../../src/cli/choose.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAE1D,MAAM,WAAW,iBAAiB;IAChC,mCAAmC;IACnC,GAAG,EAAE,OAAO,CAAC;IACb,8BAA8B;IAC9B,KAAK,EAAE,OAAO,CAAC;IACf;;;;;;;;OAQG;IACH,IAAI,EAAE,OAAO,CAAC;IACd,2CAA2C;IAC3C,MAAM,EAAE,CAAC,OAAO,EAAE,YAAY,EAAE,KAAK,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IACvD,6CAA6C;IAC7C,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACrC;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY,4CAMtB,iBAAiB,KAAG,CAAC,CACtB,OAAO,EAAE,YAAY,EAAE,KACpB,OAAO,CAAC,YAAY,EAAE,CAAC,CAwB3B,CAAC"}

package/dist/cli/codemod.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"codemod.d.ts","sourceRoot":"","sources":["../../src/cli/codemod.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,EAAE,UAAU,EAAmB,MAAM,uBAAuB,CAAC;AAEpE;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB,aAClB,MAAM,GAAG,SAAS,OACvB,MAAM,WACH,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,KAChC,MAKF,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iBAAiB,aAClB,MAAM,GAAG,SAAS,OACvB,MAAM,WACH,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,KAChC,MAKF,CAAC;AAEF,MAAM,WAAW,kBAAkB;IACjC,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IAC/B,GAAG,CAAC,EAAE,OAAO,UAAU,CAAC;CACzB;AAED,eAAO,MAAM,gBAAgB,WACnB,aAAa,qBACW,kBAAkB,KACjD,OAAO,CAAC,MAAM,CA6DhB,CAAC"}

package/dist/cli/list.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../src/cli/list.ts"],"names":[],"mappings":"AAEA,OAAO,EAAc,KAAK,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAEtE,OAAO,EAGL,KAAK,SAAS,EACf,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE/C,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB;;;;OAIG;IACH,KAAK,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC;IACrC,IAAI,EAAE,OAAO,CAAC;IACd,kEAAkE;IAClE,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,uCAAuC;IACvC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;;;OAOG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;;;;;;OASG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAkCD,eAAO,MAAM,SAAS,SAAU,MAAM,KAAG,MAAgC,CAAC;AAkE1E;;;;;GAKG;AACH,eAAO,MAAM,aAAa,uCAAuC,CAAC;AAsKlE;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,UAAU,iEASpB,eAAe,KAAG,MAiEpB,CAAC;AAEF,MAAM,WAAW,QAAS,SAAQ,SAAS;IACzC;;;OAGG;IACH,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,4EAA4E;IAC5E,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,sEAAsE;IACtE,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,eAAO,MAAM,eAAe,QAAS,MAAM,KAAG,QAG5C,CAAC;AAEH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,OAAO,WACV,aAAa,QACf,QAAQ,KACb,OAAO,CAAC,MAAM,CAmChB,CAAC"}

package/dist/cli/upgrade.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"upgrade.d.ts","sourceRoot":"","sources":["../../src/cli/upgrade.ts"],"names":[],"mappings":"AAGA,OAAO,EAAc,KAAK,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAItE,OAAO,EAIL,KAAK,aAAa,EACnB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAEvD,OAAO,EAAE,UAAU,EAAsB,MAAM,uBAAuB,CAAC;AACvE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAI/C,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,EAAE,OAAO,aAAa,CAAC;IACpC,OAAO,EAAE,aAAa,CAAC;IACvB,UAAU,EAAE,OAAO,UAAU,CAAC;IAC9B,2EAA2E;IAC3E,MAAM,EAAE,CAAC,OAAO,EAAE,YAAY,EAAE,KAAK,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC;IAC7D,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;IAClC,oBAAoB,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;IACxE,GAAG,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CAChC;AAED,eAAO,MAAM,kBAAkB,QAAS,MAAM,KAAG,WAS/C,CAAC;AA2BH;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,UAAU,WACb,aAAa,QACf,WAAW,KAChB,OAAO,CAAC,MAAM,CAiNhB,CAAC"}

package/dist/cli.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/flowPackages.generated.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"flowPackages.generated.d.ts","sourceRoot":"","sources":["../src/flowPackages.generated.ts"],"names":[],"mappings":"AAIA,mFAAmF;AACnF,eAAO,MAAM,YAAY,EAAE,MAAM,EAahC,CAAC"}

package/dist/git.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"git.d.ts","sourceRoot":"","sources":["../src/git.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB,QAAS,MAAM,KAAG,OAkCnD,CAAC"}

package/dist/install.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"install.d.ts","sourceRoot":"","sources":["../src/install.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAEpE;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GAAG,IAAI,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC,CAAC;AAiB9E;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,sBAAsB,QAC5B,MAAM,KACV,OAAO,CAAC,cAAc,CACyC,CAAC;AAEnE,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,oEAAoE;IACpE,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,cAAc,UAAW,KAAK,KAAG,cAiB7C,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,WAAW,YAAa,MAAM,GAAG,SAAS,KAAG,MAAM,GAAG,SAGpD,CAAC;AAEhB;;;;;GAKG;AACH,MAAM,MAAM,KAAK,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,MAAM,GAAG,SAAS,CAAC;AAE5E,eAAO,MAAM,QAAQ,EAAE,KAUtB,CAAC;AAEF,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5B,4EAA4E;IAC5E,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,WAAW,YACb,cAAc,UAChB,KAAK,KACX,WAuCF,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,EAAE,cAAc,EAAE,GAAG,EAAE,MAAM,KAAK,MAAM,CAAC;AAE7E,eAAO,MAAM,UAAU,EAAE,aAYxB,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,aAAa,QACnB,MAAM,mBAEV,OAAO,CAAC,MAAM,CAMhB,CAAC"}

package/dist/manifest.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../src/manifest.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,eAAe,GACvB,cAAc,GACd,iBAAiB,GACjB,kBAAkB,GAClB,sBAAsB,CAAC;AAS3B,MAAM,WAAW,QAAQ;IACvB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1C,oBAAoB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC/C;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,eAAe,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAED,wEAAwE;AACxE,eAAO,MAAM,oBAAoB,aACrB,QAAQ,gBACJ,MAAM,EAAE,KACrB,cAAc,EAKd,CAAC;AAKJ;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,UAAW,MAAM,UAAU,MAAM,KAAG,MAQ5D,CAAC;AAgBF,qEAAqE;AACrE,eAAO,MAAM,UAAU,eAAgB,cAAc,KAAG,OACb,CAAC;AAE5C;;;GAGG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,QAAQ,YAClC,CAAC,UACH,MAAM,gBACA,MAAM,EAAE,KACrB,CAcF,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,oBAAoB,iBACjB,cAAc,EAAE,wBACR,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,KACzD,MAAM,GAAG,SAgBX,CAAC"}

package/dist/migrations.generated.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"migrations.generated.d.ts","sourceRoot":"","sources":["../src/migrations.generated.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEzD,sEAAsE;AACtE,eAAO,MAAM,UAAU,EAAE,IAAI,CAAC,cAAc,EAAE,MAAM,CAAC,EA8PpD,CAAC"}

package/dist/resolve/range.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"range.d.ts","sourceRoot":"","sources":["../../src/resolve/range.ts"],"names":[],"mappings":"AAIA,OAAO,EAGL,KAAK,cAAc,EACnB,KAAK,QAAQ,EACd,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAEL,aAAa,EAEd,MAAM,eAAe,CAAC;AAGvB;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,QAC1B,MAAM,QACL,MAAM,KACX,MAAM,GAAG,SASX,CAAC;AAEF,MAAM,WAAW,SAAS;IACxB,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,EAAE,OAAO,aAAa,CAAC;IACpC,oBAAoB,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;CACzE;AAED,eAAO,MAAM,gBAAgB,QAAS,MAAM,KAAG,SAI7C,CAAC;AAEH,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,IAAI,CAAC;IACT,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,QAAQ,CAAC;IACnB,YAAY,EAAE,cAAc,EAAE,CAAC;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,KAAK,CAAC;IACV,4CAA4C;IAC5C,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,MAAM,WAAW,GAAG,aAAa,GAAG,eAAe,CAAC;AA2C1D;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,YAAY,aACb,MAAM,QACV,SAAS,KACd,OAAO,CAAC,WAAW,CAuHrB,CAAC"}

package/dist/resolve/registry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/resolve/registry.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC;AAwBD;;;;;GAKG;AACH,eAAO,MAAM,aAAa,gBACX,MAAM,KAClB,OAAO,CAAC,gBAAgB,CA6B1B,CAAC;AAEF,MAAM,WAAW,eAAgB,SAAQ,gBAAgB;IACvD,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,UACpB,MAAM,EAAE,YACL,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,gBAAgB,CAAC,KACpD,OAAO,CAAC,eAAe,EAAE,CACmD,CAAC;AAEhF;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,aAAc,eAAe,EAAE,KAAG,MAAM,EAQrE,CAAC"}

package/dist/resolve/target.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"target.d.ts","sourceRoot":"","sources":["../../src/resolve/target.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,kBAAkB;IACjC,mEAAmE;IACnE,QAAQ,EAAE,MAAM,CAAC;IACjB,sCAAsC;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB,qDAAqD;IACrD,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC;AAED,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;AAO1D;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,GACxB;IACE,IAAI,EAAE,cAAc,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,gEAAgE;IAChE,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,GACD;IACE,IAAI,EAAE,cAAc,CAAC;IACrB,QAAQ,EAAE,eAAe,CAAC;IAC1B,oEAAoE;IACpE,SAAS,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,OAAO,CAAC,EAAE;QAAE,OAAO,EAAE,eAAe,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;CACxD,GACD;IACE,IAAI,EAAE,aAAa,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,mEAAmE;IACnE,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;CAC7B,CAAC;AAEN,MAAM,MAAM,mBAAmB,GAC7B;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,gBAAgB,CAAA;CAAE,CAAC;AAiFzE;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,aAAa,+CAKvB,kBAAkB,KAAG,mBA0CvB,CAAC"}

package/dist/run/jscodeshift.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"jscodeshift.d.ts","sourceRoot":"","sources":["../../src/run/jscodeshift.ts"],"names":[],"mappings":"AAwDA;;;;;GAKG;AACH,eAAO,MAAM,eAAe,OAAQ,MAAM,KAAG,OACd,CAAC;AAEhC,MAAM,WAAW,cAAc;IAC7B,sEAAsE;IACtE,EAAE,EAAE,MAAM,CAAC;IACX,sCAAsC;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,yDAAyD;IACzD,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,sEAAsE;IACtE,gBAAgB,EAAE,OAAO,CAAC;CAC3B;AAUD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,UAAU,8BAKpB,cAAc,KAAG,OAAO,CAAC,aAAa,CA6DxC,CAAC"}