Debian Codegraph @

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

raw
1 const resolve = require('../..');
2 const assert = require('assert');
3
4 describe('with relative path base', () => {
5 describe(`base = "file"`, () => {
6 describe('with absolute input', () => {
7 it('returns input', () => {
8 const base = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
223 const input = '/';
224 const resolved = resolve(input, base);
225 assert.strictEqual(resolved, '/');
226 });
227
228 it('normalizes input path', () => {
229 const base = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
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 = 'file';
376 const input = '?input';
377 const resolved = resolve(input, base);
378 assert.strictEqual(resolved, 'file?input');
379 });
380 });
381
382 describe('with hash input', () => {
383 it('resolves relative to path', () => {
384 const base = 'file';
385 const input = '#input';
386 const resolved = resolve(input, base);
387 assert.strictEqual(resolved, 'file#input');
388 });
389 });
390
391 describe('empty input', () => {
392 it('normalizes base', () => {
393 const base = 'file';
394 const input = '';
395 const resolved = resolve(input, base);
396 assert.strictEqual(resolved, 'file');
397 });
398 });
399 });
400
401 describe(`base = "dir/"`, () => {
402 describe('with absolute input', () => {
403 it('returns input', () => {
404 const base = 'dir/';
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 = 'dir/';
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 = 'dir/';
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 = 'dir/';
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 = 'dir/';
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 = 'dir/';
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 = 'dir/';
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 = 'dir/';
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 = 'dir/';
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 = 'dir/';
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 = 'dir/';
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 = 'dir/';
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 = 'dir/';
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 = 'dir/';
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 = 'dir/';
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 = 'dir/';
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 = 'dir/';
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 = 'dir/';
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 = 'dir/';
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 = 'dir/';
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 = 'dir/';
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 = 'dir/';
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 = 'dir/';
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 = 'dir/';
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 = 'dir/';
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 = 'dir/';
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 = 'dir/';
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 = 'dir/';
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 = 'dir/';
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 = 'dir/';
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 = 'dir/';
619 const input = '/';
620 const resolved = resolve(input, base);
621 assert.strictEqual(resolved, '/');
622 });
623
624 it('normalizes input path', () => {
625 const base = 'dir/';
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 = 'dir/';
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 = 'dir/';
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 = 'dir/';
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 = 'dir/';
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 = 'dir/';
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 = 'dir/';
670 const input = './bar/main.js.map';
671 const resolved = resolve(input, base);
672 assert.strictEqual(resolved, 'dir/bar/main.js.map');
673 });
674
675 it('resolves relative to current directory with query', () => {
676 const base = 'dir/';
677 const input = './bar/main.js.map?input';
678 const resolved = resolve(input, base);
679 assert.strictEqual(resolved, 'dir/bar/main.js.map?input');
680 });
681
682 it('resolves relative to parent directory', () => {
683 const base = 'dir/';
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 = 'dir/';
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 = 'dir/';
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 = 'dir/';
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 = 'dir/';
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 = 'dir/';
719 const input = './foo/./bar/../main.js.map';
720 const resolved = resolve(input, base);
721 assert.strictEqual(resolved, 'dir/foo/main.js.map');
722 });
723 });
724
725 describe('with relative path input', () => {
726 it('resolves relative to current directory', () => {
727 const base = 'dir/';
728 const input = 'bar/main.js.map';
729 const resolved = resolve(input, base);
730 assert.strictEqual(resolved, 'dir/bar/main.js.map');
731 });
732
733 it('resolves relative to current directory with query', () => {
734 const base = 'dir/';
735 const input = 'bar/main.js.map?input';
736 const resolved = resolve(input, base);
737 assert.strictEqual(resolved, 'dir/bar/main.js.map?input');
738 });
739
740 it('resolves relative to parent multiple directory, later', () => {
741 const base = 'dir/';
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 = 'dir/';
749 const input = 'foo/./bar/../main.js.map';
750 const resolved = resolve(input, base);
751 assert.strictEqual(resolved, 'dir/foo/main.js.map');
752 });
753
754 it('resolves node_module scope as path', () => {
755 const base = 'dir/';
756 const input = 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js';
757 const resolved = resolve(input, base);
758 assert.strictEqual(resolved, 'dir/node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js');
759 });
760
761 it('resolves package scope as path', () => {
762 const base = 'dir/';
763 const input = '@babel/runtime/helpers/esm/arrayLikeToArray.js';
764 const resolved = resolve(input, base);
765 assert.strictEqual(resolved, 'dir/@babel/runtime/helpers/esm/arrayLikeToArray.js');
766 });
767 });
768
769 describe('with query input', () => {
770 it('resolves relative to path', () => {
771 const base = 'dir/';
772 const input = '?input';
773 const resolved = resolve(input, base);
774 assert.strictEqual(resolved, 'dir/?input');
775 });
776 });
777
778 describe('with hash input', () => {
779 it('resolves relative to path', () => {
780 const base = 'dir/';
781 const input = '#input';
782 const resolved = resolve(input, base);
783 assert.strictEqual(resolved, 'dir/#input');
784 });
785 });
786
787 describe('empty input', () => {
788 it('normalizes base', () => {
789 const base = 'dir/';
790 const input = '';
791 const resolved = resolve(input, base);
792 assert.strictEqual(resolved, 'dir/');
793 });
794 });
795 });
796
797 describe(`base = "dir/file"`, () => {
798 describe('with absolute input', () => {
799 it('returns input', () => {
800 const base = 'dir/file';
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 = 'dir/file';
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 = 'dir/file';
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 = 'dir/file';
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 = 'dir/file';
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 = 'dir/file';
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 = 'dir/file';
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 = 'dir/file';
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 = 'dir/file';
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 = 'dir/file';
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 = 'dir/file';
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 = 'dir/file';
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 = 'dir/file';
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 = 'dir/file';
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 = 'dir/file';
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 = 'dir/file';
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 = 'dir/file';
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 = 'dir/file';
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 = 'dir/file';
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 = 'dir/file';
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 = 'dir/file';
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 = 'dir/file';
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 = 'dir/file';
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 = 'dir/file';
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 = 'dir/file';
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 = 'dir/file';
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 = 'dir/file';
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 = 'dir/file';
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 = 'dir/file';
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 = 'dir/file';
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 = 'dir/file';
1015 const input = '/';
1016 const resolved = resolve(input, base);
1017 assert.strictEqual(resolved, '/');
1018 });
1019
1020 it('normalizes input path', () => {
1021 const base = 'dir/file';
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 = 'dir/file';
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 = 'dir/file';
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 = 'dir/file';
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 = 'dir/file';
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 = 'dir/file';
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 = 'dir/file';
1066 const input = './bar/main.js.map';
1067 const resolved = resolve(input, base);
1068 assert.strictEqual(resolved, 'dir/bar/main.js.map');
1069 });
1070
1071 it('resolves relative to current directory with query', () => {
1072 const base = 'dir/file';
1073 const input = './bar/main.js.map?input';
1074 const resolved = resolve(input, base);
1075 assert.strictEqual(resolved, 'dir/bar/main.js.map?input');
1076 });
1077
1078 it('resolves relative to parent directory', () => {
1079 const base = 'dir/file';
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 = 'dir/file';
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 = 'dir/file';
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 = 'dir/file';
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 = 'dir/file';
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 = 'dir/file';
1115 const input = './foo/./bar/../main.js.map';
1116 const resolved = resolve(input, base);
1117 assert.strictEqual(resolved, 'dir/foo/main.js.map');
1118 });
1119 });
1120
1121 describe('with relative path input', () => {
1122 it('resolves relative to current directory', () => {
1123 const base = 'dir/file';
1124 const input = 'bar/main.js.map';
1125 const resolved = resolve(input, base);
1126 assert.strictEqual(resolved, 'dir/bar/main.js.map');
1127 });
1128
1129 it('resolves relative to current directory with query', () => {
1130 const base = 'dir/file';
1131 const input = 'bar/main.js.map?input';
1132 const resolved = resolve(input, base);
1133 assert.strictEqual(resolved, 'dir/bar/main.js.map?input');
1134 });
1135
1136 it('resolves relative to parent multiple directory, later', () => {
1137 const base = 'dir/file';
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 = 'dir/file';
1145 const input = 'foo/./bar/../main.js.map';
1146 const resolved = resolve(input, base);
1147 assert.strictEqual(resolved, 'dir/foo/main.js.map');
1148 });
1149
1150 it('resolves node_module scope as path', () => {
1151 const base = 'dir/file';
1152 const input = 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js';
1153 const resolved = resolve(input, base);
1154 assert.strictEqual(resolved, 'dir/node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js');
1155 });
1156
1157 it('resolves package scope as path', () => {
1158 const base = 'dir/file';
1159 const input = '@babel/runtime/helpers/esm/arrayLikeToArray.js';
1160 const resolved = resolve(input, base);
1161 assert.strictEqual(resolved, 'dir/@babel/runtime/helpers/esm/arrayLikeToArray.js');
1162 });
1163 });
1164
1165 describe('with query input', () => {
1166 it('resolves relative to path', () => {
1167 const base = 'dir/file';
1168 const input = '?input';
1169 const resolved = resolve(input, base);
1170 assert.strictEqual(resolved, 'dir/file?input');
1171 });
1172 });
1173
1174 describe('with hash input', () => {
1175 it('resolves relative to path', () => {
1176 const base = 'dir/file';
1177 const input = '#input';
1178 const resolved = resolve(input, base);
1179 assert.strictEqual(resolved, 'dir/file#input');
1180 });
1181 });
1182
1183 describe('empty input', () => {
1184 it('normalizes base', () => {
1185 const base = 'dir/file';
1186 const input = '';
1187 const resolved = resolve(input, base);
1188 assert.strictEqual(resolved, 'dir/file');
1189 });
1190 });
1191 });
1192
1193 describe(`base = "deep/dir/"`, () => {
1194 describe('with absolute input', () => {
1195 it('returns input', () => {
1196 const base = 'deep/dir/';
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 = 'deep/dir/';
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 = 'deep/dir/';
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 = 'deep/dir/';
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 = 'deep/dir/';
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 = 'deep/dir/';
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 = 'deep/dir/';
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 = 'deep/dir/';
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 = 'deep/dir/';
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 = 'deep/dir/';
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 = 'deep/dir/';
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 = 'deep/dir/';
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 = 'deep/dir/';
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 = 'deep/dir/';
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 = 'deep/dir/';
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 = 'deep/dir/';
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 = 'deep/dir/';
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 = 'deep/dir/';
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 = 'deep/dir/';
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 = 'deep/dir/';
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 = 'deep/dir/';
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 = 'deep/dir/';
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 = 'deep/dir/';
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 = 'deep/dir/';
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 = 'deep/dir/';
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 = 'deep/dir/';
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 = 'deep/dir/';
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 = 'deep/dir/';
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 = 'deep/dir/';
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 = 'deep/dir/';
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 = 'deep/dir/';
1411 const input = '/';
1412 const resolved = resolve(input, base);
1413 assert.strictEqual(resolved, '/');
1414 });
1415
1416 it('normalizes input path', () => {
1417 const base = 'deep/dir/';
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 = 'deep/dir/';
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 = 'deep/dir/';
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 = 'deep/dir/';
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 = 'deep/dir/';
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 = 'deep/dir/';
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 = 'deep/dir/';
1462 const input = './bar/main.js.map';
1463 const resolved = resolve(input, base);
1464 assert.strictEqual(resolved, 'deep/dir/bar/main.js.map');
1465 });
1466
1467 it('resolves relative to current directory with query', () => {
1468 const base = 'deep/dir/';
1469 const input = './bar/main.js.map?input';
1470 const resolved = resolve(input, base);
1471 assert.strictEqual(resolved, 'deep/dir/bar/main.js.map?input');
1472 });
1473
1474 it('resolves relative to parent directory', () => {
1475 const base = 'deep/dir/';
1476 const input = '../bar/main.js.map';
1477 const resolved = resolve(input, base);
1478 assert.strictEqual(resolved, 'deep/bar/main.js.map');
1479 });
1480
1481 it('resolves relative to parent directory with query', () => {
1482 const base = 'deep/dir/';
1483 const input = '../bar/main.js.map?input';
1484 const resolved = resolve(input, base);
1485 assert.strictEqual(resolved, 'deep/bar/main.js.map?input');
1486 });
1487
1488 it('resolves relative to parent multiple directory', () => {
1489 const base = 'deep/dir/';
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 = 'deep/dir/';
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 = 'deep/dir/';
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 = 'deep/dir/';
1511 const input = './foo/./bar/../main.js.map';
1512 const resolved = resolve(input, base);
1513 assert.strictEqual(resolved, 'deep/dir/foo/main.js.map');
1514 });
1515 });
1516
1517 describe('with relative path input', () => {
1518 it('resolves relative to current directory', () => {
1519 const base = 'deep/dir/';
1520 const input = 'bar/main.js.map';
1521 const resolved = resolve(input, base);
1522 assert.strictEqual(resolved, 'deep/dir/bar/main.js.map');
1523 });
1524
1525 it('resolves relative to current directory with query', () => {
1526 const base = 'deep/dir/';
1527 const input = 'bar/main.js.map?input';
1528 const resolved = resolve(input, base);
1529 assert.strictEqual(resolved, 'deep/dir/bar/main.js.map?input');
1530 });
1531
1532 it('resolves relative to parent multiple directory, later', () => {
1533 const base = 'deep/dir/';
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 = 'deep/dir/';
1541 const input = 'foo/./bar/../main.js.map';
1542 const resolved = resolve(input, base);
1543 assert.strictEqual(resolved, 'deep/dir/foo/main.js.map');
1544 });
1545
1546 it('resolves node_module scope as path', () => {
1547 const base = 'deep/dir/';
1548 const input = 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js';
1549 const resolved = resolve(input, base);
1550 assert.strictEqual(resolved, 'deep/dir/node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js');
1551 });
1552
1553 it('resolves package scope as path', () => {
1554 const base = 'deep/dir/';
1555 const input = '@babel/runtime/helpers/esm/arrayLikeToArray.js';
1556 const resolved = resolve(input, base);
1557 assert.strictEqual(resolved, 'deep/dir/@babel/runtime/helpers/esm/arrayLikeToArray.js');
1558 });
1559 });
1560
1561 describe('with query input', () => {
1562 it('resolves relative to path', () => {
1563 const base = 'deep/dir/';
1564 const input = '?input';
1565 const resolved = resolve(input, base);
1566 assert.strictEqual(resolved, 'deep/dir/?input');
1567 });
1568 });
1569
1570 describe('with hash input', () => {
1571 it('resolves relative to path', () => {
1572 const base = 'deep/dir/';
1573 const input = '#input';
1574 const resolved = resolve(input, base);
1575 assert.strictEqual(resolved, 'deep/dir/#input');
1576 });
1577 });
1578
1579 describe('empty input', () => {
1580 it('normalizes base', () => {
1581 const base = 'deep/dir/';
1582 const input = '';
1583 const resolved = resolve(input, base);
1584 assert.strictEqual(resolved, 'deep/dir/');
1585 });
1586 });
1587 });
1588
1589 describe(`base = "./file"`, () => {
1590 describe('with absolute input', () => {
1591 it('returns input', () => {
1592 const base = './file';
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 = './file';
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 = './file';
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 = './file';
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 = './file';
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 = './file';
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 = './file';
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 = './file';
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 = './file';
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 = './file';
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 = './file';
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 = './file';
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 = './file';
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 = './file';
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 = './file';
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 = './file';
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 = './file';
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 = './file';
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 = './file';
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 = './file';
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 = './file';
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 = './file';
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 = './file';
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 = './file';
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 = './file';
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 = './file';
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 = './file';
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 = './file';
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 = './file';
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 = './file';
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 = './file';
1807 const input = '/';
1808 const resolved = resolve(input, base);
1809 assert.strictEqual(resolved, '/');
1810 });
1811
1812 it('normalizes input path', () => {
1813 const base = './file';
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 = './file';
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 = './file';
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 = './file';
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 = './file';
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 = './file';
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 = './file';
1858 const input = './bar/main.js.map';
1859 const resolved = resolve(input, base);
1860 assert.strictEqual(resolved, './bar/main.js.map');
1861 });
1862
1863 it('resolves relative to current directory with query', () => {
1864 const base = './file';
1865 const input = './bar/main.js.map?input';
1866 const resolved = resolve(input, base);
1867 assert.strictEqual(resolved, './bar/main.js.map?input');
1868 });
1869
1870 it('resolves relative to parent directory', () => {
1871 const base = './file';
1872 const input = '../bar/main.js.map';
1873 const resolved = resolve(input, base);
1874 assert.strictEqual(resolved, '../bar/main.js.map');
1875 });
1876
1877 it('resolves relative to parent directory with query', () => {
1878 const base = './file';
1879 const input = '../bar/main.js.map?input';
1880 const resolved = resolve(input, base);
1881 assert.strictEqual(resolved, '../bar/main.js.map?input');
1882 });
1883
1884 it('resolves relative to parent multiple directory', () => {
1885 const base = './file';
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 = './file';
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 = './file';
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 = './file';
1907 const input = './foo/./bar/../main.js.map';
1908 const resolved = resolve(input, base);
1909 assert.strictEqual(resolved, './foo/main.js.map');
1910 });
1911 });
1912
1913 describe('with relative path input', () => {
1914 it('resolves relative to current directory', () => {
1915 const base = './file';
1916 const input = 'bar/main.js.map';
1917 const resolved = resolve(input, base);
1918 assert.strictEqual(resolved, './bar/main.js.map');
1919 });
1920
1921 it('resolves relative to current directory with query', () => {
1922 const base = './file';
1923 const input = 'bar/main.js.map?input';
1924 const resolved = resolve(input, base);
1925 assert.strictEqual(resolved, './bar/main.js.map?input');
1926 });
1927
1928 it('resolves relative to parent multiple directory, later', () => {
1929 const base = './file';
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 = './file';
1937 const input = 'foo/./bar/../main.js.map';
1938 const resolved = resolve(input, base);
1939 assert.strictEqual(resolved, './foo/main.js.map');
1940 });
1941
1942 it('resolves node_module scope as path', () => {
1943 const base = './file';
1944 const input = 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js';
1945 const resolved = resolve(input, base);
1946 assert.strictEqual(resolved, './node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js');
1947 });
1948
1949 it('resolves package scope as path', () => {
1950 const base = './file';
1951 const input = '@babel/runtime/helpers/esm/arrayLikeToArray.js';
1952 const resolved = resolve(input, base);
1953 assert.strictEqual(resolved, './@babel/runtime/helpers/esm/arrayLikeToArray.js');
1954 });
1955 });
1956
1957 describe('with query input', () => {
1958 it('resolves relative to path', () => {
1959 const base = './file';
1960 const input = '?input';
1961 const resolved = resolve(input, base);
1962 assert.strictEqual(resolved, './file?input');
1963 });
1964 });
1965
1966 describe('with hash input', () => {
1967 it('resolves relative to path', () => {
1968 const base = './file';
1969 const input = '#input';
1970 const resolved = resolve(input, base);
1971 assert.strictEqual(resolved, './file#input');
1972 });
1973 });
1974
1975 describe('empty input', () => {
1976 it('normalizes base', () => {
1977 const base = './file';
1978 const input = '';
1979 const resolved = resolve(input, base);
1980 assert.strictEqual(resolved, './file');
1981 });
1982 });
1983 });
1984
1985 describe(`base = "./dir/"`, () => {
1986 describe('with absolute input', () => {
1987 it('returns input', () => {
1988 const base = './dir/';
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 = './dir/';
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 = './dir/';
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 = './dir/';
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 = './dir/';
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 = './dir/';
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 = './dir/';
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 = './dir/';
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 = './dir/';
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 = './dir/';
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 = './dir/';
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 = './dir/';
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 = './dir/';
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 = './dir/';
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 = './dir/';
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 = './dir/';
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 = './dir/';
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 = './dir/';
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 = './dir/';
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 = './dir/';
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 = './dir/';
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 = './dir/';
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 = './dir/';
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 = './dir/';
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 = './dir/';
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 = './dir/';
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 = './dir/';
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 = './dir/';
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 = './dir/';
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 = './dir/';
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 = './dir/';
2203 const input = '/';
2204 const resolved = resolve(input, base);
2205 assert.strictEqual(resolved, '/');
2206 });
2207
2208 it('normalizes input path', () => {
2209 const base = './dir/';
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 = './dir/';
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 = './dir/';
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 = './dir/';
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 = './dir/';
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 = './dir/';
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 = './dir/';
2254 const input = './bar/main.js.map';
2255 const resolved = resolve(input, base);
2256 assert.strictEqual(resolved, './dir/bar/main.js.map');
2257 });
2258
2259 it('resolves relative to current directory with query', () => {
2260 const base = './dir/';
2261 const input = './bar/main.js.map?input';
2262 const resolved = resolve(input, base);
2263 assert.strictEqual(resolved, './dir/bar/main.js.map?input');
2264 });
2265
2266 it('resolves relative to parent directory', () => {
2267 const base = './dir/';
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 = './dir/';
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 = './dir/';
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 = './dir/';
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 = './dir/';
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 = './dir/';
2303 const input = './foo/./bar/../main.js.map';
2304 const resolved = resolve(input, base);
2305 assert.strictEqual(resolved, './dir/foo/main.js.map');
2306 });
2307 });
2308
2309 describe('with relative path input', () => {
2310 it('resolves relative to current directory', () => {
2311 const base = './dir/';
2312 const input = 'bar/main.js.map';
2313 const resolved = resolve(input, base);
2314 assert.strictEqual(resolved, './dir/bar/main.js.map');
2315 });
2316
2317 it('resolves relative to current directory with query', () => {
2318 const base = './dir/';
2319 const input = 'bar/main.js.map?input';
2320 const resolved = resolve(input, base);
2321 assert.strictEqual(resolved, './dir/bar/main.js.map?input');
2322 });
2323
2324 it('resolves relative to parent multiple directory, later', () => {
2325 const base = './dir/';
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 = './dir/';
2333 const input = 'foo/./bar/../main.js.map';
2334 const resolved = resolve(input, base);
2335 assert.strictEqual(resolved, './dir/foo/main.js.map');
2336 });
2337
2338 it('resolves node_module scope as path', () => {
2339 const base = './dir/';
2340 const input = 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js';
2341 const resolved = resolve(input, base);
2342 assert.strictEqual(resolved, './dir/node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js');
2343 });
2344
2345 it('resolves package scope as path', () => {
2346 const base = './dir/';
2347 const input = '@babel/runtime/helpers/esm/arrayLikeToArray.js';
2348 const resolved = resolve(input, base);
2349 assert.strictEqual(resolved, './dir/@babel/runtime/helpers/esm/arrayLikeToArray.js');
2350 });
2351 });
2352
2353 describe('with query input', () => {
2354 it('resolves relative to path', () => {
2355 const base = './dir/';
2356 const input = '?input';
2357 const resolved = resolve(input, base);
2358 assert.strictEqual(resolved, './dir/?input');
2359 });
2360 });
2361
2362 describe('with hash input', () => {
2363 it('resolves relative to path', () => {
2364 const base = './dir/';
2365 const input = '#input';
2366 const resolved = resolve(input, base);
2367 assert.strictEqual(resolved, './dir/#input');
2368 });
2369 });
2370
2371 describe('empty input', () => {
2372 it('normalizes base', () => {
2373 const base = './dir/';
2374 const input = '';
2375 const resolved = resolve(input, base);
2376 assert.strictEqual(resolved, './dir/');
2377 });
2378 });
2379 });
2380
2381 describe(`base = "./deep/file"`, () => {
2382 describe('with absolute input', () => {
2383 it('returns input', () => {
2384 const base = './deep/file';
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 = './deep/file';
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 = './deep/file';
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 = './deep/file';
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 = './deep/file';
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 = './deep/file';
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 = './deep/file';
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 = './deep/file';
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 = './deep/file';
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 = './deep/file';
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 = './deep/file';
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 = './deep/file';
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 = './deep/file';
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 = './deep/file';
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 = './deep/file';
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 = './deep/file';
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 = './deep/file';
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 = './deep/file';
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 = './deep/file';
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 = './deep/file';
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 = './deep/file';
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 = './deep/file';
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 = './deep/file';
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 = './deep/file';
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 = './deep/file';
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 = './deep/file';
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 = './deep/file';
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 = './deep/file';
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 = './deep/file';
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 = './deep/file';
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 = './deep/file';
2599 const input = '/';
2600 const resolved = resolve(input, base);
2601 assert.strictEqual(resolved, '/');
2602 });
2603
2604 it('normalizes input path', () => {
2605 const base = './deep/file';
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 = './deep/file';
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 = './deep/file';
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 = './deep/file';
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 = './deep/file';
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 = './deep/file';
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 = './deep/file';
2650 const input = './bar/main.js.map';
2651 const resolved = resolve(input, base);
2652 assert.strictEqual(resolved, './deep/bar/main.js.map');
2653 });
2654
2655 it('resolves relative to current directory with query', () => {
2656 const base = './deep/file';
2657 const input = './bar/main.js.map?input';
2658 const resolved = resolve(input, base);
2659 assert.strictEqual(resolved, './deep/bar/main.js.map?input');
2660 });
2661
2662 it('resolves relative to parent directory', () => {
2663 const base = './deep/file';
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 = './deep/file';
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 = './deep/file';
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 = './deep/file';
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 = './deep/file';
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 = './deep/file';
2699 const input = './foo/./bar/../main.js.map';
2700 const resolved = resolve(input, base);
2701 assert.strictEqual(resolved, './deep/foo/main.js.map');
2702 });
2703 });
2704
2705 describe('with relative path input', () => {
2706 it('resolves relative to current directory', () => {
2707 const base = './deep/file';
2708 const input = 'bar/main.js.map';
2709 const resolved = resolve(input, base);
2710 assert.strictEqual(resolved, './deep/bar/main.js.map');
2711 });
2712
2713 it('resolves relative to current directory with query', () => {
2714 const base = './deep/file';
2715 const input = 'bar/main.js.map?input';
2716 const resolved = resolve(input, base);
2717 assert.strictEqual(resolved, './deep/bar/main.js.map?input');
2718 });
2719
2720 it('resolves relative to parent multiple directory, later', () => {
2721 const base = './deep/file';
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 = './deep/file';
2729 const input = 'foo/./bar/../main.js.map';
2730 const resolved = resolve(input, base);
2731 assert.strictEqual(resolved, './deep/foo/main.js.map');
2732 });
2733
2734 it('resolves node_module scope as path', () => {
2735 const base = './deep/file';
2736 const input = 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js';
2737 const resolved = resolve(input, base);
2738 assert.strictEqual(resolved, './deep/node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js');
2739 });
2740
2741 it('resolves package scope as path', () => {
2742 const base = './deep/file';
2743 const input = '@babel/runtime/helpers/esm/arrayLikeToArray.js';
2744 const resolved = resolve(input, base);
2745 assert.strictEqual(resolved, './deep/@babel/runtime/helpers/esm/arrayLikeToArray.js');
2746 });
2747 });
2748
2749 describe('with query input', () => {
2750 it('resolves relative to path', () => {
2751 const base = './deep/file';
2752 const input = '?input';
2753 const resolved = resolve(input, base);
2754 assert.strictEqual(resolved, './deep/file?input');
2755 });
2756 });
2757
2758 describe('with hash input', () => {
2759 it('resolves relative to path', () => {
2760 const base = './deep/file';
2761 const input = '#input';
2762 const resolved = resolve(input, base);
2763 assert.strictEqual(resolved, './deep/file#input');
2764 });
2765 });
2766
2767 describe('empty input', () => {
2768 it('normalizes base', () => {
2769 const base = './deep/file';
2770 const input = '';
2771 const resolved = resolve(input, base);
2772 assert.strictEqual(resolved, './deep/file');
2773 });
2774 });
2775 });
2776
2777 describe(`base = "./deep/dir/"`, () => {
2778 describe('with absolute input', () => {
2779 it('returns input', () => {
2780 const base = './deep/dir/';
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 = './deep/dir/';
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 = './deep/dir/';
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 = './deep/dir/';
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 = './deep/dir/';
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 = './deep/dir/';
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 = './deep/dir/';
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 = './deep/dir/';
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 = './deep/dir/';
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 = './deep/dir/';
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 = './deep/dir/';
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 = './deep/dir/';
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 = './deep/dir/';
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 = './deep/dir/';
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 = './deep/dir/';
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 = './deep/dir/';
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 = './deep/dir/';
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 = './deep/dir/';
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 = './deep/dir/';
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 = './deep/dir/';
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 = './deep/dir/';
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 = './deep/dir/';
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 = './deep/dir/';
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 = './deep/dir/';
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 = './deep/dir/';
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 = './deep/dir/';
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 = './deep/dir/';
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 = './deep/dir/';
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 = './deep/dir/';
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 = './deep/dir/';
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 = './deep/dir/';
2995 const input = '/';
2996 const resolved = resolve(input, base);
2997 assert.strictEqual(resolved, '/');
2998 });
2999
3000 it('normalizes input path', () => {
3001 const base = './deep/dir/';
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 = './deep/dir/';
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 = './deep/dir/';
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 = './deep/dir/';
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 = './deep/dir/';
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 = './deep/dir/';
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 = './deep/dir/';
3046 const input = './bar/main.js.map';
3047 const resolved = resolve(input, base);
3048 assert.strictEqual(resolved, './deep/dir/bar/main.js.map');
3049 });
3050
3051 it('resolves relative to current directory with query', () => {
3052 const base = './deep/dir/';
3053 const input = './bar/main.js.map?input';
3054 const resolved = resolve(input, base);
3055 assert.strictEqual(resolved, './deep/dir/bar/main.js.map?input');
3056 });
3057
3058 it('resolves relative to parent directory', () => {
3059 const base = './deep/dir/';
3060 const input = '../bar/main.js.map';
3061 const resolved = resolve(input, base);
3062 assert.strictEqual(resolved, './deep/bar/main.js.map');
3063 });
3064
3065 it('resolves relative to parent directory with query', () => {
3066 const base = './deep/dir/';
3067 const input = '../bar/main.js.map?input';
3068 const resolved = resolve(input, base);
3069 assert.strictEqual(resolved, './deep/bar/main.js.map?input');
3070 });
3071
3072 it('resolves relative to parent multiple directory', () => {
3073 const base = './deep/dir/';
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 = './deep/dir/';
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 = './deep/dir/';
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 = './deep/dir/';
3095 const input = './foo/./bar/../main.js.map';
3096 const resolved = resolve(input, base);
3097 assert.strictEqual(resolved, './deep/dir/foo/main.js.map');
3098 });
3099 });
3100
3101 describe('with relative path input', () => {
3102 it('resolves relative to current directory', () => {
3103 const base = './deep/dir/';
3104 const input = 'bar/main.js.map';
3105 const resolved = resolve(input, base);
3106 assert.strictEqual(resolved, './deep/dir/bar/main.js.map');
3107 });
3108
3109 it('resolves relative to current directory with query', () => {
3110 const base = './deep/dir/';
3111 const input = 'bar/main.js.map?input';
3112 const resolved = resolve(input, base);
3113 assert.strictEqual(resolved, './deep/dir/bar/main.js.map?input');
3114 });
3115
3116 it('resolves relative to parent multiple directory, later', () => {
3117 const base = './deep/dir/';
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 = './deep/dir/';
3125 const input = 'foo/./bar/../main.js.map';
3126 const resolved = resolve(input, base);
3127 assert.strictEqual(resolved, './deep/dir/foo/main.js.map');
3128 });
3129
3130 it('resolves node_module scope as path', () => {
3131 const base = './deep/dir/';
3132 const input = 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js';
3133 const resolved = resolve(input, base);
3134 assert.strictEqual(resolved, './deep/dir/node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js');
3135 });
3136
3137 it('resolves package scope as path', () => {
3138 const base = './deep/dir/';
3139 const input = '@babel/runtime/helpers/esm/arrayLikeToArray.js';
3140 const resolved = resolve(input, base);
3141 assert.strictEqual(resolved, './deep/dir/@babel/runtime/helpers/esm/arrayLikeToArray.js');
3142 });
3143 });
3144
3145 describe('with query input', () => {
3146 it('resolves relative to path', () => {
3147 const base = './deep/dir/';
3148 const input = '?input';
3149 const resolved = resolve(input, base);
3150 assert.strictEqual(resolved, './deep/dir/?input');
3151 });
3152 });
3153
3154 describe('with hash input', () => {
3155 it('resolves relative to path', () => {
3156 const base = './deep/dir/';
3157 const input = '#input';
3158 const resolved = resolve(input, base);
3159 assert.strictEqual(resolved, './deep/dir/#input');
3160 });
3161 });
3162
3163 describe('empty input', () => {
3164 it('normalizes base', () => {
3165 const base = './deep/dir/';
3166 const input = '';
3167 const resolved = resolve(input, base);
3168 assert.strictEqual(resolved, './deep/dir/');
3169 });
3170 });
3171 });
3172
3173 describe(`base = "../file"`, () => {
3174 describe('with absolute input', () => {
3175 it('returns input', () => {
3176 const base = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
3391 const input = '/';
3392 const resolved = resolve(input, base);
3393 assert.strictEqual(resolved, '/');
3394 });
3395
3396 it('normalizes input path', () => {
3397 const base = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
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 = '../file';
3544 const input = '?input';
3545 const resolved = resolve(input, base);
3546 assert.strictEqual(resolved, '../file?input');
3547 });
3548 });
3549
3550 describe('with hash input', () => {
3551 it('resolves relative to path', () => {
3552 const base = '../file';
3553 const input = '#input';
3554 const resolved = resolve(input, base);
3555 assert.strictEqual(resolved, '../file#input');
3556 });
3557 });
3558
3559 describe('empty input', () => {
3560 it('normalizes base', () => {
3561 const base = '../file';
3562 const input = '';
3563 const resolved = resolve(input, base);
3564 assert.strictEqual(resolved, '../file');
3565 });
3566 });
3567 });
3568
3569 describe(`base = "../dir/"`, () => {
3570 describe('with absolute input', () => {
3571 it('returns input', () => {
3572 const base = '../dir/';
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 = '../dir/';
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 = '../dir/';
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 = '../dir/';
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 = '../dir/';
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 = '../dir/';
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 = '../dir/';
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 = '../dir/';
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 = '../dir/';
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 = '../dir/';
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 = '../dir/';
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 = '../dir/';
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 = '../dir/';
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 = '../dir/';
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 = '../dir/';
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 = '../dir/';
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 = '../dir/';
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 = '../dir/';
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 = '../dir/';
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 = '../dir/';
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 = '../dir/';
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 = '../dir/';
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 = '../dir/';
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 = '../dir/';
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 = '../dir/';
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 = '../dir/';
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 = '../dir/';
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 = '../dir/';
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 = '../dir/';
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 = '../dir/';
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 = '../dir/';
3787 const input = '/';
3788 const resolved = resolve(input, base);
3789 assert.strictEqual(resolved, '/');
3790 });
3791
3792 it('normalizes input path', () => {
3793 const base = '../dir/';
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 = '../dir/';
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 = '../dir/';
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 = '../dir/';
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 = '../dir/';
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 = '../dir/';
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 = '../dir/';
3838 const input = './bar/main.js.map';
3839 const resolved = resolve(input, base);
3840 assert.strictEqual(resolved, '../dir/bar/main.js.map');
3841 });
3842
3843 it('resolves relative to current directory with query', () => {
3844 const base = '../dir/';
3845 const input = './bar/main.js.map?input';
3846 const resolved = resolve(input, base);
3847 assert.strictEqual(resolved, '../dir/bar/main.js.map?input');
3848 });
3849
3850 it('resolves relative to parent directory', () => {
3851 const base = '../dir/';
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 = '../dir/';
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 = '../dir/';
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 = '../dir/';
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 = '../dir/';
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 = '../dir/';
3887 const input = './foo/./bar/../main.js.map';
3888 const resolved = resolve(input, base);
3889 assert.strictEqual(resolved, '../dir/foo/main.js.map');
3890 });
3891 });
3892
3893 describe('with relative path input', () => {
3894 it('resolves relative to current directory', () => {
3895 const base = '../dir/';
3896 const input = 'bar/main.js.map';
3897 const resolved = resolve(input, base);
3898 assert.strictEqual(resolved, '../dir/bar/main.js.map');
3899 });
3900
3901 it('resolves relative to current directory with query', () => {
3902 const base = '../dir/';
3903 const input = 'bar/main.js.map?input';
3904 const resolved = resolve(input, base);
3905 assert.strictEqual(resolved, '../dir/bar/main.js.map?input');
3906 });
3907
3908 it('resolves relative to parent multiple directory, later', () => {
3909 const base = '../dir/';
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 = '../dir/';
3917 const input = 'foo/./bar/../main.js.map';
3918 const resolved = resolve(input, base);
3919 assert.strictEqual(resolved, '../dir/foo/main.js.map');
3920 });
3921
3922 it('resolves node_module scope as path', () => {
3923 const base = '../dir/';
3924 const input = 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js';
3925 const resolved = resolve(input, base);
3926 assert.strictEqual(resolved, '../dir/node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js');
3927 });
3928
3929 it('resolves package scope as path', () => {
3930 const base = '../dir/';
3931 const input = '@babel/runtime/helpers/esm/arrayLikeToArray.js';
3932 const resolved = resolve(input, base);
3933 assert.strictEqual(resolved, '../dir/@babel/runtime/helpers/esm/arrayLikeToArray.js');
3934 });
3935 });
3936
3937 describe('with query input', () => {
3938 it('resolves relative to path', () => {
3939 const base = '../dir/';
3940 const input = '?input';
3941 const resolved = resolve(input, base);
3942 assert.strictEqual(resolved, '../dir/?input');
3943 });
3944 });
3945
3946 describe('with hash input', () => {
3947 it('resolves relative to path', () => {
3948 const base = '../dir/';
3949 const input = '#input';
3950 const resolved = resolve(input, base);
3951 assert.strictEqual(resolved, '../dir/#input');
3952 });
3953 });
3954
3955 describe('empty input', () => {
3956 it('normalizes base', () => {
3957 const base = '../dir/';
3958 const input = '';
3959 const resolved = resolve(input, base);
3960 assert.strictEqual(resolved, '../dir/');
3961 });
3962 });
3963 });
3964
3965 describe(`base = "../deep/file"`, () => {
3966 describe('with absolute input', () => {
3967 it('returns input', () => {
3968 const base = '../deep/file';
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 = '../deep/file';
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 = '../deep/file';
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 = '../deep/file';
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 = '../deep/file';
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 = '../deep/file';
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 = '../deep/file';
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 = '../deep/file';
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 = '../deep/file';
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 = '../deep/file';
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 = '../deep/file';
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 = '../deep/file';
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 = '../deep/file';
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 = '../deep/file';
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 = '../deep/file';
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 = '../deep/file';
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 = '../deep/file';
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 = '../deep/file';
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 = '../deep/file';
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 = '../deep/file';
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 = '../deep/file';
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 = '../deep/file';
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 = '../deep/file';
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 = '../deep/file';
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 = '../deep/file';
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 = '../deep/file';
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 = '../deep/file';
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 = '../deep/file';
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 = '../deep/file';
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 = '../deep/file';
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 = '../deep/file';
4183 const input = '/';
4184 const resolved = resolve(input, base);
4185 assert.strictEqual(resolved, '/');
4186 });
4187
4188 it('normalizes input path', () => {
4189 const base = '../deep/file';
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 = '../deep/file';
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 = '../deep/file';
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 = '../deep/file';
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 = '../deep/file';
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 = '../deep/file';
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 = '../deep/file';
4234 const input = './bar/main.js.map';
4235 const resolved = resolve(input, base);
4236 assert.strictEqual(resolved, '../deep/bar/main.js.map');
4237 });
4238
4239 it('resolves relative to current directory with query', () => {
4240 const base = '../deep/file';
4241 const input = './bar/main.js.map?input';
4242 const resolved = resolve(input, base);
4243 assert.strictEqual(resolved, '../deep/bar/main.js.map?input');
4244 });
4245
4246 it('resolves relative to parent directory', () => {
4247 const base = '../deep/file';
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 = '../deep/file';
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 = '../deep/file';
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 = '../deep/file';
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 = '../deep/file';
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 = '../deep/file';
4283 const input = './foo/./bar/../main.js.map';
4284 const resolved = resolve(input, base);
4285 assert.strictEqual(resolved, '../deep/foo/main.js.map');
4286 });
4287 });
4288
4289 describe('with relative path input', () => {
4290 it('resolves relative to current directory', () => {
4291 const base = '../deep/file';
4292 const input = 'bar/main.js.map';
4293 const resolved = resolve(input, base);
4294 assert.strictEqual(resolved, '../deep/bar/main.js.map');
4295 });
4296
4297 it('resolves relative to current directory with query', () => {
4298 const base = '../deep/file';
4299 const input = 'bar/main.js.map?input';
4300 const resolved = resolve(input, base);
4301 assert.strictEqual(resolved, '../deep/bar/main.js.map?input');
4302 });
4303
4304 it('resolves relative to parent multiple directory, later', () => {
4305 const base = '../deep/file';
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 = '../deep/file';
4313 const input = 'foo/./bar/../main.js.map';
4314 const resolved = resolve(input, base);
4315 assert.strictEqual(resolved, '../deep/foo/main.js.map');
4316 });
4317
4318 it('resolves node_module scope as path', () => {
4319 const base = '../deep/file';
4320 const input = 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js';
4321 const resolved = resolve(input, base);
4322 assert.strictEqual(resolved, '../deep/node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js');
4323 });
4324
4325 it('resolves package scope as path', () => {
4326 const base = '../deep/file';
4327 const input = '@babel/runtime/helpers/esm/arrayLikeToArray.js';
4328 const resolved = resolve(input, base);
4329 assert.strictEqual(resolved, '../deep/@babel/runtime/helpers/esm/arrayLikeToArray.js');
4330 });
4331 });
4332
4333 describe('with query input', () => {
4334 it('resolves relative to path', () => {
4335 const base = '../deep/file';
4336 const input = '?input';
4337 const resolved = resolve(input, base);
4338 assert.strictEqual(resolved, '../deep/file?input');
4339 });
4340 });
4341
4342 describe('with hash input', () => {
4343 it('resolves relative to path', () => {
4344 const base = '../deep/file';
4345 const input = '#input';
4346 const resolved = resolve(input, base);
4347 assert.strictEqual(resolved, '../deep/file#input');
4348 });
4349 });
4350
4351 describe('empty input', () => {
4352 it('normalizes base', () => {
4353 const base = '../deep/file';
4354 const input = '';
4355 const resolved = resolve(input, base);
4356 assert.strictEqual(resolved, '../deep/file');
4357 });
4358 });
4359 });
4360
4361 describe(`base = "../deep/dir/"`, () => {
4362 describe('with absolute input', () => {
4363 it('returns input', () => {
4364 const base = '../deep/dir/';
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 = '../deep/dir/';
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 = '../deep/dir/';
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 = '../deep/dir/';
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 = '../deep/dir/';
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 = '../deep/dir/';
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 = '../deep/dir/';
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 = '../deep/dir/';
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 = '../deep/dir/';
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 = '../deep/dir/';
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 = '../deep/dir/';
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 = '../deep/dir/';
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 = '../deep/dir/';
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 = '../deep/dir/';
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 = '../deep/dir/';
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 = '../deep/dir/';
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 = '../deep/dir/';
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 = '../deep/dir/';
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 = '../deep/dir/';
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 = '../deep/dir/';
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 = '../deep/dir/';
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 = '../deep/dir/';
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 = '../deep/dir/';
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 = '../deep/dir/';
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 = '../deep/dir/';
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 = '../deep/dir/';
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 = '../deep/dir/';
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 = '../deep/dir/';
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 = '../deep/dir/';
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 = '../deep/dir/';
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 = '../deep/dir/';
4579 const input = '/';
4580 const resolved = resolve(input, base);
4581 assert.strictEqual(resolved, '/');
4582 });
4583
4584 it('normalizes input path', () => {
4585 const base = '../deep/dir/';
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 = '../deep/dir/';
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 = '../deep/dir/';
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 = '../deep/dir/';
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 = '../deep/dir/';
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 = '../deep/dir/';
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 = '../deep/dir/';
4630 const input = './bar/main.js.map';
4631 const resolved = resolve(input, base);
4632 assert.strictEqual(resolved, '../deep/dir/bar/main.js.map');
4633 });
4634
4635 it('resolves relative to current directory with query', () => {
4636 const base = '../deep/dir/';
4637 const input = './bar/main.js.map?input';
4638 const resolved = resolve(input, base);
4639 assert.strictEqual(resolved, '../deep/dir/bar/main.js.map?input');
4640 });
4641
4642 it('resolves relative to parent directory', () => {
4643 const base = '../deep/dir/';
4644 const input = '../bar/main.js.map';
4645 const resolved = resolve(input, base);
4646 assert.strictEqual(resolved, '../deep/bar/main.js.map');
4647 });
4648
4649 it('resolves relative to parent directory with query', () => {
4650 const base = '../deep/dir/';
4651 const input = '../bar/main.js.map?input';
4652 const resolved = resolve(input, base);
4653 assert.strictEqual(resolved, '../deep/bar/main.js.map?input');
4654 });
4655
4656 it('resolves relative to parent multiple directory', () => {
4657 const base = '../deep/dir/';
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 = '../deep/dir/';
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 = '../deep/dir/';
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 = '../deep/dir/';
4679 const input = './foo/./bar/../main.js.map';
4680 const resolved = resolve(input, base);
4681 assert.strictEqual(resolved, '../deep/dir/foo/main.js.map');
4682 });
4683 });
4684
4685 describe('with relative path input', () => {
4686 it('resolves relative to current directory', () => {
4687 const base = '../deep/dir/';
4688 const input = 'bar/main.js.map';
4689 const resolved = resolve(input, base);
4690 assert.strictEqual(resolved, '../deep/dir/bar/main.js.map');
4691 });
4692
4693 it('resolves relative to current directory with query', () => {
4694 const base = '../deep/dir/';
4695 const input = 'bar/main.js.map?input';
4696 const resolved = resolve(input, base);
4697 assert.strictEqual(resolved, '../deep/dir/bar/main.js.map?input');
4698 });
4699
4700 it('resolves relative to parent multiple directory, later', () => {
4701 const base = '../deep/dir/';
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 = '../deep/dir/';
4709 const input = 'foo/./bar/../main.js.map';
4710 const resolved = resolve(input, base);
4711 assert.strictEqual(resolved, '../deep/dir/foo/main.js.map');
4712 });
4713
4714 it('resolves node_module scope as path', () => {
4715 const base = '../deep/dir/';
4716 const input = 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js';
4717 const resolved = resolve(input, base);
4718 assert.strictEqual(resolved, '../deep/dir/node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js');
4719 });
4720
4721 it('resolves package scope as path', () => {
4722 const base = '../deep/dir/';
4723 const input = '@babel/runtime/helpers/esm/arrayLikeToArray.js';
4724 const resolved = resolve(input, base);
4725 assert.strictEqual(resolved, '../deep/dir/@babel/runtime/helpers/esm/arrayLikeToArray.js');
4726 });
4727 });
4728
4729 describe('with query input', () => {
4730 it('resolves relative to path', () => {
4731 const base = '../deep/dir/';
4732 const input = '?input';
4733 const resolved = resolve(input, base);
4734 assert.strictEqual(resolved, '../deep/dir/?input');
4735 });
4736 });
4737
4738 describe('with hash input', () => {
4739 it('resolves relative to path', () => {
4740 const base = '../deep/dir/';
4741 const input = '#input';
4742 const resolved = resolve(input, base);
4743 assert.strictEqual(resolved, '../deep/dir/#input');
4744 });
4745 });
4746
4747 describe('empty input', () => {
4748 it('normalizes base', () => {
4749 const base = '../deep/dir/';
4750 const input = '';
4751 const resolved = resolve(input, base);
4752 assert.strictEqual(resolved, '../deep/dir/');
4753 });
4754 });
4755 });
4756
4757 describe(`base = ".."`, () => {
4758 describe('with absolute input', () => {
4759 it('returns input', () => {
4760 const base = '..';
4761 const input = 'https://absolute.com/main.js.map';
4762 const resolved = resolve(input, base);
4763 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
4764 });
4765
4766 it('returns input with query', () => {
4767 const base = '..';
4768 const input = 'https://absolute.com/main.js.map?input';
4769 const resolved = resolve(input, base);
4770 assert.strictEqual(resolved, 'https://absolute.com/main.js.map?input');
4771 });
4772
4773 it('normalizes input path', () => {
4774 const base = '..';
4775 const input = 'https://absolute.com/foo/./bar/../main.js.map';
4776 const resolved = resolve(input, base);
4777 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map');
4778 });
4779
4780 it('normalizes input path with query', () => {
4781 const base = '..';
4782 const input = 'https://absolute.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
4783 const resolved = resolve(input, base);
4784 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map?input!webpack://foo/./bar');
4785 });
4786
4787 it('normalizes pathless input', () => {
4788 const base = '..';
4789 const input = 'https://absolute.com';
4790 const resolved = resolve(input, base);
4791 assert.strictEqual(resolved, 'https://absolute.com/');
4792 });
4793
4794 it('normalizes pathless input with query', () => {
4795 const base = '..';
4796 const input = 'https://absolute.com?input';
4797 const resolved = resolve(input, base);
4798 assert.strictEqual(resolved, 'https://absolute.com/?input');
4799 });
4800
4801 it('normalizes current directory', () => {
4802 const base = '..';
4803 const input = 'https://absolute.com/./main.js.map';
4804 const resolved = resolve(input, base);
4805 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
4806 });
4807
4808 it('normalizes too many parent accessors', () => {
4809 const base = '..';
4810 const input = 'https://absolute.com/../../../main.js.map';
4811 const resolved = resolve(input, base);
4812 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
4813 });
4814
4815 it('normalizes too many parent accessors, late', () => {
4816 const base = '..';
4817 const input = 'https://absolute.com/foo/../../../main.js.map';
4818 const resolved = resolve(input, base);
4819 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
4820 });
4821
4822 it('normalizes file protocol 1', () => {
4823 const base = '..';
4824 const input = 'file:///root/main.js.map';
4825 const resolved = resolve(input, base);
4826 assert.strictEqual(resolved, 'file:///root/main.js.map');
4827 });
4828
4829 it('normalizes file protocol 2', () => {
4830 const base = '..';
4831 const input = 'file://root/main.js.map';
4832 const resolved = resolve(input, base);
4833 assert.strictEqual(resolved, 'file://root/main.js.map');
4834 });
4835
4836 it('normalizes file protocol 2.5', () => {
4837 const base = '..';
4838 const input = 'file://root';
4839 const resolved = resolve(input, base);
4840 assert.strictEqual(resolved, 'file://root/');
4841 });
4842
4843 it('normalizes file protocol 3', () => {
4844 const base = '..';
4845 const input = 'file:/root/main.js.map';
4846 const resolved = resolve(input, base);
4847 assert.strictEqual(resolved, 'file:///root/main.js.map');
4848 });
4849
4850 it('normalizes file protocol 4', () => {
4851 const base = '..';
4852 const input = 'file:root/main.js.map';
4853 const resolved = resolve(input, base);
4854 assert.strictEqual(resolved, 'file:///root/main.js.map');
4855 });
4856
4857 it('normalizes file protocol 1 with query', () => {
4858 const base = '..';
4859 const input = 'file:///root/main.js.map?input';
4860 const resolved = resolve(input, base);
4861 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
4862 });
4863
4864 it('normalizes file protocol 2 with query', () => {
4865 const base = '..';
4866 const input = 'file://root/main.js.map?input';
4867 const resolved = resolve(input, base);
4868 assert.strictEqual(resolved, 'file://root/main.js.map?input');
4869 });
4870
4871 it('normalizes file protocol 2.5 with query', () => {
4872 const base = '..';
4873 const input = 'file://root?input';
4874 const resolved = resolve(input, base);
4875 assert.strictEqual(resolved, 'file://root/?input');
4876 });
4877
4878 it('normalizes file protocol 3 with query', () => {
4879 const base = '..';
4880 const input = 'file:/root/main.js.map?input';
4881 const resolved = resolve(input, base);
4882 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
4883 });
4884
4885 it('normalizes file protocol 4 with query', () => {
4886 const base = '..';
4887 const input = 'file:root/main.js.map?input';
4888 const resolved = resolve(input, base);
4889 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
4890 });
4891 });
4892
4893 describe('with protocol relative input', () => {
4894 it('resolves relative to the base protocol', () => {
4895 const base = '..';
4896 const input = '//protocol-relative.com/main.js.map';
4897 const resolved = resolve(input, base);
4898 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
4899 });
4900
4901 it('resolves relative to the base protocol with query', () => {
4902 const base = '..';
4903 const input = '//protocol-relative.com/main.js.map?input';
4904 const resolved = resolve(input, base);
4905 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map?input');
4906 });
4907
4908 it('normalizes input path', () => {
4909 const base = '..';
4910 const input = '//protocol-relative.com/foo/./bar/../main.js.map';
4911 const resolved = resolve(input, base);
4912 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map');
4913 });
4914
4915 it('normalizes input path with query', () => {
4916 const base = '..';
4917 const input = '//protocol-relative.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
4918 const resolved = resolve(input, base);
4919 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map?input!webpack://foo/./bar');
4920 });
4921
4922 it('normalizes pathless input', () => {
4923 const base = '..';
4924 const input = '//protocol-relative.com';
4925 const resolved = resolve(input, base);
4926 assert.strictEqual(resolved, '//protocol-relative.com/');
4927 });
4928
4929 it('normalizes pathless input with query', () => {
4930 const base = '..';
4931 const input = '//protocol-relative.com?input';
4932 const resolved = resolve(input, base);
4933 assert.strictEqual(resolved, '//protocol-relative.com/?input');
4934 });
4935
4936 it('normalizes current directory', () => {
4937 const base = '..';
4938 const input = '//protocol-relative.com/./main.js.map';
4939 const resolved = resolve(input, base);
4940 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
4941 });
4942
4943 it('normalizes too many parent accessors', () => {
4944 const base = '..';
4945 const input = '//protocol-relative.com/../main.js.map';
4946 const resolved = resolve(input, base);
4947 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
4948 });
4949
4950 it('normalizes too many parent accessors, late', () => {
4951 const base = '..';
4952 const input = '//protocol-relative.com/foo/../../main.js.map';
4953 const resolved = resolve(input, base);
4954 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
4955 });
4956 });
4957
4958 describe('with absolute path input', () => {
4959 it('remains absolute path', () => {
4960 const base = '..';
4961 const input = '/assets/main.js.map';
4962 const resolved = resolve(input, base);
4963 assert.strictEqual(resolved, '/assets/main.js.map');
4964 });
4965
4966 it('remains absolute path with query', () => {
4967 const base = '..';
4968 const input = '/assets/main.js.map?input';
4969 const resolved = resolve(input, base);
4970 assert.strictEqual(resolved, '/assets/main.js.map?input');
4971 });
4972
4973 it('trims to root', () => {
4974 const base = '..';
4975 const input = '/';
4976 const resolved = resolve(input, base);
4977 assert.strictEqual(resolved, '/');
4978 });
4979
4980 it('normalizes input path', () => {
4981 const base = '..';
4982 const input = '/foo/./bar/../main.js.map';
4983 const resolved = resolve(input, base);
4984 assert.strictEqual(resolved, '/foo/main.js.map');
4985 });
4986
4987 it('normalizes current directory', () => {
4988 const base = '..';
4989 const input = '/./main.js.map';
4990 const resolved = resolve(input, base);
4991 assert.strictEqual(resolved, '/main.js.map');
4992 });
4993
4994 it('normalizes too many parent accessors', () => {
4995 const base = '..';
4996 const input = '/../../../main.js.map';
4997 const resolved = resolve(input, base);
4998 assert.strictEqual(resolved, '/main.js.map');
4999 });
5000
5001 it('normalizes too many parent accessors with query 1', () => {
5002 const base = '..';
5003 const input = '/../../../?input';
5004 const resolved = resolve(input, base);
5005 assert.strictEqual(resolved, '/?input');
5006 });
5007
5008 it('normalizes too many parent accessors with query 2', () => {
5009 const base = '..';
5010 const input = '/../../..?input';
5011 const resolved = resolve(input, base);
5012 assert.strictEqual(resolved, '/?input');
5013 });
5014
5015 it('normalizes too many parent accessors, late', () => {
5016 const base = '..';
5017 const input = '/foo/../../../main.js.map';
5018 const resolved = resolve(input, base);
5019 assert.strictEqual(resolved, '/main.js.map');
5020 });
5021 });
5022
5023 describe('with leading dot relative input', () => {
5024 it('resolves relative to current directory', () => {
5025 const base = '..';
5026 const input = './bar/main.js.map';
5027 const resolved = resolve(input, base);
5028 assert.strictEqual(resolved, '../bar/main.js.map');
5029 });
5030
5031 it('resolves relative to current directory with query', () => {
5032 const base = '..';
5033 const input = './bar/main.js.map?input';
5034 const resolved = resolve(input, base);
5035 assert.strictEqual(resolved, '../bar/main.js.map?input');
5036 });
5037
5038 it('resolves relative to parent directory', () => {
5039 const base = '..';
5040 const input = '../bar/main.js.map';
5041 const resolved = resolve(input, base);
5042 assert.strictEqual(resolved, '../../bar/main.js.map');
5043 });
5044
5045 it('resolves relative to parent directory with query', () => {
5046 const base = '..';
5047 const input = '../bar/main.js.map?input';
5048 const resolved = resolve(input, base);
5049 assert.strictEqual(resolved, '../../bar/main.js.map?input');
5050 });
5051
5052 it('resolves relative to parent multiple directory', () => {
5053 const base = '..';
5054 const input = '../../../bar/main.js.map';
5055 const resolved = resolve(input, base);
5056 assert.strictEqual(resolved, '../../../../bar/main.js.map');
5057 });
5058
5059 it('resolves relative to parent multiple directory with query 1', () => {
5060 const base = '..';
5061 const input = '../../../?input';
5062 const resolved = resolve(input, base);
5063 assert.strictEqual(resolved, '../../../..?input');
5064 });
5065
5066 it('resolves relative to parent multiple directory with query 2', () => {
5067 const base = '..';
5068 const input = '../../..?input';
5069 const resolved = resolve(input, base);
5070 assert.strictEqual(resolved, '../../../..?input');
5071 });
5072
5073 it('normalizes input path', () => {
5074 const base = '..';
5075 const input = './foo/./bar/../main.js.map';
5076 const resolved = resolve(input, base);
5077 assert.strictEqual(resolved, '../foo/main.js.map');
5078 });
5079 });
5080
5081 describe('with relative path input', () => {
5082 it('resolves relative to current directory', () => {
5083 const base = '..';
5084 const input = 'bar/main.js.map';
5085 const resolved = resolve(input, base);
5086 assert.strictEqual(resolved, '../bar/main.js.map');
5087 });
5088
5089 it('resolves relative to current directory with query', () => {
5090 const base = '..';
5091 const input = 'bar/main.js.map?input';
5092 const resolved = resolve(input, base);
5093 assert.strictEqual(resolved, '../bar/main.js.map?input');
5094 });
5095
5096 it('resolves relative to parent multiple directory, later', () => {
5097 const base = '..';
5098 const input = 'foo/../../../bar/main.js.map';
5099 const resolved = resolve(input, base);
5100 assert.strictEqual(resolved, '../../../bar/main.js.map');
5101 });
5102
5103 it('normalizes input path', () => {
5104 const base = '..';
5105 const input = 'foo/./bar/../main.js.map';
5106 const resolved = resolve(input, base);
5107 assert.strictEqual(resolved, '../foo/main.js.map');
5108 });
5109
5110 it('resolves node_module scope as path', () => {
5111 const base = '..';
5112 const input = 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js';
5113 const resolved = resolve(input, base);
5114 assert.strictEqual(resolved, '../node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js');
5115 });
5116
5117 it('resolves package scope as path', () => {
5118 const base = '..';
5119 const input = '@babel/runtime/helpers/esm/arrayLikeToArray.js';
5120 const resolved = resolve(input, base);
5121 assert.strictEqual(resolved, '../@babel/runtime/helpers/esm/arrayLikeToArray.js');
5122 });
5123 });
5124
5125 describe('with query input', () => {
5126 it('resolves relative to path', () => {
5127 const base = '..';
5128 const input = '?input';
5129 const resolved = resolve(input, base);
5130 assert.strictEqual(resolved, '..?input');
5131 });
5132 });
5133
5134 describe('with hash input', () => {
5135 it('resolves relative to path', () => {
5136 const base = '..';
5137 const input = '#input';
5138 const resolved = resolve(input, base);
5139 assert.strictEqual(resolved, '..#input');
5140 });
5141 });
5142
5143 describe('empty input', () => {
5144 it('normalizes base', () => {
5145 const base = '..';
5146 const input = '';
5147 const resolved = resolve(input, base);
5148 assert.strictEqual(resolved, '..');
5149 });
5150 });
5151 });
5152
5153 describe(`base = "../"`, () => {
5154 describe('with absolute input', () => {
5155 it('returns input', () => {
5156 const base = '../';
5157 const input = 'https://absolute.com/main.js.map';
5158 const resolved = resolve(input, base);
5159 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
5160 });
5161
5162 it('returns input with query', () => {
5163 const base = '../';
5164 const input = 'https://absolute.com/main.js.map?input';
5165 const resolved = resolve(input, base);
5166 assert.strictEqual(resolved, 'https://absolute.com/main.js.map?input');
5167 });
5168
5169 it('normalizes input path', () => {
5170 const base = '../';
5171 const input = 'https://absolute.com/foo/./bar/../main.js.map';
5172 const resolved = resolve(input, base);
5173 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map');
5174 });
5175
5176 it('normalizes input path with query', () => {
5177 const base = '../';
5178 const input = 'https://absolute.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
5179 const resolved = resolve(input, base);
5180 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map?input!webpack://foo/./bar');
5181 });
5182
5183 it('normalizes pathless input', () => {
5184 const base = '../';
5185 const input = 'https://absolute.com';
5186 const resolved = resolve(input, base);
5187 assert.strictEqual(resolved, 'https://absolute.com/');
5188 });
5189
5190 it('normalizes pathless input with query', () => {
5191 const base = '../';
5192 const input = 'https://absolute.com?input';
5193 const resolved = resolve(input, base);
5194 assert.strictEqual(resolved, 'https://absolute.com/?input');
5195 });
5196
5197 it('normalizes current directory', () => {
5198 const base = '../';
5199 const input = 'https://absolute.com/./main.js.map';
5200 const resolved = resolve(input, base);
5201 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
5202 });
5203
5204 it('normalizes too many parent accessors', () => {
5205 const base = '../';
5206 const input = 'https://absolute.com/../../../main.js.map';
5207 const resolved = resolve(input, base);
5208 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
5209 });
5210
5211 it('normalizes too many parent accessors, late', () => {
5212 const base = '../';
5213 const input = 'https://absolute.com/foo/../../../main.js.map';
5214 const resolved = resolve(input, base);
5215 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
5216 });
5217
5218 it('normalizes file protocol 1', () => {
5219 const base = '../';
5220 const input = 'file:///root/main.js.map';
5221 const resolved = resolve(input, base);
5222 assert.strictEqual(resolved, 'file:///root/main.js.map');
5223 });
5224
5225 it('normalizes file protocol 2', () => {
5226 const base = '../';
5227 const input = 'file://root/main.js.map';
5228 const resolved = resolve(input, base);
5229 assert.strictEqual(resolved, 'file://root/main.js.map');
5230 });
5231
5232 it('normalizes file protocol 2.5', () => {
5233 const base = '../';
5234 const input = 'file://root';
5235 const resolved = resolve(input, base);
5236 assert.strictEqual(resolved, 'file://root/');
5237 });
5238
5239 it('normalizes file protocol 3', () => {
5240 const base = '../';
5241 const input = 'file:/root/main.js.map';
5242 const resolved = resolve(input, base);
5243 assert.strictEqual(resolved, 'file:///root/main.js.map');
5244 });
5245
5246 it('normalizes file protocol 4', () => {
5247 const base = '../';
5248 const input = 'file:root/main.js.map';
5249 const resolved = resolve(input, base);
5250 assert.strictEqual(resolved, 'file:///root/main.js.map');
5251 });
5252
5253 it('normalizes file protocol 1 with query', () => {
5254 const base = '../';
5255 const input = 'file:///root/main.js.map?input';
5256 const resolved = resolve(input, base);
5257 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
5258 });
5259
5260 it('normalizes file protocol 2 with query', () => {
5261 const base = '../';
5262 const input = 'file://root/main.js.map?input';
5263 const resolved = resolve(input, base);
5264 assert.strictEqual(resolved, 'file://root/main.js.map?input');
5265 });
5266
5267 it('normalizes file protocol 2.5 with query', () => {
5268 const base = '../';
5269 const input = 'file://root?input';
5270 const resolved = resolve(input, base);
5271 assert.strictEqual(resolved, 'file://root/?input');
5272 });
5273
5274 it('normalizes file protocol 3 with query', () => {
5275 const base = '../';
5276 const input = 'file:/root/main.js.map?input';
5277 const resolved = resolve(input, base);
5278 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
5279 });
5280
5281 it('normalizes file protocol 4 with query', () => {
5282 const base = '../';
5283 const input = 'file:root/main.js.map?input';
5284 const resolved = resolve(input, base);
5285 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
5286 });
5287 });
5288
5289 describe('with protocol relative input', () => {
5290 it('resolves relative to the base protocol', () => {
5291 const base = '../';
5292 const input = '//protocol-relative.com/main.js.map';
5293 const resolved = resolve(input, base);
5294 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
5295 });
5296
5297 it('resolves relative to the base protocol with query', () => {
5298 const base = '../';
5299 const input = '//protocol-relative.com/main.js.map?input';
5300 const resolved = resolve(input, base);
5301 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map?input');
5302 });
5303
5304 it('normalizes input path', () => {
5305 const base = '../';
5306 const input = '//protocol-relative.com/foo/./bar/../main.js.map';
5307 const resolved = resolve(input, base);
5308 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map');
5309 });
5310
5311 it('normalizes input path with query', () => {
5312 const base = '../';
5313 const input = '//protocol-relative.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
5314 const resolved = resolve(input, base);
5315 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map?input!webpack://foo/./bar');
5316 });
5317
5318 it('normalizes pathless input', () => {
5319 const base = '../';
5320 const input = '//protocol-relative.com';
5321 const resolved = resolve(input, base);
5322 assert.strictEqual(resolved, '//protocol-relative.com/');
5323 });
5324
5325 it('normalizes pathless input with query', () => {
5326 const base = '../';
5327 const input = '//protocol-relative.com?input';
5328 const resolved = resolve(input, base);
5329 assert.strictEqual(resolved, '//protocol-relative.com/?input');
5330 });
5331
5332 it('normalizes current directory', () => {
5333 const base = '../';
5334 const input = '//protocol-relative.com/./main.js.map';
5335 const resolved = resolve(input, base);
5336 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
5337 });
5338
5339 it('normalizes too many parent accessors', () => {
5340 const base = '../';
5341 const input = '//protocol-relative.com/../main.js.map';
5342 const resolved = resolve(input, base);
5343 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
5344 });
5345
5346 it('normalizes too many parent accessors, late', () => {
5347 const base = '../';
5348 const input = '//protocol-relative.com/foo/../../main.js.map';
5349 const resolved = resolve(input, base);
5350 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
5351 });
5352 });
5353
5354 describe('with absolute path input', () => {
5355 it('remains absolute path', () => {
5356 const base = '../';
5357 const input = '/assets/main.js.map';
5358 const resolved = resolve(input, base);
5359 assert.strictEqual(resolved, '/assets/main.js.map');
5360 });
5361
5362 it('remains absolute path with query', () => {
5363 const base = '../';
5364 const input = '/assets/main.js.map?input';
5365 const resolved = resolve(input, base);
5366 assert.strictEqual(resolved, '/assets/main.js.map?input');
5367 });
5368
5369 it('trims to root', () => {
5370 const base = '../';
5371 const input = '/';
5372 const resolved = resolve(input, base);
5373 assert.strictEqual(resolved, '/');
5374 });
5375
5376 it('normalizes input path', () => {
5377 const base = '../';
5378 const input = '/foo/./bar/../main.js.map';
5379 const resolved = resolve(input, base);
5380 assert.strictEqual(resolved, '/foo/main.js.map');
5381 });
5382
5383 it('normalizes current directory', () => {
5384 const base = '../';
5385 const input = '/./main.js.map';
5386 const resolved = resolve(input, base);
5387 assert.strictEqual(resolved, '/main.js.map');
5388 });
5389
5390 it('normalizes too many parent accessors', () => {
5391 const base = '../';
5392 const input = '/../../../main.js.map';
5393 const resolved = resolve(input, base);
5394 assert.strictEqual(resolved, '/main.js.map');
5395 });
5396
5397 it('normalizes too many parent accessors with query 1', () => {
5398 const base = '../';
5399 const input = '/../../../?input';
5400 const resolved = resolve(input, base);
5401 assert.strictEqual(resolved, '/?input');
5402 });
5403
5404 it('normalizes too many parent accessors with query 2', () => {
5405 const base = '../';
5406 const input = '/../../..?input';
5407 const resolved = resolve(input, base);
5408 assert.strictEqual(resolved, '/?input');
5409 });
5410
5411 it('normalizes too many parent accessors, late', () => {
5412 const base = '../';
5413 const input = '/foo/../../../main.js.map';
5414 const resolved = resolve(input, base);
5415 assert.strictEqual(resolved, '/main.js.map');
5416 });
5417 });
5418
5419 describe('with leading dot relative input', () => {
5420 it('resolves relative to current directory', () => {
5421 const base = '../';
5422 const input = './bar/main.js.map';
5423 const resolved = resolve(input, base);
5424 assert.strictEqual(resolved, '../bar/main.js.map');
5425 });
5426
5427 it('resolves relative to current directory with query', () => {
5428 const base = '../';
5429 const input = './bar/main.js.map?input';
5430 const resolved = resolve(input, base);
5431 assert.strictEqual(resolved, '../bar/main.js.map?input');
5432 });
5433
5434 it('resolves relative to parent directory', () => {
5435 const base = '../';
5436 const input = '../bar/main.js.map';
5437 const resolved = resolve(input, base);
5438 assert.strictEqual(resolved, '../../bar/main.js.map');
5439 });
5440
5441 it('resolves relative to parent directory with query', () => {
5442 const base = '../';
5443 const input = '../bar/main.js.map?input';
5444 const resolved = resolve(input, base);
5445 assert.strictEqual(resolved, '../../bar/main.js.map?input');
5446 });
5447
5448 it('resolves relative to parent multiple directory', () => {
5449 const base = '../';
5450 const input = '../../../bar/main.js.map';
5451 const resolved = resolve(input, base);
5452 assert.strictEqual(resolved, '../../../../bar/main.js.map');
5453 });
5454
5455 it('resolves relative to parent multiple directory with query 1', () => {
5456 const base = '../';
5457 const input = '../../../?input';
5458 const resolved = resolve(input, base);
5459 assert.strictEqual(resolved, '../../../..?input');
5460 });
5461
5462 it('resolves relative to parent multiple directory with query 2', () => {
5463 const base = '../';
5464 const input = '../../..?input';
5465 const resolved = resolve(input, base);
5466 assert.strictEqual(resolved, '../../../..?input');
5467 });
5468
5469 it('normalizes input path', () => {
5470 const base = '../';
5471 const input = './foo/./bar/../main.js.map';
5472 const resolved = resolve(input, base);
5473 assert.strictEqual(resolved, '../foo/main.js.map');
5474 });
5475 });
5476
5477 describe('with relative path input', () => {
5478 it('resolves relative to current directory', () => {
5479 const base = '../';
5480 const input = 'bar/main.js.map';
5481 const resolved = resolve(input, base);
5482 assert.strictEqual(resolved, '../bar/main.js.map');
5483 });
5484
5485 it('resolves relative to current directory with query', () => {
5486 const base = '../';
5487 const input = 'bar/main.js.map?input';
5488 const resolved = resolve(input, base);
5489 assert.strictEqual(resolved, '../bar/main.js.map?input');
5490 });
5491
5492 it('resolves relative to parent multiple directory, later', () => {
5493 const base = '../';
5494 const input = 'foo/../../../bar/main.js.map';
5495 const resolved = resolve(input, base);
5496 assert.strictEqual(resolved, '../../../bar/main.js.map');
5497 });
5498
5499 it('normalizes input path', () => {
5500 const base = '../';
5501 const input = 'foo/./bar/../main.js.map';
5502 const resolved = resolve(input, base);
5503 assert.strictEqual(resolved, '../foo/main.js.map');
5504 });
5505
5506 it('resolves node_module scope as path', () => {
5507 const base = '../';
5508 const input = 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js';
5509 const resolved = resolve(input, base);
5510 assert.strictEqual(resolved, '../node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js');
5511 });
5512
5513 it('resolves package scope as path', () => {
5514 const base = '../';
5515 const input = '@babel/runtime/helpers/esm/arrayLikeToArray.js';
5516 const resolved = resolve(input, base);
5517 assert.strictEqual(resolved, '../@babel/runtime/helpers/esm/arrayLikeToArray.js');
5518 });
5519 });
5520
5521 describe('with query input', () => {
5522 it('resolves relative to path', () => {
5523 const base = '../';
5524 const input = '?input';
5525 const resolved = resolve(input, base);
5526 assert.strictEqual(resolved, '..?input');
5527 });
5528 });
5529
5530 describe('with hash input', () => {
5531 it('resolves relative to path', () => {
5532 const base = '../';
5533 const input = '#input';
5534 const resolved = resolve(input, base);
5535 assert.strictEqual(resolved, '..#input');
5536 });
5537 });
5538
5539 describe('empty input', () => {
5540 it('normalizes base', () => {
5541 const base = '../';
5542 const input = '';
5543 const resolved = resolve(input, base);
5544 assert.strictEqual(resolved, '..');
5545 });
5546 });
5547 });
5548
5549 describe(`base = "dir/.."`, () => {
5550 describe('with absolute input', () => {
5551 it('returns input', () => {
5552 const base = 'dir/..';
5553 const input = 'https://absolute.com/main.js.map';
5554 const resolved = resolve(input, base);
5555 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
5556 });
5557
5558 it('returns input with query', () => {
5559 const base = 'dir/..';
5560 const input = 'https://absolute.com/main.js.map?input';
5561 const resolved = resolve(input, base);
5562 assert.strictEqual(resolved, 'https://absolute.com/main.js.map?input');
5563 });
5564
5565 it('normalizes input path', () => {
5566 const base = 'dir/..';
5567 const input = 'https://absolute.com/foo/./bar/../main.js.map';
5568 const resolved = resolve(input, base);
5569 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map');
5570 });
5571
5572 it('normalizes input path with query', () => {
5573 const base = 'dir/..';
5574 const input = 'https://absolute.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
5575 const resolved = resolve(input, base);
5576 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map?input!webpack://foo/./bar');
5577 });
5578
5579 it('normalizes pathless input', () => {
5580 const base = 'dir/..';
5581 const input = 'https://absolute.com';
5582 const resolved = resolve(input, base);
5583 assert.strictEqual(resolved, 'https://absolute.com/');
5584 });
5585
5586 it('normalizes pathless input with query', () => {
5587 const base = 'dir/..';
5588 const input = 'https://absolute.com?input';
5589 const resolved = resolve(input, base);
5590 assert.strictEqual(resolved, 'https://absolute.com/?input');
5591 });
5592
5593 it('normalizes current directory', () => {
5594 const base = 'dir/..';
5595 const input = 'https://absolute.com/./main.js.map';
5596 const resolved = resolve(input, base);
5597 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
5598 });
5599
5600 it('normalizes too many parent accessors', () => {
5601 const base = 'dir/..';
5602 const input = 'https://absolute.com/../../../main.js.map';
5603 const resolved = resolve(input, base);
5604 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
5605 });
5606
5607 it('normalizes too many parent accessors, late', () => {
5608 const base = 'dir/..';
5609 const input = 'https://absolute.com/foo/../../../main.js.map';
5610 const resolved = resolve(input, base);
5611 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
5612 });
5613
5614 it('normalizes file protocol 1', () => {
5615 const base = 'dir/..';
5616 const input = 'file:///root/main.js.map';
5617 const resolved = resolve(input, base);
5618 assert.strictEqual(resolved, 'file:///root/main.js.map');
5619 });
5620
5621 it('normalizes file protocol 2', () => {
5622 const base = 'dir/..';
5623 const input = 'file://root/main.js.map';
5624 const resolved = resolve(input, base);
5625 assert.strictEqual(resolved, 'file://root/main.js.map');
5626 });
5627
5628 it('normalizes file protocol 2.5', () => {
5629 const base = 'dir/..';
5630 const input = 'file://root';
5631 const resolved = resolve(input, base);
5632 assert.strictEqual(resolved, 'file://root/');
5633 });
5634
5635 it('normalizes file protocol 3', () => {
5636 const base = 'dir/..';
5637 const input = 'file:/root/main.js.map';
5638 const resolved = resolve(input, base);
5639 assert.strictEqual(resolved, 'file:///root/main.js.map');
5640 });
5641
5642 it('normalizes file protocol 4', () => {
5643 const base = 'dir/..';
5644 const input = 'file:root/main.js.map';
5645 const resolved = resolve(input, base);
5646 assert.strictEqual(resolved, 'file:///root/main.js.map');
5647 });
5648
5649 it('normalizes file protocol 1 with query', () => {
5650 const base = 'dir/..';
5651 const input = 'file:///root/main.js.map?input';
5652 const resolved = resolve(input, base);
5653 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
5654 });
5655
5656 it('normalizes file protocol 2 with query', () => {
5657 const base = 'dir/..';
5658 const input = 'file://root/main.js.map?input';
5659 const resolved = resolve(input, base);
5660 assert.strictEqual(resolved, 'file://root/main.js.map?input');
5661 });
5662
5663 it('normalizes file protocol 2.5 with query', () => {
5664 const base = 'dir/..';
5665 const input = 'file://root?input';
5666 const resolved = resolve(input, base);
5667 assert.strictEqual(resolved, 'file://root/?input');
5668 });
5669
5670 it('normalizes file protocol 3 with query', () => {
5671 const base = 'dir/..';
5672 const input = 'file:/root/main.js.map?input';
5673 const resolved = resolve(input, base);
5674 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
5675 });
5676
5677 it('normalizes file protocol 4 with query', () => {
5678 const base = 'dir/..';
5679 const input = 'file:root/main.js.map?input';
5680 const resolved = resolve(input, base);
5681 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
5682 });
5683 });
5684
5685 describe('with protocol relative input', () => {
5686 it('resolves relative to the base protocol', () => {
5687 const base = 'dir/..';
5688 const input = '//protocol-relative.com/main.js.map';
5689 const resolved = resolve(input, base);
5690 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
5691 });
5692
5693 it('resolves relative to the base protocol with query', () => {
5694 const base = 'dir/..';
5695 const input = '//protocol-relative.com/main.js.map?input';
5696 const resolved = resolve(input, base);
5697 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map?input');
5698 });
5699
5700 it('normalizes input path', () => {
5701 const base = 'dir/..';
5702 const input = '//protocol-relative.com/foo/./bar/../main.js.map';
5703 const resolved = resolve(input, base);
5704 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map');
5705 });
5706
5707 it('normalizes input path with query', () => {
5708 const base = 'dir/..';
5709 const input = '//protocol-relative.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
5710 const resolved = resolve(input, base);
5711 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map?input!webpack://foo/./bar');
5712 });
5713
5714 it('normalizes pathless input', () => {
5715 const base = 'dir/..';
5716 const input = '//protocol-relative.com';
5717 const resolved = resolve(input, base);
5718 assert.strictEqual(resolved, '//protocol-relative.com/');
5719 });
5720
5721 it('normalizes pathless input with query', () => {
5722 const base = 'dir/..';
5723 const input = '//protocol-relative.com?input';
5724 const resolved = resolve(input, base);
5725 assert.strictEqual(resolved, '//protocol-relative.com/?input');
5726 });
5727
5728 it('normalizes current directory', () => {
5729 const base = 'dir/..';
5730 const input = '//protocol-relative.com/./main.js.map';
5731 const resolved = resolve(input, base);
5732 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
5733 });
5734
5735 it('normalizes too many parent accessors', () => {
5736 const base = 'dir/..';
5737 const input = '//protocol-relative.com/../main.js.map';
5738 const resolved = resolve(input, base);
5739 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
5740 });
5741
5742 it('normalizes too many parent accessors, late', () => {
5743 const base = 'dir/..';
5744 const input = '//protocol-relative.com/foo/../../main.js.map';
5745 const resolved = resolve(input, base);
5746 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
5747 });
5748 });
5749
5750 describe('with absolute path input', () => {
5751 it('remains absolute path', () => {
5752 const base = 'dir/..';
5753 const input = '/assets/main.js.map';
5754 const resolved = resolve(input, base);
5755 assert.strictEqual(resolved, '/assets/main.js.map');
5756 });
5757
5758 it('remains absolute path with query', () => {
5759 const base = 'dir/..';
5760 const input = '/assets/main.js.map?input';
5761 const resolved = resolve(input, base);
5762 assert.strictEqual(resolved, '/assets/main.js.map?input');
5763 });
5764
5765 it('trims to root', () => {
5766 const base = 'dir/..';
5767 const input = '/';
5768 const resolved = resolve(input, base);
5769 assert.strictEqual(resolved, '/');
5770 });
5771
5772 it('normalizes input path', () => {
5773 const base = 'dir/..';
5774 const input = '/foo/./bar/../main.js.map';
5775 const resolved = resolve(input, base);
5776 assert.strictEqual(resolved, '/foo/main.js.map');
5777 });
5778
5779 it('normalizes current directory', () => {
5780 const base = 'dir/..';
5781 const input = '/./main.js.map';
5782 const resolved = resolve(input, base);
5783 assert.strictEqual(resolved, '/main.js.map');
5784 });
5785
5786 it('normalizes too many parent accessors', () => {
5787 const base = 'dir/..';
5788 const input = '/../../../main.js.map';
5789 const resolved = resolve(input, base);
5790 assert.strictEqual(resolved, '/main.js.map');
5791 });
5792
5793 it('normalizes too many parent accessors with query 1', () => {
5794 const base = 'dir/..';
5795 const input = '/../../../?input';
5796 const resolved = resolve(input, base);
5797 assert.strictEqual(resolved, '/?input');
5798 });
5799
5800 it('normalizes too many parent accessors with query 2', () => {
5801 const base = 'dir/..';
5802 const input = '/../../..?input';
5803 const resolved = resolve(input, base);
5804 assert.strictEqual(resolved, '/?input');
5805 });
5806
5807 it('normalizes too many parent accessors, late', () => {
5808 const base = 'dir/..';
5809 const input = '/foo/../../../main.js.map';
5810 const resolved = resolve(input, base);
5811 assert.strictEqual(resolved, '/main.js.map');
5812 });
5813 });
5814
5815 describe('with leading dot relative input', () => {
5816 it('resolves relative to current directory', () => {
5817 const base = 'dir/..';
5818 const input = './bar/main.js.map';
5819 const resolved = resolve(input, base);
5820 assert.strictEqual(resolved, 'bar/main.js.map');
5821 });
5822
5823 it('resolves relative to current directory with query', () => {
5824 const base = 'dir/..';
5825 const input = './bar/main.js.map?input';
5826 const resolved = resolve(input, base);
5827 assert.strictEqual(resolved, 'bar/main.js.map?input');
5828 });
5829
5830 it('resolves relative to parent directory', () => {
5831 const base = 'dir/..';
5832 const input = '../bar/main.js.map';
5833 const resolved = resolve(input, base);
5834 assert.strictEqual(resolved, '../bar/main.js.map');
5835 });
5836
5837 it('resolves relative to parent directory with query', () => {
5838 const base = 'dir/..';
5839 const input = '../bar/main.js.map?input';
5840 const resolved = resolve(input, base);
5841 assert.strictEqual(resolved, '../bar/main.js.map?input');
5842 });
5843
5844 it('resolves relative to parent multiple directory', () => {
5845 const base = 'dir/..';
5846 const input = '../../../bar/main.js.map';
5847 const resolved = resolve(input, base);
5848 assert.strictEqual(resolved, '../../../bar/main.js.map');
5849 });
5850
5851 it('resolves relative to parent multiple directory with query 1', () => {
5852 const base = 'dir/..';
5853 const input = '../../../?input';
5854 const resolved = resolve(input, base);
5855 assert.strictEqual(resolved, '../../..?input');
5856 });
5857
5858 it('resolves relative to parent multiple directory with query 2', () => {
5859 const base = 'dir/..';
5860 const input = '../../..?input';
5861 const resolved = resolve(input, base);
5862 assert.strictEqual(resolved, '../../..?input');
5863 });
5864
5865 it('normalizes input path', () => {
5866 const base = 'dir/..';
5867 const input = './foo/./bar/../main.js.map';
5868 const resolved = resolve(input, base);
5869 assert.strictEqual(resolved, 'foo/main.js.map');
5870 });
5871 });
5872
5873 describe('with relative path input', () => {
5874 it('resolves relative to current directory', () => {
5875 const base = 'dir/..';
5876 const input = 'bar/main.js.map';
5877 const resolved = resolve(input, base);
5878 assert.strictEqual(resolved, 'bar/main.js.map');
5879 });
5880
5881 it('resolves relative to current directory with query', () => {
5882 const base = 'dir/..';
5883 const input = 'bar/main.js.map?input';
5884 const resolved = resolve(input, base);
5885 assert.strictEqual(resolved, 'bar/main.js.map?input');
5886 });
5887
5888 it('resolves relative to parent multiple directory, later', () => {
5889 const base = 'dir/..';
5890 const input = 'foo/../../../bar/main.js.map';
5891 const resolved = resolve(input, base);
5892 assert.strictEqual(resolved, '../../bar/main.js.map');
5893 });
5894
5895 it('normalizes input path', () => {
5896 const base = 'dir/..';
5897 const input = 'foo/./bar/../main.js.map';
5898 const resolved = resolve(input, base);
5899 assert.strictEqual(resolved, 'foo/main.js.map');
5900 });
5901
5902 it('resolves node_module scope as path', () => {
5903 const base = 'dir/..';
5904 const input = 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js';
5905 const resolved = resolve(input, base);
5906 assert.strictEqual(resolved, 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js');
5907 });
5908
5909 it('resolves package scope as path', () => {
5910 const base = 'dir/..';
5911 const input = '@babel/runtime/helpers/esm/arrayLikeToArray.js';
5912 const resolved = resolve(input, base);
5913 assert.strictEqual(resolved, '@babel/runtime/helpers/esm/arrayLikeToArray.js');
5914 });
5915 });
5916
5917 describe('with query input', () => {
5918 it('resolves relative to path', () => {
5919 const base = 'dir/..';
5920 const input = '?input';
5921 const resolved = resolve(input, base);
5922 assert.strictEqual(resolved, '?input');
5923 });
5924 });
5925
5926 describe('with hash input', () => {
5927 it('resolves relative to path', () => {
5928 const base = 'dir/..';
5929 const input = '#input';
5930 const resolved = resolve(input, base);
5931 assert.strictEqual(resolved, '#input');
5932 });
5933 });
5934
5935 describe('empty input', () => {
5936 it('normalizes base', () => {
5937 const base = 'dir/..';
5938 const input = '';
5939 const resolved = resolve(input, base);
5940 assert.strictEqual(resolved, '.');
5941 });
5942 });
5943 });
5944
5945 describe(`base = "deep/../"`, () => {
5946 describe('with absolute input', () => {
5947 it('returns input', () => {
5948 const base = 'deep/../';
5949 const input = 'https://absolute.com/main.js.map';
5950 const resolved = resolve(input, base);
5951 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
5952 });
5953
5954 it('returns input with query', () => {
5955 const base = 'deep/../';
5956 const input = 'https://absolute.com/main.js.map?input';
5957 const resolved = resolve(input, base);
5958 assert.strictEqual(resolved, 'https://absolute.com/main.js.map?input');
5959 });
5960
5961 it('normalizes input path', () => {
5962 const base = 'deep/../';
5963 const input = 'https://absolute.com/foo/./bar/../main.js.map';
5964 const resolved = resolve(input, base);
5965 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map');
5966 });
5967
5968 it('normalizes input path with query', () => {
5969 const base = 'deep/../';
5970 const input = 'https://absolute.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
5971 const resolved = resolve(input, base);
5972 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map?input!webpack://foo/./bar');
5973 });
5974
5975 it('normalizes pathless input', () => {
5976 const base = 'deep/../';
5977 const input = 'https://absolute.com';
5978 const resolved = resolve(input, base);
5979 assert.strictEqual(resolved, 'https://absolute.com/');
5980 });
5981
5982 it('normalizes pathless input with query', () => {
5983 const base = 'deep/../';
5984 const input = 'https://absolute.com?input';
5985 const resolved = resolve(input, base);
5986 assert.strictEqual(resolved, 'https://absolute.com/?input');
5987 });
5988
5989 it('normalizes current directory', () => {
5990 const base = 'deep/../';
5991 const input = 'https://absolute.com/./main.js.map';
5992 const resolved = resolve(input, base);
5993 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
5994 });
5995
5996 it('normalizes too many parent accessors', () => {
5997 const base = 'deep/../';
5998 const input = 'https://absolute.com/../../../main.js.map';
5999 const resolved = resolve(input, base);
6000 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
6001 });
6002
6003 it('normalizes too many parent accessors, late', () => {
6004 const base = 'deep/../';
6005 const input = 'https://absolute.com/foo/../../../main.js.map';
6006 const resolved = resolve(input, base);
6007 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
6008 });
6009
6010 it('normalizes file protocol 1', () => {
6011 const base = 'deep/../';
6012 const input = 'file:///root/main.js.map';
6013 const resolved = resolve(input, base);
6014 assert.strictEqual(resolved, 'file:///root/main.js.map');
6015 });
6016
6017 it('normalizes file protocol 2', () => {
6018 const base = 'deep/../';
6019 const input = 'file://root/main.js.map';
6020 const resolved = resolve(input, base);
6021 assert.strictEqual(resolved, 'file://root/main.js.map');
6022 });
6023
6024 it('normalizes file protocol 2.5', () => {
6025 const base = 'deep/../';
6026 const input = 'file://root';
6027 const resolved = resolve(input, base);
6028 assert.strictEqual(resolved, 'file://root/');
6029 });
6030
6031 it('normalizes file protocol 3', () => {
6032 const base = 'deep/../';
6033 const input = 'file:/root/main.js.map';
6034 const resolved = resolve(input, base);
6035 assert.strictEqual(resolved, 'file:///root/main.js.map');
6036 });
6037
6038 it('normalizes file protocol 4', () => {
6039 const base = 'deep/../';
6040 const input = 'file:root/main.js.map';
6041 const resolved = resolve(input, base);
6042 assert.strictEqual(resolved, 'file:///root/main.js.map');
6043 });
6044
6045 it('normalizes file protocol 1 with query', () => {
6046 const base = 'deep/../';
6047 const input = 'file:///root/main.js.map?input';
6048 const resolved = resolve(input, base);
6049 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
6050 });
6051
6052 it('normalizes file protocol 2 with query', () => {
6053 const base = 'deep/../';
6054 const input = 'file://root/main.js.map?input';
6055 const resolved = resolve(input, base);
6056 assert.strictEqual(resolved, 'file://root/main.js.map?input');
6057 });
6058
6059 it('normalizes file protocol 2.5 with query', () => {
6060 const base = 'deep/../';
6061 const input = 'file://root?input';
6062 const resolved = resolve(input, base);
6063 assert.strictEqual(resolved, 'file://root/?input');
6064 });
6065
6066 it('normalizes file protocol 3 with query', () => {
6067 const base = 'deep/../';
6068 const input = 'file:/root/main.js.map?input';
6069 const resolved = resolve(input, base);
6070 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
6071 });
6072
6073 it('normalizes file protocol 4 with query', () => {
6074 const base = 'deep/../';
6075 const input = 'file:root/main.js.map?input';
6076 const resolved = resolve(input, base);
6077 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
6078 });
6079 });
6080
6081 describe('with protocol relative input', () => {
6082 it('resolves relative to the base protocol', () => {
6083 const base = 'deep/../';
6084 const input = '//protocol-relative.com/main.js.map';
6085 const resolved = resolve(input, base);
6086 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
6087 });
6088
6089 it('resolves relative to the base protocol with query', () => {
6090 const base = 'deep/../';
6091 const input = '//protocol-relative.com/main.js.map?input';
6092 const resolved = resolve(input, base);
6093 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map?input');
6094 });
6095
6096 it('normalizes input path', () => {
6097 const base = 'deep/../';
6098 const input = '//protocol-relative.com/foo/./bar/../main.js.map';
6099 const resolved = resolve(input, base);
6100 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map');
6101 });
6102
6103 it('normalizes input path with query', () => {
6104 const base = 'deep/../';
6105 const input = '//protocol-relative.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
6106 const resolved = resolve(input, base);
6107 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map?input!webpack://foo/./bar');
6108 });
6109
6110 it('normalizes pathless input', () => {
6111 const base = 'deep/../';
6112 const input = '//protocol-relative.com';
6113 const resolved = resolve(input, base);
6114 assert.strictEqual(resolved, '//protocol-relative.com/');
6115 });
6116
6117 it('normalizes pathless input with query', () => {
6118 const base = 'deep/../';
6119 const input = '//protocol-relative.com?input';
6120 const resolved = resolve(input, base);
6121 assert.strictEqual(resolved, '//protocol-relative.com/?input');
6122 });
6123
6124 it('normalizes current directory', () => {
6125 const base = 'deep/../';
6126 const input = '//protocol-relative.com/./main.js.map';
6127 const resolved = resolve(input, base);
6128 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
6129 });
6130
6131 it('normalizes too many parent accessors', () => {
6132 const base = 'deep/../';
6133 const input = '//protocol-relative.com/../main.js.map';
6134 const resolved = resolve(input, base);
6135 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
6136 });
6137
6138 it('normalizes too many parent accessors, late', () => {
6139 const base = 'deep/../';
6140 const input = '//protocol-relative.com/foo/../../main.js.map';
6141 const resolved = resolve(input, base);
6142 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
6143 });
6144 });
6145
6146 describe('with absolute path input', () => {
6147 it('remains absolute path', () => {
6148 const base = 'deep/../';
6149 const input = '/assets/main.js.map';
6150 const resolved = resolve(input, base);
6151 assert.strictEqual(resolved, '/assets/main.js.map');
6152 });
6153
6154 it('remains absolute path with query', () => {
6155 const base = 'deep/../';
6156 const input = '/assets/main.js.map?input';
6157 const resolved = resolve(input, base);
6158 assert.strictEqual(resolved, '/assets/main.js.map?input');
6159 });
6160
6161 it('trims to root', () => {
6162 const base = 'deep/../';
6163 const input = '/';
6164 const resolved = resolve(input, base);
6165 assert.strictEqual(resolved, '/');
6166 });
6167
6168 it('normalizes input path', () => {
6169 const base = 'deep/../';
6170 const input = '/foo/./bar/../main.js.map';
6171 const resolved = resolve(input, base);
6172 assert.strictEqual(resolved, '/foo/main.js.map');
6173 });
6174
6175 it('normalizes current directory', () => {
6176 const base = 'deep/../';
6177 const input = '/./main.js.map';
6178 const resolved = resolve(input, base);
6179 assert.strictEqual(resolved, '/main.js.map');
6180 });
6181
6182 it('normalizes too many parent accessors', () => {
6183 const base = 'deep/../';
6184 const input = '/../../../main.js.map';
6185 const resolved = resolve(input, base);
6186 assert.strictEqual(resolved, '/main.js.map');
6187 });
6188
6189 it('normalizes too many parent accessors with query 1', () => {
6190 const base = 'deep/../';
6191 const input = '/../../../?input';
6192 const resolved = resolve(input, base);
6193 assert.strictEqual(resolved, '/?input');
6194 });
6195
6196 it('normalizes too many parent accessors with query 2', () => {
6197 const base = 'deep/../';
6198 const input = '/../../..?input';
6199 const resolved = resolve(input, base);
6200 assert.strictEqual(resolved, '/?input');
6201 });
6202
6203 it('normalizes too many parent accessors, late', () => {
6204 const base = 'deep/../';
6205 const input = '/foo/../../../main.js.map';
6206 const resolved = resolve(input, base);
6207 assert.strictEqual(resolved, '/main.js.map');
6208 });
6209 });
6210
6211 describe('with leading dot relative input', () => {
6212 it('resolves relative to current directory', () => {
6213 const base = 'deep/../';
6214 const input = './bar/main.js.map';
6215 const resolved = resolve(input, base);
6216 assert.strictEqual(resolved, 'bar/main.js.map');
6217 });
6218
6219 it('resolves relative to current directory with query', () => {
6220 const base = 'deep/../';
6221 const input = './bar/main.js.map?input';
6222 const resolved = resolve(input, base);
6223 assert.strictEqual(resolved, 'bar/main.js.map?input');
6224 });
6225
6226 it('resolves relative to parent directory', () => {
6227 const base = 'deep/../';
6228 const input = '../bar/main.js.map';
6229 const resolved = resolve(input, base);
6230 assert.strictEqual(resolved, '../bar/main.js.map');
6231 });
6232
6233 it('resolves relative to parent directory with query', () => {
6234 const base = 'deep/../';
6235 const input = '../bar/main.js.map?input';
6236 const resolved = resolve(input, base);
6237 assert.strictEqual(resolved, '../bar/main.js.map?input');
6238 });
6239
6240 it('resolves relative to parent multiple directory', () => {
6241 const base = 'deep/../';
6242 const input = '../../../bar/main.js.map';
6243 const resolved = resolve(input, base);
6244 assert.strictEqual(resolved, '../../../bar/main.js.map');
6245 });
6246
6247 it('resolves relative to parent multiple directory with query 1', () => {
6248 const base = 'deep/../';
6249 const input = '../../../?input';
6250 const resolved = resolve(input, base);
6251 assert.strictEqual(resolved, '../../..?input');
6252 });
6253
6254 it('resolves relative to parent multiple directory with query 2', () => {
6255 const base = 'deep/../';
6256 const input = '../../..?input';
6257 const resolved = resolve(input, base);
6258 assert.strictEqual(resolved, '../../..?input');
6259 });
6260
6261 it('normalizes input path', () => {
6262 const base = 'deep/../';
6263 const input = './foo/./bar/../main.js.map';
6264 const resolved = resolve(input, base);
6265 assert.strictEqual(resolved, 'foo/main.js.map');
6266 });
6267 });
6268
6269 describe('with relative path input', () => {
6270 it('resolves relative to current directory', () => {
6271 const base = 'deep/../';
6272 const input = 'bar/main.js.map';
6273 const resolved = resolve(input, base);
6274 assert.strictEqual(resolved, 'bar/main.js.map');
6275 });
6276
6277 it('resolves relative to current directory with query', () => {
6278 const base = 'deep/../';
6279 const input = 'bar/main.js.map?input';
6280 const resolved = resolve(input, base);
6281 assert.strictEqual(resolved, 'bar/main.js.map?input');
6282 });
6283
6284 it('resolves relative to parent multiple directory, later', () => {
6285 const base = 'deep/../';
6286 const input = 'foo/../../../bar/main.js.map';
6287 const resolved = resolve(input, base);
6288 assert.strictEqual(resolved, '../../bar/main.js.map');
6289 });
6290
6291 it('normalizes input path', () => {
6292 const base = 'deep/../';
6293 const input = 'foo/./bar/../main.js.map';
6294 const resolved = resolve(input, base);
6295 assert.strictEqual(resolved, 'foo/main.js.map');
6296 });
6297
6298 it('resolves node_module scope as path', () => {
6299 const base = 'deep/../';
6300 const input = 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js';
6301 const resolved = resolve(input, base);
6302 assert.strictEqual(resolved, 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js');
6303 });
6304
6305 it('resolves package scope as path', () => {
6306 const base = 'deep/../';
6307 const input = '@babel/runtime/helpers/esm/arrayLikeToArray.js';
6308 const resolved = resolve(input, base);
6309 assert.strictEqual(resolved, '@babel/runtime/helpers/esm/arrayLikeToArray.js');
6310 });
6311 });
6312
6313 describe('with query input', () => {
6314 it('resolves relative to path', () => {
6315 const base = 'deep/../';
6316 const input = '?input';
6317 const resolved = resolve(input, base);
6318 assert.strictEqual(resolved, '?input');
6319 });
6320 });
6321
6322 describe('with hash input', () => {
6323 it('resolves relative to path', () => {
6324 const base = 'deep/../';
6325 const input = '#input';
6326 const resolved = resolve(input, base);
6327 assert.strictEqual(resolved, '#input');
6328 });
6329 });
6330
6331 describe('empty input', () => {
6332 it('normalizes base', () => {
6333 const base = 'deep/../';
6334 const input = '';
6335 const resolved = resolve(input, base);
6336 assert.strictEqual(resolved, '.');
6337 });
6338 });
6339 });
6340
6341 describe(`base = "./.."`, () => {
6342 describe('with absolute input', () => {
6343 it('returns input', () => {
6344 const base = './..';
6345 const input = 'https://absolute.com/main.js.map';
6346 const resolved = resolve(input, base);
6347 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
6348 });
6349
6350 it('returns input with query', () => {
6351 const base = './..';
6352 const input = 'https://absolute.com/main.js.map?input';
6353 const resolved = resolve(input, base);
6354 assert.strictEqual(resolved, 'https://absolute.com/main.js.map?input');
6355 });
6356
6357 it('normalizes input path', () => {
6358 const base = './..';
6359 const input = 'https://absolute.com/foo/./bar/../main.js.map';
6360 const resolved = resolve(input, base);
6361 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map');
6362 });
6363
6364 it('normalizes input path with query', () => {
6365 const base = './..';
6366 const input = 'https://absolute.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
6367 const resolved = resolve(input, base);
6368 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map?input!webpack://foo/./bar');
6369 });
6370
6371 it('normalizes pathless input', () => {
6372 const base = './..';
6373 const input = 'https://absolute.com';
6374 const resolved = resolve(input, base);
6375 assert.strictEqual(resolved, 'https://absolute.com/');
6376 });
6377
6378 it('normalizes pathless input with query', () => {
6379 const base = './..';
6380 const input = 'https://absolute.com?input';
6381 const resolved = resolve(input, base);
6382 assert.strictEqual(resolved, 'https://absolute.com/?input');
6383 });
6384
6385 it('normalizes current directory', () => {
6386 const base = './..';
6387 const input = 'https://absolute.com/./main.js.map';
6388 const resolved = resolve(input, base);
6389 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
6390 });
6391
6392 it('normalizes too many parent accessors', () => {
6393 const base = './..';
6394 const input = 'https://absolute.com/../../../main.js.map';
6395 const resolved = resolve(input, base);
6396 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
6397 });
6398
6399 it('normalizes too many parent accessors, late', () => {
6400 const base = './..';
6401 const input = 'https://absolute.com/foo/../../../main.js.map';
6402 const resolved = resolve(input, base);
6403 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
6404 });
6405
6406 it('normalizes file protocol 1', () => {
6407 const base = './..';
6408 const input = 'file:///root/main.js.map';
6409 const resolved = resolve(input, base);
6410 assert.strictEqual(resolved, 'file:///root/main.js.map');
6411 });
6412
6413 it('normalizes file protocol 2', () => {
6414 const base = './..';
6415 const input = 'file://root/main.js.map';
6416 const resolved = resolve(input, base);
6417 assert.strictEqual(resolved, 'file://root/main.js.map');
6418 });
6419
6420 it('normalizes file protocol 2.5', () => {
6421 const base = './..';
6422 const input = 'file://root';
6423 const resolved = resolve(input, base);
6424 assert.strictEqual(resolved, 'file://root/');
6425 });
6426
6427 it('normalizes file protocol 3', () => {
6428 const base = './..';
6429 const input = 'file:/root/main.js.map';
6430 const resolved = resolve(input, base);
6431 assert.strictEqual(resolved, 'file:///root/main.js.map');
6432 });
6433
6434 it('normalizes file protocol 4', () => {
6435 const base = './..';
6436 const input = 'file:root/main.js.map';
6437 const resolved = resolve(input, base);
6438 assert.strictEqual(resolved, 'file:///root/main.js.map');
6439 });
6440
6441 it('normalizes file protocol 1 with query', () => {
6442 const base = './..';
6443 const input = 'file:///root/main.js.map?input';
6444 const resolved = resolve(input, base);
6445 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
6446 });
6447
6448 it('normalizes file protocol 2 with query', () => {
6449 const base = './..';
6450 const input = 'file://root/main.js.map?input';
6451 const resolved = resolve(input, base);
6452 assert.strictEqual(resolved, 'file://root/main.js.map?input');
6453 });
6454
6455 it('normalizes file protocol 2.5 with query', () => {
6456 const base = './..';
6457 const input = 'file://root?input';
6458 const resolved = resolve(input, base);
6459 assert.strictEqual(resolved, 'file://root/?input');
6460 });
6461
6462 it('normalizes file protocol 3 with query', () => {
6463 const base = './..';
6464 const input = 'file:/root/main.js.map?input';
6465 const resolved = resolve(input, base);
6466 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
6467 });
6468
6469 it('normalizes file protocol 4 with query', () => {
6470 const base = './..';
6471 const input = 'file:root/main.js.map?input';
6472 const resolved = resolve(input, base);
6473 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
6474 });
6475 });
6476
6477 describe('with protocol relative input', () => {
6478 it('resolves relative to the base protocol', () => {
6479 const base = './..';
6480 const input = '//protocol-relative.com/main.js.map';
6481 const resolved = resolve(input, base);
6482 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
6483 });
6484
6485 it('resolves relative to the base protocol with query', () => {
6486 const base = './..';
6487 const input = '//protocol-relative.com/main.js.map?input';
6488 const resolved = resolve(input, base);
6489 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map?input');
6490 });
6491
6492 it('normalizes input path', () => {
6493 const base = './..';
6494 const input = '//protocol-relative.com/foo/./bar/../main.js.map';
6495 const resolved = resolve(input, base);
6496 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map');
6497 });
6498
6499 it('normalizes input path with query', () => {
6500 const base = './..';
6501 const input = '//protocol-relative.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
6502 const resolved = resolve(input, base);
6503 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map?input!webpack://foo/./bar');
6504 });
6505
6506 it('normalizes pathless input', () => {
6507 const base = './..';
6508 const input = '//protocol-relative.com';
6509 const resolved = resolve(input, base);
6510 assert.strictEqual(resolved, '//protocol-relative.com/');
6511 });
6512
6513 it('normalizes pathless input with query', () => {
6514 const base = './..';
6515 const input = '//protocol-relative.com?input';
6516 const resolved = resolve(input, base);
6517 assert.strictEqual(resolved, '//protocol-relative.com/?input');
6518 });
6519
6520 it('normalizes current directory', () => {
6521 const base = './..';
6522 const input = '//protocol-relative.com/./main.js.map';
6523 const resolved = resolve(input, base);
6524 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
6525 });
6526
6527 it('normalizes too many parent accessors', () => {
6528 const base = './..';
6529 const input = '//protocol-relative.com/../main.js.map';
6530 const resolved = resolve(input, base);
6531 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
6532 });
6533
6534 it('normalizes too many parent accessors, late', () => {
6535 const base = './..';
6536 const input = '//protocol-relative.com/foo/../../main.js.map';
6537 const resolved = resolve(input, base);
6538 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
6539 });
6540 });
6541
6542 describe('with absolute path input', () => {
6543 it('remains absolute path', () => {
6544 const base = './..';
6545 const input = '/assets/main.js.map';
6546 const resolved = resolve(input, base);
6547 assert.strictEqual(resolved, '/assets/main.js.map');
6548 });
6549
6550 it('remains absolute path with query', () => {
6551 const base = './..';
6552 const input = '/assets/main.js.map?input';
6553 const resolved = resolve(input, base);
6554 assert.strictEqual(resolved, '/assets/main.js.map?input');
6555 });
6556
6557 it('trims to root', () => {
6558 const base = './..';
6559 const input = '/';
6560 const resolved = resolve(input, base);
6561 assert.strictEqual(resolved, '/');
6562 });
6563
6564 it('normalizes input path', () => {
6565 const base = './..';
6566 const input = '/foo/./bar/../main.js.map';
6567 const resolved = resolve(input, base);
6568 assert.strictEqual(resolved, '/foo/main.js.map');
6569 });
6570
6571 it('normalizes current directory', () => {
6572 const base = './..';
6573 const input = '/./main.js.map';
6574 const resolved = resolve(input, base);
6575 assert.strictEqual(resolved, '/main.js.map');
6576 });
6577
6578 it('normalizes too many parent accessors', () => {
6579 const base = './..';
6580 const input = '/../../../main.js.map';
6581 const resolved = resolve(input, base);
6582 assert.strictEqual(resolved, '/main.js.map');
6583 });
6584
6585 it('normalizes too many parent accessors with query 1', () => {
6586 const base = './..';
6587 const input = '/../../../?input';
6588 const resolved = resolve(input, base);
6589 assert.strictEqual(resolved, '/?input');
6590 });
6591
6592 it('normalizes too many parent accessors with query 2', () => {
6593 const base = './..';
6594 const input = '/../../..?input';
6595 const resolved = resolve(input, base);
6596 assert.strictEqual(resolved, '/?input');
6597 });
6598
6599 it('normalizes too many parent accessors, late', () => {
6600 const base = './..';
6601 const input = '/foo/../../../main.js.map';
6602 const resolved = resolve(input, base);
6603 assert.strictEqual(resolved, '/main.js.map');
6604 });
6605 });
6606
6607 describe('with leading dot relative input', () => {
6608 it('resolves relative to current directory', () => {
6609 const base = './..';
6610 const input = './bar/main.js.map';
6611 const resolved = resolve(input, base);
6612 assert.strictEqual(resolved, '../bar/main.js.map');
6613 });
6614
6615 it('resolves relative to current directory with query', () => {
6616 const base = './..';
6617 const input = './bar/main.js.map?input';
6618 const resolved = resolve(input, base);
6619 assert.strictEqual(resolved, '../bar/main.js.map?input');
6620 });
6621
6622 it('resolves relative to parent directory', () => {
6623 const base = './..';
6624 const input = '../bar/main.js.map';
6625 const resolved = resolve(input, base);
6626 assert.strictEqual(resolved, '../../bar/main.js.map');
6627 });
6628
6629 it('resolves relative to parent directory with query', () => {
6630 const base = './..';
6631 const input = '../bar/main.js.map?input';
6632 const resolved = resolve(input, base);
6633 assert.strictEqual(resolved, '../../bar/main.js.map?input');
6634 });
6635
6636 it('resolves relative to parent multiple directory', () => {
6637 const base = './..';
6638 const input = '../../../bar/main.js.map';
6639 const resolved = resolve(input, base);
6640 assert.strictEqual(resolved, '../../../../bar/main.js.map');
6641 });
6642
6643 it('resolves relative to parent multiple directory with query 1', () => {
6644 const base = './..';
6645 const input = '../../../?input';
6646 const resolved = resolve(input, base);
6647 assert.strictEqual(resolved, '../../../..?input');
6648 });
6649
6650 it('resolves relative to parent multiple directory with query 2', () => {
6651 const base = './..';
6652 const input = '../../..?input';
6653 const resolved = resolve(input, base);
6654 assert.strictEqual(resolved, '../../../..?input');
6655 });
6656
6657 it('normalizes input path', () => {
6658 const base = './..';
6659 const input = './foo/./bar/../main.js.map';
6660 const resolved = resolve(input, base);
6661 assert.strictEqual(resolved, '../foo/main.js.map');
6662 });
6663 });
6664
6665 describe('with relative path input', () => {
6666 it('resolves relative to current directory', () => {
6667 const base = './..';
6668 const input = 'bar/main.js.map';
6669 const resolved = resolve(input, base);
6670 assert.strictEqual(resolved, '../bar/main.js.map');
6671 });
6672
6673 it('resolves relative to current directory with query', () => {
6674 const base = './..';
6675 const input = 'bar/main.js.map?input';
6676 const resolved = resolve(input, base);
6677 assert.strictEqual(resolved, '../bar/main.js.map?input');
6678 });
6679
6680 it('resolves relative to parent multiple directory, later', () => {
6681 const base = './..';
6682 const input = 'foo/../../../bar/main.js.map';
6683 const resolved = resolve(input, base);
6684 assert.strictEqual(resolved, '../../../bar/main.js.map');
6685 });
6686
6687 it('normalizes input path', () => {
6688 const base = './..';
6689 const input = 'foo/./bar/../main.js.map';
6690 const resolved = resolve(input, base);
6691 assert.strictEqual(resolved, '../foo/main.js.map');
6692 });
6693
6694 it('resolves node_module scope as path', () => {
6695 const base = './..';
6696 const input = 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js';
6697 const resolved = resolve(input, base);
6698 assert.strictEqual(resolved, '../node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js');
6699 });
6700
6701 it('resolves package scope as path', () => {
6702 const base = './..';
6703 const input = '@babel/runtime/helpers/esm/arrayLikeToArray.js';
6704 const resolved = resolve(input, base);
6705 assert.strictEqual(resolved, '../@babel/runtime/helpers/esm/arrayLikeToArray.js');
6706 });
6707 });
6708
6709 describe('with query input', () => {
6710 it('resolves relative to path', () => {
6711 const base = './..';
6712 const input = '?input';
6713 const resolved = resolve(input, base);
6714 assert.strictEqual(resolved, '..?input');
6715 });
6716 });
6717
6718 describe('with hash input', () => {
6719 it('resolves relative to path', () => {
6720 const base = './..';
6721 const input = '#input';
6722 const resolved = resolve(input, base);
6723 assert.strictEqual(resolved, '..#input');
6724 });
6725 });
6726
6727 describe('empty input', () => {
6728 it('normalizes base', () => {
6729 const base = './..';
6730 const input = '';
6731 const resolved = resolve(input, base);
6732 assert.strictEqual(resolved, '..');
6733 });
6734 });
6735 });
6736
6737 describe(`base = "./../"`, () => {
6738 describe('with absolute input', () => {
6739 it('returns input', () => {
6740 const base = './../';
6741 const input = 'https://absolute.com/main.js.map';
6742 const resolved = resolve(input, base);
6743 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
6744 });
6745
6746 it('returns input with query', () => {
6747 const base = './../';
6748 const input = 'https://absolute.com/main.js.map?input';
6749 const resolved = resolve(input, base);
6750 assert.strictEqual(resolved, 'https://absolute.com/main.js.map?input');
6751 });
6752
6753 it('normalizes input path', () => {
6754 const base = './../';
6755 const input = 'https://absolute.com/foo/./bar/../main.js.map';
6756 const resolved = resolve(input, base);
6757 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map');
6758 });
6759
6760 it('normalizes input path with query', () => {
6761 const base = './../';
6762 const input = 'https://absolute.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
6763 const resolved = resolve(input, base);
6764 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map?input!webpack://foo/./bar');
6765 });
6766
6767 it('normalizes pathless input', () => {
6768 const base = './../';
6769 const input = 'https://absolute.com';
6770 const resolved = resolve(input, base);
6771 assert.strictEqual(resolved, 'https://absolute.com/');
6772 });
6773
6774 it('normalizes pathless input with query', () => {
6775 const base = './../';
6776 const input = 'https://absolute.com?input';
6777 const resolved = resolve(input, base);
6778 assert.strictEqual(resolved, 'https://absolute.com/?input');
6779 });
6780
6781 it('normalizes current directory', () => {
6782 const base = './../';
6783 const input = 'https://absolute.com/./main.js.map';
6784 const resolved = resolve(input, base);
6785 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
6786 });
6787
6788 it('normalizes too many parent accessors', () => {
6789 const base = './../';
6790 const input = 'https://absolute.com/../../../main.js.map';
6791 const resolved = resolve(input, base);
6792 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
6793 });
6794
6795 it('normalizes too many parent accessors, late', () => {
6796 const base = './../';
6797 const input = 'https://absolute.com/foo/../../../main.js.map';
6798 const resolved = resolve(input, base);
6799 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
6800 });
6801
6802 it('normalizes file protocol 1', () => {
6803 const base = './../';
6804 const input = 'file:///root/main.js.map';
6805 const resolved = resolve(input, base);
6806 assert.strictEqual(resolved, 'file:///root/main.js.map');
6807 });
6808
6809 it('normalizes file protocol 2', () => {
6810 const base = './../';
6811 const input = 'file://root/main.js.map';
6812 const resolved = resolve(input, base);
6813 assert.strictEqual(resolved, 'file://root/main.js.map');
6814 });
6815
6816 it('normalizes file protocol 2.5', () => {
6817 const base = './../';
6818 const input = 'file://root';
6819 const resolved = resolve(input, base);
6820 assert.strictEqual(resolved, 'file://root/');
6821 });
6822
6823 it('normalizes file protocol 3', () => {
6824 const base = './../';
6825 const input = 'file:/root/main.js.map';
6826 const resolved = resolve(input, base);
6827 assert.strictEqual(resolved, 'file:///root/main.js.map');
6828 });
6829
6830 it('normalizes file protocol 4', () => {
6831 const base = './../';
6832 const input = 'file:root/main.js.map';
6833 const resolved = resolve(input, base);
6834 assert.strictEqual(resolved, 'file:///root/main.js.map');
6835 });
6836
6837 it('normalizes file protocol 1 with query', () => {
6838 const base = './../';
6839 const input = 'file:///root/main.js.map?input';
6840 const resolved = resolve(input, base);
6841 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
6842 });
6843
6844 it('normalizes file protocol 2 with query', () => {
6845 const base = './../';
6846 const input = 'file://root/main.js.map?input';
6847 const resolved = resolve(input, base);
6848 assert.strictEqual(resolved, 'file://root/main.js.map?input');
6849 });
6850
6851 it('normalizes file protocol 2.5 with query', () => {
6852 const base = './../';
6853 const input = 'file://root?input';
6854 const resolved = resolve(input, base);
6855 assert.strictEqual(resolved, 'file://root/?input');
6856 });
6857
6858 it('normalizes file protocol 3 with query', () => {
6859 const base = './../';
6860 const input = 'file:/root/main.js.map?input';
6861 const resolved = resolve(input, base);
6862 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
6863 });
6864
6865 it('normalizes file protocol 4 with query', () => {
6866 const base = './../';
6867 const input = 'file:root/main.js.map?input';
6868 const resolved = resolve(input, base);
6869 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
6870 });
6871 });
6872
6873 describe('with protocol relative input', () => {
6874 it('resolves relative to the base protocol', () => {
6875 const base = './../';
6876 const input = '//protocol-relative.com/main.js.map';
6877 const resolved = resolve(input, base);
6878 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
6879 });
6880
6881 it('resolves relative to the base protocol with query', () => {
6882 const base = './../';
6883 const input = '//protocol-relative.com/main.js.map?input';
6884 const resolved = resolve(input, base);
6885 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map?input');
6886 });
6887
6888 it('normalizes input path', () => {
6889 const base = './../';
6890 const input = '//protocol-relative.com/foo/./bar/../main.js.map';
6891 const resolved = resolve(input, base);
6892 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map');
6893 });
6894
6895 it('normalizes input path with query', () => {
6896 const base = './../';
6897 const input = '//protocol-relative.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
6898 const resolved = resolve(input, base);
6899 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map?input!webpack://foo/./bar');
6900 });
6901
6902 it('normalizes pathless input', () => {
6903 const base = './../';
6904 const input = '//protocol-relative.com';
6905 const resolved = resolve(input, base);
6906 assert.strictEqual(resolved, '//protocol-relative.com/');
6907 });
6908
6909 it('normalizes pathless input with query', () => {
6910 const base = './../';
6911 const input = '//protocol-relative.com?input';
6912 const resolved = resolve(input, base);
6913 assert.strictEqual(resolved, '//protocol-relative.com/?input');
6914 });
6915
6916 it('normalizes current directory', () => {
6917 const base = './../';
6918 const input = '//protocol-relative.com/./main.js.map';
6919 const resolved = resolve(input, base);
6920 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
6921 });
6922
6923 it('normalizes too many parent accessors', () => {
6924 const base = './../';
6925 const input = '//protocol-relative.com/../main.js.map';
6926 const resolved = resolve(input, base);
6927 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
6928 });
6929
6930 it('normalizes too many parent accessors, late', () => {
6931 const base = './../';
6932 const input = '//protocol-relative.com/foo/../../main.js.map';
6933 const resolved = resolve(input, base);
6934 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
6935 });
6936 });
6937
6938 describe('with absolute path input', () => {
6939 it('remains absolute path', () => {
6940 const base = './../';
6941 const input = '/assets/main.js.map';
6942 const resolved = resolve(input, base);
6943 assert.strictEqual(resolved, '/assets/main.js.map');
6944 });
6945
6946 it('remains absolute path with query', () => {
6947 const base = './../';
6948 const input = '/assets/main.js.map?input';
6949 const resolved = resolve(input, base);
6950 assert.strictEqual(resolved, '/assets/main.js.map?input');
6951 });
6952
6953 it('trims to root', () => {
6954 const base = './../';
6955 const input = '/';
6956 const resolved = resolve(input, base);
6957 assert.strictEqual(resolved, '/');
6958 });
6959
6960 it('normalizes input path', () => {
6961 const base = './../';
6962 const input = '/foo/./bar/../main.js.map';
6963 const resolved = resolve(input, base);
6964 assert.strictEqual(resolved, '/foo/main.js.map');
6965 });
6966
6967 it('normalizes current directory', () => {
6968 const base = './../';
6969 const input = '/./main.js.map';
6970 const resolved = resolve(input, base);
6971 assert.strictEqual(resolved, '/main.js.map');
6972 });
6973
6974 it('normalizes too many parent accessors', () => {
6975 const base = './../';
6976 const input = '/../../../main.js.map';
6977 const resolved = resolve(input, base);
6978 assert.strictEqual(resolved, '/main.js.map');
6979 });
6980
6981 it('normalizes too many parent accessors with query 1', () => {
6982 const base = './../';
6983 const input = '/../../../?input';
6984 const resolved = resolve(input, base);
6985 assert.strictEqual(resolved, '/?input');
6986 });
6987
6988 it('normalizes too many parent accessors with query 2', () => {
6989 const base = './../';
6990 const input = '/../../..?input';
6991 const resolved = resolve(input, base);
6992 assert.strictEqual(resolved, '/?input');
6993 });
6994
6995 it('normalizes too many parent accessors, late', () => {
6996 const base = './../';
6997 const input = '/foo/../../../main.js.map';
6998 const resolved = resolve(input, base);
6999 assert.strictEqual(resolved, '/main.js.map');
7000 });
7001 });
7002
7003 describe('with leading dot relative input', () => {
7004 it('resolves relative to current directory', () => {
7005 const base = './../';
7006 const input = './bar/main.js.map';
7007 const resolved = resolve(input, base);
7008 assert.strictEqual(resolved, '../bar/main.js.map');
7009 });
7010
7011 it('resolves relative to current directory with query', () => {
7012 const base = './../';
7013 const input = './bar/main.js.map?input';
7014 const resolved = resolve(input, base);
7015 assert.strictEqual(resolved, '../bar/main.js.map?input');
7016 });
7017
7018 it('resolves relative to parent directory', () => {
7019 const base = './../';
7020 const input = '../bar/main.js.map';
7021 const resolved = resolve(input, base);
7022 assert.strictEqual(resolved, '../../bar/main.js.map');
7023 });
7024
7025 it('resolves relative to parent directory with query', () => {
7026 const base = './../';
7027 const input = '../bar/main.js.map?input';
7028 const resolved = resolve(input, base);
7029 assert.strictEqual(resolved, '../../bar/main.js.map?input');
7030 });
7031
7032 it('resolves relative to parent multiple directory', () => {
7033 const base = './../';
7034 const input = '../../../bar/main.js.map';
7035 const resolved = resolve(input, base);
7036 assert.strictEqual(resolved, '../../../../bar/main.js.map');
7037 });
7038
7039 it('resolves relative to parent multiple directory with query 1', () => {
7040 const base = './../';
7041 const input = '../../../?input';
7042 const resolved = resolve(input, base);
7043 assert.strictEqual(resolved, '../../../..?input');
7044 });
7045
7046 it('resolves relative to parent multiple directory with query 2', () => {
7047 const base = './../';
7048 const input = '../../..?input';
7049 const resolved = resolve(input, base);
7050 assert.strictEqual(resolved, '../../../..?input');
7051 });
7052
7053 it('normalizes input path', () => {
7054 const base = './../';
7055 const input = './foo/./bar/../main.js.map';
7056 const resolved = resolve(input, base);
7057 assert.strictEqual(resolved, '../foo/main.js.map');
7058 });
7059 });
7060
7061 describe('with relative path input', () => {
7062 it('resolves relative to current directory', () => {
7063 const base = './../';
7064 const input = 'bar/main.js.map';
7065 const resolved = resolve(input, base);
7066 assert.strictEqual(resolved, '../bar/main.js.map');
7067 });
7068
7069 it('resolves relative to current directory with query', () => {
7070 const base = './../';
7071 const input = 'bar/main.js.map?input';
7072 const resolved = resolve(input, base);
7073 assert.strictEqual(resolved, '../bar/main.js.map?input');
7074 });
7075
7076 it('resolves relative to parent multiple directory, later', () => {
7077 const base = './../';
7078 const input = 'foo/../../../bar/main.js.map';
7079 const resolved = resolve(input, base);
7080 assert.strictEqual(resolved, '../../../bar/main.js.map');
7081 });
7082
7083 it('normalizes input path', () => {
7084 const base = './../';
7085 const input = 'foo/./bar/../main.js.map';
7086 const resolved = resolve(input, base);
7087 assert.strictEqual(resolved, '../foo/main.js.map');
7088 });
7089
7090 it('resolves node_module scope as path', () => {
7091 const base = './../';
7092 const input = 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js';
7093 const resolved = resolve(input, base);
7094 assert.strictEqual(resolved, '../node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js');
7095 });
7096
7097 it('resolves package scope as path', () => {
7098 const base = './../';
7099 const input = '@babel/runtime/helpers/esm/arrayLikeToArray.js';
7100 const resolved = resolve(input, base);
7101 assert.strictEqual(resolved, '../@babel/runtime/helpers/esm/arrayLikeToArray.js');
7102 });
7103 });
7104
7105 describe('with query input', () => {
7106 it('resolves relative to path', () => {
7107 const base = './../';
7108 const input = '?input';
7109 const resolved = resolve(input, base);
7110 assert.strictEqual(resolved, '..?input');
7111 });
7112 });
7113
7114 describe('with hash input', () => {
7115 it('resolves relative to path', () => {
7116 const base = './../';
7117 const input = '#input';
7118 const resolved = resolve(input, base);
7119 assert.strictEqual(resolved, '..#input');
7120 });
7121 });
7122
7123 describe('empty input', () => {
7124 it('normalizes base', () => {
7125 const base = './../';
7126 const input = '';
7127 const resolved = resolve(input, base);
7128 assert.strictEqual(resolved, '..');
7129 });
7130 });
7131 });
7132
7133 describe(`base = "./deep/.."`, () => {
7134 describe('with absolute input', () => {
7135 it('returns input', () => {
7136 const base = './deep/..';
7137 const input = 'https://absolute.com/main.js.map';
7138 const resolved = resolve(input, base);
7139 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
7140 });
7141
7142 it('returns input with query', () => {
7143 const base = './deep/..';
7144 const input = 'https://absolute.com/main.js.map?input';
7145 const resolved = resolve(input, base);
7146 assert.strictEqual(resolved, 'https://absolute.com/main.js.map?input');
7147 });
7148
7149 it('normalizes input path', () => {
7150 const base = './deep/..';
7151 const input = 'https://absolute.com/foo/./bar/../main.js.map';
7152 const resolved = resolve(input, base);
7153 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map');
7154 });
7155
7156 it('normalizes input path with query', () => {
7157 const base = './deep/..';
7158 const input = 'https://absolute.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
7159 const resolved = resolve(input, base);
7160 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map?input!webpack://foo/./bar');
7161 });
7162
7163 it('normalizes pathless input', () => {
7164 const base = './deep/..';
7165 const input = 'https://absolute.com';
7166 const resolved = resolve(input, base);
7167 assert.strictEqual(resolved, 'https://absolute.com/');
7168 });
7169
7170 it('normalizes pathless input with query', () => {
7171 const base = './deep/..';
7172 const input = 'https://absolute.com?input';
7173 const resolved = resolve(input, base);
7174 assert.strictEqual(resolved, 'https://absolute.com/?input');
7175 });
7176
7177 it('normalizes current directory', () => {
7178 const base = './deep/..';
7179 const input = 'https://absolute.com/./main.js.map';
7180 const resolved = resolve(input, base);
7181 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
7182 });
7183
7184 it('normalizes too many parent accessors', () => {
7185 const base = './deep/..';
7186 const input = 'https://absolute.com/../../../main.js.map';
7187 const resolved = resolve(input, base);
7188 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
7189 });
7190
7191 it('normalizes too many parent accessors, late', () => {
7192 const base = './deep/..';
7193 const input = 'https://absolute.com/foo/../../../main.js.map';
7194 const resolved = resolve(input, base);
7195 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
7196 });
7197
7198 it('normalizes file protocol 1', () => {
7199 const base = './deep/..';
7200 const input = 'file:///root/main.js.map';
7201 const resolved = resolve(input, base);
7202 assert.strictEqual(resolved, 'file:///root/main.js.map');
7203 });
7204
7205 it('normalizes file protocol 2', () => {
7206 const base = './deep/..';
7207 const input = 'file://root/main.js.map';
7208 const resolved = resolve(input, base);
7209 assert.strictEqual(resolved, 'file://root/main.js.map');
7210 });
7211
7212 it('normalizes file protocol 2.5', () => {
7213 const base = './deep/..';
7214 const input = 'file://root';
7215 const resolved = resolve(input, base);
7216 assert.strictEqual(resolved, 'file://root/');
7217 });
7218
7219 it('normalizes file protocol 3', () => {
7220 const base = './deep/..';
7221 const input = 'file:/root/main.js.map';
7222 const resolved = resolve(input, base);
7223 assert.strictEqual(resolved, 'file:///root/main.js.map');
7224 });
7225
7226 it('normalizes file protocol 4', () => {
7227 const base = './deep/..';
7228 const input = 'file:root/main.js.map';
7229 const resolved = resolve(input, base);
7230 assert.strictEqual(resolved, 'file:///root/main.js.map');
7231 });
7232
7233 it('normalizes file protocol 1 with query', () => {
7234 const base = './deep/..';
7235 const input = 'file:///root/main.js.map?input';
7236 const resolved = resolve(input, base);
7237 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
7238 });
7239
7240 it('normalizes file protocol 2 with query', () => {
7241 const base = './deep/..';
7242 const input = 'file://root/main.js.map?input';
7243 const resolved = resolve(input, base);
7244 assert.strictEqual(resolved, 'file://root/main.js.map?input');
7245 });
7246
7247 it('normalizes file protocol 2.5 with query', () => {
7248 const base = './deep/..';
7249 const input = 'file://root?input';
7250 const resolved = resolve(input, base);
7251 assert.strictEqual(resolved, 'file://root/?input');
7252 });
7253
7254 it('normalizes file protocol 3 with query', () => {
7255 const base = './deep/..';
7256 const input = 'file:/root/main.js.map?input';
7257 const resolved = resolve(input, base);
7258 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
7259 });
7260
7261 it('normalizes file protocol 4 with query', () => {
7262 const base = './deep/..';
7263 const input = 'file:root/main.js.map?input';
7264 const resolved = resolve(input, base);
7265 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
7266 });
7267 });
7268
7269 describe('with protocol relative input', () => {
7270 it('resolves relative to the base protocol', () => {
7271 const base = './deep/..';
7272 const input = '//protocol-relative.com/main.js.map';
7273 const resolved = resolve(input, base);
7274 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
7275 });
7276
7277 it('resolves relative to the base protocol with query', () => {
7278 const base = './deep/..';
7279 const input = '//protocol-relative.com/main.js.map?input';
7280 const resolved = resolve(input, base);
7281 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map?input');
7282 });
7283
7284 it('normalizes input path', () => {
7285 const base = './deep/..';
7286 const input = '//protocol-relative.com/foo/./bar/../main.js.map';
7287 const resolved = resolve(input, base);
7288 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map');
7289 });
7290
7291 it('normalizes input path with query', () => {
7292 const base = './deep/..';
7293 const input = '//protocol-relative.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
7294 const resolved = resolve(input, base);
7295 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map?input!webpack://foo/./bar');
7296 });
7297
7298 it('normalizes pathless input', () => {
7299 const base = './deep/..';
7300 const input = '//protocol-relative.com';
7301 const resolved = resolve(input, base);
7302 assert.strictEqual(resolved, '//protocol-relative.com/');
7303 });
7304
7305 it('normalizes pathless input with query', () => {
7306 const base = './deep/..';
7307 const input = '//protocol-relative.com?input';
7308 const resolved = resolve(input, base);
7309 assert.strictEqual(resolved, '//protocol-relative.com/?input');
7310 });
7311
7312 it('normalizes current directory', () => {
7313 const base = './deep/..';
7314 const input = '//protocol-relative.com/./main.js.map';
7315 const resolved = resolve(input, base);
7316 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
7317 });
7318
7319 it('normalizes too many parent accessors', () => {
7320 const base = './deep/..';
7321 const input = '//protocol-relative.com/../main.js.map';
7322 const resolved = resolve(input, base);
7323 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
7324 });
7325
7326 it('normalizes too many parent accessors, late', () => {
7327 const base = './deep/..';
7328 const input = '//protocol-relative.com/foo/../../main.js.map';
7329 const resolved = resolve(input, base);
7330 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
7331 });
7332 });
7333
7334 describe('with absolute path input', () => {
7335 it('remains absolute path', () => {
7336 const base = './deep/..';
7337 const input = '/assets/main.js.map';
7338 const resolved = resolve(input, base);
7339 assert.strictEqual(resolved, '/assets/main.js.map');
7340 });
7341
7342 it('remains absolute path with query', () => {
7343 const base = './deep/..';
7344 const input = '/assets/main.js.map?input';
7345 const resolved = resolve(input, base);
7346 assert.strictEqual(resolved, '/assets/main.js.map?input');
7347 });
7348
7349 it('trims to root', () => {
7350 const base = './deep/..';
7351 const input = '/';
7352 const resolved = resolve(input, base);
7353 assert.strictEqual(resolved, '/');
7354 });
7355
7356 it('normalizes input path', () => {
7357 const base = './deep/..';
7358 const input = '/foo/./bar/../main.js.map';
7359 const resolved = resolve(input, base);
7360 assert.strictEqual(resolved, '/foo/main.js.map');
7361 });
7362
7363 it('normalizes current directory', () => {
7364 const base = './deep/..';
7365 const input = '/./main.js.map';
7366 const resolved = resolve(input, base);
7367 assert.strictEqual(resolved, '/main.js.map');
7368 });
7369
7370 it('normalizes too many parent accessors', () => {
7371 const base = './deep/..';
7372 const input = '/../../../main.js.map';
7373 const resolved = resolve(input, base);
7374 assert.strictEqual(resolved, '/main.js.map');
7375 });
7376
7377 it('normalizes too many parent accessors with query 1', () => {
7378 const base = './deep/..';
7379 const input = '/../../../?input';
7380 const resolved = resolve(input, base);
7381 assert.strictEqual(resolved, '/?input');
7382 });
7383
7384 it('normalizes too many parent accessors with query 2', () => {
7385 const base = './deep/..';
7386 const input = '/../../..?input';
7387 const resolved = resolve(input, base);
7388 assert.strictEqual(resolved, '/?input');
7389 });
7390
7391 it('normalizes too many parent accessors, late', () => {
7392 const base = './deep/..';
7393 const input = '/foo/../../../main.js.map';
7394 const resolved = resolve(input, base);
7395 assert.strictEqual(resolved, '/main.js.map');
7396 });
7397 });
7398
7399 describe('with leading dot relative input', () => {
7400 it('resolves relative to current directory', () => {
7401 const base = './deep/..';
7402 const input = './bar/main.js.map';
7403 const resolved = resolve(input, base);
7404 assert.strictEqual(resolved, './bar/main.js.map');
7405 });
7406
7407 it('resolves relative to current directory with query', () => {
7408 const base = './deep/..';
7409 const input = './bar/main.js.map?input';
7410 const resolved = resolve(input, base);
7411 assert.strictEqual(resolved, './bar/main.js.map?input');
7412 });
7413
7414 it('resolves relative to parent directory', () => {
7415 const base = './deep/..';
7416 const input = '../bar/main.js.map';
7417 const resolved = resolve(input, base);
7418 assert.strictEqual(resolved, '../bar/main.js.map');
7419 });
7420
7421 it('resolves relative to parent directory with query', () => {
7422 const base = './deep/..';
7423 const input = '../bar/main.js.map?input';
7424 const resolved = resolve(input, base);
7425 assert.strictEqual(resolved, '../bar/main.js.map?input');
7426 });
7427
7428 it('resolves relative to parent multiple directory', () => {
7429 const base = './deep/..';
7430 const input = '../../../bar/main.js.map';
7431 const resolved = resolve(input, base);
7432 assert.strictEqual(resolved, '../../../bar/main.js.map');
7433 });
7434
7435 it('resolves relative to parent multiple directory with query 1', () => {
7436 const base = './deep/..';
7437 const input = '../../../?input';
7438 const resolved = resolve(input, base);
7439 assert.strictEqual(resolved, '../../..?input');
7440 });
7441
7442 it('resolves relative to parent multiple directory with query 2', () => {
7443 const base = './deep/..';
7444 const input = '../../..?input';
7445 const resolved = resolve(input, base);
7446 assert.strictEqual(resolved, '../../..?input');
7447 });
7448
7449 it('normalizes input path', () => {
7450 const base = './deep/..';
7451 const input = './foo/./bar/../main.js.map';
7452 const resolved = resolve(input, base);
7453 assert.strictEqual(resolved, './foo/main.js.map');
7454 });
7455 });
7456
7457 describe('with relative path input', () => {
7458 it('resolves relative to current directory', () => {
7459 const base = './deep/..';
7460 const input = 'bar/main.js.map';
7461 const resolved = resolve(input, base);
7462 assert.strictEqual(resolved, './bar/main.js.map');
7463 });
7464
7465 it('resolves relative to current directory with query', () => {
7466 const base = './deep/..';
7467 const input = 'bar/main.js.map?input';
7468 const resolved = resolve(input, base);
7469 assert.strictEqual(resolved, './bar/main.js.map?input');
7470 });
7471
7472 it('resolves relative to parent multiple directory, later', () => {
7473 const base = './deep/..';
7474 const input = 'foo/../../../bar/main.js.map';
7475 const resolved = resolve(input, base);
7476 assert.strictEqual(resolved, '../../bar/main.js.map');
7477 });
7478
7479 it('normalizes input path', () => {
7480 const base = './deep/..';
7481 const input = 'foo/./bar/../main.js.map';
7482 const resolved = resolve(input, base);
7483 assert.strictEqual(resolved, './foo/main.js.map');
7484 });
7485
7486 it('resolves node_module scope as path', () => {
7487 const base = './deep/..';
7488 const input = 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js';
7489 const resolved = resolve(input, base);
7490 assert.strictEqual(resolved, './node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js');
7491 });
7492
7493 it('resolves package scope as path', () => {
7494 const base = './deep/..';
7495 const input = '@babel/runtime/helpers/esm/arrayLikeToArray.js';
7496 const resolved = resolve(input, base);
7497 assert.strictEqual(resolved, './@babel/runtime/helpers/esm/arrayLikeToArray.js');
7498 });
7499 });
7500
7501 describe('with query input', () => {
7502 it('resolves relative to path', () => {
7503 const base = './deep/..';
7504 const input = '?input';
7505 const resolved = resolve(input, base);
7506 assert.strictEqual(resolved, '?input');
7507 });
7508 });
7509
7510 describe('with hash input', () => {
7511 it('resolves relative to path', () => {
7512 const base = './deep/..';
7513 const input = '#input';
7514 const resolved = resolve(input, base);
7515 assert.strictEqual(resolved, '#input');
7516 });
7517 });
7518
7519 describe('empty input', () => {
7520 it('normalizes base', () => {
7521 const base = './deep/..';
7522 const input = '';
7523 const resolved = resolve(input, base);
7524 assert.strictEqual(resolved, '.');
7525 });
7526 });
7527 });
7528
7529 describe(`base = "./deep/../"`, () => {
7530 describe('with absolute input', () => {
7531 it('returns input', () => {
7532 const base = './deep/../';
7533 const input = 'https://absolute.com/main.js.map';
7534 const resolved = resolve(input, base);
7535 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
7536 });
7537
7538 it('returns input with query', () => {
7539 const base = './deep/../';
7540 const input = 'https://absolute.com/main.js.map?input';
7541 const resolved = resolve(input, base);
7542 assert.strictEqual(resolved, 'https://absolute.com/main.js.map?input');
7543 });
7544
7545 it('normalizes input path', () => {
7546 const base = './deep/../';
7547 const input = 'https://absolute.com/foo/./bar/../main.js.map';
7548 const resolved = resolve(input, base);
7549 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map');
7550 });
7551
7552 it('normalizes input path with query', () => {
7553 const base = './deep/../';
7554 const input = 'https://absolute.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
7555 const resolved = resolve(input, base);
7556 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map?input!webpack://foo/./bar');
7557 });
7558
7559 it('normalizes pathless input', () => {
7560 const base = './deep/../';
7561 const input = 'https://absolute.com';
7562 const resolved = resolve(input, base);
7563 assert.strictEqual(resolved, 'https://absolute.com/');
7564 });
7565
7566 it('normalizes pathless input with query', () => {
7567 const base = './deep/../';
7568 const input = 'https://absolute.com?input';
7569 const resolved = resolve(input, base);
7570 assert.strictEqual(resolved, 'https://absolute.com/?input');
7571 });
7572
7573 it('normalizes current directory', () => {
7574 const base = './deep/../';
7575 const input = 'https://absolute.com/./main.js.map';
7576 const resolved = resolve(input, base);
7577 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
7578 });
7579
7580 it('normalizes too many parent accessors', () => {
7581 const base = './deep/../';
7582 const input = 'https://absolute.com/../../../main.js.map';
7583 const resolved = resolve(input, base);
7584 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
7585 });
7586
7587 it('normalizes too many parent accessors, late', () => {
7588 const base = './deep/../';
7589 const input = 'https://absolute.com/foo/../../../main.js.map';
7590 const resolved = resolve(input, base);
7591 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
7592 });
7593
7594 it('normalizes file protocol 1', () => {
7595 const base = './deep/../';
7596 const input = 'file:///root/main.js.map';
7597 const resolved = resolve(input, base);
7598 assert.strictEqual(resolved, 'file:///root/main.js.map');
7599 });
7600
7601 it('normalizes file protocol 2', () => {
7602 const base = './deep/../';
7603 const input = 'file://root/main.js.map';
7604 const resolved = resolve(input, base);
7605 assert.strictEqual(resolved, 'file://root/main.js.map');
7606 });
7607
7608 it('normalizes file protocol 2.5', () => {
7609 const base = './deep/../';
7610 const input = 'file://root';
7611 const resolved = resolve(input, base);
7612 assert.strictEqual(resolved, 'file://root/');
7613 });
7614
7615 it('normalizes file protocol 3', () => {
7616 const base = './deep/../';
7617 const input = 'file:/root/main.js.map';
7618 const resolved = resolve(input, base);
7619 assert.strictEqual(resolved, 'file:///root/main.js.map');
7620 });
7621
7622 it('normalizes file protocol 4', () => {
7623 const base = './deep/../';
7624 const input = 'file:root/main.js.map';
7625 const resolved = resolve(input, base);
7626 assert.strictEqual(resolved, 'file:///root/main.js.map');
7627 });
7628
7629 it('normalizes file protocol 1 with query', () => {
7630 const base = './deep/../';
7631 const input = 'file:///root/main.js.map?input';
7632 const resolved = resolve(input, base);
7633 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
7634 });
7635
7636 it('normalizes file protocol 2 with query', () => {
7637 const base = './deep/../';
7638 const input = 'file://root/main.js.map?input';
7639 const resolved = resolve(input, base);
7640 assert.strictEqual(resolved, 'file://root/main.js.map?input');
7641 });
7642
7643 it('normalizes file protocol 2.5 with query', () => {
7644 const base = './deep/../';
7645 const input = 'file://root?input';
7646 const resolved = resolve(input, base);
7647 assert.strictEqual(resolved, 'file://root/?input');
7648 });
7649
7650 it('normalizes file protocol 3 with query', () => {
7651 const base = './deep/../';
7652 const input = 'file:/root/main.js.map?input';
7653 const resolved = resolve(input, base);
7654 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
7655 });
7656
7657 it('normalizes file protocol 4 with query', () => {
7658 const base = './deep/../';
7659 const input = 'file:root/main.js.map?input';
7660 const resolved = resolve(input, base);
7661 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
7662 });
7663 });
7664
7665 describe('with protocol relative input', () => {
7666 it('resolves relative to the base protocol', () => {
7667 const base = './deep/../';
7668 const input = '//protocol-relative.com/main.js.map';
7669 const resolved = resolve(input, base);
7670 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
7671 });
7672
7673 it('resolves relative to the base protocol with query', () => {
7674 const base = './deep/../';
7675 const input = '//protocol-relative.com/main.js.map?input';
7676 const resolved = resolve(input, base);
7677 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map?input');
7678 });
7679
7680 it('normalizes input path', () => {
7681 const base = './deep/../';
7682 const input = '//protocol-relative.com/foo/./bar/../main.js.map';
7683 const resolved = resolve(input, base);
7684 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map');
7685 });
7686
7687 it('normalizes input path with query', () => {
7688 const base = './deep/../';
7689 const input = '//protocol-relative.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
7690 const resolved = resolve(input, base);
7691 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map?input!webpack://foo/./bar');
7692 });
7693
7694 it('normalizes pathless input', () => {
7695 const base = './deep/../';
7696 const input = '//protocol-relative.com';
7697 const resolved = resolve(input, base);
7698 assert.strictEqual(resolved, '//protocol-relative.com/');
7699 });
7700
7701 it('normalizes pathless input with query', () => {
7702 const base = './deep/../';
7703 const input = '//protocol-relative.com?input';
7704 const resolved = resolve(input, base);
7705 assert.strictEqual(resolved, '//protocol-relative.com/?input');
7706 });
7707
7708 it('normalizes current directory', () => {
7709 const base = './deep/../';
7710 const input = '//protocol-relative.com/./main.js.map';
7711 const resolved = resolve(input, base);
7712 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
7713 });
7714
7715 it('normalizes too many parent accessors', () => {
7716 const base = './deep/../';
7717 const input = '//protocol-relative.com/../main.js.map';
7718 const resolved = resolve(input, base);
7719 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
7720 });
7721
7722 it('normalizes too many parent accessors, late', () => {
7723 const base = './deep/../';
7724 const input = '//protocol-relative.com/foo/../../main.js.map';
7725 const resolved = resolve(input, base);
7726 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
7727 });
7728 });
7729
7730 describe('with absolute path input', () => {
7731 it('remains absolute path', () => {
7732 const base = './deep/../';
7733 const input = '/assets/main.js.map';
7734 const resolved = resolve(input, base);
7735 assert.strictEqual(resolved, '/assets/main.js.map');
7736 });
7737
7738 it('remains absolute path with query', () => {
7739 const base = './deep/../';
7740 const input = '/assets/main.js.map?input';
7741 const resolved = resolve(input, base);
7742 assert.strictEqual(resolved, '/assets/main.js.map?input');
7743 });
7744
7745 it('trims to root', () => {
7746 const base = './deep/../';
7747 const input = '/';
7748 const resolved = resolve(input, base);
7749 assert.strictEqual(resolved, '/');
7750 });
7751
7752 it('normalizes input path', () => {
7753 const base = './deep/../';
7754 const input = '/foo/./bar/../main.js.map';
7755 const resolved = resolve(input, base);
7756 assert.strictEqual(resolved, '/foo/main.js.map');
7757 });
7758
7759 it('normalizes current directory', () => {
7760 const base = './deep/../';
7761 const input = '/./main.js.map';
7762 const resolved = resolve(input, base);
7763 assert.strictEqual(resolved, '/main.js.map');
7764 });
7765
7766 it('normalizes too many parent accessors', () => {
7767 const base = './deep/../';
7768 const input = '/../../../main.js.map';
7769 const resolved = resolve(input, base);
7770 assert.strictEqual(resolved, '/main.js.map');
7771 });
7772
7773 it('normalizes too many parent accessors with query 1', () => {
7774 const base = './deep/../';
7775 const input = '/../../../?input';
7776 const resolved = resolve(input, base);
7777 assert.strictEqual(resolved, '/?input');
7778 });
7779
7780 it('normalizes too many parent accessors with query 2', () => {
7781 const base = './deep/../';
7782 const input = '/../../..?input';
7783 const resolved = resolve(input, base);
7784 assert.strictEqual(resolved, '/?input');
7785 });
7786
7787 it('normalizes too many parent accessors, late', () => {
7788 const base = './deep/../';
7789 const input = '/foo/../../../main.js.map';
7790 const resolved = resolve(input, base);
7791 assert.strictEqual(resolved, '/main.js.map');
7792 });
7793 });
7794
7795 describe('with leading dot relative input', () => {
7796 it('resolves relative to current directory', () => {
7797 const base = './deep/../';
7798 const input = './bar/main.js.map';
7799 const resolved = resolve(input, base);
7800 assert.strictEqual(resolved, './bar/main.js.map');
7801 });
7802
7803 it('resolves relative to current directory with query', () => {
7804 const base = './deep/../';
7805 const input = './bar/main.js.map?input';
7806 const resolved = resolve(input, base);
7807 assert.strictEqual(resolved, './bar/main.js.map?input');
7808 });
7809
7810 it('resolves relative to parent directory', () => {
7811 const base = './deep/../';
7812 const input = '../bar/main.js.map';
7813 const resolved = resolve(input, base);
7814 assert.strictEqual(resolved, '../bar/main.js.map');
7815 });
7816
7817 it('resolves relative to parent directory with query', () => {
7818 const base = './deep/../';
7819 const input = '../bar/main.js.map?input';
7820 const resolved = resolve(input, base);
7821 assert.strictEqual(resolved, '../bar/main.js.map?input');
7822 });
7823
7824 it('resolves relative to parent multiple directory', () => {
7825 const base = './deep/../';
7826 const input = '../../../bar/main.js.map';
7827 const resolved = resolve(input, base);
7828 assert.strictEqual(resolved, '../../../bar/main.js.map');
7829 });
7830
7831 it('resolves relative to parent multiple directory with query 1', () => {
7832 const base = './deep/../';
7833 const input = '../../../?input';
7834 const resolved = resolve(input, base);
7835 assert.strictEqual(resolved, '../../..?input');
7836 });
7837
7838 it('resolves relative to parent multiple directory with query 2', () => {
7839 const base = './deep/../';
7840 const input = '../../..?input';
7841 const resolved = resolve(input, base);
7842 assert.strictEqual(resolved, '../../..?input');
7843 });
7844
7845 it('normalizes input path', () => {
7846 const base = './deep/../';
7847 const input = './foo/./bar/../main.js.map';
7848 const resolved = resolve(input, base);
7849 assert.strictEqual(resolved, './foo/main.js.map');
7850 });
7851 });
7852
7853 describe('with relative path input', () => {
7854 it('resolves relative to current directory', () => {
7855 const base = './deep/../';
7856 const input = 'bar/main.js.map';
7857 const resolved = resolve(input, base);
7858 assert.strictEqual(resolved, './bar/main.js.map');
7859 });
7860
7861 it('resolves relative to current directory with query', () => {
7862 const base = './deep/../';
7863 const input = 'bar/main.js.map?input';
7864 const resolved = resolve(input, base);
7865 assert.strictEqual(resolved, './bar/main.js.map?input');
7866 });
7867
7868 it('resolves relative to parent multiple directory, later', () => {
7869 const base = './deep/../';
7870 const input = 'foo/../../../bar/main.js.map';
7871 const resolved = resolve(input, base);
7872 assert.strictEqual(resolved, '../../bar/main.js.map');
7873 });
7874
7875 it('normalizes input path', () => {
7876 const base = './deep/../';
7877 const input = 'foo/./bar/../main.js.map';
7878 const resolved = resolve(input, base);
7879 assert.strictEqual(resolved, './foo/main.js.map');
7880 });
7881
7882 it('resolves node_module scope as path', () => {
7883 const base = './deep/../';
7884 const input = 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js';
7885 const resolved = resolve(input, base);
7886 assert.strictEqual(resolved, './node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js');
7887 });
7888
7889 it('resolves package scope as path', () => {
7890 const base = './deep/../';
7891 const input = '@babel/runtime/helpers/esm/arrayLikeToArray.js';
7892 const resolved = resolve(input, base);
7893 assert.strictEqual(resolved, './@babel/runtime/helpers/esm/arrayLikeToArray.js');
7894 });
7895 });
7896
7897 describe('with query input', () => {
7898 it('resolves relative to path', () => {
7899 const base = './deep/../';
7900 const input = '?input';
7901 const resolved = resolve(input, base);
7902 assert.strictEqual(resolved, '?input');
7903 });
7904 });
7905
7906 describe('with hash input', () => {
7907 it('resolves relative to path', () => {
7908 const base = './deep/../';
7909 const input = '#input';
7910 const resolved = resolve(input, base);
7911 assert.strictEqual(resolved, '#input');
7912 });
7913 });
7914
7915 describe('empty input', () => {
7916 it('normalizes base', () => {
7917 const base = './deep/../';
7918 const input = '';
7919 const resolved = resolve(input, base);
7920 assert.strictEqual(resolved, '.');
7921 });
7922 });
7923 });
7924
7925 describe(`base = "../.."`, () => {
7926 describe('with absolute input', () => {
7927 it('returns input', () => {
7928 const base = '../..';
7929 const input = 'https://absolute.com/main.js.map';
7930 const resolved = resolve(input, base);
7931 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
7932 });
7933
7934 it('returns input with query', () => {
7935 const base = '../..';
7936 const input = 'https://absolute.com/main.js.map?input';
7937 const resolved = resolve(input, base);
7938 assert.strictEqual(resolved, 'https://absolute.com/main.js.map?input');
7939 });
7940
7941 it('normalizes input path', () => {
7942 const base = '../..';
7943 const input = 'https://absolute.com/foo/./bar/../main.js.map';
7944 const resolved = resolve(input, base);
7945 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map');
7946 });
7947
7948 it('normalizes input path with query', () => {
7949 const base = '../..';
7950 const input = 'https://absolute.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
7951 const resolved = resolve(input, base);
7952 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map?input!webpack://foo/./bar');
7953 });
7954
7955 it('normalizes pathless input', () => {
7956 const base = '../..';
7957 const input = 'https://absolute.com';
7958 const resolved = resolve(input, base);
7959 assert.strictEqual(resolved, 'https://absolute.com/');
7960 });
7961
7962 it('normalizes pathless input with query', () => {
7963 const base = '../..';
7964 const input = 'https://absolute.com?input';
7965 const resolved = resolve(input, base);
7966 assert.strictEqual(resolved, 'https://absolute.com/?input');
7967 });
7968
7969 it('normalizes current directory', () => {
7970 const base = '../..';
7971 const input = 'https://absolute.com/./main.js.map';
7972 const resolved = resolve(input, base);
7973 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
7974 });
7975
7976 it('normalizes too many parent accessors', () => {
7977 const base = '../..';
7978 const input = 'https://absolute.com/../../../main.js.map';
7979 const resolved = resolve(input, base);
7980 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
7981 });
7982
7983 it('normalizes too many parent accessors, late', () => {
7984 const base = '../..';
7985 const input = 'https://absolute.com/foo/../../../main.js.map';
7986 const resolved = resolve(input, base);
7987 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
7988 });
7989
7990 it('normalizes file protocol 1', () => {
7991 const base = '../..';
7992 const input = 'file:///root/main.js.map';
7993 const resolved = resolve(input, base);
7994 assert.strictEqual(resolved, 'file:///root/main.js.map');
7995 });
7996
7997 it('normalizes file protocol 2', () => {
7998 const base = '../..';
7999 const input = 'file://root/main.js.map';
8000 const resolved = resolve(input, base);
8001 assert.strictEqual(resolved, 'file://root/main.js.map');
8002 });
8003
8004 it('normalizes file protocol 2.5', () => {
8005 const base = '../..';
8006 const input = 'file://root';
8007 const resolved = resolve(input, base);
8008 assert.strictEqual(resolved, 'file://root/');
8009 });
8010
8011 it('normalizes file protocol 3', () => {
8012 const base = '../..';
8013 const input = 'file:/root/main.js.map';
8014 const resolved = resolve(input, base);
8015 assert.strictEqual(resolved, 'file:///root/main.js.map');
8016 });
8017
8018 it('normalizes file protocol 4', () => {
8019 const base = '../..';
8020 const input = 'file:root/main.js.map';
8021 const resolved = resolve(input, base);
8022 assert.strictEqual(resolved, 'file:///root/main.js.map');
8023 });
8024
8025 it('normalizes file protocol 1 with query', () => {
8026 const base = '../..';
8027 const input = 'file:///root/main.js.map?input';
8028 const resolved = resolve(input, base);
8029 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
8030 });
8031
8032 it('normalizes file protocol 2 with query', () => {
8033 const base = '../..';
8034 const input = 'file://root/main.js.map?input';
8035 const resolved = resolve(input, base);
8036 assert.strictEqual(resolved, 'file://root/main.js.map?input');
8037 });
8038
8039 it('normalizes file protocol 2.5 with query', () => {
8040 const base = '../..';
8041 const input = 'file://root?input';
8042 const resolved = resolve(input, base);
8043 assert.strictEqual(resolved, 'file://root/?input');
8044 });
8045
8046 it('normalizes file protocol 3 with query', () => {
8047 const base = '../..';
8048 const input = 'file:/root/main.js.map?input';
8049 const resolved = resolve(input, base);
8050 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
8051 });
8052
8053 it('normalizes file protocol 4 with query', () => {
8054 const base = '../..';
8055 const input = 'file:root/main.js.map?input';
8056 const resolved = resolve(input, base);
8057 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
8058 });
8059 });
8060
8061 describe('with protocol relative input', () => {
8062 it('resolves relative to the base protocol', () => {
8063 const base = '../..';
8064 const input = '//protocol-relative.com/main.js.map';
8065 const resolved = resolve(input, base);
8066 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
8067 });
8068
8069 it('resolves relative to the base protocol with query', () => {
8070 const base = '../..';
8071 const input = '//protocol-relative.com/main.js.map?input';
8072 const resolved = resolve(input, base);
8073 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map?input');
8074 });
8075
8076 it('normalizes input path', () => {
8077 const base = '../..';
8078 const input = '//protocol-relative.com/foo/./bar/../main.js.map';
8079 const resolved = resolve(input, base);
8080 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map');
8081 });
8082
8083 it('normalizes input path with query', () => {
8084 const base = '../..';
8085 const input = '//protocol-relative.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
8086 const resolved = resolve(input, base);
8087 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map?input!webpack://foo/./bar');
8088 });
8089
8090 it('normalizes pathless input', () => {
8091 const base = '../..';
8092 const input = '//protocol-relative.com';
8093 const resolved = resolve(input, base);
8094 assert.strictEqual(resolved, '//protocol-relative.com/');
8095 });
8096
8097 it('normalizes pathless input with query', () => {
8098 const base = '../..';
8099 const input = '//protocol-relative.com?input';
8100 const resolved = resolve(input, base);
8101 assert.strictEqual(resolved, '//protocol-relative.com/?input');
8102 });
8103
8104 it('normalizes current directory', () => {
8105 const base = '../..';
8106 const input = '//protocol-relative.com/./main.js.map';
8107 const resolved = resolve(input, base);
8108 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
8109 });
8110
8111 it('normalizes too many parent accessors', () => {
8112 const base = '../..';
8113 const input = '//protocol-relative.com/../main.js.map';
8114 const resolved = resolve(input, base);
8115 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
8116 });
8117
8118 it('normalizes too many parent accessors, late', () => {
8119 const base = '../..';
8120 const input = '//protocol-relative.com/foo/../../main.js.map';
8121 const resolved = resolve(input, base);
8122 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
8123 });
8124 });
8125
8126 describe('with absolute path input', () => {
8127 it('remains absolute path', () => {
8128 const base = '../..';
8129 const input = '/assets/main.js.map';
8130 const resolved = resolve(input, base);
8131 assert.strictEqual(resolved, '/assets/main.js.map');
8132 });
8133
8134 it('remains absolute path with query', () => {
8135 const base = '../..';
8136 const input = '/assets/main.js.map?input';
8137 const resolved = resolve(input, base);
8138 assert.strictEqual(resolved, '/assets/main.js.map?input');
8139 });
8140
8141 it('trims to root', () => {
8142 const base = '../..';
8143 const input = '/';
8144 const resolved = resolve(input, base);
8145 assert.strictEqual(resolved, '/');
8146 });
8147
8148 it('normalizes input path', () => {
8149 const base = '../..';
8150 const input = '/foo/./bar/../main.js.map';
8151 const resolved = resolve(input, base);
8152 assert.strictEqual(resolved, '/foo/main.js.map');
8153 });
8154
8155 it('normalizes current directory', () => {
8156 const base = '../..';
8157 const input = '/./main.js.map';
8158 const resolved = resolve(input, base);
8159 assert.strictEqual(resolved, '/main.js.map');
8160 });
8161
8162 it('normalizes too many parent accessors', () => {
8163 const base = '../..';
8164 const input = '/../../../main.js.map';
8165 const resolved = resolve(input, base);
8166 assert.strictEqual(resolved, '/main.js.map');
8167 });
8168
8169 it('normalizes too many parent accessors with query 1', () => {
8170 const base = '../..';
8171 const input = '/../../../?input';
8172 const resolved = resolve(input, base);
8173 assert.strictEqual(resolved, '/?input');
8174 });
8175
8176 it('normalizes too many parent accessors with query 2', () => {
8177 const base = '../..';
8178 const input = '/../../..?input';
8179 const resolved = resolve(input, base);
8180 assert.strictEqual(resolved, '/?input');
8181 });
8182
8183 it('normalizes too many parent accessors, late', () => {
8184 const base = '../..';
8185 const input = '/foo/../../../main.js.map';
8186 const resolved = resolve(input, base);
8187 assert.strictEqual(resolved, '/main.js.map');
8188 });
8189 });
8190
8191 describe('with leading dot relative input', () => {
8192 it('resolves relative to current directory', () => {
8193 const base = '../..';
8194 const input = './bar/main.js.map';
8195 const resolved = resolve(input, base);
8196 assert.strictEqual(resolved, '../../bar/main.js.map');
8197 });
8198
8199 it('resolves relative to current directory with query', () => {
8200 const base = '../..';
8201 const input = './bar/main.js.map?input';
8202 const resolved = resolve(input, base);
8203 assert.strictEqual(resolved, '../../bar/main.js.map?input');
8204 });
8205
8206 it('resolves relative to parent directory', () => {
8207 const base = '../..';
8208 const input = '../bar/main.js.map';
8209 const resolved = resolve(input, base);
8210 assert.strictEqual(resolved, '../../../bar/main.js.map');
8211 });
8212
8213 it('resolves relative to parent directory with query', () => {
8214 const base = '../..';
8215 const input = '../bar/main.js.map?input';
8216 const resolved = resolve(input, base);
8217 assert.strictEqual(resolved, '../../../bar/main.js.map?input');
8218 });
8219
8220 it('resolves relative to parent multiple directory', () => {
8221 const base = '../..';
8222 const input = '../../../bar/main.js.map';
8223 const resolved = resolve(input, base);
8224 assert.strictEqual(resolved, '../../../../../bar/main.js.map');
8225 });
8226
8227 it('resolves relative to parent multiple directory with query 1', () => {
8228 const base = '../..';
8229 const input = '../../../?input';
8230 const resolved = resolve(input, base);
8231 assert.strictEqual(resolved, '../../../../..?input');
8232 });
8233
8234 it('resolves relative to parent multiple directory with query 2', () => {
8235 const base = '../..';
8236 const input = '../../..?input';
8237 const resolved = resolve(input, base);
8238 assert.strictEqual(resolved, '../../../../..?input');
8239 });
8240
8241 it('normalizes input path', () => {
8242 const base = '../..';
8243 const input = './foo/./bar/../main.js.map';
8244 const resolved = resolve(input, base);
8245 assert.strictEqual(resolved, '../../foo/main.js.map');
8246 });
8247 });
8248
8249 describe('with relative path input', () => {
8250 it('resolves relative to current directory', () => {
8251 const base = '../..';
8252 const input = 'bar/main.js.map';
8253 const resolved = resolve(input, base);
8254 assert.strictEqual(resolved, '../../bar/main.js.map');
8255 });
8256
8257 it('resolves relative to current directory with query', () => {
8258 const base = '../..';
8259 const input = 'bar/main.js.map?input';
8260 const resolved = resolve(input, base);
8261 assert.strictEqual(resolved, '../../bar/main.js.map?input');
8262 });
8263
8264 it('resolves relative to parent multiple directory, later', () => {
8265 const base = '../..';
8266 const input = 'foo/../../../bar/main.js.map';
8267 const resolved = resolve(input, base);
8268 assert.strictEqual(resolved, '../../../../bar/main.js.map');
8269 });
8270
8271 it('normalizes input path', () => {
8272 const base = '../..';
8273 const input = 'foo/./bar/../main.js.map';
8274 const resolved = resolve(input, base);
8275 assert.strictEqual(resolved, '../../foo/main.js.map');
8276 });
8277
8278 it('resolves node_module scope as path', () => {
8279 const base = '../..';
8280 const input = 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js';
8281 const resolved = resolve(input, base);
8282 assert.strictEqual(resolved, '../../node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js');
8283 });
8284
8285 it('resolves package scope as path', () => {
8286 const base = '../..';
8287 const input = '@babel/runtime/helpers/esm/arrayLikeToArray.js';
8288 const resolved = resolve(input, base);
8289 assert.strictEqual(resolved, '../../@babel/runtime/helpers/esm/arrayLikeToArray.js');
8290 });
8291 });
8292
8293 describe('with query input', () => {
8294 it('resolves relative to path', () => {
8295 const base = '../..';
8296 const input = '?input';
8297 const resolved = resolve(input, base);
8298 assert.strictEqual(resolved, '../..?input');
8299 });
8300 });
8301
8302 describe('with hash input', () => {
8303 it('resolves relative to path', () => {
8304 const base = '../..';
8305 const input = '#input';
8306 const resolved = resolve(input, base);
8307 assert.strictEqual(resolved, '../..#input');
8308 });
8309 });
8310
8311 describe('empty input', () => {
8312 it('normalizes base', () => {
8313 const base = '../..';
8314 const input = '';
8315 const resolved = resolve(input, base);
8316 assert.strictEqual(resolved, '../..');
8317 });
8318 });
8319 });
8320
8321 describe(`base = "../../"`, () => {
8322 describe('with absolute input', () => {
8323 it('returns input', () => {
8324 const base = '../../';
8325 const input = 'https://absolute.com/main.js.map';
8326 const resolved = resolve(input, base);
8327 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
8328 });
8329
8330 it('returns input with query', () => {
8331 const base = '../../';
8332 const input = 'https://absolute.com/main.js.map?input';
8333 const resolved = resolve(input, base);
8334 assert.strictEqual(resolved, 'https://absolute.com/main.js.map?input');
8335 });
8336
8337 it('normalizes input path', () => {
8338 const base = '../../';
8339 const input = 'https://absolute.com/foo/./bar/../main.js.map';
8340 const resolved = resolve(input, base);
8341 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map');
8342 });
8343
8344 it('normalizes input path with query', () => {
8345 const base = '../../';
8346 const input = 'https://absolute.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
8347 const resolved = resolve(input, base);
8348 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map?input!webpack://foo/./bar');
8349 });
8350
8351 it('normalizes pathless input', () => {
8352 const base = '../../';
8353 const input = 'https://absolute.com';
8354 const resolved = resolve(input, base);
8355 assert.strictEqual(resolved, 'https://absolute.com/');
8356 });
8357
8358 it('normalizes pathless input with query', () => {
8359 const base = '../../';
8360 const input = 'https://absolute.com?input';
8361 const resolved = resolve(input, base);
8362 assert.strictEqual(resolved, 'https://absolute.com/?input');
8363 });
8364
8365 it('normalizes current directory', () => {
8366 const base = '../../';
8367 const input = 'https://absolute.com/./main.js.map';
8368 const resolved = resolve(input, base);
8369 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
8370 });
8371
8372 it('normalizes too many parent accessors', () => {
8373 const base = '../../';
8374 const input = 'https://absolute.com/../../../main.js.map';
8375 const resolved = resolve(input, base);
8376 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
8377 });
8378
8379 it('normalizes too many parent accessors, late', () => {
8380 const base = '../../';
8381 const input = 'https://absolute.com/foo/../../../main.js.map';
8382 const resolved = resolve(input, base);
8383 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
8384 });
8385
8386 it('normalizes file protocol 1', () => {
8387 const base = '../../';
8388 const input = 'file:///root/main.js.map';
8389 const resolved = resolve(input, base);
8390 assert.strictEqual(resolved, 'file:///root/main.js.map');
8391 });
8392
8393 it('normalizes file protocol 2', () => {
8394 const base = '../../';
8395 const input = 'file://root/main.js.map';
8396 const resolved = resolve(input, base);
8397 assert.strictEqual(resolved, 'file://root/main.js.map');
8398 });
8399
8400 it('normalizes file protocol 2.5', () => {
8401 const base = '../../';
8402 const input = 'file://root';
8403 const resolved = resolve(input, base);
8404 assert.strictEqual(resolved, 'file://root/');
8405 });
8406
8407 it('normalizes file protocol 3', () => {
8408 const base = '../../';
8409 const input = 'file:/root/main.js.map';
8410 const resolved = resolve(input, base);
8411 assert.strictEqual(resolved, 'file:///root/main.js.map');
8412 });
8413
8414 it('normalizes file protocol 4', () => {
8415 const base = '../../';
8416 const input = 'file:root/main.js.map';
8417 const resolved = resolve(input, base);
8418 assert.strictEqual(resolved, 'file:///root/main.js.map');
8419 });
8420
8421 it('normalizes file protocol 1 with query', () => {
8422 const base = '../../';
8423 const input = 'file:///root/main.js.map?input';
8424 const resolved = resolve(input, base);
8425 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
8426 });
8427
8428 it('normalizes file protocol 2 with query', () => {
8429 const base = '../../';
8430 const input = 'file://root/main.js.map?input';
8431 const resolved = resolve(input, base);
8432 assert.strictEqual(resolved, 'file://root/main.js.map?input');
8433 });
8434
8435 it('normalizes file protocol 2.5 with query', () => {
8436 const base = '../../';
8437 const input = 'file://root?input';
8438 const resolved = resolve(input, base);
8439 assert.strictEqual(resolved, 'file://root/?input');
8440 });
8441
8442 it('normalizes file protocol 3 with query', () => {
8443 const base = '../../';
8444 const input = 'file:/root/main.js.map?input';
8445 const resolved = resolve(input, base);
8446 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
8447 });
8448
8449 it('normalizes file protocol 4 with query', () => {
8450 const base = '../../';
8451 const input = 'file:root/main.js.map?input';
8452 const resolved = resolve(input, base);
8453 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
8454 });
8455 });
8456
8457 describe('with protocol relative input', () => {
8458 it('resolves relative to the base protocol', () => {
8459 const base = '../../';
8460 const input = '//protocol-relative.com/main.js.map';
8461 const resolved = resolve(input, base);
8462 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
8463 });
8464
8465 it('resolves relative to the base protocol with query', () => {
8466 const base = '../../';
8467 const input = '//protocol-relative.com/main.js.map?input';
8468 const resolved = resolve(input, base);
8469 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map?input');
8470 });
8471
8472 it('normalizes input path', () => {
8473 const base = '../../';
8474 const input = '//protocol-relative.com/foo/./bar/../main.js.map';
8475 const resolved = resolve(input, base);
8476 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map');
8477 });
8478
8479 it('normalizes input path with query', () => {
8480 const base = '../../';
8481 const input = '//protocol-relative.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
8482 const resolved = resolve(input, base);
8483 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map?input!webpack://foo/./bar');
8484 });
8485
8486 it('normalizes pathless input', () => {
8487 const base = '../../';
8488 const input = '//protocol-relative.com';
8489 const resolved = resolve(input, base);
8490 assert.strictEqual(resolved, '//protocol-relative.com/');
8491 });
8492
8493 it('normalizes pathless input with query', () => {
8494 const base = '../../';
8495 const input = '//protocol-relative.com?input';
8496 const resolved = resolve(input, base);
8497 assert.strictEqual(resolved, '//protocol-relative.com/?input');
8498 });
8499
8500 it('normalizes current directory', () => {
8501 const base = '../../';
8502 const input = '//protocol-relative.com/./main.js.map';
8503 const resolved = resolve(input, base);
8504 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
8505 });
8506
8507 it('normalizes too many parent accessors', () => {
8508 const base = '../../';
8509 const input = '//protocol-relative.com/../main.js.map';
8510 const resolved = resolve(input, base);
8511 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
8512 });
8513
8514 it('normalizes too many parent accessors, late', () => {
8515 const base = '../../';
8516 const input = '//protocol-relative.com/foo/../../main.js.map';
8517 const resolved = resolve(input, base);
8518 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
8519 });
8520 });
8521
8522 describe('with absolute path input', () => {
8523 it('remains absolute path', () => {
8524 const base = '../../';
8525 const input = '/assets/main.js.map';
8526 const resolved = resolve(input, base);
8527 assert.strictEqual(resolved, '/assets/main.js.map');
8528 });
8529
8530 it('remains absolute path with query', () => {
8531 const base = '../../';
8532 const input = '/assets/main.js.map?input';
8533 const resolved = resolve(input, base);
8534 assert.strictEqual(resolved, '/assets/main.js.map?input');
8535 });
8536
8537 it('trims to root', () => {
8538 const base = '../../';
8539 const input = '/';
8540 const resolved = resolve(input, base);
8541 assert.strictEqual(resolved, '/');
8542 });
8543
8544 it('normalizes input path', () => {
8545 const base = '../../';
8546 const input = '/foo/./bar/../main.js.map';
8547 const resolved = resolve(input, base);
8548 assert.strictEqual(resolved, '/foo/main.js.map');
8549 });
8550
8551 it('normalizes current directory', () => {
8552 const base = '../../';
8553 const input = '/./main.js.map';
8554 const resolved = resolve(input, base);
8555 assert.strictEqual(resolved, '/main.js.map');
8556 });
8557
8558 it('normalizes too many parent accessors', () => {
8559 const base = '../../';
8560 const input = '/../../../main.js.map';
8561 const resolved = resolve(input, base);
8562 assert.strictEqual(resolved, '/main.js.map');
8563 });
8564
8565 it('normalizes too many parent accessors with query 1', () => {
8566 const base = '../../';
8567 const input = '/../../../?input';
8568 const resolved = resolve(input, base);
8569 assert.strictEqual(resolved, '/?input');
8570 });
8571
8572 it('normalizes too many parent accessors with query 2', () => {
8573 const base = '../../';
8574 const input = '/../../..?input';
8575 const resolved = resolve(input, base);
8576 assert.strictEqual(resolved, '/?input');
8577 });
8578
8579 it('normalizes too many parent accessors, late', () => {
8580 const base = '../../';
8581 const input = '/foo/../../../main.js.map';
8582 const resolved = resolve(input, base);
8583 assert.strictEqual(resolved, '/main.js.map');
8584 });
8585 });
8586
8587 describe('with leading dot relative input', () => {
8588 it('resolves relative to current directory', () => {
8589 const base = '../../';
8590 const input = './bar/main.js.map';
8591 const resolved = resolve(input, base);
8592 assert.strictEqual(resolved, '../../bar/main.js.map');
8593 });
8594
8595 it('resolves relative to current directory with query', () => {
8596 const base = '../../';
8597 const input = './bar/main.js.map?input';
8598 const resolved = resolve(input, base);
8599 assert.strictEqual(resolved, '../../bar/main.js.map?input');
8600 });
8601
8602 it('resolves relative to parent directory', () => {
8603 const base = '../../';
8604 const input = '../bar/main.js.map';
8605 const resolved = resolve(input, base);
8606 assert.strictEqual(resolved, '../../../bar/main.js.map');
8607 });
8608
8609 it('resolves relative to parent directory with query', () => {
8610 const base = '../../';
8611 const input = '../bar/main.js.map?input';
8612 const resolved = resolve(input, base);
8613 assert.strictEqual(resolved, '../../../bar/main.js.map?input');
8614 });
8615
8616 it('resolves relative to parent multiple directory', () => {
8617 const base = '../../';
8618 const input = '../../../bar/main.js.map';
8619 const resolved = resolve(input, base);
8620 assert.strictEqual(resolved, '../../../../../bar/main.js.map');
8621 });
8622
8623 it('resolves relative to parent multiple directory with query 1', () => {
8624 const base = '../../';
8625 const input = '../../../?input';
8626 const resolved = resolve(input, base);
8627 assert.strictEqual(resolved, '../../../../..?input');
8628 });
8629
8630 it('resolves relative to parent multiple directory with query 2', () => {
8631 const base = '../../';
8632 const input = '../../..?input';
8633 const resolved = resolve(input, base);
8634 assert.strictEqual(resolved, '../../../../..?input');
8635 });
8636
8637 it('normalizes input path', () => {
8638 const base = '../../';
8639 const input = './foo/./bar/../main.js.map';
8640 const resolved = resolve(input, base);
8641 assert.strictEqual(resolved, '../../foo/main.js.map');
8642 });
8643 });
8644
8645 describe('with relative path input', () => {
8646 it('resolves relative to current directory', () => {
8647 const base = '../../';
8648 const input = 'bar/main.js.map';
8649 const resolved = resolve(input, base);
8650 assert.strictEqual(resolved, '../../bar/main.js.map');
8651 });
8652
8653 it('resolves relative to current directory with query', () => {
8654 const base = '../../';
8655 const input = 'bar/main.js.map?input';
8656 const resolved = resolve(input, base);
8657 assert.strictEqual(resolved, '../../bar/main.js.map?input');
8658 });
8659
8660 it('resolves relative to parent multiple directory, later', () => {
8661 const base = '../../';
8662 const input = 'foo/../../../bar/main.js.map';
8663 const resolved = resolve(input, base);
8664 assert.strictEqual(resolved, '../../../../bar/main.js.map');
8665 });
8666
8667 it('normalizes input path', () => {
8668 const base = '../../';
8669 const input = 'foo/./bar/../main.js.map';
8670 const resolved = resolve(input, base);
8671 assert.strictEqual(resolved, '../../foo/main.js.map');
8672 });
8673
8674 it('resolves node_module scope as path', () => {
8675 const base = '../../';
8676 const input = 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js';
8677 const resolved = resolve(input, base);
8678 assert.strictEqual(resolved, '../../node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js');
8679 });
8680
8681 it('resolves package scope as path', () => {
8682 const base = '../../';
8683 const input = '@babel/runtime/helpers/esm/arrayLikeToArray.js';
8684 const resolved = resolve(input, base);
8685 assert.strictEqual(resolved, '../../@babel/runtime/helpers/esm/arrayLikeToArray.js');
8686 });
8687 });
8688
8689 describe('with query input', () => {
8690 it('resolves relative to path', () => {
8691 const base = '../../';
8692 const input = '?input';
8693 const resolved = resolve(input, base);
8694 assert.strictEqual(resolved, '../..?input');
8695 });
8696 });
8697
8698 describe('with hash input', () => {
8699 it('resolves relative to path', () => {
8700 const base = '../../';
8701 const input = '#input';
8702 const resolved = resolve(input, base);
8703 assert.strictEqual(resolved, '../..#input');
8704 });
8705 });
8706
8707 describe('empty input', () => {
8708 it('normalizes base', () => {
8709 const base = '../../';
8710 const input = '';
8711 const resolved = resolve(input, base);
8712 assert.strictEqual(resolved, '../..');
8713 });
8714 });
8715 });
8716
8717 describe(`base = "../deep/.."`, () => {
8718 describe('with absolute input', () => {
8719 it('returns input', () => {
8720 const base = '../deep/..';
8721 const input = 'https://absolute.com/main.js.map';
8722 const resolved = resolve(input, base);
8723 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
8724 });
8725
8726 it('returns input with query', () => {
8727 const base = '../deep/..';
8728 const input = 'https://absolute.com/main.js.map?input';
8729 const resolved = resolve(input, base);
8730 assert.strictEqual(resolved, 'https://absolute.com/main.js.map?input');
8731 });
8732
8733 it('normalizes input path', () => {
8734 const base = '../deep/..';
8735 const input = 'https://absolute.com/foo/./bar/../main.js.map';
8736 const resolved = resolve(input, base);
8737 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map');
8738 });
8739
8740 it('normalizes input path with query', () => {
8741 const base = '../deep/..';
8742 const input = 'https://absolute.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
8743 const resolved = resolve(input, base);
8744 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map?input!webpack://foo/./bar');
8745 });
8746
8747 it('normalizes pathless input', () => {
8748 const base = '../deep/..';
8749 const input = 'https://absolute.com';
8750 const resolved = resolve(input, base);
8751 assert.strictEqual(resolved, 'https://absolute.com/');
8752 });
8753
8754 it('normalizes pathless input with query', () => {
8755 const base = '../deep/..';
8756 const input = 'https://absolute.com?input';
8757 const resolved = resolve(input, base);
8758 assert.strictEqual(resolved, 'https://absolute.com/?input');
8759 });
8760
8761 it('normalizes current directory', () => {
8762 const base = '../deep/..';
8763 const input = 'https://absolute.com/./main.js.map';
8764 const resolved = resolve(input, base);
8765 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
8766 });
8767
8768 it('normalizes too many parent accessors', () => {
8769 const base = '../deep/..';
8770 const input = 'https://absolute.com/../../../main.js.map';
8771 const resolved = resolve(input, base);
8772 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
8773 });
8774
8775 it('normalizes too many parent accessors, late', () => {
8776 const base = '../deep/..';
8777 const input = 'https://absolute.com/foo/../../../main.js.map';
8778 const resolved = resolve(input, base);
8779 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
8780 });
8781
8782 it('normalizes file protocol 1', () => {
8783 const base = '../deep/..';
8784 const input = 'file:///root/main.js.map';
8785 const resolved = resolve(input, base);
8786 assert.strictEqual(resolved, 'file:///root/main.js.map');
8787 });
8788
8789 it('normalizes file protocol 2', () => {
8790 const base = '../deep/..';
8791 const input = 'file://root/main.js.map';
8792 const resolved = resolve(input, base);
8793 assert.strictEqual(resolved, 'file://root/main.js.map');
8794 });
8795
8796 it('normalizes file protocol 2.5', () => {
8797 const base = '../deep/..';
8798 const input = 'file://root';
8799 const resolved = resolve(input, base);
8800 assert.strictEqual(resolved, 'file://root/');
8801 });
8802
8803 it('normalizes file protocol 3', () => {
8804 const base = '../deep/..';
8805 const input = 'file:/root/main.js.map';
8806 const resolved = resolve(input, base);
8807 assert.strictEqual(resolved, 'file:///root/main.js.map');
8808 });
8809
8810 it('normalizes file protocol 4', () => {
8811 const base = '../deep/..';
8812 const input = 'file:root/main.js.map';
8813 const resolved = resolve(input, base);
8814 assert.strictEqual(resolved, 'file:///root/main.js.map');
8815 });
8816
8817 it('normalizes file protocol 1 with query', () => {
8818 const base = '../deep/..';
8819 const input = 'file:///root/main.js.map?input';
8820 const resolved = resolve(input, base);
8821 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
8822 });
8823
8824 it('normalizes file protocol 2 with query', () => {
8825 const base = '../deep/..';
8826 const input = 'file://root/main.js.map?input';
8827 const resolved = resolve(input, base);
8828 assert.strictEqual(resolved, 'file://root/main.js.map?input');
8829 });
8830
8831 it('normalizes file protocol 2.5 with query', () => {
8832 const base = '../deep/..';
8833 const input = 'file://root?input';
8834 const resolved = resolve(input, base);
8835 assert.strictEqual(resolved, 'file://root/?input');
8836 });
8837
8838 it('normalizes file protocol 3 with query', () => {
8839 const base = '../deep/..';
8840 const input = 'file:/root/main.js.map?input';
8841 const resolved = resolve(input, base);
8842 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
8843 });
8844
8845 it('normalizes file protocol 4 with query', () => {
8846 const base = '../deep/..';
8847 const input = 'file:root/main.js.map?input';
8848 const resolved = resolve(input, base);
8849 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
8850 });
8851 });
8852
8853 describe('with protocol relative input', () => {
8854 it('resolves relative to the base protocol', () => {
8855 const base = '../deep/..';
8856 const input = '//protocol-relative.com/main.js.map';
8857 const resolved = resolve(input, base);
8858 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
8859 });
8860
8861 it('resolves relative to the base protocol with query', () => {
8862 const base = '../deep/..';
8863 const input = '//protocol-relative.com/main.js.map?input';
8864 const resolved = resolve(input, base);
8865 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map?input');
8866 });
8867
8868 it('normalizes input path', () => {
8869 const base = '../deep/..';
8870 const input = '//protocol-relative.com/foo/./bar/../main.js.map';
8871 const resolved = resolve(input, base);
8872 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map');
8873 });
8874
8875 it('normalizes input path with query', () => {
8876 const base = '../deep/..';
8877 const input = '//protocol-relative.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
8878 const resolved = resolve(input, base);
8879 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map?input!webpack://foo/./bar');
8880 });
8881
8882 it('normalizes pathless input', () => {
8883 const base = '../deep/..';
8884 const input = '//protocol-relative.com';
8885 const resolved = resolve(input, base);
8886 assert.strictEqual(resolved, '//protocol-relative.com/');
8887 });
8888
8889 it('normalizes pathless input with query', () => {
8890 const base = '../deep/..';
8891 const input = '//protocol-relative.com?input';
8892 const resolved = resolve(input, base);
8893 assert.strictEqual(resolved, '//protocol-relative.com/?input');
8894 });
8895
8896 it('normalizes current directory', () => {
8897 const base = '../deep/..';
8898 const input = '//protocol-relative.com/./main.js.map';
8899 const resolved = resolve(input, base);
8900 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
8901 });
8902
8903 it('normalizes too many parent accessors', () => {
8904 const base = '../deep/..';
8905 const input = '//protocol-relative.com/../main.js.map';
8906 const resolved = resolve(input, base);
8907 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
8908 });
8909
8910 it('normalizes too many parent accessors, late', () => {
8911 const base = '../deep/..';
8912 const input = '//protocol-relative.com/foo/../../main.js.map';
8913 const resolved = resolve(input, base);
8914 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
8915 });
8916 });
8917
8918 describe('with absolute path input', () => {
8919 it('remains absolute path', () => {
8920 const base = '../deep/..';
8921 const input = '/assets/main.js.map';
8922 const resolved = resolve(input, base);
8923 assert.strictEqual(resolved, '/assets/main.js.map');
8924 });
8925
8926 it('remains absolute path with query', () => {
8927 const base = '../deep/..';
8928 const input = '/assets/main.js.map?input';
8929 const resolved = resolve(input, base);
8930 assert.strictEqual(resolved, '/assets/main.js.map?input');
8931 });
8932
8933 it('trims to root', () => {
8934 const base = '../deep/..';
8935 const input = '/';
8936 const resolved = resolve(input, base);
8937 assert.strictEqual(resolved, '/');
8938 });
8939
8940 it('normalizes input path', () => {
8941 const base = '../deep/..';
8942 const input = '/foo/./bar/../main.js.map';
8943 const resolved = resolve(input, base);
8944 assert.strictEqual(resolved, '/foo/main.js.map');
8945 });
8946
8947 it('normalizes current directory', () => {
8948 const base = '../deep/..';
8949 const input = '/./main.js.map';
8950 const resolved = resolve(input, base);
8951 assert.strictEqual(resolved, '/main.js.map');
8952 });
8953
8954 it('normalizes too many parent accessors', () => {
8955 const base = '../deep/..';
8956 const input = '/../../../main.js.map';
8957 const resolved = resolve(input, base);
8958 assert.strictEqual(resolved, '/main.js.map');
8959 });
8960
8961 it('normalizes too many parent accessors with query 1', () => {
8962 const base = '../deep/..';
8963 const input = '/../../../?input';
8964 const resolved = resolve(input, base);
8965 assert.strictEqual(resolved, '/?input');
8966 });
8967
8968 it('normalizes too many parent accessors with query 2', () => {
8969 const base = '../deep/..';
8970 const input = '/../../..?input';
8971 const resolved = resolve(input, base);
8972 assert.strictEqual(resolved, '/?input');
8973 });
8974
8975 it('normalizes too many parent accessors, late', () => {
8976 const base = '../deep/..';
8977 const input = '/foo/../../../main.js.map';
8978 const resolved = resolve(input, base);
8979 assert.strictEqual(resolved, '/main.js.map');
8980 });
8981 });
8982
8983 describe('with leading dot relative input', () => {
8984 it('resolves relative to current directory', () => {
8985 const base = '../deep/..';
8986 const input = './bar/main.js.map';
8987 const resolved = resolve(input, base);
8988 assert.strictEqual(resolved, '../bar/main.js.map');
8989 });
8990
8991 it('resolves relative to current directory with query', () => {
8992 const base = '../deep/..';
8993 const input = './bar/main.js.map?input';
8994 const resolved = resolve(input, base);
8995 assert.strictEqual(resolved, '../bar/main.js.map?input');
8996 });
8997
8998 it('resolves relative to parent directory', () => {
8999 const base = '../deep/..';
9000 const input = '../bar/main.js.map';
9001 const resolved = resolve(input, base);
9002 assert.strictEqual(resolved, '../../bar/main.js.map');
9003 });
9004
9005 it('resolves relative to parent directory with query', () => {
9006 const base = '../deep/..';
9007 const input = '../bar/main.js.map?input';
9008 const resolved = resolve(input, base);
9009 assert.strictEqual(resolved, '../../bar/main.js.map?input');
9010 });
9011
9012 it('resolves relative to parent multiple directory', () => {
9013 const base = '../deep/..';
9014 const input = '../../../bar/main.js.map';
9015 const resolved = resolve(input, base);
9016 assert.strictEqual(resolved, '../../../../bar/main.js.map');
9017 });
9018
9019 it('resolves relative to parent multiple directory with query 1', () => {
9020 const base = '../deep/..';
9021 const input = '../../../?input';
9022 const resolved = resolve(input, base);
9023 assert.strictEqual(resolved, '../../../..?input');
9024 });
9025
9026 it('resolves relative to parent multiple directory with query 2', () => {
9027 const base = '../deep/..';
9028 const input = '../../..?input';
9029 const resolved = resolve(input, base);
9030 assert.strictEqual(resolved, '../../../..?input');
9031 });
9032
9033 it('normalizes input path', () => {
9034 const base = '../deep/..';
9035 const input = './foo/./bar/../main.js.map';
9036 const resolved = resolve(input, base);
9037 assert.strictEqual(resolved, '../foo/main.js.map');
9038 });
9039 });
9040
9041 describe('with relative path input', () => {
9042 it('resolves relative to current directory', () => {
9043 const base = '../deep/..';
9044 const input = 'bar/main.js.map';
9045 const resolved = resolve(input, base);
9046 assert.strictEqual(resolved, '../bar/main.js.map');
9047 });
9048
9049 it('resolves relative to current directory with query', () => {
9050 const base = '../deep/..';
9051 const input = 'bar/main.js.map?input';
9052 const resolved = resolve(input, base);
9053 assert.strictEqual(resolved, '../bar/main.js.map?input');
9054 });
9055
9056 it('resolves relative to parent multiple directory, later', () => {
9057 const base = '../deep/..';
9058 const input = 'foo/../../../bar/main.js.map';
9059 const resolved = resolve(input, base);
9060 assert.strictEqual(resolved, '../../../bar/main.js.map');
9061 });
9062
9063 it('normalizes input path', () => {
9064 const base = '../deep/..';
9065 const input = 'foo/./bar/../main.js.map';
9066 const resolved = resolve(input, base);
9067 assert.strictEqual(resolved, '../foo/main.js.map');
9068 });
9069
9070 it('resolves node_module scope as path', () => {
9071 const base = '../deep/..';
9072 const input = 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js';
9073 const resolved = resolve(input, base);
9074 assert.strictEqual(resolved, '../node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js');
9075 });
9076
9077 it('resolves package scope as path', () => {
9078 const base = '../deep/..';
9079 const input = '@babel/runtime/helpers/esm/arrayLikeToArray.js';
9080 const resolved = resolve(input, base);
9081 assert.strictEqual(resolved, '../@babel/runtime/helpers/esm/arrayLikeToArray.js');
9082 });
9083 });
9084
9085 describe('with query input', () => {
9086 it('resolves relative to path', () => {
9087 const base = '../deep/..';
9088 const input = '?input';
9089 const resolved = resolve(input, base);
9090 assert.strictEqual(resolved, '..?input');
9091 });
9092 });
9093
9094 describe('with hash input', () => {
9095 it('resolves relative to path', () => {
9096 const base = '../deep/..';
9097 const input = '#input';
9098 const resolved = resolve(input, base);
9099 assert.strictEqual(resolved, '..#input');
9100 });
9101 });
9102
9103 describe('empty input', () => {
9104 it('normalizes base', () => {
9105 const base = '../deep/..';
9106 const input = '';
9107 const resolved = resolve(input, base);
9108 assert.strictEqual(resolved, '..');
9109 });
9110 });
9111 });
9112
9113 describe(`base = "../deep/../"`, () => {
9114 describe('with absolute input', () => {
9115 it('returns input', () => {
9116 const base = '../deep/../';
9117 const input = 'https://absolute.com/main.js.map';
9118 const resolved = resolve(input, base);
9119 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
9120 });
9121
9122 it('returns input with query', () => {
9123 const base = '../deep/../';
9124 const input = 'https://absolute.com/main.js.map?input';
9125 const resolved = resolve(input, base);
9126 assert.strictEqual(resolved, 'https://absolute.com/main.js.map?input');
9127 });
9128
9129 it('normalizes input path', () => {
9130 const base = '../deep/../';
9131 const input = 'https://absolute.com/foo/./bar/../main.js.map';
9132 const resolved = resolve(input, base);
9133 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map');
9134 });
9135
9136 it('normalizes input path with query', () => {
9137 const base = '../deep/../';
9138 const input = 'https://absolute.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
9139 const resolved = resolve(input, base);
9140 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map?input!webpack://foo/./bar');
9141 });
9142
9143 it('normalizes pathless input', () => {
9144 const base = '../deep/../';
9145 const input = 'https://absolute.com';
9146 const resolved = resolve(input, base);
9147 assert.strictEqual(resolved, 'https://absolute.com/');
9148 });
9149
9150 it('normalizes pathless input with query', () => {
9151 const base = '../deep/../';
9152 const input = 'https://absolute.com?input';
9153 const resolved = resolve(input, base);
9154 assert.strictEqual(resolved, 'https://absolute.com/?input');
9155 });
9156
9157 it('normalizes current directory', () => {
9158 const base = '../deep/../';
9159 const input = 'https://absolute.com/./main.js.map';
9160 const resolved = resolve(input, base);
9161 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
9162 });
9163
9164 it('normalizes too many parent accessors', () => {
9165 const base = '../deep/../';
9166 const input = 'https://absolute.com/../../../main.js.map';
9167 const resolved = resolve(input, base);
9168 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
9169 });
9170
9171 it('normalizes too many parent accessors, late', () => {
9172 const base = '../deep/../';
9173 const input = 'https://absolute.com/foo/../../../main.js.map';
9174 const resolved = resolve(input, base);
9175 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
9176 });
9177
9178 it('normalizes file protocol 1', () => {
9179 const base = '../deep/../';
9180 const input = 'file:///root/main.js.map';
9181 const resolved = resolve(input, base);
9182 assert.strictEqual(resolved, 'file:///root/main.js.map');
9183 });
9184
9185 it('normalizes file protocol 2', () => {
9186 const base = '../deep/../';
9187 const input = 'file://root/main.js.map';
9188 const resolved = resolve(input, base);
9189 assert.strictEqual(resolved, 'file://root/main.js.map');
9190 });
9191
9192 it('normalizes file protocol 2.5', () => {
9193 const base = '../deep/../';
9194 const input = 'file://root';
9195 const resolved = resolve(input, base);
9196 assert.strictEqual(resolved, 'file://root/');
9197 });
9198
9199 it('normalizes file protocol 3', () => {
9200 const base = '../deep/../';
9201 const input = 'file:/root/main.js.map';
9202 const resolved = resolve(input, base);
9203 assert.strictEqual(resolved, 'file:///root/main.js.map');
9204 });
9205
9206 it('normalizes file protocol 4', () => {
9207 const base = '../deep/../';
9208 const input = 'file:root/main.js.map';
9209 const resolved = resolve(input, base);
9210 assert.strictEqual(resolved, 'file:///root/main.js.map');
9211 });
9212
9213 it('normalizes file protocol 1 with query', () => {
9214 const base = '../deep/../';
9215 const input = 'file:///root/main.js.map?input';
9216 const resolved = resolve(input, base);
9217 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
9218 });
9219
9220 it('normalizes file protocol 2 with query', () => {
9221 const base = '../deep/../';
9222 const input = 'file://root/main.js.map?input';
9223 const resolved = resolve(input, base);
9224 assert.strictEqual(resolved, 'file://root/main.js.map?input');
9225 });
9226
9227 it('normalizes file protocol 2.5 with query', () => {
9228 const base = '../deep/../';
9229 const input = 'file://root?input';
9230 const resolved = resolve(input, base);
9231 assert.strictEqual(resolved, 'file://root/?input');
9232 });
9233
9234 it('normalizes file protocol 3 with query', () => {
9235 const base = '../deep/../';
9236 const input = 'file:/root/main.js.map?input';
9237 const resolved = resolve(input, base);
9238 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
9239 });
9240
9241 it('normalizes file protocol 4 with query', () => {
9242 const base = '../deep/../';
9243 const input = 'file:root/main.js.map?input';
9244 const resolved = resolve(input, base);
9245 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
9246 });
9247 });
9248
9249 describe('with protocol relative input', () => {
9250 it('resolves relative to the base protocol', () => {
9251 const base = '../deep/../';
9252 const input = '//protocol-relative.com/main.js.map';
9253 const resolved = resolve(input, base);
9254 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
9255 });
9256
9257 it('resolves relative to the base protocol with query', () => {
9258 const base = '../deep/../';
9259 const input = '//protocol-relative.com/main.js.map?input';
9260 const resolved = resolve(input, base);
9261 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map?input');
9262 });
9263
9264 it('normalizes input path', () => {
9265 const base = '../deep/../';
9266 const input = '//protocol-relative.com/foo/./bar/../main.js.map';
9267 const resolved = resolve(input, base);
9268 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map');
9269 });
9270
9271 it('normalizes input path with query', () => {
9272 const base = '../deep/../';
9273 const input = '//protocol-relative.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
9274 const resolved = resolve(input, base);
9275 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map?input!webpack://foo/./bar');
9276 });
9277
9278 it('normalizes pathless input', () => {
9279 const base = '../deep/../';
9280 const input = '//protocol-relative.com';
9281 const resolved = resolve(input, base);
9282 assert.strictEqual(resolved, '//protocol-relative.com/');
9283 });
9284
9285 it('normalizes pathless input with query', () => {
9286 const base = '../deep/../';
9287 const input = '//protocol-relative.com?input';
9288 const resolved = resolve(input, base);
9289 assert.strictEqual(resolved, '//protocol-relative.com/?input');
9290 });
9291
9292 it('normalizes current directory', () => {
9293 const base = '../deep/../';
9294 const input = '//protocol-relative.com/./main.js.map';
9295 const resolved = resolve(input, base);
9296 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
9297 });
9298
9299 it('normalizes too many parent accessors', () => {
9300 const base = '../deep/../';
9301 const input = '//protocol-relative.com/../main.js.map';
9302 const resolved = resolve(input, base);
9303 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
9304 });
9305
9306 it('normalizes too many parent accessors, late', () => {
9307 const base = '../deep/../';
9308 const input = '//protocol-relative.com/foo/../../main.js.map';
9309 const resolved = resolve(input, base);
9310 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
9311 });
9312 });
9313
9314 describe('with absolute path input', () => {
9315 it('remains absolute path', () => {
9316 const base = '../deep/../';
9317 const input = '/assets/main.js.map';
9318 const resolved = resolve(input, base);
9319 assert.strictEqual(resolved, '/assets/main.js.map');
9320 });
9321
9322 it('remains absolute path with query', () => {
9323 const base = '../deep/../';
9324 const input = '/assets/main.js.map?input';
9325 const resolved = resolve(input, base);
9326 assert.strictEqual(resolved, '/assets/main.js.map?input');
9327 });
9328
9329 it('trims to root', () => {
9330 const base = '../deep/../';
9331 const input = '/';
9332 const resolved = resolve(input, base);
9333 assert.strictEqual(resolved, '/');
9334 });
9335
9336 it('normalizes input path', () => {
9337 const base = '../deep/../';
9338 const input = '/foo/./bar/../main.js.map';
9339 const resolved = resolve(input, base);
9340 assert.strictEqual(resolved, '/foo/main.js.map');
9341 });
9342
9343 it('normalizes current directory', () => {
9344 const base = '../deep/../';
9345 const input = '/./main.js.map';
9346 const resolved = resolve(input, base);
9347 assert.strictEqual(resolved, '/main.js.map');
9348 });
9349
9350 it('normalizes too many parent accessors', () => {
9351 const base = '../deep/../';
9352 const input = '/../../../main.js.map';
9353 const resolved = resolve(input, base);
9354 assert.strictEqual(resolved, '/main.js.map');
9355 });
9356
9357 it('normalizes too many parent accessors with query 1', () => {
9358 const base = '../deep/../';
9359 const input = '/../../../?input';
9360 const resolved = resolve(input, base);
9361 assert.strictEqual(resolved, '/?input');
9362 });
9363
9364 it('normalizes too many parent accessors with query 2', () => {
9365 const base = '../deep/../';
9366 const input = '/../../..?input';
9367 const resolved = resolve(input, base);
9368 assert.strictEqual(resolved, '/?input');
9369 });
9370
9371 it('normalizes too many parent accessors, late', () => {
9372 const base = '../deep/../';
9373 const input = '/foo/../../../main.js.map';
9374 const resolved = resolve(input, base);
9375 assert.strictEqual(resolved, '/main.js.map');
9376 });
9377 });
9378
9379 describe('with leading dot relative input', () => {
9380 it('resolves relative to current directory', () => {
9381 const base = '../deep/../';
9382 const input = './bar/main.js.map';
9383 const resolved = resolve(input, base);
9384 assert.strictEqual(resolved, '../bar/main.js.map');
9385 });
9386
9387 it('resolves relative to current directory with query', () => {
9388 const base = '../deep/../';
9389 const input = './bar/main.js.map?input';
9390 const resolved = resolve(input, base);
9391 assert.strictEqual(resolved, '../bar/main.js.map?input');
9392 });
9393
9394 it('resolves relative to parent directory', () => {
9395 const base = '../deep/../';
9396 const input = '../bar/main.js.map';
9397 const resolved = resolve(input, base);
9398 assert.strictEqual(resolved, '../../bar/main.js.map');
9399 });
9400
9401 it('resolves relative to parent directory with query', () => {
9402 const base = '../deep/../';
9403 const input = '../bar/main.js.map?input';
9404 const resolved = resolve(input, base);
9405 assert.strictEqual(resolved, '../../bar/main.js.map?input');
9406 });
9407
9408 it('resolves relative to parent multiple directory', () => {
9409 const base = '../deep/../';
9410 const input = '../../../bar/main.js.map';
9411 const resolved = resolve(input, base);
9412 assert.strictEqual(resolved, '../../../../bar/main.js.map');
9413 });
9414
9415 it('resolves relative to parent multiple directory with query 1', () => {
9416 const base = '../deep/../';
9417 const input = '../../../?input';
9418 const resolved = resolve(input, base);
9419 assert.strictEqual(resolved, '../../../..?input');
9420 });
9421
9422 it('resolves relative to parent multiple directory with query 2', () => {
9423 const base = '../deep/../';
9424 const input = '../../..?input';
9425 const resolved = resolve(input, base);
9426 assert.strictEqual(resolved, '../../../..?input');
9427 });
9428
9429 it('normalizes input path', () => {
9430 const base = '../deep/../';
9431 const input = './foo/./bar/../main.js.map';
9432 const resolved = resolve(input, base);
9433 assert.strictEqual(resolved, '../foo/main.js.map');
9434 });
9435 });
9436
9437 describe('with relative path input', () => {
9438 it('resolves relative to current directory', () => {
9439 const base = '../deep/../';
9440 const input = 'bar/main.js.map';
9441 const resolved = resolve(input, base);
9442 assert.strictEqual(resolved, '../bar/main.js.map');
9443 });
9444
9445 it('resolves relative to current directory with query', () => {
9446 const base = '../deep/../';
9447 const input = 'bar/main.js.map?input';
9448 const resolved = resolve(input, base);
9449 assert.strictEqual(resolved, '../bar/main.js.map?input');
9450 });
9451
9452 it('resolves relative to parent multiple directory, later', () => {
9453 const base = '../deep/../';
9454 const input = 'foo/../../../bar/main.js.map';
9455 const resolved = resolve(input, base);
9456 assert.strictEqual(resolved, '../../../bar/main.js.map');
9457 });
9458
9459 it('normalizes input path', () => {
9460 const base = '../deep/../';
9461 const input = 'foo/./bar/../main.js.map';
9462 const resolved = resolve(input, base);
9463 assert.strictEqual(resolved, '../foo/main.js.map');
9464 });
9465
9466 it('resolves node_module scope as path', () => {
9467 const base = '../deep/../';
9468 const input = 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js';
9469 const resolved = resolve(input, base);
9470 assert.strictEqual(resolved, '../node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js');
9471 });
9472
9473 it('resolves package scope as path', () => {
9474 const base = '../deep/../';
9475 const input = '@babel/runtime/helpers/esm/arrayLikeToArray.js';
9476 const resolved = resolve(input, base);
9477 assert.strictEqual(resolved, '../@babel/runtime/helpers/esm/arrayLikeToArray.js');
9478 });
9479 });
9480
9481 describe('with query input', () => {
9482 it('resolves relative to path', () => {
9483 const base = '../deep/../';
9484 const input = '?input';
9485 const resolved = resolve(input, base);
9486 assert.strictEqual(resolved, '..?input');
9487 });
9488 });
9489
9490 describe('with hash input', () => {
9491 it('resolves relative to path', () => {
9492 const base = '../deep/../';
9493 const input = '#input';
9494 const resolved = resolve(input, base);
9495 assert.strictEqual(resolved, '..#input');
9496 });
9497 });
9498
9499 describe('empty input', () => {
9500 it('normalizes base', () => {
9501 const base = '../deep/../';
9502 const input = '';
9503 const resolved = resolve(input, base);
9504 assert.strictEqual(resolved, '..');
9505 });
9506 });
9507 });
9508
9509 describe(`base = "file?baseQuery"`, () => {
9510 describe('with absolute input', () => {
9511 it('returns input', () => {
9512 const base = 'file?baseQuery';
9513 const input = 'https://absolute.com/main.js.map';
9514 const resolved = resolve(input, base);
9515 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
9516 });
9517
9518 it('returns input with query', () => {
9519 const base = 'file?baseQuery';
9520 const input = 'https://absolute.com/main.js.map?input';
9521 const resolved = resolve(input, base);
9522 assert.strictEqual(resolved, 'https://absolute.com/main.js.map?input');
9523 });
9524
9525 it('normalizes input path', () => {
9526 const base = 'file?baseQuery';
9527 const input = 'https://absolute.com/foo/./bar/../main.js.map';
9528 const resolved = resolve(input, base);
9529 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map');
9530 });
9531
9532 it('normalizes input path with query', () => {
9533 const base = 'file?baseQuery';
9534 const input = 'https://absolute.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
9535 const resolved = resolve(input, base);
9536 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map?input!webpack://foo/./bar');
9537 });
9538
9539 it('normalizes pathless input', () => {
9540 const base = 'file?baseQuery';
9541 const input = 'https://absolute.com';
9542 const resolved = resolve(input, base);
9543 assert.strictEqual(resolved, 'https://absolute.com/');
9544 });
9545
9546 it('normalizes pathless input with query', () => {
9547 const base = 'file?baseQuery';
9548 const input = 'https://absolute.com?input';
9549 const resolved = resolve(input, base);
9550 assert.strictEqual(resolved, 'https://absolute.com/?input');
9551 });
9552
9553 it('normalizes current directory', () => {
9554 const base = 'file?baseQuery';
9555 const input = 'https://absolute.com/./main.js.map';
9556 const resolved = resolve(input, base);
9557 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
9558 });
9559
9560 it('normalizes too many parent accessors', () => {
9561 const base = 'file?baseQuery';
9562 const input = 'https://absolute.com/../../../main.js.map';
9563 const resolved = resolve(input, base);
9564 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
9565 });
9566
9567 it('normalizes too many parent accessors, late', () => {
9568 const base = 'file?baseQuery';
9569 const input = 'https://absolute.com/foo/../../../main.js.map';
9570 const resolved = resolve(input, base);
9571 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
9572 });
9573
9574 it('normalizes file protocol 1', () => {
9575 const base = 'file?baseQuery';
9576 const input = 'file:///root/main.js.map';
9577 const resolved = resolve(input, base);
9578 assert.strictEqual(resolved, 'file:///root/main.js.map');
9579 });
9580
9581 it('normalizes file protocol 2', () => {
9582 const base = 'file?baseQuery';
9583 const input = 'file://root/main.js.map';
9584 const resolved = resolve(input, base);
9585 assert.strictEqual(resolved, 'file://root/main.js.map');
9586 });
9587
9588 it('normalizes file protocol 2.5', () => {
9589 const base = 'file?baseQuery';
9590 const input = 'file://root';
9591 const resolved = resolve(input, base);
9592 assert.strictEqual(resolved, 'file://root/');
9593 });
9594
9595 it('normalizes file protocol 3', () => {
9596 const base = 'file?baseQuery';
9597 const input = 'file:/root/main.js.map';
9598 const resolved = resolve(input, base);
9599 assert.strictEqual(resolved, 'file:///root/main.js.map');
9600 });
9601
9602 it('normalizes file protocol 4', () => {
9603 const base = 'file?baseQuery';
9604 const input = 'file:root/main.js.map';
9605 const resolved = resolve(input, base);
9606 assert.strictEqual(resolved, 'file:///root/main.js.map');
9607 });
9608
9609 it('normalizes file protocol 1 with query', () => {
9610 const base = 'file?baseQuery';
9611 const input = 'file:///root/main.js.map?input';
9612 const resolved = resolve(input, base);
9613 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
9614 });
9615
9616 it('normalizes file protocol 2 with query', () => {
9617 const base = 'file?baseQuery';
9618 const input = 'file://root/main.js.map?input';
9619 const resolved = resolve(input, base);
9620 assert.strictEqual(resolved, 'file://root/main.js.map?input');
9621 });
9622
9623 it('normalizes file protocol 2.5 with query', () => {
9624 const base = 'file?baseQuery';
9625 const input = 'file://root?input';
9626 const resolved = resolve(input, base);
9627 assert.strictEqual(resolved, 'file://root/?input');
9628 });
9629
9630 it('normalizes file protocol 3 with query', () => {
9631 const base = 'file?baseQuery';
9632 const input = 'file:/root/main.js.map?input';
9633 const resolved = resolve(input, base);
9634 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
9635 });
9636
9637 it('normalizes file protocol 4 with query', () => {
9638 const base = 'file?baseQuery';
9639 const input = 'file:root/main.js.map?input';
9640 const resolved = resolve(input, base);
9641 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
9642 });
9643 });
9644
9645 describe('with protocol relative input', () => {
9646 it('resolves relative to the base protocol', () => {
9647 const base = 'file?baseQuery';
9648 const input = '//protocol-relative.com/main.js.map';
9649 const resolved = resolve(input, base);
9650 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
9651 });
9652
9653 it('resolves relative to the base protocol with query', () => {
9654 const base = 'file?baseQuery';
9655 const input = '//protocol-relative.com/main.js.map?input';
9656 const resolved = resolve(input, base);
9657 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map?input');
9658 });
9659
9660 it('normalizes input path', () => {
9661 const base = 'file?baseQuery';
9662 const input = '//protocol-relative.com/foo/./bar/../main.js.map';
9663 const resolved = resolve(input, base);
9664 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map');
9665 });
9666
9667 it('normalizes input path with query', () => {
9668 const base = 'file?baseQuery';
9669 const input = '//protocol-relative.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
9670 const resolved = resolve(input, base);
9671 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map?input!webpack://foo/./bar');
9672 });
9673
9674 it('normalizes pathless input', () => {
9675 const base = 'file?baseQuery';
9676 const input = '//protocol-relative.com';
9677 const resolved = resolve(input, base);
9678 assert.strictEqual(resolved, '//protocol-relative.com/');
9679 });
9680
9681 it('normalizes pathless input with query', () => {
9682 const base = 'file?baseQuery';
9683 const input = '//protocol-relative.com?input';
9684 const resolved = resolve(input, base);
9685 assert.strictEqual(resolved, '//protocol-relative.com/?input');
9686 });
9687
9688 it('normalizes current directory', () => {
9689 const base = 'file?baseQuery';
9690 const input = '//protocol-relative.com/./main.js.map';
9691 const resolved = resolve(input, base);
9692 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
9693 });
9694
9695 it('normalizes too many parent accessors', () => {
9696 const base = 'file?baseQuery';
9697 const input = '//protocol-relative.com/../main.js.map';
9698 const resolved = resolve(input, base);
9699 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
9700 });
9701
9702 it('normalizes too many parent accessors, late', () => {
9703 const base = 'file?baseQuery';
9704 const input = '//protocol-relative.com/foo/../../main.js.map';
9705 const resolved = resolve(input, base);
9706 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
9707 });
9708 });
9709
9710 describe('with absolute path input', () => {
9711 it('remains absolute path', () => {
9712 const base = 'file?baseQuery';
9713 const input = '/assets/main.js.map';
9714 const resolved = resolve(input, base);
9715 assert.strictEqual(resolved, '/assets/main.js.map');
9716 });
9717
9718 it('remains absolute path with query', () => {
9719 const base = 'file?baseQuery';
9720 const input = '/assets/main.js.map?input';
9721 const resolved = resolve(input, base);
9722 assert.strictEqual(resolved, '/assets/main.js.map?input');
9723 });
9724
9725 it('trims to root', () => {
9726 const base = 'file?baseQuery';
9727 const input = '/';
9728 const resolved = resolve(input, base);
9729 assert.strictEqual(resolved, '/');
9730 });
9731
9732 it('normalizes input path', () => {
9733 const base = 'file?baseQuery';
9734 const input = '/foo/./bar/../main.js.map';
9735 const resolved = resolve(input, base);
9736 assert.strictEqual(resolved, '/foo/main.js.map');
9737 });
9738
9739 it('normalizes current directory', () => {
9740 const base = 'file?baseQuery';
9741 const input = '/./main.js.map';
9742 const resolved = resolve(input, base);
9743 assert.strictEqual(resolved, '/main.js.map');
9744 });
9745
9746 it('normalizes too many parent accessors', () => {
9747 const base = 'file?baseQuery';
9748 const input = '/../../../main.js.map';
9749 const resolved = resolve(input, base);
9750 assert.strictEqual(resolved, '/main.js.map');
9751 });
9752
9753 it('normalizes too many parent accessors with query 1', () => {
9754 const base = 'file?baseQuery';
9755 const input = '/../../../?input';
9756 const resolved = resolve(input, base);
9757 assert.strictEqual(resolved, '/?input');
9758 });
9759
9760 it('normalizes too many parent accessors with query 2', () => {
9761 const base = 'file?baseQuery';
9762 const input = '/../../..?input';
9763 const resolved = resolve(input, base);
9764 assert.strictEqual(resolved, '/?input');
9765 });
9766
9767 it('normalizes too many parent accessors, late', () => {
9768 const base = 'file?baseQuery';
9769 const input = '/foo/../../../main.js.map';
9770 const resolved = resolve(input, base);
9771 assert.strictEqual(resolved, '/main.js.map');
9772 });
9773 });
9774
9775 describe('with leading dot relative input', () => {
9776 it('resolves relative to current directory', () => {
9777 const base = 'file?baseQuery';
9778 const input = './bar/main.js.map';
9779 const resolved = resolve(input, base);
9780 assert.strictEqual(resolved, 'bar/main.js.map');
9781 });
9782
9783 it('resolves relative to current directory with query', () => {
9784 const base = 'file?baseQuery';
9785 const input = './bar/main.js.map?input';
9786 const resolved = resolve(input, base);
9787 assert.strictEqual(resolved, 'bar/main.js.map?input');
9788 });
9789
9790 it('resolves relative to parent directory', () => {
9791 const base = 'file?baseQuery';
9792 const input = '../bar/main.js.map';
9793 const resolved = resolve(input, base);
9794 assert.strictEqual(resolved, '../bar/main.js.map');
9795 });
9796
9797 it('resolves relative to parent directory with query', () => {
9798 const base = 'file?baseQuery';
9799 const input = '../bar/main.js.map?input';
9800 const resolved = resolve(input, base);
9801 assert.strictEqual(resolved, '../bar/main.js.map?input');
9802 });
9803
9804 it('resolves relative to parent multiple directory', () => {
9805 const base = 'file?baseQuery';
9806 const input = '../../../bar/main.js.map';
9807 const resolved = resolve(input, base);
9808 assert.strictEqual(resolved, '../../../bar/main.js.map');
9809 });
9810
9811 it('resolves relative to parent multiple directory with query 1', () => {
9812 const base = 'file?baseQuery';
9813 const input = '../../../?input';
9814 const resolved = resolve(input, base);
9815 assert.strictEqual(resolved, '../../..?input');
9816 });
9817
9818 it('resolves relative to parent multiple directory with query 2', () => {
9819 const base = 'file?baseQuery';
9820 const input = '../../..?input';
9821 const resolved = resolve(input, base);
9822 assert.strictEqual(resolved, '../../..?input');
9823 });
9824
9825 it('normalizes input path', () => {
9826 const base = 'file?baseQuery';
9827 const input = './foo/./bar/../main.js.map';
9828 const resolved = resolve(input, base);
9829 assert.strictEqual(resolved, 'foo/main.js.map');
9830 });
9831 });
9832
9833 describe('with relative path input', () => {
9834 it('resolves relative to current directory', () => {
9835 const base = 'file?baseQuery';
9836 const input = 'bar/main.js.map';
9837 const resolved = resolve(input, base);
9838 assert.strictEqual(resolved, 'bar/main.js.map');
9839 });
9840
9841 it('resolves relative to current directory with query', () => {
9842 const base = 'file?baseQuery';
9843 const input = 'bar/main.js.map?input';
9844 const resolved = resolve(input, base);
9845 assert.strictEqual(resolved, 'bar/main.js.map?input');
9846 });
9847
9848 it('resolves relative to parent multiple directory, later', () => {
9849 const base = 'file?baseQuery';
9850 const input = 'foo/../../../bar/main.js.map';
9851 const resolved = resolve(input, base);
9852 assert.strictEqual(resolved, '../../bar/main.js.map');
9853 });
9854
9855 it('normalizes input path', () => {
9856 const base = 'file?baseQuery';
9857 const input = 'foo/./bar/../main.js.map';
9858 const resolved = resolve(input, base);
9859 assert.strictEqual(resolved, 'foo/main.js.map');
9860 });
9861
9862 it('resolves node_module scope as path', () => {
9863 const base = 'file?baseQuery';
9864 const input = 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js';
9865 const resolved = resolve(input, base);
9866 assert.strictEqual(resolved, 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js');
9867 });
9868
9869 it('resolves package scope as path', () => {
9870 const base = 'file?baseQuery';
9871 const input = '@babel/runtime/helpers/esm/arrayLikeToArray.js';
9872 const resolved = resolve(input, base);
9873 assert.strictEqual(resolved, '@babel/runtime/helpers/esm/arrayLikeToArray.js');
9874 });
9875 });
9876
9877 describe('with query input', () => {
9878 it('resolves relative to path', () => {
9879 const base = 'file?baseQuery';
9880 const input = '?input';
9881 const resolved = resolve(input, base);
9882 assert.strictEqual(resolved, 'file?input');
9883 });
9884 });
9885
9886 describe('with hash input', () => {
9887 it('resolves relative to path', () => {
9888 const base = 'file?baseQuery';
9889 const input = '#input';
9890 const resolved = resolve(input, base);
9891 assert.strictEqual(resolved, 'file?baseQuery#input');
9892 });
9893 });
9894
9895 describe('empty input', () => {
9896 it('normalizes base', () => {
9897 const base = 'file?baseQuery';
9898 const input = '';
9899 const resolved = resolve(input, base);
9900 assert.strictEqual(resolved, 'file?baseQuery');
9901 });
9902 });
9903 });
9904
9905 describe(`base = "file?baseQuery#baseHash"`, () => {
9906 describe('with absolute input', () => {
9907 it('returns input', () => {
9908 const base = 'file?baseQuery#baseHash';
9909 const input = 'https://absolute.com/main.js.map';
9910 const resolved = resolve(input, base);
9911 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
9912 });
9913
9914 it('returns input with query', () => {
9915 const base = 'file?baseQuery#baseHash';
9916 const input = 'https://absolute.com/main.js.map?input';
9917 const resolved = resolve(input, base);
9918 assert.strictEqual(resolved, 'https://absolute.com/main.js.map?input');
9919 });
9920
9921 it('normalizes input path', () => {
9922 const base = 'file?baseQuery#baseHash';
9923 const input = 'https://absolute.com/foo/./bar/../main.js.map';
9924 const resolved = resolve(input, base);
9925 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map');
9926 });
9927
9928 it('normalizes input path with query', () => {
9929 const base = 'file?baseQuery#baseHash';
9930 const input = 'https://absolute.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
9931 const resolved = resolve(input, base);
9932 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map?input!webpack://foo/./bar');
9933 });
9934
9935 it('normalizes pathless input', () => {
9936 const base = 'file?baseQuery#baseHash';
9937 const input = 'https://absolute.com';
9938 const resolved = resolve(input, base);
9939 assert.strictEqual(resolved, 'https://absolute.com/');
9940 });
9941
9942 it('normalizes pathless input with query', () => {
9943 const base = 'file?baseQuery#baseHash';
9944 const input = 'https://absolute.com?input';
9945 const resolved = resolve(input, base);
9946 assert.strictEqual(resolved, 'https://absolute.com/?input');
9947 });
9948
9949 it('normalizes current directory', () => {
9950 const base = 'file?baseQuery#baseHash';
9951 const input = 'https://absolute.com/./main.js.map';
9952 const resolved = resolve(input, base);
9953 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
9954 });
9955
9956 it('normalizes too many parent accessors', () => {
9957 const base = 'file?baseQuery#baseHash';
9958 const input = 'https://absolute.com/../../../main.js.map';
9959 const resolved = resolve(input, base);
9960 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
9961 });
9962
9963 it('normalizes too many parent accessors, late', () => {
9964 const base = 'file?baseQuery#baseHash';
9965 const input = 'https://absolute.com/foo/../../../main.js.map';
9966 const resolved = resolve(input, base);
9967 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
9968 });
9969
9970 it('normalizes file protocol 1', () => {
9971 const base = 'file?baseQuery#baseHash';
9972 const input = 'file:///root/main.js.map';
9973 const resolved = resolve(input, base);
9974 assert.strictEqual(resolved, 'file:///root/main.js.map');
9975 });
9976
9977 it('normalizes file protocol 2', () => {
9978 const base = 'file?baseQuery#baseHash';
9979 const input = 'file://root/main.js.map';
9980 const resolved = resolve(input, base);
9981 assert.strictEqual(resolved, 'file://root/main.js.map');
9982 });
9983
9984 it('normalizes file protocol 2.5', () => {
9985 const base = 'file?baseQuery#baseHash';
9986 const input = 'file://root';
9987 const resolved = resolve(input, base);
9988 assert.strictEqual(resolved, 'file://root/');
9989 });
9990
9991 it('normalizes file protocol 3', () => {
9992 const base = 'file?baseQuery#baseHash';
9993 const input = 'file:/root/main.js.map';
9994 const resolved = resolve(input, base);
9995 assert.strictEqual(resolved, 'file:///root/main.js.map');
9996 });
9997
9998 it('normalizes file protocol 4', () => {
9999 const base = 'file?baseQuery#baseHash';
10000 const input = 'file:root/main.js.map';
10001 const resolved = resolve(input, base);
10002 assert.strictEqual(resolved, 'file:///root/main.js.map');
10003 });
10004
10005 it('normalizes file protocol 1 with query', () => {
10006 const base = 'file?baseQuery#baseHash';
10007 const input = 'file:///root/main.js.map?input';
10008 const resolved = resolve(input, base);
10009 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
10010 });
10011
10012 it('normalizes file protocol 2 with query', () => {
10013 const base = 'file?baseQuery#baseHash';
10014 const input = 'file://root/main.js.map?input';
10015 const resolved = resolve(input, base);
10016 assert.strictEqual(resolved, 'file://root/main.js.map?input');
10017 });
10018
10019 it('normalizes file protocol 2.5 with query', () => {
10020 const base = 'file?baseQuery#baseHash';
10021 const input = 'file://root?input';
10022 const resolved = resolve(input, base);
10023 assert.strictEqual(resolved, 'file://root/?input');
10024 });
10025
10026 it('normalizes file protocol 3 with query', () => {
10027 const base = 'file?baseQuery#baseHash';
10028 const input = 'file:/root/main.js.map?input';
10029 const resolved = resolve(input, base);
10030 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
10031 });
10032
10033 it('normalizes file protocol 4 with query', () => {
10034 const base = 'file?baseQuery#baseHash';
10035 const input = 'file:root/main.js.map?input';
10036 const resolved = resolve(input, base);
10037 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
10038 });
10039 });
10040
10041 describe('with protocol relative input', () => {
10042 it('resolves relative to the base protocol', () => {
10043 const base = 'file?baseQuery#baseHash';
10044 const input = '//protocol-relative.com/main.js.map';
10045 const resolved = resolve(input, base);
10046 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
10047 });
10048
10049 it('resolves relative to the base protocol with query', () => {
10050 const base = 'file?baseQuery#baseHash';
10051 const input = '//protocol-relative.com/main.js.map?input';
10052 const resolved = resolve(input, base);
10053 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map?input');
10054 });
10055
10056 it('normalizes input path', () => {
10057 const base = 'file?baseQuery#baseHash';
10058 const input = '//protocol-relative.com/foo/./bar/../main.js.map';
10059 const resolved = resolve(input, base);
10060 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map');
10061 });
10062
10063 it('normalizes input path with query', () => {
10064 const base = 'file?baseQuery#baseHash';
10065 const input = '//protocol-relative.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
10066 const resolved = resolve(input, base);
10067 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map?input!webpack://foo/./bar');
10068 });
10069
10070 it('normalizes pathless input', () => {
10071 const base = 'file?baseQuery#baseHash';
10072 const input = '//protocol-relative.com';
10073 const resolved = resolve(input, base);
10074 assert.strictEqual(resolved, '//protocol-relative.com/');
10075 });
10076
10077 it('normalizes pathless input with query', () => {
10078 const base = 'file?baseQuery#baseHash';
10079 const input = '//protocol-relative.com?input';
10080 const resolved = resolve(input, base);
10081 assert.strictEqual(resolved, '//protocol-relative.com/?input');
10082 });
10083
10084 it('normalizes current directory', () => {
10085 const base = 'file?baseQuery#baseHash';
10086 const input = '//protocol-relative.com/./main.js.map';
10087 const resolved = resolve(input, base);
10088 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
10089 });
10090
10091 it('normalizes too many parent accessors', () => {
10092 const base = 'file?baseQuery#baseHash';
10093 const input = '//protocol-relative.com/../main.js.map';
10094 const resolved = resolve(input, base);
10095 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
10096 });
10097
10098 it('normalizes too many parent accessors, late', () => {
10099 const base = 'file?baseQuery#baseHash';
10100 const input = '//protocol-relative.com/foo/../../main.js.map';
10101 const resolved = resolve(input, base);
10102 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
10103 });
10104 });
10105
10106 describe('with absolute path input', () => {
10107 it('remains absolute path', () => {
10108 const base = 'file?baseQuery#baseHash';
10109 const input = '/assets/main.js.map';
10110 const resolved = resolve(input, base);
10111 assert.strictEqual(resolved, '/assets/main.js.map');
10112 });
10113
10114 it('remains absolute path with query', () => {
10115 const base = 'file?baseQuery#baseHash';
10116 const input = '/assets/main.js.map?input';
10117 const resolved = resolve(input, base);
10118 assert.strictEqual(resolved, '/assets/main.js.map?input');
10119 });
10120
10121 it('trims to root', () => {
10122 const base = 'file?baseQuery#baseHash';
10123 const input = '/';
10124 const resolved = resolve(input, base);
10125 assert.strictEqual(resolved, '/');
10126 });
10127
10128 it('normalizes input path', () => {
10129 const base = 'file?baseQuery#baseHash';
10130 const input = '/foo/./bar/../main.js.map';
10131 const resolved = resolve(input, base);
10132 assert.strictEqual(resolved, '/foo/main.js.map');
10133 });
10134
10135 it('normalizes current directory', () => {
10136 const base = 'file?baseQuery#baseHash';
10137 const input = '/./main.js.map';
10138 const resolved = resolve(input, base);
10139 assert.strictEqual(resolved, '/main.js.map');
10140 });
10141
10142 it('normalizes too many parent accessors', () => {
10143 const base = 'file?baseQuery#baseHash';
10144 const input = '/../../../main.js.map';
10145 const resolved = resolve(input, base);
10146 assert.strictEqual(resolved, '/main.js.map');
10147 });
10148
10149 it('normalizes too many parent accessors with query 1', () => {
10150 const base = 'file?baseQuery#baseHash';
10151 const input = '/../../../?input';
10152 const resolved = resolve(input, base);
10153 assert.strictEqual(resolved, '/?input');
10154 });
10155
10156 it('normalizes too many parent accessors with query 2', () => {
10157 const base = 'file?baseQuery#baseHash';
10158 const input = '/../../..?input';
10159 const resolved = resolve(input, base);
10160 assert.strictEqual(resolved, '/?input');
10161 });
10162
10163 it('normalizes too many parent accessors, late', () => {
10164 const base = 'file?baseQuery#baseHash';
10165 const input = '/foo/../../../main.js.map';
10166 const resolved = resolve(input, base);
10167 assert.strictEqual(resolved, '/main.js.map');
10168 });
10169 });
10170
10171 describe('with leading dot relative input', () => {
10172 it('resolves relative to current directory', () => {
10173 const base = 'file?baseQuery#baseHash';
10174 const input = './bar/main.js.map';
10175 const resolved = resolve(input, base);
10176 assert.strictEqual(resolved, 'bar/main.js.map');
10177 });
10178
10179 it('resolves relative to current directory with query', () => {
10180 const base = 'file?baseQuery#baseHash';
10181 const input = './bar/main.js.map?input';
10182 const resolved = resolve(input, base);
10183 assert.strictEqual(resolved, 'bar/main.js.map?input');
10184 });
10185
10186 it('resolves relative to parent directory', () => {
10187 const base = 'file?baseQuery#baseHash';
10188 const input = '../bar/main.js.map';
10189 const resolved = resolve(input, base);
10190 assert.strictEqual(resolved, '../bar/main.js.map');
10191 });
10192
10193 it('resolves relative to parent directory with query', () => {
10194 const base = 'file?baseQuery#baseHash';
10195 const input = '../bar/main.js.map?input';
10196 const resolved = resolve(input, base);
10197 assert.strictEqual(resolved, '../bar/main.js.map?input');
10198 });
10199
10200 it('resolves relative to parent multiple directory', () => {
10201 const base = 'file?baseQuery#baseHash';
10202 const input = '../../../bar/main.js.map';
10203 const resolved = resolve(input, base);
10204 assert.strictEqual(resolved, '../../../bar/main.js.map');
10205 });
10206
10207 it('resolves relative to parent multiple directory with query 1', () => {
10208 const base = 'file?baseQuery#baseHash';
10209 const input = '../../../?input';
10210 const resolved = resolve(input, base);
10211 assert.strictEqual(resolved, '../../..?input');
10212 });
10213
10214 it('resolves relative to parent multiple directory with query 2', () => {
10215 const base = 'file?baseQuery#baseHash';
10216 const input = '../../..?input';
10217 const resolved = resolve(input, base);
10218 assert.strictEqual(resolved, '../../..?input');
10219 });
10220
10221 it('normalizes input path', () => {
10222 const base = 'file?baseQuery#baseHash';
10223 const input = './foo/./bar/../main.js.map';
10224 const resolved = resolve(input, base);
10225 assert.strictEqual(resolved, 'foo/main.js.map');
10226 });
10227 });
10228
10229 describe('with relative path input', () => {
10230 it('resolves relative to current directory', () => {
10231 const base = 'file?baseQuery#baseHash';
10232 const input = 'bar/main.js.map';
10233 const resolved = resolve(input, base);
10234 assert.strictEqual(resolved, 'bar/main.js.map');
10235 });
10236
10237 it('resolves relative to current directory with query', () => {
10238 const base = 'file?baseQuery#baseHash';
10239 const input = 'bar/main.js.map?input';
10240 const resolved = resolve(input, base);
10241 assert.strictEqual(resolved, 'bar/main.js.map?input');
10242 });
10243
10244 it('resolves relative to parent multiple directory, later', () => {
10245 const base = 'file?baseQuery#baseHash';
10246 const input = 'foo/../../../bar/main.js.map';
10247 const resolved = resolve(input, base);
10248 assert.strictEqual(resolved, '../../bar/main.js.map');
10249 });
10250
10251 it('normalizes input path', () => {
10252 const base = 'file?baseQuery#baseHash';
10253 const input = 'foo/./bar/../main.js.map';
10254 const resolved = resolve(input, base);
10255 assert.strictEqual(resolved, 'foo/main.js.map');
10256 });
10257
10258 it('resolves node_module scope as path', () => {
10259 const base = 'file?baseQuery#baseHash';
10260 const input = 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js';
10261 const resolved = resolve(input, base);
10262 assert.strictEqual(resolved, 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js');
10263 });
10264
10265 it('resolves package scope as path', () => {
10266 const base = 'file?baseQuery#baseHash';
10267 const input = '@babel/runtime/helpers/esm/arrayLikeToArray.js';
10268 const resolved = resolve(input, base);
10269 assert.strictEqual(resolved, '@babel/runtime/helpers/esm/arrayLikeToArray.js');
10270 });
10271 });
10272
10273 describe('with query input', () => {
10274 it('resolves relative to path', () => {
10275 const base = 'file?baseQuery#baseHash';
10276 const input = '?input';
10277 const resolved = resolve(input, base);
10278 assert.strictEqual(resolved, 'file?input');
10279 });
10280 });
10281
10282 describe('with hash input', () => {
10283 it('resolves relative to path', () => {
10284 const base = 'file?baseQuery#baseHash';
10285 const input = '#input';
10286 const resolved = resolve(input, base);
10287 assert.strictEqual(resolved, 'file?baseQuery#input');
10288 });
10289 });
10290
10291 describe('empty input', () => {
10292 it('normalizes base', () => {
10293 const base = 'file?baseQuery#baseHash';
10294 const input = '';
10295 const resolved = resolve(input, base);
10296 assert.strictEqual(resolved, 'file?baseQuery#baseHash');
10297 });
10298 });
10299 });
10300
10301 describe(`base = "file#baseHash"`, () => {
10302 describe('with absolute input', () => {
10303 it('returns input', () => {
10304 const base = 'file#baseHash';
10305 const input = 'https://absolute.com/main.js.map';
10306 const resolved = resolve(input, base);
10307 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
10308 });
10309
10310 it('returns input with query', () => {
10311 const base = 'file#baseHash';
10312 const input = 'https://absolute.com/main.js.map?input';
10313 const resolved = resolve(input, base);
10314 assert.strictEqual(resolved, 'https://absolute.com/main.js.map?input');
10315 });
10316
10317 it('normalizes input path', () => {
10318 const base = 'file#baseHash';
10319 const input = 'https://absolute.com/foo/./bar/../main.js.map';
10320 const resolved = resolve(input, base);
10321 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map');
10322 });
10323
10324 it('normalizes input path with query', () => {
10325 const base = 'file#baseHash';
10326 const input = 'https://absolute.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
10327 const resolved = resolve(input, base);
10328 assert.strictEqual(resolved, 'https://absolute.com/foo/main.js.map?input!webpack://foo/./bar');
10329 });
10330
10331 it('normalizes pathless input', () => {
10332 const base = 'file#baseHash';
10333 const input = 'https://absolute.com';
10334 const resolved = resolve(input, base);
10335 assert.strictEqual(resolved, 'https://absolute.com/');
10336 });
10337
10338 it('normalizes pathless input with query', () => {
10339 const base = 'file#baseHash';
10340 const input = 'https://absolute.com?input';
10341 const resolved = resolve(input, base);
10342 assert.strictEqual(resolved, 'https://absolute.com/?input');
10343 });
10344
10345 it('normalizes current directory', () => {
10346 const base = 'file#baseHash';
10347 const input = 'https://absolute.com/./main.js.map';
10348 const resolved = resolve(input, base);
10349 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
10350 });
10351
10352 it('normalizes too many parent accessors', () => {
10353 const base = 'file#baseHash';
10354 const input = 'https://absolute.com/../../../main.js.map';
10355 const resolved = resolve(input, base);
10356 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
10357 });
10358
10359 it('normalizes too many parent accessors, late', () => {
10360 const base = 'file#baseHash';
10361 const input = 'https://absolute.com/foo/../../../main.js.map';
10362 const resolved = resolve(input, base);
10363 assert.strictEqual(resolved, 'https://absolute.com/main.js.map');
10364 });
10365
10366 it('normalizes file protocol 1', () => {
10367 const base = 'file#baseHash';
10368 const input = 'file:///root/main.js.map';
10369 const resolved = resolve(input, base);
10370 assert.strictEqual(resolved, 'file:///root/main.js.map');
10371 });
10372
10373 it('normalizes file protocol 2', () => {
10374 const base = 'file#baseHash';
10375 const input = 'file://root/main.js.map';
10376 const resolved = resolve(input, base);
10377 assert.strictEqual(resolved, 'file://root/main.js.map');
10378 });
10379
10380 it('normalizes file protocol 2.5', () => {
10381 const base = 'file#baseHash';
10382 const input = 'file://root';
10383 const resolved = resolve(input, base);
10384 assert.strictEqual(resolved, 'file://root/');
10385 });
10386
10387 it('normalizes file protocol 3', () => {
10388 const base = 'file#baseHash';
10389 const input = 'file:/root/main.js.map';
10390 const resolved = resolve(input, base);
10391 assert.strictEqual(resolved, 'file:///root/main.js.map');
10392 });
10393
10394 it('normalizes file protocol 4', () => {
10395 const base = 'file#baseHash';
10396 const input = 'file:root/main.js.map';
10397 const resolved = resolve(input, base);
10398 assert.strictEqual(resolved, 'file:///root/main.js.map');
10399 });
10400
10401 it('normalizes file protocol 1 with query', () => {
10402 const base = 'file#baseHash';
10403 const input = 'file:///root/main.js.map?input';
10404 const resolved = resolve(input, base);
10405 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
10406 });
10407
10408 it('normalizes file protocol 2 with query', () => {
10409 const base = 'file#baseHash';
10410 const input = 'file://root/main.js.map?input';
10411 const resolved = resolve(input, base);
10412 assert.strictEqual(resolved, 'file://root/main.js.map?input');
10413 });
10414
10415 it('normalizes file protocol 2.5 with query', () => {
10416 const base = 'file#baseHash';
10417 const input = 'file://root?input';
10418 const resolved = resolve(input, base);
10419 assert.strictEqual(resolved, 'file://root/?input');
10420 });
10421
10422 it('normalizes file protocol 3 with query', () => {
10423 const base = 'file#baseHash';
10424 const input = 'file:/root/main.js.map?input';
10425 const resolved = resolve(input, base);
10426 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
10427 });
10428
10429 it('normalizes file protocol 4 with query', () => {
10430 const base = 'file#baseHash';
10431 const input = 'file:root/main.js.map?input';
10432 const resolved = resolve(input, base);
10433 assert.strictEqual(resolved, 'file:///root/main.js.map?input');
10434 });
10435 });
10436
10437 describe('with protocol relative input', () => {
10438 it('resolves relative to the base protocol', () => {
10439 const base = 'file#baseHash';
10440 const input = '//protocol-relative.com/main.js.map';
10441 const resolved = resolve(input, base);
10442 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
10443 });
10444
10445 it('resolves relative to the base protocol with query', () => {
10446 const base = 'file#baseHash';
10447 const input = '//protocol-relative.com/main.js.map?input';
10448 const resolved = resolve(input, base);
10449 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map?input');
10450 });
10451
10452 it('normalizes input path', () => {
10453 const base = 'file#baseHash';
10454 const input = '//protocol-relative.com/foo/./bar/../main.js.map';
10455 const resolved = resolve(input, base);
10456 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map');
10457 });
10458
10459 it('normalizes input path with query', () => {
10460 const base = 'file#baseHash';
10461 const input = '//protocol-relative.com/foo/./bar/../main.js.map?input!webpack://foo/./bar';
10462 const resolved = resolve(input, base);
10463 assert.strictEqual(resolved, '//protocol-relative.com/foo/main.js.map?input!webpack://foo/./bar');
10464 });
10465
10466 it('normalizes pathless input', () => {
10467 const base = 'file#baseHash';
10468 const input = '//protocol-relative.com';
10469 const resolved = resolve(input, base);
10470 assert.strictEqual(resolved, '//protocol-relative.com/');
10471 });
10472
10473 it('normalizes pathless input with query', () => {
10474 const base = 'file#baseHash';
10475 const input = '//protocol-relative.com?input';
10476 const resolved = resolve(input, base);
10477 assert.strictEqual(resolved, '//protocol-relative.com/?input');
10478 });
10479
10480 it('normalizes current directory', () => {
10481 const base = 'file#baseHash';
10482 const input = '//protocol-relative.com/./main.js.map';
10483 const resolved = resolve(input, base);
10484 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
10485 });
10486
10487 it('normalizes too many parent accessors', () => {
10488 const base = 'file#baseHash';
10489 const input = '//protocol-relative.com/../main.js.map';
10490 const resolved = resolve(input, base);
10491 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
10492 });
10493
10494 it('normalizes too many parent accessors, late', () => {
10495 const base = 'file#baseHash';
10496 const input = '//protocol-relative.com/foo/../../main.js.map';
10497 const resolved = resolve(input, base);
10498 assert.strictEqual(resolved, '//protocol-relative.com/main.js.map');
10499 });
10500 });
10501
10502 describe('with absolute path input', () => {
10503 it('remains absolute path', () => {
10504 const base = 'file#baseHash';
10505 const input = '/assets/main.js.map';
10506 const resolved = resolve(input, base);
10507 assert.strictEqual(resolved, '/assets/main.js.map');
10508 });
10509
10510 it('remains absolute path with query', () => {
10511 const base = 'file#baseHash';
10512 const input = '/assets/main.js.map?input';
10513 const resolved = resolve(input, base);
10514 assert.strictEqual(resolved, '/assets/main.js.map?input');
10515 });
10516
10517 it('trims to root', () => {
10518 const base = 'file#baseHash';
10519 const input = '/';
10520 const resolved = resolve(input, base);
10521 assert.strictEqual(resolved, '/');
10522 });
10523
10524 it('normalizes input path', () => {
10525 const base = 'file#baseHash';
10526 const input = '/foo/./bar/../main.js.map';
10527 const resolved = resolve(input, base);
10528 assert.strictEqual(resolved, '/foo/main.js.map');
10529 });
10530
10531 it('normalizes current directory', () => {
10532 const base = 'file#baseHash';
10533 const input = '/./main.js.map';
10534 const resolved = resolve(input, base);
10535 assert.strictEqual(resolved, '/main.js.map');
10536 });
10537
10538 it('normalizes too many parent accessors', () => {
10539 const base = 'file#baseHash';
10540 const input = '/../../../main.js.map';
10541 const resolved = resolve(input, base);
10542 assert.strictEqual(resolved, '/main.js.map');
10543 });
10544
10545 it('normalizes too many parent accessors with query 1', () => {
10546 const base = 'file#baseHash';
10547 const input = '/../../../?input';
10548 const resolved = resolve(input, base);
10549 assert.strictEqual(resolved, '/?input');
10550 });
10551
10552 it('normalizes too many parent accessors with query 2', () => {
10553 const base = 'file#baseHash';
10554 const input = '/../../..?input';
10555 const resolved = resolve(input, base);
10556 assert.strictEqual(resolved, '/?input');
10557 });
10558
10559 it('normalizes too many parent accessors, late', () => {
10560 const base = 'file#baseHash';
10561 const input = '/foo/../../../main.js.map';
10562 const resolved = resolve(input, base);
10563 assert.strictEqual(resolved, '/main.js.map');
10564 });
10565 });
10566
10567 describe('with leading dot relative input', () => {
10568 it('resolves relative to current directory', () => {
10569 const base = 'file#baseHash';
10570 const input = './bar/main.js.map';
10571 const resolved = resolve(input, base);
10572 assert.strictEqual(resolved, 'bar/main.js.map');
10573 });
10574
10575 it('resolves relative to current directory with query', () => {
10576 const base = 'file#baseHash';
10577 const input = './bar/main.js.map?input';
10578 const resolved = resolve(input, base);
10579 assert.strictEqual(resolved, 'bar/main.js.map?input');
10580 });
10581
10582 it('resolves relative to parent directory', () => {
10583 const base = 'file#baseHash';
10584 const input = '../bar/main.js.map';
10585 const resolved = resolve(input, base);
10586 assert.strictEqual(resolved, '../bar/main.js.map');
10587 });
10588
10589 it('resolves relative to parent directory with query', () => {
10590 const base = 'file#baseHash';
10591 const input = '../bar/main.js.map?input';
10592 const resolved = resolve(input, base);
10593 assert.strictEqual(resolved, '../bar/main.js.map?input');
10594 });
10595
10596 it('resolves relative to parent multiple directory', () => {
10597 const base = 'file#baseHash';
10598 const input = '../../../bar/main.js.map';
10599 const resolved = resolve(input, base);
10600 assert.strictEqual(resolved, '../../../bar/main.js.map');
10601 });
10602
10603 it('resolves relative to parent multiple directory with query 1', () => {
10604 const base = 'file#baseHash';
10605 const input = '../../../?input';
10606 const resolved = resolve(input, base);
10607 assert.strictEqual(resolved, '../../..?input');
10608 });
10609
10610 it('resolves relative to parent multiple directory with query 2', () => {
10611 const base = 'file#baseHash';
10612 const input = '../../..?input';
10613 const resolved = resolve(input, base);
10614 assert.strictEqual(resolved, '../../..?input');
10615 });
10616
10617 it('normalizes input path', () => {
10618 const base = 'file#baseHash';
10619 const input = './foo/./bar/../main.js.map';
10620 const resolved = resolve(input, base);
10621 assert.strictEqual(resolved, 'foo/main.js.map');
10622 });
10623 });
10624
10625 describe('with relative path input', () => {
10626 it('resolves relative to current directory', () => {
10627 const base = 'file#baseHash';
10628 const input = 'bar/main.js.map';
10629 const resolved = resolve(input, base);
10630 assert.strictEqual(resolved, 'bar/main.js.map');
10631 });
10632
10633 it('resolves relative to current directory with query', () => {
10634 const base = 'file#baseHash';
10635 const input = 'bar/main.js.map?input';
10636 const resolved = resolve(input, base);
10637 assert.strictEqual(resolved, 'bar/main.js.map?input');
10638 });
10639
10640 it('resolves relative to parent multiple directory, later', () => {
10641 const base = 'file#baseHash';
10642 const input = 'foo/../../../bar/main.js.map';
10643 const resolved = resolve(input, base);
10644 assert.strictEqual(resolved, '../../bar/main.js.map');
10645 });
10646
10647 it('normalizes input path', () => {
10648 const base = 'file#baseHash';
10649 const input = 'foo/./bar/../main.js.map';
10650 const resolved = resolve(input, base);
10651 assert.strictEqual(resolved, 'foo/main.js.map');
10652 });
10653
10654 it('resolves node_module scope as path', () => {
10655 const base = 'file#baseHash';
10656 const input = 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js';
10657 const resolved = resolve(input, base);
10658 assert.strictEqual(resolved, 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js');
10659 });
10660
10661 it('resolves package scope as path', () => {
10662 const base = 'file#baseHash';
10663 const input = '@babel/runtime/helpers/esm/arrayLikeToArray.js';
10664 const resolved = resolve(input, base);
10665 assert.strictEqual(resolved, '@babel/runtime/helpers/esm/arrayLikeToArray.js');
10666 });
10667 });
10668
10669 describe('with query input', () => {
10670 it('resolves relative to path', () => {
10671 const base = 'file#baseHash';
10672 const input = '?input';
10673 const resolved = resolve(input, base);
10674 assert.strictEqual(resolved, 'file?input');
10675 });
10676 });
10677
10678 describe('with hash input', () => {
10679 it('resolves relative to path', () => {
10680 const base = 'file#baseHash';
10681 const input = '#input';
10682 const resolved = resolve(input, base);
10683 assert.strictEqual(resolved, 'file#input');
10684 });
10685 });
10686
10687 describe('empty input', () => {
10688 it('normalizes base', () => {
10689 const base = 'file#baseHash';
10690 const input = '';
10691 const resolved = resolve(input, base);
10692 assert.strictEqual(resolved, 'file#baseHash');
10693 });
10694 });
10695 });
10696 });