syncpack 12.2.0 → 12.3.1

package/dist/lib/ring-buffer.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RingBuffer = void 0;
 /**
  * An Array with a maximum size which, once reached, will replace the oldest
  * item when a new one is added.
  */
-class RingBuffer extends Array {
+export class RingBuffer extends Array {
     cursor;
     fixedLength;
     constructor(fixedLength) {
@@ -21,4 +18,3 @@ class RingBuffer extends Array {
         return this.length;
     }
 }
-exports.RingBuffer = RingBuffer;

package/dist/lib/set-semver-range.d.ts

@@ -1,3 +1,3 @@
-import type { SemverRange } from '../config/types';
+import type { SemverRange } from '../config/types.js';
 /** @deprecated migrate to make better use of npm-package-arg */
 export declare function setSemverRange(semverRange: SemverRange, version: string): string;

package/dist/lib/set-semver-range.js

@@ -1,24 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.setSemverRange = void 0;
-const is_string_1 = require("tightrope/guard/is-string");
-const constants_1 = require("../constants");
-const is_semver_1 = require("../guards/is-semver");
-const is_valid_semver_range_1 = require("../guards/is-valid-semver-range");
+import { isString } from 'tightrope/guard/is-string.js';
+import { RANGE } from '../constants.js';
+import { isSemver } from '../guards/is-semver.js';
+import { isValidSemverRange } from '../guards/is-valid-semver-range.js';
 /** @deprecated migrate to make better use of npm-package-arg */
-function setSemverRange(semverRange, version) {
-    if (!(0, is_semver_1.isSemver)(version) || !(0, is_valid_semver_range_1.isValidSemverRange)(semverRange))
+export function setSemverRange(semverRange, version) {
+    if (!isSemver(version) || !isValidSemverRange(semverRange))
         return version;
     if (semverRange === '*')
         return semverRange;
     const nextVersion = isLooseSemver(version) ? version.replace(/\.x/g, '.0') : version;
     const from1stNumber = nextVersion.search(/[0-9]/);
     const from1stDot = nextVersion.indexOf('.');
-    return semverRange === constants_1.RANGE.LOOSE
+    return semverRange === RANGE.LOOSE
         ? `${nextVersion.slice(from1stNumber, from1stDot)}.x.x`
         : `${semverRange}${nextVersion.slice(from1stNumber)}`;
 }
-exports.setSemverRange = setSemverRange;
 function isLooseSemver(version) {
-    return (0, is_string_1.isString)(version) && (0, is_semver_1.isSemver)(version) && version.search(/\.x(\.|$)/) !== -1;
+    return isString(version) && isSemver(version) && version.search(/\.x(\.|$)/) !== -1;
 }

package/dist/lib/show-help-on-error.js

@@ -1,12 +1,6 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.showHelpOnError = void 0;
-const chalk_1 = __importDefault(require("chalk"));
-function showHelpOnError(program) {
-    program.showHelpAfterError((0, chalk_1.default) `
+import chalk from 'chalk-template';
+export function showHelpOnError(program) {
+    program.showHelpAfterError(chalk `
 1. The following options were replaced in syncpack@9.0.0:
 {red
   -p, --prod              include dependencies
@@ -36,4 +30,3 @@ function showHelpOnError(program) {
     "dependencyTypes": ["dev", "prod", "peer"]
 }`);
 }
-exports.showHelpOnError = showHelpOnError;

package/dist/lib/sort-by-name.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sortByName = void 0;
-function sortByName(a, b) {
+export function sortByName(a, b) {
     if (a.name < b.name) {
         return -1;
     }
@@ -10,4 +7,3 @@ function sortByName(a, b) {
     }
     return 0;
 }
-exports.sortByName = sortByName;

package/dist/lib/with-logger.d.ts

@@ -1,2 +1,2 @@
 import { Effect } from 'effect';
-export declare function withLogger(program: Effect.Effect<never, never, unknown>): Effect.Effect<never, never, unknown>;
+export declare function withLogger(program: Effect.Effect<unknown>): Effect.Effect<unknown, never, never>;

package/dist/lib/with-logger.js

@@ -1,35 +1,28 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.withLogger = void 0;
-const chalk_1 = __importDefault(require("chalk"));
-const effect_1 = require("effect");
-function withLogger(program) {
-    const logger = effect_1.Logger.make(({ logLevel, message }) => {
-        if (logLevel === effect_1.LogLevel.Info) {
+import chalk from 'chalk-template';
+import { Effect, Logger, LogLevel } from 'effect';
+export function withLogger(program) {
+    const logger = Logger.make(({ logLevel, message }) => {
+        if (logLevel === LogLevel.Info) {
             globalThis.console.info(message);
         }
-        else if (logLevel === effect_1.LogLevel.Debug) {
-            globalThis.console.info((0, chalk_1.default) `{magenta ? %s}`, message);
+        else if (logLevel === LogLevel.Debug) {
+            globalThis.console.info(chalk `{magenta ? %s}`, message);
         }
-        else if (logLevel === effect_1.LogLevel.Error) {
-            globalThis.console.error((0, chalk_1.default) `{red ! %s}`, message);
+        else if (logLevel === LogLevel.Error) {
+            globalThis.console.error(chalk `{red ! %s}`, message);
         }
-        else if (logLevel === effect_1.LogLevel.Warning) {
-            globalThis.console.warn((0, chalk_1.default) `{yellow ! %s}`, message);
+        else if (logLevel === LogLevel.Warning) {
+            globalThis.console.warn(chalk `{yellow ! %s}`, message);
         }
         else {
-            globalThis.console.log((0, chalk_1.default) `{cyan [%s] %s}`, logLevel, message);
+            globalThis.console.log(chalk `{cyan [%s] %s}`, logLevel, message);
         }
     });
-    const layer = effect_1.Logger.replace(effect_1.Logger.defaultLogger, logger);
+    const layer = Logger.replace(Logger.defaultLogger, logger);
     const logLevel = process.env.SYNCPACK_VERBOSE === 'true'
-        ? effect_1.LogLevel.Debug
+        ? LogLevel.Debug
         : process.env.NODE_ENV === 'test'
-            ? effect_1.LogLevel.None
-            : effect_1.LogLevel.Info;
-    return effect_1.Effect.provide(effect_1.Logger.withMinimumLogLevel(program, logLevel), layer);
+            ? LogLevel.None
+            : LogLevel.Info;
+    return Effect.provide(Logger.withMinimumLogLevel(program, logLevel), layer);
 }
-exports.withLogger = withLogger;

package/dist/option.d.ts

@@ -3,7 +3,7 @@ export declare const option: {
     readonly filter: readonly ["-f, --filter [pattern]", string];
     readonly indent: readonly ["-i, --indent [value]", `override indentation. defaults to "${string}"`];
     readonly source: readonly ["-s, --source [pattern]", "glob pattern for package.json files to read from", typeof collect, string[]];
-    readonly specs: readonly ["-s, --specs <names>", string];
+    readonly specs: readonly ["-S, --specs <names>", string];
     readonly types: readonly ["-t, --types <names>", string];
 };
 declare function collect(value: string, previous: string[]): string[];

package/dist/option.js

@@ -1,18 +1,12 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.option = void 0;
-const chalk_1 = __importDefault(require("chalk"));
-const constants_1 = require("./constants");
-exports.option = {
+import chalk from 'chalk-template';
+import { DEFAULT_CONFIG } from './constants.js';
+export const option = {
     config: ['-c, --config <path>', 'path to a syncpack config file'],
     filter: [
         '-f, --filter [pattern]',
-        (0, chalk_1.default) `only include dependencies whose {yellow name} matches this regex`,
+        chalk `only include dependencies whose {yellow name} matches this regex`,
     ],
-    indent: ['-i, --indent [value]', `override indentation. defaults to "${constants_1.DEFAULT_CONFIG.indent}"`],
+    indent: ['-i, --indent [value]', `override indentation. defaults to "${DEFAULT_CONFIG.indent}"`],
     source: [
         '-s, --source [pattern]',
         'glob pattern for package.json files to read from',
@@ -20,12 +14,12 @@ exports.option = {
         [],
     ],
     specs: [
-        '-s, --specs <names>',
-        (0, chalk_1.default) `only include dependencies whose version specifier match these types (eg. {yellow specs=latest,range,workspace-protocol})`,
+        '-S, --specs <names>',
+        chalk `only include dependencies whose version specifier match these types (eg. {yellow specs=latest,range,workspace-protocol})`,
     ],
     types: [
         '-t, --types <names>',
-        (0, chalk_1.default) `only include dependencies matching these types (eg. {yellow types=dev,prod,myCustomType})`,
+        chalk `only include dependencies matching these types (eg. {yellow types=dev,prod,myCustomType})`,
     ],
 };
 function collect(value, previous) {

package/dist/report.d.ts

@@ -1,5 +1,5 @@
-import type { Instance } from './get-instances/instance';
-import type { Specifier } from './specifier';
+import type { Instance } from './get-instances/instance.js';
+import type { Specifier } from './specifier/index.js';
 export declare namespace Report {
     export type Any = Semver.Any | Version.Any;
     export namespace Semver {

package/dist/report.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Report = void 0;
-var Report;
+export var Report;
 (function (Report) {
     class Excluded {
         _tagGroup = 'Excluded';
@@ -129,4 +126,4 @@ var Report;
         _tag = 'UnsupportedMismatch';
     }
     Report.UnsupportedMismatch = UnsupportedMismatch;
-})(Report || (exports.Report = Report = {}));
+})(Report || (Report = {}));

package/dist/schema.json

@@ -472,9 +472,24 @@
         "filter": {
             "type": "string"
         },
+        "formatBugs": {
+            "type": "boolean"
+        },
+        "formatRepository": {
+            "type": "boolean"
+        },
         "indent": {
             "type": "string"
         },
+        "lintFormatting": {
+            "type": "boolean"
+        },
+        "lintSemverRanges": {
+            "type": "boolean"
+        },
+        "lintVersions": {
+            "type": "boolean"
+        },
         "semverGroups": {
             "items": {
                 "$ref": "#/definitions/SemverGroupConfig.Any"
@@ -487,12 +502,21 @@
             },
             "type": "array"
         },
+        "sortExports": {
+            "items": {
+                "type": "string"
+            },
+            "type": "array"
+        },
         "sortFirst": {
             "items": {
                 "type": "string"
             },
             "type": "array"
         },
+        "sortPackages": {
+            "type": "boolean"
+        },
         "source": {
             "items": {
                 "type": "string"

package/dist/semver-group/create-semver-groups.d.ts

@@ -1,4 +1,4 @@
 import { Effect } from 'effect';
-import { SemverGroup } from '.';
-import type { Ctx } from '../get-context';
-export declare function createSemverGroups(ctx: Ctx): Effect.Effect<never, SemverGroup.ConfigError, SemverGroup.Any[]>;
+import type { Ctx } from '../get-context/index.js';
+import { SemverGroup } from './index.js';
+export declare function createSemverGroups(ctx: Ctx): Effect.Effect<SemverGroup.Any[], SemverGroup.ConfigError>;

package/dist/semver-group/create-semver-groups.js

@@ -1,22 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSemverGroups = void 0;
-const effect_1 = require("effect");
-const is_array_of_strings_1 = require("tightrope/guard/is-array-of-strings");
-const is_non_empty_array_1 = require("tightrope/guard/is-non-empty-array");
-const is_non_empty_string_1 = require("tightrope/guard/is-non-empty-string");
-const is_object_1 = require("tightrope/guard/is-object");
-const _1 = require(".");
-const is_valid_semver_range_1 = require("../guards/is-valid-semver-range");
-const disabled_1 = require("./disabled");
-const filtered_out_1 = require("./filtered-out");
-const ignored_1 = require("./ignored");
-const with_range_1 = require("./with-range");
-function createSemverGroups(ctx) {
+import { Effect } from 'effect';
+import { isArrayOfStrings } from 'tightrope/guard/is-array-of-strings.js';
+import { isNonEmptyArray } from 'tightrope/guard/is-non-empty-array.js';
+import { isNonEmptyString } from 'tightrope/guard/is-non-empty-string.js';
+import { isObject } from 'tightrope/guard/is-object.js';
+import { isValidSemverRange } from '../guards/is-valid-semver-range.js';
+import { DisabledSemverGroup } from './disabled.js';
+import { FilteredOutSemverGroup } from './filtered-out.js';
+import { IgnoredSemverGroup } from './ignored.js';
+import { SemverGroup } from './index.js';
+import { WithRangeSemverGroup } from './with-range.js';
+export function createSemverGroups(ctx) {
     const { rcFile } = ctx.config;
     const semverGroups = [
-        effect_1.Effect.succeed(new filtered_out_1.FilteredOutSemverGroup(ctx)),
-        effect_1.Effect.succeed(new with_range_1.WithRangeSemverGroup(false, {
+        Effect.succeed(new FilteredOutSemverGroup(ctx)),
+        Effect.succeed(new WithRangeSemverGroup(false, {
             dependencies: ['**'],
             dependencyTypes: ['local'],
             label: 'the version property of package.json files must always be exact',
@@ -24,32 +21,32 @@ function createSemverGroups(ctx) {
             range: '',
         })),
     ];
-    if ((0, is_non_empty_array_1.isNonEmptyArray)(rcFile.semverGroups)) {
+    if (isNonEmptyArray(rcFile.semverGroups)) {
         rcFile.semverGroups.forEach((config) => {
-            if (!(0, is_object_1.isObject)(config)) {
-                return semverGroups.push(effect_1.Effect.fail(new _1.SemverGroup.ConfigError({
+            if (!isObject(config)) {
+                return semverGroups.push(Effect.fail(new SemverGroup.ConfigError({
                     config,
                     error: 'config is not an object',
                 })));
             }
             const mutuallyExclusiveProps = ['isIgnored', 'range'].filter((prop) => Boolean(config[prop]));
             if (mutuallyExclusiveProps.length > 1) {
-                return semverGroups.push(effect_1.Effect.fail(new _1.SemverGroup.ConfigError({
+                return semverGroups.push(Effect.fail(new SemverGroup.ConfigError({
                     config,
                     error: `it's unclear what kind of semver group you want, as it contains both ${mutuallyExclusiveProps.join(' and ')}`,
                 })));
             }
-            const label = (0, is_non_empty_string_1.isNonEmptyString)(config.label) ? config.label : '';
-            const dependencyTypes = (0, is_array_of_strings_1.isArrayOfStrings)(config.dependencyTypes)
+            const label = isNonEmptyString(config.label) ? config.label : '';
+            const dependencyTypes = isArrayOfStrings(config.dependencyTypes)
                 ? config.dependencyTypes
                 : ['**'];
-            const dependencies = (0, is_array_of_strings_1.isArrayOfStrings)(config.dependencies) ? config.dependencies : ['**'];
-            const packages = (0, is_array_of_strings_1.isArrayOfStrings)(config.packages) ? config.packages : ['**'];
-            const specifierTypes = (0, is_array_of_strings_1.isArrayOfStrings)(config.specifierTypes)
+            const dependencies = isArrayOfStrings(config.dependencies) ? config.dependencies : ['**'];
+            const packages = isArrayOfStrings(config.packages) ? config.packages : ['**'];
+            const specifierTypes = isArrayOfStrings(config.specifierTypes)
                 ? config.specifierTypes
                 : ['**'];
             if (config.isIgnored === true) {
-                semverGroups.push(effect_1.Effect.succeed(new ignored_1.IgnoredSemverGroup({
+                semverGroups.push(Effect.succeed(new IgnoredSemverGroup({
                     dependencies,
                     dependencyTypes,
                     specifierTypes,
@@ -58,8 +55,8 @@ function createSemverGroups(ctx) {
                     packages,
                 })));
             }
-            else if ((0, is_valid_semver_range_1.isValidSemverRange)(config.range)) {
-                semverGroups.push(effect_1.Effect.succeed(new with_range_1.WithRangeSemverGroup(false, {
+            else if (isValidSemverRange(config.range)) {
+                semverGroups.push(Effect.succeed(new WithRangeSemverGroup(false, {
                     dependencies,
                     dependencyTypes,
                     specifierTypes,
@@ -70,7 +67,7 @@ function createSemverGroups(ctx) {
             }
         });
     }
-    semverGroups.push(effect_1.Effect.succeed(new disabled_1.DisabledSemverGroup(true, {
+    semverGroups.push(Effect.succeed(new DisabledSemverGroup(true, {
         dependencies: ['**'],
         dependencyTypes: ['**'],
         specifierTypes: ['**'],
@@ -78,6 +75,5 @@ function createSemverGroups(ctx) {
         packages: ['**'],
         isDisabled: true,
     })));
-    return effect_1.Effect.all(semverGroups);
+    return Effect.all(semverGroups);
 }
-exports.createSemverGroups = createSemverGroups;

package/dist/semver-group/disabled.d.ts

@@ -1,12 +1,12 @@
-import { Data, Effect } from 'effect';
-import type { SemverGroupConfig } from '../config/types';
-import type { Instance } from '../get-instances/instance';
-import { Report } from '../report';
-import type { Specifier } from '../specifier';
-import type { NonSemverError } from '../specifier/lib/non-semver-error';
-declare const DisabledSemverGroup_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/Equal").Equal>, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" | keyof import("effect/Equal").Equal ? never : P]: A[P]; }) => Data.Data<Readonly<A> & {
+import { Effect } from 'effect';
+import type { SemverGroupConfig } from '../config/types.js';
+import type { Instance } from '../get-instances/instance.js';
+import { Report } from '../report.js';
+import type { Specifier } from '../specifier/index.js';
+import type { NonSemverError } from '../specifier/lib/non-semver-error.js';
+declare const DisabledSemverGroup_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Readonly<A> & {
     readonly _tag: "Disabled";
-}>;
+};
 /**
  * Semver groups are disabled by default and, when that's the case, every
  * instance is assigned to this group. This group will allow anything.
@@ -19,8 +19,8 @@ export declare class DisabledSemverGroup extends DisabledSemverGroup_base<{
     groupType: string;
     constructor(isCatchAll: boolean, config: SemverGroupConfig.Disabled);
     canAdd(_: Instance): boolean;
-    getFixed(specifier: Specifier.Any): Effect.Effect<never, NonSemverError, Specifier.Any>;
-    inspectAll(): Effect.Effect<never, never, Report.Disabled[]>;
-    inspect(instance: Instance): Effect.Effect<never, never, Report.Disabled>;
+    getFixed(specifier: Specifier.Any): Effect.Effect<Specifier.Any, NonSemverError>;
+    inspectAll(): Effect.Effect<Report.Disabled[], never, never>;
+    inspect(instance: Instance): Effect.Effect<Report.Disabled>;
 }
 export {};

package/dist/semver-group/disabled.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DisabledSemverGroup = void 0;
-const effect_1 = require("effect");
-const report_1 = require("../report");
+import { Data, Effect } from 'effect';
+import { Report } from '../report.js';
 /**
  * Semver groups are disabled by default and, when that's the case, every
  * instance is assigned to this group. This group will allow anything.
  */
-class DisabledSemverGroup extends effect_1.Data.TaggedClass('Disabled') {
+export class DisabledSemverGroup extends Data.TaggedClass('Disabled') {
     groupType = 'semverGroup';
     constructor(isCatchAll, config) {
         super({
@@ -20,13 +17,12 @@ class DisabledSemverGroup extends effect_1.Data.TaggedClass('Disabled') {
         return true;
     }
     getFixed(specifier) {
-        return effect_1.Effect.succeed(specifier);
+        return Effect.succeed(specifier);
     }
     inspectAll() {
-        return effect_1.Effect.all(this.instances.map((instance) => this.inspect(instance)));
+        return Effect.all(this.instances.map((instance) => this.inspect(instance)));
     }
     inspect(instance) {
-        return effect_1.Effect.succeed(new report_1.Report.Disabled(instance));
+        return Effect.succeed(new Report.Disabled(instance));
     }
 }
-exports.DisabledSemverGroup = DisabledSemverGroup;

package/dist/semver-group/filtered-out.d.ts

@@ -1,13 +1,13 @@
-import { Data, Effect } from 'effect';
-import type { GroupConfig } from '../config/types';
-import type { Ctx } from '../get-context';
-import type { Instance } from '../get-instances/instance';
-import { Report } from '../report';
-import type { Specifier } from '../specifier';
-import type { NonSemverError } from '../specifier/lib/non-semver-error';
-declare const FilteredOutSemverGroup_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/Equal").Equal>, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" | keyof import("effect/Equal").Equal ? never : P]: A[P]; }) => Data.Data<Readonly<A> & {
+import { Effect } from 'effect';
+import type { GroupConfig } from '../config/types.js';
+import type { Ctx } from '../get-context/index.js';
+import type { Instance } from '../get-instances/instance.js';
+import { Report } from '../report.js';
+import type { Specifier } from '../specifier/index.js';
+import type { NonSemverError } from '../specifier/lib/non-semver-error.js';
+declare const FilteredOutSemverGroup_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Readonly<A> & {
     readonly _tag: "FilteredOut";
-}>;
+};
 /**
  * Instances which do not match a given `--filter` option are assigned to this
  * group and nothing will be changed.
@@ -20,8 +20,8 @@ export declare class FilteredOutSemverGroup extends FilteredOutSemverGroup_base<
     groupType: string;
     constructor(ctx: Ctx);
     canAdd(instance: Instance): boolean;
-    getFixed(specifier: Specifier.Any): Effect.Effect<never, NonSemverError, Specifier.Any>;
-    inspectAll(): Effect.Effect<never, never, Report.FilteredOut[]>;
-    inspect(instance: Instance): Effect.Effect<never, never, Report.FilteredOut>;
+    getFixed(specifier: Specifier.Any): Effect.Effect<Specifier.Any, NonSemverError>;
+    inspectAll(): Effect.Effect<Report.FilteredOut[], never, never>;
+    inspect(instance: Instance): Effect.Effect<Report.FilteredOut>;
 }
 export {};

package/dist/semver-group/filtered-out.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FilteredOutSemverGroup = void 0;
-const effect_1 = require("effect");
-const get_filter_1 = require("../config/get-filter");
-const report_1 = require("../report");
+import { Data, Effect } from 'effect';
+import { getFilter } from '../config/get-filter.js';
+import { Report } from '../report.js';
 /**
  * Instances which do not match a given `--filter` option are assigned to this
  * group and nothing will be changed.
  */
-class FilteredOutSemverGroup extends effect_1.Data.TaggedClass('FilteredOut') {
+export class FilteredOutSemverGroup extends Data.TaggedClass('FilteredOut') {
     groupType = 'semverGroup';
     constructor(ctx) {
         super({
@@ -18,7 +15,7 @@ class FilteredOutSemverGroup extends effect_1.Data.TaggedClass('FilteredOut') {
                 label: 'Filtered out',
                 packages: ['**'],
             },
-            filter: (0, get_filter_1.getFilter)(ctx.config),
+            filter: getFilter(ctx.config),
             instances: [],
         });
     }
@@ -26,13 +23,12 @@ class FilteredOutSemverGroup extends effect_1.Data.TaggedClass('FilteredOut') {
         return instance.name.search(new RegExp(this.filter)) === -1;
     }
     getFixed(specifier) {
-        return effect_1.Effect.succeed(specifier);
+        return Effect.succeed(specifier);
     }
     inspectAll() {
-        return effect_1.Effect.all(this.instances.map((instance) => this.inspect(instance)));
+        return Effect.all(this.instances.map((instance) => this.inspect(instance)));
     }
     inspect(instance) {
-        return effect_1.Effect.succeed(new report_1.Report.FilteredOut(instance));
+        return Effect.succeed(new Report.FilteredOut(instance));
     }
 }
-exports.FilteredOutSemverGroup = FilteredOutSemverGroup;

package/dist/semver-group/ignored.d.ts

@@ -1,12 +1,12 @@
-import { Data, Effect } from 'effect';
-import type { SemverGroupConfig } from '../config/types';
-import type { Instance } from '../get-instances/instance';
-import { Report } from '../report';
-import type { Specifier } from '../specifier';
-import type { NonSemverError } from '../specifier/lib/non-semver-error';
-declare const IgnoredSemverGroup_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/Equal").Equal>, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" | keyof import("effect/Equal").Equal ? never : P]: A[P]; }) => Data.Data<Readonly<A> & {
+import { Effect } from 'effect';
+import type { SemverGroupConfig } from '../config/types.js';
+import type { Instance } from '../get-instances/instance.js';
+import { Report } from '../report.js';
+import type { Specifier } from '../specifier/index.js';
+import type { NonSemverError } from '../specifier/lib/non-semver-error.js';
+declare const IgnoredSemverGroup_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Readonly<A> & {
     readonly _tag: "Ignored";
-}>;
+};
 /** Every instance in this group is ignored and nothing will be changed */
 export declare class IgnoredSemverGroup extends IgnoredSemverGroup_base<{
     config: SemverGroupConfig.Ignored;
@@ -15,8 +15,8 @@ export declare class IgnoredSemverGroup extends IgnoredSemverGroup_base<{
     groupType: string;
     constructor(config: SemverGroupConfig.Ignored);
     canAdd(_: Instance): boolean;
-    getFixed(specifier: Specifier.Any): Effect.Effect<never, NonSemverError, Specifier.Any>;
-    inspectAll(): Effect.Effect<never, never, Report.Ignored[]>;
-    inspect(instance: Instance): Effect.Effect<never, never, Report.Ignored>;
+    getFixed(specifier: Specifier.Any): Effect.Effect<Specifier.Any, NonSemverError>;
+    inspectAll(): Effect.Effect<Report.Ignored[], never, never>;
+    inspect(instance: Instance): Effect.Effect<Report.Ignored>;
 }
 export {};

package/dist/semver-group/ignored.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IgnoredSemverGroup = void 0;
-const effect_1 = require("effect");
-const report_1 = require("../report");
+import { Data, Effect } from 'effect';
+import { Report } from '../report.js';
 /** Every instance in this group is ignored and nothing will be changed */
-class IgnoredSemverGroup extends effect_1.Data.TaggedClass('Ignored') {
+export class IgnoredSemverGroup extends Data.TaggedClass('Ignored') {
     groupType = 'semverGroup';
     constructor(config) {
         super({
@@ -16,13 +13,12 @@ class IgnoredSemverGroup extends effect_1.Data.TaggedClass('Ignored') {
         return true;
     }
     getFixed(specifier) {
-        return effect_1.Effect.succeed(specifier);
+        return Effect.succeed(specifier);
     }
     inspectAll() {
-        return effect_1.Effect.all(this.instances.map((instance) => this.inspect(instance)));
+        return Effect.all(this.instances.map((instance) => this.inspect(instance)));
     }
     inspect(instance) {
-        return effect_1.Effect.succeed(new report_1.Report.Ignored(instance));
+        return Effect.succeed(new Report.Ignored(instance));
     }
 }
-exports.IgnoredSemverGroup = IgnoredSemverGroup;

package/dist/semver-group/index.d.ts

@@ -1,17 +1,16 @@
-import { Data } from 'effect';
-import type { DisabledSemverGroup } from './disabled';
-import type { FilteredOutSemverGroup } from './filtered-out';
-import type { IgnoredSemverGroup } from './ignored';
-import type { WithRangeSemverGroup } from './with-range';
+import type { DisabledSemverGroup } from './disabled.js';
+import type { FilteredOutSemverGroup } from './filtered-out.js';
+import type { IgnoredSemverGroup } from './ignored.js';
+import type { WithRangeSemverGroup } from './with-range.js';
 export declare namespace SemverGroup {
     export type Disabled = DisabledSemverGroup;
     export type FilteredOut = FilteredOutSemverGroup;
     export type Ignored = IgnoredSemverGroup;
     export type WithRange = WithRangeSemverGroup;
     export type Any = Disabled | FilteredOut | Ignored | WithRange;
-    const ConfigError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<Omit<A, keyof import("effect/Equal").Equal>, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" | keyof import("effect/Equal").Equal ? never : P]: A[P]; }) => Data.Data<Readonly<A> & {
+    const ConfigError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => Readonly<A> & {
         readonly _tag: "SemverGroupConfigError";
-    }>;
+    };
     export class ConfigError extends ConfigError_base<{
         readonly config: unknown;
         readonly error: string;