1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.// This module is browser compatible.
import { CHAR_COLON } from "./_constants.ts";import {  assertPath,  isPathSeparator,  isPosixPathSeparator,  isWindowsDeviceRoot,  normalizeString,} from "./_util.ts";
function assertArg(path: string) {  assertPath(path);  if (path.length === 0) return ".";}
/** * Normalize the `path`, resolving `'..'` and `'.'` segments. * Note that resolving these segments does not necessarily mean that all will be eliminated. * A `'..'` at the top-level will be preserved, and an empty path is canonically `'.'`. * @param path to be normalized */export function posixNormalize(path: string): string {  assertArg(path);
  const isAbsolute = isPosixPathSeparator(path.charCodeAt(0));  const trailingSeparator = isPosixPathSeparator(    path.charCodeAt(path.length - 1),  );
  // Normalize the path  path = normalizeString(path, !isAbsolute, "/", isPosixPathSeparator);
  if (path.length === 0 && !isAbsolute) path = ".";  if (path.length > 0 && trailingSeparator) path += "/";
  if (isAbsolute) return `/${path}`;  return path;}
/** * Normalize the `path`, resolving `'..'` and `'.'` segments. * Note that resolving these segments does not necessarily mean that all will be eliminated. * A `'..'` at the top-level will be preserved, and an empty path is canonically `'.'`. * @param path to be normalized */export function windowsNormalize(path: string): string {  assertArg(path);
  const len = path.length;  let rootEnd = 0;  let device: string | undefined;  let isAbsolute = false;  const code = path.charCodeAt(0);
  // Try to match a root  if (len > 1) {    if (isPathSeparator(code)) {      // Possible UNC root
      // If we started with a separator, we know we at least have an absolute      // path of some kind (UNC or otherwise)      isAbsolute = true;
      if (isPathSeparator(path.charCodeAt(1))) {        // Matched double path separator at beginning        let j = 2;        let last = j;        // Match 1 or more non-path separators        for (; j < len; ++j) {          if (isPathSeparator(path.charCodeAt(j))) break;        }        if (j < len && j !== last) {          const firstPart = path.slice(last, j);          // Matched!          last = j;          // Match 1 or more path separators          for (; j < len; ++j) {            if (!isPathSeparator(path.charCodeAt(j))) break;          }          if (j < len && j !== last) {            // Matched!            last = j;            // Match 1 or more non-path separators            for (; j < len; ++j) {              if (isPathSeparator(path.charCodeAt(j))) break;            }            if (j === len) {              // We matched a UNC root only              // Return the normalized version of the UNC root since there              // is nothing left to process
              return `\\\\${firstPart}\\${path.slice(last)}\\`;            } else if (j !== last) {              // We matched a UNC root with leftovers
              device = `\\\\${firstPart}\\${path.slice(last, j)}`;              rootEnd = j;            }          }        }      } else {        rootEnd = 1;      }    } else if (isWindowsDeviceRoot(code)) {      // Possible device root
      if (path.charCodeAt(1) === CHAR_COLON) {        device = path.slice(0, 2);        rootEnd = 2;        if (len > 2) {          if (isPathSeparator(path.charCodeAt(2))) {            // Treat separator following drive name as an absolute path            // indicator            isAbsolute = true;            rootEnd = 3;          }        }      }    }  } else if (isPathSeparator(code)) {    // `path` contains just a path separator, exit early to avoid unnecessary    // work    return "\\";  }
  let tail: string;  if (rootEnd < len) {    tail = normalizeString(      path.slice(rootEnd),      !isAbsolute,      "\\",      isPathSeparator,    );  } else {    tail = "";  }  if (tail.length === 0 && !isAbsolute) tail = ".";  if (tail.length > 0 && isPathSeparator(path.charCodeAt(len - 1))) {    tail += "\\";  }  if (device === undefined) {    if (isAbsolute) {      if (tail.length > 0) return `\\${tail}`;      else return "\\";    } else if (tail.length > 0) {      return tail;    } else {      return "";    }  } else if (isAbsolute) {    if (tail.length > 0) return `${device}\\${tail}`;    else return `${device}\\`;  } else if (tail.length > 0) {    return device + tail;  } else {    return device;  }}