syncpack 12.2.0 → 12.3.1

package/dist/semver-group/index.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SemverGroup = void 0;
-const effect_1 = require("effect");
-var SemverGroup;
+import { Data } from 'effect';
+export var SemverGroup;
 (function (SemverGroup) {
-    class ConfigError extends effect_1.Data.TaggedClass('SemverGroupConfigError') {
+    class ConfigError extends Data.TaggedClass('SemverGroupConfigError') {
     }
     SemverGroup.ConfigError = ConfigError;
-})(SemverGroup || (exports.SemverGroup = SemverGroup = {}));
+})(SemverGroup || (SemverGroup = {}));

package/dist/semver-group/with-range.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 { Specifier } from '../specifier';
-import type { NonSemverError } from '../specifier/lib/non-semver-error';
-declare const WithRangeSemverGroup_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 { Specifier } from '../specifier/index.js';
+import type { NonSemverError } from '../specifier/lib/non-semver-error.js';
+declare const WithRangeSemverGroup_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: "WithRange";
-}>;
+};
 export declare class WithRangeSemverGroup extends WithRangeSemverGroup_base<{
     config: SemverGroupConfig.WithRange;
     instances: Instance[];
@@ -15,8 +15,8 @@ export declare class WithRangeSemverGroup extends WithRangeSemverGroup_base<{
     groupType: string;
     constructor(isCatchAll: boolean, config: SemverGroupConfig.WithRange);
     canAdd(_: Instance): boolean;
-    getFixed(specifier: Specifier.Any): Effect.Effect<never, NonSemverError, Specifier.Any>;
-    inspectAll(): Effect.Effect<never, never, (Report.SemverRangeMismatch | Report.UnsupportedMismatch | Report.Valid)[]>;
-    inspect(instance: Instance): Effect.Effect<never, never, Report.UnsupportedMismatch | Report.SemverRangeMismatch | Report.Valid>;
+    getFixed(specifier: Specifier.Any): Effect.Effect<Specifier.Any, NonSemverError>;
+    inspectAll(): Effect.Effect<(Report.SemverRangeMismatch | Report.UnsupportedMismatch | Report.Valid)[], never, never>;
+    inspect(instance: Instance): Effect.Effect<Report.UnsupportedMismatch | Report.SemverRangeMismatch | Report.Valid>;
 }
 export {};

package/dist/semver-group/with-range.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WithRangeSemverGroup = void 0;
-const effect_1 = require("effect");
-const set_semver_range_1 = require("../lib/set-semver-range");
-const report_1 = require("../report");
-const specifier_1 = require("../specifier");
-class WithRangeSemverGroup extends effect_1.Data.TaggedClass('WithRange') {
+import { Data, Effect, pipe } from 'effect';
+import { setSemverRange } from '../lib/set-semver-range.js';
+import { Report } from '../report.js';
+import { Specifier } from '../specifier/index.js';
+export class WithRangeSemverGroup extends Data.TaggedClass('WithRange') {
     groupType = 'semverGroup';
     constructor(isCatchAll, config) {
         super({
@@ -19,31 +16,30 @@ class WithRangeSemverGroup extends effect_1.Data.TaggedClass('WithRange') {
         return true;
     }
     getFixed(specifier) {
-        return (0, effect_1.pipe)(specifier.getSemver(), effect_1.Effect.map((semver) => (0, set_semver_range_1.setSemverRange)(this.config.range, semver)), effect_1.Effect.flatMap((nextSemver) => specifier.setSemver(nextSemver)));
+        return pipe(specifier.getSemver(), Effect.map((semver) => setSemverRange(this.config.range, semver)), Effect.flatMap((nextSemver) => specifier.setSemver(nextSemver)));
     }
     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) {
-        const current = specifier_1.Specifier.create(instance, instance.rawSpecifier.raw);
-        return (0, effect_1.pipe)(this.getFixed(current), effect_1.Effect.match({
+        const current = Specifier.create(instance, instance.rawSpecifier.raw);
+        return pipe(this.getFixed(current), Effect.match({
             // if range is fixable
             onSuccess: (valid) => 
             // if it is pinned and matches its pin
             instance.versionGroup._tag === 'Pinned' &&
                 instance.rawSpecifier.raw === instance.versionGroup.config.pinVersion
                 ? // the pinned version takes precendence and is a match
-                    new report_1.Report.Valid(current)
+                    new Report.Valid(current)
                 : // if it is already like this on disk
                     instance.rawSpecifier.raw === valid.raw
                         ? // it is a match
-                            new report_1.Report.Valid(current)
+                            new Report.Valid(current)
                         : // it is a mismatch and should be this one
-                            new report_1.Report.SemverRangeMismatch(valid),
+                            new Report.SemverRangeMismatch(valid),
             // if range is NOT fixable, it is a mismatch we can't auto-fix
             // as it seems to not be semver
-            onFailure: () => new report_1.Report.UnsupportedMismatch(instance),
+            onFailure: () => new Report.UnsupportedMismatch(instance),
         }));
     }
 }
-exports.WithRangeSemverGroup = WithRangeSemverGroup;

package/dist/specifier/alias.d.ts

@@ -1,8 +1,8 @@
 import { Effect } from 'effect';
 import type { AliasResult } from 'npm-package-arg';
-import { Specifier } from '.';
-import { BaseSpecifier } from './base';
-import { NonSemverError } from './lib/non-semver-error';
+import { BaseSpecifier } from './base.js';
+import { Specifier } from './index.js';
+import { NonSemverError } from './lib/non-semver-error.js';
 type T = AliasResult;
 /** @example "npm:imageoptim-cli@3.1.7" */
 export declare class AliasSpecifier extends BaseSpecifier<T> {
@@ -10,8 +10,8 @@ export declare class AliasSpecifier extends BaseSpecifier<T> {
     /** The public name referenced in config */
     name: "alias";
     /** Return the version portion if it is valid semver */
-    getSemver(): Effect.Effect<never, NonSemverError, string>;
+    getSemver(): Effect.Effect<string, NonSemverError>;
     /** Get a new `Specifier` from the given semver version applied to this one */
-    setSemver(version: string): Effect.Effect<never, NonSemverError, Specifier.Any>;
+    setSemver(version: string): Effect.Effect<Specifier.Any, NonSemverError>;
 }
 export {};

package/dist/specifier/alias.js

@@ -1,24 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AliasSpecifier = void 0;
-const effect_1 = require("effect");
-const _1 = require(".");
-const base_1 = require("./base");
-const non_semver_error_1 = require("./lib/non-semver-error");
+import { Effect, pipe } from 'effect';
+import { BaseSpecifier } from './base.js';
+import { Specifier } from './index.js';
+import { NonSemverError } from './lib/non-semver-error.js';
 /** @example "npm:imageoptim-cli@3.1.7" */
-class AliasSpecifier extends base_1.BaseSpecifier {
+export class AliasSpecifier extends BaseSpecifier {
     _tag = 'Alias';
     /** The public name referenced in config */
     name = 'alias';
     /** Return the version portion if it is valid semver */
     getSemver() {
-        return (0, effect_1.pipe)(this.parse(), effect_1.Effect.mapError(() => new non_semver_error_1.NonSemverError({ specifier: this })), effect_1.Effect.map((parsed) => parsed.subSpec), effect_1.Effect.flatMap((subSpec) => ['range', 'version'].includes(subSpec.type) && subSpec.fetchSpec !== null
-            ? effect_1.Effect.succeed(subSpec.fetchSpec)
-            : non_semver_error_1.NonSemverError.asEffect(this)));
+        return pipe(this.parse(), Effect.mapError(() => new NonSemverError({ specifier: this })), Effect.map((parsed) => parsed.subSpec), Effect.flatMap((subSpec) => ['range', 'version'].includes(subSpec.type) && subSpec.fetchSpec !== null
+            ? Effect.succeed(subSpec.fetchSpec)
+            : NonSemverError.asEffect(this)));
     }
     /** Get a new `Specifier` from the given semver version applied to this one */
     setSemver(version) {
-        return (0, effect_1.pipe)(this.parse(), effect_1.Effect.mapError(() => new non_semver_error_1.NonSemverError({ specifier: this })), effect_1.Effect.map((parsed) => parsed.subSpec), effect_1.Effect.map((subSpec) => subSpec.name || ''), effect_1.Effect.map((name) => `npm:${name}@${version}`), effect_1.Effect.map((raw) => _1.Specifier.create(this.instance, raw)));
+        return pipe(this.parse(), Effect.mapError(() => new NonSemverError({ specifier: this })), Effect.map((parsed) => parsed.subSpec), Effect.map((subSpec) => subSpec.name || ''), Effect.map((name) => `npm:${name}@${version}`), Effect.map((raw) => Specifier.create(this.instance, raw)));
     }
 }
-exports.AliasSpecifier = AliasSpecifier;

package/dist/specifier/base.d.ts

@@ -1,8 +1,8 @@
 import { Effect } from 'effect';
-import { Specifier } from '.';
-import type { Instance } from '../get-instances/instance';
-import { NonSemverError } from './lib/non-semver-error';
-import type { NpmPackageArgResult } from './lib/parse-specifier';
+import type { Instance } from '../get-instances/instance.js';
+import { Specifier } from './index.js';
+import { NonSemverError } from './lib/non-semver-error.js';
+import type { NpmPackageArgResult } from './lib/parse-specifier.js';
 export declare class BaseSpecifier<T extends NpmPackageArgResult | unknown> {
     /** should be overridden by sub classes */
     _tag: string;
@@ -31,11 +31,11 @@ export declare class BaseSpecifier<T extends NpmPackageArgResult | unknown> {
      * Parse the raw version specifier using
      * https://github.com/npm/npm-package-arg
      */
-    protected parse(): Effect.Effect<never, unknown, T>;
+    protected parse(): Effect.Effect<T, unknown>;
     /** Return the version portion if it is valid semver */
-    getSemver(this: Specifier.Any): Effect.Effect<never, NonSemverError, string>;
+    getSemver(this: Specifier.Any): Effect.Effect<string, NonSemverError>;
     /** Get a new `Specifier` from the given semver version applied to this one */
-    setSemver(this: Specifier.Any, _version: string): Effect.Effect<never, NonSemverError, Specifier.Any>;
+    setSemver(this: Specifier.Any, _version: string): Effect.Effect<Specifier.Any, NonSemverError>;
     /** Apply the given specifier to a new one with this instance bound to it */
     replaceWith<T extends Specifier.Any>(specifier: T): T;
 }

package/dist/specifier/base.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseSpecifier = void 0;
-const effect_1 = require("effect");
-const _1 = require(".");
-const non_semver_error_1 = require("./lib/non-semver-error");
-const parse_specifier_1 = require("./lib/parse-specifier");
-class BaseSpecifier {
+import { Effect, pipe } from 'effect';
+import { Specifier } from './index.js';
+import { NonSemverError } from './lib/non-semver-error.js';
+import { parseSpecifier } from './lib/parse-specifier.js';
+export class BaseSpecifier {
     /** should be overridden by sub classes */
     _tag = 'Base';
     /** should be overridden by sub classes */
@@ -40,19 +37,18 @@ class BaseSpecifier {
         const name = this.instance.name;
         const raw = this.raw;
         const packageJsonFile = this.instance.packageJsonFile;
-        return (0, effect_1.pipe)(effect_1.Effect.try(() => (0, parse_specifier_1.parseSpecifier)(name, raw, packageJsonFile)), effect_1.Effect.tapError(() => effect_1.Effect.logError(`parseSpecifier threw on ${name}@${raw} at ${packageJsonFile.jsonFile.shortPath}`)));
+        return pipe(Effect.try(() => parseSpecifier(name, raw, packageJsonFile)), Effect.tapError(() => Effect.logError(`parseSpecifier threw on ${name}@${raw} at ${packageJsonFile.jsonFile.shortPath}`)));
     }
     /** Return the version portion if it is valid semver */
     getSemver() {
-        return non_semver_error_1.NonSemverError.asEffect(this);
+        return NonSemverError.asEffect(this);
     }
     /** Get a new `Specifier` from the given semver version applied to this one */
     setSemver(_version) {
-        return non_semver_error_1.NonSemverError.asEffect(this);
+        return NonSemverError.asEffect(this);
     }
     /** Apply the given specifier to a new one with this instance bound to it */
     replaceWith(specifier) {
-        return _1.Specifier.create(this.instance, specifier.raw);
+        return Specifier.create(this.instance, specifier.raw);
     }
 }
-exports.BaseSpecifier = BaseSpecifier;

package/dist/specifier/delete.d.ts

@@ -1,5 +1,5 @@
-import type { Instance } from '../get-instances/instance';
-import type { Delete } from '../version-group/lib/delete';
+import type { Instance } from '../get-instances/instance.js';
+import type { Delete } from '../version-group/lib/delete.js';
 /** A instance which should be deleted */
 export declare class DeleteSpecifier {
     _tag: string;
@@ -11,7 +11,7 @@ export declare class DeleteSpecifier {
         raw: Delete;
         instance: Instance;
     });
-    getSemver: (this: import(".").Specifier.Any) => import("effect/Effect").Effect<never, import("./lib/non-semver-error").NonSemverError, string>;
-    setSemver: (this: import(".").Specifier.Any, _version: string) => import("effect/Effect").Effect<never, import("./lib/non-semver-error").NonSemverError, import(".").Specifier.Any>;
-    replaceWith: <T extends import(".").Specifier.Any>(specifier: T) => T;
+    getSemver: (this: import("./index.js").Specifier.Any) => import("effect/Effect").Effect<string, import("./lib/non-semver-error.js").NonSemverError, never>;
+    setSemver: (this: import("./index.js").Specifier.Any, _version: string) => import("effect/Effect").Effect<import("./index.js").Specifier.Any, import("./lib/non-semver-error.js").NonSemverError, never>;
+    replaceWith: <T extends import("./index.js").Specifier.Any>(specifier: T) => T;
 }

package/dist/specifier/delete.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeleteSpecifier = void 0;
-const base_1 = require("./base");
+import { BaseSpecifier } from './base.js';
 /** A instance which should be deleted */
-class DeleteSpecifier {
+export class DeleteSpecifier {
     _tag = 'Delete';
     /** The public name referenced in config */
     name = 'delete';
@@ -13,8 +10,7 @@ class DeleteSpecifier {
         this.raw = data.raw;
         this.instance = data.instance;
     }
-    getSemver = base_1.BaseSpecifier.prototype.getSemver;
-    setSemver = base_1.BaseSpecifier.prototype.setSemver;
-    replaceWith = base_1.BaseSpecifier.prototype.replaceWith;
+    getSemver = BaseSpecifier.prototype.getSemver;
+    setSemver = BaseSpecifier.prototype.setSemver;
+    replaceWith = BaseSpecifier.prototype.replaceWith;
 }
-exports.DeleteSpecifier = DeleteSpecifier;

package/dist/specifier/exact.d.ts

@@ -1,8 +1,8 @@
 import { Effect } from 'effect';
-import { Specifier } from '.';
-import { BaseSpecifier } from './base';
-import { NonSemverError } from './lib/non-semver-error';
-import type { SpecificRegistryResult } from './lib/specific-registry-result';
+import { BaseSpecifier } from './base.js';
+import { Specifier } from './index.js';
+import { NonSemverError } from './lib/non-semver-error.js';
+import type { SpecificRegistryResult } from './lib/specific-registry-result.js';
 type T = SpecificRegistryResult<'version'>;
 /**
  * An exact semver version
@@ -13,8 +13,8 @@ export declare class ExactSpecifier extends BaseSpecifier<T> {
     /** The public name referenced in config */
     name: "exact";
     /** Return the semver version */
-    getSemver(): Effect.Effect<never, NonSemverError, string>;
+    getSemver(): Effect.Effect<string, NonSemverError>;
     /** Get a new `Specifier` from the given semver version applied to this one */
-    setSemver(version: string): Effect.Effect<never, never, Specifier.Any>;
+    setSemver(version: string): Effect.Effect<Specifier.Any>;
 }
 export {};

package/dist/specifier/exact.js

@@ -1,25 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExactSpecifier = void 0;
-const effect_1 = require("effect");
-const _1 = require(".");
-const base_1 = require("./base");
-const non_semver_error_1 = require("./lib/non-semver-error");
+import { Effect, pipe } from 'effect';
+import { BaseSpecifier } from './base.js';
+import { Specifier } from './index.js';
+import { NonSemverError } from './lib/non-semver-error.js';
 /**
  * An exact semver version
  * @example "1.4.4"
  */
-class ExactSpecifier extends base_1.BaseSpecifier {
+export class ExactSpecifier extends BaseSpecifier {
     _tag = 'Exact';
     /** The public name referenced in config */
     name = 'exact';
     /** Return the semver version */
     getSemver() {
-        return (0, effect_1.pipe)(this.parse(), effect_1.Effect.mapError(() => new non_semver_error_1.NonSemverError({ specifier: this })), effect_1.Effect.map((parsed) => parsed.fetchSpec));
+        return pipe(this.parse(), Effect.mapError(() => new NonSemverError({ specifier: this })), Effect.map((parsed) => parsed.fetchSpec));
     }
     /** Get a new `Specifier` from the given semver version applied to this one */
     setSemver(version) {
-        return effect_1.Effect.succeed(_1.Specifier.create(this.instance, version));
+        return Effect.succeed(Specifier.create(this.instance, version));
     }
 }
-exports.ExactSpecifier = ExactSpecifier;

package/dist/specifier/file.d.ts

@@ -1,5 +1,5 @@
 import type { FileResult } from 'npm-package-arg';
-import { BaseSpecifier } from './base';
+import { BaseSpecifier } from './base.js';
 /** @example */
 export declare class FileSpecifier extends BaseSpecifier<FileResult> {
     _tag: string;

package/dist/specifier/file.js

@@ -1,11 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileSpecifier = void 0;
-const base_1 = require("./base");
+import { BaseSpecifier } from './base.js';
 /** @example */
-class FileSpecifier extends base_1.BaseSpecifier {
+export class FileSpecifier extends BaseSpecifier {
     _tag = 'File';
     /** The public name referenced in config */
     name = 'file';
 }
-exports.FileSpecifier = FileSpecifier;

package/dist/specifier/hosted-git.d.ts

@@ -1,15 +1,15 @@
 import { Effect } from 'effect';
 import type { HostedGitResult } from 'npm-package-arg';
-import { Specifier } from '.';
-import { BaseSpecifier } from './base';
-import { NonSemverError } from './lib/non-semver-error';
+import { BaseSpecifier } from './base.js';
+import { Specifier } from './index.js';
+import { NonSemverError } from './lib/non-semver-error.js';
 /** @example "git+https://github.com/user/foo" */
 export declare class HostedGitSpecifier extends BaseSpecifier<HostedGitResult> {
     _tag: string;
     /** The public name referenced in config */
     name: "hosted-git";
     /** Return the git tag if it is valid semver */
-    getSemver(): Effect.Effect<never, NonSemverError, string>;
+    getSemver(): Effect.Effect<string, NonSemverError>;
     /** Get a new `Specifier` from the given semver version applied to this one */
-    setSemver(version: string): Effect.Effect<never, NonSemverError, Specifier.Any>;
+    setSemver(version: string): Effect.Effect<Specifier.Any, NonSemverError>;
 }

package/dist/specifier/hosted-git.js

@@ -1,26 +1,22 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HostedGitSpecifier = void 0;
-const effect_1 = require("effect");
-const _1 = require(".");
-const is_semver_1 = require("../guards/is-semver");
-const base_1 = require("./base");
-const non_semver_error_1 = require("./lib/non-semver-error");
+import { Effect, pipe } from 'effect';
+import { isSemver } from '../guards/is-semver.js';
+import { BaseSpecifier } from './base.js';
+import { Specifier } from './index.js';
+import { NonSemverError } from './lib/non-semver-error.js';
 /** @example "git+https://github.com/user/foo" */
-class HostedGitSpecifier extends base_1.BaseSpecifier {
+export class HostedGitSpecifier extends BaseSpecifier {
     _tag = 'HostedGit';
     /** The public name referenced in config */
     name = 'hosted-git';
     /** Return the git tag if it is valid semver */
     getSemver() {
-        return (0, effect_1.pipe)(this.parse(), effect_1.Effect.mapError(() => new non_semver_error_1.NonSemverError({ specifier: this })), effect_1.Effect.map((parsed) => parsed.gitCommittish || ''), effect_1.Effect.flatMap((gitCommittish) => (0, is_semver_1.isSemver)(gitCommittish) ? effect_1.Effect.succeed(gitCommittish) : non_semver_error_1.NonSemverError.asEffect(this)));
+        return pipe(this.parse(), Effect.mapError(() => new NonSemverError({ specifier: this })), Effect.map((parsed) => parsed.gitCommittish || ''), Effect.flatMap((gitCommittish) => isSemver(gitCommittish) ? Effect.succeed(gitCommittish) : NonSemverError.asEffect(this)));
     }
     /** Get a new `Specifier` from the given semver version applied to this one */
     setSemver(version) {
-        return (0, effect_1.pipe)(this.parse(), effect_1.Effect.mapError(() => new non_semver_error_1.NonSemverError({ specifier: this })), effect_1.Effect.map((parsed) => ({
+        return pipe(this.parse(), Effect.mapError(() => new NonSemverError({ specifier: this })), Effect.map((parsed) => ({
             gitCommittish: parsed.gitCommittish || '',
             rawSpec: parsed.rawSpec || '',
-        })), effect_1.Effect.map(({ gitCommittish, rawSpec }) => rawSpec.replace(gitCommittish, version)), effect_1.Effect.map((raw) => _1.Specifier.create(this.instance, raw)));
+        })), Effect.map(({ gitCommittish, rawSpec }) => rawSpec.replace(gitCommittish, version)), Effect.map((raw) => Specifier.create(this.instance, raw)));
     }
 }
-exports.HostedGitSpecifier = HostedGitSpecifier;

package/dist/specifier/index.d.ts

@@ -1,16 +1,16 @@
-import type { Instance } from '../get-instances/instance';
-import { type Delete } from '../version-group/lib/delete';
-import { AliasSpecifier } from './alias';
-import { DeleteSpecifier } from './delete';
-import { ExactSpecifier } from './exact';
-import { FileSpecifier } from './file';
-import { HostedGitSpecifier } from './hosted-git';
-import { LatestSpecifier } from './latest';
-import { RangeSpecifier } from './range';
-import { TagSpecifier } from './tag';
-import { UnsupportedSpecifier } from './unsupported';
-import { UrlSpecifier } from './url';
-import { WorkspaceProtocolSpecifier } from './workspace-protocol';
+import type { Instance } from '../get-instances/instance.js';
+import { type Delete } from '../version-group/lib/delete.js';
+import { AliasSpecifier } from './alias.js';
+import { DeleteSpecifier } from './delete.js';
+import { ExactSpecifier } from './exact.js';
+import { FileSpecifier } from './file.js';
+import { HostedGitSpecifier } from './hosted-git.js';
+import { LatestSpecifier } from './latest.js';
+import { RangeSpecifier } from './range.js';
+import { TagSpecifier } from './tag.js';
+import { UnsupportedSpecifier } from './unsupported.js';
+import { UrlSpecifier } from './url.js';
+import { WorkspaceProtocolSpecifier } from './workspace-protocol.js';
 export declare namespace Specifier {
     const Alias: typeof AliasSpecifier;
     const Delete: typeof DeleteSpecifier;

package/dist/specifier/index.js

@@ -1,41 +1,38 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Specifier = void 0;
-const delete_1 = require("../version-group/lib/delete");
-const alias_1 = require("./alias");
-const delete_2 = require("./delete");
-const exact_1 = require("./exact");
-const file_1 = require("./file");
-const hosted_git_1 = require("./hosted-git");
-const latest_1 = require("./latest");
-const parse_specifier_1 = require("./lib/parse-specifier");
-const range_1 = require("./range");
-const tag_1 = require("./tag");
-const unsupported_1 = require("./unsupported");
-const url_1 = require("./url");
-const workspace_protocol_1 = require("./workspace-protocol");
-var Specifier;
+import { DELETE } from '../version-group/lib/delete.js';
+import { AliasSpecifier } from './alias.js';
+import { DeleteSpecifier } from './delete.js';
+import { ExactSpecifier } from './exact.js';
+import { FileSpecifier } from './file.js';
+import { HostedGitSpecifier } from './hosted-git.js';
+import { LatestSpecifier } from './latest.js';
+import { parseSpecifier } from './lib/parse-specifier.js';
+import { RangeSpecifier } from './range.js';
+import { TagSpecifier } from './tag.js';
+import { UnsupportedSpecifier } from './unsupported.js';
+import { UrlSpecifier } from './url.js';
+import { WorkspaceProtocolSpecifier } from './workspace-protocol.js';
+export var Specifier;
 (function (Specifier) {
-    Specifier.Alias = alias_1.AliasSpecifier;
-    Specifier.Delete = delete_2.DeleteSpecifier;
-    Specifier.Exact = exact_1.ExactSpecifier;
-    Specifier.File = file_1.FileSpecifier;
-    Specifier.HostedGit = hosted_git_1.HostedGitSpecifier;
-    Specifier.Latest = latest_1.LatestSpecifier;
-    Specifier.Range = range_1.RangeSpecifier;
-    Specifier.Tag = tag_1.TagSpecifier;
-    Specifier.Unsupported = unsupported_1.UnsupportedSpecifier;
-    Specifier.Url = url_1.UrlSpecifier;
-    Specifier.WorkspaceProtocol = workspace_protocol_1.WorkspaceProtocolSpecifier;
+    Specifier.Alias = AliasSpecifier;
+    Specifier.Delete = DeleteSpecifier;
+    Specifier.Exact = ExactSpecifier;
+    Specifier.File = FileSpecifier;
+    Specifier.HostedGit = HostedGitSpecifier;
+    Specifier.Latest = LatestSpecifier;
+    Specifier.Range = RangeSpecifier;
+    Specifier.Tag = TagSpecifier;
+    Specifier.Unsupported = UnsupportedSpecifier;
+    Specifier.Url = UrlSpecifier;
+    Specifier.WorkspaceProtocol = WorkspaceProtocolSpecifier;
     function create(instance, raw) {
-        if (raw === delete_1.DELETE)
+        if (raw === DELETE)
             return new Specifier.Delete({ instance, raw });
         if (!raw)
             return new Specifier.Unsupported({ instance, raw });
         try {
             if (raw === 'latest')
                 raw = '*';
-            const parsed = (0, parse_specifier_1.parseSpecifier)(instance.name, raw, instance.packageJsonFile);
+            const parsed = parseSpecifier(instance.name, raw, instance.packageJsonFile);
             const type = parsed.type;
             const data = { instance, raw };
             if (raw === '*')
@@ -63,4 +60,4 @@ var Specifier;
         }
     }
     Specifier.create = create;
-})(Specifier || (exports.Specifier = Specifier = {}));
+})(Specifier || (Specifier = {}));

package/dist/specifier/latest.d.ts

@@ -1,8 +1,8 @@
 import { Effect } from 'effect';
-import { Specifier } from '.';
-import { BaseSpecifier } from './base';
-import { NonSemverError } from './lib/non-semver-error';
-import type { SpecificRegistryResult } from './lib/specific-registry-result';
+import { BaseSpecifier } from './base.js';
+import { Specifier } from './index.js';
+import { NonSemverError } from './lib/non-semver-error.js';
+import type { SpecificRegistryResult } from './lib/specific-registry-result.js';
 type T = SpecificRegistryResult<'range'>;
 /**
  * @example "*"
@@ -12,8 +12,8 @@ export declare class LatestSpecifier extends BaseSpecifier<T> {
     /** The public name referenced in config */
     name: "latest";
     /** Return the semver version including the range */
-    getSemver(): Effect.Effect<never, NonSemverError, string>;
+    getSemver(): Effect.Effect<string, NonSemverError>;
     /** Get a new `Specifier` from the given semver version applied to this one */
-    setSemver(version: string): Effect.Effect<never, never, Specifier.Any>;
+    setSemver(version: string): Effect.Effect<Specifier.Any>;
 }
 export {};

package/dist/specifier/latest.js

@@ -1,24 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LatestSpecifier = void 0;
-const effect_1 = require("effect");
-const _1 = require(".");
-const base_1 = require("./base");
-const non_semver_error_1 = require("./lib/non-semver-error");
+import { Effect, pipe } from 'effect';
+import { BaseSpecifier } from './base.js';
+import { Specifier } from './index.js';
+import { NonSemverError } from './lib/non-semver-error.js';
 /**
  * @example "*"
  */
-class LatestSpecifier extends base_1.BaseSpecifier {
+export class LatestSpecifier extends BaseSpecifier {
     _tag = 'Latest';
     /** The public name referenced in config */
     name = 'latest';
     /** Return the semver version including the range */
     getSemver() {
-        return (0, effect_1.pipe)(this.parse(), effect_1.Effect.mapError(() => new non_semver_error_1.NonSemverError({ specifier: this })), effect_1.Effect.map((parsed) => parsed.fetchSpec));
+        return pipe(this.parse(), Effect.mapError(() => new NonSemverError({ specifier: this })), Effect.map((parsed) => parsed.fetchSpec));
     }
     /** Get a new `Specifier` from the given semver version applied to this one */
     setSemver(version) {
-        return effect_1.Effect.succeed(_1.Specifier.create(this.instance, version));
+        return Effect.succeed(Specifier.create(this.instance, version));
     }
 }
-exports.LatestSpecifier = LatestSpecifier;

package/dist/specifier/lib/non-semver-error.d.ts

@@ -1,11 +1,11 @@
-import { Data, Effect } from 'effect';
-import type { Specifier } from '..';
-declare const NonSemverError_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 { Specifier } from '../index.js';
+declare const NonSemverError_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: "NonSemverError";
-}>;
+};
 export declare class NonSemverError extends NonSemverError_base<{
     specifier: Specifier.Any;
 }> {
-    static asEffect<T>(specifier: Specifier.Any): Effect.Effect<never, NonSemverError, T>;
+    static asEffect<T>(specifier: Specifier.Any): Effect.Effect<T, NonSemverError>;
 }
 export {};