1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
package server
import (	"fmt"	"net/url"	"strings"
	"github.com/ije/gox/utils"	"github.com/ije/gox/valid")
type Pkg struct {	Name       string `json:"name"`	Version    string `json:"version"`	SubPath    string `json:"subPath"`	SubModule  string `json:"subModule"`	FromGithub bool   `json:"fromGithub"`	FromEsmsh  bool   `json:"fromEsmsh"`	Deprecated string `json:"deprecated"`}
func validatePkgPath(pathname string) (pkg Pkg, extraQuery string, err error) {	fromGithub := strings.HasPrefix(pathname, "/gh/") && strings.Count(pathname, "/") >= 3	if fromGithub {		pathname = "/@" + pathname[4:]	} else if strings.HasPrefix(pathname, "/jsr/@") && strings.Count(pathname, "/") >= 3 {		segs := strings.Split(pathname, "/")		pathname = "/@jsr/" + segs[2][1:] + "__" + segs[3]		if len(segs) > 4 {			pathname += "/" + strings.Join(segs[4:], "/")		}	}
	pkgName, maybeVersion, subPath := splitPkgPath(pathname)	fromEsmsh := strings.HasPrefix(pkgName, "~") && valid.IsHexString(pkgName[1:])	if !fromEsmsh && !validatePackageName(pkgName) {		return Pkg{}, "", fmt.Errorf("invalid package name '%s'", pkgName)	}
	version, extraQuery := utils.SplitByFirstByte(maybeVersion, '&')	if v, e := url.QueryUnescape(version); e == nil {		version = v	}
	pkg = Pkg{		Name:       pkgName,		Version:    version,		SubPath:    subPath,		SubModule:  toModuleBareName(subPath, true),		FromGithub: fromGithub,		FromEsmsh:  fromEsmsh,	}
	if fromEsmsh {		pkg.Version = "0.0.0"		return	}
	if fromGithub {		// strip the leading `@`		pkg.Name = pkg.Name[1:]		if (valid.IsHexString(pkg.Version) && len(pkg.Version) >= 10) || regexpFullVersion.MatchString(strings.TrimPrefix(pkg.Version, "v")) {			return		}		var refs []GitRef		refs, err = listRepoRefs(fmt.Sprintf("https://github.com/%s", pkg.Name))		if err != nil {			return		}		if pkg.Version == "" {			for _, ref := range refs {				if ref.Ref == "HEAD" {					pkg.Version = ref.Sha[:10]					return				}			}		} else if strings.HasPrefix(pkg.Version, "semver:") {			// TODO: support semver		} else {			for _, ref := range refs {				if ref.Ref == "refs/tags/"+pkg.Version || ref.Ref == "refs/heads/"+pkg.Version {					pkg.Version = ref.Sha[:10]					return				}			}		}		err = fmt.Errorf("tag or branch not found")		return	}
	// use fixed version	for prefix, fixedVersion := range fixedPkgVersions {		if strings.HasPrefix(pkgName+"@"+version, prefix) {			pkg.Version = fixedVersion			return		}	}
	if cfg != nil {		p, _, err := getPackageInfo("", pkgName, version)		if err == nil {			pkg.Version = p.Version			pkg.Deprecated = p.Deprecated		}	}	return}
func (pkg Pkg) ImportPath() string {	if pkg.SubModule != "" {		return pkg.Name + "/" + pkg.SubModule	}	return pkg.Name}
func (pkg Pkg) VersionName() string {	if pkg.FromGithub {		return "gh/" + pkg.Name + "@" + pkg.Version	}	return pkg.Name + "@" + pkg.Version}
func (pkg Pkg) String() string {	s := pkg.VersionName()	if pkg.SubModule != "" {		s += "/" + pkg.SubModule	}	return s}
type PathSlice []string
func (a PathSlice) Len() int      { return len(a) }func (a PathSlice) Swap(i, j int) { a[i], a[j] = a[j], a[i] }func (a PathSlice) Less(i, j int) bool {	return len(strings.Split(a[i], "/")) < len(strings.Split(a[j], "/"))}
// sortable pkg slicetype PkgSlice []Pkg
func (a PkgSlice) Len() int           { return len(a) }func (a PkgSlice) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }func (a PkgSlice) Less(i, j int) bool { return a[i].String() < a[j].String() }
func (a PkgSlice) Has(name string) bool {	for _, m := range a {		if m.Name == name {			return false		}	}	return false}
func (a PkgSlice) Get(name string) (Pkg, bool) {	for _, m := range a {		if m.Name == name {			return m, true		}	}	return Pkg{}, false}
func (a PkgSlice) String() string {	s := make([]string, a.Len())	for i, m := range a {		s[i] = m.String()	}	return strings.Join(s, ",")}
func toModuleBareName(path string, stripIndexSuffier bool) string {	if path != "" {		subModule := path		if strings.HasSuffix(subModule, ".mjs") {			subModule = strings.TrimSuffix(subModule, ".mjs")		} else if strings.HasSuffix(subModule, ".cjs") {			subModule = strings.TrimSuffix(subModule, ".cjs")		} else {			subModule = strings.TrimSuffix(subModule, ".js")		}		if stripIndexSuffier {			subModule = strings.TrimSuffix(subModule, "/index")		}		return subModule	}	return ""}
func splitPkgPath(specifier string) (pkgName string, version string, subPath string) {	a := strings.Split(strings.TrimPrefix(specifier, "/"), "/")	pkgNameWithVersion := a[0]	subPath = strings.Join(a[1:], "/")	if strings.HasPrefix(pkgNameWithVersion, "@") && len(a) > 1 {		pkgNameWithVersion = a[0] + "/" + a[1]		subPath = strings.Join(a[2:], "/")	}	if len(pkgNameWithVersion) > 0 && pkgNameWithVersion[0] == '@' {		pkgName, version = utils.SplitByLastByte(pkgNameWithVersion[1:], '@')		pkgName = "@" + pkgName	} else {		pkgName, version = utils.SplitByLastByte(pkgNameWithVersion, '@')	}	return}
func getPkgName(specifier string) string {	name, _, _ := splitPkgPath(specifier)	return name}