renovate 43.253.2 → 43.255.0

package/dist/data/replacements.js

@@ -229,6 +229,15 @@ var replacements_default = {
 			}
 		]
 	},
+	"corentinmusard-otel-cicd-action-to-dash0hq": {
+		"description": "`corentinmusard/otel-cicd-action` was transferred to `dash0hq/otel-cicd-action`.",
+		"packageRules": [{
+			"matchDatasources": ["github-releases", "github-tags"],
+			"matchPackageNames": ["corentinmusard/otel-cicd-action"],
+			"replacementName": "dash0hq/otel-cicd-action",
+			"replacementVersion": "4.0.1"
+		}]
+	},
 	"cpx-to-maintenance-fork": {
 		"description": "Maintenance fork of `cpx`",
 		"packageRules": [{

package/dist/modules/versioning/api.js

@@ -35,22 +35,23 @@ import api$34, { id as id$26 } from "./node/index.js";
 import api$35, { id as id$27 } from "./lambda-node/index.js";
 import api$36, { id as id$28 } from "./nixpkgs/index.js";
 import api$37, { id as id$29 } from "./nuget/index.js";
-import api$38, { id as id$30 } from "./perl/index.js";
-import api$39, { id as id$31 } from "./poetry/index.js";
-import api$40 from "./pvp/index.js";
-import api$41, { id as id$32 } from "./python/index.js";
-import api$42, { id as id$33 } from "./redhat/index.js";
-import api$43 from "./rez/index.js";
-import api$44 from "./rpm/index.js";
-import api$45, { id as id$34 } from "./ruby/index.js";
-import api$46, { id as id$35 } from "./rust-release-channel/index.js";
-import api$47, { id as id$36 } from "./semver-coerced/index.js";
-import api$48, { id as id$37 } from "./same-major/index.js";
-import api$49, { id as id$38 } from "./semver-partial/index.js";
-import api$50, { id as id$39 } from "./swift/index.js";
-import { api as api$51, id as id$40 } from "./ubuntu/index.js";
-import api$52, { id as id$41 } from "./unity3d/index.js";
-import api$53, { id as id$42 } from "./unity3d-packages/index.js";
+import api$38, { id as id$30 } from "./paket/index.js";
+import api$39, { id as id$31 } from "./perl/index.js";
+import api$40, { id as id$32 } from "./poetry/index.js";
+import api$41 from "./pvp/index.js";
+import api$42, { id as id$33 } from "./python/index.js";
+import api$43, { id as id$34 } from "./redhat/index.js";
+import api$44 from "./rez/index.js";
+import api$45 from "./rpm/index.js";
+import api$46, { id as id$35 } from "./ruby/index.js";
+import api$47, { id as id$36 } from "./rust-release-channel/index.js";
+import api$48, { id as id$37 } from "./semver-coerced/index.js";
+import api$49, { id as id$38 } from "./same-major/index.js";
+import api$50, { id as id$39 } from "./semver-partial/index.js";
+import api$51, { id as id$40 } from "./swift/index.js";
+import { api as api$52, id as id$41 } from "./ubuntu/index.js";
+import api$53, { id as id$42 } from "./unity3d/index.js";
+import api$54, { id as id$43 } from "./unity3d-packages/index.js";
 //#region lib/modules/versioning/api.ts
 const api = /* @__PURE__ */ new Map();
 api.set("apk", api$1);
@@ -87,25 +88,26 @@ api.set(id$28, api$36);
 api.set(id$26, api$34);
 api.set("npm", api$8);
 api.set(id$29, api$37);
-api.set(id$10, api$13);
 api.set(id$30, api$38);
+api.set(id$10, api$13);
 api.set(id$31, api$39);
-api.set("pvp", api$40);
-api.set(id$32, api$41);
+api.set(id$32, api$40);
+api.set("pvp", api$41);
 api.set(id$33, api$42);
+api.set(id$34, api$43);
 api.set(id, api$2);
-api.set("rez", api$43);
-api.set("rpm", api$44);
-api.set(id$34, api$45);
+api.set("rez", api$44);
+api.set("rpm", api$45);
 api.set(id$35, api$46);
-api.set(id$37, api$48);
-api.set(id$5, api$7);
 api.set(id$36, api$47);
 api.set(id$38, api$49);
+api.set(id$5, api$7);
+api.set(id$37, api$48);
 api.set(id$39, api$50);
 api.set(id$40, api$51);
 api.set(id$41, api$52);
 api.set(id$42, api$53);
+api.set(id$43, api$54);
 //#endregion
 export { api as default };
 

package/dist/modules/versioning/api.js.map

@@ -1 +1 @@
-{"version":3,"file":"api.js","names":["apk.api","awsEksAddon.id","awsEksAddon.api","amazonMachineImage.id","amazonMachineImage.api","azureRestApi.id","azureRestApi.api","bazelModule.id","bazelModule.api","cargo.id","cargo.api","composer.id","composer.api","conan.id","conan.api","conda.id","conda.api","deb.api","debian.id","debian.api","deno.id","deno.api","devbox.id","devbox.api","docker.id","docker.api","elm.api","exact.id","exact.api","git.api","githubActions.id","githubActions.api","glasskube.id","glasskube.api","goModDirective.id","goModDirective.api","gradle.id","gradle.api","hashicorp.id","hashicorp.api","helm.id","helm.api","hermit.id","hermit.api","hex.api","ivy.api","kubernetesApi.id","kubernetesApi.api","lambdaNode.id","lambdaNode.api","loose.id","loose.api","maven.id","maven.api","nixpkgs.id","nixpkgs.api","node.id","node.api","npm.api","nuget.id","nuget.api","pep440.id","pep440.api","perl.id","perl.api","poetry.id","poetry.api","pvp.api","python.id","python.api","redhat.id","redhat.api","regex.id","regex.api","rez.api","rpm.api","ruby.id","ruby.api","rustReleaseChannel.id","rustReleaseChannel.api","sameMajor.id","sameMajor.api","semver.id","semver.api","semverCoerced.id","semverCoerced.api","semverPartial.id","semverPartial.api","swift.id","swift.api","ubuntu.id","ubuntu.api","unity3d.id","unity3d.api","unity3dPackages.id","unity3dPackages.api"],"sources":["../../../lib/modules/versioning/api.ts"],"sourcesContent":["import * as apk from './apk/index.ts';\nimport * as awsEksAddon from './aws-eks-addon/index.ts';\nimport * as amazonMachineImage from './aws-machine-image/index.ts';\nimport * as azureRestApi from './azure-rest-api/index.ts';\nimport * as bazelModule from './bazel-module/index.ts';\nimport * as cargo from './cargo/index.ts';\nimport * as composer from './composer/index.ts';\nimport * as conan from './conan/index.ts';\nimport * as conda from './conda/index.ts';\nimport * as deb from './deb/index.ts';\nimport * as debian from './debian/index.ts';\nimport * as deno from './deno/index.ts';\nimport * as devbox from './devbox/index.ts';\nimport * as docker from './docker/index.ts';\nimport * as elm from './elm/index.ts';\nimport * as exact from './exact/index.ts';\nimport * as git from './git/index.ts';\nimport * as githubActions from './github-actions/index.ts';\nimport * as glasskube from './glasskube/index.ts';\nimport * as goModDirective from './go-mod-directive/index.ts';\nimport * as gradle from './gradle/index.ts';\nimport * as hashicorp from './hashicorp/index.ts';\nimport * as helm from './helm/index.ts';\nimport * as hermit from './hermit/index.ts';\nimport * as hex from './hex/index.ts';\nimport * as ivy from './ivy/index.ts';\nimport * as kubernetesApi from './kubernetes-api/index.ts';\nimport * as lambdaNode from './lambda-node/index.ts';\nimport * as loose from './loose/index.ts';\nimport * as maven from './maven/index.ts';\nimport * as nixpkgs from './nixpkgs/index.ts';\nimport * as node from './node/index.ts';\nimport * as npm from './npm/index.ts';\nimport * as nuget from './nuget/index.ts';\nimport * as pep440 from './pep440/index.ts';\nimport * as perl from './perl/index.ts';\nimport * as poetry from './poetry/index.ts';\nimport * as pvp from './pvp/index.ts';\nimport * as python from './python/index.ts';\nimport * as redhat from './redhat/index.ts';\nimport * as regex from './regex/index.ts';\nimport * as rez from './rez/index.ts';\nimport * as rpm from './rpm/index.ts';\nimport * as ruby from './ruby/index.ts';\nimport * as rustReleaseChannel from './rust-release-channel/index.ts';\nimport * as sameMajor from './same-major/index.ts';\nimport * as semver from './semver/index.ts';\nimport * as semverCoerced from './semver-coerced/index.ts';\nimport * as semverPartial from './semver-partial/index.ts';\nimport * as swift from './swift/index.ts';\nimport type { VersioningApi, VersioningApiConstructor } from './types.ts';\nimport * as ubuntu from './ubuntu/index.ts';\nimport * as unity3d from './unity3d/index.ts';\nimport * as unity3dPackages from './unity3d-packages/index.ts';\n\nconst api = new Map<string, VersioningApi | VersioningApiConstructor>();\nexport default api;\n\napi.set(apk.id, apk.api);\napi.set(awsEksAddon.id, awsEksAddon.api);\napi.set(amazonMachineImage.id, amazonMachineImage.api);\napi.set(azureRestApi.id, azureRestApi.api);\napi.set(bazelModule.id, bazelModule.api);\napi.set(cargo.id, cargo.api);\napi.set(composer.id, composer.api);\napi.set(conan.id, conan.api);\napi.set(conda.id, conda.api);\napi.set(deb.id, deb.api);\napi.set(debian.id, debian.api);\napi.set(deno.id, deno.api);\napi.set(devbox.id, devbox.api);\napi.set(docker.id, docker.api);\napi.set(elm.id, elm.api);\napi.set(exact.id, exact.api);\napi.set(git.id, git.api);\napi.set(githubActions.id, githubActions.api);\napi.set(glasskube.id, glasskube.api);\napi.set(goModDirective.id, goModDirective.api);\napi.set(gradle.id, gradle.api);\napi.set(hashicorp.id, hashicorp.api);\napi.set(helm.id, helm.api);\napi.set(hermit.id, hermit.api);\napi.set(hex.id, hex.api);\napi.set(ivy.id, ivy.api);\napi.set(kubernetesApi.id, kubernetesApi.api);\napi.set(lambdaNode.id, lambdaNode.api);\napi.set(loose.id, loose.api);\napi.set(maven.id, maven.api);\napi.set(nixpkgs.id, nixpkgs.api);\napi.set(node.id, node.api);\napi.set(npm.id, npm.api);\napi.set(nuget.id, nuget.api);\napi.set(pep440.id, pep440.api);\napi.set(perl.id, perl.api);\napi.set(poetry.id, poetry.api);\napi.set(pvp.id, pvp.api);\napi.set(python.id, python.api);\napi.set(redhat.id, redhat.api);\napi.set(regex.id, regex.api);\napi.set(rez.id, rez.api);\napi.set(rpm.id, rpm.api);\napi.set(ruby.id, ruby.api);\napi.set(rustReleaseChannel.id, rustReleaseChannel.api);\napi.set(sameMajor.id, sameMajor.api);\napi.set(semver.id, semver.api);\napi.set(semverCoerced.id, semverCoerced.api);\napi.set(semverPartial.id, semverPartial.api);\napi.set(swift.id, swift.api);\napi.set(ubuntu.id, ubuntu.api);\napi.set(unity3d.id, unity3d.api);\napi.set(unity3dPackages.id, unity3dPackages.api);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuDA,MAAM,sBAAM,IAAI,IAAsD;AAGtE,IAAI,IAAI,OAAQA,KAAO;AACvB,IAAI,IAAIC,MAAgBC,KAAe;AACvC,IAAI,IAAIC,MAAuBC,KAAsB;AACrD,IAAI,IAAIC,MAAiBC,KAAgB;AACzC,IAAI,IAAIC,MAAgBC,KAAe;AACvC,IAAI,IAAIC,MAAUC,KAAS;AAC3B,IAAI,IAAIC,MAAaC,MAAY;AACjC,IAAI,IAAIC,MAAUC,MAAS;AAC3B,IAAI,IAAIC,OAAUC,MAAS;AAC3B,IAAI,IAAI,OAAQC,MAAO;AACvB,IAAI,IAAIC,OAAWC,MAAU;AAC7B,IAAI,IAAIC,OAASC,MAAQ;AACzB,IAAI,IAAIC,OAAWC,MAAU;AAC7B,IAAI,IAAIC,OAAWC,MAAU;AAC7B,IAAI,IAAI,OAAQC,MAAO;AACvB,IAAI,IAAIC,OAAUC,MAAS;AAC3B,IAAI,IAAI,OAAQC,MAAO;AACvB,IAAI,IAAIC,OAAkBC,MAAiB;AAC3C,IAAI,IAAIC,OAAcC,MAAa;AACnC,IAAI,IAAIC,OAAmBC,MAAkB;AAC7C,IAAI,IAAIC,OAAWC,MAAU;AAC7B,IAAI,IAAIC,OAAcC,MAAa;AACnC,IAAI,IAAIC,OAASC,MAAQ;AACzB,IAAI,IAAIC,OAAWC,MAAU;AAC7B,IAAI,IAAI,OAAQC,MAAO;AACvB,IAAI,IAAI,OAAQC,MAAO;AACvB,IAAI,IAAIC,OAAkBC,MAAiB;AAC3C,IAAI,IAAIC,OAAeC,MAAc;AACrC,IAAI,IAAIC,MAAUC,MAAS;AAC3B,IAAI,IAAIC,OAAUC,MAAS;AAC3B,IAAI,IAAIC,OAAYC,MAAW;AAC/B,IAAI,IAAIC,OAASC,MAAQ;AACzB,IAAI,IAAI,OAAQC,KAAO;AACvB,IAAI,IAAIC,OAAUC,MAAS;AAC3B,IAAI,IAAIC,OAAWC,MAAU;AAC7B,IAAI,IAAIC,OAASC,MAAQ;AACzB,IAAI,IAAIC,OAAWC,MAAU;AAC7B,IAAI,IAAI,OAAQC,MAAO;AACvB,IAAI,IAAIC,OAAWC,MAAU;AAC7B,IAAI,IAAIC,OAAWC,MAAU;AAC7B,IAAI,IAAIC,IAAUC,KAAS;AAC3B,IAAI,IAAI,OAAQC,MAAO;AACvB,IAAI,IAAI,OAAQC,MAAO;AACvB,IAAI,IAAIC,OAASC,MAAQ;AACzB,IAAI,IAAIC,OAAuBC,MAAsB;AACrD,IAAI,IAAIC,OAAcC,MAAa;AACnC,IAAI,IAAIC,MAAWC,KAAU;AAC7B,IAAI,IAAIC,OAAkBC,MAAiB;AAC3C,IAAI,IAAIC,OAAkBC,MAAiB;AAC3C,IAAI,IAAIC,OAAUC,MAAS;AAC3B,IAAI,IAAIC,OAAWC,MAAU;AAC7B,IAAI,IAAIC,OAAYC,MAAW;AAC/B,IAAI,IAAIC,OAAoBC,MAAmB"}
+{"version":3,"file":"api.js","names":["apk.api","awsEksAddon.id","awsEksAddon.api","amazonMachineImage.id","amazonMachineImage.api","azureRestApi.id","azureRestApi.api","bazelModule.id","bazelModule.api","cargo.id","cargo.api","composer.id","composer.api","conan.id","conan.api","conda.id","conda.api","deb.api","debian.id","debian.api","deno.id","deno.api","devbox.id","devbox.api","docker.id","docker.api","elm.api","exact.id","exact.api","git.api","githubActions.id","githubActions.api","glasskube.id","glasskube.api","goModDirective.id","goModDirective.api","gradle.id","gradle.api","hashicorp.id","hashicorp.api","helm.id","helm.api","hermit.id","hermit.api","hex.api","ivy.api","kubernetesApi.id","kubernetesApi.api","lambdaNode.id","lambdaNode.api","loose.id","loose.api","maven.id","maven.api","nixpkgs.id","nixpkgs.api","node.id","node.api","npm.api","nuget.id","nuget.api","paket.id","paket.api","pep440.id","pep440.api","perl.id","perl.api","poetry.id","poetry.api","pvp.api","python.id","python.api","redhat.id","redhat.api","regex.id","regex.api","rez.api","rpm.api","ruby.id","ruby.api","rustReleaseChannel.id","rustReleaseChannel.api","sameMajor.id","sameMajor.api","semver.id","semver.api","semverCoerced.id","semverCoerced.api","semverPartial.id","semverPartial.api","swift.id","swift.api","ubuntu.id","ubuntu.api","unity3d.id","unity3d.api","unity3dPackages.id","unity3dPackages.api"],"sources":["../../../lib/modules/versioning/api.ts"],"sourcesContent":["import * as apk from './apk/index.ts';\nimport * as awsEksAddon from './aws-eks-addon/index.ts';\nimport * as amazonMachineImage from './aws-machine-image/index.ts';\nimport * as azureRestApi from './azure-rest-api/index.ts';\nimport * as bazelModule from './bazel-module/index.ts';\nimport * as cargo from './cargo/index.ts';\nimport * as composer from './composer/index.ts';\nimport * as conan from './conan/index.ts';\nimport * as conda from './conda/index.ts';\nimport * as deb from './deb/index.ts';\nimport * as debian from './debian/index.ts';\nimport * as deno from './deno/index.ts';\nimport * as devbox from './devbox/index.ts';\nimport * as docker from './docker/index.ts';\nimport * as elm from './elm/index.ts';\nimport * as exact from './exact/index.ts';\nimport * as git from './git/index.ts';\nimport * as githubActions from './github-actions/index.ts';\nimport * as glasskube from './glasskube/index.ts';\nimport * as goModDirective from './go-mod-directive/index.ts';\nimport * as gradle from './gradle/index.ts';\nimport * as hashicorp from './hashicorp/index.ts';\nimport * as helm from './helm/index.ts';\nimport * as hermit from './hermit/index.ts';\nimport * as hex from './hex/index.ts';\nimport * as ivy from './ivy/index.ts';\nimport * as kubernetesApi from './kubernetes-api/index.ts';\nimport * as lambdaNode from './lambda-node/index.ts';\nimport * as loose from './loose/index.ts';\nimport * as maven from './maven/index.ts';\nimport * as nixpkgs from './nixpkgs/index.ts';\nimport * as node from './node/index.ts';\nimport * as npm from './npm/index.ts';\nimport * as nuget from './nuget/index.ts';\nimport * as paket from './paket/index.ts';\nimport * as pep440 from './pep440/index.ts';\nimport * as perl from './perl/index.ts';\nimport * as poetry from './poetry/index.ts';\nimport * as pvp from './pvp/index.ts';\nimport * as python from './python/index.ts';\nimport * as redhat from './redhat/index.ts';\nimport * as regex from './regex/index.ts';\nimport * as rez from './rez/index.ts';\nimport * as rpm from './rpm/index.ts';\nimport * as ruby from './ruby/index.ts';\nimport * as rustReleaseChannel from './rust-release-channel/index.ts';\nimport * as sameMajor from './same-major/index.ts';\nimport * as semver from './semver/index.ts';\nimport * as semverCoerced from './semver-coerced/index.ts';\nimport * as semverPartial from './semver-partial/index.ts';\nimport * as swift from './swift/index.ts';\nimport type { VersioningApi, VersioningApiConstructor } from './types.ts';\nimport * as ubuntu from './ubuntu/index.ts';\nimport * as unity3d from './unity3d/index.ts';\nimport * as unity3dPackages from './unity3d-packages/index.ts';\n\nconst api = new Map<string, VersioningApi | VersioningApiConstructor>();\nexport default api;\n\napi.set(apk.id, apk.api);\napi.set(awsEksAddon.id, awsEksAddon.api);\napi.set(amazonMachineImage.id, amazonMachineImage.api);\napi.set(azureRestApi.id, azureRestApi.api);\napi.set(bazelModule.id, bazelModule.api);\napi.set(cargo.id, cargo.api);\napi.set(composer.id, composer.api);\napi.set(conan.id, conan.api);\napi.set(conda.id, conda.api);\napi.set(deb.id, deb.api);\napi.set(debian.id, debian.api);\napi.set(deno.id, deno.api);\napi.set(devbox.id, devbox.api);\napi.set(docker.id, docker.api);\napi.set(elm.id, elm.api);\napi.set(exact.id, exact.api);\napi.set(git.id, git.api);\napi.set(githubActions.id, githubActions.api);\napi.set(glasskube.id, glasskube.api);\napi.set(goModDirective.id, goModDirective.api);\napi.set(gradle.id, gradle.api);\napi.set(hashicorp.id, hashicorp.api);\napi.set(helm.id, helm.api);\napi.set(hermit.id, hermit.api);\napi.set(hex.id, hex.api);\napi.set(ivy.id, ivy.api);\napi.set(kubernetesApi.id, kubernetesApi.api);\napi.set(lambdaNode.id, lambdaNode.api);\napi.set(loose.id, loose.api);\napi.set(maven.id, maven.api);\napi.set(nixpkgs.id, nixpkgs.api);\napi.set(node.id, node.api);\napi.set(npm.id, npm.api);\napi.set(nuget.id, nuget.api);\napi.set(paket.id, paket.api);\napi.set(pep440.id, pep440.api);\napi.set(perl.id, perl.api);\napi.set(poetry.id, poetry.api);\napi.set(pvp.id, pvp.api);\napi.set(python.id, python.api);\napi.set(redhat.id, redhat.api);\napi.set(regex.id, regex.api);\napi.set(rez.id, rez.api);\napi.set(rpm.id, rpm.api);\napi.set(ruby.id, ruby.api);\napi.set(rustReleaseChannel.id, rustReleaseChannel.api);\napi.set(sameMajor.id, sameMajor.api);\napi.set(semver.id, semver.api);\napi.set(semverCoerced.id, semverCoerced.api);\napi.set(semverPartial.id, semverPartial.api);\napi.set(swift.id, swift.api);\napi.set(ubuntu.id, ubuntu.api);\napi.set(unity3d.id, unity3d.api);\napi.set(unity3dPackages.id, unity3dPackages.api);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwDA,MAAM,sBAAM,IAAI,IAAsD;AAGtE,IAAI,IAAI,OAAQA,KAAO;AACvB,IAAI,IAAIC,MAAgBC,KAAe;AACvC,IAAI,IAAIC,MAAuBC,KAAsB;AACrD,IAAI,IAAIC,MAAiBC,KAAgB;AACzC,IAAI,IAAIC,MAAgBC,KAAe;AACvC,IAAI,IAAIC,MAAUC,KAAS;AAC3B,IAAI,IAAIC,MAAaC,MAAY;AACjC,IAAI,IAAIC,MAAUC,MAAS;AAC3B,IAAI,IAAIC,OAAUC,MAAS;AAC3B,IAAI,IAAI,OAAQC,MAAO;AACvB,IAAI,IAAIC,OAAWC,MAAU;AAC7B,IAAI,IAAIC,OAASC,MAAQ;AACzB,IAAI,IAAIC,OAAWC,MAAU;AAC7B,IAAI,IAAIC,OAAWC,MAAU;AAC7B,IAAI,IAAI,OAAQC,MAAO;AACvB,IAAI,IAAIC,OAAUC,MAAS;AAC3B,IAAI,IAAI,OAAQC,MAAO;AACvB,IAAI,IAAIC,OAAkBC,MAAiB;AAC3C,IAAI,IAAIC,OAAcC,MAAa;AACnC,IAAI,IAAIC,OAAmBC,MAAkB;AAC7C,IAAI,IAAIC,OAAWC,MAAU;AAC7B,IAAI,IAAIC,OAAcC,MAAa;AACnC,IAAI,IAAIC,OAASC,MAAQ;AACzB,IAAI,IAAIC,OAAWC,MAAU;AAC7B,IAAI,IAAI,OAAQC,MAAO;AACvB,IAAI,IAAI,OAAQC,MAAO;AACvB,IAAI,IAAIC,OAAkBC,MAAiB;AAC3C,IAAI,IAAIC,OAAeC,MAAc;AACrC,IAAI,IAAIC,MAAUC,MAAS;AAC3B,IAAI,IAAIC,OAAUC,MAAS;AAC3B,IAAI,IAAIC,OAAYC,MAAW;AAC/B,IAAI,IAAIC,OAASC,MAAQ;AACzB,IAAI,IAAI,OAAQC,KAAO;AACvB,IAAI,IAAIC,OAAUC,MAAS;AAC3B,IAAI,IAAIC,OAAUC,MAAS;AAC3B,IAAI,IAAIC,OAAWC,MAAU;AAC7B,IAAI,IAAIC,OAASC,MAAQ;AACzB,IAAI,IAAIC,OAAWC,MAAU;AAC7B,IAAI,IAAI,OAAQC,MAAO;AACvB,IAAI,IAAIC,OAAWC,MAAU;AAC7B,IAAI,IAAIC,OAAWC,MAAU;AAC7B,IAAI,IAAIC,IAAUC,KAAS;AAC3B,IAAI,IAAI,OAAQC,MAAO;AACvB,IAAI,IAAI,OAAQC,MAAO;AACvB,IAAI,IAAIC,OAASC,MAAQ;AACzB,IAAI,IAAIC,OAAuBC,MAAsB;AACrD,IAAI,IAAIC,OAAcC,MAAa;AACnC,IAAI,IAAIC,MAAWC,KAAU;AAC7B,IAAI,IAAIC,OAAkBC,MAAiB;AAC3C,IAAI,IAAIC,OAAkBC,MAAiB;AAC3C,IAAI,IAAIC,OAAUC,MAAS;AAC3B,IAAI,IAAIC,OAAWC,MAAU;AAC7B,IAAI,IAAIC,OAAYC,MAAW;AAC/B,IAAI,IAAIC,OAAoBC,MAAmB"}

package/dist/modules/versioning/paket/index.js

@@ -0,0 +1,227 @@
+import { parseVersion } from "../nuget/parser.js";
+import { compare, sameReleaseParts } from "./version.js";
+import { adaptToPrecision, bumpAtPrecision, ensurePrereleaseMatches, intervalOf, isLessThanLowerBound, matches as matches$1, parseRange, rangeToString, releaseParts, twiddle } from "./range.js";
+//#region lib/modules/versioning/paket/index.ts
+const id = "paket";
+function isVersion(input) {
+	return !!input && parseVersion(input) !== null;
+}
+function isValid(input) {
+	return parseRange(input) !== null;
+}
+function isSingleVersionRange(range) {
+	if (range.constraints.length !== 1 || range.prereleaseTags.length > 0) return false;
+	const { operator } = range.constraints[0];
+	return operator === "" || operator === "=" || operator === "==";
+}
+function isSingleVersion(input) {
+	const range = parseRange(input);
+	return !!range && isSingleVersionRange(range);
+}
+function isStable(input) {
+	const version = parseVersion(input);
+	if (version) return !version.prerelease;
+	const range = parseRange(input);
+	return !!range && isSingleVersionRange(range) && !range.constraints[0].version.prerelease;
+}
+function isCompatible(version) {
+	return isVersion(version);
+}
+function getMajor(version) {
+	return parseVersion(version)?.major ?? null;
+}
+function getMinor(version) {
+	return parseVersion(version)?.minor ?? null;
+}
+function getPatch(version) {
+	return parseVersion(version)?.patch ?? null;
+}
+function compareVersions(version, other) {
+	const x = parseVersion(version);
+	const y = parseVersion(other);
+	return x && y ? compare(x, y) : null;
+}
+function equals(version, other) {
+	return compareVersions(version, other) === 0;
+}
+function isGreaterThan(version, other) {
+	const cmp = compareVersions(version, other);
+	return cmp !== null && cmp > 0;
+}
+function sortVersions(version, other) {
+	return compareVersions(version, other) ?? 0;
+}
+function matches(version, range) {
+	const v = parseVersion(version);
+	const r = parseRange(range);
+	return !!v && !!r && matches$1(v, r);
+}
+function isLessThanRange(version, range) {
+	const v = parseVersion(version);
+	const r = parseRange(range);
+	return !!v && !!r && isLessThanLowerBound(v, r);
+}
+function satisfyingVersions(versions, range) {
+	return versions.filter((v) => matches(v, range)).sort(sortVersions);
+}
+function getSatisfyingVersion(versions, range) {
+	return satisfyingVersions(versions, range).pop() ?? null;
+}
+function minSatisfyingVersion(versions, range) {
+	return satisfyingVersions(versions, range).shift() ?? null;
+}
+function getPinnedValue(newVersion) {
+	return newVersion;
+}
+function replaceConstraint(constraint, v) {
+	const { operator, version } = constraint;
+	switch (operator) {
+		case "":
+		case "=":
+		case "==": return {
+			operator,
+			version: v
+		};
+		case ">":
+		case ">=": return constraint;
+		case "<=": return compare(v, version) > 0 ? {
+			operator,
+			version: v
+		} : constraint;
+		case "<": return compare(v, version) >= 0 || sameReleaseParts(v, version) ? {
+			operator,
+			version: bumpAtPrecision(v, releaseParts(version).length)
+		} : constraint;
+		case "~>": {
+			const cap = twiddle(version);
+			return compare(v, cap) >= 0 || sameReleaseParts(v, cap) ? {
+				operator,
+				version: adaptToPrecision(v, releaseParts(version).length)
+			} : constraint;
+		}
+	}
+}
+/**
+* Rewrite `~> band` optionally followed by a `>=`/`>` floor: the band follows
+* the new version at its old precision, and the floor sticks to the exact new
+* version unless it becomes redundant.
+*/
+function pessimisticWithFloor(range, v) {
+	const [pessimistic] = range.constraints;
+	const band = adaptToPrecision(v, releaseParts(pessimistic.version).length);
+	const constraints = compare(band, v) === 0 ? [{
+		operator: "~>",
+		version: band
+	}] : [{
+		operator: "~>",
+		version: band
+	}, {
+		operator: ">=",
+		version: v
+	}];
+	return {
+		...range,
+		constraints
+	};
+}
+function replaceRange(range, v) {
+	const [first, second] = range.constraints;
+	if (first.operator === "~>" && (second?.operator === ">" || second?.operator === ">=")) return pessimisticWithFloor(range, v);
+	return {
+		...range,
+		constraints: range.constraints.map((c) => replaceConstraint(c, v))
+	};
+}
+function bumpConstraint(constraint, v) {
+	const { operator, version } = constraint;
+	switch (operator) {
+		case ">=": return compare(v, version) > 0 ? {
+			operator,
+			version: v
+		} : constraint;
+		case ">": return {
+			operator: ">=",
+			version: v
+		};
+		case "~>": {
+			const adapted = adaptToPrecision(v, releaseParts(version).length);
+			return compare(adapted, version) > 0 ? {
+				operator,
+				version: adapted
+			} : constraint;
+		}
+		default: return replaceConstraint(constraint, v);
+	}
+}
+function bumpRange(range, v) {
+	const [first, second] = range.constraints;
+	if (first.operator === "~>" && second?.operator !== "<" && second?.operator !== "<=") return pessimisticWithFloor(range, v);
+	return {
+		...range,
+		constraints: range.constraints.map((c) => bumpConstraint(c, v))
+	};
+}
+function widenRange(range, v) {
+	const interval = intervalOf(range.constraints);
+	const [first] = range.constraints;
+	if (interval.kind !== "range" || first.operator !== "~>") return {
+		...range,
+		constraints: range.constraints.map((c) => replaceConstraint(c, v))
+	};
+	const { from, fromInclusive, to, toInclusive } = interval;
+	if (!(toInclusive ? compare(v, to) > 0 : compare(v, to) >= 0 || sameReleaseParts(v, to))) return range;
+	const lower = {
+		operator: fromInclusive ? ">=" : ">",
+		version: from
+	};
+	const upper = toInclusive ? {
+		operator: "<=",
+		version: v
+	} : {
+		operator: "<",
+		version: bumpAtPrecision(v, releaseParts(to).length)
+	};
+	return {
+		...range,
+		constraints: [lower, upper]
+	};
+}
+function getNewValue({ currentValue, rangeStrategy, newVersion }) {
+	const v = parseVersion(newVersion);
+	if (!v) return null;
+	if (isVersion(currentValue)) return newVersion;
+	const range = parseRange(currentValue);
+	if (!range) return null;
+	if (rangeStrategy === "pin") return `${range.strategy ?? ""}${newVersion}`;
+	if (isLessThanLowerBound(v, range)) return currentValue;
+	let result;
+	if (rangeStrategy === "bump") result = bumpRange(range, v);
+	else if (matches$1(v, range)) return currentValue;
+	else if (rangeStrategy === "widen") result = widenRange(range, v);
+	else result = replaceRange(range, v);
+	const newValue = rangeToString(ensurePrereleaseMatches(result, v));
+	return newValue === rangeToString(range) ? currentValue : newValue;
+}
+const api = {
+	equals,
+	getMajor,
+	getMinor,
+	getPatch,
+	getNewValue,
+	getPinnedValue,
+	getSatisfyingVersion,
+	minSatisfyingVersion,
+	isCompatible,
+	isGreaterThan,
+	isLessThanRange,
+	isSingleVersion,
+	isStable,
+	isValid,
+	isVersion,
+	matches,
+	sortVersions
+};
+//#endregion
+export { api as default, id };
+
+//# sourceMappingURL=index.js.map

package/dist/modules/versioning/paket/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["matchesRange"],"sources":["../../../../lib/modules/versioning/paket/index.ts"],"sourcesContent":["import type { RangeStrategy } from '../../../types/versioning.ts';\nimport { parseVersion } from '../nuget/parser.ts';\nimport type { NugetVersion } from '../nuget/types.ts';\nimport type { NewValueConfig, VersioningApi } from '../types.ts';\nimport type { PaketConstraint, PaketRange } from './range.ts';\nimport {\n  adaptToPrecision,\n  bumpAtPrecision,\n  ensurePrereleaseMatches,\n  intervalOf,\n  isLessThanLowerBound,\n  matches as matchesRange,\n  parseRange,\n  rangeToString,\n  releaseParts,\n  twiddle,\n} from './range.ts';\nimport { compare, sameReleaseParts } from './version.ts';\n\nexport const id = 'paket';\nexport const displayName = 'Paket';\nexport const urls = [\n  '[Paket version constraints](https://fsprojects.github.io/Paket/nuget-dependencies.html#Version-constraints)',\n  '[NuGet package versioning](https://learn.microsoft.com/nuget/concepts/package-versioning)',\n];\nexport const supportsRanges = true;\nexport const supportedRangeStrategies: RangeStrategy[] = [\n  'bump',\n  'widen',\n  'replace',\n  'update-lockfile',\n];\n\nfunction isVersion(input: string | undefined | null): boolean {\n  return !!input && parseVersion(input) !== null;\n}\n\nfunction isValid(input: string): boolean {\n  return parseRange(input) !== null;\n}\n\nfunction isSingleVersionRange(range: PaketRange): boolean {\n  if (range.constraints.length !== 1 || range.prereleaseTags.length > 0) {\n    return false;\n  }\n\n  const { operator } = range.constraints[0];\n  return operator === '' || operator === '=' || operator === '==';\n}\n\nfunction isSingleVersion(input: string): boolean {\n  const range = parseRange(input);\n  return !!range && isSingleVersionRange(range);\n}\n\nfunction isStable(input: string): boolean {\n  const version = parseVersion(input);\n  if (version) {\n    return !version.prerelease;\n  }\n\n  const range = parseRange(input);\n  return (\n    !!range &&\n    isSingleVersionRange(range) &&\n    !range.constraints[0].version.prerelease\n  );\n}\n\nfunction isCompatible(version: string): boolean {\n  return isVersion(version);\n}\n\nfunction getMajor(version: string): number | null {\n  return parseVersion(version)?.major ?? null;\n}\n\nfunction getMinor(version: string): number | null {\n  return parseVersion(version)?.minor ?? null;\n}\n\nfunction getPatch(version: string): number | null {\n  return parseVersion(version)?.patch ?? null;\n}\n\nfunction compareVersions(version: string, other: string): number | null {\n  const x = parseVersion(version);\n  const y = parseVersion(other);\n  return x && y ? compare(x, y) : null;\n}\n\nfunction equals(version: string, other: string): boolean {\n  return compareVersions(version, other) === 0;\n}\n\nfunction isGreaterThan(version: string, other: string): boolean {\n  const cmp = compareVersions(version, other);\n  return cmp !== null && cmp > 0;\n}\n\nfunction sortVersions(version: string, other: string): number {\n  return compareVersions(version, other) ?? 0;\n}\n\nfunction matches(version: string, range: string): boolean {\n  const v = parseVersion(version);\n  const r = parseRange(range);\n  return !!v && !!r && matchesRange(v, r);\n}\n\nfunction isLessThanRange(version: string, range: string): boolean {\n  const v = parseVersion(version);\n  const r = parseRange(range);\n  return !!v && !!r && isLessThanLowerBound(v, r);\n}\n\nfunction satisfyingVersions(versions: string[], range: string): string[] {\n  return versions.filter((v) => matches(v, range)).sort(sortVersions);\n}\n\nfunction getSatisfyingVersion(\n  versions: string[],\n  range: string,\n): string | null {\n  return satisfyingVersions(versions, range).pop() ?? null;\n}\n\nfunction minSatisfyingVersion(\n  versions: string[],\n  range: string,\n): string | null {\n  return satisfyingVersions(versions, range).shift() ?? null;\n}\n\nfunction getPinnedValue(newVersion: string): string {\n  return newVersion;\n}\n\nfunction replaceConstraint(\n  constraint: PaketConstraint,\n  v: NugetVersion,\n): PaketConstraint {\n  const { operator, version } = constraint;\n  switch (operator) {\n    case '':\n    case '=':\n    case '==':\n      return { operator, version: v };\n    case '>':\n    case '>=':\n      return constraint;\n    case '<=':\n      return compare(v, version) > 0 ? { operator, version: v } : constraint;\n    case '<':\n      return compare(v, version) >= 0 || sameReleaseParts(v, version)\n        ? {\n            operator,\n            version: bumpAtPrecision(v, releaseParts(version).length),\n          }\n        : constraint;\n    case '~>': {\n      const cap = twiddle(version);\n      return compare(v, cap) >= 0 || sameReleaseParts(v, cap)\n        ? {\n            operator,\n            version: adaptToPrecision(v, releaseParts(version).length),\n          }\n        : constraint;\n    }\n  }\n}\n\n/**\n * Rewrite `~> band` optionally followed by a `>=`/`>` floor: the band follows\n * the new version at its old precision, and the floor sticks to the exact new\n * version unless it becomes redundant.\n */\nfunction pessimisticWithFloor(range: PaketRange, v: NugetVersion): PaketRange {\n  const [pessimistic] = range.constraints;\n  const band = adaptToPrecision(v, releaseParts(pessimistic.version).length);\n  const constraints: PaketConstraint[] =\n    compare(band, v) === 0\n      ? [{ operator: '~>', version: band }]\n      : [\n          { operator: '~>', version: band },\n          { operator: '>=', version: v },\n        ];\n  return { ...range, constraints };\n}\n\nfunction replaceRange(range: PaketRange, v: NugetVersion): PaketRange {\n  const [first, second] = range.constraints;\n  if (\n    first.operator === '~>' &&\n    (second?.operator === '>' || second?.operator === '>=')\n  ) {\n    return pessimisticWithFloor(range, v);\n  }\n\n  return {\n    ...range,\n    constraints: range.constraints.map((c) => replaceConstraint(c, v)),\n  };\n}\n\nfunction bumpConstraint(\n  constraint: PaketConstraint,\n  v: NugetVersion,\n): PaketConstraint {\n  const { operator, version } = constraint;\n  switch (operator) {\n    case '>=':\n      return compare(v, version) > 0 ? { operator, version: v } : constraint;\n    case '>':\n      // the lower bound guard in `getNewValue` ensures `v` is above `version`\n      return { operator: '>=', version: v };\n    case '~>': {\n      const adapted = adaptToPrecision(v, releaseParts(version).length);\n      return compare(adapted, version) > 0\n        ? { operator, version: adapted }\n        : constraint;\n    }\n    default:\n      return replaceConstraint(constraint, v);\n  }\n}\n\nfunction bumpRange(range: PaketRange, v: NugetVersion): PaketRange {\n  const [first, second] = range.constraints;\n  if (\n    first.operator === '~>' &&\n    second?.operator !== '<' &&\n    second?.operator !== '<='\n  ) {\n    return pessimisticWithFloor(range, v);\n  }\n\n  return {\n    ...range,\n    constraints: range.constraints.map((c) => bumpConstraint(c, v)),\n  };\n}\n\nfunction widenRange(range: PaketRange, v: NugetVersion): PaketRange {\n  const interval = intervalOf(range.constraints);\n  const [first] = range.constraints;\n\n  if (interval.kind !== 'range' || first.operator !== '~>') {\n    return {\n      ...range,\n      constraints: range.constraints.map((c) => replaceConstraint(c, v)),\n    };\n  }\n\n  const { from, fromInclusive, to, toInclusive } = interval;\n  const upperViolated = toInclusive\n    ? compare(v, to) > 0\n    : compare(v, to) >= 0 || sameReleaseParts(v, to);\n  if (!upperViolated) {\n    return range;\n  }\n\n  // The pessimistic operator acts as both bounds, so decompose it into\n  // explicit bounds to widen upwards while keeping the lower bound.\n  const lower: PaketConstraint = {\n    operator: fromInclusive ? '>=' : '>',\n    version: from,\n  };\n  const upper: PaketConstraint = toInclusive\n    ? { operator: '<=', version: v }\n    : { operator: '<', version: bumpAtPrecision(v, releaseParts(to).length) };\n  return { ...range, constraints: [lower, upper] };\n}\n\nfunction getNewValue({\n  currentValue,\n  rangeStrategy,\n  newVersion,\n}: NewValueConfig): string | null {\n  const v = parseVersion(newVersion);\n  if (!v) {\n    return null;\n  }\n\n  if (isVersion(currentValue)) {\n    return newVersion;\n  }\n\n  const range = parseRange(currentValue);\n  if (!range) {\n    return null;\n  }\n\n  if (rangeStrategy === 'pin') {\n    return `${range.strategy ?? ''}${newVersion}`;\n  }\n\n  if (isLessThanLowerBound(v, range)) {\n    return currentValue;\n  }\n\n  let result: PaketRange;\n  if (rangeStrategy === 'bump') {\n    result = bumpRange(range, v);\n  } else if (matchesRange(v, range)) {\n    return currentValue;\n  } else if (rangeStrategy === 'widen') {\n    result = widenRange(range, v);\n  } else {\n    result = replaceRange(range, v);\n  }\n\n  const newValue = rangeToString(ensurePrereleaseMatches(result, v));\n  return newValue === rangeToString(range) ? currentValue : newValue;\n}\n\nexport const api: VersioningApi = {\n  equals,\n  getMajor,\n  getMinor,\n  getPatch,\n  getNewValue,\n  getPinnedValue,\n  getSatisfyingVersion,\n  minSatisfyingVersion,\n  isCompatible,\n  isGreaterThan,\n  isLessThanRange,\n  isSingleVersion,\n  isStable,\n  isValid,\n  isVersion,\n  matches,\n  sortVersions,\n};\n\nexport default api;\n"],"mappings":"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"}

package/dist/modules/versioning/paket/range.js

@@ -0,0 +1,268 @@
+import { regEx } from "../../../util/regex.js";
+import { isNotNullOrUndefined } from "../../../util/array.js";
+import { parseVersion } from "../nuget/parser.js";
+import { versionToString } from "../nuget/version.js";
+import { compare, sameReleaseParts } from "./version.js";
+//#region lib/modules/versioning/paket/range.ts
+const constraintOperators = [
+	"=",
+	"==",
+	">",
+	">=",
+	"<",
+	"<=",
+	"~>"
+];
+const prereleaseTagRegex = regEx(/^[a-zA-Z][a-zA-Z0-9-]*$/);
+/**
+* Paket only accepts these operator combinations for two-part constraints.
+*/
+function isValidPair(first, second) {
+	if (first === "~>") return second === ">" || second === ">=" || second === "<" || second === "<=";
+	if (first === ">" || first === ">=") return second === "<" || second === "<=";
+	return false;
+}
+function parseRange(input) {
+	if (!input?.trim()) return null;
+	let text = input.trim();
+	let strategy = null;
+	if (text.startsWith("!") || text.startsWith("@")) {
+		strategy = text[0];
+		text = text.slice(1).trim();
+	}
+	const tokens = text.split(regEx(/\s+/));
+	const constraints = [];
+	let idx = 0;
+	while (idx < tokens.length && constraints.length < 2 && constraintOperators.includes(tokens[idx])) {
+		const operator = tokens[idx];
+		const versionToken = tokens[idx + 1];
+		const version = versionToken ? parseVersion(versionToken) : null;
+		if (!version) return null;
+		constraints.push({
+			operator,
+			version
+		});
+		idx += 2;
+	}
+	if (constraints.length === 0) {
+		const version = parseVersion(tokens[0]);
+		if (!version) return null;
+		constraints.push({
+			operator: "",
+			version
+		});
+		idx = 1;
+	}
+	if (constraints.length === 2 && !isValidPair(constraints[0].operator, constraints[1].operator)) return null;
+	const prereleaseTags = [];
+	for (const token of tokens.slice(idx)) {
+		if (!prereleaseTagRegex.test(token)) return null;
+		if (!prereleaseTags.includes(token)) prereleaseTags.push(token);
+	}
+	return {
+		strategy,
+		constraints,
+		prereleaseTags
+	};
+}
+function rangeToString(range) {
+	const parts = [];
+	for (const { operator, version } of range.constraints) {
+		const versionStr = versionToString(version);
+		parts.push(operator === "" ? versionStr : `${operator} ${versionStr}`);
+	}
+	parts.push(...range.prereleaseTags);
+	return `${range.strategy ?? ""}${parts.join(" ")}`;
+}
+function releaseParts(version) {
+	const { major, minor, patch, revision } = version;
+	return [
+		major,
+		minor,
+		patch,
+		revision
+	].filter(isNotNullOrUndefined);
+}
+function versionFromParts(parts) {
+	const [major, minor, patch, revision] = parts;
+	const result = {
+		type: "nuget-version",
+		major
+	};
+	if (minor !== void 0) result.minor = minor;
+	if (patch !== void 0) result.patch = patch;
+	if (revision !== void 0) result.revision = revision;
+	return result;
+}
+function adaptToPrecision(version, precision) {
+	const parts = releaseParts(version).slice(0, precision);
+	while (parts.length < precision) parts.push(0);
+	return versionFromParts(parts);
+}
+function bumpAtPrecision(version, precision) {
+	const parts = releaseParts(adaptToPrecision(version, precision));
+	parts[precision - 1] += 1;
+	return versionFromParts(parts);
+}
+/**
+* Upper bound of the pessimistic operator: chop off the last release part and
+* increment the remaining last number, so `~> 1.2.3` allows `< 1.3` and
+* `~> 1.2` allows `< 2`.
+*/
+function twiddle(version) {
+	return bumpAtPrecision(version, Math.max(releaseParts(version).length - 1, 1));
+}
+function intervalOfPair(first, second) {
+	if (first.operator === "~>") {
+		const cap = twiddle(first.version);
+		if (second.operator === ">" || second.operator === ">=") return {
+			kind: "range",
+			from: second.version,
+			fromInclusive: second.operator === ">=",
+			to: cap,
+			toInclusive: false
+		};
+		const to = compare(second.version, cap) < 0 ? second.version : cap;
+		return {
+			kind: "range",
+			from: first.version,
+			fromInclusive: true,
+			to,
+			toInclusive: second.operator === "<="
+		};
+	}
+	return {
+		kind: "range",
+		from: first.version,
+		fromInclusive: first.operator === ">=",
+		to: second.version,
+		toInclusive: second.operator === "<="
+	};
+}
+const singleOperatorKind = {
+	"": "specific",
+	"=": "specific",
+	"==": "override",
+	">=": "minimum",
+	">": "greater-than",
+	"<=": "maximum",
+	"<": "less-than"
+};
+function intervalOf(constraints) {
+	if (constraints.length === 2) return intervalOfPair(constraints[0], constraints[1]);
+	const [{ operator, version }] = constraints;
+	if (operator === "~>") return {
+		kind: "range",
+		from: version,
+		fromInclusive: true,
+		to: twiddle(version),
+		toInclusive: false
+	};
+	return {
+		kind: singleOperatorKind[operator],
+		version
+	};
+}
+const numericSegmentRegex = regEx(/^\d+$/);
+const channelPrefixRegex = regEx(/^[a-zA-Z]+(?:-[a-zA-Z]+)*/);
+function channelFromSegments(segments) {
+	const [first, second] = segments;
+	if (first && !numericSegmentRegex.test(first)) return first;
+	if (second && !numericSegmentRegex.test(second)) return second;
+	return "";
+}
+/**
+* The channel name of a prerelease suffix, e.g. `alpha` for `alpha001` or
+* `beta` for `beta.2`.
+*/
+function prereleaseChannel(prerelease) {
+	const segments = prerelease.split(".");
+	if (segments.length > 1) return channelFromSegments(segments);
+	const prefix = channelPrefixRegex.exec(prerelease);
+	if (prefix) return prefix[0];
+	return channelFromSegments(prerelease.split("-").filter((segment) => segment !== ""));
+}
+function prereleaseStatusOf(range, interval) {
+	const { prereleaseTags } = range;
+	if (prereleaseTags.length === 1 && prereleaseTags[0].toLowerCase() === "prerelease") return "all";
+	if (prereleaseTags.length > 0) return prereleaseTags;
+	const bounds = interval.kind === "range" ? [interval.from, interval.to] : [interval.version];
+	const channels = [];
+	for (const bound of bounds) {
+		if (!bound.prerelease) continue;
+		const channel = prereleaseChannel(bound.prerelease);
+		if (!channels.includes(channel)) channels.push(channel);
+	}
+	return channels.length > 0 ? channels : "none";
+}
+function isPrereleaseAllowed(version, status) {
+	if (status === "all") return true;
+	if (status === "none") return !version.prerelease;
+	if (!version.prerelease) return true;
+	return status.includes(prereleaseChannel(version.prerelease));
+}
+/**
+* Paket rule: a prerelease of a stable bound version counts as being in range
+* when its channel is allowed, e.g. `1.2.3-alpha1` satisfies `= 1.2.3 alpha`.
+*/
+function isPrereleaseOfBound(version, bound, status) {
+	return status !== "none" && !bound.prerelease && sameReleaseParts(version, bound) && isPrereleaseAllowed(version, status);
+}
+function matches(version, range) {
+	const interval = intervalOf(range.constraints);
+	const status = prereleaseStatusOf(range, interval);
+	switch (interval.kind) {
+		case "specific": return compare(version, interval.version) === 0 || isPrereleaseOfBound(version, interval.version, status);
+		case "override": return compare(version, interval.version) === 0;
+		case "minimum": {
+			const cmp = compare(version, interval.version);
+			return cmp === 0 || cmp > 0 && isPrereleaseAllowed(version, status) || isPrereleaseOfBound(version, interval.version, status);
+		}
+		case "greater-than": return compare(version, interval.version) > 0 && isPrereleaseAllowed(version, status);
+		case "maximum": {
+			const cmp = compare(version, interval.version);
+			return cmp === 0 || cmp < 0 && isPrereleaseAllowed(version, status);
+		}
+		case "less-than": return compare(version, interval.version) < 0 && isPrereleaseAllowed(version, status) && !isPrereleaseOfBound(version, interval.version, status);
+		case "range": {
+			const { from, fromInclusive, to, toInclusive } = interval;
+			const lowerCmp = compare(version, from);
+			const upperCmp = compare(version, to);
+			const inLower = fromInclusive ? lowerCmp >= 0 : lowerCmp > 0;
+			const inUpper = toInclusive ? upperCmp <= 0 : upperCmp < 0 && !isPrereleaseOfBound(version, to, status);
+			return inLower && inUpper && isPrereleaseAllowed(version, status) || isPrereleaseOfBound(version, from, status);
+		}
+	}
+}
+function isLessThanLowerBound(version, range) {
+	const interval = intervalOf(range.constraints);
+	switch (interval.kind) {
+		case "specific":
+		case "override":
+		case "minimum": return compare(version, interval.version) < 0;
+		case "greater-than": return compare(version, interval.version) <= 0;
+		case "maximum":
+		case "less-than": return false;
+		case "range": return interval.fromInclusive ? compare(version, interval.from) < 0 : compare(version, interval.from) <= 0;
+	}
+}
+/**
+* A rewritten range admits the new version numerically, but its prerelease
+* channel may still be blocked, so allow the channel with an explicit tag.
+*/
+function ensurePrereleaseMatches(range, version) {
+	if (!version.prerelease || matches(version, range)) return range;
+	const channel = prereleaseChannel(version.prerelease);
+	if (prereleaseTagRegex.test(channel)) return {
+		...range,
+		prereleaseTags: [...range.prereleaseTags, channel]
+	};
+	return {
+		...range,
+		prereleaseTags: ["prerelease"]
+	};
+}
+//#endregion
+export { adaptToPrecision, bumpAtPrecision, ensurePrereleaseMatches, intervalOf, isLessThanLowerBound, matches, parseRange, rangeToString, releaseParts, twiddle };
+
+//# sourceMappingURL=range.js.map

package/dist/modules/versioning/paket/range.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"range.js","names":[],"sources":["../../../../lib/modules/versioning/paket/range.ts"],"sourcesContent":["import { isNotNullOrUndefined } from '../../../util/array.ts';\nimport { regEx } from '../../../util/regex.ts';\nimport { parseVersion } from '../nuget/parser.ts';\nimport type { NugetVersion } from '../nuget/types.ts';\nimport { versionToString } from '../nuget/version.ts';\nimport { compare, sameReleaseParts } from './version.ts';\n\nexport type PaketOperator = '' | '=' | '==' | '>' | '>=' | '<' | '<=' | '~>';\n\nexport interface PaketConstraint {\n  operator: PaketOperator;\n  version: NugetVersion;\n}\n\nexport interface PaketRange {\n  strategy: '!' | '@' | null;\n  constraints: PaketConstraint[];\n  prereleaseTags: string[];\n}\n\nconst constraintOperators: readonly string[] = [\n  '=',\n  '==',\n  '>',\n  '>=',\n  '<',\n  '<=',\n  '~>',\n];\n\nconst prereleaseTagRegex = regEx(/^[a-zA-Z][a-zA-Z0-9-]*$/);\n\n/**\n * Paket only accepts these operator combinations for two-part constraints.\n */\nfunction isValidPair(first: PaketOperator, second: PaketOperator): boolean {\n  if (first === '~>') {\n    return (\n      second === '>' || second === '>=' || second === '<' || second === '<='\n    );\n  }\n\n  if (first === '>' || first === '>=') {\n    return second === '<' || second === '<=';\n  }\n\n  return false;\n}\n\nexport function parseRange(input: string): PaketRange | null {\n  if (!input?.trim()) {\n    return null;\n  }\n\n  let text = input.trim();\n  let strategy: PaketRange['strategy'] = null;\n  if (text.startsWith('!') || text.startsWith('@')) {\n    strategy = text[0] as '!' | '@';\n    text = text.slice(1).trim();\n  }\n\n  const tokens = text.split(regEx(/\\s+/));\n  const constraints: PaketConstraint[] = [];\n  let idx = 0;\n\n  while (\n    idx < tokens.length &&\n    constraints.length < 2 &&\n    constraintOperators.includes(tokens[idx])\n  ) {\n    const operator = tokens[idx] as PaketOperator;\n    const versionToken = tokens[idx + 1];\n    const version = versionToken ? parseVersion(versionToken) : null;\n    if (!version) {\n      return null;\n    }\n    constraints.push({ operator, version });\n    idx += 2;\n  }\n\n  if (constraints.length === 0) {\n    const version = parseVersion(tokens[0]);\n    if (!version) {\n      return null;\n    }\n    constraints.push({ operator: '', version });\n    idx = 1;\n  }\n\n  if (\n    constraints.length === 2 &&\n    !isValidPair(constraints[0].operator, constraints[1].operator)\n  ) {\n    return null;\n  }\n\n  const prereleaseTags: string[] = [];\n  for (const token of tokens.slice(idx)) {\n    if (!prereleaseTagRegex.test(token)) {\n      return null;\n    }\n    if (!prereleaseTags.includes(token)) {\n      prereleaseTags.push(token);\n    }\n  }\n\n  return { strategy, constraints, prereleaseTags };\n}\n\nexport function rangeToString(range: PaketRange): string {\n  const parts: string[] = [];\n  for (const { operator, version } of range.constraints) {\n    const versionStr = versionToString(version);\n    parts.push(operator === '' ? versionStr : `${operator} ${versionStr}`);\n  }\n  parts.push(...range.prereleaseTags);\n  return `${range.strategy ?? ''}${parts.join(' ')}`;\n}\n\nexport function releaseParts(version: NugetVersion): number[] {\n  const { major, minor, patch, revision } = version;\n  return [major, minor, patch, revision].filter(isNotNullOrUndefined);\n}\n\nfunction versionFromParts(parts: number[]): NugetVersion {\n  const [major, minor, patch, revision] = parts;\n  const result: NugetVersion = { type: 'nuget-version', major };\n  if (minor !== undefined) {\n    result.minor = minor;\n  }\n  if (patch !== undefined) {\n    result.patch = patch;\n  }\n  if (revision !== undefined) {\n    result.revision = revision;\n  }\n  return result;\n}\n\nexport function adaptToPrecision(\n  version: NugetVersion,\n  precision: number,\n): NugetVersion {\n  const parts = releaseParts(version).slice(0, precision);\n  while (parts.length < precision) {\n    parts.push(0);\n  }\n  return versionFromParts(parts);\n}\n\nexport function bumpAtPrecision(\n  version: NugetVersion,\n  precision: number,\n): NugetVersion {\n  const parts = releaseParts(adaptToPrecision(version, precision));\n  parts[precision - 1] += 1;\n  return versionFromParts(parts);\n}\n\n/**\n * Upper bound of the pessimistic operator: chop off the last release part and\n * increment the remaining last number, so `~> 1.2.3` allows `< 1.3` and\n * `~> 1.2` allows `< 2`.\n */\nexport function twiddle(version: NugetVersion): NugetVersion {\n  const precision = Math.max(releaseParts(version).length - 1, 1);\n  return bumpAtPrecision(version, precision);\n}\n\nexport type PaketInterval =\n  | {\n      kind:\n        | 'specific'\n        | 'override'\n        | 'minimum'\n        | 'greater-than'\n        | 'maximum'\n        | 'less-than';\n      version: NugetVersion;\n    }\n  | {\n      kind: 'range';\n      from: NugetVersion;\n      fromInclusive: boolean;\n      to: NugetVersion;\n      toInclusive: boolean;\n    };\n\nfunction intervalOfPair(\n  first: PaketConstraint,\n  second: PaketConstraint,\n): PaketInterval {\n  if (first.operator === '~>') {\n    const cap = twiddle(first.version);\n\n    if (second.operator === '>' || second.operator === '>=') {\n      return {\n        kind: 'range',\n        from: second.version,\n        fromInclusive: second.operator === '>=',\n        to: cap,\n        toInclusive: false,\n      };\n    }\n\n    const to = compare(second.version, cap) < 0 ? second.version : cap;\n    return {\n      kind: 'range',\n      from: first.version,\n      fromInclusive: true,\n      to,\n      toInclusive: second.operator === '<=',\n    };\n  }\n\n  return {\n    kind: 'range',\n    from: first.version,\n    fromInclusive: first.operator === '>=',\n    to: second.version,\n    toInclusive: second.operator === '<=',\n  };\n}\n\nconst singleOperatorKind = {\n  '': 'specific',\n  '=': 'specific',\n  '==': 'override',\n  '>=': 'minimum',\n  '>': 'greater-than',\n  '<=': 'maximum',\n  '<': 'less-than',\n} as const;\n\nexport function intervalOf(constraints: PaketConstraint[]): PaketInterval {\n  if (constraints.length === 2) {\n    return intervalOfPair(constraints[0], constraints[1]);\n  }\n\n  const [{ operator, version }] = constraints;\n  if (operator === '~>') {\n    return {\n      kind: 'range',\n      from: version,\n      fromInclusive: true,\n      to: twiddle(version),\n      toInclusive: false,\n    };\n  }\n  return { kind: singleOperatorKind[operator], version };\n}\n\nconst numericSegmentRegex = regEx(/^\\d+$/);\nconst channelPrefixRegex = regEx(/^[a-zA-Z]+(?:-[a-zA-Z]+)*/);\n\nfunction channelFromSegments(segments: string[]): string {\n  const [first, second] = segments;\n  if (first && !numericSegmentRegex.test(first)) {\n    return first;\n  }\n  if (second && !numericSegmentRegex.test(second)) {\n    return second;\n  }\n  return '';\n}\n\n/**\n * The channel name of a prerelease suffix, e.g. `alpha` for `alpha001` or\n * `beta` for `beta.2`.\n */\nexport function prereleaseChannel(prerelease: string): string {\n  const segments = prerelease.split('.');\n  if (segments.length > 1) {\n    return channelFromSegments(segments);\n  }\n\n  const prefix = channelPrefixRegex.exec(prerelease);\n  if (prefix) {\n    return prefix[0];\n  }\n\n  return channelFromSegments(\n    prerelease.split('-').filter((segment) => segment !== ''),\n  );\n}\n\ntype PrereleaseStatus = 'none' | 'all' | string[];\n\nfunction prereleaseStatusOf(\n  range: PaketRange,\n  interval: PaketInterval,\n): PrereleaseStatus {\n  const { prereleaseTags } = range;\n  if (\n    prereleaseTags.length === 1 &&\n    prereleaseTags[0].toLowerCase() === 'prerelease'\n  ) {\n    return 'all';\n  }\n  if (prereleaseTags.length > 0) {\n    return prereleaseTags;\n  }\n\n  // Without explicit tags, prerelease versions used in the constraint itself\n  // allow their own channels, e.g. `~> 1.2.3-alpha001` allows `alpha` versions.\n  const bounds =\n    interval.kind === 'range'\n      ? [interval.from, interval.to]\n      : [interval.version];\n  const channels: string[] = [];\n  for (const bound of bounds) {\n    if (!bound.prerelease) {\n      continue;\n    }\n    const channel = prereleaseChannel(bound.prerelease);\n    if (!channels.includes(channel)) {\n      channels.push(channel);\n    }\n  }\n  return channels.length > 0 ? channels : 'none';\n}\n\nfunction isPrereleaseAllowed(\n  version: NugetVersion,\n  status: PrereleaseStatus,\n): boolean {\n  if (status === 'all') {\n    return true;\n  }\n  if (status === 'none') {\n    return !version.prerelease;\n  }\n  if (!version.prerelease) {\n    return true;\n  }\n  return status.includes(prereleaseChannel(version.prerelease));\n}\n\n/**\n * Paket rule: a prerelease of a stable bound version counts as being in range\n * when its channel is allowed, e.g. `1.2.3-alpha1` satisfies `= 1.2.3 alpha`.\n */\nfunction isPrereleaseOfBound(\n  version: NugetVersion,\n  bound: NugetVersion,\n  status: PrereleaseStatus,\n): boolean {\n  return (\n    status !== 'none' &&\n    !bound.prerelease &&\n    sameReleaseParts(version, bound) &&\n    isPrereleaseAllowed(version, status)\n  );\n}\n\nexport function matches(version: NugetVersion, range: PaketRange): boolean {\n  const interval = intervalOf(range.constraints);\n  const status = prereleaseStatusOf(range, interval);\n\n  switch (interval.kind) {\n    case 'specific':\n      return (\n        compare(version, interval.version) === 0 ||\n        isPrereleaseOfBound(version, interval.version, status)\n      );\n    case 'override':\n      return compare(version, interval.version) === 0;\n    case 'minimum': {\n      const cmp = compare(version, interval.version);\n      return (\n        cmp === 0 ||\n        (cmp > 0 && isPrereleaseAllowed(version, status)) ||\n        isPrereleaseOfBound(version, interval.version, status)\n      );\n    }\n    case 'greater-than':\n      return (\n        compare(version, interval.version) > 0 &&\n        isPrereleaseAllowed(version, status)\n      );\n    case 'maximum': {\n      const cmp = compare(version, interval.version);\n      return cmp === 0 || (cmp < 0 && isPrereleaseAllowed(version, status));\n    }\n    case 'less-than':\n      return (\n        compare(version, interval.version) < 0 &&\n        isPrereleaseAllowed(version, status) &&\n        !isPrereleaseOfBound(version, interval.version, status)\n      );\n    case 'range': {\n      const { from, fromInclusive, to, toInclusive } = interval;\n      const lowerCmp = compare(version, from);\n      const upperCmp = compare(version, to);\n      const inLower = fromInclusive ? lowerCmp >= 0 : lowerCmp > 0;\n      const inUpper = toInclusive\n        ? upperCmp <= 0\n        : upperCmp < 0 && !isPrereleaseOfBound(version, to, status);\n      return (\n        (inLower && inUpper && isPrereleaseAllowed(version, status)) ||\n        isPrereleaseOfBound(version, from, status)\n      );\n    }\n  }\n}\n\nexport function isLessThanLowerBound(\n  version: NugetVersion,\n  range: PaketRange,\n): boolean {\n  const interval = intervalOf(range.constraints);\n  switch (interval.kind) {\n    case 'specific':\n    case 'override':\n    case 'minimum':\n      return compare(version, interval.version) < 0;\n    case 'greater-than':\n      return compare(version, interval.version) <= 0;\n    case 'maximum':\n    case 'less-than':\n      return false;\n    case 'range':\n      return interval.fromInclusive\n        ? compare(version, interval.from) < 0\n        : compare(version, interval.from) <= 0;\n  }\n}\n\n/**\n * A rewritten range admits the new version numerically, but its prerelease\n * channel may still be blocked, so allow the channel with an explicit tag.\n */\nexport function ensurePrereleaseMatches(\n  range: PaketRange,\n  version: NugetVersion,\n): PaketRange {\n  if (!version.prerelease || matches(version, range)) {\n    return range;\n  }\n\n  const channel = prereleaseChannel(version.prerelease);\n  if (prereleaseTagRegex.test(channel)) {\n    return { ...range, prereleaseTags: [...range.prereleaseTags, channel] };\n  }\n  return { ...range, prereleaseTags: ['prerelease'] };\n}\n"],"mappings":"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"}

package/dist/modules/versioning/paket/version.js

@@ -0,0 +1,21 @@
+import { compare as compare$1 } from "../nuget/version.js";
+//#region lib/modules/versioning/paket/version.ts
+function sameReleaseParts(x, y) {
+	return x.major === y.major && (x.minor ?? 0) === (y.minor ?? 0) && (x.patch ?? 0) === (y.patch ?? 0) && (x.revision ?? 0) === (y.revision ?? 0);
+}
+/**
+* NuGet ordering, plus the Paket rule that the literal `prerelease` suffix
+* sorts below any other prerelease of the same release version, so that
+* `1.2.3-prerelease` acts as an "any prerelease of 1.2.3" floor.
+*/
+function compare(x, y) {
+	if (x.prerelease && y.prerelease && sameReleaseParts(x, y)) {
+		const xSentinel = x.prerelease === "prerelease";
+		if (xSentinel !== (y.prerelease === "prerelease")) return xSentinel ? -1 : 1;
+	}
+	return compare$1(x, y);
+}
+//#endregion
+export { compare, sameReleaseParts };
+
+//# sourceMappingURL=version.js.map

package/dist/modules/versioning/paket/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","names":["compareNuget"],"sources":["../../../../lib/modules/versioning/paket/version.ts"],"sourcesContent":["import type { NugetVersion } from '../nuget/types.ts';\nimport { compare as compareNuget } from '../nuget/version.ts';\n\nexport function sameReleaseParts(x: NugetVersion, y: NugetVersion): boolean {\n  return (\n    x.major === y.major &&\n    (x.minor ?? 0) === (y.minor ?? 0) &&\n    (x.patch ?? 0) === (y.patch ?? 0) &&\n    (x.revision ?? 0) === (y.revision ?? 0)\n  );\n}\n\n/**\n * NuGet ordering, plus the Paket rule that the literal `prerelease` suffix\n * sorts below any other prerelease of the same release version, so that\n * `1.2.3-prerelease` acts as an \"any prerelease of 1.2.3\" floor.\n */\nexport function compare(x: NugetVersion, y: NugetVersion): number {\n  if (x.prerelease && y.prerelease && sameReleaseParts(x, y)) {\n    const xSentinel = x.prerelease === 'prerelease';\n    const ySentinel = y.prerelease === 'prerelease';\n    if (xSentinel !== ySentinel) {\n      return xSentinel ? -1 : 1;\n    }\n  }\n  return compareNuget(x, y);\n}\n"],"mappings":";;AAGA,SAAgB,iBAAiB,GAAiB,GAA0B;CAC1E,OACE,EAAE,UAAU,EAAE,UACb,EAAE,SAAS,QAAQ,EAAE,SAAS,OAC9B,EAAE,SAAS,QAAQ,EAAE,SAAS,OAC9B,EAAE,YAAY,QAAQ,EAAE,YAAY;AAEzC;;;;;;AAOA,SAAgB,QAAQ,GAAiB,GAAyB;CAChE,IAAI,EAAE,cAAc,EAAE,cAAc,iBAAiB,GAAG,CAAC,GAAG;EAC1D,MAAM,YAAY,EAAE,eAAe;EAEnC,IAAI,eADc,EAAE,eAAe,eAEjC,OAAO,YAAY,KAAK;CAE5B;CACA,OAAOA,UAAa,GAAG,CAAC;AAC1B"}

package/dist/versioning-list.generated.d.ts

@@ -1,5 +1,5 @@
 //#region lib/versioning-list.generated.d.ts
-declare const AllVersioningsListLiteral: readonly ["apk", "aws-eks-addon", "aws-machine-image", "azure-rest-api", "bazel-module", "cargo", "composer", "conan", "conda", "deb", "debian", "deno", "devbox", "docker", "elm", "exact", "git", "github-actions", "glasskube", "go-mod-directive", "gradle", "hashicorp", "helm", "hermit", "hex", "ivy", "kubernetes-api", "lambda-node", "loose", "maven", "nixpkgs", "node", "npm", "nuget", "pep440", "perl", "poetry", "pvp", "python", "redhat", "regex", "rez", "rpm", "ruby", "rust-release-channel", "same-major", "semver", "semver-coerced", "semver-partial", "swift", "ubuntu", "unity3d", "unity3d-packages"];
+declare const AllVersioningsListLiteral: readonly ["apk", "aws-eks-addon", "aws-machine-image", "azure-rest-api", "bazel-module", "cargo", "composer", "conan", "conda", "deb", "debian", "deno", "devbox", "docker", "elm", "exact", "git", "github-actions", "glasskube", "go-mod-directive", "gradle", "hashicorp", "helm", "hermit", "hex", "ivy", "kubernetes-api", "lambda-node", "loose", "maven", "nixpkgs", "node", "npm", "nuget", "paket", "pep440", "perl", "poetry", "pvp", "python", "redhat", "regex", "rez", "rpm", "ruby", "rust-release-channel", "same-major", "semver", "semver-coerced", "semver-partial", "swift", "ubuntu", "unity3d", "unity3d-packages"];
 type VersioningName = typeof AllVersioningsListLiteral[number];
 //#endregion
 export { VersioningName };

package/dist/versioning-list.generated.js

@@ -34,6 +34,7 @@ const AllVersioningsListLiteral = [
 	"node",
 	"npm",
 	"nuget",
+	"paket",
 	"pep440",
 	"perl",
 	"poetry",

package/dist/versioning-list.generated.js.map

@@ -1 +1 @@
-{"version":3,"file":"versioning-list.generated.js","names":[],"sources":["../lib/versioning-list.generated.ts"],"sourcesContent":["\nexport const AllVersioningsListLiteral = [\"apk\",\"aws-eks-addon\",\"aws-machine-image\",\"azure-rest-api\",\"bazel-module\",\"cargo\",\"composer\",\"conan\",\"conda\",\"deb\",\"debian\",\"deno\",\"devbox\",\"docker\",\"elm\",\"exact\",\"git\",\"github-actions\",\"glasskube\",\"go-mod-directive\",\"gradle\",\"hashicorp\",\"helm\",\"hermit\",\"hex\",\"ivy\",\"kubernetes-api\",\"lambda-node\",\"loose\",\"maven\",\"nixpkgs\",\"node\",\"npm\",\"nuget\",\"pep440\",\"perl\",\"poetry\",\"pvp\",\"python\",\"redhat\",\"regex\",\"rez\",\"rpm\",\"ruby\",\"rust-release-channel\",\"same-major\",\"semver\",\"semver-coerced\",\"semver-partial\",\"swift\",\"ubuntu\",\"unity3d\",\"unity3d-packages\"] as const;\nexport type VersioningName = typeof AllVersioningsListLiteral[number];\n"],"mappings":";AACA,MAAa,4BAA4B;CAAC;CAAM;CAAgB;CAAoB;CAAiB;CAAe;CAAQ;CAAW;CAAQ;CAAQ;CAAM;CAAS;CAAO;CAAS;CAAS;CAAM;CAAQ;CAAM;CAAiB;CAAY;CAAmB;CAAS;CAAY;CAAO;CAAS;CAAM;CAAM;CAAiB;CAAc;CAAQ;CAAQ;CAAU;CAAO;CAAM;CAAQ;CAAS;CAAO;CAAS;CAAM;CAAS;CAAS;CAAQ;CAAM;CAAM;CAAO;CAAuB;CAAa;CAAS;CAAiB;CAAiB;CAAQ;CAAS;CAAU;AAAkB"}
+{"version":3,"file":"versioning-list.generated.js","names":[],"sources":["../lib/versioning-list.generated.ts"],"sourcesContent":["\nexport const AllVersioningsListLiteral = [\"apk\",\"aws-eks-addon\",\"aws-machine-image\",\"azure-rest-api\",\"bazel-module\",\"cargo\",\"composer\",\"conan\",\"conda\",\"deb\",\"debian\",\"deno\",\"devbox\",\"docker\",\"elm\",\"exact\",\"git\",\"github-actions\",\"glasskube\",\"go-mod-directive\",\"gradle\",\"hashicorp\",\"helm\",\"hermit\",\"hex\",\"ivy\",\"kubernetes-api\",\"lambda-node\",\"loose\",\"maven\",\"nixpkgs\",\"node\",\"npm\",\"nuget\",\"paket\",\"pep440\",\"perl\",\"poetry\",\"pvp\",\"python\",\"redhat\",\"regex\",\"rez\",\"rpm\",\"ruby\",\"rust-release-channel\",\"same-major\",\"semver\",\"semver-coerced\",\"semver-partial\",\"swift\",\"ubuntu\",\"unity3d\",\"unity3d-packages\"] as const;\nexport type VersioningName = typeof AllVersioningsListLiteral[number];\n"],"mappings":";AACA,MAAa,4BAA4B;CAAC;CAAM;CAAgB;CAAoB;CAAiB;CAAe;CAAQ;CAAW;CAAQ;CAAQ;CAAM;CAAS;CAAO;CAAS;CAAS;CAAM;CAAQ;CAAM;CAAiB;CAAY;CAAmB;CAAS;CAAY;CAAO;CAAS;CAAM;CAAM;CAAiB;CAAc;CAAQ;CAAQ;CAAU;CAAO;CAAM;CAAQ;CAAQ;CAAS;CAAO;CAAS;CAAM;CAAS;CAAS;CAAQ;CAAM;CAAM;CAAO;CAAuB;CAAa;CAAS;CAAiB;CAAiB;CAAQ;CAAS;CAAU;AAAkB"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "renovate",
   "description": "Automated dependency updates. Flexible so you don't need to be.",
-  "version": "43.253.2",
+  "version": "43.255.0",
   "type": "module",
   "bin": {
     "renovate": "dist/renovate.js",

package/renovate-schema.json

@@ -1,8 +1,8 @@
 {
   "$id": "https://docs.renovatebot.com/renovate-schema.json",
-  "title": "JSON schema for Renovate 43.253.2 config files (https://renovatebot.com/)",
+  "title": "JSON schema for Renovate 43.255.0 config files (https://renovatebot.com/)",
   "$schema": "http://json-schema.org/draft-07/schema#",
-  "x-renovate-version": "43.253.2",
+  "x-renovate-version": "43.255.0",
   "allowComments": true,
   "type": "object",
   "definitions": {
@@ -8226,6 +8226,7 @@
             "node",
             "npm",
             "nuget",
+            "paket",
             "pep440",
             "perl",
             "poetry",