Debian Codegraph @

jridgewell-resolve-uri/test/resolve/with-absolute-path-base.test.js

raw
1 const resolve = require('../..');
2 const assert = require('assert');
3
4 describe('with absolute path base', () => {
5 describe(`base = "/"`, () => {
6 describe('with absolute input', () => {
7 it('returns input', () => {
8 const base = '/';
9 const input = 'https://absolute.com/main.js.map';
10 const resolved = resolve(input, base);
11 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
12 });
13
14 it('returns input with query', () => {
15 const base = '/';
16 const input = 'https://absolute.com/main.js.map?input';
17 const resolved = resolve(input, base);
18 assert.strictEqual(resolved, 'https://absolute.com/main.js.map?input');
19 });
20
21 it('normalizes input path', () => {
22 const base = '/';
23 const input = 'https://absolute.com/foo/./bar/../main.js.map';
24 const resolved = resolve(input, base);
25 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map');
26 });
27
28 it('normalizes input path with query', () => {
29 const base = '/';
30 const input = 'https://absolute.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
31 const resolved = resolve(input, base);
32 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map?input!webpack://foo/./bar');
33 });
34
35 it('normalizes pathless input', () => {
36 const base = '/';
37 const input = 'https://absolute.com';
38 const resolved = resolve(input, base);
39 assert.strictEqual(resolved, 'https://absolute.com/');
40 });
41
42 it('normalizes pathless input with query', () => {
43 const base = '/';
44 const input = 'https://absolute.com?input';
45 const resolved = resolve(input, base);
46 assert.strictEqual(resolved, 'https://absolute.com/?input');
47 });
48
49 it('normalizes current directory', () => {
50 const base = '/';
51 const input = 'https://absolute.com/./main.js.map';
52 const resolved = resolve(input, base);
53 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
54 });
55
56 it('normalizes too many parent accessors', () => {
57 const base = '/';
58 const input = 'https://absolute.com/../../../main.js.map';
59 const resolved = resolve(input, base);
60 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
61 });
62
63 it('normalizes too many parent accessors, late', () => {
64 const base = '/';
65 const input = 'https://absolute.com/foo/../../../main.js.map';
66 const resolved = resolve(input, base);
67 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
68 });
69
70 it('normalizes file protocol 1', () => {
71 const base = '/';
72 const input = 'file:///root/main.js.map';
73 const resolved = resolve(input, base);
74 assert.strictEqual(resolved, 'file:///root/main.js.map');
75 });
76
77 it('normalizes file protocol 2', () => {
78 const base = '/';
79 const input = 'file://root/main.js.map';
80 const resolved = resolve(input, base);
81 assert.strictEqual(resolved, 'file://root/main.js.map');
82 });
83
84 it('normalizes file protocol 2.5', () => {
85 const base = '/';
86 const input = 'file://root';
87 const resolved = resolve(input, base);
88 assert.strictEqual(resolved, 'file://root/');
89 });
90
91 it('normalizes file protocol 3', () => {
92 const base = '/';
93 const input = 'file:/root/main.js.map';
94 const resolved = resolve(input, base);
95 assert.strictEqual(resolved, 'file:///root/main.js.map');
96 });
97
98 it('normalizes file protocol 4', () => {
99 const base = '/';
100 const input = 'file:root/main.js.map';
101 const resolved = resolve(input, base);
102 assert.strictEqual(resolved, 'file:///root/main.js.map');
103 });
104
105 it('normalizes file protocol 1 with query', () => {
106 const base = '/';
107 const input = 'file:///root/main.js.map?input';
108 const resolved = resolve(input, base);
109 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
110 });
111
112 it('normalizes file protocol 2 with query', () => {
113 const base = '/';
114 const input = 'file://root/main.js.map?input';
115 const resolved = resolve(input, base);
116 assert.strictEqual(resolved, 'file://root/main.js.map?input');
117 });
118
119 it('normalizes file protocol 2.5 with query', () => {
120 const base = '/';
121 const input = 'file://root?input';
122 const resolved = resolve(input, base);
123 assert.strictEqual(resolved, 'file://root/?input');
124 });
125
126 it('normalizes file protocol 3 with query', () => {
127 const base = '/';
128 const input = 'file:/root/main.js.map?input';
129 const resolved = resolve(input, base);
130 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
131 });
132
133 it('normalizes file protocol 4 with query', () => {
134 const base = '/';
135 const input = 'file:root/main.js.map?input';
136 const resolved = resolve(input, base);
137 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
138 });
139 });
140
141 describe('with protocol relative input', () => {
142 it('resolves relative to the base protocol', () => {
143 const base = '/';
144 const input = '//protocol-relative.com/main.js.map';
145 const resolved = resolve(input, base);
146 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
147 });
148
149 it('resolves relative to the base protocol with query', () => {
150 const base = '/';
151 const input = '//protocol-relative.com/main.js.map?input';
152 const resolved = resolve(input, base);
153 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map?input');
154 });
155
156 it('normalizes input path', () => {
157 const base = '/';
158 const input = '//protocol-relative.com/foo/./bar/../main.js.map';
159 const resolved = resolve(input, base);
160 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map');
161 });
162
163 it('normalizes input path with query', () => {
164 const base = '/';
165 const input = '//protocol-relative.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
166 const resolved = resolve(input, base);
167 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map?input!webpack://foo/./bar');
168 });
169
170 it('normalizes pathless input', () => {
171 const base = '/';
172 const input = '//protocol-relative.com';
173 const resolved = resolve(input, base);
174 assert.strictEqual(resolved, '//protocol-relative.com/');
175 });
176
177 it('normalizes pathless input with query', () => {
178 const base = '/';
179 const input = '//protocol-relative.com?input';
180 const resolved = resolve(input, base);
181 assert.strictEqual(resolved, '//protocol-relative.com/?input');
182 });
183
184 it('normalizes current directory', () => {
185 const base = '/';
186 const input = '//protocol-relative.com/./main.js.map';
187 const resolved = resolve(input, base);
188 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
189 });
190
191 it('normalizes too many parent accessors', () => {
192 const base = '/';
193 const input = '//protocol-relative.com/../main.js.map';
194 const resolved = resolve(input, base);
195 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
196 });
197
198 it('normalizes too many parent accessors, late', () => {
199 const base = '/';
200 const input = '//protocol-relative.com/foo/../../main.js.map';
201 const resolved = resolve(input, base);
202 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
203 });
204 });
205
206 describe('with absolute path input', () => {
207 it('remains absolute path', () => {
208 const base = '/';
209 const input = '/assets/main.js.map';
210 const resolved = resolve(input, base);
211 assert.strictEqual(resolved, '/assets/main.js.map');
212 });
213
214 it('remains absolute path with query', () => {
215 const base = '/';
216 const input = '/assets/main.js.map?input';
217 const resolved = resolve(input, base);
218 assert.strictEqual(resolved, '/assets/main.js.map?input');
219 });
220
221 it('trims to root', () => {
222 const base = '/';
223 const input = '/';
224 const resolved = resolve(input, base);
225 assert.strictEqual(resolved, '/');
226 });
227
228 it('normalizes input path', () => {
229 const base = '/';
230 const input = '/foo/./bar/../main.js.map';
231 const resolved = resolve(input, base);
232 assert.strictEqual(resolved, '/foo/main.js.map');
233 });
234
235 it('normalizes current directory', () => {
236 const base = '/';
237 const input = '/./main.js.map';
238 const resolved = resolve(input, base);
239 assert.strictEqual(resolved, '/main.js.map');
240 });
241
242 it('normalizes too many parent accessors', () => {
243 const base = '/';
244 const input = '/../../../main.js.map';
245 const resolved = resolve(input, base);
246 assert.strictEqual(resolved, '/main.js.map');
247 });
248
249 it('normalizes too many parent accessors with query 1', () => {
250 const base = '/';
251 const input = '/../../../?input';
252 const resolved = resolve(input, base);
253 assert.strictEqual(resolved, '/?input');
254 });
255
256 it('normalizes too many parent accessors with query 2', () => {
257 const base = '/';
258 const input = '/../../..?input';
259 const resolved = resolve(input, base);
260 assert.strictEqual(resolved, '/?input');
261 });
262
263 it('normalizes too many parent accessors, late', () => {
264 const base = '/';
265 const input = '/foo/../../../main.js.map';
266 const resolved = resolve(input, base);
267 assert.strictEqual(resolved, '/main.js.map');
268 });
269 });
270
271 describe('with leading dot relative input', () => {
272 it('resolves relative to current directory', () => {
273 const base = '/';
274 const input = './bar/main.js.map';
275 const resolved = resolve(input, base);
276 assert.strictEqual(resolved, '/bar/main.js.map');
277 });
278
279 it('resolves relative to current directory with query', () => {
280 const base = '/';
281 const input = './bar/main.js.map?input';
282 const resolved = resolve(input, base);
283 assert.strictEqual(resolved, '/bar/main.js.map?input');
284 });
285
286 it('resolves relative to parent directory', () => {
287 const base = '/';
288 const input = '../bar/main.js.map';
289 const resolved = resolve(input, base);
290 assert.strictEqual(resolved, '/bar/main.js.map');
291 });
292
293 it('resolves relative to parent directory with query', () => {
294 const base = '/';
295 const input = '../bar/main.js.map?input';
296 const resolved = resolve(input, base);
297 assert.strictEqual(resolved, '/bar/main.js.map?input');
298 });
299
300 it('resolves relative to parent multiple directory', () => {
301 const base = '/';
302 const input = '../../../bar/main.js.map';
303 const resolved = resolve(input, base);
304 assert.strictEqual(resolved, '/bar/main.js.map');
305 });
306
307 it('resolves relative to parent multiple directory with query 1', () => {
308 const base = '/';
309 const input = '../../../?input';
310 const resolved = resolve(input, base);
311 assert.strictEqual(resolved, '/?input');
312 });
313
314 it('resolves relative to parent multiple directory with query 2', () => {
315 const base = '/';
316 const input = '../../..?input';
317 const resolved = resolve(input, base);
318 assert.strictEqual(resolved, '/?input');
319 });
320
321 it('normalizes input path', () => {
322 const base = '/';
323 const input = './foo/./bar/../main.js.map';
324 const resolved = resolve(input, base);
325 assert.strictEqual(resolved, '/foo/main.js.map');
326 });
327 });
328
329 describe('with relative path input', () => {
330 it('resolves relative to current directory', () => {
331 const base = '/';
332 const input = 'bar/main.js.map';
333 const resolved = resolve(input, base);
334 assert.strictEqual(resolved, '/bar/main.js.map');
335 });
336
337 it('resolves relative to current directory with query', () => {
338 const base = '/';
339 const input = 'bar/main.js.map?input';
340 const resolved = resolve(input, base);
341 assert.strictEqual(resolved, '/bar/main.js.map?input');
342 });
343
344 it('resolves relative to parent multiple directory, later', () => {
345 const base = '/';
346 const input = 'foo/../../../bar/main.js.map';
347 const resolved = resolve(input, base);
348 assert.strictEqual(resolved, '/bar/main.js.map');
349 });
350
351 it('normalizes input path', () => {
352 const base = '/';
353 const input = 'foo/./bar/../main.js.map';
354 const resolved = resolve(input, base);
355 assert.strictEqual(resolved, '/foo/main.js.map');
356 });
357
358 it('resolves node_module scope as path', () => {
359 const base = '/';
360 const input = 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js';
361 const resolved = resolve(input, base);
362 assert.strictEqual(resolved, '/node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js');
363 });
364
365 it('resolves package scope as path', () => {
366 const base = '/';
367 const input = '@babel/runtime/helpers/esm/arrayLikeToArray.js';
368 const resolved = resolve(input, base);
369 assert.strictEqual(resolved, '/@babel/runtime/helpers/esm/arrayLikeToArray.js');
370 });
371 });
372
373 describe('with query input', () => {
374 it('resolves relative to path', () => {
375 const base = '/';
376 const input = '?input';
377 const resolved = resolve(input, base);
378 assert.strictEqual(resolved, '/?input');
379 });
380 });
381
382 describe('with hash input', () => {
383 it('resolves relative to path', () => {
384 const base = '/';
385 const input = '#input';
386 const resolved = resolve(input, base);
387 assert.strictEqual(resolved, '/#input');
388 });
389 });
390
391 describe('empty input', () => {
392 it('normalizes base', () => {
393 const base = '/';
394 const input = '';
395 const resolved = resolve(input, base);
396 assert.strictEqual(resolved, '/');
397 });
398 });
399 });
400
401 describe(`base = "/root"`, () => {
402 describe('with absolute input', () => {
403 it('returns input', () => {
404 const base = '/root';
405 const input = 'https://absolute.com/main.js.map';
406 const resolved = resolve(input, base);
407 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
408 });
409
410 it('returns input with query', () => {
411 const base = '/root';
412 const input = 'https://absolute.com/main.js.map?input';
413 const resolved = resolve(input, base);
414 assert.strictEqual(resolved, 'https://absolute.com/main.js.map?input');
415 });
416
417 it('normalizes input path', () => {
418 const base = '/root';
419 const input = 'https://absolute.com/foo/./bar/../main.js.map';
420 const resolved = resolve(input, base);
421 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map');
422 });
423
424 it('normalizes input path with query', () => {
425 const base = '/root';
426 const input = 'https://absolute.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
427 const resolved = resolve(input, base);
428 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map?input!webpack://foo/./bar');
429 });
430
431 it('normalizes pathless input', () => {
432 const base = '/root';
433 const input = 'https://absolute.com';
434 const resolved = resolve(input, base);
435 assert.strictEqual(resolved, 'https://absolute.com/');
436 });
437
438 it('normalizes pathless input with query', () => {
439 const base = '/root';
440 const input = 'https://absolute.com?input';
441 const resolved = resolve(input, base);
442 assert.strictEqual(resolved, 'https://absolute.com/?input');
443 });
444
445 it('normalizes current directory', () => {
446 const base = '/root';
447 const input = 'https://absolute.com/./main.js.map';
448 const resolved = resolve(input, base);
449 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
450 });
451
452 it('normalizes too many parent accessors', () => {
453 const base = '/root';
454 const input = 'https://absolute.com/../../../main.js.map';
455 const resolved = resolve(input, base);
456 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
457 });
458
459 it('normalizes too many parent accessors, late', () => {
460 const base = '/root';
461 const input = 'https://absolute.com/foo/../../../main.js.map';
462 const resolved = resolve(input, base);
463 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
464 });
465
466 it('normalizes file protocol 1', () => {
467 const base = '/root';
468 const input = 'file:///root/main.js.map';
469 const resolved = resolve(input, base);
470 assert.strictEqual(resolved, 'file:///root/main.js.map');
471 });
472
473 it('normalizes file protocol 2', () => {
474 const base = '/root';
475 const input = 'file://root/main.js.map';
476 const resolved = resolve(input, base);
477 assert.strictEqual(resolved, 'file://root/main.js.map');
478 });
479
480 it('normalizes file protocol 2.5', () => {
481 const base = '/root';
482 const input = 'file://root';
483 const resolved = resolve(input, base);
484 assert.strictEqual(resolved, 'file://root/');
485 });
486
487 it('normalizes file protocol 3', () => {
488 const base = '/root';
489 const input = 'file:/root/main.js.map';
490 const resolved = resolve(input, base);
491 assert.strictEqual(resolved, 'file:///root/main.js.map');
492 });
493
494 it('normalizes file protocol 4', () => {
495 const base = '/root';
496 const input = 'file:root/main.js.map';
497 const resolved = resolve(input, base);
498 assert.strictEqual(resolved, 'file:///root/main.js.map');
499 });
500
501 it('normalizes file protocol 1 with query', () => {
502 const base = '/root';
503 const input = 'file:///root/main.js.map?input';
504 const resolved = resolve(input, base);
505 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
506 });
507
508 it('normalizes file protocol 2 with query', () => {
509 const base = '/root';
510 const input = 'file://root/main.js.map?input';
511 const resolved = resolve(input, base);
512 assert.strictEqual(resolved, 'file://root/main.js.map?input');
513 });
514
515 it('normalizes file protocol 2.5 with query', () => {
516 const base = '/root';
517 const input = 'file://root?input';
518 const resolved = resolve(input, base);
519 assert.strictEqual(resolved, 'file://root/?input');
520 });
521
522 it('normalizes file protocol 3 with query', () => {
523 const base = '/root';
524 const input = 'file:/root/main.js.map?input';
525 const resolved = resolve(input, base);
526 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
527 });
528
529 it('normalizes file protocol 4 with query', () => {
530 const base = '/root';
531 const input = 'file:root/main.js.map?input';
532 const resolved = resolve(input, base);
533 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
534 });
535 });
536
537 describe('with protocol relative input', () => {
538 it('resolves relative to the base protocol', () => {
539 const base = '/root';
540 const input = '//protocol-relative.com/main.js.map';
541 const resolved = resolve(input, base);
542 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
543 });
544
545 it('resolves relative to the base protocol with query', () => {
546 const base = '/root';
547 const input = '//protocol-relative.com/main.js.map?input';
548 const resolved = resolve(input, base);
549 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map?input');
550 });
551
552 it('normalizes input path', () => {
553 const base = '/root';
554 const input = '//protocol-relative.com/foo/./bar/../main.js.map';
555 const resolved = resolve(input, base);
556 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map');
557 });
558
559 it('normalizes input path with query', () => {
560 const base = '/root';
561 const input = '//protocol-relative.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
562 const resolved = resolve(input, base);
563 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map?input!webpack://foo/./bar');
564 });
565
566 it('normalizes pathless input', () => {
567 const base = '/root';
568 const input = '//protocol-relative.com';
569 const resolved = resolve(input, base);
570 assert.strictEqual(resolved, '//protocol-relative.com/');
571 });
572
573 it('normalizes pathless input with query', () => {
574 const base = '/root';
575 const input = '//protocol-relative.com?input';
576 const resolved = resolve(input, base);
577 assert.strictEqual(resolved, '//protocol-relative.com/?input');
578 });
579
580 it('normalizes current directory', () => {
581 const base = '/root';
582 const input = '//protocol-relative.com/./main.js.map';
583 const resolved = resolve(input, base);
584 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
585 });
586
587 it('normalizes too many parent accessors', () => {
588 const base = '/root';
589 const input = '//protocol-relative.com/../main.js.map';
590 const resolved = resolve(input, base);
591 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
592 });
593
594 it('normalizes too many parent accessors, late', () => {
595 const base = '/root';
596 const input = '//protocol-relative.com/foo/../../main.js.map';
597 const resolved = resolve(input, base);
598 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
599 });
600 });
601
602 describe('with absolute path input', () => {
603 it('remains absolute path', () => {
604 const base = '/root';
605 const input = '/assets/main.js.map';
606 const resolved = resolve(input, base);
607 assert.strictEqual(resolved, '/assets/main.js.map');
608 });
609
610 it('remains absolute path with query', () => {
611 const base = '/root';
612 const input = '/assets/main.js.map?input';
613 const resolved = resolve(input, base);
614 assert.strictEqual(resolved, '/assets/main.js.map?input');
615 });
616
617 it('trims to root', () => {
618 const base = '/root';
619 const input = '/';
620 const resolved = resolve(input, base);
621 assert.strictEqual(resolved, '/');
622 });
623
624 it('normalizes input path', () => {
625 const base = '/root';
626 const input = '/foo/./bar/../main.js.map';
627 const resolved = resolve(input, base);
628 assert.strictEqual(resolved, '/foo/main.js.map');
629 });
630
631 it('normalizes current directory', () => {
632 const base = '/root';
633 const input = '/./main.js.map';
634 const resolved = resolve(input, base);
635 assert.strictEqual(resolved, '/main.js.map');
636 });
637
638 it('normalizes too many parent accessors', () => {
639 const base = '/root';
640 const input = '/../../../main.js.map';
641 const resolved = resolve(input, base);
642 assert.strictEqual(resolved, '/main.js.map');
643 });
644
645 it('normalizes too many parent accessors with query 1', () => {
646 const base = '/root';
647 const input = '/../../../?input';
648 const resolved = resolve(input, base);
649 assert.strictEqual(resolved, '/?input');
650 });
651
652 it('normalizes too many parent accessors with query 2', () => {
653 const base = '/root';
654 const input = '/../../..?input';
655 const resolved = resolve(input, base);
656 assert.strictEqual(resolved, '/?input');
657 });
658
659 it('normalizes too many parent accessors, late', () => {
660 const base = '/root';
661 const input = '/foo/../../../main.js.map';
662 const resolved = resolve(input, base);
663 assert.strictEqual(resolved, '/main.js.map');
664 });
665 });
666
667 describe('with leading dot relative input', () => {
668 it('resolves relative to current directory', () => {
669 const base = '/root';
670 const input = './bar/main.js.map';
671 const resolved = resolve(input, base);
672 assert.strictEqual(resolved, '/bar/main.js.map');
673 });
674
675 it('resolves relative to current directory with query', () => {
676 const base = '/root';
677 const input = './bar/main.js.map?input';
678 const resolved = resolve(input, base);
679 assert.strictEqual(resolved, '/bar/main.js.map?input');
680 });
681
682 it('resolves relative to parent directory', () => {
683 const base = '/root';
684 const input = '../bar/main.js.map';
685 const resolved = resolve(input, base);
686 assert.strictEqual(resolved, '/bar/main.js.map');
687 });
688
689 it('resolves relative to parent directory with query', () => {
690 const base = '/root';
691 const input = '../bar/main.js.map?input';
692 const resolved = resolve(input, base);
693 assert.strictEqual(resolved, '/bar/main.js.map?input');
694 });
695
696 it('resolves relative to parent multiple directory', () => {
697 const base = '/root';
698 const input = '../../../bar/main.js.map';
699 const resolved = resolve(input, base);
700 assert.strictEqual(resolved, '/bar/main.js.map');
701 });
702
703 it('resolves relative to parent multiple directory with query 1', () => {
704 const base = '/root';
705 const input = '../../../?input';
706 const resolved = resolve(input, base);
707 assert.strictEqual(resolved, '/?input');
708 });
709
710 it('resolves relative to parent multiple directory with query 2', () => {
711 const base = '/root';
712 const input = '../../..?input';
713 const resolved = resolve(input, base);
714 assert.strictEqual(resolved, '/?input');
715 });
716
717 it('normalizes input path', () => {
718 const base = '/root';
719 const input = './foo/./bar/../main.js.map';
720 const resolved = resolve(input, base);
721 assert.strictEqual(resolved, '/foo/main.js.map');
722 });
723 });
724
725 describe('with relative path input', () => {
726 it('resolves relative to current directory', () => {
727 const base = '/root';
728 const input = 'bar/main.js.map';
729 const resolved = resolve(input, base);
730 assert.strictEqual(resolved, '/bar/main.js.map');
731 });
732
733 it('resolves relative to current directory with query', () => {
734 const base = '/root';
735 const input = 'bar/main.js.map?input';
736 const resolved = resolve(input, base);
737 assert.strictEqual(resolved, '/bar/main.js.map?input');
738 });
739
740 it('resolves relative to parent multiple directory, later', () => {
741 const base = '/root';
742 const input = 'foo/../../../bar/main.js.map';
743 const resolved = resolve(input, base);
744 assert.strictEqual(resolved, '/bar/main.js.map');
745 });
746
747 it('normalizes input path', () => {
748 const base = '/root';
749 const input = 'foo/./bar/../main.js.map';
750 const resolved = resolve(input, base);
751 assert.strictEqual(resolved, '/foo/main.js.map');
752 });
753
754 it('resolves node_module scope as path', () => {
755 const base = '/root';
756 const input = 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js';
757 const resolved = resolve(input, base);
758 assert.strictEqual(resolved, '/node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js');
759 });
760
761 it('resolves package scope as path', () => {
762 const base = '/root';
763 const input = '@babel/runtime/helpers/esm/arrayLikeToArray.js';
764 const resolved = resolve(input, base);
765 assert.strictEqual(resolved, '/@babel/runtime/helpers/esm/arrayLikeToArray.js');
766 });
767 });
768
769 describe('with query input', () => {
770 it('resolves relative to path', () => {
771 const base = '/root';
772 const input = '?input';
773 const resolved = resolve(input, base);
774 assert.strictEqual(resolved, '/root?input');
775 });
776 });
777
778 describe('with hash input', () => {
779 it('resolves relative to path', () => {
780 const base = '/root';
781 const input = '#input';
782 const resolved = resolve(input, base);
783 assert.strictEqual(resolved, '/root#input');
784 });
785 });
786
787 describe('empty input', () => {
788 it('normalizes base', () => {
789 const base = '/root';
790 const input = '';
791 const resolved = resolve(input, base);
792 assert.strictEqual(resolved, '/root');
793 });
794 });
795 });
796
797 describe(`base = "/root/"`, () => {
798 describe('with absolute input', () => {
799 it('returns input', () => {
800 const base = '/root/';
801 const input = 'https://absolute.com/main.js.map';
802 const resolved = resolve(input, base);
803 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
804 });
805
806 it('returns input with query', () => {
807 const base = '/root/';
808 const input = 'https://absolute.com/main.js.map?input';
809 const resolved = resolve(input, base);
810 assert.strictEqual(resolved, 'https://absolute.com/main.js.map?input');
811 });
812
813 it('normalizes input path', () => {
814 const base = '/root/';
815 const input = 'https://absolute.com/foo/./bar/../main.js.map';
816 const resolved = resolve(input, base);
817 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map');
818 });
819
820 it('normalizes input path with query', () => {
821 const base = '/root/';
822 const input = 'https://absolute.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
823 const resolved = resolve(input, base);
824 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map?input!webpack://foo/./bar');
825 });
826
827 it('normalizes pathless input', () => {
828 const base = '/root/';
829 const input = 'https://absolute.com';
830 const resolved = resolve(input, base);
831 assert.strictEqual(resolved, 'https://absolute.com/');
832 });
833
834 it('normalizes pathless input with query', () => {
835 const base = '/root/';
836 const input = 'https://absolute.com?input';
837 const resolved = resolve(input, base);
838 assert.strictEqual(resolved, 'https://absolute.com/?input');
839 });
840
841 it('normalizes current directory', () => {
842 const base = '/root/';
843 const input = 'https://absolute.com/./main.js.map';
844 const resolved = resolve(input, base);
845 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
846 });
847
848 it('normalizes too many parent accessors', () => {
849 const base = '/root/';
850 const input = 'https://absolute.com/../../../main.js.map';
851 const resolved = resolve(input, base);
852 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
853 });
854
855 it('normalizes too many parent accessors, late', () => {
856 const base = '/root/';
857 const input = 'https://absolute.com/foo/../../../main.js.map';
858 const resolved = resolve(input, base);
859 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
860 });
861
862 it('normalizes file protocol 1', () => {
863 const base = '/root/';
864 const input = 'file:///root/main.js.map';
865 const resolved = resolve(input, base);
866 assert.strictEqual(resolved, 'file:///root/main.js.map');
867 });
868
869 it('normalizes file protocol 2', () => {
870 const base = '/root/';
871 const input = 'file://root/main.js.map';
872 const resolved = resolve(input, base);
873 assert.strictEqual(resolved, 'file://root/main.js.map');
874 });
875
876 it('normalizes file protocol 2.5', () => {
877 const base = '/root/';
878 const input = 'file://root';
879 const resolved = resolve(input, base);
880 assert.strictEqual(resolved, 'file://root/');
881 });
882
883 it('normalizes file protocol 3', () => {
884 const base = '/root/';
885 const input = 'file:/root/main.js.map';
886 const resolved = resolve(input, base);
887 assert.strictEqual(resolved, 'file:///root/main.js.map');
888 });
889
890 it('normalizes file protocol 4', () => {
891 const base = '/root/';
892 const input = 'file:root/main.js.map';
893 const resolved = resolve(input, base);
894 assert.strictEqual(resolved, 'file:///root/main.js.map');
895 });
896
897 it('normalizes file protocol 1 with query', () => {
898 const base = '/root/';
899 const input = 'file:///root/main.js.map?input';
900 const resolved = resolve(input, base);
901 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
902 });
903
904 it('normalizes file protocol 2 with query', () => {
905 const base = '/root/';
906 const input = 'file://root/main.js.map?input';
907 const resolved = resolve(input, base);
908 assert.strictEqual(resolved, 'file://root/main.js.map?input');
909 });
910
911 it('normalizes file protocol 2.5 with query', () => {
912 const base = '/root/';
913 const input = 'file://root?input';
914 const resolved = resolve(input, base);
915 assert.strictEqual(resolved, 'file://root/?input');
916 });
917
918 it('normalizes file protocol 3 with query', () => {
919 const base = '/root/';
920 const input = 'file:/root/main.js.map?input';
921 const resolved = resolve(input, base);
922 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
923 });
924
925 it('normalizes file protocol 4 with query', () => {
926 const base = '/root/';
927 const input = 'file:root/main.js.map?input';
928 const resolved = resolve(input, base);
929 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
930 });
931 });
932
933 describe('with protocol relative input', () => {
934 it('resolves relative to the base protocol', () => {
935 const base = '/root/';
936 const input = '//protocol-relative.com/main.js.map';
937 const resolved = resolve(input, base);
938 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
939 });
940
941 it('resolves relative to the base protocol with query', () => {
942 const base = '/root/';
943 const input = '//protocol-relative.com/main.js.map?input';
944 const resolved = resolve(input, base);
945 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map?input');
946 });
947
948 it('normalizes input path', () => {
949 const base = '/root/';
950 const input = '//protocol-relative.com/foo/./bar/../main.js.map';
951 const resolved = resolve(input, base);
952 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map');
953 });
954
955 it('normalizes input path with query', () => {
956 const base = '/root/';
957 const input = '//protocol-relative.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
958 const resolved = resolve(input, base);
959 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map?input!webpack://foo/./bar');
960 });
961
962 it('normalizes pathless input', () => {
963 const base = '/root/';
964 const input = '//protocol-relative.com';
965 const resolved = resolve(input, base);
966 assert.strictEqual(resolved, '//protocol-relative.com/');
967 });
968
969 it('normalizes pathless input with query', () => {
970 const base = '/root/';
971 const input = '//protocol-relative.com?input';
972 const resolved = resolve(input, base);
973 assert.strictEqual(resolved, '//protocol-relative.com/?input');
974 });
975
976 it('normalizes current directory', () => {
977 const base = '/root/';
978 const input = '//protocol-relative.com/./main.js.map';
979 const resolved = resolve(input, base);
980 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
981 });
982
983 it('normalizes too many parent accessors', () => {
984 const base = '/root/';
985 const input = '//protocol-relative.com/../main.js.map';
986 const resolved = resolve(input, base);
987 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
988 });
989
990 it('normalizes too many parent accessors, late', () => {
991 const base = '/root/';
992 const input = '//protocol-relative.com/foo/../../main.js.map';
993 const resolved = resolve(input, base);
994 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
995 });
996 });
997
998 describe('with absolute path input', () => {
999 it('remains absolute path', () => {
1000 const base = '/root/';
1001 const input = '/assets/main.js.map';
1002 const resolved = resolve(input, base);
1003 assert.strictEqual(resolved, '/assets/main.js.map');
1004 });
1005
1006 it('remains absolute path with query', () => {
1007 const base = '/root/';
1008 const input = '/assets/main.js.map?input';
1009 const resolved = resolve(input, base);
1010 assert.strictEqual(resolved, '/assets/main.js.map?input');
1011 });
1012
1013 it('trims to root', () => {
1014 const base = '/root/';
1015 const input = '/';
1016 const resolved = resolve(input, base);
1017 assert.strictEqual(resolved, '/');
1018 });
1019
1020 it('normalizes input path', () => {
1021 const base = '/root/';
1022 const input = '/foo/./bar/../main.js.map';
1023 const resolved = resolve(input, base);
1024 assert.strictEqual(resolved, '/foo/main.js.map');
1025 });
1026
1027 it('normalizes current directory', () => {
1028 const base = '/root/';
1029 const input = '/./main.js.map';
1030 const resolved = resolve(input, base);
1031 assert.strictEqual(resolved, '/main.js.map');
1032 });
1033
1034 it('normalizes too many parent accessors', () => {
1035 const base = '/root/';
1036 const input = '/../../../main.js.map';
1037 const resolved = resolve(input, base);
1038 assert.strictEqual(resolved, '/main.js.map');
1039 });
1040
1041 it('normalizes too many parent accessors with query 1', () => {
1042 const base = '/root/';
1043 const input = '/../../../?input';
1044 const resolved = resolve(input, base);
1045 assert.strictEqual(resolved, '/?input');
1046 });
1047
1048 it('normalizes too many parent accessors with query 2', () => {
1049 const base = '/root/';
1050 const input = '/../../..?input';
1051 const resolved = resolve(input, base);
1052 assert.strictEqual(resolved, '/?input');
1053 });
1054
1055 it('normalizes too many parent accessors, late', () => {
1056 const base = '/root/';
1057 const input = '/foo/../../../main.js.map';
1058 const resolved = resolve(input, base);
1059 assert.strictEqual(resolved, '/main.js.map');
1060 });
1061 });
1062
1063 describe('with leading dot relative input', () => {
1064 it('resolves relative to current directory', () => {
1065 const base = '/root/';
1066 const input = './bar/main.js.map';
1067 const resolved = resolve(input, base);
1068 assert.strictEqual(resolved, '/root/bar/main.js.map');
1069 });
1070
1071 it('resolves relative to current directory with query', () => {
1072 const base = '/root/';
1073 const input = './bar/main.js.map?input';
1074 const resolved = resolve(input, base);
1075 assert.strictEqual(resolved, '/root/bar/main.js.map?input');
1076 });
1077
1078 it('resolves relative to parent directory', () => {
1079 const base = '/root/';
1080 const input = '../bar/main.js.map';
1081 const resolved = resolve(input, base);
1082 assert.strictEqual(resolved, '/bar/main.js.map');
1083 });
1084
1085 it('resolves relative to parent directory with query', () => {
1086 const base = '/root/';
1087 const input = '../bar/main.js.map?input';
1088 const resolved = resolve(input, base);
1089 assert.strictEqual(resolved, '/bar/main.js.map?input');
1090 });
1091
1092 it('resolves relative to parent multiple directory', () => {
1093 const base = '/root/';
1094 const input = '../../../bar/main.js.map';
1095 const resolved = resolve(input, base);
1096 assert.strictEqual(resolved, '/bar/main.js.map');
1097 });
1098
1099 it('resolves relative to parent multiple directory with query 1', () => {
1100 const base = '/root/';
1101 const input = '../../../?input';
1102 const resolved = resolve(input, base);
1103 assert.strictEqual(resolved, '/?input');
1104 });
1105
1106 it('resolves relative to parent multiple directory with query 2', () => {
1107 const base = '/root/';
1108 const input = '../../..?input';
1109 const resolved = resolve(input, base);
1110 assert.strictEqual(resolved, '/?input');
1111 });
1112
1113 it('normalizes input path', () => {
1114 const base = '/root/';
1115 const input = './foo/./bar/../main.js.map';
1116 const resolved = resolve(input, base);
1117 assert.strictEqual(resolved, '/root/foo/main.js.map');
1118 });
1119 });
1120
1121 describe('with relative path input', () => {
1122 it('resolves relative to current directory', () => {
1123 const base = '/root/';
1124 const input = 'bar/main.js.map';
1125 const resolved = resolve(input, base);
1126 assert.strictEqual(resolved, '/root/bar/main.js.map');
1127 });
1128
1129 it('resolves relative to current directory with query', () => {
1130 const base = '/root/';
1131 const input = 'bar/main.js.map?input';
1132 const resolved = resolve(input, base);
1133 assert.strictEqual(resolved, '/root/bar/main.js.map?input');
1134 });
1135
1136 it('resolves relative to parent multiple directory, later', () => {
1137 const base = '/root/';
1138 const input = 'foo/../../../bar/main.js.map';
1139 const resolved = resolve(input, base);
1140 assert.strictEqual(resolved, '/bar/main.js.map');
1141 });
1142
1143 it('normalizes input path', () => {
1144 const base = '/root/';
1145 const input = 'foo/./bar/../main.js.map';
1146 const resolved = resolve(input, base);
1147 assert.strictEqual(resolved, '/root/foo/main.js.map');
1148 });
1149
1150 it('resolves node_module scope as path', () => {
1151 const base = '/root/';
1152 const input = 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js';
1153 const resolved = resolve(input, base);
1154 assert.strictEqual(resolved, '/root/node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js');
1155 });
1156
1157 it('resolves package scope as path', () => {
1158 const base = '/root/';
1159 const input = '@babel/runtime/helpers/esm/arrayLikeToArray.js';
1160 const resolved = resolve(input, base);
1161 assert.strictEqual(resolved, '/root/@babel/runtime/helpers/esm/arrayLikeToArray.js');
1162 });
1163 });
1164
1165 describe('with query input', () => {
1166 it('resolves relative to path', () => {
1167 const base = '/root/';
1168 const input = '?input';
1169 const resolved = resolve(input, base);
1170 assert.strictEqual(resolved, '/root/?input');
1171 });
1172 });
1173
1174 describe('with hash input', () => {
1175 it('resolves relative to path', () => {
1176 const base = '/root/';
1177 const input = '#input';
1178 const resolved = resolve(input, base);
1179 assert.strictEqual(resolved, '/root/#input');
1180 });
1181 });
1182
1183 describe('empty input', () => {
1184 it('normalizes base', () => {
1185 const base = '/root/';
1186 const input = '';
1187 const resolved = resolve(input, base);
1188 assert.strictEqual(resolved, '/root/');
1189 });
1190 });
1191 });
1192
1193 describe(`base = "/root/file"`, () => {
1194 describe('with absolute input', () => {
1195 it('returns input', () => {
1196 const base = '/root/file';
1197 const input = 'https://absolute.com/main.js.map';
1198 const resolved = resolve(input, base);
1199 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
1200 });
1201
1202 it('returns input with query', () => {
1203 const base = '/root/file';
1204 const input = 'https://absolute.com/main.js.map?input';
1205 const resolved = resolve(input, base);
1206 assert.strictEqual(resolved, 'https://absolute.com/main.js.map?input');
1207 });
1208
1209 it('normalizes input path', () => {
1210 const base = '/root/file';
1211 const input = 'https://absolute.com/foo/./bar/../main.js.map';
1212 const resolved = resolve(input, base);
1213 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map');
1214 });
1215
1216 it('normalizes input path with query', () => {
1217 const base = '/root/file';
1218 const input = 'https://absolute.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
1219 const resolved = resolve(input, base);
1220 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map?input!webpack://foo/./bar');
1221 });
1222
1223 it('normalizes pathless input', () => {
1224 const base = '/root/file';
1225 const input = 'https://absolute.com';
1226 const resolved = resolve(input, base);
1227 assert.strictEqual(resolved, 'https://absolute.com/');
1228 });
1229
1230 it('normalizes pathless input with query', () => {
1231 const base = '/root/file';
1232 const input = 'https://absolute.com?input';
1233 const resolved = resolve(input, base);
1234 assert.strictEqual(resolved, 'https://absolute.com/?input');
1235 });
1236
1237 it('normalizes current directory', () => {
1238 const base = '/root/file';
1239 const input = 'https://absolute.com/./main.js.map';
1240 const resolved = resolve(input, base);
1241 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
1242 });
1243
1244 it('normalizes too many parent accessors', () => {
1245 const base = '/root/file';
1246 const input = 'https://absolute.com/../../../main.js.map';
1247 const resolved = resolve(input, base);
1248 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
1249 });
1250
1251 it('normalizes too many parent accessors, late', () => {
1252 const base = '/root/file';
1253 const input = 'https://absolute.com/foo/../../../main.js.map';
1254 const resolved = resolve(input, base);
1255 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
1256 });
1257
1258 it('normalizes file protocol 1', () => {
1259 const base = '/root/file';
1260 const input = 'file:///root/main.js.map';
1261 const resolved = resolve(input, base);
1262 assert.strictEqual(resolved, 'file:///root/main.js.map');
1263 });
1264
1265 it('normalizes file protocol 2', () => {
1266 const base = '/root/file';
1267 const input = 'file://root/main.js.map';
1268 const resolved = resolve(input, base);
1269 assert.strictEqual(resolved, 'file://root/main.js.map');
1270 });
1271
1272 it('normalizes file protocol 2.5', () => {
1273 const base = '/root/file';
1274 const input = 'file://root';
1275 const resolved = resolve(input, base);
1276 assert.strictEqual(resolved, 'file://root/');
1277 });
1278
1279 it('normalizes file protocol 3', () => {
1280 const base = '/root/file';
1281 const input = 'file:/root/main.js.map';
1282 const resolved = resolve(input, base);
1283 assert.strictEqual(resolved, 'file:///root/main.js.map');
1284 });
1285
1286 it('normalizes file protocol 4', () => {
1287 const base = '/root/file';
1288 const input = 'file:root/main.js.map';
1289 const resolved = resolve(input, base);
1290 assert.strictEqual(resolved, 'file:///root/main.js.map');
1291 });
1292
1293 it('normalizes file protocol 1 with query', () => {
1294 const base = '/root/file';
1295 const input = 'file:///root/main.js.map?input';
1296 const resolved = resolve(input, base);
1297 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
1298 });
1299
1300 it('normalizes file protocol 2 with query', () => {
1301 const base = '/root/file';
1302 const input = 'file://root/main.js.map?input';
1303 const resolved = resolve(input, base);
1304 assert.strictEqual(resolved, 'file://root/main.js.map?input');
1305 });
1306
1307 it('normalizes file protocol 2.5 with query', () => {
1308 const base = '/root/file';
1309 const input = 'file://root?input';
1310 const resolved = resolve(input, base);
1311 assert.strictEqual(resolved, 'file://root/?input');
1312 });
1313
1314 it('normalizes file protocol 3 with query', () => {
1315 const base = '/root/file';
1316 const input = 'file:/root/main.js.map?input';
1317 const resolved = resolve(input, base);
1318 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
1319 });
1320
1321 it('normalizes file protocol 4 with query', () => {
1322 const base = '/root/file';
1323 const input = 'file:root/main.js.map?input';
1324 const resolved = resolve(input, base);
1325 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
1326 });
1327 });
1328
1329 describe('with protocol relative input', () => {
1330 it('resolves relative to the base protocol', () => {
1331 const base = '/root/file';
1332 const input = '//protocol-relative.com/main.js.map';
1333 const resolved = resolve(input, base);
1334 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
1335 });
1336
1337 it('resolves relative to the base protocol with query', () => {
1338 const base = '/root/file';
1339 const input = '//protocol-relative.com/main.js.map?input';
1340 const resolved = resolve(input, base);
1341 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map?input');
1342 });
1343
1344 it('normalizes input path', () => {
1345 const base = '/root/file';
1346 const input = '//protocol-relative.com/foo/./bar/../main.js.map';
1347 const resolved = resolve(input, base);
1348 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map');
1349 });
1350
1351 it('normalizes input path with query', () => {
1352 const base = '/root/file';
1353 const input = '//protocol-relative.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
1354 const resolved = resolve(input, base);
1355 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map?input!webpack://foo/./bar');
1356 });
1357
1358 it('normalizes pathless input', () => {
1359 const base = '/root/file';
1360 const input = '//protocol-relative.com';
1361 const resolved = resolve(input, base);
1362 assert.strictEqual(resolved, '//protocol-relative.com/');
1363 });
1364
1365 it('normalizes pathless input with query', () => {
1366 const base = '/root/file';
1367 const input = '//protocol-relative.com?input';
1368 const resolved = resolve(input, base);
1369 assert.strictEqual(resolved, '//protocol-relative.com/?input');
1370 });
1371
1372 it('normalizes current directory', () => {
1373 const base = '/root/file';
1374 const input = '//protocol-relative.com/./main.js.map';
1375 const resolved = resolve(input, base);
1376 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
1377 });
1378
1379 it('normalizes too many parent accessors', () => {
1380 const base = '/root/file';
1381 const input = '//protocol-relative.com/../main.js.map';
1382 const resolved = resolve(input, base);
1383 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
1384 });
1385
1386 it('normalizes too many parent accessors, late', () => {
1387 const base = '/root/file';
1388 const input = '//protocol-relative.com/foo/../../main.js.map';
1389 const resolved = resolve(input, base);
1390 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
1391 });
1392 });
1393
1394 describe('with absolute path input', () => {
1395 it('remains absolute path', () => {
1396 const base = '/root/file';
1397 const input = '/assets/main.js.map';
1398 const resolved = resolve(input, base);
1399 assert.strictEqual(resolved, '/assets/main.js.map');
1400 });
1401
1402 it('remains absolute path with query', () => {
1403 const base = '/root/file';
1404 const input = '/assets/main.js.map?input';
1405 const resolved = resolve(input, base);
1406 assert.strictEqual(resolved, '/assets/main.js.map?input');
1407 });
1408
1409 it('trims to root', () => {
1410 const base = '/root/file';
1411 const input = '/';
1412 const resolved = resolve(input, base);
1413 assert.strictEqual(resolved, '/');
1414 });
1415
1416 it('normalizes input path', () => {
1417 const base = '/root/file';
1418 const input = '/foo/./bar/../main.js.map';
1419 const resolved = resolve(input, base);
1420 assert.strictEqual(resolved, '/foo/main.js.map');
1421 });
1422
1423 it('normalizes current directory', () => {
1424 const base = '/root/file';
1425 const input = '/./main.js.map';
1426 const resolved = resolve(input, base);
1427 assert.strictEqual(resolved, '/main.js.map');
1428 });
1429
1430 it('normalizes too many parent accessors', () => {
1431 const base = '/root/file';
1432 const input = '/../../../main.js.map';
1433 const resolved = resolve(input, base);
1434 assert.strictEqual(resolved, '/main.js.map');
1435 });
1436
1437 it('normalizes too many parent accessors with query 1', () => {
1438 const base = '/root/file';
1439 const input = '/../../../?input';
1440 const resolved = resolve(input, base);
1441 assert.strictEqual(resolved, '/?input');
1442 });
1443
1444 it('normalizes too many parent accessors with query 2', () => {
1445 const base = '/root/file';
1446 const input = '/../../..?input';
1447 const resolved = resolve(input, base);
1448 assert.strictEqual(resolved, '/?input');
1449 });
1450
1451 it('normalizes too many parent accessors, late', () => {
1452 const base = '/root/file';
1453 const input = '/foo/../../../main.js.map';
1454 const resolved = resolve(input, base);
1455 assert.strictEqual(resolved, '/main.js.map');
1456 });
1457 });
1458
1459 describe('with leading dot relative input', () => {
1460 it('resolves relative to current directory', () => {
1461 const base = '/root/file';
1462 const input = './bar/main.js.map';
1463 const resolved = resolve(input, base);
1464 assert.strictEqual(resolved, '/root/bar/main.js.map');
1465 });
1466
1467 it('resolves relative to current directory with query', () => {
1468 const base = '/root/file';
1469 const input = './bar/main.js.map?input';
1470 const resolved = resolve(input, base);
1471 assert.strictEqual(resolved, '/root/bar/main.js.map?input');
1472 });
1473
1474 it('resolves relative to parent directory', () => {
1475 const base = '/root/file';
1476 const input = '../bar/main.js.map';
1477 const resolved = resolve(input, base);
1478 assert.strictEqual(resolved, '/bar/main.js.map');
1479 });
1480
1481 it('resolves relative to parent directory with query', () => {
1482 const base = '/root/file';
1483 const input = '../bar/main.js.map?input';
1484 const resolved = resolve(input, base);
1485 assert.strictEqual(resolved, '/bar/main.js.map?input');
1486 });
1487
1488 it('resolves relative to parent multiple directory', () => {
1489 const base = '/root/file';
1490 const input = '../../../bar/main.js.map';
1491 const resolved = resolve(input, base);
1492 assert.strictEqual(resolved, '/bar/main.js.map');
1493 });
1494
1495 it('resolves relative to parent multiple directory with query 1', () => {
1496 const base = '/root/file';
1497 const input = '../../../?input';
1498 const resolved = resolve(input, base);
1499 assert.strictEqual(resolved, '/?input');
1500 });
1501
1502 it('resolves relative to parent multiple directory with query 2', () => {
1503 const base = '/root/file';
1504 const input = '../../..?input';
1505 const resolved = resolve(input, base);
1506 assert.strictEqual(resolved, '/?input');
1507 });
1508
1509 it('normalizes input path', () => {
1510 const base = '/root/file';
1511 const input = './foo/./bar/../main.js.map';
1512 const resolved = resolve(input, base);
1513 assert.strictEqual(resolved, '/root/foo/main.js.map');
1514 });
1515 });
1516
1517 describe('with relative path input', () => {
1518 it('resolves relative to current directory', () => {
1519 const base = '/root/file';
1520 const input = 'bar/main.js.map';
1521 const resolved = resolve(input, base);
1522 assert.strictEqual(resolved, '/root/bar/main.js.map');
1523 });
1524
1525 it('resolves relative to current directory with query', () => {
1526 const base = '/root/file';
1527 const input = 'bar/main.js.map?input';
1528 const resolved = resolve(input, base);
1529 assert.strictEqual(resolved, '/root/bar/main.js.map?input');
1530 });
1531
1532 it('resolves relative to parent multiple directory, later', () => {
1533 const base = '/root/file';
1534 const input = 'foo/../../../bar/main.js.map';
1535 const resolved = resolve(input, base);
1536 assert.strictEqual(resolved, '/bar/main.js.map');
1537 });
1538
1539 it('normalizes input path', () => {
1540 const base = '/root/file';
1541 const input = 'foo/./bar/../main.js.map';
1542 const resolved = resolve(input, base);
1543 assert.strictEqual(resolved, '/root/foo/main.js.map');
1544 });
1545
1546 it('resolves node_module scope as path', () => {
1547 const base = '/root/file';
1548 const input = 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js';
1549 const resolved = resolve(input, base);
1550 assert.strictEqual(resolved, '/root/node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js');
1551 });
1552
1553 it('resolves package scope as path', () => {
1554 const base = '/root/file';
1555 const input = '@babel/runtime/helpers/esm/arrayLikeToArray.js';
1556 const resolved = resolve(input, base);
1557 assert.strictEqual(resolved, '/root/@babel/runtime/helpers/esm/arrayLikeToArray.js');
1558 });
1559 });
1560
1561 describe('with query input', () => {
1562 it('resolves relative to path', () => {
1563 const base = '/root/file';
1564 const input = '?input';
1565 const resolved = resolve(input, base);
1566 assert.strictEqual(resolved, '/root/file?input');
1567 });
1568 });
1569
1570 describe('with hash input', () => {
1571 it('resolves relative to path', () => {
1572 const base = '/root/file';
1573 const input = '#input';
1574 const resolved = resolve(input, base);
1575 assert.strictEqual(resolved, '/root/file#input');
1576 });
1577 });
1578
1579 describe('empty input', () => {
1580 it('normalizes base', () => {
1581 const base = '/root/file';
1582 const input = '';
1583 const resolved = resolve(input, base);
1584 assert.strictEqual(resolved, '/root/file');
1585 });
1586 });
1587 });
1588
1589 describe(`base = "/root/dir/"`, () => {
1590 describe('with absolute input', () => {
1591 it('returns input', () => {
1592 const base = '/root/dir/';
1593 const input = 'https://absolute.com/main.js.map';
1594 const resolved = resolve(input, base);
1595 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
1596 });
1597
1598 it('returns input with query', () => {
1599 const base = '/root/dir/';
1600 const input = 'https://absolute.com/main.js.map?input';
1601 const resolved = resolve(input, base);
1602 assert.strictEqual(resolved, 'https://absolute.com/main.js.map?input');
1603 });
1604
1605 it('normalizes input path', () => {
1606 const base = '/root/dir/';
1607 const input = 'https://absolute.com/foo/./bar/../main.js.map';
1608 const resolved = resolve(input, base);
1609 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map');
1610 });
1611
1612 it('normalizes input path with query', () => {
1613 const base = '/root/dir/';
1614 const input = 'https://absolute.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
1615 const resolved = resolve(input, base);
1616 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map?input!webpack://foo/./bar');
1617 });
1618
1619 it('normalizes pathless input', () => {
1620 const base = '/root/dir/';
1621 const input = 'https://absolute.com';
1622 const resolved = resolve(input, base);
1623 assert.strictEqual(resolved, 'https://absolute.com/');
1624 });
1625
1626 it('normalizes pathless input with query', () => {
1627 const base = '/root/dir/';
1628 const input = 'https://absolute.com?input';
1629 const resolved = resolve(input, base);
1630 assert.strictEqual(resolved, 'https://absolute.com/?input');
1631 });
1632
1633 it('normalizes current directory', () => {
1634 const base = '/root/dir/';
1635 const input = 'https://absolute.com/./main.js.map';
1636 const resolved = resolve(input, base);
1637 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
1638 });
1639
1640 it('normalizes too many parent accessors', () => {
1641 const base = '/root/dir/';
1642 const input = 'https://absolute.com/../../../main.js.map';
1643 const resolved = resolve(input, base);
1644 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
1645 });
1646
1647 it('normalizes too many parent accessors, late', () => {
1648 const base = '/root/dir/';
1649 const input = 'https://absolute.com/foo/../../../main.js.map';
1650 const resolved = resolve(input, base);
1651 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
1652 });
1653
1654 it('normalizes file protocol 1', () => {
1655 const base = '/root/dir/';
1656 const input = 'file:///root/main.js.map';
1657 const resolved = resolve(input, base);
1658 assert.strictEqual(resolved, 'file:///root/main.js.map');
1659 });
1660
1661 it('normalizes file protocol 2', () => {
1662 const base = '/root/dir/';
1663 const input = 'file://root/main.js.map';
1664 const resolved = resolve(input, base);
1665 assert.strictEqual(resolved, 'file://root/main.js.map');
1666 });
1667
1668 it('normalizes file protocol 2.5', () => {
1669 const base = '/root/dir/';
1670 const input = 'file://root';
1671 const resolved = resolve(input, base);
1672 assert.strictEqual(resolved, 'file://root/');
1673 });
1674
1675 it('normalizes file protocol 3', () => {
1676 const base = '/root/dir/';
1677 const input = 'file:/root/main.js.map';
1678 const resolved = resolve(input, base);
1679 assert.strictEqual(resolved, 'file:///root/main.js.map');
1680 });
1681
1682 it('normalizes file protocol 4', () => {
1683 const base = '/root/dir/';
1684 const input = 'file:root/main.js.map';
1685 const resolved = resolve(input, base);
1686 assert.strictEqual(resolved, 'file:///root/main.js.map');
1687 });
1688
1689 it('normalizes file protocol 1 with query', () => {
1690 const base = '/root/dir/';
1691 const input = 'file:///root/main.js.map?input';
1692 const resolved = resolve(input, base);
1693 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
1694 });
1695
1696 it('normalizes file protocol 2 with query', () => {
1697 const base = '/root/dir/';
1698 const input = 'file://root/main.js.map?input';
1699 const resolved = resolve(input, base);
1700 assert.strictEqual(resolved, 'file://root/main.js.map?input');
1701 });
1702
1703 it('normalizes file protocol 2.5 with query', () => {
1704 const base = '/root/dir/';
1705 const input = 'file://root?input';
1706 const resolved = resolve(input, base);
1707 assert.strictEqual(resolved, 'file://root/?input');
1708 });
1709
1710 it('normalizes file protocol 3 with query', () => {
1711 const base = '/root/dir/';
1712 const input = 'file:/root/main.js.map?input';
1713 const resolved = resolve(input, base);
1714 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
1715 });
1716
1717 it('normalizes file protocol 4 with query', () => {
1718 const base = '/root/dir/';
1719 const input = 'file:root/main.js.map?input';
1720 const resolved = resolve(input, base);
1721 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
1722 });
1723 });
1724
1725 describe('with protocol relative input', () => {
1726 it('resolves relative to the base protocol', () => {
1727 const base = '/root/dir/';
1728 const input = '//protocol-relative.com/main.js.map';
1729 const resolved = resolve(input, base);
1730 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
1731 });
1732
1733 it('resolves relative to the base protocol with query', () => {
1734 const base = '/root/dir/';
1735 const input = '//protocol-relative.com/main.js.map?input';
1736 const resolved = resolve(input, base);
1737 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map?input');
1738 });
1739
1740 it('normalizes input path', () => {
1741 const base = '/root/dir/';
1742 const input = '//protocol-relative.com/foo/./bar/../main.js.map';
1743 const resolved = resolve(input, base);
1744 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map');
1745 });
1746
1747 it('normalizes input path with query', () => {
1748 const base = '/root/dir/';
1749 const input = '//protocol-relative.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
1750 const resolved = resolve(input, base);
1751 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map?input!webpack://foo/./bar');
1752 });
1753
1754 it('normalizes pathless input', () => {
1755 const base = '/root/dir/';
1756 const input = '//protocol-relative.com';
1757 const resolved = resolve(input, base);
1758 assert.strictEqual(resolved, '//protocol-relative.com/');
1759 });
1760
1761 it('normalizes pathless input with query', () => {
1762 const base = '/root/dir/';
1763 const input = '//protocol-relative.com?input';
1764 const resolved = resolve(input, base);
1765 assert.strictEqual(resolved, '//protocol-relative.com/?input');
1766 });
1767
1768 it('normalizes current directory', () => {
1769 const base = '/root/dir/';
1770 const input = '//protocol-relative.com/./main.js.map';
1771 const resolved = resolve(input, base);
1772 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
1773 });
1774
1775 it('normalizes too many parent accessors', () => {
1776 const base = '/root/dir/';
1777 const input = '//protocol-relative.com/../main.js.map';
1778 const resolved = resolve(input, base);
1779 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
1780 });
1781
1782 it('normalizes too many parent accessors, late', () => {
1783 const base = '/root/dir/';
1784 const input = '//protocol-relative.com/foo/../../main.js.map';
1785 const resolved = resolve(input, base);
1786 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
1787 });
1788 });
1789
1790 describe('with absolute path input', () => {
1791 it('remains absolute path', () => {
1792 const base = '/root/dir/';
1793 const input = '/assets/main.js.map';
1794 const resolved = resolve(input, base);
1795 assert.strictEqual(resolved, '/assets/main.js.map');
1796 });
1797
1798 it('remains absolute path with query', () => {
1799 const base = '/root/dir/';
1800 const input = '/assets/main.js.map?input';
1801 const resolved = resolve(input, base);
1802 assert.strictEqual(resolved, '/assets/main.js.map?input');
1803 });
1804
1805 it('trims to root', () => {
1806 const base = '/root/dir/';
1807 const input = '/';
1808 const resolved = resolve(input, base);
1809 assert.strictEqual(resolved, '/');
1810 });
1811
1812 it('normalizes input path', () => {
1813 const base = '/root/dir/';
1814 const input = '/foo/./bar/../main.js.map';
1815 const resolved = resolve(input, base);
1816 assert.strictEqual(resolved, '/foo/main.js.map');
1817 });
1818
1819 it('normalizes current directory', () => {
1820 const base = '/root/dir/';
1821 const input = '/./main.js.map';
1822 const resolved = resolve(input, base);
1823 assert.strictEqual(resolved, '/main.js.map');
1824 });
1825
1826 it('normalizes too many parent accessors', () => {
1827 const base = '/root/dir/';
1828 const input = '/../../../main.js.map';
1829 const resolved = resolve(input, base);
1830 assert.strictEqual(resolved, '/main.js.map');
1831 });
1832
1833 it('normalizes too many parent accessors with query 1', () => {
1834 const base = '/root/dir/';
1835 const input = '/../../../?input';
1836 const resolved = resolve(input, base);
1837 assert.strictEqual(resolved, '/?input');
1838 });
1839
1840 it('normalizes too many parent accessors with query 2', () => {
1841 const base = '/root/dir/';
1842 const input = '/../../..?input';
1843 const resolved = resolve(input, base);
1844 assert.strictEqual(resolved, '/?input');
1845 });
1846
1847 it('normalizes too many parent accessors, late', () => {
1848 const base = '/root/dir/';
1849 const input = '/foo/../../../main.js.map';
1850 const resolved = resolve(input, base);
1851 assert.strictEqual(resolved, '/main.js.map');
1852 });
1853 });
1854
1855 describe('with leading dot relative input', () => {
1856 it('resolves relative to current directory', () => {
1857 const base = '/root/dir/';
1858 const input = './bar/main.js.map';
1859 const resolved = resolve(input, base);
1860 assert.strictEqual(resolved, '/root/dir/bar/main.js.map');
1861 });
1862
1863 it('resolves relative to current directory with query', () => {
1864 const base = '/root/dir/';
1865 const input = './bar/main.js.map?input';
1866 const resolved = resolve(input, base);
1867 assert.strictEqual(resolved, '/root/dir/bar/main.js.map?input');
1868 });
1869
1870 it('resolves relative to parent directory', () => {
1871 const base = '/root/dir/';
1872 const input = '../bar/main.js.map';
1873 const resolved = resolve(input, base);
1874 assert.strictEqual(resolved, '/root/bar/main.js.map');
1875 });
1876
1877 it('resolves relative to parent directory with query', () => {
1878 const base = '/root/dir/';
1879 const input = '../bar/main.js.map?input';
1880 const resolved = resolve(input, base);
1881 assert.strictEqual(resolved, '/root/bar/main.js.map?input');
1882 });
1883
1884 it('resolves relative to parent multiple directory', () => {
1885 const base = '/root/dir/';
1886 const input = '../../../bar/main.js.map';
1887 const resolved = resolve(input, base);
1888 assert.strictEqual(resolved, '/bar/main.js.map');
1889 });
1890
1891 it('resolves relative to parent multiple directory with query 1', () => {
1892 const base = '/root/dir/';
1893 const input = '../../../?input';
1894 const resolved = resolve(input, base);
1895 assert.strictEqual(resolved, '/?input');
1896 });
1897
1898 it('resolves relative to parent multiple directory with query 2', () => {
1899 const base = '/root/dir/';
1900 const input = '../../..?input';
1901 const resolved = resolve(input, base);
1902 assert.strictEqual(resolved, '/?input');
1903 });
1904
1905 it('normalizes input path', () => {
1906 const base = '/root/dir/';
1907 const input = './foo/./bar/../main.js.map';
1908 const resolved = resolve(input, base);
1909 assert.strictEqual(resolved, '/root/dir/foo/main.js.map');
1910 });
1911 });
1912
1913 describe('with relative path input', () => {
1914 it('resolves relative to current directory', () => {
1915 const base = '/root/dir/';
1916 const input = 'bar/main.js.map';
1917 const resolved = resolve(input, base);
1918 assert.strictEqual(resolved, '/root/dir/bar/main.js.map');
1919 });
1920
1921 it('resolves relative to current directory with query', () => {
1922 const base = '/root/dir/';
1923 const input = 'bar/main.js.map?input';
1924 const resolved = resolve(input, base);
1925 assert.strictEqual(resolved, '/root/dir/bar/main.js.map?input');
1926 });
1927
1928 it('resolves relative to parent multiple directory, later', () => {
1929 const base = '/root/dir/';
1930 const input = 'foo/../../../bar/main.js.map';
1931 const resolved = resolve(input, base);
1932 assert.strictEqual(resolved, '/bar/main.js.map');
1933 });
1934
1935 it('normalizes input path', () => {
1936 const base = '/root/dir/';
1937 const input = 'foo/./bar/../main.js.map';
1938 const resolved = resolve(input, base);
1939 assert.strictEqual(resolved, '/root/dir/foo/main.js.map');
1940 });
1941
1942 it('resolves node_module scope as path', () => {
1943 const base = '/root/dir/';
1944 const input = 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js';
1945 const resolved = resolve(input, base);
1946 assert.strictEqual(resolved, '/root/dir/node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js');
1947 });
1948
1949 it('resolves package scope as path', () => {
1950 const base = '/root/dir/';
1951 const input = '@babel/runtime/helpers/esm/arrayLikeToArray.js';
1952 const resolved = resolve(input, base);
1953 assert.strictEqual(resolved, '/root/dir/@babel/runtime/helpers/esm/arrayLikeToArray.js');
1954 });
1955 });
1956
1957 describe('with query input', () => {
1958 it('resolves relative to path', () => {
1959 const base = '/root/dir/';
1960 const input = '?input';
1961 const resolved = resolve(input, base);
1962 assert.strictEqual(resolved, '/root/dir/?input');
1963 });
1964 });
1965
1966 describe('with hash input', () => {
1967 it('resolves relative to path', () => {
1968 const base = '/root/dir/';
1969 const input = '#input';
1970 const resolved = resolve(input, base);
1971 assert.strictEqual(resolved, '/root/dir/#input');
1972 });
1973 });
1974
1975 describe('empty input', () => {
1976 it('normalizes base', () => {
1977 const base = '/root/dir/';
1978 const input = '';
1979 const resolved = resolve(input, base);
1980 assert.strictEqual(resolved, '/root/dir/');
1981 });
1982 });
1983 });
1984
1985 describe(`base = "/.."`, () => {
1986 describe('with absolute input', () => {
1987 it('returns input', () => {
1988 const base = '/..';
1989 const input = 'https://absolute.com/main.js.map';
1990 const resolved = resolve(input, base);
1991 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
1992 });
1993
1994 it('returns input with query', () => {
1995 const base = '/..';
1996 const input = 'https://absolute.com/main.js.map?input';
1997 const resolved = resolve(input, base);
1998 assert.strictEqual(resolved, 'https://absolute.com/main.js.map?input');
1999 });
2000
2001 it('normalizes input path', () => {
2002 const base = '/..';
2003 const input = 'https://absolute.com/foo/./bar/../main.js.map';
2004 const resolved = resolve(input, base);
2005 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map');
2006 });
2007
2008 it('normalizes input path with query', () => {
2009 const base = '/..';
2010 const input = 'https://absolute.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
2011 const resolved = resolve(input, base);
2012 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map?input!webpack://foo/./bar');
2013 });
2014
2015 it('normalizes pathless input', () => {
2016 const base = '/..';
2017 const input = 'https://absolute.com';
2018 const resolved = resolve(input, base);
2019 assert.strictEqual(resolved, 'https://absolute.com/');
2020 });
2021
2022 it('normalizes pathless input with query', () => {
2023 const base = '/..';
2024 const input = 'https://absolute.com?input';
2025 const resolved = resolve(input, base);
2026 assert.strictEqual(resolved, 'https://absolute.com/?input');
2027 });
2028
2029 it('normalizes current directory', () => {
2030 const base = '/..';
2031 const input = 'https://absolute.com/./main.js.map';
2032 const resolved = resolve(input, base);
2033 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
2034 });
2035
2036 it('normalizes too many parent accessors', () => {
2037 const base = '/..';
2038 const input = 'https://absolute.com/../../../main.js.map';
2039 const resolved = resolve(input, base);
2040 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
2041 });
2042
2043 it('normalizes too many parent accessors, late', () => {
2044 const base = '/..';
2045 const input = 'https://absolute.com/foo/../../../main.js.map';
2046 const resolved = resolve(input, base);
2047 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
2048 });
2049
2050 it('normalizes file protocol 1', () => {
2051 const base = '/..';
2052 const input = 'file:///root/main.js.map';
2053 const resolved = resolve(input, base);
2054 assert.strictEqual(resolved, 'file:///root/main.js.map');
2055 });
2056
2057 it('normalizes file protocol 2', () => {
2058 const base = '/..';
2059 const input = 'file://root/main.js.map';
2060 const resolved = resolve(input, base);
2061 assert.strictEqual(resolved, 'file://root/main.js.map');
2062 });
2063
2064 it('normalizes file protocol 2.5', () => {
2065 const base = '/..';
2066 const input = 'file://root';
2067 const resolved = resolve(input, base);
2068 assert.strictEqual(resolved, 'file://root/');
2069 });
2070
2071 it('normalizes file protocol 3', () => {
2072 const base = '/..';
2073 const input = 'file:/root/main.js.map';
2074 const resolved = resolve(input, base);
2075 assert.strictEqual(resolved, 'file:///root/main.js.map');
2076 });
2077
2078 it('normalizes file protocol 4', () => {
2079 const base = '/..';
2080 const input = 'file:root/main.js.map';
2081 const resolved = resolve(input, base);
2082 assert.strictEqual(resolved, 'file:///root/main.js.map');
2083 });
2084
2085 it('normalizes file protocol 1 with query', () => {
2086 const base = '/..';
2087 const input = 'file:///root/main.js.map?input';
2088 const resolved = resolve(input, base);
2089 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
2090 });
2091
2092 it('normalizes file protocol 2 with query', () => {
2093 const base = '/..';
2094 const input = 'file://root/main.js.map?input';
2095 const resolved = resolve(input, base);
2096 assert.strictEqual(resolved, 'file://root/main.js.map?input');
2097 });
2098
2099 it('normalizes file protocol 2.5 with query', () => {
2100 const base = '/..';
2101 const input = 'file://root?input';
2102 const resolved = resolve(input, base);
2103 assert.strictEqual(resolved, 'file://root/?input');
2104 });
2105
2106 it('normalizes file protocol 3 with query', () => {
2107 const base = '/..';
2108 const input = 'file:/root/main.js.map?input';
2109 const resolved = resolve(input, base);
2110 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
2111 });
2112
2113 it('normalizes file protocol 4 with query', () => {
2114 const base = '/..';
2115 const input = 'file:root/main.js.map?input';
2116 const resolved = resolve(input, base);
2117 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
2118 });
2119 });
2120
2121 describe('with protocol relative input', () => {
2122 it('resolves relative to the base protocol', () => {
2123 const base = '/..';
2124 const input = '//protocol-relative.com/main.js.map';
2125 const resolved = resolve(input, base);
2126 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
2127 });
2128
2129 it('resolves relative to the base protocol with query', () => {
2130 const base = '/..';
2131 const input = '//protocol-relative.com/main.js.map?input';
2132 const resolved = resolve(input, base);
2133 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map?input');
2134 });
2135
2136 it('normalizes input path', () => {
2137 const base = '/..';
2138 const input = '//protocol-relative.com/foo/./bar/../main.js.map';
2139 const resolved = resolve(input, base);
2140 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map');
2141 });
2142
2143 it('normalizes input path with query', () => {
2144 const base = '/..';
2145 const input = '//protocol-relative.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
2146 const resolved = resolve(input, base);
2147 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map?input!webpack://foo/./bar');
2148 });
2149
2150 it('normalizes pathless input', () => {
2151 const base = '/..';
2152 const input = '//protocol-relative.com';
2153 const resolved = resolve(input, base);
2154 assert.strictEqual(resolved, '//protocol-relative.com/');
2155 });
2156
2157 it('normalizes pathless input with query', () => {
2158 const base = '/..';
2159 const input = '//protocol-relative.com?input';
2160 const resolved = resolve(input, base);
2161 assert.strictEqual(resolved, '//protocol-relative.com/?input');
2162 });
2163
2164 it('normalizes current directory', () => {
2165 const base = '/..';
2166 const input = '//protocol-relative.com/./main.js.map';
2167 const resolved = resolve(input, base);
2168 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
2169 });
2170
2171 it('normalizes too many parent accessors', () => {
2172 const base = '/..';
2173 const input = '//protocol-relative.com/../main.js.map';
2174 const resolved = resolve(input, base);
2175 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
2176 });
2177
2178 it('normalizes too many parent accessors, late', () => {
2179 const base = '/..';
2180 const input = '//protocol-relative.com/foo/../../main.js.map';
2181 const resolved = resolve(input, base);
2182 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
2183 });
2184 });
2185
2186 describe('with absolute path input', () => {
2187 it('remains absolute path', () => {
2188 const base = '/..';
2189 const input = '/assets/main.js.map';
2190 const resolved = resolve(input, base);
2191 assert.strictEqual(resolved, '/assets/main.js.map');
2192 });
2193
2194 it('remains absolute path with query', () => {
2195 const base = '/..';
2196 const input = '/assets/main.js.map?input';
2197 const resolved = resolve(input, base);
2198 assert.strictEqual(resolved, '/assets/main.js.map?input');
2199 });
2200
2201 it('trims to root', () => {
2202 const base = '/..';
2203 const input = '/';
2204 const resolved = resolve(input, base);
2205 assert.strictEqual(resolved, '/');
2206 });
2207
2208 it('normalizes input path', () => {
2209 const base = '/..';
2210 const input = '/foo/./bar/../main.js.map';
2211 const resolved = resolve(input, base);
2212 assert.strictEqual(resolved, '/foo/main.js.map');
2213 });
2214
2215 it('normalizes current directory', () => {
2216 const base = '/..';
2217 const input = '/./main.js.map';
2218 const resolved = resolve(input, base);
2219 assert.strictEqual(resolved, '/main.js.map');
2220 });
2221
2222 it('normalizes too many parent accessors', () => {
2223 const base = '/..';
2224 const input = '/../../../main.js.map';
2225 const resolved = resolve(input, base);
2226 assert.strictEqual(resolved, '/main.js.map');
2227 });
2228
2229 it('normalizes too many parent accessors with query 1', () => {
2230 const base = '/..';
2231 const input = '/../../../?input';
2232 const resolved = resolve(input, base);
2233 assert.strictEqual(resolved, '/?input');
2234 });
2235
2236 it('normalizes too many parent accessors with query 2', () => {
2237 const base = '/..';
2238 const input = '/../../..?input';
2239 const resolved = resolve(input, base);
2240 assert.strictEqual(resolved, '/?input');
2241 });
2242
2243 it('normalizes too many parent accessors, late', () => {
2244 const base = '/..';
2245 const input = '/foo/../../../main.js.map';
2246 const resolved = resolve(input, base);
2247 assert.strictEqual(resolved, '/main.js.map');
2248 });
2249 });
2250
2251 describe('with leading dot relative input', () => {
2252 it('resolves relative to current directory', () => {
2253 const base = '/..';
2254 const input = './bar/main.js.map';
2255 const resolved = resolve(input, base);
2256 assert.strictEqual(resolved, '/bar/main.js.map');
2257 });
2258
2259 it('resolves relative to current directory with query', () => {
2260 const base = '/..';
2261 const input = './bar/main.js.map?input';
2262 const resolved = resolve(input, base);
2263 assert.strictEqual(resolved, '/bar/main.js.map?input');
2264 });
2265
2266 it('resolves relative to parent directory', () => {
2267 const base = '/..';
2268 const input = '../bar/main.js.map';
2269 const resolved = resolve(input, base);
2270 assert.strictEqual(resolved, '/bar/main.js.map');
2271 });
2272
2273 it('resolves relative to parent directory with query', () => {
2274 const base = '/..';
2275 const input = '../bar/main.js.map?input';
2276 const resolved = resolve(input, base);
2277 assert.strictEqual(resolved, '/bar/main.js.map?input');
2278 });
2279
2280 it('resolves relative to parent multiple directory', () => {
2281 const base = '/..';
2282 const input = '../../../bar/main.js.map';
2283 const resolved = resolve(input, base);
2284 assert.strictEqual(resolved, '/bar/main.js.map');
2285 });
2286
2287 it('resolves relative to parent multiple directory with query 1', () => {
2288 const base = '/..';
2289 const input = '../../../?input';
2290 const resolved = resolve(input, base);
2291 assert.strictEqual(resolved, '/?input');
2292 });
2293
2294 it('resolves relative to parent multiple directory with query 2', () => {
2295 const base = '/..';
2296 const input = '../../..?input';
2297 const resolved = resolve(input, base);
2298 assert.strictEqual(resolved, '/?input');
2299 });
2300
2301 it('normalizes input path', () => {
2302 const base = '/..';
2303 const input = './foo/./bar/../main.js.map';
2304 const resolved = resolve(input, base);
2305 assert.strictEqual(resolved, '/foo/main.js.map');
2306 });
2307 });
2308
2309 describe('with relative path input', () => {
2310 it('resolves relative to current directory', () => {
2311 const base = '/..';
2312 const input = 'bar/main.js.map';
2313 const resolved = resolve(input, base);
2314 assert.strictEqual(resolved, '/bar/main.js.map');
2315 });
2316
2317 it('resolves relative to current directory with query', () => {
2318 const base = '/..';
2319 const input = 'bar/main.js.map?input';
2320 const resolved = resolve(input, base);
2321 assert.strictEqual(resolved, '/bar/main.js.map?input');
2322 });
2323
2324 it('resolves relative to parent multiple directory, later', () => {
2325 const base = '/..';
2326 const input = 'foo/../../../bar/main.js.map';
2327 const resolved = resolve(input, base);
2328 assert.strictEqual(resolved, '/bar/main.js.map');
2329 });
2330
2331 it('normalizes input path', () => {
2332 const base = '/..';
2333 const input = 'foo/./bar/../main.js.map';
2334 const resolved = resolve(input, base);
2335 assert.strictEqual(resolved, '/foo/main.js.map');
2336 });
2337
2338 it('resolves node_module scope as path', () => {
2339 const base = '/..';
2340 const input = 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js';
2341 const resolved = resolve(input, base);
2342 assert.strictEqual(resolved, '/node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js');
2343 });
2344
2345 it('resolves package scope as path', () => {
2346 const base = '/..';
2347 const input = '@babel/runtime/helpers/esm/arrayLikeToArray.js';
2348 const resolved = resolve(input, base);
2349 assert.strictEqual(resolved, '/@babel/runtime/helpers/esm/arrayLikeToArray.js');
2350 });
2351 });
2352
2353 describe('with query input', () => {
2354 it('resolves relative to path', () => {
2355 const base = '/..';
2356 const input = '?input';
2357 const resolved = resolve(input, base);
2358 assert.strictEqual(resolved, '/?input');
2359 });
2360 });
2361
2362 describe('with hash input', () => {
2363 it('resolves relative to path', () => {
2364 const base = '/..';
2365 const input = '#input';
2366 const resolved = resolve(input, base);
2367 assert.strictEqual(resolved, '/#input');
2368 });
2369 });
2370
2371 describe('empty input', () => {
2372 it('normalizes base', () => {
2373 const base = '/..';
2374 const input = '';
2375 const resolved = resolve(input, base);
2376 assert.strictEqual(resolved, '/');
2377 });
2378 });
2379 });
2380
2381 describe(`base = "/../"`, () => {
2382 describe('with absolute input', () => {
2383 it('returns input', () => {
2384 const base = '/../';
2385 const input = 'https://absolute.com/main.js.map';
2386 const resolved = resolve(input, base);
2387 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
2388 });
2389
2390 it('returns input with query', () => {
2391 const base = '/../';
2392 const input = 'https://absolute.com/main.js.map?input';
2393 const resolved = resolve(input, base);
2394 assert.strictEqual(resolved, 'https://absolute.com/main.js.map?input');
2395 });
2396
2397 it('normalizes input path', () => {
2398 const base = '/../';
2399 const input = 'https://absolute.com/foo/./bar/../main.js.map';
2400 const resolved = resolve(input, base);
2401 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map');
2402 });
2403
2404 it('normalizes input path with query', () => {
2405 const base = '/../';
2406 const input = 'https://absolute.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
2407 const resolved = resolve(input, base);
2408 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map?input!webpack://foo/./bar');
2409 });
2410
2411 it('normalizes pathless input', () => {
2412 const base = '/../';
2413 const input = 'https://absolute.com';
2414 const resolved = resolve(input, base);
2415 assert.strictEqual(resolved, 'https://absolute.com/');
2416 });
2417
2418 it('normalizes pathless input with query', () => {
2419 const base = '/../';
2420 const input = 'https://absolute.com?input';
2421 const resolved = resolve(input, base);
2422 assert.strictEqual(resolved, 'https://absolute.com/?input');
2423 });
2424
2425 it('normalizes current directory', () => {
2426 const base = '/../';
2427 const input = 'https://absolute.com/./main.js.map';
2428 const resolved = resolve(input, base);
2429 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
2430 });
2431
2432 it('normalizes too many parent accessors', () => {
2433 const base = '/../';
2434 const input = 'https://absolute.com/../../../main.js.map';
2435 const resolved = resolve(input, base);
2436 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
2437 });
2438
2439 it('normalizes too many parent accessors, late', () => {
2440 const base = '/../';
2441 const input = 'https://absolute.com/foo/../../../main.js.map';
2442 const resolved = resolve(input, base);
2443 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
2444 });
2445
2446 it('normalizes file protocol 1', () => {
2447 const base = '/../';
2448 const input = 'file:///root/main.js.map';
2449 const resolved = resolve(input, base);
2450 assert.strictEqual(resolved, 'file:///root/main.js.map');
2451 });
2452
2453 it('normalizes file protocol 2', () => {
2454 const base = '/../';
2455 const input = 'file://root/main.js.map';
2456 const resolved = resolve(input, base);
2457 assert.strictEqual(resolved, 'file://root/main.js.map');
2458 });
2459
2460 it('normalizes file protocol 2.5', () => {
2461 const base = '/../';
2462 const input = 'file://root';
2463 const resolved = resolve(input, base);
2464 assert.strictEqual(resolved, 'file://root/');
2465 });
2466
2467 it('normalizes file protocol 3', () => {
2468 const base = '/../';
2469 const input = 'file:/root/main.js.map';
2470 const resolved = resolve(input, base);
2471 assert.strictEqual(resolved, 'file:///root/main.js.map');
2472 });
2473
2474 it('normalizes file protocol 4', () => {
2475 const base = '/../';
2476 const input = 'file:root/main.js.map';
2477 const resolved = resolve(input, base);
2478 assert.strictEqual(resolved, 'file:///root/main.js.map');
2479 });
2480
2481 it('normalizes file protocol 1 with query', () => {
2482 const base = '/../';
2483 const input = 'file:///root/main.js.map?input';
2484 const resolved = resolve(input, base);
2485 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
2486 });
2487
2488 it('normalizes file protocol 2 with query', () => {
2489 const base = '/../';
2490 const input = 'file://root/main.js.map?input';
2491 const resolved = resolve(input, base);
2492 assert.strictEqual(resolved, 'file://root/main.js.map?input');
2493 });
2494
2495 it('normalizes file protocol 2.5 with query', () => {
2496 const base = '/../';
2497 const input = 'file://root?input';
2498 const resolved = resolve(input, base);
2499 assert.strictEqual(resolved, 'file://root/?input');
2500 });
2501
2502 it('normalizes file protocol 3 with query', () => {
2503 const base = '/../';
2504 const input = 'file:/root/main.js.map?input';
2505 const resolved = resolve(input, base);
2506 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
2507 });
2508
2509 it('normalizes file protocol 4 with query', () => {
2510 const base = '/../';
2511 const input = 'file:root/main.js.map?input';
2512 const resolved = resolve(input, base);
2513 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
2514 });
2515 });
2516
2517 describe('with protocol relative input', () => {
2518 it('resolves relative to the base protocol', () => {
2519 const base = '/../';
2520 const input = '//protocol-relative.com/main.js.map';
2521 const resolved = resolve(input, base);
2522 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
2523 });
2524
2525 it('resolves relative to the base protocol with query', () => {
2526 const base = '/../';
2527 const input = '//protocol-relative.com/main.js.map?input';
2528 const resolved = resolve(input, base);
2529 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map?input');
2530 });
2531
2532 it('normalizes input path', () => {
2533 const base = '/../';
2534 const input = '//protocol-relative.com/foo/./bar/../main.js.map';
2535 const resolved = resolve(input, base);
2536 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map');
2537 });
2538
2539 it('normalizes input path with query', () => {
2540 const base = '/../';
2541 const input = '//protocol-relative.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
2542 const resolved = resolve(input, base);
2543 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map?input!webpack://foo/./bar');
2544 });
2545
2546 it('normalizes pathless input', () => {
2547 const base = '/../';
2548 const input = '//protocol-relative.com';
2549 const resolved = resolve(input, base);
2550 assert.strictEqual(resolved, '//protocol-relative.com/');
2551 });
2552
2553 it('normalizes pathless input with query', () => {
2554 const base = '/../';
2555 const input = '//protocol-relative.com?input';
2556 const resolved = resolve(input, base);
2557 assert.strictEqual(resolved, '//protocol-relative.com/?input');
2558 });
2559
2560 it('normalizes current directory', () => {
2561 const base = '/../';
2562 const input = '//protocol-relative.com/./main.js.map';
2563 const resolved = resolve(input, base);
2564 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
2565 });
2566
2567 it('normalizes too many parent accessors', () => {
2568 const base = '/../';
2569 const input = '//protocol-relative.com/../main.js.map';
2570 const resolved = resolve(input, base);
2571 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
2572 });
2573
2574 it('normalizes too many parent accessors, late', () => {
2575 const base = '/../';
2576 const input = '//protocol-relative.com/foo/../../main.js.map';
2577 const resolved = resolve(input, base);
2578 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
2579 });
2580 });
2581
2582 describe('with absolute path input', () => {
2583 it('remains absolute path', () => {
2584 const base = '/../';
2585 const input = '/assets/main.js.map';
2586 const resolved = resolve(input, base);
2587 assert.strictEqual(resolved, '/assets/main.js.map');
2588 });
2589
2590 it('remains absolute path with query', () => {
2591 const base = '/../';
2592 const input = '/assets/main.js.map?input';
2593 const resolved = resolve(input, base);
2594 assert.strictEqual(resolved, '/assets/main.js.map?input');
2595 });
2596
2597 it('trims to root', () => {
2598 const base = '/../';
2599 const input = '/';
2600 const resolved = resolve(input, base);
2601 assert.strictEqual(resolved, '/');
2602 });
2603
2604 it('normalizes input path', () => {
2605 const base = '/../';
2606 const input = '/foo/./bar/../main.js.map';
2607 const resolved = resolve(input, base);
2608 assert.strictEqual(resolved, '/foo/main.js.map');
2609 });
2610
2611 it('normalizes current directory', () => {
2612 const base = '/../';
2613 const input = '/./main.js.map';
2614 const resolved = resolve(input, base);
2615 assert.strictEqual(resolved, '/main.js.map');
2616 });
2617
2618 it('normalizes too many parent accessors', () => {
2619 const base = '/../';
2620 const input = '/../../../main.js.map';
2621 const resolved = resolve(input, base);
2622 assert.strictEqual(resolved, '/main.js.map');
2623 });
2624
2625 it('normalizes too many parent accessors with query 1', () => {
2626 const base = '/../';
2627 const input = '/../../../?input';
2628 const resolved = resolve(input, base);
2629 assert.strictEqual(resolved, '/?input');
2630 });
2631
2632 it('normalizes too many parent accessors with query 2', () => {
2633 const base = '/../';
2634 const input = '/../../..?input';
2635 const resolved = resolve(input, base);
2636 assert.strictEqual(resolved, '/?input');
2637 });
2638
2639 it('normalizes too many parent accessors, late', () => {
2640 const base = '/../';
2641 const input = '/foo/../../../main.js.map';
2642 const resolved = resolve(input, base);
2643 assert.strictEqual(resolved, '/main.js.map');
2644 });
2645 });
2646
2647 describe('with leading dot relative input', () => {
2648 it('resolves relative to current directory', () => {
2649 const base = '/../';
2650 const input = './bar/main.js.map';
2651 const resolved = resolve(input, base);
2652 assert.strictEqual(resolved, '/bar/main.js.map');
2653 });
2654
2655 it('resolves relative to current directory with query', () => {
2656 const base = '/../';
2657 const input = './bar/main.js.map?input';
2658 const resolved = resolve(input, base);
2659 assert.strictEqual(resolved, '/bar/main.js.map?input');
2660 });
2661
2662 it('resolves relative to parent directory', () => {
2663 const base = '/../';
2664 const input = '../bar/main.js.map';
2665 const resolved = resolve(input, base);
2666 assert.strictEqual(resolved, '/bar/main.js.map');
2667 });
2668
2669 it('resolves relative to parent directory with query', () => {
2670 const base = '/../';
2671 const input = '../bar/main.js.map?input';
2672 const resolved = resolve(input, base);
2673 assert.strictEqual(resolved, '/bar/main.js.map?input');
2674 });
2675
2676 it('resolves relative to parent multiple directory', () => {
2677 const base = '/../';
2678 const input = '../../../bar/main.js.map';
2679 const resolved = resolve(input, base);
2680 assert.strictEqual(resolved, '/bar/main.js.map');
2681 });
2682
2683 it('resolves relative to parent multiple directory with query 1', () => {
2684 const base = '/../';
2685 const input = '../../../?input';
2686 const resolved = resolve(input, base);
2687 assert.strictEqual(resolved, '/?input');
2688 });
2689
2690 it('resolves relative to parent multiple directory with query 2', () => {
2691 const base = '/../';
2692 const input = '../../..?input';
2693 const resolved = resolve(input, base);
2694 assert.strictEqual(resolved, '/?input');
2695 });
2696
2697 it('normalizes input path', () => {
2698 const base = '/../';
2699 const input = './foo/./bar/../main.js.map';
2700 const resolved = resolve(input, base);
2701 assert.strictEqual(resolved, '/foo/main.js.map');
2702 });
2703 });
2704
2705 describe('with relative path input', () => {
2706 it('resolves relative to current directory', () => {
2707 const base = '/../';
2708 const input = 'bar/main.js.map';
2709 const resolved = resolve(input, base);
2710 assert.strictEqual(resolved, '/bar/main.js.map');
2711 });
2712
2713 it('resolves relative to current directory with query', () => {
2714 const base = '/../';
2715 const input = 'bar/main.js.map?input';
2716 const resolved = resolve(input, base);
2717 assert.strictEqual(resolved, '/bar/main.js.map?input');
2718 });
2719
2720 it('resolves relative to parent multiple directory, later', () => {
2721 const base = '/../';
2722 const input = 'foo/../../../bar/main.js.map';
2723 const resolved = resolve(input, base);
2724 assert.strictEqual(resolved, '/bar/main.js.map');
2725 });
2726
2727 it('normalizes input path', () => {
2728 const base = '/../';
2729 const input = 'foo/./bar/../main.js.map';
2730 const resolved = resolve(input, base);
2731 assert.strictEqual(resolved, '/foo/main.js.map');
2732 });
2733
2734 it('resolves node_module scope as path', () => {
2735 const base = '/../';
2736 const input = 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js';
2737 const resolved = resolve(input, base);
2738 assert.strictEqual(resolved, '/node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js');
2739 });
2740
2741 it('resolves package scope as path', () => {
2742 const base = '/../';
2743 const input = '@babel/runtime/helpers/esm/arrayLikeToArray.js';
2744 const resolved = resolve(input, base);
2745 assert.strictEqual(resolved, '/@babel/runtime/helpers/esm/arrayLikeToArray.js');
2746 });
2747 });
2748
2749 describe('with query input', () => {
2750 it('resolves relative to path', () => {
2751 const base = '/../';
2752 const input = '?input';
2753 const resolved = resolve(input, base);
2754 assert.strictEqual(resolved, '/?input');
2755 });
2756 });
2757
2758 describe('with hash input', () => {
2759 it('resolves relative to path', () => {
2760 const base = '/../';
2761 const input = '#input';
2762 const resolved = resolve(input, base);
2763 assert.strictEqual(resolved, '/#input');
2764 });
2765 });
2766
2767 describe('empty input', () => {
2768 it('normalizes base', () => {
2769 const base = '/../';
2770 const input = '';
2771 const resolved = resolve(input, base);
2772 assert.strictEqual(resolved, '/');
2773 });
2774 });
2775 });
2776
2777 describe(`base = "/root/.."`, () => {
2778 describe('with absolute input', () => {
2779 it('returns input', () => {
2780 const base = '/root/..';
2781 const input = 'https://absolute.com/main.js.map';
2782 const resolved = resolve(input, base);
2783 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
2784 });
2785
2786 it('returns input with query', () => {
2787 const base = '/root/..';
2788 const input = 'https://absolute.com/main.js.map?input';
2789 const resolved = resolve(input, base);
2790 assert.strictEqual(resolved, 'https://absolute.com/main.js.map?input');
2791 });
2792
2793 it('normalizes input path', () => {
2794 const base = '/root/..';
2795 const input = 'https://absolute.com/foo/./bar/../main.js.map';
2796 const resolved = resolve(input, base);
2797 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map');
2798 });
2799
2800 it('normalizes input path with query', () => {
2801 const base = '/root/..';
2802 const input = 'https://absolute.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
2803 const resolved = resolve(input, base);
2804 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map?input!webpack://foo/./bar');
2805 });
2806
2807 it('normalizes pathless input', () => {
2808 const base = '/root/..';
2809 const input = 'https://absolute.com';
2810 const resolved = resolve(input, base);
2811 assert.strictEqual(resolved, 'https://absolute.com/');
2812 });
2813
2814 it('normalizes pathless input with query', () => {
2815 const base = '/root/..';
2816 const input = 'https://absolute.com?input';
2817 const resolved = resolve(input, base);
2818 assert.strictEqual(resolved, 'https://absolute.com/?input');
2819 });
2820
2821 it('normalizes current directory', () => {
2822 const base = '/root/..';
2823 const input = 'https://absolute.com/./main.js.map';
2824 const resolved = resolve(input, base);
2825 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
2826 });
2827
2828 it('normalizes too many parent accessors', () => {
2829 const base = '/root/..';
2830 const input = 'https://absolute.com/../../../main.js.map';
2831 const resolved = resolve(input, base);
2832 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
2833 });
2834
2835 it('normalizes too many parent accessors, late', () => {
2836 const base = '/root/..';
2837 const input = 'https://absolute.com/foo/../../../main.js.map';
2838 const resolved = resolve(input, base);
2839 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
2840 });
2841
2842 it('normalizes file protocol 1', () => {
2843 const base = '/root/..';
2844 const input = 'file:///root/main.js.map';
2845 const resolved = resolve(input, base);
2846 assert.strictEqual(resolved, 'file:///root/main.js.map');
2847 });
2848
2849 it('normalizes file protocol 2', () => {
2850 const base = '/root/..';
2851 const input = 'file://root/main.js.map';
2852 const resolved = resolve(input, base);
2853 assert.strictEqual(resolved, 'file://root/main.js.map');
2854 });
2855
2856 it('normalizes file protocol 2.5', () => {
2857 const base = '/root/..';
2858 const input = 'file://root';
2859 const resolved = resolve(input, base);
2860 assert.strictEqual(resolved, 'file://root/');
2861 });
2862
2863 it('normalizes file protocol 3', () => {
2864 const base = '/root/..';
2865 const input = 'file:/root/main.js.map';
2866 const resolved = resolve(input, base);
2867 assert.strictEqual(resolved, 'file:///root/main.js.map');
2868 });
2869
2870 it('normalizes file protocol 4', () => {
2871 const base = '/root/..';
2872 const input = 'file:root/main.js.map';
2873 const resolved = resolve(input, base);
2874 assert.strictEqual(resolved, 'file:///root/main.js.map');
2875 });
2876
2877 it('normalizes file protocol 1 with query', () => {
2878 const base = '/root/..';
2879 const input = 'file:///root/main.js.map?input';
2880 const resolved = resolve(input, base);
2881 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
2882 });
2883
2884 it('normalizes file protocol 2 with query', () => {
2885 const base = '/root/..';
2886 const input = 'file://root/main.js.map?input';
2887 const resolved = resolve(input, base);
2888 assert.strictEqual(resolved, 'file://root/main.js.map?input');
2889 });
2890
2891 it('normalizes file protocol 2.5 with query', () => {
2892 const base = '/root/..';
2893 const input = 'file://root?input';
2894 const resolved = resolve(input, base);
2895 assert.strictEqual(resolved, 'file://root/?input');
2896 });
2897
2898 it('normalizes file protocol 3 with query', () => {
2899 const base = '/root/..';
2900 const input = 'file:/root/main.js.map?input';
2901 const resolved = resolve(input, base);
2902 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
2903 });
2904
2905 it('normalizes file protocol 4 with query', () => {
2906 const base = '/root/..';
2907 const input = 'file:root/main.js.map?input';
2908 const resolved = resolve(input, base);
2909 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
2910 });
2911 });
2912
2913 describe('with protocol relative input', () => {
2914 it('resolves relative to the base protocol', () => {
2915 const base = '/root/..';
2916 const input = '//protocol-relative.com/main.js.map';
2917 const resolved = resolve(input, base);
2918 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
2919 });
2920
2921 it('resolves relative to the base protocol with query', () => {
2922 const base = '/root/..';
2923 const input = '//protocol-relative.com/main.js.map?input';
2924 const resolved = resolve(input, base);
2925 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map?input');
2926 });
2927
2928 it('normalizes input path', () => {
2929 const base = '/root/..';
2930 const input = '//protocol-relative.com/foo/./bar/../main.js.map';
2931 const resolved = resolve(input, base);
2932 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map');
2933 });
2934
2935 it('normalizes input path with query', () => {
2936 const base = '/root/..';
2937 const input = '//protocol-relative.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
2938 const resolved = resolve(input, base);
2939 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map?input!webpack://foo/./bar');
2940 });
2941
2942 it('normalizes pathless input', () => {
2943 const base = '/root/..';
2944 const input = '//protocol-relative.com';
2945 const resolved = resolve(input, base);
2946 assert.strictEqual(resolved, '//protocol-relative.com/');
2947 });
2948
2949 it('normalizes pathless input with query', () => {
2950 const base = '/root/..';
2951 const input = '//protocol-relative.com?input';
2952 const resolved = resolve(input, base);
2953 assert.strictEqual(resolved, '//protocol-relative.com/?input');
2954 });
2955
2956 it('normalizes current directory', () => {
2957 const base = '/root/..';
2958 const input = '//protocol-relative.com/./main.js.map';
2959 const resolved = resolve(input, base);
2960 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
2961 });
2962
2963 it('normalizes too many parent accessors', () => {
2964 const base = '/root/..';
2965 const input = '//protocol-relative.com/../main.js.map';
2966 const resolved = resolve(input, base);
2967 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
2968 });
2969
2970 it('normalizes too many parent accessors, late', () => {
2971 const base = '/root/..';
2972 const input = '//protocol-relative.com/foo/../../main.js.map';
2973 const resolved = resolve(input, base);
2974 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
2975 });
2976 });
2977
2978 describe('with absolute path input', () => {
2979 it('remains absolute path', () => {
2980 const base = '/root/..';
2981 const input = '/assets/main.js.map';
2982 const resolved = resolve(input, base);
2983 assert.strictEqual(resolved, '/assets/main.js.map');
2984 });
2985
2986 it('remains absolute path with query', () => {
2987 const base = '/root/..';
2988 const input = '/assets/main.js.map?input';
2989 const resolved = resolve(input, base);
2990 assert.strictEqual(resolved, '/assets/main.js.map?input');
2991 });
2992
2993 it('trims to root', () => {
2994 const base = '/root/..';
2995 const input = '/';
2996 const resolved = resolve(input, base);
2997 assert.strictEqual(resolved, '/');
2998 });
2999
3000 it('normalizes input path', () => {
3001 const base = '/root/..';
3002 const input = '/foo/./bar/../main.js.map';
3003 const resolved = resolve(input, base);
3004 assert.strictEqual(resolved, '/foo/main.js.map');
3005 });
3006
3007 it('normalizes current directory', () => {
3008 const base = '/root/..';
3009 const input = '/./main.js.map';
3010 const resolved = resolve(input, base);
3011 assert.strictEqual(resolved, '/main.js.map');
3012 });
3013
3014 it('normalizes too many parent accessors', () => {
3015 const base = '/root/..';
3016 const input = '/../../../main.js.map';
3017 const resolved = resolve(input, base);
3018 assert.strictEqual(resolved, '/main.js.map');
3019 });
3020
3021 it('normalizes too many parent accessors with query 1', () => {
3022 const base = '/root/..';
3023 const input = '/../../../?input';
3024 const resolved = resolve(input, base);
3025 assert.strictEqual(resolved, '/?input');
3026 });
3027
3028 it('normalizes too many parent accessors with query 2', () => {
3029 const base = '/root/..';
3030 const input = '/../../..?input';
3031 const resolved = resolve(input, base);
3032 assert.strictEqual(resolved, '/?input');
3033 });
3034
3035 it('normalizes too many parent accessors, late', () => {
3036 const base = '/root/..';
3037 const input = '/foo/../../../main.js.map';
3038 const resolved = resolve(input, base);
3039 assert.strictEqual(resolved, '/main.js.map');
3040 });
3041 });
3042
3043 describe('with leading dot relative input', () => {
3044 it('resolves relative to current directory', () => {
3045 const base = '/root/..';
3046 const input = './bar/main.js.map';
3047 const resolved = resolve(input, base);
3048 assert.strictEqual(resolved, '/bar/main.js.map');
3049 });
3050
3051 it('resolves relative to current directory with query', () => {
3052 const base = '/root/..';
3053 const input = './bar/main.js.map?input';
3054 const resolved = resolve(input, base);
3055 assert.strictEqual(resolved, '/bar/main.js.map?input');
3056 });
3057
3058 it('resolves relative to parent directory', () => {
3059 const base = '/root/..';
3060 const input = '../bar/main.js.map';
3061 const resolved = resolve(input, base);
3062 assert.strictEqual(resolved, '/bar/main.js.map');
3063 });
3064
3065 it('resolves relative to parent directory with query', () => {
3066 const base = '/root/..';
3067 const input = '../bar/main.js.map?input';
3068 const resolved = resolve(input, base);
3069 assert.strictEqual(resolved, '/bar/main.js.map?input');
3070 });
3071
3072 it('resolves relative to parent multiple directory', () => {
3073 const base = '/root/..';
3074 const input = '../../../bar/main.js.map';
3075 const resolved = resolve(input, base);
3076 assert.strictEqual(resolved, '/bar/main.js.map');
3077 });
3078
3079 it('resolves relative to parent multiple directory with query 1', () => {
3080 const base = '/root/..';
3081 const input = '../../../?input';
3082 const resolved = resolve(input, base);
3083 assert.strictEqual(resolved, '/?input');
3084 });
3085
3086 it('resolves relative to parent multiple directory with query 2', () => {
3087 const base = '/root/..';
3088 const input = '../../..?input';
3089 const resolved = resolve(input, base);
3090 assert.strictEqual(resolved, '/?input');
3091 });
3092
3093 it('normalizes input path', () => {
3094 const base = '/root/..';
3095 const input = './foo/./bar/../main.js.map';
3096 const resolved = resolve(input, base);
3097 assert.strictEqual(resolved, '/foo/main.js.map');
3098 });
3099 });
3100
3101 describe('with relative path input', () => {
3102 it('resolves relative to current directory', () => {
3103 const base = '/root/..';
3104 const input = 'bar/main.js.map';
3105 const resolved = resolve(input, base);
3106 assert.strictEqual(resolved, '/bar/main.js.map');
3107 });
3108
3109 it('resolves relative to current directory with query', () => {
3110 const base = '/root/..';
3111 const input = 'bar/main.js.map?input';
3112 const resolved = resolve(input, base);
3113 assert.strictEqual(resolved, '/bar/main.js.map?input');
3114 });
3115
3116 it('resolves relative to parent multiple directory, later', () => {
3117 const base = '/root/..';
3118 const input = 'foo/../../../bar/main.js.map';
3119 const resolved = resolve(input, base);
3120 assert.strictEqual(resolved, '/bar/main.js.map');
3121 });
3122
3123 it('normalizes input path', () => {
3124 const base = '/root/..';
3125 const input = 'foo/./bar/../main.js.map';
3126 const resolved = resolve(input, base);
3127 assert.strictEqual(resolved, '/foo/main.js.map');
3128 });
3129
3130 it('resolves node_module scope as path', () => {
3131 const base = '/root/..';
3132 const input = 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js';
3133 const resolved = resolve(input, base);
3134 assert.strictEqual(resolved, '/node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js');
3135 });
3136
3137 it('resolves package scope as path', () => {
3138 const base = '/root/..';
3139 const input = '@babel/runtime/helpers/esm/arrayLikeToArray.js';
3140 const resolved = resolve(input, base);
3141 assert.strictEqual(resolved, '/@babel/runtime/helpers/esm/arrayLikeToArray.js');
3142 });
3143 });
3144
3145 describe('with query input', () => {
3146 it('resolves relative to path', () => {
3147 const base = '/root/..';
3148 const input = '?input';
3149 const resolved = resolve(input, base);
3150 assert.strictEqual(resolved, '/?input');
3151 });
3152 });
3153
3154 describe('with hash input', () => {
3155 it('resolves relative to path', () => {
3156 const base = '/root/..';
3157 const input = '#input';
3158 const resolved = resolve(input, base);
3159 assert.strictEqual(resolved, '/#input');
3160 });
3161 });
3162
3163 describe('empty input', () => {
3164 it('normalizes base', () => {
3165 const base = '/root/..';
3166 const input = '';
3167 const resolved = resolve(input, base);
3168 assert.strictEqual(resolved, '/');
3169 });
3170 });
3171 });
3172
3173 describe(`base = "/root/../"`, () => {
3174 describe('with absolute input', () => {
3175 it('returns input', () => {
3176 const base = '/root/../';
3177 const input = 'https://absolute.com/main.js.map';
3178 const resolved = resolve(input, base);
3179 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
3180 });
3181
3182 it('returns input with query', () => {
3183 const base = '/root/../';
3184 const input = 'https://absolute.com/main.js.map?input';
3185 const resolved = resolve(input, base);
3186 assert.strictEqual(resolved, 'https://absolute.com/main.js.map?input');
3187 });
3188
3189 it('normalizes input path', () => {
3190 const base = '/root/../';
3191 const input = 'https://absolute.com/foo/./bar/../main.js.map';
3192 const resolved = resolve(input, base);
3193 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map');
3194 });
3195
3196 it('normalizes input path with query', () => {
3197 const base = '/root/../';
3198 const input = 'https://absolute.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
3199 const resolved = resolve(input, base);
3200 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map?input!webpack://foo/./bar');
3201 });
3202
3203 it('normalizes pathless input', () => {
3204 const base = '/root/../';
3205 const input = 'https://absolute.com';
3206 const resolved = resolve(input, base);
3207 assert.strictEqual(resolved, 'https://absolute.com/');
3208 });
3209
3210 it('normalizes pathless input with query', () => {
3211 const base = '/root/../';
3212 const input = 'https://absolute.com?input';
3213 const resolved = resolve(input, base);
3214 assert.strictEqual(resolved, 'https://absolute.com/?input');
3215 });
3216
3217 it('normalizes current directory', () => {
3218 const base = '/root/../';
3219 const input = 'https://absolute.com/./main.js.map';
3220 const resolved = resolve(input, base);
3221 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
3222 });
3223
3224 it('normalizes too many parent accessors', () => {
3225 const base = '/root/../';
3226 const input = 'https://absolute.com/../../../main.js.map';
3227 const resolved = resolve(input, base);
3228 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
3229 });
3230
3231 it('normalizes too many parent accessors, late', () => {
3232 const base = '/root/../';
3233 const input = 'https://absolute.com/foo/../../../main.js.map';
3234 const resolved = resolve(input, base);
3235 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
3236 });
3237
3238 it('normalizes file protocol 1', () => {
3239 const base = '/root/../';
3240 const input = 'file:///root/main.js.map';
3241 const resolved = resolve(input, base);
3242 assert.strictEqual(resolved, 'file:///root/main.js.map');
3243 });
3244
3245 it('normalizes file protocol 2', () => {
3246 const base = '/root/../';
3247 const input = 'file://root/main.js.map';
3248 const resolved = resolve(input, base);
3249 assert.strictEqual(resolved, 'file://root/main.js.map');
3250 });
3251
3252 it('normalizes file protocol 2.5', () => {
3253 const base = '/root/../';
3254 const input = 'file://root';
3255 const resolved = resolve(input, base);
3256 assert.strictEqual(resolved, 'file://root/');
3257 });
3258
3259 it('normalizes file protocol 3', () => {
3260 const base = '/root/../';
3261 const input = 'file:/root/main.js.map';
3262 const resolved = resolve(input, base);
3263 assert.strictEqual(resolved, 'file:///root/main.js.map');
3264 });
3265
3266 it('normalizes file protocol 4', () => {
3267 const base = '/root/../';
3268 const input = 'file:root/main.js.map';
3269 const resolved = resolve(input, base);
3270 assert.strictEqual(resolved, 'file:///root/main.js.map');
3271 });
3272
3273 it('normalizes file protocol 1 with query', () => {
3274 const base = '/root/../';
3275 const input = 'file:///root/main.js.map?input';
3276 const resolved = resolve(input, base);
3277 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
3278 });
3279
3280 it('normalizes file protocol 2 with query', () => {
3281 const base = '/root/../';
3282 const input = 'file://root/main.js.map?input';
3283 const resolved = resolve(input, base);
3284 assert.strictEqual(resolved, 'file://root/main.js.map?input');
3285 });
3286
3287 it('normalizes file protocol 2.5 with query', () => {
3288 const base = '/root/../';
3289 const input = 'file://root?input';
3290 const resolved = resolve(input, base);
3291 assert.strictEqual(resolved, 'file://root/?input');
3292 });
3293
3294 it('normalizes file protocol 3 with query', () => {
3295 const base = '/root/../';
3296 const input = 'file:/root/main.js.map?input';
3297 const resolved = resolve(input, base);
3298 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
3299 });
3300
3301 it('normalizes file protocol 4 with query', () => {
3302 const base = '/root/../';
3303 const input = 'file:root/main.js.map?input';
3304 const resolved = resolve(input, base);
3305 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
3306 });
3307 });
3308
3309 describe('with protocol relative input', () => {
3310 it('resolves relative to the base protocol', () => {
3311 const base = '/root/../';
3312 const input = '//protocol-relative.com/main.js.map';
3313 const resolved = resolve(input, base);
3314 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
3315 });
3316
3317 it('resolves relative to the base protocol with query', () => {
3318 const base = '/root/../';
3319 const input = '//protocol-relative.com/main.js.map?input';
3320 const resolved = resolve(input, base);
3321 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map?input');
3322 });
3323
3324 it('normalizes input path', () => {
3325 const base = '/root/../';
3326 const input = '//protocol-relative.com/foo/./bar/../main.js.map';
3327 const resolved = resolve(input, base);
3328 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map');
3329 });
3330
3331 it('normalizes input path with query', () => {
3332 const base = '/root/../';
3333 const input = '//protocol-relative.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
3334 const resolved = resolve(input, base);
3335 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map?input!webpack://foo/./bar');
3336 });
3337
3338 it('normalizes pathless input', () => {
3339 const base = '/root/../';
3340 const input = '//protocol-relative.com';
3341 const resolved = resolve(input, base);
3342 assert.strictEqual(resolved, '//protocol-relative.com/');
3343 });
3344
3345 it('normalizes pathless input with query', () => {
3346 const base = '/root/../';
3347 const input = '//protocol-relative.com?input';
3348 const resolved = resolve(input, base);
3349 assert.strictEqual(resolved, '//protocol-relative.com/?input');
3350 });
3351
3352 it('normalizes current directory', () => {
3353 const base = '/root/../';
3354 const input = '//protocol-relative.com/./main.js.map';
3355 const resolved = resolve(input, base);
3356 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
3357 });
3358
3359 it('normalizes too many parent accessors', () => {
3360 const base = '/root/../';
3361 const input = '//protocol-relative.com/../main.js.map';
3362 const resolved = resolve(input, base);
3363 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
3364 });
3365
3366 it('normalizes too many parent accessors, late', () => {
3367 const base = '/root/../';
3368 const input = '//protocol-relative.com/foo/../../main.js.map';
3369 const resolved = resolve(input, base);
3370 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
3371 });
3372 });
3373
3374 describe('with absolute path input', () => {
3375 it('remains absolute path', () => {
3376 const base = '/root/../';
3377 const input = '/assets/main.js.map';
3378 const resolved = resolve(input, base);
3379 assert.strictEqual(resolved, '/assets/main.js.map');
3380 });
3381
3382 it('remains absolute path with query', () => {
3383 const base = '/root/../';
3384 const input = '/assets/main.js.map?input';
3385 const resolved = resolve(input, base);
3386 assert.strictEqual(resolved, '/assets/main.js.map?input');
3387 });
3388
3389 it('trims to root', () => {
3390 const base = '/root/../';
3391 const input = '/';
3392 const resolved = resolve(input, base);
3393 assert.strictEqual(resolved, '/');
3394 });
3395
3396 it('normalizes input path', () => {
3397 const base = '/root/../';
3398 const input = '/foo/./bar/../main.js.map';
3399 const resolved = resolve(input, base);
3400 assert.strictEqual(resolved, '/foo/main.js.map');
3401 });
3402
3403 it('normalizes current directory', () => {
3404 const base = '/root/../';
3405 const input = '/./main.js.map';
3406 const resolved = resolve(input, base);
3407 assert.strictEqual(resolved, '/main.js.map');
3408 });
3409
3410 it('normalizes too many parent accessors', () => {
3411 const base = '/root/../';
3412 const input = '/../../../main.js.map';
3413 const resolved = resolve(input, base);
3414 assert.strictEqual(resolved, '/main.js.map');
3415 });
3416
3417 it('normalizes too many parent accessors with query 1', () => {
3418 const base = '/root/../';
3419 const input = '/../../../?input';
3420 const resolved = resolve(input, base);
3421 assert.strictEqual(resolved, '/?input');
3422 });
3423
3424 it('normalizes too many parent accessors with query 2', () => {
3425 const base = '/root/../';
3426 const input = '/../../..?input';
3427 const resolved = resolve(input, base);
3428 assert.strictEqual(resolved, '/?input');
3429 });
3430
3431 it('normalizes too many parent accessors, late', () => {
3432 const base = '/root/../';
3433 const input = '/foo/../../../main.js.map';
3434 const resolved = resolve(input, base);
3435 assert.strictEqual(resolved, '/main.js.map');
3436 });
3437 });
3438
3439 describe('with leading dot relative input', () => {
3440 it('resolves relative to current directory', () => {
3441 const base = '/root/../';
3442 const input = './bar/main.js.map';
3443 const resolved = resolve(input, base);
3444 assert.strictEqual(resolved, '/bar/main.js.map');
3445 });
3446
3447 it('resolves relative to current directory with query', () => {
3448 const base = '/root/../';
3449 const input = './bar/main.js.map?input';
3450 const resolved = resolve(input, base);
3451 assert.strictEqual(resolved, '/bar/main.js.map?input');
3452 });
3453
3454 it('resolves relative to parent directory', () => {
3455 const base = '/root/../';
3456 const input = '../bar/main.js.map';
3457 const resolved = resolve(input, base);
3458 assert.strictEqual(resolved, '/bar/main.js.map');
3459 });
3460
3461 it('resolves relative to parent directory with query', () => {
3462 const base = '/root/../';
3463 const input = '../bar/main.js.map?input';
3464 const resolved = resolve(input, base);
3465 assert.strictEqual(resolved, '/bar/main.js.map?input');
3466 });
3467
3468 it('resolves relative to parent multiple directory', () => {
3469 const base = '/root/../';
3470 const input = '../../../bar/main.js.map';
3471 const resolved = resolve(input, base);
3472 assert.strictEqual(resolved, '/bar/main.js.map');
3473 });
3474
3475 it('resolves relative to parent multiple directory with query 1', () => {
3476 const base = '/root/../';
3477 const input = '../../../?input';
3478 const resolved = resolve(input, base);
3479 assert.strictEqual(resolved, '/?input');
3480 });
3481
3482 it('resolves relative to parent multiple directory with query 2', () => {
3483 const base = '/root/../';
3484 const input = '../../..?input';
3485 const resolved = resolve(input, base);
3486 assert.strictEqual(resolved, '/?input');
3487 });
3488
3489 it('normalizes input path', () => {
3490 const base = '/root/../';
3491 const input = './foo/./bar/../main.js.map';
3492 const resolved = resolve(input, base);
3493 assert.strictEqual(resolved, '/foo/main.js.map');
3494 });
3495 });
3496
3497 describe('with relative path input', () => {
3498 it('resolves relative to current directory', () => {
3499 const base = '/root/../';
3500 const input = 'bar/main.js.map';
3501 const resolved = resolve(input, base);
3502 assert.strictEqual(resolved, '/bar/main.js.map');
3503 });
3504
3505 it('resolves relative to current directory with query', () => {
3506 const base = '/root/../';
3507 const input = 'bar/main.js.map?input';
3508 const resolved = resolve(input, base);
3509 assert.strictEqual(resolved, '/bar/main.js.map?input');
3510 });
3511
3512 it('resolves relative to parent multiple directory, later', () => {
3513 const base = '/root/../';
3514 const input = 'foo/../../../bar/main.js.map';
3515 const resolved = resolve(input, base);
3516 assert.strictEqual(resolved, '/bar/main.js.map');
3517 });
3518
3519 it('normalizes input path', () => {
3520 const base = '/root/../';
3521 const input = 'foo/./bar/../main.js.map';
3522 const resolved = resolve(input, base);
3523 assert.strictEqual(resolved, '/foo/main.js.map');
3524 });
3525
3526 it('resolves node_module scope as path', () => {
3527 const base = '/root/../';
3528 const input = 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js';
3529 const resolved = resolve(input, base);
3530 assert.strictEqual(resolved, '/node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js');
3531 });
3532
3533 it('resolves package scope as path', () => {
3534 const base = '/root/../';
3535 const input = '@babel/runtime/helpers/esm/arrayLikeToArray.js';
3536 const resolved = resolve(input, base);
3537 assert.strictEqual(resolved, '/@babel/runtime/helpers/esm/arrayLikeToArray.js');
3538 });
3539 });
3540
3541 describe('with query input', () => {
3542 it('resolves relative to path', () => {
3543 const base = '/root/../';
3544 const input = '?input';
3545 const resolved = resolve(input, base);
3546 assert.strictEqual(resolved, '/?input');
3547 });
3548 });
3549
3550 describe('with hash input', () => {
3551 it('resolves relative to path', () => {
3552 const base = '/root/../';
3553 const input = '#input';
3554 const resolved = resolve(input, base);
3555 assert.strictEqual(resolved, '/#input');
3556 });
3557 });
3558
3559 describe('empty input', () => {
3560 it('normalizes base', () => {
3561 const base = '/root/../';
3562 const input = '';
3563 const resolved = resolve(input, base);
3564 assert.strictEqual(resolved, '/');
3565 });
3566 });
3567 });
3568
3569 describe(`base = "/root?baseQuery"`, () => {
3570 describe('with absolute input', () => {
3571 it('returns input', () => {
3572 const base = '/root?baseQuery';
3573 const input = 'https://absolute.com/main.js.map';
3574 const resolved = resolve(input, base);
3575 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
3576 });
3577
3578 it('returns input with query', () => {
3579 const base = '/root?baseQuery';
3580 const input = 'https://absolute.com/main.js.map?input';
3581 const resolved = resolve(input, base);
3582 assert.strictEqual(resolved, 'https://absolute.com/main.js.map?input');
3583 });
3584
3585 it('normalizes input path', () => {
3586 const base = '/root?baseQuery';
3587 const input = 'https://absolute.com/foo/./bar/../main.js.map';
3588 const resolved = resolve(input, base);
3589 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map');
3590 });
3591
3592 it('normalizes input path with query', () => {
3593 const base = '/root?baseQuery';
3594 const input = 'https://absolute.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
3595 const resolved = resolve(input, base);
3596 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map?input!webpack://foo/./bar');
3597 });
3598
3599 it('normalizes pathless input', () => {
3600 const base = '/root?baseQuery';
3601 const input = 'https://absolute.com';
3602 const resolved = resolve(input, base);
3603 assert.strictEqual(resolved, 'https://absolute.com/');
3604 });
3605
3606 it('normalizes pathless input with query', () => {
3607 const base = '/root?baseQuery';
3608 const input = 'https://absolute.com?input';
3609 const resolved = resolve(input, base);
3610 assert.strictEqual(resolved, 'https://absolute.com/?input');
3611 });
3612
3613 it('normalizes current directory', () => {
3614 const base = '/root?baseQuery';
3615 const input = 'https://absolute.com/./main.js.map';
3616 const resolved = resolve(input, base);
3617 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
3618 });
3619
3620 it('normalizes too many parent accessors', () => {
3621 const base = '/root?baseQuery';
3622 const input = 'https://absolute.com/../../../main.js.map';
3623 const resolved = resolve(input, base);
3624 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
3625 });
3626
3627 it('normalizes too many parent accessors, late', () => {
3628 const base = '/root?baseQuery';
3629 const input = 'https://absolute.com/foo/../../../main.js.map';
3630 const resolved = resolve(input, base);
3631 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
3632 });
3633
3634 it('normalizes file protocol 1', () => {
3635 const base = '/root?baseQuery';
3636 const input = 'file:///root/main.js.map';
3637 const resolved = resolve(input, base);
3638 assert.strictEqual(resolved, 'file:///root/main.js.map');
3639 });
3640
3641 it('normalizes file protocol 2', () => {
3642 const base = '/root?baseQuery';
3643 const input = 'file://root/main.js.map';
3644 const resolved = resolve(input, base);
3645 assert.strictEqual(resolved, 'file://root/main.js.map');
3646 });
3647
3648 it('normalizes file protocol 2.5', () => {
3649 const base = '/root?baseQuery';
3650 const input = 'file://root';
3651 const resolved = resolve(input, base);
3652 assert.strictEqual(resolved, 'file://root/');
3653 });
3654
3655 it('normalizes file protocol 3', () => {
3656 const base = '/root?baseQuery';
3657 const input = 'file:/root/main.js.map';
3658 const resolved = resolve(input, base);
3659 assert.strictEqual(resolved, 'file:///root/main.js.map');
3660 });
3661
3662 it('normalizes file protocol 4', () => {
3663 const base = '/root?baseQuery';
3664 const input = 'file:root/main.js.map';
3665 const resolved = resolve(input, base);
3666 assert.strictEqual(resolved, 'file:///root/main.js.map');
3667 });
3668
3669 it('normalizes file protocol 1 with query', () => {
3670 const base = '/root?baseQuery';
3671 const input = 'file:///root/main.js.map?input';
3672 const resolved = resolve(input, base);
3673 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
3674 });
3675
3676 it('normalizes file protocol 2 with query', () => {
3677 const base = '/root?baseQuery';
3678 const input = 'file://root/main.js.map?input';
3679 const resolved = resolve(input, base);
3680 assert.strictEqual(resolved, 'file://root/main.js.map?input');
3681 });
3682
3683 it('normalizes file protocol 2.5 with query', () => {
3684 const base = '/root?baseQuery';
3685 const input = 'file://root?input';
3686 const resolved = resolve(input, base);
3687 assert.strictEqual(resolved, 'file://root/?input');
3688 });
3689
3690 it('normalizes file protocol 3 with query', () => {
3691 const base = '/root?baseQuery';
3692 const input = 'file:/root/main.js.map?input';
3693 const resolved = resolve(input, base);
3694 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
3695 });
3696
3697 it('normalizes file protocol 4 with query', () => {
3698 const base = '/root?baseQuery';
3699 const input = 'file:root/main.js.map?input';
3700 const resolved = resolve(input, base);
3701 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
3702 });
3703 });
3704
3705 describe('with protocol relative input', () => {
3706 it('resolves relative to the base protocol', () => {
3707 const base = '/root?baseQuery';
3708 const input = '//protocol-relative.com/main.js.map';
3709 const resolved = resolve(input, base);
3710 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
3711 });
3712
3713 it('resolves relative to the base protocol with query', () => {
3714 const base = '/root?baseQuery';
3715 const input = '//protocol-relative.com/main.js.map?input';
3716 const resolved = resolve(input, base);
3717 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map?input');
3718 });
3719
3720 it('normalizes input path', () => {
3721 const base = '/root?baseQuery';
3722 const input = '//protocol-relative.com/foo/./bar/../main.js.map';
3723 const resolved = resolve(input, base);
3724 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map');
3725 });
3726
3727 it('normalizes input path with query', () => {
3728 const base = '/root?baseQuery';
3729 const input = '//protocol-relative.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
3730 const resolved = resolve(input, base);
3731 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map?input!webpack://foo/./bar');
3732 });
3733
3734 it('normalizes pathless input', () => {
3735 const base = '/root?baseQuery';
3736 const input = '//protocol-relative.com';
3737 const resolved = resolve(input, base);
3738 assert.strictEqual(resolved, '//protocol-relative.com/');
3739 });
3740
3741 it('normalizes pathless input with query', () => {
3742 const base = '/root?baseQuery';
3743 const input = '//protocol-relative.com?input';
3744 const resolved = resolve(input, base);
3745 assert.strictEqual(resolved, '//protocol-relative.com/?input');
3746 });
3747
3748 it('normalizes current directory', () => {
3749 const base = '/root?baseQuery';
3750 const input = '//protocol-relative.com/./main.js.map';
3751 const resolved = resolve(input, base);
3752 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
3753 });
3754
3755 it('normalizes too many parent accessors', () => {
3756 const base = '/root?baseQuery';
3757 const input = '//protocol-relative.com/../main.js.map';
3758 const resolved = resolve(input, base);
3759 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
3760 });
3761
3762 it('normalizes too many parent accessors, late', () => {
3763 const base = '/root?baseQuery';
3764 const input = '//protocol-relative.com/foo/../../main.js.map';
3765 const resolved = resolve(input, base);
3766 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
3767 });
3768 });
3769
3770 describe('with absolute path input', () => {
3771 it('remains absolute path', () => {
3772 const base = '/root?baseQuery';
3773 const input = '/assets/main.js.map';
3774 const resolved = resolve(input, base);
3775 assert.strictEqual(resolved, '/assets/main.js.map');
3776 });
3777
3778 it('remains absolute path with query', () => {
3779 const base = '/root?baseQuery';
3780 const input = '/assets/main.js.map?input';
3781 const resolved = resolve(input, base);
3782 assert.strictEqual(resolved, '/assets/main.js.map?input');
3783 });
3784
3785 it('trims to root', () => {
3786 const base = '/root?baseQuery';
3787 const input = '/';
3788 const resolved = resolve(input, base);
3789 assert.strictEqual(resolved, '/');
3790 });
3791
3792 it('normalizes input path', () => {
3793 const base = '/root?baseQuery';
3794 const input = '/foo/./bar/../main.js.map';
3795 const resolved = resolve(input, base);
3796 assert.strictEqual(resolved, '/foo/main.js.map');
3797 });
3798
3799 it('normalizes current directory', () => {
3800 const base = '/root?baseQuery';
3801 const input = '/./main.js.map';
3802 const resolved = resolve(input, base);
3803 assert.strictEqual(resolved, '/main.js.map');
3804 });
3805
3806 it('normalizes too many parent accessors', () => {
3807 const base = '/root?baseQuery';
3808 const input = '/../../../main.js.map';
3809 const resolved = resolve(input, base);
3810 assert.strictEqual(resolved, '/main.js.map');
3811 });
3812
3813 it('normalizes too many parent accessors with query 1', () => {
3814 const base = '/root?baseQuery';
3815 const input = '/../../../?input';
3816 const resolved = resolve(input, base);
3817 assert.strictEqual(resolved, '/?input');
3818 });
3819
3820 it('normalizes too many parent accessors with query 2', () => {
3821 const base = '/root?baseQuery';
3822 const input = '/../../..?input';
3823 const resolved = resolve(input, base);
3824 assert.strictEqual(resolved, '/?input');
3825 });
3826
3827 it('normalizes too many parent accessors, late', () => {
3828 const base = '/root?baseQuery';
3829 const input = '/foo/../../../main.js.map';
3830 const resolved = resolve(input, base);
3831 assert.strictEqual(resolved, '/main.js.map');
3832 });
3833 });
3834
3835 describe('with leading dot relative input', () => {
3836 it('resolves relative to current directory', () => {
3837 const base = '/root?baseQuery';
3838 const input = './bar/main.js.map';
3839 const resolved = resolve(input, base);
3840 assert.strictEqual(resolved, '/bar/main.js.map');
3841 });
3842
3843 it('resolves relative to current directory with query', () => {
3844 const base = '/root?baseQuery';
3845 const input = './bar/main.js.map?input';
3846 const resolved = resolve(input, base);
3847 assert.strictEqual(resolved, '/bar/main.js.map?input');
3848 });
3849
3850 it('resolves relative to parent directory', () => {
3851 const base = '/root?baseQuery';
3852 const input = '../bar/main.js.map';
3853 const resolved = resolve(input, base);
3854 assert.strictEqual(resolved, '/bar/main.js.map');
3855 });
3856
3857 it('resolves relative to parent directory with query', () => {
3858 const base = '/root?baseQuery';
3859 const input = '../bar/main.js.map?input';
3860 const resolved = resolve(input, base);
3861 assert.strictEqual(resolved, '/bar/main.js.map?input');
3862 });
3863
3864 it('resolves relative to parent multiple directory', () => {
3865 const base = '/root?baseQuery';
3866 const input = '../../../bar/main.js.map';
3867 const resolved = resolve(input, base);
3868 assert.strictEqual(resolved, '/bar/main.js.map');
3869 });
3870
3871 it('resolves relative to parent multiple directory with query 1', () => {
3872 const base = '/root?baseQuery';
3873 const input = '../../../?input';
3874 const resolved = resolve(input, base);
3875 assert.strictEqual(resolved, '/?input');
3876 });
3877
3878 it('resolves relative to parent multiple directory with query 2', () => {
3879 const base = '/root?baseQuery';
3880 const input = '../../..?input';
3881 const resolved = resolve(input, base);
3882 assert.strictEqual(resolved, '/?input');
3883 });
3884
3885 it('normalizes input path', () => {
3886 const base = '/root?baseQuery';
3887 const input = './foo/./bar/../main.js.map';
3888 const resolved = resolve(input, base);
3889 assert.strictEqual(resolved, '/foo/main.js.map');
3890 });
3891 });
3892
3893 describe('with relative path input', () => {
3894 it('resolves relative to current directory', () => {
3895 const base = '/root?baseQuery';
3896 const input = 'bar/main.js.map';
3897 const resolved = resolve(input, base);
3898 assert.strictEqual(resolved, '/bar/main.js.map');
3899 });
3900
3901 it('resolves relative to current directory with query', () => {
3902 const base = '/root?baseQuery';
3903 const input = 'bar/main.js.map?input';
3904 const resolved = resolve(input, base);
3905 assert.strictEqual(resolved, '/bar/main.js.map?input');
3906 });
3907
3908 it('resolves relative to parent multiple directory, later', () => {
3909 const base = '/root?baseQuery';
3910 const input = 'foo/../../../bar/main.js.map';
3911 const resolved = resolve(input, base);
3912 assert.strictEqual(resolved, '/bar/main.js.map');
3913 });
3914
3915 it('normalizes input path', () => {
3916 const base = '/root?baseQuery';
3917 const input = 'foo/./bar/../main.js.map';
3918 const resolved = resolve(input, base);
3919 assert.strictEqual(resolved, '/foo/main.js.map');
3920 });
3921
3922 it('resolves node_module scope as path', () => {
3923 const base = '/root?baseQuery';
3924 const input = 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js';
3925 const resolved = resolve(input, base);
3926 assert.strictEqual(resolved, '/node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js');
3927 });
3928
3929 it('resolves package scope as path', () => {
3930 const base = '/root?baseQuery';
3931 const input = '@babel/runtime/helpers/esm/arrayLikeToArray.js';
3932 const resolved = resolve(input, base);
3933 assert.strictEqual(resolved, '/@babel/runtime/helpers/esm/arrayLikeToArray.js');
3934 });
3935 });
3936
3937 describe('with query input', () => {
3938 it('resolves relative to path', () => {
3939 const base = '/root?baseQuery';
3940 const input = '?input';
3941 const resolved = resolve(input, base);
3942 assert.strictEqual(resolved, '/root?input');
3943 });
3944 });
3945
3946 describe('with hash input', () => {
3947 it('resolves relative to path', () => {
3948 const base = '/root?baseQuery';
3949 const input = '#input';
3950 const resolved = resolve(input, base);
3951 assert.strictEqual(resolved, '/root?baseQuery#input');
3952 });
3953 });
3954
3955 describe('empty input', () => {
3956 it('normalizes base', () => {
3957 const base = '/root?baseQuery';
3958 const input = '';
3959 const resolved = resolve(input, base);
3960 assert.strictEqual(resolved, '/root?baseQuery');
3961 });
3962 });
3963 });
3964
3965 describe(`base = "/root?baseQuery#baseHash"`, () => {
3966 describe('with absolute input', () => {
3967 it('returns input', () => {
3968 const base = '/root?baseQuery#baseHash';
3969 const input = 'https://absolute.com/main.js.map';
3970 const resolved = resolve(input, base);
3971 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
3972 });
3973
3974 it('returns input with query', () => {
3975 const base = '/root?baseQuery#baseHash';
3976 const input = 'https://absolute.com/main.js.map?input';
3977 const resolved = resolve(input, base);
3978 assert.strictEqual(resolved, 'https://absolute.com/main.js.map?input');
3979 });
3980
3981 it('normalizes input path', () => {
3982 const base = '/root?baseQuery#baseHash';
3983 const input = 'https://absolute.com/foo/./bar/../main.js.map';
3984 const resolved = resolve(input, base);
3985 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map');
3986 });
3987
3988 it('normalizes input path with query', () => {
3989 const base = '/root?baseQuery#baseHash';
3990 const input = 'https://absolute.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
3991 const resolved = resolve(input, base);
3992 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map?input!webpack://foo/./bar');
3993 });
3994
3995 it('normalizes pathless input', () => {
3996 const base = '/root?baseQuery#baseHash';
3997 const input = 'https://absolute.com';
3998 const resolved = resolve(input, base);
3999 assert.strictEqual(resolved, 'https://absolute.com/');
4000 });
4001
4002 it('normalizes pathless input with query', () => {
4003 const base = '/root?baseQuery#baseHash';
4004 const input = 'https://absolute.com?input';
4005 const resolved = resolve(input, base);
4006 assert.strictEqual(resolved, 'https://absolute.com/?input');
4007 });
4008
4009 it('normalizes current directory', () => {
4010 const base = '/root?baseQuery#baseHash';
4011 const input = 'https://absolute.com/./main.js.map';
4012 const resolved = resolve(input, base);
4013 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
4014 });
4015
4016 it('normalizes too many parent accessors', () => {
4017 const base = '/root?baseQuery#baseHash';
4018 const input = 'https://absolute.com/../../../main.js.map';
4019 const resolved = resolve(input, base);
4020 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
4021 });
4022
4023 it('normalizes too many parent accessors, late', () => {
4024 const base = '/root?baseQuery#baseHash';
4025 const input = 'https://absolute.com/foo/../../../main.js.map';
4026 const resolved = resolve(input, base);
4027 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
4028 });
4029
4030 it('normalizes file protocol 1', () => {
4031 const base = '/root?baseQuery#baseHash';
4032 const input = 'file:///root/main.js.map';
4033 const resolved = resolve(input, base);
4034 assert.strictEqual(resolved, 'file:///root/main.js.map');
4035 });
4036
4037 it('normalizes file protocol 2', () => {
4038 const base = '/root?baseQuery#baseHash';
4039 const input = 'file://root/main.js.map';
4040 const resolved = resolve(input, base);
4041 assert.strictEqual(resolved, 'file://root/main.js.map');
4042 });
4043
4044 it('normalizes file protocol 2.5', () => {
4045 const base = '/root?baseQuery#baseHash';
4046 const input = 'file://root';
4047 const resolved = resolve(input, base);
4048 assert.strictEqual(resolved, 'file://root/');
4049 });
4050
4051 it('normalizes file protocol 3', () => {
4052 const base = '/root?baseQuery#baseHash';
4053 const input = 'file:/root/main.js.map';
4054 const resolved = resolve(input, base);
4055 assert.strictEqual(resolved, 'file:///root/main.js.map');
4056 });
4057
4058 it('normalizes file protocol 4', () => {
4059 const base = '/root?baseQuery#baseHash';
4060 const input = 'file:root/main.js.map';
4061 const resolved = resolve(input, base);
4062 assert.strictEqual(resolved, 'file:///root/main.js.map');
4063 });
4064
4065 it('normalizes file protocol 1 with query', () => {
4066 const base = '/root?baseQuery#baseHash';
4067 const input = 'file:///root/main.js.map?input';
4068 const resolved = resolve(input, base);
4069 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
4070 });
4071
4072 it('normalizes file protocol 2 with query', () => {
4073 const base = '/root?baseQuery#baseHash';
4074 const input = 'file://root/main.js.map?input';
4075 const resolved = resolve(input, base);
4076 assert.strictEqual(resolved, 'file://root/main.js.map?input');
4077 });
4078
4079 it('normalizes file protocol 2.5 with query', () => {
4080 const base = '/root?baseQuery#baseHash';
4081 const input = 'file://root?input';
4082 const resolved = resolve(input, base);
4083 assert.strictEqual(resolved, 'file://root/?input');
4084 });
4085
4086 it('normalizes file protocol 3 with query', () => {
4087 const base = '/root?baseQuery#baseHash';
4088 const input = 'file:/root/main.js.map?input';
4089 const resolved = resolve(input, base);
4090 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
4091 });
4092
4093 it('normalizes file protocol 4 with query', () => {
4094 const base = '/root?baseQuery#baseHash';
4095 const input = 'file:root/main.js.map?input';
4096 const resolved = resolve(input, base);
4097 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
4098 });
4099 });
4100
4101 describe('with protocol relative input', () => {
4102 it('resolves relative to the base protocol', () => {
4103 const base = '/root?baseQuery#baseHash';
4104 const input = '//protocol-relative.com/main.js.map';
4105 const resolved = resolve(input, base);
4106 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
4107 });
4108
4109 it('resolves relative to the base protocol with query', () => {
4110 const base = '/root?baseQuery#baseHash';
4111 const input = '//protocol-relative.com/main.js.map?input';
4112 const resolved = resolve(input, base);
4113 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map?input');
4114 });
4115
4116 it('normalizes input path', () => {
4117 const base = '/root?baseQuery#baseHash';
4118 const input = '//protocol-relative.com/foo/./bar/../main.js.map';
4119 const resolved = resolve(input, base);
4120 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map');
4121 });
4122
4123 it('normalizes input path with query', () => {
4124 const base = '/root?baseQuery#baseHash';
4125 const input = '//protocol-relative.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
4126 const resolved = resolve(input, base);
4127 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map?input!webpack://foo/./bar');
4128 });
4129
4130 it('normalizes pathless input', () => {
4131 const base = '/root?baseQuery#baseHash';
4132 const input = '//protocol-relative.com';
4133 const resolved = resolve(input, base);
4134 assert.strictEqual(resolved, '//protocol-relative.com/');
4135 });
4136
4137 it('normalizes pathless input with query', () => {
4138 const base = '/root?baseQuery#baseHash';
4139 const input = '//protocol-relative.com?input';
4140 const resolved = resolve(input, base);
4141 assert.strictEqual(resolved, '//protocol-relative.com/?input');
4142 });
4143
4144 it('normalizes current directory', () => {
4145 const base = '/root?baseQuery#baseHash';
4146 const input = '//protocol-relative.com/./main.js.map';
4147 const resolved = resolve(input, base);
4148 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
4149 });
4150
4151 it('normalizes too many parent accessors', () => {
4152 const base = '/root?baseQuery#baseHash';
4153 const input = '//protocol-relative.com/../main.js.map';
4154 const resolved = resolve(input, base);
4155 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
4156 });
4157
4158 it('normalizes too many parent accessors, late', () => {
4159 const base = '/root?baseQuery#baseHash';
4160 const input = '//protocol-relative.com/foo/../../main.js.map';
4161 const resolved = resolve(input, base);
4162 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
4163 });
4164 });
4165
4166 describe('with absolute path input', () => {
4167 it('remains absolute path', () => {
4168 const base = '/root?baseQuery#baseHash';
4169 const input = '/assets/main.js.map';
4170 const resolved = resolve(input, base);
4171 assert.strictEqual(resolved, '/assets/main.js.map');
4172 });
4173
4174 it('remains absolute path with query', () => {
4175 const base = '/root?baseQuery#baseHash';
4176 const input = '/assets/main.js.map?input';
4177 const resolved = resolve(input, base);
4178 assert.strictEqual(resolved, '/assets/main.js.map?input');
4179 });
4180
4181 it('trims to root', () => {
4182 const base = '/root?baseQuery#baseHash';
4183 const input = '/';
4184 const resolved = resolve(input, base);
4185 assert.strictEqual(resolved, '/');
4186 });
4187
4188 it('normalizes input path', () => {
4189 const base = '/root?baseQuery#baseHash';
4190 const input = '/foo/./bar/../main.js.map';
4191 const resolved = resolve(input, base);
4192 assert.strictEqual(resolved, '/foo/main.js.map');
4193 });
4194
4195 it('normalizes current directory', () => {
4196 const base = '/root?baseQuery#baseHash';
4197 const input = '/./main.js.map';
4198 const resolved = resolve(input, base);
4199 assert.strictEqual(resolved, '/main.js.map');
4200 });
4201
4202 it('normalizes too many parent accessors', () => {
4203 const base = '/root?baseQuery#baseHash';
4204 const input = '/../../../main.js.map';
4205 const resolved = resolve(input, base);
4206 assert.strictEqual(resolved, '/main.js.map');
4207 });
4208
4209 it('normalizes too many parent accessors with query 1', () => {
4210 const base = '/root?baseQuery#baseHash';
4211 const input = '/../../../?input';
4212 const resolved = resolve(input, base);
4213 assert.strictEqual(resolved, '/?input');
4214 });
4215
4216 it('normalizes too many parent accessors with query 2', () => {
4217 const base = '/root?baseQuery#baseHash';
4218 const input = '/../../..?input';
4219 const resolved = resolve(input, base);
4220 assert.strictEqual(resolved, '/?input');
4221 });
4222
4223 it('normalizes too many parent accessors, late', () => {
4224 const base = '/root?baseQuery#baseHash';
4225 const input = '/foo/../../../main.js.map';
4226 const resolved = resolve(input, base);
4227 assert.strictEqual(resolved, '/main.js.map');
4228 });
4229 });
4230
4231 describe('with leading dot relative input', () => {
4232 it('resolves relative to current directory', () => {
4233 const base = '/root?baseQuery#baseHash';
4234 const input = './bar/main.js.map';
4235 const resolved = resolve(input, base);
4236 assert.strictEqual(resolved, '/bar/main.js.map');
4237 });
4238
4239 it('resolves relative to current directory with query', () => {
4240 const base = '/root?baseQuery#baseHash';
4241 const input = './bar/main.js.map?input';
4242 const resolved = resolve(input, base);
4243 assert.strictEqual(resolved, '/bar/main.js.map?input');
4244 });
4245
4246 it('resolves relative to parent directory', () => {
4247 const base = '/root?baseQuery#baseHash';
4248 const input = '../bar/main.js.map';
4249 const resolved = resolve(input, base);
4250 assert.strictEqual(resolved, '/bar/main.js.map');
4251 });
4252
4253 it('resolves relative to parent directory with query', () => {
4254 const base = '/root?baseQuery#baseHash';
4255 const input = '../bar/main.js.map?input';
4256 const resolved = resolve(input, base);
4257 assert.strictEqual(resolved, '/bar/main.js.map?input');
4258 });
4259
4260 it('resolves relative to parent multiple directory', () => {
4261 const base = '/root?baseQuery#baseHash';
4262 const input = '../../../bar/main.js.map';
4263 const resolved = resolve(input, base);
4264 assert.strictEqual(resolved, '/bar/main.js.map');
4265 });
4266
4267 it('resolves relative to parent multiple directory with query 1', () => {
4268 const base = '/root?baseQuery#baseHash';
4269 const input = '../../../?input';
4270 const resolved = resolve(input, base);
4271 assert.strictEqual(resolved, '/?input');
4272 });
4273
4274 it('resolves relative to parent multiple directory with query 2', () => {
4275 const base = '/root?baseQuery#baseHash';
4276 const input = '../../..?input';
4277 const resolved = resolve(input, base);
4278 assert.strictEqual(resolved, '/?input');
4279 });
4280
4281 it('normalizes input path', () => {
4282 const base = '/root?baseQuery#baseHash';
4283 const input = './foo/./bar/../main.js.map';
4284 const resolved = resolve(input, base);
4285 assert.strictEqual(resolved, '/foo/main.js.map');
4286 });
4287 });
4288
4289 describe('with relative path input', () => {
4290 it('resolves relative to current directory', () => {
4291 const base = '/root?baseQuery#baseHash';
4292 const input = 'bar/main.js.map';
4293 const resolved = resolve(input, base);
4294 assert.strictEqual(resolved, '/bar/main.js.map');
4295 });
4296
4297 it('resolves relative to current directory with query', () => {
4298 const base = '/root?baseQuery#baseHash';
4299 const input = 'bar/main.js.map?input';
4300 const resolved = resolve(input, base);
4301 assert.strictEqual(resolved, '/bar/main.js.map?input');
4302 });
4303
4304 it('resolves relative to parent multiple directory, later', () => {
4305 const base = '/root?baseQuery#baseHash';
4306 const input = 'foo/../../../bar/main.js.map';
4307 const resolved = resolve(input, base);
4308 assert.strictEqual(resolved, '/bar/main.js.map');
4309 });
4310
4311 it('normalizes input path', () => {
4312 const base = '/root?baseQuery#baseHash';
4313 const input = 'foo/./bar/../main.js.map';
4314 const resolved = resolve(input, base);
4315 assert.strictEqual(resolved, '/foo/main.js.map');
4316 });
4317
4318 it('resolves node_module scope as path', () => {
4319 const base = '/root?baseQuery#baseHash';
4320 const input = 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js';
4321 const resolved = resolve(input, base);
4322 assert.strictEqual(resolved, '/node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js');
4323 });
4324
4325 it('resolves package scope as path', () => {
4326 const base = '/root?baseQuery#baseHash';
4327 const input = '@babel/runtime/helpers/esm/arrayLikeToArray.js';
4328 const resolved = resolve(input, base);
4329 assert.strictEqual(resolved, '/@babel/runtime/helpers/esm/arrayLikeToArray.js');
4330 });
4331 });
4332
4333 describe('with query input', () => {
4334 it('resolves relative to path', () => {
4335 const base = '/root?baseQuery#baseHash';
4336 const input = '?input';
4337 const resolved = resolve(input, base);
4338 assert.strictEqual(resolved, '/root?input');
4339 });
4340 });
4341
4342 describe('with hash input', () => {
4343 it('resolves relative to path', () => {
4344 const base = '/root?baseQuery#baseHash';
4345 const input = '#input';
4346 const resolved = resolve(input, base);
4347 assert.strictEqual(resolved, '/root?baseQuery#input');
4348 });
4349 });
4350
4351 describe('empty input', () => {
4352 it('normalizes base', () => {
4353 const base = '/root?baseQuery#baseHash';
4354 const input = '';
4355 const resolved = resolve(input, base);
4356 assert.strictEqual(resolved, '/root?baseQuery#baseHash');
4357 });
4358 });
4359 });
4360
4361 describe(`base = "/root#baseHash"`, () => {
4362 describe('with absolute input', () => {
4363 it('returns input', () => {
4364 const base = '/root#baseHash';
4365 const input = 'https://absolute.com/main.js.map';
4366 const resolved = resolve(input, base);
4367 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
4368 });
4369
4370 it('returns input with query', () => {
4371 const base = '/root#baseHash';
4372 const input = 'https://absolute.com/main.js.map?input';
4373 const resolved = resolve(input, base);
4374 assert.strictEqual(resolved, 'https://absolute.com/main.js.map?input');
4375 });
4376
4377 it('normalizes input path', () => {
4378 const base = '/root#baseHash';
4379 const input = 'https://absolute.com/foo/./bar/../main.js.map';
4380 const resolved = resolve(input, base);
4381 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map');
4382 });
4383
4384 it('normalizes input path with query', () => {
4385 const base = '/root#baseHash';
4386 const input = 'https://absolute.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
4387 const resolved = resolve(input, base);
4388 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map?input!webpack://foo/./bar');
4389 });
4390
4391 it('normalizes pathless input', () => {
4392 const base = '/root#baseHash';
4393 const input = 'https://absolute.com';
4394 const resolved = resolve(input, base);
4395 assert.strictEqual(resolved, 'https://absolute.com/');
4396 });
4397
4398 it('normalizes pathless input with query', () => {
4399 const base = '/root#baseHash';
4400 const input = 'https://absolute.com?input';
4401 const resolved = resolve(input, base);
4402 assert.strictEqual(resolved, 'https://absolute.com/?input');
4403 });
4404
4405 it('normalizes current directory', () => {
4406 const base = '/root#baseHash';
4407 const input = 'https://absolute.com/./main.js.map';
4408 const resolved = resolve(input, base);
4409 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
4410 });
4411
4412 it('normalizes too many parent accessors', () => {
4413 const base = '/root#baseHash';
4414 const input = 'https://absolute.com/../../../main.js.map';
4415 const resolved = resolve(input, base);
4416 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
4417 });
4418
4419 it('normalizes too many parent accessors, late', () => {
4420 const base = '/root#baseHash';
4421 const input = 'https://absolute.com/foo/../../../main.js.map';
4422 const resolved = resolve(input, base);
4423 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
4424 });
4425
4426 it('normalizes file protocol 1', () => {
4427 const base = '/root#baseHash';
4428 const input = 'file:///root/main.js.map';
4429 const resolved = resolve(input, base);
4430 assert.strictEqual(resolved, 'file:///root/main.js.map');
4431 });
4432
4433 it('normalizes file protocol 2', () => {
4434 const base = '/root#baseHash';
4435 const input = 'file://root/main.js.map';
4436 const resolved = resolve(input, base);
4437 assert.strictEqual(resolved, 'file://root/main.js.map');
4438 });
4439
4440 it('normalizes file protocol 2.5', () => {
4441 const base = '/root#baseHash';
4442 const input = 'file://root';
4443 const resolved = resolve(input, base);
4444 assert.strictEqual(resolved, 'file://root/');
4445 });
4446
4447 it('normalizes file protocol 3', () => {
4448 const base = '/root#baseHash';
4449 const input = 'file:/root/main.js.map';
4450 const resolved = resolve(input, base);
4451 assert.strictEqual(resolved, 'file:///root/main.js.map');
4452 });
4453
4454 it('normalizes file protocol 4', () => {
4455 const base = '/root#baseHash';
4456 const input = 'file:root/main.js.map';
4457 const resolved = resolve(input, base);
4458 assert.strictEqual(resolved, 'file:///root/main.js.map');
4459 });
4460
4461 it('normalizes file protocol 1 with query', () => {
4462 const base = '/root#baseHash';
4463 const input = 'file:///root/main.js.map?input';
4464 const resolved = resolve(input, base);
4465 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
4466 });
4467
4468 it('normalizes file protocol 2 with query', () => {
4469 const base = '/root#baseHash';
4470 const input = 'file://root/main.js.map?input';
4471 const resolved = resolve(input, base);
4472 assert.strictEqual(resolved, 'file://root/main.js.map?input');
4473 });
4474
4475 it('normalizes file protocol 2.5 with query', () => {
4476 const base = '/root#baseHash';
4477 const input = 'file://root?input';
4478 const resolved = resolve(input, base);
4479 assert.strictEqual(resolved, 'file://root/?input');
4480 });
4481
4482 it('normalizes file protocol 3 with query', () => {
4483 const base = '/root#baseHash';
4484 const input = 'file:/root/main.js.map?input';
4485 const resolved = resolve(input, base);
4486 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
4487 });
4488
4489 it('normalizes file protocol 4 with query', () => {
4490 const base = '/root#baseHash';
4491 const input = 'file:root/main.js.map?input';
4492 const resolved = resolve(input, base);
4493 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
4494 });
4495 });
4496
4497 describe('with protocol relative input', () => {
4498 it('resolves relative to the base protocol', () => {
4499 const base = '/root#baseHash';
4500 const input = '//protocol-relative.com/main.js.map';
4501 const resolved = resolve(input, base);
4502 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
4503 });
4504
4505 it('resolves relative to the base protocol with query', () => {
4506 const base = '/root#baseHash';
4507 const input = '//protocol-relative.com/main.js.map?input';
4508 const resolved = resolve(input, base);
4509 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map?input');
4510 });
4511
4512 it('normalizes input path', () => {
4513 const base = '/root#baseHash';
4514 const input = '//protocol-relative.com/foo/./bar/../main.js.map';
4515 const resolved = resolve(input, base);
4516 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map');
4517 });
4518
4519 it('normalizes input path with query', () => {
4520 const base = '/root#baseHash';
4521 const input = '//protocol-relative.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
4522 const resolved = resolve(input, base);
4523 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map?input!webpack://foo/./bar');
4524 });
4525
4526 it('normalizes pathless input', () => {
4527 const base = '/root#baseHash';
4528 const input = '//protocol-relative.com';
4529 const resolved = resolve(input, base);
4530 assert.strictEqual(resolved, '//protocol-relative.com/');
4531 });
4532
4533 it('normalizes pathless input with query', () => {
4534 const base = '/root#baseHash';
4535 const input = '//protocol-relative.com?input';
4536 const resolved = resolve(input, base);
4537 assert.strictEqual(resolved, '//protocol-relative.com/?input');
4538 });
4539
4540 it('normalizes current directory', () => {
4541 const base = '/root#baseHash';
4542 const input = '//protocol-relative.com/./main.js.map';
4543 const resolved = resolve(input, base);
4544 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
4545 });
4546
4547 it('normalizes too many parent accessors', () => {
4548 const base = '/root#baseHash';
4549 const input = '//protocol-relative.com/../main.js.map';
4550 const resolved = resolve(input, base);
4551 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
4552 });
4553
4554 it('normalizes too many parent accessors, late', () => {
4555 const base = '/root#baseHash';
4556 const input = '//protocol-relative.com/foo/../../main.js.map';
4557 const resolved = resolve(input, base);
4558 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
4559 });
4560 });
4561
4562 describe('with absolute path input', () => {
4563 it('remains absolute path', () => {
4564 const base = '/root#baseHash';
4565 const input = '/assets/main.js.map';
4566 const resolved = resolve(input, base);
4567 assert.strictEqual(resolved, '/assets/main.js.map');
4568 });
4569
4570 it('remains absolute path with query', () => {
4571 const base = '/root#baseHash';
4572 const input = '/assets/main.js.map?input';
4573 const resolved = resolve(input, base);
4574 assert.strictEqual(resolved, '/assets/main.js.map?input');
4575 });
4576
4577 it('trims to root', () => {
4578 const base = '/root#baseHash';
4579 const input = '/';
4580 const resolved = resolve(input, base);
4581 assert.strictEqual(resolved, '/');
4582 });
4583
4584 it('normalizes input path', () => {
4585 const base = '/root#baseHash';
4586 const input = '/foo/./bar/../main.js.map';
4587 const resolved = resolve(input, base);
4588 assert.strictEqual(resolved, '/foo/main.js.map');
4589 });
4590
4591 it('normalizes current directory', () => {
4592 const base = '/root#baseHash';
4593 const input = '/./main.js.map';
4594 const resolved = resolve(input, base);
4595 assert.strictEqual(resolved, '/main.js.map');
4596 });
4597
4598 it('normalizes too many parent accessors', () => {
4599 const base = '/root#baseHash';
4600 const input = '/../../../main.js.map';
4601 const resolved = resolve(input, base);
4602 assert.strictEqual(resolved, '/main.js.map');
4603 });
4604
4605 it('normalizes too many parent accessors with query 1', () => {
4606 const base = '/root#baseHash';
4607 const input = '/../../../?input';
4608 const resolved = resolve(input, base);
4609 assert.strictEqual(resolved, '/?input');
4610 });
4611
4612 it('normalizes too many parent accessors with query 2', () => {
4613 const base = '/root#baseHash';
4614 const input = '/../../..?input';
4615 const resolved = resolve(input, base);
4616 assert.strictEqual(resolved, '/?input');
4617 });
4618
4619 it('normalizes too many parent accessors, late', () => {
4620 const base = '/root#baseHash';
4621 const input = '/foo/../../../main.js.map';
4622 const resolved = resolve(input, base);
4623 assert.strictEqual(resolved, '/main.js.map');
4624 });
4625 });
4626
4627 describe('with leading dot relative input', () => {
4628 it('resolves relative to current directory', () => {
4629 const base = '/root#baseHash';
4630 const input = './bar/main.js.map';
4631 const resolved = resolve(input, base);
4632 assert.strictEqual(resolved, '/bar/main.js.map');
4633 });
4634
4635 it('resolves relative to current directory with query', () => {
4636 const base = '/root#baseHash';
4637 const input = './bar/main.js.map?input';
4638 const resolved = resolve(input, base);
4639 assert.strictEqual(resolved, '/bar/main.js.map?input');
4640 });
4641
4642 it('resolves relative to parent directory', () => {
4643 const base = '/root#baseHash';
4644 const input = '../bar/main.js.map';
4645 const resolved = resolve(input, base);
4646 assert.strictEqual(resolved, '/bar/main.js.map');
4647 });
4648
4649 it('resolves relative to parent directory with query', () => {
4650 const base = '/root#baseHash';
4651 const input = '../bar/main.js.map?input';
4652 const resolved = resolve(input, base);
4653 assert.strictEqual(resolved, '/bar/main.js.map?input');
4654 });
4655
4656 it('resolves relative to parent multiple directory', () => {
4657 const base = '/root#baseHash';
4658 const input = '../../../bar/main.js.map';
4659 const resolved = resolve(input, base);
4660 assert.strictEqual(resolved, '/bar/main.js.map');
4661 });
4662
4663 it('resolves relative to parent multiple directory with query 1', () => {
4664 const base = '/root#baseHash';
4665 const input = '../../../?input';
4666 const resolved = resolve(input, base);
4667 assert.strictEqual(resolved, '/?input');
4668 });
4669
4670 it('resolves relative to parent multiple directory with query 2', () => {
4671 const base = '/root#baseHash';
4672 const input = '../../..?input';
4673 const resolved = resolve(input, base);
4674 assert.strictEqual(resolved, '/?input');
4675 });
4676
4677 it('normalizes input path', () => {
4678 const base = '/root#baseHash';
4679 const input = './foo/./bar/../main.js.map';
4680 const resolved = resolve(input, base);
4681 assert.strictEqual(resolved, '/foo/main.js.map');
4682 });
4683 });
4684
4685 describe('with relative path input', () => {
4686 it('resolves relative to current directory', () => {
4687 const base = '/root#baseHash';
4688 const input = 'bar/main.js.map';
4689 const resolved = resolve(input, base);
4690 assert.strictEqual(resolved, '/bar/main.js.map');
4691 });
4692
4693 it('resolves relative to current directory with query', () => {
4694 const base = '/root#baseHash';
4695 const input = 'bar/main.js.map?input';
4696 const resolved = resolve(input, base);
4697 assert.strictEqual(resolved, '/bar/main.js.map?input');
4698 });
4699
4700 it('resolves relative to parent multiple directory, later', () => {
4701 const base = '/root#baseHash';
4702 const input = 'foo/../../../bar/main.js.map';
4703 const resolved = resolve(input, base);
4704 assert.strictEqual(resolved, '/bar/main.js.map');
4705 });
4706
4707 it('normalizes input path', () => {
4708 const base = '/root#baseHash';
4709 const input = 'foo/./bar/../main.js.map';
4710 const resolved = resolve(input, base);
4711 assert.strictEqual(resolved, '/foo/main.js.map');
4712 });
4713
4714 it('resolves node_module scope as path', () => {
4715 const base = '/root#baseHash';
4716 const input = 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js';
4717 const resolved = resolve(input, base);
4718 assert.strictEqual(resolved, '/node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js');
4719 });
4720
4721 it('resolves package scope as path', () => {
4722 const base = '/root#baseHash';
4723 const input = '@babel/runtime/helpers/esm/arrayLikeToArray.js';
4724 const resolved = resolve(input, base);
4725 assert.strictEqual(resolved, '/@babel/runtime/helpers/esm/arrayLikeToArray.js');
4726 });
4727 });
4728
4729 describe('with query input', () => {
4730 it('resolves relative to path', () => {
4731 const base = '/root#baseHash';
4732 const input = '?input';
4733 const resolved = resolve(input, base);
4734 assert.strictEqual(resolved, '/root?input');
4735 });
4736 });
4737
4738 describe('with hash input', () => {
4739 it('resolves relative to path', () => {
4740 const base = '/root#baseHash';
4741 const input = '#input';
4742 const resolved = resolve(input, base);
4743 assert.strictEqual(resolved, '/root#input');
4744 });
4745 });
4746
4747 describe('empty input', () => {
4748 it('normalizes base', () => {
4749 const base = '/root#baseHash';
4750 const input = '';
4751 const resolved = resolve(input, base);
4752 assert.strictEqual(resolved, '/root#baseHash');
4753 });
4754 });
4755 });
4756 });