html-validate-vue 6.0.3 → 6.0.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/dist/index.js +45 -2520
  2. package/dist/index.js.map +4 -4
  3. package/package.json +1 -1
package/dist/index.js CHANGED
@@ -5,9 +5,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
5
5
  var __getOwnPropNames = Object.getOwnPropertyNames;
6
6
  var __getProtoOf = Object.getPrototypeOf;
7
7
  var __hasOwnProp = Object.prototype.hasOwnProperty;
8
- var __commonJS = (cb, mod) => function __require() {
9
- return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
10
- };
11
8
  var __copyProps = (to, from, except, desc) => {
12
9
  if (from && typeof from === "object" || typeof from === "function") {
13
10
  for (let key of __getOwnPropNames(from))
@@ -25,2443 +22,13 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
25
22
  mod
26
23
  ));
27
24
 
28
- // node_modules/semver/internal/constants.js
29
- var require_constants = __commonJS({
30
- "node_modules/semver/internal/constants.js"(exports2, module2) {
31
- var SEMVER_SPEC_VERSION = "2.0.0";
32
- var MAX_LENGTH = 256;
33
- var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
34
- 9007199254740991;
35
- var MAX_SAFE_COMPONENT_LENGTH = 16;
36
- var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;
37
- var RELEASE_TYPES = [
38
- "major",
39
- "premajor",
40
- "minor",
41
- "preminor",
42
- "patch",
43
- "prepatch",
44
- "prerelease"
45
- ];
46
- module2.exports = {
47
- MAX_LENGTH,
48
- MAX_SAFE_COMPONENT_LENGTH,
49
- MAX_SAFE_BUILD_LENGTH,
50
- MAX_SAFE_INTEGER,
51
- RELEASE_TYPES,
52
- SEMVER_SPEC_VERSION,
53
- FLAG_INCLUDE_PRERELEASE: 1,
54
- FLAG_LOOSE: 2
55
- };
56
- }
57
- });
58
-
59
- // node_modules/semver/internal/debug.js
60
- var require_debug = __commonJS({
61
- "node_modules/semver/internal/debug.js"(exports2, module2) {
62
- var debug = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {
63
- };
64
- module2.exports = debug;
65
- }
66
- });
67
-
68
- // node_modules/semver/internal/re.js
69
- var require_re = __commonJS({
70
- "node_modules/semver/internal/re.js"(exports2, module2) {
71
- var {
72
- MAX_SAFE_COMPONENT_LENGTH,
73
- MAX_SAFE_BUILD_LENGTH,
74
- MAX_LENGTH
75
- } = require_constants();
76
- var debug = require_debug();
77
- exports2 = module2.exports = {};
78
- var re = exports2.re = [];
79
- var safeRe = exports2.safeRe = [];
80
- var src = exports2.src = [];
81
- var t = exports2.t = {};
82
- var R = 0;
83
- var LETTERDASHNUMBER = "[a-zA-Z0-9-]";
84
- var safeRegexReplacements = [
85
- ["\\s", 1],
86
- ["\\d", MAX_LENGTH],
87
- [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
88
- ];
89
- var makeSafeRegex = (value) => {
90
- for (const [token, max] of safeRegexReplacements) {
91
- value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
92
- }
93
- return value;
94
- };
95
- var createToken = (name, value, isGlobal) => {
96
- const safe = makeSafeRegex(value);
97
- const index = R++;
98
- debug(name, index, value);
99
- t[name] = index;
100
- src[index] = value;
101
- re[index] = new RegExp(value, isGlobal ? "g" : void 0);
102
- safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
103
- };
104
- createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
105
- createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
106
- createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
107
- createToken("MAINVERSION", `(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})`);
108
- createToken("MAINVERSIONLOOSE", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})`);
109
- createToken("PRERELEASEIDENTIFIER", `(?:${src[t.NUMERICIDENTIFIER]}|${src[t.NONNUMERICIDENTIFIER]})`);
110
- createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t.NUMERICIDENTIFIERLOOSE]}|${src[t.NONNUMERICIDENTIFIER]})`);
111
- createToken("PRERELEASE", `(?:-(${src[t.PRERELEASEIDENTIFIER]}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
112
- createToken("PRERELEASELOOSE", `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
113
- createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
114
- createToken("BUILD", `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
115
- createToken("FULLPLAIN", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);
116
- createToken("FULL", `^${src[t.FULLPLAIN]}$`);
117
- createToken("LOOSEPLAIN", `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`);
118
- createToken("LOOSE", `^${src[t.LOOSEPLAIN]}$`);
119
- createToken("GTLT", "((?:<|>)?=?)");
120
- createToken("XRANGEIDENTIFIERLOOSE", `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
121
- createToken("XRANGEIDENTIFIER", `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
122
- createToken("XRANGEPLAIN", `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?)?)?`);
123
- createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?)?)?`);
124
- createToken("XRANGE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
125
- createToken("XRANGELOOSE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
126
- createToken("COERCE", `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:$|[^\\d])`);
127
- createToken("COERCERTL", src[t.COERCE], true);
128
- createToken("LONETILDE", "(?:~>?)");
129
- createToken("TILDETRIM", `(\\s*)${src[t.LONETILDE]}\\s+`, true);
130
- exports2.tildeTrimReplace = "$1~";
131
- createToken("TILDE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
132
- createToken("TILDELOOSE", `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
133
- createToken("LONECARET", "(?:\\^)");
134
- createToken("CARETTRIM", `(\\s*)${src[t.LONECARET]}\\s+`, true);
135
- exports2.caretTrimReplace = "$1^";
136
- createToken("CARET", `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
137
- createToken("CARETLOOSE", `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
138
- createToken("COMPARATORLOOSE", `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
139
- createToken("COMPARATOR", `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
140
- createToken("COMPARATORTRIM", `(\\s*)${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
141
- exports2.comparatorTrimReplace = "$1$2$3";
142
- createToken("HYPHENRANGE", `^\\s*(${src[t.XRANGEPLAIN]})\\s+-\\s+(${src[t.XRANGEPLAIN]})\\s*$`);
143
- createToken("HYPHENRANGELOOSE", `^\\s*(${src[t.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t.XRANGEPLAINLOOSE]})\\s*$`);
144
- createToken("STAR", "(<|>)?=?\\s*\\*");
145
- createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
146
- createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
147
- }
148
- });
149
-
150
- // node_modules/semver/internal/parse-options.js
151
- var require_parse_options = __commonJS({
152
- "node_modules/semver/internal/parse-options.js"(exports2, module2) {
153
- var looseOption = Object.freeze({ loose: true });
154
- var emptyOpts = Object.freeze({});
155
- var parseOptions = (options) => {
156
- if (!options) {
157
- return emptyOpts;
158
- }
159
- if (typeof options !== "object") {
160
- return looseOption;
161
- }
162
- return options;
163
- };
164
- module2.exports = parseOptions;
165
- }
166
- });
167
-
168
- // node_modules/semver/internal/identifiers.js
169
- var require_identifiers = __commonJS({
170
- "node_modules/semver/internal/identifiers.js"(exports2, module2) {
171
- var numeric = /^[0-9]+$/;
172
- var compareIdentifiers = (a, b) => {
173
- const anum = numeric.test(a);
174
- const bnum = numeric.test(b);
175
- if (anum && bnum) {
176
- a = +a;
177
- b = +b;
178
- }
179
- return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
180
- };
181
- var rcompareIdentifiers = (a, b) => compareIdentifiers(b, a);
182
- module2.exports = {
183
- compareIdentifiers,
184
- rcompareIdentifiers
185
- };
186
- }
187
- });
188
-
189
- // node_modules/semver/classes/semver.js
190
- var require_semver = __commonJS({
191
- "node_modules/semver/classes/semver.js"(exports2, module2) {
192
- var debug = require_debug();
193
- var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants();
194
- var { safeRe: re, t } = require_re();
195
- var parseOptions = require_parse_options();
196
- var { compareIdentifiers } = require_identifiers();
197
- var SemVer = class _SemVer {
198
- constructor(version, options) {
199
- options = parseOptions(options);
200
- if (version instanceof _SemVer) {
201
- if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) {
202
- return version;
203
- } else {
204
- version = version.version;
205
- }
206
- } else if (typeof version !== "string") {
207
- throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`);
208
- }
209
- if (version.length > MAX_LENGTH) {
210
- throw new TypeError(
211
- `version is longer than ${MAX_LENGTH} characters`
212
- );
213
- }
214
- debug("SemVer", version, options);
215
- this.options = options;
216
- this.loose = !!options.loose;
217
- this.includePrerelease = !!options.includePrerelease;
218
- const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
219
- if (!m) {
220
- throw new TypeError(`Invalid Version: ${version}`);
221
- }
222
- this.raw = version;
223
- this.major = +m[1];
224
- this.minor = +m[2];
225
- this.patch = +m[3];
226
- if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
227
- throw new TypeError("Invalid major version");
228
- }
229
- if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
230
- throw new TypeError("Invalid minor version");
231
- }
232
- if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
233
- throw new TypeError("Invalid patch version");
234
- }
235
- if (!m[4]) {
236
- this.prerelease = [];
237
- } else {
238
- this.prerelease = m[4].split(".").map((id) => {
239
- if (/^[0-9]+$/.test(id)) {
240
- const num = +id;
241
- if (num >= 0 && num < MAX_SAFE_INTEGER) {
242
- return num;
243
- }
244
- }
245
- return id;
246
- });
247
- }
248
- this.build = m[5] ? m[5].split(".") : [];
249
- this.format();
250
- }
251
- format() {
252
- this.version = `${this.major}.${this.minor}.${this.patch}`;
253
- if (this.prerelease.length) {
254
- this.version += `-${this.prerelease.join(".")}`;
255
- }
256
- return this.version;
257
- }
258
- toString() {
259
- return this.version;
260
- }
261
- compare(other) {
262
- debug("SemVer.compare", this.version, this.options, other);
263
- if (!(other instanceof _SemVer)) {
264
- if (typeof other === "string" && other === this.version) {
265
- return 0;
266
- }
267
- other = new _SemVer(other, this.options);
268
- }
269
- if (other.version === this.version) {
270
- return 0;
271
- }
272
- return this.compareMain(other) || this.comparePre(other);
273
- }
274
- compareMain(other) {
275
- if (!(other instanceof _SemVer)) {
276
- other = new _SemVer(other, this.options);
277
- }
278
- return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
279
- }
280
- comparePre(other) {
281
- if (!(other instanceof _SemVer)) {
282
- other = new _SemVer(other, this.options);
283
- }
284
- if (this.prerelease.length && !other.prerelease.length) {
285
- return -1;
286
- } else if (!this.prerelease.length && other.prerelease.length) {
287
- return 1;
288
- } else if (!this.prerelease.length && !other.prerelease.length) {
289
- return 0;
290
- }
291
- let i = 0;
292
- do {
293
- const a = this.prerelease[i];
294
- const b = other.prerelease[i];
295
- debug("prerelease compare", i, a, b);
296
- if (a === void 0 && b === void 0) {
297
- return 0;
298
- } else if (b === void 0) {
299
- return 1;
300
- } else if (a === void 0) {
301
- return -1;
302
- } else if (a === b) {
303
- continue;
304
- } else {
305
- return compareIdentifiers(a, b);
306
- }
307
- } while (++i);
308
- }
309
- compareBuild(other) {
310
- if (!(other instanceof _SemVer)) {
311
- other = new _SemVer(other, this.options);
312
- }
313
- let i = 0;
314
- do {
315
- const a = this.build[i];
316
- const b = other.build[i];
317
- debug("prerelease compare", i, a, b);
318
- if (a === void 0 && b === void 0) {
319
- return 0;
320
- } else if (b === void 0) {
321
- return 1;
322
- } else if (a === void 0) {
323
- return -1;
324
- } else if (a === b) {
325
- continue;
326
- } else {
327
- return compareIdentifiers(a, b);
328
- }
329
- } while (++i);
330
- }
331
- // preminor will bump the version up to the next minor release, and immediately
332
- // down to pre-release. premajor and prepatch work the same way.
333
- inc(release, identifier, identifierBase) {
334
- switch (release) {
335
- case "premajor":
336
- this.prerelease.length = 0;
337
- this.patch = 0;
338
- this.minor = 0;
339
- this.major++;
340
- this.inc("pre", identifier, identifierBase);
341
- break;
342
- case "preminor":
343
- this.prerelease.length = 0;
344
- this.patch = 0;
345
- this.minor++;
346
- this.inc("pre", identifier, identifierBase);
347
- break;
348
- case "prepatch":
349
- this.prerelease.length = 0;
350
- this.inc("patch", identifier, identifierBase);
351
- this.inc("pre", identifier, identifierBase);
352
- break;
353
- case "prerelease":
354
- if (this.prerelease.length === 0) {
355
- this.inc("patch", identifier, identifierBase);
356
- }
357
- this.inc("pre", identifier, identifierBase);
358
- break;
359
- case "major":
360
- if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
361
- this.major++;
362
- }
363
- this.minor = 0;
364
- this.patch = 0;
365
- this.prerelease = [];
366
- break;
367
- case "minor":
368
- if (this.patch !== 0 || this.prerelease.length === 0) {
369
- this.minor++;
370
- }
371
- this.patch = 0;
372
- this.prerelease = [];
373
- break;
374
- case "patch":
375
- if (this.prerelease.length === 0) {
376
- this.patch++;
377
- }
378
- this.prerelease = [];
379
- break;
380
- case "pre": {
381
- const base = Number(identifierBase) ? 1 : 0;
382
- if (!identifier && identifierBase === false) {
383
- throw new Error("invalid increment argument: identifier is empty");
384
- }
385
- if (this.prerelease.length === 0) {
386
- this.prerelease = [base];
387
- } else {
388
- let i = this.prerelease.length;
389
- while (--i >= 0) {
390
- if (typeof this.prerelease[i] === "number") {
391
- this.prerelease[i]++;
392
- i = -2;
393
- }
394
- }
395
- if (i === -1) {
396
- if (identifier === this.prerelease.join(".") && identifierBase === false) {
397
- throw new Error("invalid increment argument: identifier already exists");
398
- }
399
- this.prerelease.push(base);
400
- }
401
- }
402
- if (identifier) {
403
- let prerelease = [identifier, base];
404
- if (identifierBase === false) {
405
- prerelease = [identifier];
406
- }
407
- if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
408
- if (isNaN(this.prerelease[1])) {
409
- this.prerelease = prerelease;
410
- }
411
- } else {
412
- this.prerelease = prerelease;
413
- }
414
- }
415
- break;
416
- }
417
- default:
418
- throw new Error(`invalid increment argument: ${release}`);
419
- }
420
- this.raw = this.format();
421
- if (this.build.length) {
422
- this.raw += `+${this.build.join(".")}`;
423
- }
424
- return this;
425
- }
426
- };
427
- module2.exports = SemVer;
428
- }
429
- });
430
-
431
- // node_modules/semver/functions/parse.js
432
- var require_parse = __commonJS({
433
- "node_modules/semver/functions/parse.js"(exports2, module2) {
434
- var SemVer = require_semver();
435
- var parse = (version, options, throwErrors = false) => {
436
- if (version instanceof SemVer) {
437
- return version;
438
- }
439
- try {
440
- return new SemVer(version, options);
441
- } catch (er) {
442
- if (!throwErrors) {
443
- return null;
444
- }
445
- throw er;
446
- }
447
- };
448
- module2.exports = parse;
449
- }
450
- });
451
-
452
- // node_modules/semver/functions/valid.js
453
- var require_valid = __commonJS({
454
- "node_modules/semver/functions/valid.js"(exports2, module2) {
455
- var parse = require_parse();
456
- var valid = (version, options) => {
457
- const v = parse(version, options);
458
- return v ? v.version : null;
459
- };
460
- module2.exports = valid;
461
- }
462
- });
463
-
464
- // node_modules/semver/functions/clean.js
465
- var require_clean = __commonJS({
466
- "node_modules/semver/functions/clean.js"(exports2, module2) {
467
- var parse = require_parse();
468
- var clean = (version, options) => {
469
- const s = parse(version.trim().replace(/^[=v]+/, ""), options);
470
- return s ? s.version : null;
471
- };
472
- module2.exports = clean;
473
- }
474
- });
475
-
476
- // node_modules/semver/functions/inc.js
477
- var require_inc = __commonJS({
478
- "node_modules/semver/functions/inc.js"(exports2, module2) {
479
- var SemVer = require_semver();
480
- var inc = (version, release, options, identifier, identifierBase) => {
481
- if (typeof options === "string") {
482
- identifierBase = identifier;
483
- identifier = options;
484
- options = void 0;
485
- }
486
- try {
487
- return new SemVer(
488
- version instanceof SemVer ? version.version : version,
489
- options
490
- ).inc(release, identifier, identifierBase).version;
491
- } catch (er) {
492
- return null;
493
- }
494
- };
495
- module2.exports = inc;
496
- }
497
- });
498
-
499
- // node_modules/semver/functions/diff.js
500
- var require_diff = __commonJS({
501
- "node_modules/semver/functions/diff.js"(exports2, module2) {
502
- var parse = require_parse();
503
- var diff = (version1, version2) => {
504
- const v1 = parse(version1, null, true);
505
- const v2 = parse(version2, null, true);
506
- const comparison = v1.compare(v2);
507
- if (comparison === 0) {
508
- return null;
509
- }
510
- const v1Higher = comparison > 0;
511
- const highVersion = v1Higher ? v1 : v2;
512
- const lowVersion = v1Higher ? v2 : v1;
513
- const highHasPre = !!highVersion.prerelease.length;
514
- const lowHasPre = !!lowVersion.prerelease.length;
515
- if (lowHasPre && !highHasPre) {
516
- if (!lowVersion.patch && !lowVersion.minor) {
517
- return "major";
518
- }
519
- if (highVersion.patch) {
520
- return "patch";
521
- }
522
- if (highVersion.minor) {
523
- return "minor";
524
- }
525
- return "major";
526
- }
527
- const prefix2 = highHasPre ? "pre" : "";
528
- if (v1.major !== v2.major) {
529
- return prefix2 + "major";
530
- }
531
- if (v1.minor !== v2.minor) {
532
- return prefix2 + "minor";
533
- }
534
- if (v1.patch !== v2.patch) {
535
- return prefix2 + "patch";
536
- }
537
- return "prerelease";
538
- };
539
- module2.exports = diff;
540
- }
541
- });
542
-
543
- // node_modules/semver/functions/major.js
544
- var require_major = __commonJS({
545
- "node_modules/semver/functions/major.js"(exports2, module2) {
546
- var SemVer = require_semver();
547
- var major = (a, loose) => new SemVer(a, loose).major;
548
- module2.exports = major;
549
- }
550
- });
551
-
552
- // node_modules/semver/functions/minor.js
553
- var require_minor = __commonJS({
554
- "node_modules/semver/functions/minor.js"(exports2, module2) {
555
- var SemVer = require_semver();
556
- var minor = (a, loose) => new SemVer(a, loose).minor;
557
- module2.exports = minor;
558
- }
559
- });
560
-
561
- // node_modules/semver/functions/patch.js
562
- var require_patch = __commonJS({
563
- "node_modules/semver/functions/patch.js"(exports2, module2) {
564
- var SemVer = require_semver();
565
- var patch = (a, loose) => new SemVer(a, loose).patch;
566
- module2.exports = patch;
567
- }
568
- });
569
-
570
- // node_modules/semver/functions/prerelease.js
571
- var require_prerelease = __commonJS({
572
- "node_modules/semver/functions/prerelease.js"(exports2, module2) {
573
- var parse = require_parse();
574
- var prerelease = (version, options) => {
575
- const parsed = parse(version, options);
576
- return parsed && parsed.prerelease.length ? parsed.prerelease : null;
577
- };
578
- module2.exports = prerelease;
579
- }
580
- });
581
-
582
- // node_modules/semver/functions/compare.js
583
- var require_compare = __commonJS({
584
- "node_modules/semver/functions/compare.js"(exports2, module2) {
585
- var SemVer = require_semver();
586
- var compare = (a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose));
587
- module2.exports = compare;
588
- }
589
- });
590
-
591
- // node_modules/semver/functions/rcompare.js
592
- var require_rcompare = __commonJS({
593
- "node_modules/semver/functions/rcompare.js"(exports2, module2) {
594
- var compare = require_compare();
595
- var rcompare = (a, b, loose) => compare(b, a, loose);
596
- module2.exports = rcompare;
597
- }
598
- });
599
-
600
- // node_modules/semver/functions/compare-loose.js
601
- var require_compare_loose = __commonJS({
602
- "node_modules/semver/functions/compare-loose.js"(exports2, module2) {
603
- var compare = require_compare();
604
- var compareLoose = (a, b) => compare(a, b, true);
605
- module2.exports = compareLoose;
606
- }
607
- });
608
-
609
- // node_modules/semver/functions/compare-build.js
610
- var require_compare_build = __commonJS({
611
- "node_modules/semver/functions/compare-build.js"(exports2, module2) {
612
- var SemVer = require_semver();
613
- var compareBuild = (a, b, loose) => {
614
- const versionA = new SemVer(a, loose);
615
- const versionB = new SemVer(b, loose);
616
- return versionA.compare(versionB) || versionA.compareBuild(versionB);
617
- };
618
- module2.exports = compareBuild;
619
- }
620
- });
621
-
622
- // node_modules/semver/functions/sort.js
623
- var require_sort = __commonJS({
624
- "node_modules/semver/functions/sort.js"(exports2, module2) {
625
- var compareBuild = require_compare_build();
626
- var sort = (list, loose) => list.sort((a, b) => compareBuild(a, b, loose));
627
- module2.exports = sort;
628
- }
629
- });
630
-
631
- // node_modules/semver/functions/rsort.js
632
- var require_rsort = __commonJS({
633
- "node_modules/semver/functions/rsort.js"(exports2, module2) {
634
- var compareBuild = require_compare_build();
635
- var rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose));
636
- module2.exports = rsort;
637
- }
638
- });
639
-
640
- // node_modules/semver/functions/gt.js
641
- var require_gt = __commonJS({
642
- "node_modules/semver/functions/gt.js"(exports2, module2) {
643
- var compare = require_compare();
644
- var gt = (a, b, loose) => compare(a, b, loose) > 0;
645
- module2.exports = gt;
646
- }
647
- });
648
-
649
- // node_modules/semver/functions/lt.js
650
- var require_lt = __commonJS({
651
- "node_modules/semver/functions/lt.js"(exports2, module2) {
652
- var compare = require_compare();
653
- var lt = (a, b, loose) => compare(a, b, loose) < 0;
654
- module2.exports = lt;
655
- }
656
- });
657
-
658
- // node_modules/semver/functions/eq.js
659
- var require_eq = __commonJS({
660
- "node_modules/semver/functions/eq.js"(exports2, module2) {
661
- var compare = require_compare();
662
- var eq = (a, b, loose) => compare(a, b, loose) === 0;
663
- module2.exports = eq;
664
- }
665
- });
666
-
667
- // node_modules/semver/functions/neq.js
668
- var require_neq = __commonJS({
669
- "node_modules/semver/functions/neq.js"(exports2, module2) {
670
- var compare = require_compare();
671
- var neq = (a, b, loose) => compare(a, b, loose) !== 0;
672
- module2.exports = neq;
673
- }
674
- });
675
-
676
- // node_modules/semver/functions/gte.js
677
- var require_gte = __commonJS({
678
- "node_modules/semver/functions/gte.js"(exports2, module2) {
679
- var compare = require_compare();
680
- var gte = (a, b, loose) => compare(a, b, loose) >= 0;
681
- module2.exports = gte;
682
- }
683
- });
684
-
685
- // node_modules/semver/functions/lte.js
686
- var require_lte = __commonJS({
687
- "node_modules/semver/functions/lte.js"(exports2, module2) {
688
- var compare = require_compare();
689
- var lte = (a, b, loose) => compare(a, b, loose) <= 0;
690
- module2.exports = lte;
691
- }
692
- });
693
-
694
- // node_modules/semver/functions/cmp.js
695
- var require_cmp = __commonJS({
696
- "node_modules/semver/functions/cmp.js"(exports2, module2) {
697
- var eq = require_eq();
698
- var neq = require_neq();
699
- var gt = require_gt();
700
- var gte = require_gte();
701
- var lt = require_lt();
702
- var lte = require_lte();
703
- var cmp = (a, op, b, loose) => {
704
- switch (op) {
705
- case "===":
706
- if (typeof a === "object") {
707
- a = a.version;
708
- }
709
- if (typeof b === "object") {
710
- b = b.version;
711
- }
712
- return a === b;
713
- case "!==":
714
- if (typeof a === "object") {
715
- a = a.version;
716
- }
717
- if (typeof b === "object") {
718
- b = b.version;
719
- }
720
- return a !== b;
721
- case "":
722
- case "=":
723
- case "==":
724
- return eq(a, b, loose);
725
- case "!=":
726
- return neq(a, b, loose);
727
- case ">":
728
- return gt(a, b, loose);
729
- case ">=":
730
- return gte(a, b, loose);
731
- case "<":
732
- return lt(a, b, loose);
733
- case "<=":
734
- return lte(a, b, loose);
735
- default:
736
- throw new TypeError(`Invalid operator: ${op}`);
737
- }
738
- };
739
- module2.exports = cmp;
740
- }
741
- });
742
-
743
- // node_modules/semver/functions/coerce.js
744
- var require_coerce = __commonJS({
745
- "node_modules/semver/functions/coerce.js"(exports2, module2) {
746
- var SemVer = require_semver();
747
- var parse = require_parse();
748
- var { safeRe: re, t } = require_re();
749
- var coerce = (version, options) => {
750
- if (version instanceof SemVer) {
751
- return version;
752
- }
753
- if (typeof version === "number") {
754
- version = String(version);
755
- }
756
- if (typeof version !== "string") {
757
- return null;
758
- }
759
- options = options || {};
760
- let match = null;
761
- if (!options.rtl) {
762
- match = version.match(re[t.COERCE]);
763
- } else {
764
- let next;
765
- while ((next = re[t.COERCERTL].exec(version)) && (!match || match.index + match[0].length !== version.length)) {
766
- if (!match || next.index + next[0].length !== match.index + match[0].length) {
767
- match = next;
768
- }
769
- re[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length;
770
- }
771
- re[t.COERCERTL].lastIndex = -1;
772
- }
773
- if (match === null) {
774
- return null;
775
- }
776
- return parse(`${match[2]}.${match[3] || "0"}.${match[4] || "0"}`, options);
777
- };
778
- module2.exports = coerce;
779
- }
780
- });
781
-
782
- // node_modules/yallist/iterator.js
783
- var require_iterator = __commonJS({
784
- "node_modules/yallist/iterator.js"(exports2, module2) {
785
- "use strict";
786
- module2.exports = function(Yallist) {
787
- Yallist.prototype[Symbol.iterator] = function* () {
788
- for (let walker = this.head; walker; walker = walker.next) {
789
- yield walker.value;
790
- }
791
- };
792
- };
793
- }
794
- });
795
-
796
- // node_modules/yallist/yallist.js
797
- var require_yallist = __commonJS({
798
- "node_modules/yallist/yallist.js"(exports2, module2) {
799
- "use strict";
800
- module2.exports = Yallist;
801
- Yallist.Node = Node;
802
- Yallist.create = Yallist;
803
- function Yallist(list) {
804
- var self = this;
805
- if (!(self instanceof Yallist)) {
806
- self = new Yallist();
807
- }
808
- self.tail = null;
809
- self.head = null;
810
- self.length = 0;
811
- if (list && typeof list.forEach === "function") {
812
- list.forEach(function(item) {
813
- self.push(item);
814
- });
815
- } else if (arguments.length > 0) {
816
- for (var i = 0, l = arguments.length; i < l; i++) {
817
- self.push(arguments[i]);
818
- }
819
- }
820
- return self;
821
- }
822
- Yallist.prototype.removeNode = function(node) {
823
- if (node.list !== this) {
824
- throw new Error("removing node which does not belong to this list");
825
- }
826
- var next = node.next;
827
- var prev = node.prev;
828
- if (next) {
829
- next.prev = prev;
830
- }
831
- if (prev) {
832
- prev.next = next;
833
- }
834
- if (node === this.head) {
835
- this.head = next;
836
- }
837
- if (node === this.tail) {
838
- this.tail = prev;
839
- }
840
- node.list.length--;
841
- node.next = null;
842
- node.prev = null;
843
- node.list = null;
844
- return next;
845
- };
846
- Yallist.prototype.unshiftNode = function(node) {
847
- if (node === this.head) {
848
- return;
849
- }
850
- if (node.list) {
851
- node.list.removeNode(node);
852
- }
853
- var head = this.head;
854
- node.list = this;
855
- node.next = head;
856
- if (head) {
857
- head.prev = node;
858
- }
859
- this.head = node;
860
- if (!this.tail) {
861
- this.tail = node;
862
- }
863
- this.length++;
864
- };
865
- Yallist.prototype.pushNode = function(node) {
866
- if (node === this.tail) {
867
- return;
868
- }
869
- if (node.list) {
870
- node.list.removeNode(node);
871
- }
872
- var tail = this.tail;
873
- node.list = this;
874
- node.prev = tail;
875
- if (tail) {
876
- tail.next = node;
877
- }
878
- this.tail = node;
879
- if (!this.head) {
880
- this.head = node;
881
- }
882
- this.length++;
883
- };
884
- Yallist.prototype.push = function() {
885
- for (var i = 0, l = arguments.length; i < l; i++) {
886
- push(this, arguments[i]);
887
- }
888
- return this.length;
889
- };
890
- Yallist.prototype.unshift = function() {
891
- for (var i = 0, l = arguments.length; i < l; i++) {
892
- unshift(this, arguments[i]);
893
- }
894
- return this.length;
895
- };
896
- Yallist.prototype.pop = function() {
897
- if (!this.tail) {
898
- return void 0;
899
- }
900
- var res = this.tail.value;
901
- this.tail = this.tail.prev;
902
- if (this.tail) {
903
- this.tail.next = null;
904
- } else {
905
- this.head = null;
906
- }
907
- this.length--;
908
- return res;
909
- };
910
- Yallist.prototype.shift = function() {
911
- if (!this.head) {
912
- return void 0;
913
- }
914
- var res = this.head.value;
915
- this.head = this.head.next;
916
- if (this.head) {
917
- this.head.prev = null;
918
- } else {
919
- this.tail = null;
920
- }
921
- this.length--;
922
- return res;
923
- };
924
- Yallist.prototype.forEach = function(fn, thisp) {
925
- thisp = thisp || this;
926
- for (var walker = this.head, i = 0; walker !== null; i++) {
927
- fn.call(thisp, walker.value, i, this);
928
- walker = walker.next;
929
- }
930
- };
931
- Yallist.prototype.forEachReverse = function(fn, thisp) {
932
- thisp = thisp || this;
933
- for (var walker = this.tail, i = this.length - 1; walker !== null; i--) {
934
- fn.call(thisp, walker.value, i, this);
935
- walker = walker.prev;
936
- }
937
- };
938
- Yallist.prototype.get = function(n) {
939
- for (var i = 0, walker = this.head; walker !== null && i < n; i++) {
940
- walker = walker.next;
941
- }
942
- if (i === n && walker !== null) {
943
- return walker.value;
944
- }
945
- };
946
- Yallist.prototype.getReverse = function(n) {
947
- for (var i = 0, walker = this.tail; walker !== null && i < n; i++) {
948
- walker = walker.prev;
949
- }
950
- if (i === n && walker !== null) {
951
- return walker.value;
952
- }
953
- };
954
- Yallist.prototype.map = function(fn, thisp) {
955
- thisp = thisp || this;
956
- var res = new Yallist();
957
- for (var walker = this.head; walker !== null; ) {
958
- res.push(fn.call(thisp, walker.value, this));
959
- walker = walker.next;
960
- }
961
- return res;
962
- };
963
- Yallist.prototype.mapReverse = function(fn, thisp) {
964
- thisp = thisp || this;
965
- var res = new Yallist();
966
- for (var walker = this.tail; walker !== null; ) {
967
- res.push(fn.call(thisp, walker.value, this));
968
- walker = walker.prev;
969
- }
970
- return res;
971
- };
972
- Yallist.prototype.reduce = function(fn, initial) {
973
- var acc;
974
- var walker = this.head;
975
- if (arguments.length > 1) {
976
- acc = initial;
977
- } else if (this.head) {
978
- walker = this.head.next;
979
- acc = this.head.value;
980
- } else {
981
- throw new TypeError("Reduce of empty list with no initial value");
982
- }
983
- for (var i = 0; walker !== null; i++) {
984
- acc = fn(acc, walker.value, i);
985
- walker = walker.next;
986
- }
987
- return acc;
988
- };
989
- Yallist.prototype.reduceReverse = function(fn, initial) {
990
- var acc;
991
- var walker = this.tail;
992
- if (arguments.length > 1) {
993
- acc = initial;
994
- } else if (this.tail) {
995
- walker = this.tail.prev;
996
- acc = this.tail.value;
997
- } else {
998
- throw new TypeError("Reduce of empty list with no initial value");
999
- }
1000
- for (var i = this.length - 1; walker !== null; i--) {
1001
- acc = fn(acc, walker.value, i);
1002
- walker = walker.prev;
1003
- }
1004
- return acc;
1005
- };
1006
- Yallist.prototype.toArray = function() {
1007
- var arr = new Array(this.length);
1008
- for (var i = 0, walker = this.head; walker !== null; i++) {
1009
- arr[i] = walker.value;
1010
- walker = walker.next;
1011
- }
1012
- return arr;
1013
- };
1014
- Yallist.prototype.toArrayReverse = function() {
1015
- var arr = new Array(this.length);
1016
- for (var i = 0, walker = this.tail; walker !== null; i++) {
1017
- arr[i] = walker.value;
1018
- walker = walker.prev;
1019
- }
1020
- return arr;
1021
- };
1022
- Yallist.prototype.slice = function(from, to) {
1023
- to = to || this.length;
1024
- if (to < 0) {
1025
- to += this.length;
1026
- }
1027
- from = from || 0;
1028
- if (from < 0) {
1029
- from += this.length;
1030
- }
1031
- var ret = new Yallist();
1032
- if (to < from || to < 0) {
1033
- return ret;
1034
- }
1035
- if (from < 0) {
1036
- from = 0;
1037
- }
1038
- if (to > this.length) {
1039
- to = this.length;
1040
- }
1041
- for (var i = 0, walker = this.head; walker !== null && i < from; i++) {
1042
- walker = walker.next;
1043
- }
1044
- for (; walker !== null && i < to; i++, walker = walker.next) {
1045
- ret.push(walker.value);
1046
- }
1047
- return ret;
1048
- };
1049
- Yallist.prototype.sliceReverse = function(from, to) {
1050
- to = to || this.length;
1051
- if (to < 0) {
1052
- to += this.length;
1053
- }
1054
- from = from || 0;
1055
- if (from < 0) {
1056
- from += this.length;
1057
- }
1058
- var ret = new Yallist();
1059
- if (to < from || to < 0) {
1060
- return ret;
1061
- }
1062
- if (from < 0) {
1063
- from = 0;
1064
- }
1065
- if (to > this.length) {
1066
- to = this.length;
1067
- }
1068
- for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) {
1069
- walker = walker.prev;
1070
- }
1071
- for (; walker !== null && i > from; i--, walker = walker.prev) {
1072
- ret.push(walker.value);
1073
- }
1074
- return ret;
1075
- };
1076
- Yallist.prototype.splice = function(start, deleteCount, ...nodes) {
1077
- if (start > this.length) {
1078
- start = this.length - 1;
1079
- }
1080
- if (start < 0) {
1081
- start = this.length + start;
1082
- }
1083
- for (var i = 0, walker = this.head; walker !== null && i < start; i++) {
1084
- walker = walker.next;
1085
- }
1086
- var ret = [];
1087
- for (var i = 0; walker && i < deleteCount; i++) {
1088
- ret.push(walker.value);
1089
- walker = this.removeNode(walker);
1090
- }
1091
- if (walker === null) {
1092
- walker = this.tail;
1093
- }
1094
- if (walker !== this.head && walker !== this.tail) {
1095
- walker = walker.prev;
1096
- }
1097
- for (var i = 0; i < nodes.length; i++) {
1098
- walker = insert(this, walker, nodes[i]);
1099
- }
1100
- return ret;
1101
- };
1102
- Yallist.prototype.reverse = function() {
1103
- var head = this.head;
1104
- var tail = this.tail;
1105
- for (var walker = head; walker !== null; walker = walker.prev) {
1106
- var p = walker.prev;
1107
- walker.prev = walker.next;
1108
- walker.next = p;
1109
- }
1110
- this.head = tail;
1111
- this.tail = head;
1112
- return this;
1113
- };
1114
- function insert(self, node, value) {
1115
- var inserted = node === self.head ? new Node(value, null, node, self) : new Node(value, node, node.next, self);
1116
- if (inserted.next === null) {
1117
- self.tail = inserted;
1118
- }
1119
- if (inserted.prev === null) {
1120
- self.head = inserted;
1121
- }
1122
- self.length++;
1123
- return inserted;
1124
- }
1125
- function push(self, item) {
1126
- self.tail = new Node(item, self.tail, null, self);
1127
- if (!self.head) {
1128
- self.head = self.tail;
1129
- }
1130
- self.length++;
1131
- }
1132
- function unshift(self, item) {
1133
- self.head = new Node(item, null, self.head, self);
1134
- if (!self.tail) {
1135
- self.tail = self.head;
1136
- }
1137
- self.length++;
1138
- }
1139
- function Node(value, prev, next, list) {
1140
- if (!(this instanceof Node)) {
1141
- return new Node(value, prev, next, list);
1142
- }
1143
- this.list = list;
1144
- this.value = value;
1145
- if (prev) {
1146
- prev.next = this;
1147
- this.prev = prev;
1148
- } else {
1149
- this.prev = null;
1150
- }
1151
- if (next) {
1152
- next.prev = this;
1153
- this.next = next;
1154
- } else {
1155
- this.next = null;
1156
- }
1157
- }
1158
- try {
1159
- require_iterator()(Yallist);
1160
- } catch (er) {
1161
- }
1162
- }
1163
- });
1164
-
1165
- // node_modules/lru-cache/index.js
1166
- var require_lru_cache = __commonJS({
1167
- "node_modules/lru-cache/index.js"(exports2, module2) {
1168
- "use strict";
1169
- var Yallist = require_yallist();
1170
- var MAX = Symbol("max");
1171
- var LENGTH = Symbol("length");
1172
- var LENGTH_CALCULATOR = Symbol("lengthCalculator");
1173
- var ALLOW_STALE = Symbol("allowStale");
1174
- var MAX_AGE = Symbol("maxAge");
1175
- var DISPOSE = Symbol("dispose");
1176
- var NO_DISPOSE_ON_SET = Symbol("noDisposeOnSet");
1177
- var LRU_LIST = Symbol("lruList");
1178
- var CACHE = Symbol("cache");
1179
- var UPDATE_AGE_ON_GET = Symbol("updateAgeOnGet");
1180
- var naiveLength = () => 1;
1181
- var LRUCache = class {
1182
- constructor(options) {
1183
- if (typeof options === "number")
1184
- options = { max: options };
1185
- if (!options)
1186
- options = {};
1187
- if (options.max && (typeof options.max !== "number" || options.max < 0))
1188
- throw new TypeError("max must be a non-negative number");
1189
- const max = this[MAX] = options.max || Infinity;
1190
- const lc = options.length || naiveLength;
1191
- this[LENGTH_CALCULATOR] = typeof lc !== "function" ? naiveLength : lc;
1192
- this[ALLOW_STALE] = options.stale || false;
1193
- if (options.maxAge && typeof options.maxAge !== "number")
1194
- throw new TypeError("maxAge must be a number");
1195
- this[MAX_AGE] = options.maxAge || 0;
1196
- this[DISPOSE] = options.dispose;
1197
- this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false;
1198
- this[UPDATE_AGE_ON_GET] = options.updateAgeOnGet || false;
1199
- this.reset();
1200
- }
1201
- // resize the cache when the max changes.
1202
- set max(mL) {
1203
- if (typeof mL !== "number" || mL < 0)
1204
- throw new TypeError("max must be a non-negative number");
1205
- this[MAX] = mL || Infinity;
1206
- trim(this);
1207
- }
1208
- get max() {
1209
- return this[MAX];
1210
- }
1211
- set allowStale(allowStale) {
1212
- this[ALLOW_STALE] = !!allowStale;
1213
- }
1214
- get allowStale() {
1215
- return this[ALLOW_STALE];
1216
- }
1217
- set maxAge(mA) {
1218
- if (typeof mA !== "number")
1219
- throw new TypeError("maxAge must be a non-negative number");
1220
- this[MAX_AGE] = mA;
1221
- trim(this);
1222
- }
1223
- get maxAge() {
1224
- return this[MAX_AGE];
1225
- }
1226
- // resize the cache when the lengthCalculator changes.
1227
- set lengthCalculator(lC) {
1228
- if (typeof lC !== "function")
1229
- lC = naiveLength;
1230
- if (lC !== this[LENGTH_CALCULATOR]) {
1231
- this[LENGTH_CALCULATOR] = lC;
1232
- this[LENGTH] = 0;
1233
- this[LRU_LIST].forEach((hit) => {
1234
- hit.length = this[LENGTH_CALCULATOR](hit.value, hit.key);
1235
- this[LENGTH] += hit.length;
1236
- });
1237
- }
1238
- trim(this);
1239
- }
1240
- get lengthCalculator() {
1241
- return this[LENGTH_CALCULATOR];
1242
- }
1243
- get length() {
1244
- return this[LENGTH];
1245
- }
1246
- get itemCount() {
1247
- return this[LRU_LIST].length;
1248
- }
1249
- rforEach(fn, thisp) {
1250
- thisp = thisp || this;
1251
- for (let walker = this[LRU_LIST].tail; walker !== null; ) {
1252
- const prev = walker.prev;
1253
- forEachStep(this, fn, walker, thisp);
1254
- walker = prev;
1255
- }
1256
- }
1257
- forEach(fn, thisp) {
1258
- thisp = thisp || this;
1259
- for (let walker = this[LRU_LIST].head; walker !== null; ) {
1260
- const next = walker.next;
1261
- forEachStep(this, fn, walker, thisp);
1262
- walker = next;
1263
- }
1264
- }
1265
- keys() {
1266
- return this[LRU_LIST].toArray().map((k) => k.key);
1267
- }
1268
- values() {
1269
- return this[LRU_LIST].toArray().map((k) => k.value);
1270
- }
1271
- reset() {
1272
- if (this[DISPOSE] && this[LRU_LIST] && this[LRU_LIST].length) {
1273
- this[LRU_LIST].forEach((hit) => this[DISPOSE](hit.key, hit.value));
1274
- }
1275
- this[CACHE] = /* @__PURE__ */ new Map();
1276
- this[LRU_LIST] = new Yallist();
1277
- this[LENGTH] = 0;
1278
- }
1279
- dump() {
1280
- return this[LRU_LIST].map((hit) => isStale(this, hit) ? false : {
1281
- k: hit.key,
1282
- v: hit.value,
1283
- e: hit.now + (hit.maxAge || 0)
1284
- }).toArray().filter((h) => h);
1285
- }
1286
- dumpLru() {
1287
- return this[LRU_LIST];
1288
- }
1289
- set(key, value, maxAge) {
1290
- maxAge = maxAge || this[MAX_AGE];
1291
- if (maxAge && typeof maxAge !== "number")
1292
- throw new TypeError("maxAge must be a number");
1293
- const now = maxAge ? Date.now() : 0;
1294
- const len = this[LENGTH_CALCULATOR](value, key);
1295
- if (this[CACHE].has(key)) {
1296
- if (len > this[MAX]) {
1297
- del(this, this[CACHE].get(key));
1298
- return false;
1299
- }
1300
- const node = this[CACHE].get(key);
1301
- const item = node.value;
1302
- if (this[DISPOSE]) {
1303
- if (!this[NO_DISPOSE_ON_SET])
1304
- this[DISPOSE](key, item.value);
1305
- }
1306
- item.now = now;
1307
- item.maxAge = maxAge;
1308
- item.value = value;
1309
- this[LENGTH] += len - item.length;
1310
- item.length = len;
1311
- this.get(key);
1312
- trim(this);
1313
- return true;
1314
- }
1315
- const hit = new Entry(key, value, len, now, maxAge);
1316
- if (hit.length > this[MAX]) {
1317
- if (this[DISPOSE])
1318
- this[DISPOSE](key, value);
1319
- return false;
1320
- }
1321
- this[LENGTH] += hit.length;
1322
- this[LRU_LIST].unshift(hit);
1323
- this[CACHE].set(key, this[LRU_LIST].head);
1324
- trim(this);
1325
- return true;
1326
- }
1327
- has(key) {
1328
- if (!this[CACHE].has(key))
1329
- return false;
1330
- const hit = this[CACHE].get(key).value;
1331
- return !isStale(this, hit);
1332
- }
1333
- get(key) {
1334
- return get(this, key, true);
1335
- }
1336
- peek(key) {
1337
- return get(this, key, false);
1338
- }
1339
- pop() {
1340
- const node = this[LRU_LIST].tail;
1341
- if (!node)
1342
- return null;
1343
- del(this, node);
1344
- return node.value;
1345
- }
1346
- del(key) {
1347
- del(this, this[CACHE].get(key));
1348
- }
1349
- load(arr) {
1350
- this.reset();
1351
- const now = Date.now();
1352
- for (let l = arr.length - 1; l >= 0; l--) {
1353
- const hit = arr[l];
1354
- const expiresAt = hit.e || 0;
1355
- if (expiresAt === 0)
1356
- this.set(hit.k, hit.v);
1357
- else {
1358
- const maxAge = expiresAt - now;
1359
- if (maxAge > 0) {
1360
- this.set(hit.k, hit.v, maxAge);
1361
- }
1362
- }
1363
- }
1364
- }
1365
- prune() {
1366
- this[CACHE].forEach((value, key) => get(this, key, false));
1367
- }
1368
- };
1369
- var get = (self, key, doUse) => {
1370
- const node = self[CACHE].get(key);
1371
- if (node) {
1372
- const hit = node.value;
1373
- if (isStale(self, hit)) {
1374
- del(self, node);
1375
- if (!self[ALLOW_STALE])
1376
- return void 0;
1377
- } else {
1378
- if (doUse) {
1379
- if (self[UPDATE_AGE_ON_GET])
1380
- node.value.now = Date.now();
1381
- self[LRU_LIST].unshiftNode(node);
1382
- }
1383
- }
1384
- return hit.value;
1385
- }
1386
- };
1387
- var isStale = (self, hit) => {
1388
- if (!hit || !hit.maxAge && !self[MAX_AGE])
1389
- return false;
1390
- const diff = Date.now() - hit.now;
1391
- return hit.maxAge ? diff > hit.maxAge : self[MAX_AGE] && diff > self[MAX_AGE];
1392
- };
1393
- var trim = (self) => {
1394
- if (self[LENGTH] > self[MAX]) {
1395
- for (let walker = self[LRU_LIST].tail; self[LENGTH] > self[MAX] && walker !== null; ) {
1396
- const prev = walker.prev;
1397
- del(self, walker);
1398
- walker = prev;
1399
- }
1400
- }
1401
- };
1402
- var del = (self, node) => {
1403
- if (node) {
1404
- const hit = node.value;
1405
- if (self[DISPOSE])
1406
- self[DISPOSE](hit.key, hit.value);
1407
- self[LENGTH] -= hit.length;
1408
- self[CACHE].delete(hit.key);
1409
- self[LRU_LIST].removeNode(node);
1410
- }
1411
- };
1412
- var Entry = class {
1413
- constructor(key, value, length, now, maxAge) {
1414
- this.key = key;
1415
- this.value = value;
1416
- this.length = length;
1417
- this.now = now;
1418
- this.maxAge = maxAge || 0;
1419
- }
1420
- };
1421
- var forEachStep = (self, fn, node, thisp) => {
1422
- let hit = node.value;
1423
- if (isStale(self, hit)) {
1424
- del(self, node);
1425
- if (!self[ALLOW_STALE])
1426
- hit = void 0;
1427
- }
1428
- if (hit)
1429
- fn.call(thisp, hit.value, hit.key, self);
1430
- };
1431
- module2.exports = LRUCache;
1432
- }
1433
- });
1434
-
1435
- // node_modules/semver/classes/range.js
1436
- var require_range = __commonJS({
1437
- "node_modules/semver/classes/range.js"(exports2, module2) {
1438
- var Range = class _Range {
1439
- constructor(range, options) {
1440
- options = parseOptions(options);
1441
- if (range instanceof _Range) {
1442
- if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
1443
- return range;
1444
- } else {
1445
- return new _Range(range.raw, options);
1446
- }
1447
- }
1448
- if (range instanceof Comparator) {
1449
- this.raw = range.value;
1450
- this.set = [[range]];
1451
- this.format();
1452
- return this;
1453
- }
1454
- this.options = options;
1455
- this.loose = !!options.loose;
1456
- this.includePrerelease = !!options.includePrerelease;
1457
- this.raw = range.trim().split(/\s+/).join(" ");
1458
- this.set = this.raw.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length);
1459
- if (!this.set.length) {
1460
- throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
1461
- }
1462
- if (this.set.length > 1) {
1463
- const first = this.set[0];
1464
- this.set = this.set.filter((c) => !isNullSet(c[0]));
1465
- if (this.set.length === 0) {
1466
- this.set = [first];
1467
- } else if (this.set.length > 1) {
1468
- for (const c of this.set) {
1469
- if (c.length === 1 && isAny(c[0])) {
1470
- this.set = [c];
1471
- break;
1472
- }
1473
- }
1474
- }
1475
- }
1476
- this.format();
1477
- }
1478
- format() {
1479
- this.range = this.set.map((comps) => comps.join(" ").trim()).join("||").trim();
1480
- return this.range;
1481
- }
1482
- toString() {
1483
- return this.range;
1484
- }
1485
- parseRange(range) {
1486
- const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE);
1487
- const memoKey = memoOpts + ":" + range;
1488
- const cached = cache.get(memoKey);
1489
- if (cached) {
1490
- return cached;
1491
- }
1492
- const loose = this.options.loose;
1493
- const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
1494
- range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
1495
- debug("hyphen replace", range);
1496
- range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
1497
- debug("comparator trim", range);
1498
- range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
1499
- debug("tilde trim", range);
1500
- range = range.replace(re[t.CARETTRIM], caretTrimReplace);
1501
- debug("caret trim", range);
1502
- let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
1503
- if (loose) {
1504
- rangeList = rangeList.filter((comp) => {
1505
- debug("loose invalid filter", comp, this.options);
1506
- return !!comp.match(re[t.COMPARATORLOOSE]);
1507
- });
1508
- }
1509
- debug("range list", rangeList);
1510
- const rangeMap = /* @__PURE__ */ new Map();
1511
- const comparators = rangeList.map((comp) => new Comparator(comp, this.options));
1512
- for (const comp of comparators) {
1513
- if (isNullSet(comp)) {
1514
- return [comp];
1515
- }
1516
- rangeMap.set(comp.value, comp);
1517
- }
1518
- if (rangeMap.size > 1 && rangeMap.has("")) {
1519
- rangeMap.delete("");
1520
- }
1521
- const result = [...rangeMap.values()];
1522
- cache.set(memoKey, result);
1523
- return result;
1524
- }
1525
- intersects(range, options) {
1526
- if (!(range instanceof _Range)) {
1527
- throw new TypeError("a Range is required");
1528
- }
1529
- return this.set.some((thisComparators) => {
1530
- return isSatisfiable(thisComparators, options) && range.set.some((rangeComparators) => {
1531
- return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => {
1532
- return rangeComparators.every((rangeComparator) => {
1533
- return thisComparator.intersects(rangeComparator, options);
1534
- });
1535
- });
1536
- });
1537
- });
1538
- }
1539
- // if ANY of the sets match ALL of its comparators, then pass
1540
- test(version) {
1541
- if (!version) {
1542
- return false;
1543
- }
1544
- if (typeof version === "string") {
1545
- try {
1546
- version = new SemVer(version, this.options);
1547
- } catch (er) {
1548
- return false;
1549
- }
1550
- }
1551
- for (let i = 0; i < this.set.length; i++) {
1552
- if (testSet(this.set[i], version, this.options)) {
1553
- return true;
1554
- }
1555
- }
1556
- return false;
1557
- }
1558
- };
1559
- module2.exports = Range;
1560
- var LRU = require_lru_cache();
1561
- var cache = new LRU({ max: 1e3 });
1562
- var parseOptions = require_parse_options();
1563
- var Comparator = require_comparator();
1564
- var debug = require_debug();
1565
- var SemVer = require_semver();
1566
- var {
1567
- safeRe: re,
1568
- t,
1569
- comparatorTrimReplace,
1570
- tildeTrimReplace,
1571
- caretTrimReplace
1572
- } = require_re();
1573
- var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants();
1574
- var isNullSet = (c) => c.value === "<0.0.0-0";
1575
- var isAny = (c) => c.value === "";
1576
- var isSatisfiable = (comparators, options) => {
1577
- let result = true;
1578
- const remainingComparators = comparators.slice();
1579
- let testComparator = remainingComparators.pop();
1580
- while (result && remainingComparators.length) {
1581
- result = remainingComparators.every((otherComparator) => {
1582
- return testComparator.intersects(otherComparator, options);
1583
- });
1584
- testComparator = remainingComparators.pop();
1585
- }
1586
- return result;
1587
- };
1588
- var parseComparator = (comp, options) => {
1589
- debug("comp", comp, options);
1590
- comp = replaceCarets(comp, options);
1591
- debug("caret", comp);
1592
- comp = replaceTildes(comp, options);
1593
- debug("tildes", comp);
1594
- comp = replaceXRanges(comp, options);
1595
- debug("xrange", comp);
1596
- comp = replaceStars(comp, options);
1597
- debug("stars", comp);
1598
- return comp;
1599
- };
1600
- var isX = (id) => !id || id.toLowerCase() === "x" || id === "*";
1601
- var replaceTildes = (comp, options) => {
1602
- return comp.trim().split(/\s+/).map((c) => replaceTilde(c, options)).join(" ");
1603
- };
1604
- var replaceTilde = (comp, options) => {
1605
- const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
1606
- return comp.replace(r, (_, M, m, p, pr) => {
1607
- debug("tilde", comp, _, M, m, p, pr);
1608
- let ret;
1609
- if (isX(M)) {
1610
- ret = "";
1611
- } else if (isX(m)) {
1612
- ret = `>=${M}.0.0 <${+M + 1}.0.0-0`;
1613
- } else if (isX(p)) {
1614
- ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`;
1615
- } else if (pr) {
1616
- debug("replaceTilde pr", pr);
1617
- ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
1618
- } else {
1619
- ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
1620
- }
1621
- debug("tilde return", ret);
1622
- return ret;
1623
- });
1624
- };
1625
- var replaceCarets = (comp, options) => {
1626
- return comp.trim().split(/\s+/).map((c) => replaceCaret(c, options)).join(" ");
1627
- };
1628
- var replaceCaret = (comp, options) => {
1629
- debug("caret", comp, options);
1630
- const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
1631
- const z = options.includePrerelease ? "-0" : "";
1632
- return comp.replace(r, (_, M, m, p, pr) => {
1633
- debug("caret", comp, _, M, m, p, pr);
1634
- let ret;
1635
- if (isX(M)) {
1636
- ret = "";
1637
- } else if (isX(m)) {
1638
- ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
1639
- } else if (isX(p)) {
1640
- if (M === "0") {
1641
- ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
1642
- } else {
1643
- ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
1644
- }
1645
- } else if (pr) {
1646
- debug("replaceCaret pr", pr);
1647
- if (M === "0") {
1648
- if (m === "0") {
1649
- ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`;
1650
- } else {
1651
- ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
1652
- }
1653
- } else {
1654
- ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`;
1655
- }
1656
- } else {
1657
- debug("no pr");
1658
- if (M === "0") {
1659
- if (m === "0") {
1660
- ret = `>=${M}.${m}.${p}${z} <${M}.${m}.${+p + 1}-0`;
1661
- } else {
1662
- ret = `>=${M}.${m}.${p}${z} <${M}.${+m + 1}.0-0`;
1663
- }
1664
- } else {
1665
- ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
1666
- }
1667
- }
1668
- debug("caret return", ret);
1669
- return ret;
1670
- });
1671
- };
1672
- var replaceXRanges = (comp, options) => {
1673
- debug("replaceXRanges", comp, options);
1674
- return comp.split(/\s+/).map((c) => replaceXRange(c, options)).join(" ");
1675
- };
1676
- var replaceXRange = (comp, options) => {
1677
- comp = comp.trim();
1678
- const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
1679
- return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
1680
- debug("xRange", comp, ret, gtlt, M, m, p, pr);
1681
- const xM = isX(M);
1682
- const xm = xM || isX(m);
1683
- const xp = xm || isX(p);
1684
- const anyX = xp;
1685
- if (gtlt === "=" && anyX) {
1686
- gtlt = "";
1687
- }
1688
- pr = options.includePrerelease ? "-0" : "";
1689
- if (xM) {
1690
- if (gtlt === ">" || gtlt === "<") {
1691
- ret = "<0.0.0-0";
1692
- } else {
1693
- ret = "*";
1694
- }
1695
- } else if (gtlt && anyX) {
1696
- if (xm) {
1697
- m = 0;
1698
- }
1699
- p = 0;
1700
- if (gtlt === ">") {
1701
- gtlt = ">=";
1702
- if (xm) {
1703
- M = +M + 1;
1704
- m = 0;
1705
- p = 0;
1706
- } else {
1707
- m = +m + 1;
1708
- p = 0;
1709
- }
1710
- } else if (gtlt === "<=") {
1711
- gtlt = "<";
1712
- if (xm) {
1713
- M = +M + 1;
1714
- } else {
1715
- m = +m + 1;
1716
- }
1717
- }
1718
- if (gtlt === "<") {
1719
- pr = "-0";
1720
- }
1721
- ret = `${gtlt + M}.${m}.${p}${pr}`;
1722
- } else if (xm) {
1723
- ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
1724
- } else if (xp) {
1725
- ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`;
1726
- }
1727
- debug("xRange return", ret);
1728
- return ret;
1729
- });
1730
- };
1731
- var replaceStars = (comp, options) => {
1732
- debug("replaceStars", comp, options);
1733
- return comp.trim().replace(re[t.STAR], "");
1734
- };
1735
- var replaceGTE0 = (comp, options) => {
1736
- debug("replaceGTE0", comp, options);
1737
- return comp.trim().replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], "");
1738
- };
1739
- var hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb) => {
1740
- if (isX(fM)) {
1741
- from = "";
1742
- } else if (isX(fm)) {
1743
- from = `>=${fM}.0.0${incPr ? "-0" : ""}`;
1744
- } else if (isX(fp)) {
1745
- from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`;
1746
- } else if (fpr) {
1747
- from = `>=${from}`;
1748
- } else {
1749
- from = `>=${from}${incPr ? "-0" : ""}`;
1750
- }
1751
- if (isX(tM)) {
1752
- to = "";
1753
- } else if (isX(tm)) {
1754
- to = `<${+tM + 1}.0.0-0`;
1755
- } else if (isX(tp)) {
1756
- to = `<${tM}.${+tm + 1}.0-0`;
1757
- } else if (tpr) {
1758
- to = `<=${tM}.${tm}.${tp}-${tpr}`;
1759
- } else if (incPr) {
1760
- to = `<${tM}.${tm}.${+tp + 1}-0`;
1761
- } else {
1762
- to = `<=${to}`;
1763
- }
1764
- return `${from} ${to}`.trim();
1765
- };
1766
- var testSet = (set, version, options) => {
1767
- for (let i = 0; i < set.length; i++) {
1768
- if (!set[i].test(version)) {
1769
- return false;
1770
- }
1771
- }
1772
- if (version.prerelease.length && !options.includePrerelease) {
1773
- for (let i = 0; i < set.length; i++) {
1774
- debug(set[i].semver);
1775
- if (set[i].semver === Comparator.ANY) {
1776
- continue;
1777
- }
1778
- if (set[i].semver.prerelease.length > 0) {
1779
- const allowed = set[i].semver;
1780
- if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) {
1781
- return true;
1782
- }
1783
- }
1784
- }
1785
- return false;
1786
- }
1787
- return true;
1788
- };
1789
- }
1790
- });
1791
-
1792
- // node_modules/semver/classes/comparator.js
1793
- var require_comparator = __commonJS({
1794
- "node_modules/semver/classes/comparator.js"(exports2, module2) {
1795
- var ANY = Symbol("SemVer ANY");
1796
- var Comparator = class _Comparator {
1797
- static get ANY() {
1798
- return ANY;
1799
- }
1800
- constructor(comp, options) {
1801
- options = parseOptions(options);
1802
- if (comp instanceof _Comparator) {
1803
- if (comp.loose === !!options.loose) {
1804
- return comp;
1805
- } else {
1806
- comp = comp.value;
1807
- }
1808
- }
1809
- comp = comp.trim().split(/\s+/).join(" ");
1810
- debug("comparator", comp, options);
1811
- this.options = options;
1812
- this.loose = !!options.loose;
1813
- this.parse(comp);
1814
- if (this.semver === ANY) {
1815
- this.value = "";
1816
- } else {
1817
- this.value = this.operator + this.semver.version;
1818
- }
1819
- debug("comp", this);
1820
- }
1821
- parse(comp) {
1822
- const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
1823
- const m = comp.match(r);
1824
- if (!m) {
1825
- throw new TypeError(`Invalid comparator: ${comp}`);
1826
- }
1827
- this.operator = m[1] !== void 0 ? m[1] : "";
1828
- if (this.operator === "=") {
1829
- this.operator = "";
1830
- }
1831
- if (!m[2]) {
1832
- this.semver = ANY;
1833
- } else {
1834
- this.semver = new SemVer(m[2], this.options.loose);
1835
- }
1836
- }
1837
- toString() {
1838
- return this.value;
1839
- }
1840
- test(version) {
1841
- debug("Comparator.test", version, this.options.loose);
1842
- if (this.semver === ANY || version === ANY) {
1843
- return true;
1844
- }
1845
- if (typeof version === "string") {
1846
- try {
1847
- version = new SemVer(version, this.options);
1848
- } catch (er) {
1849
- return false;
1850
- }
1851
- }
1852
- return cmp(version, this.operator, this.semver, this.options);
1853
- }
1854
- intersects(comp, options) {
1855
- if (!(comp instanceof _Comparator)) {
1856
- throw new TypeError("a Comparator is required");
1857
- }
1858
- if (this.operator === "") {
1859
- if (this.value === "") {
1860
- return true;
1861
- }
1862
- return new Range(comp.value, options).test(this.value);
1863
- } else if (comp.operator === "") {
1864
- if (comp.value === "") {
1865
- return true;
1866
- }
1867
- return new Range(this.value, options).test(comp.semver);
1868
- }
1869
- options = parseOptions(options);
1870
- if (options.includePrerelease && (this.value === "<0.0.0-0" || comp.value === "<0.0.0-0")) {
1871
- return false;
1872
- }
1873
- if (!options.includePrerelease && (this.value.startsWith("<0.0.0") || comp.value.startsWith("<0.0.0"))) {
1874
- return false;
1875
- }
1876
- if (this.operator.startsWith(">") && comp.operator.startsWith(">")) {
1877
- return true;
1878
- }
1879
- if (this.operator.startsWith("<") && comp.operator.startsWith("<")) {
1880
- return true;
1881
- }
1882
- if (this.semver.version === comp.semver.version && this.operator.includes("=") && comp.operator.includes("=")) {
1883
- return true;
1884
- }
1885
- if (cmp(this.semver, "<", comp.semver, options) && this.operator.startsWith(">") && comp.operator.startsWith("<")) {
1886
- return true;
1887
- }
1888
- if (cmp(this.semver, ">", comp.semver, options) && this.operator.startsWith("<") && comp.operator.startsWith(">")) {
1889
- return true;
1890
- }
1891
- return false;
1892
- }
1893
- };
1894
- module2.exports = Comparator;
1895
- var parseOptions = require_parse_options();
1896
- var { safeRe: re, t } = require_re();
1897
- var cmp = require_cmp();
1898
- var debug = require_debug();
1899
- var SemVer = require_semver();
1900
- var Range = require_range();
1901
- }
1902
- });
1903
-
1904
- // node_modules/semver/functions/satisfies.js
1905
- var require_satisfies = __commonJS({
1906
- "node_modules/semver/functions/satisfies.js"(exports2, module2) {
1907
- var Range = require_range();
1908
- var satisfies2 = (version, range, options) => {
1909
- try {
1910
- range = new Range(range, options);
1911
- } catch (er) {
1912
- return false;
1913
- }
1914
- return range.test(version);
1915
- };
1916
- module2.exports = satisfies2;
1917
- }
1918
- });
1919
-
1920
- // node_modules/semver/ranges/to-comparators.js
1921
- var require_to_comparators = __commonJS({
1922
- "node_modules/semver/ranges/to-comparators.js"(exports2, module2) {
1923
- var Range = require_range();
1924
- var toComparators = (range, options) => new Range(range, options).set.map((comp) => comp.map((c) => c.value).join(" ").trim().split(" "));
1925
- module2.exports = toComparators;
1926
- }
1927
- });
1928
-
1929
- // node_modules/semver/ranges/max-satisfying.js
1930
- var require_max_satisfying = __commonJS({
1931
- "node_modules/semver/ranges/max-satisfying.js"(exports2, module2) {
1932
- var SemVer = require_semver();
1933
- var Range = require_range();
1934
- var maxSatisfying = (versions, range, options) => {
1935
- let max = null;
1936
- let maxSV = null;
1937
- let rangeObj = null;
1938
- try {
1939
- rangeObj = new Range(range, options);
1940
- } catch (er) {
1941
- return null;
1942
- }
1943
- versions.forEach((v) => {
1944
- if (rangeObj.test(v)) {
1945
- if (!max || maxSV.compare(v) === -1) {
1946
- max = v;
1947
- maxSV = new SemVer(max, options);
1948
- }
1949
- }
1950
- });
1951
- return max;
1952
- };
1953
- module2.exports = maxSatisfying;
1954
- }
1955
- });
1956
-
1957
- // node_modules/semver/ranges/min-satisfying.js
1958
- var require_min_satisfying = __commonJS({
1959
- "node_modules/semver/ranges/min-satisfying.js"(exports2, module2) {
1960
- var SemVer = require_semver();
1961
- var Range = require_range();
1962
- var minSatisfying = (versions, range, options) => {
1963
- let min = null;
1964
- let minSV = null;
1965
- let rangeObj = null;
1966
- try {
1967
- rangeObj = new Range(range, options);
1968
- } catch (er) {
1969
- return null;
1970
- }
1971
- versions.forEach((v) => {
1972
- if (rangeObj.test(v)) {
1973
- if (!min || minSV.compare(v) === 1) {
1974
- min = v;
1975
- minSV = new SemVer(min, options);
1976
- }
1977
- }
1978
- });
1979
- return min;
1980
- };
1981
- module2.exports = minSatisfying;
1982
- }
1983
- });
1984
-
1985
- // node_modules/semver/ranges/min-version.js
1986
- var require_min_version = __commonJS({
1987
- "node_modules/semver/ranges/min-version.js"(exports2, module2) {
1988
- var SemVer = require_semver();
1989
- var Range = require_range();
1990
- var gt = require_gt();
1991
- var minVersion = (range, loose) => {
1992
- range = new Range(range, loose);
1993
- let minver = new SemVer("0.0.0");
1994
- if (range.test(minver)) {
1995
- return minver;
1996
- }
1997
- minver = new SemVer("0.0.0-0");
1998
- if (range.test(minver)) {
1999
- return minver;
2000
- }
2001
- minver = null;
2002
- for (let i = 0; i < range.set.length; ++i) {
2003
- const comparators = range.set[i];
2004
- let setMin = null;
2005
- comparators.forEach((comparator) => {
2006
- const compver = new SemVer(comparator.semver.version);
2007
- switch (comparator.operator) {
2008
- case ">":
2009
- if (compver.prerelease.length === 0) {
2010
- compver.patch++;
2011
- } else {
2012
- compver.prerelease.push(0);
2013
- }
2014
- compver.raw = compver.format();
2015
- case "":
2016
- case ">=":
2017
- if (!setMin || gt(compver, setMin)) {
2018
- setMin = compver;
2019
- }
2020
- break;
2021
- case "<":
2022
- case "<=":
2023
- break;
2024
- default:
2025
- throw new Error(`Unexpected operation: ${comparator.operator}`);
2026
- }
2027
- });
2028
- if (setMin && (!minver || gt(minver, setMin))) {
2029
- minver = setMin;
2030
- }
2031
- }
2032
- if (minver && range.test(minver)) {
2033
- return minver;
2034
- }
2035
- return null;
2036
- };
2037
- module2.exports = minVersion;
2038
- }
2039
- });
2040
-
2041
- // node_modules/semver/ranges/valid.js
2042
- var require_valid2 = __commonJS({
2043
- "node_modules/semver/ranges/valid.js"(exports2, module2) {
2044
- var Range = require_range();
2045
- var validRange = (range, options) => {
2046
- try {
2047
- return new Range(range, options).range || "*";
2048
- } catch (er) {
2049
- return null;
2050
- }
2051
- };
2052
- module2.exports = validRange;
2053
- }
2054
- });
2055
-
2056
- // node_modules/semver/ranges/outside.js
2057
- var require_outside = __commonJS({
2058
- "node_modules/semver/ranges/outside.js"(exports2, module2) {
2059
- var SemVer = require_semver();
2060
- var Comparator = require_comparator();
2061
- var { ANY } = Comparator;
2062
- var Range = require_range();
2063
- var satisfies2 = require_satisfies();
2064
- var gt = require_gt();
2065
- var lt = require_lt();
2066
- var lte = require_lte();
2067
- var gte = require_gte();
2068
- var outside = (version, range, hilo, options) => {
2069
- version = new SemVer(version, options);
2070
- range = new Range(range, options);
2071
- let gtfn, ltefn, ltfn, comp, ecomp;
2072
- switch (hilo) {
2073
- case ">":
2074
- gtfn = gt;
2075
- ltefn = lte;
2076
- ltfn = lt;
2077
- comp = ">";
2078
- ecomp = ">=";
2079
- break;
2080
- case "<":
2081
- gtfn = lt;
2082
- ltefn = gte;
2083
- ltfn = gt;
2084
- comp = "<";
2085
- ecomp = "<=";
2086
- break;
2087
- default:
2088
- throw new TypeError('Must provide a hilo val of "<" or ">"');
2089
- }
2090
- if (satisfies2(version, range, options)) {
2091
- return false;
2092
- }
2093
- for (let i = 0; i < range.set.length; ++i) {
2094
- const comparators = range.set[i];
2095
- let high = null;
2096
- let low = null;
2097
- comparators.forEach((comparator) => {
2098
- if (comparator.semver === ANY) {
2099
- comparator = new Comparator(">=0.0.0");
2100
- }
2101
- high = high || comparator;
2102
- low = low || comparator;
2103
- if (gtfn(comparator.semver, high.semver, options)) {
2104
- high = comparator;
2105
- } else if (ltfn(comparator.semver, low.semver, options)) {
2106
- low = comparator;
2107
- }
2108
- });
2109
- if (high.operator === comp || high.operator === ecomp) {
2110
- return false;
2111
- }
2112
- if ((!low.operator || low.operator === comp) && ltefn(version, low.semver)) {
2113
- return false;
2114
- } else if (low.operator === ecomp && ltfn(version, low.semver)) {
2115
- return false;
2116
- }
2117
- }
2118
- return true;
2119
- };
2120
- module2.exports = outside;
2121
- }
2122
- });
2123
-
2124
- // node_modules/semver/ranges/gtr.js
2125
- var require_gtr = __commonJS({
2126
- "node_modules/semver/ranges/gtr.js"(exports2, module2) {
2127
- var outside = require_outside();
2128
- var gtr = (version, range, options) => outside(version, range, ">", options);
2129
- module2.exports = gtr;
2130
- }
2131
- });
2132
-
2133
- // node_modules/semver/ranges/ltr.js
2134
- var require_ltr = __commonJS({
2135
- "node_modules/semver/ranges/ltr.js"(exports2, module2) {
2136
- var outside = require_outside();
2137
- var ltr = (version, range, options) => outside(version, range, "<", options);
2138
- module2.exports = ltr;
2139
- }
2140
- });
2141
-
2142
- // node_modules/semver/ranges/intersects.js
2143
- var require_intersects = __commonJS({
2144
- "node_modules/semver/ranges/intersects.js"(exports2, module2) {
2145
- var Range = require_range();
2146
- var intersects = (r1, r2, options) => {
2147
- r1 = new Range(r1, options);
2148
- r2 = new Range(r2, options);
2149
- return r1.intersects(r2, options);
2150
- };
2151
- module2.exports = intersects;
2152
- }
2153
- });
2154
-
2155
- // node_modules/semver/ranges/simplify.js
2156
- var require_simplify = __commonJS({
2157
- "node_modules/semver/ranges/simplify.js"(exports2, module2) {
2158
- var satisfies2 = require_satisfies();
2159
- var compare = require_compare();
2160
- module2.exports = (versions, range, options) => {
2161
- const set = [];
2162
- let first = null;
2163
- let prev = null;
2164
- const v = versions.sort((a, b) => compare(a, b, options));
2165
- for (const version of v) {
2166
- const included = satisfies2(version, range, options);
2167
- if (included) {
2168
- prev = version;
2169
- if (!first) {
2170
- first = version;
2171
- }
2172
- } else {
2173
- if (prev) {
2174
- set.push([first, prev]);
2175
- }
2176
- prev = null;
2177
- first = null;
2178
- }
2179
- }
2180
- if (first) {
2181
- set.push([first, null]);
2182
- }
2183
- const ranges = [];
2184
- for (const [min, max] of set) {
2185
- if (min === max) {
2186
- ranges.push(min);
2187
- } else if (!max && min === v[0]) {
2188
- ranges.push("*");
2189
- } else if (!max) {
2190
- ranges.push(`>=${min}`);
2191
- } else if (min === v[0]) {
2192
- ranges.push(`<=${max}`);
2193
- } else {
2194
- ranges.push(`${min} - ${max}`);
2195
- }
2196
- }
2197
- const simplified = ranges.join(" || ");
2198
- const original = typeof range.raw === "string" ? range.raw : String(range);
2199
- return simplified.length < original.length ? simplified : range;
2200
- };
2201
- }
2202
- });
2203
-
2204
- // node_modules/semver/ranges/subset.js
2205
- var require_subset = __commonJS({
2206
- "node_modules/semver/ranges/subset.js"(exports2, module2) {
2207
- var Range = require_range();
2208
- var Comparator = require_comparator();
2209
- var { ANY } = Comparator;
2210
- var satisfies2 = require_satisfies();
2211
- var compare = require_compare();
2212
- var subset = (sub, dom, options = {}) => {
2213
- if (sub === dom) {
2214
- return true;
2215
- }
2216
- sub = new Range(sub, options);
2217
- dom = new Range(dom, options);
2218
- let sawNonNull = false;
2219
- OUTER:
2220
- for (const simpleSub of sub.set) {
2221
- for (const simpleDom of dom.set) {
2222
- const isSub = simpleSubset(simpleSub, simpleDom, options);
2223
- sawNonNull = sawNonNull || isSub !== null;
2224
- if (isSub) {
2225
- continue OUTER;
2226
- }
2227
- }
2228
- if (sawNonNull) {
2229
- return false;
2230
- }
2231
- }
2232
- return true;
2233
- };
2234
- var minimumVersionWithPreRelease = [new Comparator(">=0.0.0-0")];
2235
- var minimumVersion = [new Comparator(">=0.0.0")];
2236
- var simpleSubset = (sub, dom, options) => {
2237
- if (sub === dom) {
2238
- return true;
2239
- }
2240
- if (sub.length === 1 && sub[0].semver === ANY) {
2241
- if (dom.length === 1 && dom[0].semver === ANY) {
2242
- return true;
2243
- } else if (options.includePrerelease) {
2244
- sub = minimumVersionWithPreRelease;
2245
- } else {
2246
- sub = minimumVersion;
2247
- }
2248
- }
2249
- if (dom.length === 1 && dom[0].semver === ANY) {
2250
- if (options.includePrerelease) {
2251
- return true;
2252
- } else {
2253
- dom = minimumVersion;
2254
- }
2255
- }
2256
- const eqSet = /* @__PURE__ */ new Set();
2257
- let gt, lt;
2258
- for (const c of sub) {
2259
- if (c.operator === ">" || c.operator === ">=") {
2260
- gt = higherGT(gt, c, options);
2261
- } else if (c.operator === "<" || c.operator === "<=") {
2262
- lt = lowerLT(lt, c, options);
2263
- } else {
2264
- eqSet.add(c.semver);
2265
- }
2266
- }
2267
- if (eqSet.size > 1) {
2268
- return null;
2269
- }
2270
- let gtltComp;
2271
- if (gt && lt) {
2272
- gtltComp = compare(gt.semver, lt.semver, options);
2273
- if (gtltComp > 0) {
2274
- return null;
2275
- } else if (gtltComp === 0 && (gt.operator !== ">=" || lt.operator !== "<=")) {
2276
- return null;
2277
- }
2278
- }
2279
- for (const eq of eqSet) {
2280
- if (gt && !satisfies2(eq, String(gt), options)) {
2281
- return null;
2282
- }
2283
- if (lt && !satisfies2(eq, String(lt), options)) {
2284
- return null;
2285
- }
2286
- for (const c of dom) {
2287
- if (!satisfies2(eq, String(c), options)) {
2288
- return false;
2289
- }
2290
- }
2291
- return true;
2292
- }
2293
- let higher, lower;
2294
- let hasDomLT, hasDomGT;
2295
- let needDomLTPre = lt && !options.includePrerelease && lt.semver.prerelease.length ? lt.semver : false;
2296
- let needDomGTPre = gt && !options.includePrerelease && gt.semver.prerelease.length ? gt.semver : false;
2297
- if (needDomLTPre && needDomLTPre.prerelease.length === 1 && lt.operator === "<" && needDomLTPre.prerelease[0] === 0) {
2298
- needDomLTPre = false;
2299
- }
2300
- for (const c of dom) {
2301
- hasDomGT = hasDomGT || c.operator === ">" || c.operator === ">=";
2302
- hasDomLT = hasDomLT || c.operator === "<" || c.operator === "<=";
2303
- if (gt) {
2304
- if (needDomGTPre) {
2305
- if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomGTPre.major && c.semver.minor === needDomGTPre.minor && c.semver.patch === needDomGTPre.patch) {
2306
- needDomGTPre = false;
2307
- }
2308
- }
2309
- if (c.operator === ">" || c.operator === ">=") {
2310
- higher = higherGT(gt, c, options);
2311
- if (higher === c && higher !== gt) {
2312
- return false;
2313
- }
2314
- } else if (gt.operator === ">=" && !satisfies2(gt.semver, String(c), options)) {
2315
- return false;
2316
- }
2317
- }
2318
- if (lt) {
2319
- if (needDomLTPre) {
2320
- if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomLTPre.major && c.semver.minor === needDomLTPre.minor && c.semver.patch === needDomLTPre.patch) {
2321
- needDomLTPre = false;
2322
- }
2323
- }
2324
- if (c.operator === "<" || c.operator === "<=") {
2325
- lower = lowerLT(lt, c, options);
2326
- if (lower === c && lower !== lt) {
2327
- return false;
2328
- }
2329
- } else if (lt.operator === "<=" && !satisfies2(lt.semver, String(c), options)) {
2330
- return false;
2331
- }
2332
- }
2333
- if (!c.operator && (lt || gt) && gtltComp !== 0) {
2334
- return false;
2335
- }
2336
- }
2337
- if (gt && hasDomLT && !lt && gtltComp !== 0) {
2338
- return false;
2339
- }
2340
- if (lt && hasDomGT && !gt && gtltComp !== 0) {
2341
- return false;
2342
- }
2343
- if (needDomGTPre || needDomLTPre) {
2344
- return false;
2345
- }
2346
- return true;
2347
- };
2348
- var higherGT = (a, b, options) => {
2349
- if (!a) {
2350
- return b;
2351
- }
2352
- const comp = compare(a.semver, b.semver, options);
2353
- return comp > 0 ? a : comp < 0 ? b : b.operator === ">" && a.operator === ">=" ? b : a;
2354
- };
2355
- var lowerLT = (a, b, options) => {
2356
- if (!a) {
2357
- return b;
2358
- }
2359
- const comp = compare(a.semver, b.semver, options);
2360
- return comp < 0 ? a : comp > 0 ? b : b.operator === "<" && a.operator === "<=" ? b : a;
2361
- };
2362
- module2.exports = subset;
2363
- }
2364
- });
2365
-
2366
- // node_modules/semver/index.js
2367
- var require_semver2 = __commonJS({
2368
- "node_modules/semver/index.js"(exports2, module2) {
2369
- var internalRe = require_re();
2370
- var constants = require_constants();
2371
- var SemVer = require_semver();
2372
- var identifiers = require_identifiers();
2373
- var parse = require_parse();
2374
- var valid = require_valid();
2375
- var clean = require_clean();
2376
- var inc = require_inc();
2377
- var diff = require_diff();
2378
- var major = require_major();
2379
- var minor = require_minor();
2380
- var patch = require_patch();
2381
- var prerelease = require_prerelease();
2382
- var compare = require_compare();
2383
- var rcompare = require_rcompare();
2384
- var compareLoose = require_compare_loose();
2385
- var compareBuild = require_compare_build();
2386
- var sort = require_sort();
2387
- var rsort = require_rsort();
2388
- var gt = require_gt();
2389
- var lt = require_lt();
2390
- var eq = require_eq();
2391
- var neq = require_neq();
2392
- var gte = require_gte();
2393
- var lte = require_lte();
2394
- var cmp = require_cmp();
2395
- var coerce = require_coerce();
2396
- var Comparator = require_comparator();
2397
- var Range = require_range();
2398
- var satisfies2 = require_satisfies();
2399
- var toComparators = require_to_comparators();
2400
- var maxSatisfying = require_max_satisfying();
2401
- var minSatisfying = require_min_satisfying();
2402
- var minVersion = require_min_version();
2403
- var validRange = require_valid2();
2404
- var outside = require_outside();
2405
- var gtr = require_gtr();
2406
- var ltr = require_ltr();
2407
- var intersects = require_intersects();
2408
- var simplifyRange = require_simplify();
2409
- var subset = require_subset();
2410
- module2.exports = {
2411
- parse,
2412
- valid,
2413
- clean,
2414
- inc,
2415
- diff,
2416
- major,
2417
- minor,
2418
- patch,
2419
- prerelease,
2420
- compare,
2421
- rcompare,
2422
- compareLoose,
2423
- compareBuild,
2424
- sort,
2425
- rsort,
2426
- gt,
2427
- lt,
2428
- eq,
2429
- neq,
2430
- gte,
2431
- lte,
2432
- cmp,
2433
- coerce,
2434
- Comparator,
2435
- Range,
2436
- satisfies: satisfies2,
2437
- toComparators,
2438
- maxSatisfying,
2439
- minSatisfying,
2440
- minVersion,
2441
- validRange,
2442
- outside,
2443
- gtr,
2444
- ltr,
2445
- intersects,
2446
- simplifyRange,
2447
- subset,
2448
- SemVer,
2449
- re: internalRe.re,
2450
- src: internalRe.src,
2451
- tokens: internalRe.t,
2452
- SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,
2453
- RELEASE_TYPES: constants.RELEASE_TYPES,
2454
- compareIdentifiers: identifiers.compareIdentifiers,
2455
- rcompareIdentifiers: identifiers.rcompareIdentifiers
2456
- };
2457
- }
2458
- });
25
+ // src/index.ts
26
+ var import_html_validate6 = require("html-validate");
2459
27
 
2460
28
  // src/configs/recommended.ts
2461
29
  var import_path = __toESM(require("path"));
2462
- var import_html_validate = require("html-validate");
2463
30
  var rootDir = import_path.default.dirname(require.resolve("html-validate-vue/package.json"));
2464
- function createConfig(options) {
31
+ function createConfig() {
2465
32
  const config = {
2466
33
  elements: [import_path.default.join(rootDir, "elements.json")],
2467
34
  rules: {
@@ -2476,26 +43,9 @@ function createConfig(options) {
2476
43
  "vue/required-slots": "error"
2477
44
  }
2478
45
  };
2479
- if (options.legacyVoid) {
2480
- config.rules.void = ["error", { style: "selfclose" }];
2481
- delete config.rules["void-style"];
2482
- delete config.rules["no-self-closing"];
2483
- }
2484
46
  return config;
2485
47
  }
2486
- function canResolve(pkg3) {
2487
- try {
2488
- require.resolve(pkg3);
2489
- return true;
2490
- } catch (err) {
2491
- return false;
2492
- }
2493
- }
2494
- var haveVoidContent = import_html_validate.ruleExists && (0, import_html_validate.ruleExists)("void-content") || canResolve("html-validate/build/rules/void-content") || canResolve("html-validate/dist/rules/void-content");
2495
- var useLegacyVoid = !haveVoidContent;
2496
- var recommended_default = createConfig({
2497
- legacyVoid: useLegacyVoid
2498
- });
48
+ var recommended_default = createConfig();
2499
49
 
2500
50
  // src/configs/index.ts
2501
51
  var configs_default = {
@@ -2503,7 +53,7 @@ var configs_default = {
2503
53
  };
2504
54
 
2505
55
  // src/rules/available-slots.ts
2506
- var import_html_validate2 = require("html-validate");
56
+ var import_html_validate = require("html-validate");
2507
57
 
2508
58
  // src/utils/strip-templating.ts
2509
59
  function stripTemplating(str) {
@@ -2515,9 +65,12 @@ function stripTemplating(str) {
2515
65
 
2516
66
  // src/utils/slots.ts
2517
67
  var slotAttr = /(?:v-slot:|#)([^[]+)/;
68
+ function haveSlot(value) {
69
+ return value !== null;
70
+ }
2518
71
  function findUsedSlots(node) {
2519
72
  const template = node.querySelectorAll(">template, >[slot]");
2520
- const slots = template.map((child) => findSlotAttribute(child)).filter(Boolean);
73
+ const slots = template.map((child) => findSlotAttribute(child)).filter(haveSlot);
2521
74
  const initial = /* @__PURE__ */ new Map();
2522
75
  return slots.reduce((result, [key, val]) => {
2523
76
  result.set(key, val);
@@ -2531,7 +84,7 @@ function findSlotAttribute(node) {
2531
84
  const [, slot] = match;
2532
85
  return [slot, attr.keyLocation];
2533
86
  }
2534
- if (attr.key === "slot" && attr.isStatic) {
87
+ if (attr.key === "slot" && typeof attr.value === "string") {
2535
88
  return [attr.value.toString(), attr.valueLocation];
2536
89
  }
2537
90
  }
@@ -2546,7 +99,7 @@ function difference(a, b) {
2546
99
  }
2547
100
  return result;
2548
101
  }
2549
- var AvailableSlots = class extends import_html_validate2.Rule {
102
+ var AvailableSlots = class extends import_html_validate.Rule {
2550
103
  documentation(context) {
2551
104
  if (context) {
2552
105
  return {
@@ -2567,23 +120,23 @@ var AvailableSlots = class extends import_html_validate2.Rule {
2567
120
  const doc = event.document;
2568
121
  doc.visitDepthFirst((node) => {
2569
122
  const meta = node.meta;
2570
- if (!meta || !meta.slots)
123
+ if (!(meta == null ? void 0 : meta.slots)) {
2571
124
  return;
2572
- this.validateSlots(node);
125
+ }
126
+ this.validateSlots(node, meta.slots);
2573
127
  });
2574
128
  });
2575
129
  }
2576
- validateSlots(node) {
2577
- const meta = node.meta;
130
+ validateSlots(node, slots) {
2578
131
  const usedSlots = findUsedSlots(node);
2579
- const available = new Set(meta.slots);
132
+ const available = new Set(slots);
2580
133
  const used = new Set(usedSlots.keys());
2581
134
  const diff = difference(used, available);
2582
135
  for (const missing of diff) {
2583
136
  const context = {
2584
137
  element: node.tagName,
2585
138
  slot: missing,
2586
- available: meta.slots
139
+ available: slots
2587
140
  };
2588
141
  this.report(
2589
142
  node,
@@ -2596,7 +149,7 @@ var AvailableSlots = class extends import_html_validate2.Rule {
2596
149
  };
2597
150
 
2598
151
  // src/rules/prefer-slot-shorthand.ts
2599
- var import_html_validate3 = require("html-validate");
152
+ var import_html_validate2 = require("html-validate");
2600
153
  var prefix = "v-slot:";
2601
154
  function isVSlot(attr) {
2602
155
  if (!attr.startsWith(prefix)) {
@@ -2615,7 +168,7 @@ function isDeprecatedSlot(attr, value) {
2615
168
  if (attr !== "slot") {
2616
169
  return null;
2617
170
  }
2618
- if (value instanceof import_html_validate3.DynamicValue) {
171
+ if (value instanceof import_html_validate2.DynamicValue) {
2619
172
  return null;
2620
173
  }
2621
174
  if (value === null || value === "") {
@@ -2623,7 +176,7 @@ function isDeprecatedSlot(attr, value) {
2623
176
  }
2624
177
  return value.toString();
2625
178
  }
2626
- var PreferSlotShorthand = class extends import_html_validate3.Rule {
179
+ var PreferSlotShorthand = class extends import_html_validate2.Rule {
2627
180
  documentation(context) {
2628
181
  const slot = (context == null ? void 0 : context.slot) ?? "my-slot";
2629
182
  return {
@@ -2653,7 +206,7 @@ var PreferSlotShorthand = class extends import_html_validate3.Rule {
2653
206
  };
2654
207
 
2655
208
  // src/rules/required-slots.ts
2656
- var import_html_validate4 = require("html-validate");
209
+ var import_html_validate3 = require("html-validate");
2657
210
  function difference2(a, b) {
2658
211
  const result = new Set(a);
2659
212
  for (const elem of b) {
@@ -2661,7 +214,7 @@ function difference2(a, b) {
2661
214
  }
2662
215
  return result;
2663
216
  }
2664
- var RequiredSlots = class extends import_html_validate4.Rule {
217
+ var RequiredSlots = class extends import_html_validate3.Rule {
2665
218
  documentation(context) {
2666
219
  if (context) {
2667
220
  return {
@@ -2682,23 +235,23 @@ var RequiredSlots = class extends import_html_validate4.Rule {
2682
235
  const doc = event.document;
2683
236
  doc.visitDepthFirst((node) => {
2684
237
  const meta = node.meta;
2685
- if (!meta || !meta.requiredSlots)
238
+ if (!(meta == null ? void 0 : meta.requiredSlots)) {
2686
239
  return;
2687
- this.validateSlots(node);
240
+ }
241
+ this.validateSlots(node, meta.requiredSlots);
2688
242
  });
2689
243
  });
2690
244
  }
2691
- validateSlots(node) {
2692
- const meta = node.meta;
245
+ validateSlots(node, requiredSlots) {
2693
246
  const usedSlots = findUsedSlots(node);
2694
- const required = new Set(meta.requiredSlots);
247
+ const required = new Set(requiredSlots);
2695
248
  const used = new Set(usedSlots.keys());
2696
249
  const diff = difference2(required, used);
2697
250
  for (const missing of diff) {
2698
251
  const context = {
2699
252
  element: node.tagName,
2700
253
  slot: missing,
2701
- required: meta.requiredSlots
254
+ required: requiredSlots
2702
255
  };
2703
256
  this.report(
2704
257
  node,
@@ -2719,7 +272,7 @@ var rules = {
2719
272
  var rules_default = rules;
2720
273
 
2721
274
  // src/hooks/attribute.ts
2722
- var import_html_validate5 = require("html-validate");
275
+ var import_html_validate4 = require("html-validate");
2723
276
  function* processAttribute(attr) {
2724
277
  yield attr;
2725
278
  if (!attr.value) {
@@ -2729,23 +282,20 @@ function* processAttribute(attr) {
2729
282
  if (bind) {
2730
283
  yield Object.assign({}, attr, {
2731
284
  key: bind[1],
2732
- value: new import_html_validate5.DynamicValue(attr.value),
285
+ value: new import_html_validate4.DynamicValue(attr.value),
2733
286
  originalAttribute: attr.key
2734
287
  });
2735
288
  }
2736
289
  }
2737
290
 
2738
291
  // src/hooks/element.ts
2739
- var import_html_validate6 = require("html-validate");
292
+ var import_html_validate5 = require("html-validate");
2740
293
  function isBound(node) {
2741
294
  return node.hasAttribute("v-html");
2742
295
  }
2743
296
  function isSlot(node) {
2744
297
  return node.is("slot");
2745
298
  }
2746
- function haveGetMetaFor(context) {
2747
- return !!(context && context.getMetaFor);
2748
- }
2749
299
  function loadSlotMeta(context, slotname, node) {
2750
300
  const parent = node.parent;
2751
301
  if (!parent) {
@@ -2764,12 +314,12 @@ function loadSlotMeta(context, slotname, node) {
2764
314
  node.loadMeta(meta);
2765
315
  node.setAnnotation(`slot "${slotname}" (<${parent.tagName}>)`);
2766
316
  }
2767
- function loadComponentMeta(context, node) {
317
+ function loadComponentMeta(context, node, component) {
2768
318
  let src = node;
2769
- if (node.tagName === "template") {
319
+ if (node.tagName === "template" && src.parent) {
2770
320
  src = src.parent;
2771
321
  }
2772
- const attr = src.getAttribute(node.meta.component);
322
+ const attr = src.getAttribute(component);
2773
323
  if (!attr || attr.isDynamic) {
2774
324
  return;
2775
325
  }
@@ -2787,16 +337,17 @@ function loadComponentMeta(context, node) {
2787
337
  }
2788
338
  }
2789
339
  function processElement(node) {
340
+ var _a;
2790
341
  const slot = findSlotAttribute(node);
2791
- if (slot && haveGetMetaFor(this)) {
342
+ if (slot) {
2792
343
  const [slotname] = slot;
2793
344
  loadSlotMeta(this, slotname, node);
2794
345
  }
2795
- if (node.meta && node.meta.component) {
2796
- loadComponentMeta(this, node);
346
+ if ((_a = node.meta) == null ? void 0 : _a.component) {
347
+ loadComponentMeta(this, node, node.meta.component);
2797
348
  }
2798
349
  if (isBound(node) || isSlot(node)) {
2799
- node.appendText(new import_html_validate6.DynamicValue(""), node.location);
350
+ node.appendText(new import_html_validate5.DynamicValue(""), node.location);
2800
351
  }
2801
352
  }
2802
353
 
@@ -2817,7 +368,7 @@ var import_plugin_utils = require("@html-validate/plugin-utils");
2817
368
  function transformJS(source) {
2818
369
  const te = import_plugin_utils.TemplateExtractor.fromString(source.data, source.filename);
2819
370
  return Array.from(te.extractObjectProperty("template"), (cur) => {
2820
- cur.originalData = source.originalData || source.data;
371
+ cur.originalData = source.originalData ?? source.data;
2821
372
  cur.hooks = {
2822
373
  processAttribute,
2823
374
  processElement
@@ -2855,7 +406,7 @@ function* transformSFC(source) {
2855
406
  line: line + (source.line - 1),
2856
407
  column: column + (source.column - 1),
2857
408
  offset: match.index + (source.offset || 0) + preamble.length,
2858
- originalData: source.originalData || source.data,
409
+ originalData: source.originalData ?? source.data,
2859
410
  hooks: {
2860
411
  processAttribute,
2861
412
  processElement
@@ -2916,38 +467,12 @@ var schema_default = {
2916
467
  }
2917
468
  };
2918
469
 
2919
- // src/version-check.ts
2920
- var import_semver = __toESM(require_semver2());
2921
- var import_html_validate7 = require("html-validate");
2922
- var pkg = require("../package.json");
2923
- function doVersionCheck(peerDependency, version) {
2924
- const printVersion = version || "< 1.16.0";
2925
- if (!(0, import_semver.satisfies)(version || "0.0.0", peerDependency)) {
2926
- console.error(
2927
- [
2928
- "-----------------------------------------------------------------------------------------------------",
2929
- `${pkg.name} requires html-validate version "${peerDependency}" but current installed version is ${printVersion}`,
2930
- "This is not a supported configuration. Please install a supported version before reporting bugs.",
2931
- "-----------------------------------------------------------------------------------------------------"
2932
- ].join("\n")
2933
- );
2934
- }
2935
- }
2936
- function versionCheck() {
2937
- const range = pkg.peerDependencies["html-validate"];
2938
- if (import_html_validate7.compatibilityCheck) {
2939
- (0, import_html_validate7.compatibilityCheck)(pkg.name, range);
2940
- } else {
2941
- const version = import_html_validate7.version;
2942
- doVersionCheck(range, version);
2943
- }
2944
- }
2945
-
2946
470
  // src/index.ts
2947
- versionCheck();
2948
- var pkg2 = require("../package.json");
471
+ var pkg = require("../package.json");
472
+ var range = pkg.peerDependencies["html-validate"];
473
+ (0, import_html_validate6.compatibilityCheck)(pkg.name, range);
2949
474
  var plugin = {
2950
- name: pkg2.name,
475
+ name: pkg.name,
2951
476
  configs: configs_default,
2952
477
  rules: rules_default,
2953
478
  transformer: transform_default,