Debian Codegraph @

jridgewell-resolve-uri/test/resolve/without-base.test.js

raw
1 const resolve = require('../..');
2 const assert = require('assert');
3
4 describe('without base', () => {
5 describe(`base = undefined`, () => {
6 describe('with absolute input', () => {
7 it('returns input', () => {
8 const base = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
223 const input = '/';
224 const resolved = resolve(input, base);
225 assert.strictEqual(resolved, '/');
226 });
227
228 it('normalizes input path', () => {
229 const base = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
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 = undefined;
376 const input = '?input';
377 const resolved = resolve(input, base);
378 assert.strictEqual(resolved, '?input');
379 });
380 });
381
382 describe('with hash input', () => {
383 it('resolves relative to path', () => {
384 const base = undefined;
385 const input = '#input';
386 const resolved = resolve(input, base);
387 assert.strictEqual(resolved, '#input');
388 });
389 });
390
391 describe('empty input', () => {
392 it('normalizes base', () => {
393 const base = undefined;
394 const input = '';
395 const resolved = resolve(input, base);
396 assert.strictEqual(resolved, '');
397 });
398 });
399 });
400
401 describe(`base = ""`, () => {
402 describe('with absolute input', () => {
403 it('returns input', () => {
404 const base = '';
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 = '';
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 = '';
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 = '';
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 = '';
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 = '';
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 = '';
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 = '';
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 = '';
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 = '';
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 = '';
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 = '';
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 = '';
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 = '';
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 = '';
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 = '';
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 = '';
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 = '';
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 = '';
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 = '';
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 = '';
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 = '';
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 = '';
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 = '';
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 = '';
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 = '';
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 = '';
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 = '';
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 = '';
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 = '';
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 = '';
619 const input = '/';
620 const resolved = resolve(input, base);
621 assert.strictEqual(resolved, '/');
622 });
623
624 it('normalizes input path', () => {
625 const base = '';
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 = '';
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 = '';
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 = '';
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 = '';
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 = '';
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 = '';
670 const input = './bar/main.js.map';
671 const resolved = resolve(input, base);
672 assert.strictEqual(resolved, './bar/main.js.map');
673 });
674
675 it('resolves relative to current directory with query', () => {
676 const base = '';
677 const input = './bar/main.js.map?input';
678 const resolved = resolve(input, base);
679 assert.strictEqual(resolved, './bar/main.js.map?input');
680 });
681
682 it('resolves relative to parent directory', () => {
683 const base = '';
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 = '';
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 = '';
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 = '';
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 = '';
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 = '';
719 const input = './foo/./bar/../main.js.map';
720 const resolved = resolve(input, base);
721 assert.strictEqual(resolved, './foo/main.js.map');
722 });
723 });
724
725 describe('with relative path input', () => {
726 it('resolves relative to current directory', () => {
727 const base = '';
728 const input = 'bar/main.js.map';
729 const resolved = resolve(input, base);
730 assert.strictEqual(resolved, 'bar/main.js.map');
731 });
732
733 it('resolves relative to current directory with query', () => {
734 const base = '';
735 const input = 'bar/main.js.map?input';
736 const resolved = resolve(input, base);
737 assert.strictEqual(resolved, 'bar/main.js.map?input');
738 });
739
740 it('resolves relative to parent multiple directory, later', () => {
741 const base = '';
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 = '';
749 const input = 'foo/./bar/../main.js.map';
750 const resolved = resolve(input, base);
751 assert.strictEqual(resolved, 'foo/main.js.map');
752 });
753
754 it('resolves node_module scope as path', () => {
755 const base = '';
756 const input = 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js';
757 const resolved = resolve(input, base);
758 assert.strictEqual(resolved, 'node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js');
759 });
760
761 it('resolves package scope as path', () => {
762 const base = '';
763 const input = '@babel/runtime/helpers/esm/arrayLikeToArray.js';
764 const resolved = resolve(input, base);
765 assert.strictEqual(resolved, '@babel/runtime/helpers/esm/arrayLikeToArray.js');
766 });
767 });
768
769 describe('with query input', () => {
770 it('resolves relative to path', () => {
771 const base = '';
772 const input = '?input';
773 const resolved = resolve(input, base);
774 assert.strictEqual(resolved, '?input');
775 });
776 });
777
778 describe('with hash input', () => {
779 it('resolves relative to path', () => {
780 const base = '';
781 const input = '#input';
782 const resolved = resolve(input, base);
783 assert.strictEqual(resolved, '#input');
784 });
785 });
786
787 describe('empty input', () => {
788 it('normalizes base', () => {
789 const base = '';
790 const input = '';
791 const resolved = resolve(input, base);
792 assert.strictEqual(resolved, '');
793 });
794 });
795 });
796 });