diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..7f5a2bc --- /dev/null +++ b/.gitattributes @@ -0,0 +1,3 @@ +* text=auto +/tests/__snapshots__/** text eol=lf +/testdata/** text eol=lf diff --git a/deno.jsonc b/deno.jsonc index 8070966..a594570 100644 --- a/deno.jsonc +++ b/deno.jsonc @@ -4,7 +4,8 @@ "exclude": [ "lib", "static", - "target" + "target", + "tests/__snapshots__" ] } }, @@ -13,12 +14,14 @@ "exclude": [ "lib", "static/*.js", - "target" + "target", + "tests/__snapshots__" ] } }, "tasks": { "test": "deno test --allow-read --allow-net --allow-env --allow-write", + "update-snapshots": "deno test --allow-read --allow-net --allow-env --allow-write -- --update", "build": "deno run -A --unstable https://deno.land/x/wasmbuild@0.8.3/main.ts" } } diff --git a/test.ts b/test.ts deleted file mode 100644 index d089ef5..0000000 --- a/test.ts +++ /dev/null @@ -1,173 +0,0 @@ -// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. -import { - assert, - assertEquals, - assertStringIncludes, -} from "https://deno.land/std@0.140.0/testing/asserts.ts"; -import { join } from "https://deno.land/std@0.140.0/path/mod.ts"; -import { bundle, emit } from "./mod.ts"; - -Deno.test({ - name: "bundle - remote", - async fn() { - const result = await bundle( - new URL("https://deno.land/std@0.140.0/examples/chat/server.ts"), - ); - console.log(result); - assert(result.code); - }, -}); - -Deno.test({ - name: "bundle - url", - async fn() { - const result = await bundle( - new URL( - "https://deno.land/std@0.140.0/examples/chat/server.ts", - ), - ); - console.log(result); - assert(result.code); - }, -}); - -Deno.test({ - name: "bundle - relative", - async fn() { - const result = await bundle( - "./testdata/mod.ts", - ); - console.log(result); - assert(result.code); - }, -}); - -Deno.test({ - name: "bundle - absolute", - async fn() { - const result = await bundle( - join(Deno.cwd(), "testdata", "mod.ts"), - ); - console.log(result); - assert(result.code); - }, -}); - -Deno.test({ - name: "bundle - source", - async fn() { - const result = await bundle(new URL("file:///src.ts"), { - async load(specifier) { - if (specifier !== "file:///src.ts") return undefined; - const content = await Deno.readTextFile( - join(Deno.cwd(), "testdata", "mod.ts"), - ); - return { kind: "module", specifier, content }; - }, - }); - console.log(result); - assert(result.code); - }, -}); - -Deno.test({ - name: "bundle - json escapes", - async fn() { - const result = await bundle("./testdata/escape.ts"); - const { code } = result; - assert(code); - const EOL = Deno?.build?.os === "windows" - ? String.raw`\r\n` - : String.raw`\n`; - // This is done on purpose, as `String.raw` still performs a string interpolation, - // and we want a literal value ${jsInterpolation" as is, without any modifications. - // We should not need to escape `$` nor `{` as they are both JSON-safe characters. - const jsInterpolation = "${jsInterpolation}"; - assertStringIncludes( - code, - String - .raw`const __default = JSON.parse("{${EOL} \"key\": \"a value with newline\\n, \\\"double quotes\\\", 'single quotes', and ${jsInterpolation}\"${EOL}}");`, - ); - }, -}); - -Deno.test({ - name: "transpile - remote", - async fn() { - const result = await emit( - new URL( - "https://deno.land/std@0.140.0/examples/chat/server.ts", - ), - ); - - console.log(result); - assertEquals(Object.keys(result).length, 18); - const code = - result["https://deno.land/std@0.140.0/examples/chat/server.ts"]; - assert(code); - }, -}); - -Deno.test({ - name: "transpile - url", - async fn() { - const result = await emit( - new URL( - "https://deno.land/std@0.140.0/examples/chat/server.ts", - ), - ); - - console.log(result); - assertEquals(Object.keys(result).length, 18); - const code = - result["https://deno.land/std@0.140.0/examples/chat/server.ts"]; - assert(code); - }, -}); - -Deno.test({ - name: "transpile - relative", - async fn() { - const result = await emit("./testdata/mod.ts"); - - console.log(result); - assertEquals(Object.keys(result).length, 1); - const code = result[Object.keys(result)[0]]; - assert(code); - assertStringIncludes(code, "export default function hello()"); - }, -}); - -Deno.test({ - name: "transpile - absolute", - async fn() { - const result = await emit(join(Deno.cwd(), "testdata", "mod.ts")); - - console.log(result); - assertEquals(Object.keys(result).length, 1); - const code = result[Object.keys(result)[0]]; - assert(code); - assertStringIncludes(code, "export default function hello()"); - }, -}); - -Deno.test({ - name: "transpile - source", - async fn() { - const result = await emit(new URL("file:///src.ts"), { - async load(specifier) { - if (specifier !== "file:///src.ts") return undefined; - const content = await Deno.readTextFile( - join(Deno.cwd(), "testdata", "mod.ts"), - ); - return { kind: "module", specifier, content }; - }, - }); - - console.log(result); - assertEquals(Object.keys(result).length, 1); - const code = result[Object.keys(result)[0]]; - assert(code); - assertStringIncludes(code, "export default function hello()"); - }, -}); diff --git a/tests/__snapshots__/bundle/absolute.js b/tests/__snapshots__/bundle/absolute.js new file mode 100644 index 0000000..2f81635 --- /dev/null +++ b/tests/__snapshots__/bundle/absolute.js @@ -0,0 +1,5 @@ +function hello() { + return "Hello there!"; +} +export { hello as default }; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImZpbGU6Ly8vdGVzdGRhdGEvbW9kLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBkZWZhdWx0IGZ1bmN0aW9uIGhlbGxvKCk6IHN0cmluZyB7XG4gIHJldHVybiBcIkhlbGxvIHRoZXJlIVwiO1xufVxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFlLFNBQVMsUUFBZ0I7SUFDdEMsT0FBTztBQUNUO0FBRkEsNEJBRUMifQ== diff --git a/tests/__snapshots__/bundle/json_escapes.js b/tests/__snapshots__/bundle/json_escapes.js new file mode 100644 index 0000000..e53e9f7 --- /dev/null +++ b/tests/__snapshots__/bundle/json_escapes.js @@ -0,0 +1,6 @@ +const __default = JSON.parse("{\n \"key\": \"a value with newline\\n, \\\"double quotes\\\", 'single quotes', and ${jsInterpolation}\"\n}"); +function payload() { + return JSON.stringify(__default); +} +export { payload as default }; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImZpbGU6Ly8vdGVzdGRhdGEvZXNjYXBlLmpzb24iLCJmaWxlOi8vL3Rlc3RkYXRhL2VzY2FwZS50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZGVmYXVsdCBKU09OLnBhcnNlKFwie1xcbiAgXFxcImtleVxcXCI6IFxcXCJhIHZhbHVlIHdpdGggbmV3bGluZVxcXFxuLCBcXFxcXFxcImRvdWJsZSBxdW90ZXNcXFxcXFxcIiwgJ3NpbmdsZSBxdW90ZXMnLCBhbmQgJHtqc0ludGVycG9sYXRpb259XFxcIlxcbn1cIik7IiwiaW1wb3J0IGogZnJvbSBcIi4vZXNjYXBlLmpzb25cIiBhc3NlcnQgeyB0eXBlOiBcImpzb25cIiB9O1xuXG5leHBvcnQgZGVmYXVsdCBmdW5jdGlvbiBwYXlsb2FkKCk6IHN0cmluZyB7XG4gIHJldHVybiBKU09OLnN0cmluZ2lmeShqKTtcbn1cbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoia0JBQWUsS0FBSyxLQUFLLENBQUM7QUNFWCxTQUFTLFVBQWtCO0lBQ3hDLE9BQU8sS0FBSyxTQUFTO0FBQ3ZCO0FBRkEsOEJBRUMifQ== diff --git a/tests/__snapshots__/bundle/relative.js b/tests/__snapshots__/bundle/relative.js new file mode 100644 index 0000000..2f81635 --- /dev/null +++ b/tests/__snapshots__/bundle/relative.js @@ -0,0 +1,5 @@ +function hello() { + return "Hello there!"; +} +export { hello as default }; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImZpbGU6Ly8vdGVzdGRhdGEvbW9kLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBkZWZhdWx0IGZ1bmN0aW9uIGhlbGxvKCk6IHN0cmluZyB7XG4gIHJldHVybiBcIkhlbGxvIHRoZXJlIVwiO1xufVxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFlLFNBQVMsUUFBZ0I7SUFDdEMsT0FBTztBQUNUO0FBRkEsNEJBRUMifQ== diff --git a/tests/__snapshots__/bundle/remote.js b/tests/__snapshots__/bundle/remote.js new file mode 100644 index 0000000..d0b5685 --- /dev/null +++ b/tests/__snapshots__/bundle/remote.js @@ -0,0 +1,1185 @@ +const osType = (()=>{ + const { Deno: Deno1 } = globalThis; + if (typeof Deno1?.build?.os === "string") { + return Deno1.build.os; + } + const { navigator } = globalThis; + if (navigator?.appVersion?.includes?.("Win")) { + return "windows"; + } + return "linux"; +})(); +const isWindows = osType === "windows"; +const CHAR_FORWARD_SLASH = 47; +function assertPath(path) { + if (typeof path !== "string") { + throw new TypeError(`Path must be a string. Received ${JSON.stringify(path)}`); + } +} +function isPosixPathSeparator(code) { + return code === 47; +} +function isPathSeparator(code) { + return isPosixPathSeparator(code) || code === 92; +} +function isWindowsDeviceRoot(code) { + return code >= 97 && code <= 122 || code >= 65 && code <= 90; +} +function normalizeString(path, allowAboveRoot, separator, isPathSeparator) { + let res = ""; + let lastSegmentLength = 0; + let lastSlash = -1; + let dots = 0; + let code; + for(let i = 0, len = path.length; i <= len; ++i){ + if (i < len) code = path.charCodeAt(i); + else if (isPathSeparator(code)) break; + else code = CHAR_FORWARD_SLASH; + if (isPathSeparator(code)) { + if (lastSlash === i - 1 || dots === 1) {} else if (lastSlash !== i - 1 && dots === 2) { + if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 || res.charCodeAt(res.length - 2) !== 46) { + if (res.length > 2) { + const lastSlashIndex = res.lastIndexOf(separator); + if (lastSlashIndex === -1) { + res = ""; + lastSegmentLength = 0; + } else { + res = res.slice(0, lastSlashIndex); + lastSegmentLength = res.length - 1 - res.lastIndexOf(separator); + } + lastSlash = i; + dots = 0; + continue; + } else if (res.length === 2 || res.length === 1) { + res = ""; + lastSegmentLength = 0; + lastSlash = i; + dots = 0; + continue; + } + } + if (allowAboveRoot) { + if (res.length > 0) res += `${separator}..`; + else res = ".."; + lastSegmentLength = 2; + } + } else { + if (res.length > 0) res += separator + path.slice(lastSlash + 1, i); + else res = path.slice(lastSlash + 1, i); + lastSegmentLength = i - lastSlash - 1; + } + lastSlash = i; + dots = 0; + } else if (code === 46 && dots !== -1) { + ++dots; + } else { + dots = -1; + } + } + return res; +} +function _format(sep, pathObject) { + const dir = pathObject.dir || pathObject.root; + const base = pathObject.base || (pathObject.name || "") + (pathObject.ext || ""); + if (!dir) return base; + if (dir === pathObject.root) return dir + base; + return dir + sep + base; +} +const WHITESPACE_ENCODINGS = { + "\u0009": "%09", + "\u000A": "%0A", + "\u000B": "%0B", + "\u000C": "%0C", + "\u000D": "%0D", + "\u0020": "%20" +}; +function encodeWhitespace(string) { + return string.replaceAll(/[\s]/g, (c)=>{ + return WHITESPACE_ENCODINGS[c] ?? c; + }); +} +class DenoStdInternalError extends Error { + constructor(message){ + super(message); + this.name = "DenoStdInternalError"; + } +} +function assert(expr, msg = "") { + if (!expr) { + throw new DenoStdInternalError(msg); + } +} +const sep = "\\"; +const delimiter = ";"; +function resolve(...pathSegments) { + let resolvedDevice = ""; + let resolvedTail = ""; + let resolvedAbsolute = false; + for(let i = pathSegments.length - 1; i >= -1; i--){ + let path; + const { Deno: Deno1 } = globalThis; + if (i >= 0) { + path = pathSegments[i]; + } else if (!resolvedDevice) { + if (typeof Deno1?.cwd !== "function") { + throw new TypeError("Resolved a drive-letter-less path without a CWD."); + } + path = Deno1.cwd(); + } else { + if (typeof Deno1?.env?.get !== "function" || typeof Deno1?.cwd !== "function") { + throw new TypeError("Resolved a relative path without a CWD."); + } + path = Deno1.cwd(); + if (path === undefined || path.slice(0, 3).toLowerCase() !== `${resolvedDevice.toLowerCase()}\\`) { + path = `${resolvedDevice}\\`; + } + } + assertPath(path); + const len = path.length; + if (len === 0) continue; + let rootEnd = 0; + let device = ""; + let isAbsolute = false; + const code = path.charCodeAt(0); + if (len > 1) { + if (isPathSeparator(code)) { + isAbsolute = true; + if (isPathSeparator(path.charCodeAt(1))) { + let j = 2; + let last = j; + for(; j < len; ++j){ + if (isPathSeparator(path.charCodeAt(j))) break; + } + if (j < len && j !== last) { + const firstPart = path.slice(last, j); + last = j; + for(; j < len; ++j){ + if (!isPathSeparator(path.charCodeAt(j))) break; + } + if (j < len && j !== last) { + last = j; + for(; j < len; ++j){ + if (isPathSeparator(path.charCodeAt(j))) break; + } + if (j === len) { + device = `\\\\${firstPart}\\${path.slice(last)}`; + rootEnd = j; + } else if (j !== last) { + device = `\\\\${firstPart}\\${path.slice(last, j)}`; + rootEnd = j; + } + } + } + } else { + rootEnd = 1; + } + } else if (isWindowsDeviceRoot(code)) { + if (path.charCodeAt(1) === 58) { + device = path.slice(0, 2); + rootEnd = 2; + if (len > 2) { + if (isPathSeparator(path.charCodeAt(2))) { + isAbsolute = true; + rootEnd = 3; + } + } + } + } + } else if (isPathSeparator(code)) { + rootEnd = 1; + isAbsolute = true; + } + if (device.length > 0 && resolvedDevice.length > 0 && device.toLowerCase() !== resolvedDevice.toLowerCase()) { + continue; + } + if (resolvedDevice.length === 0 && device.length > 0) { + resolvedDevice = device; + } + if (!resolvedAbsolute) { + resolvedTail = `${path.slice(rootEnd)}\\${resolvedTail}`; + resolvedAbsolute = isAbsolute; + } + if (resolvedAbsolute && resolvedDevice.length > 0) break; + } + resolvedTail = normalizeString(resolvedTail, !resolvedAbsolute, "\\", isPathSeparator); + return resolvedDevice + (resolvedAbsolute ? "\\" : "") + resolvedTail || "."; +} +function normalize(path) { + assertPath(path); + const len = path.length; + if (len === 0) return "."; + let rootEnd = 0; + let device; + let isAbsolute = false; + const code = path.charCodeAt(0); + if (len > 1) { + if (isPathSeparator(code)) { + isAbsolute = true; + if (isPathSeparator(path.charCodeAt(1))) { + let j = 2; + let last = j; + for(; j < len; ++j){ + if (isPathSeparator(path.charCodeAt(j))) break; + } + if (j < len && j !== last) { + const firstPart = path.slice(last, j); + last = j; + for(; j < len; ++j){ + if (!isPathSeparator(path.charCodeAt(j))) break; + } + if (j < len && j !== last) { + last = j; + for(; j < len; ++j){ + if (isPathSeparator(path.charCodeAt(j))) break; + } + if (j === len) { + return `\\\\${firstPart}\\${path.slice(last)}\\`; + } else if (j !== last) { + device = `\\\\${firstPart}\\${path.slice(last, j)}`; + rootEnd = j; + } + } + } + } else { + rootEnd = 1; + } + } else if (isWindowsDeviceRoot(code)) { + if (path.charCodeAt(1) === 58) { + device = path.slice(0, 2); + rootEnd = 2; + if (len > 2) { + if (isPathSeparator(path.charCodeAt(2))) { + isAbsolute = true; + rootEnd = 3; + } + } + } + } + } else if (isPathSeparator(code)) { + return "\\"; + } + let tail; + 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; + } +} +function isAbsolute(path) { + assertPath(path); + const len = path.length; + if (len === 0) return false; + const code = path.charCodeAt(0); + if (isPathSeparator(code)) { + return true; + } else if (isWindowsDeviceRoot(code)) { + if (len > 2 && path.charCodeAt(1) === 58) { + if (isPathSeparator(path.charCodeAt(2))) return true; + } + } + return false; +} +function join(...paths) { + const pathsCount = paths.length; + if (pathsCount === 0) return "."; + let joined; + let firstPart = null; + for(let i = 0; i < pathsCount; ++i){ + const path = paths[i]; + assertPath(path); + if (path.length > 0) { + if (joined === undefined) joined = firstPart = path; + else joined += `\\${path}`; + } + } + if (joined === undefined) return "."; + let needsReplace = true; + let slashCount = 0; + assert(firstPart != null); + if (isPathSeparator(firstPart.charCodeAt(0))) { + ++slashCount; + const firstLen = firstPart.length; + if (firstLen > 1) { + if (isPathSeparator(firstPart.charCodeAt(1))) { + ++slashCount; + if (firstLen > 2) { + if (isPathSeparator(firstPart.charCodeAt(2))) ++slashCount; + else { + needsReplace = false; + } + } + } + } + } + if (needsReplace) { + for(; slashCount < joined.length; ++slashCount){ + if (!isPathSeparator(joined.charCodeAt(slashCount))) break; + } + if (slashCount >= 2) joined = `\\${joined.slice(slashCount)}`; + } + return normalize(joined); +} +function relative(from, to) { + assertPath(from); + assertPath(to); + if (from === to) return ""; + const fromOrig = resolve(from); + const toOrig = resolve(to); + if (fromOrig === toOrig) return ""; + from = fromOrig.toLowerCase(); + to = toOrig.toLowerCase(); + if (from === to) return ""; + let fromStart = 0; + let fromEnd = from.length; + for(; fromStart < fromEnd; ++fromStart){ + if (from.charCodeAt(fromStart) !== 92) break; + } + for(; fromEnd - 1 > fromStart; --fromEnd){ + if (from.charCodeAt(fromEnd - 1) !== 92) break; + } + const fromLen = fromEnd - fromStart; + let toStart = 0; + let toEnd = to.length; + for(; toStart < toEnd; ++toStart){ + if (to.charCodeAt(toStart) !== 92) break; + } + for(; toEnd - 1 > toStart; --toEnd){ + if (to.charCodeAt(toEnd - 1) !== 92) break; + } + const toLen = toEnd - toStart; + const length = fromLen < toLen ? fromLen : toLen; + let lastCommonSep = -1; + let i = 0; + for(; i <= length; ++i){ + if (i === length) { + if (toLen > length) { + if (to.charCodeAt(toStart + i) === 92) { + return toOrig.slice(toStart + i + 1); + } else if (i === 2) { + return toOrig.slice(toStart + i); + } + } + if (fromLen > length) { + if (from.charCodeAt(fromStart + i) === 92) { + lastCommonSep = i; + } else if (i === 2) { + lastCommonSep = 3; + } + } + break; + } + const fromCode = from.charCodeAt(fromStart + i); + const toCode = to.charCodeAt(toStart + i); + if (fromCode !== toCode) break; + else if (fromCode === 92) lastCommonSep = i; + } + if (i !== length && lastCommonSep === -1) { + return toOrig; + } + let out = ""; + if (lastCommonSep === -1) lastCommonSep = 0; + for(i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i){ + if (i === fromEnd || from.charCodeAt(i) === 92) { + if (out.length === 0) out += ".."; + else out += "\\.."; + } + } + if (out.length > 0) { + return out + toOrig.slice(toStart + lastCommonSep, toEnd); + } else { + toStart += lastCommonSep; + if (toOrig.charCodeAt(toStart) === 92) ++toStart; + return toOrig.slice(toStart, toEnd); + } +} +function toNamespacedPath(path) { + if (typeof path !== "string") return path; + if (path.length === 0) return ""; + const resolvedPath = resolve(path); + if (resolvedPath.length >= 3) { + if (resolvedPath.charCodeAt(0) === 92) { + if (resolvedPath.charCodeAt(1) === 92) { + const code = resolvedPath.charCodeAt(2); + if (code !== 63 && code !== 46) { + return `\\\\?\\UNC\\${resolvedPath.slice(2)}`; + } + } + } else if (isWindowsDeviceRoot(resolvedPath.charCodeAt(0))) { + if (resolvedPath.charCodeAt(1) === 58 && resolvedPath.charCodeAt(2) === 92) { + return `\\\\?\\${resolvedPath}`; + } + } + } + return path; +} +function dirname(path) { + assertPath(path); + const len = path.length; + if (len === 0) return "."; + let rootEnd = -1; + let end = -1; + let matchedSlash = true; + let offset = 0; + const code = path.charCodeAt(0); + if (len > 1) { + if (isPathSeparator(code)) { + rootEnd = offset = 1; + if (isPathSeparator(path.charCodeAt(1))) { + let j = 2; + let last = j; + for(; j < len; ++j){ + if (isPathSeparator(path.charCodeAt(j))) break; + } + if (j < len && j !== last) { + last = j; + for(; j < len; ++j){ + if (!isPathSeparator(path.charCodeAt(j))) break; + } + if (j < len && j !== last) { + last = j; + for(; j < len; ++j){ + if (isPathSeparator(path.charCodeAt(j))) break; + } + if (j === len) { + return path; + } + if (j !== last) { + rootEnd = offset = j + 1; + } + } + } + } + } else if (isWindowsDeviceRoot(code)) { + if (path.charCodeAt(1) === 58) { + rootEnd = offset = 2; + if (len > 2) { + if (isPathSeparator(path.charCodeAt(2))) rootEnd = offset = 3; + } + } + } + } else if (isPathSeparator(code)) { + return path; + } + for(let i = len - 1; i >= offset; --i){ + if (isPathSeparator(path.charCodeAt(i))) { + if (!matchedSlash) { + end = i; + break; + } + } else { + matchedSlash = false; + } + } + if (end === -1) { + if (rootEnd === -1) return "."; + else end = rootEnd; + } + return path.slice(0, end); +} +function basename(path, ext = "") { + if (ext !== undefined && typeof ext !== "string") { + throw new TypeError('"ext" argument must be a string'); + } + assertPath(path); + let start = 0; + let end = -1; + let matchedSlash = true; + let i; + if (path.length >= 2) { + const drive = path.charCodeAt(0); + if (isWindowsDeviceRoot(drive)) { + if (path.charCodeAt(1) === 58) start = 2; + } + } + if (ext !== undefined && ext.length > 0 && ext.length <= path.length) { + if (ext.length === path.length && ext === path) return ""; + let extIdx = ext.length - 1; + let firstNonSlashEnd = -1; + for(i = path.length - 1; i >= start; --i){ + const code = path.charCodeAt(i); + if (isPathSeparator(code)) { + if (!matchedSlash) { + start = i + 1; + break; + } + } else { + if (firstNonSlashEnd === -1) { + matchedSlash = false; + firstNonSlashEnd = i + 1; + } + if (extIdx >= 0) { + if (code === ext.charCodeAt(extIdx)) { + if (--extIdx === -1) { + end = i; + } + } else { + extIdx = -1; + end = firstNonSlashEnd; + } + } + } + } + if (start === end) end = firstNonSlashEnd; + else if (end === -1) end = path.length; + return path.slice(start, end); + } else { + for(i = path.length - 1; i >= start; --i){ + if (isPathSeparator(path.charCodeAt(i))) { + if (!matchedSlash) { + start = i + 1; + break; + } + } else if (end === -1) { + matchedSlash = false; + end = i + 1; + } + } + if (end === -1) return ""; + return path.slice(start, end); + } +} +function extname(path) { + assertPath(path); + let start = 0; + let startDot = -1; + let startPart = 0; + let end = -1; + let matchedSlash = true; + let preDotState = 0; + if (path.length >= 2 && path.charCodeAt(1) === 58 && isWindowsDeviceRoot(path.charCodeAt(0))) { + start = startPart = 2; + } + for(let i = path.length - 1; i >= start; --i){ + const code = path.charCodeAt(i); + if (isPathSeparator(code)) { + if (!matchedSlash) { + startPart = i + 1; + break; + } + continue; + } + if (end === -1) { + matchedSlash = false; + end = i + 1; + } + if (code === 46) { + if (startDot === -1) startDot = i; + else if (preDotState !== 1) preDotState = 1; + } else if (startDot !== -1) { + preDotState = -1; + } + } + if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) { + return ""; + } + return path.slice(startDot, end); +} +function format(pathObject) { + if (pathObject === null || typeof pathObject !== "object") { + throw new TypeError(`The "pathObject" argument must be of type Object. Received type ${typeof pathObject}`); + } + return _format("\\", pathObject); +} +function parse(path) { + assertPath(path); + const ret = { + root: "", + dir: "", + base: "", + ext: "", + name: "" + }; + const len = path.length; + if (len === 0) return ret; + let rootEnd = 0; + let code = path.charCodeAt(0); + if (len > 1) { + if (isPathSeparator(code)) { + rootEnd = 1; + if (isPathSeparator(path.charCodeAt(1))) { + let j = 2; + let last = j; + for(; j < len; ++j){ + if (isPathSeparator(path.charCodeAt(j))) break; + } + if (j < len && j !== last) { + last = j; + for(; j < len; ++j){ + if (!isPathSeparator(path.charCodeAt(j))) break; + } + if (j < len && j !== last) { + last = j; + for(; j < len; ++j){ + if (isPathSeparator(path.charCodeAt(j))) break; + } + if (j === len) { + rootEnd = j; + } else if (j !== last) { + rootEnd = j + 1; + } + } + } + } + } else if (isWindowsDeviceRoot(code)) { + if (path.charCodeAt(1) === 58) { + rootEnd = 2; + if (len > 2) { + if (isPathSeparator(path.charCodeAt(2))) { + if (len === 3) { + ret.root = ret.dir = path; + return ret; + } + rootEnd = 3; + } + } else { + ret.root = ret.dir = path; + return ret; + } + } + } + } else if (isPathSeparator(code)) { + ret.root = ret.dir = path; + return ret; + } + if (rootEnd > 0) ret.root = path.slice(0, rootEnd); + let startDot = -1; + let startPart = rootEnd; + let end = -1; + let matchedSlash = true; + let i = path.length - 1; + let preDotState = 0; + for(; i >= rootEnd; --i){ + code = path.charCodeAt(i); + if (isPathSeparator(code)) { + if (!matchedSlash) { + startPart = i + 1; + break; + } + continue; + } + if (end === -1) { + matchedSlash = false; + end = i + 1; + } + if (code === 46) { + if (startDot === -1) startDot = i; + else if (preDotState !== 1) preDotState = 1; + } else if (startDot !== -1) { + preDotState = -1; + } + } + if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) { + if (end !== -1) { + ret.base = ret.name = path.slice(startPart, end); + } + } else { + ret.name = path.slice(startPart, startDot); + ret.base = path.slice(startPart, end); + ret.ext = path.slice(startDot, end); + } + if (startPart > 0 && startPart !== rootEnd) { + ret.dir = path.slice(0, startPart - 1); + } else ret.dir = ret.root; + return ret; +} +function fromFileUrl(url) { + url = url instanceof URL ? url : new URL(url); + if (url.protocol != "file:") { + throw new TypeError("Must be a file URL."); + } + let path = decodeURIComponent(url.pathname.replace(/\//g, "\\").replace(/%(?![0-9A-Fa-f]{2})/g, "%25")).replace(/^\\*([A-Za-z]:)(\\|$)/, "$1\\"); + if (url.hostname != "") { + path = `\\\\${url.hostname}${path}`; + } + return path; +} +function toFileUrl(path) { + if (!isAbsolute(path)) { + throw new TypeError("Must be an absolute path."); + } + const [, hostname, pathname] = path.match(/^(?:[/\\]{2}([^/\\]+)(?=[/\\](?:[^/\\]|$)))?(.*)/); + const url = new URL("file:///"); + url.pathname = encodeWhitespace(pathname.replace(/%/g, "%25")); + if (hostname != null && hostname != "localhost") { + url.hostname = hostname; + if (!url.hostname) { + throw new TypeError("Invalid hostname."); + } + } + return url; +} +const mod = { + sep: sep, + delimiter: delimiter, + resolve: resolve, + normalize: normalize, + isAbsolute: isAbsolute, + join: join, + relative: relative, + toNamespacedPath: toNamespacedPath, + dirname: dirname, + basename: basename, + extname: extname, + format: format, + parse: parse, + fromFileUrl: fromFileUrl, + toFileUrl: toFileUrl +}; +const sep1 = "/"; +const delimiter1 = ":"; +function resolve1(...pathSegments) { + let resolvedPath = ""; + let resolvedAbsolute = false; + for(let i = pathSegments.length - 1; i >= -1 && !resolvedAbsolute; i--){ + let path; + if (i >= 0) path = pathSegments[i]; + else { + const { Deno: Deno1 } = globalThis; + if (typeof Deno1?.cwd !== "function") { + throw new TypeError("Resolved a relative path without a CWD."); + } + path = Deno1.cwd(); + } + assertPath(path); + if (path.length === 0) { + continue; + } + resolvedPath = `${path}/${resolvedPath}`; + resolvedAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH; + } + resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute, "/", isPosixPathSeparator); + if (resolvedAbsolute) { + if (resolvedPath.length > 0) return `/${resolvedPath}`; + else return "/"; + } else if (resolvedPath.length > 0) return resolvedPath; + else return "."; +} +function normalize1(path) { + assertPath(path); + if (path.length === 0) return "."; + const isAbsolute = path.charCodeAt(0) === 47; + const trailingSeparator = path.charCodeAt(path.length - 1) === 47; + path = normalizeString(path, !isAbsolute, "/", isPosixPathSeparator); + if (path.length === 0 && !isAbsolute) path = "."; + if (path.length > 0 && trailingSeparator) path += "/"; + if (isAbsolute) return `/${path}`; + return path; +} +function isAbsolute1(path) { + assertPath(path); + return path.length > 0 && path.charCodeAt(0) === 47; +} +function join1(...paths) { + if (paths.length === 0) return "."; + let joined; + for(let i = 0, len = paths.length; i < len; ++i){ + const path = paths[i]; + assertPath(path); + if (path.length > 0) { + if (!joined) joined = path; + else joined += `/${path}`; + } + } + if (!joined) return "."; + return normalize1(joined); +} +function relative1(from, to) { + assertPath(from); + assertPath(to); + if (from === to) return ""; + from = resolve1(from); + to = resolve1(to); + if (from === to) return ""; + let fromStart = 1; + const fromEnd = from.length; + for(; fromStart < fromEnd; ++fromStart){ + if (from.charCodeAt(fromStart) !== 47) break; + } + const fromLen = fromEnd - fromStart; + let toStart = 1; + const toEnd = to.length; + for(; toStart < toEnd; ++toStart){ + if (to.charCodeAt(toStart) !== 47) break; + } + const toLen = toEnd - toStart; + const length = fromLen < toLen ? fromLen : toLen; + let lastCommonSep = -1; + let i = 0; + for(; i <= length; ++i){ + if (i === length) { + if (toLen > length) { + if (to.charCodeAt(toStart + i) === 47) { + return to.slice(toStart + i + 1); + } else if (i === 0) { + return to.slice(toStart + i); + } + } else if (fromLen > length) { + if (from.charCodeAt(fromStart + i) === 47) { + lastCommonSep = i; + } else if (i === 0) { + lastCommonSep = 0; + } + } + break; + } + const fromCode = from.charCodeAt(fromStart + i); + const toCode = to.charCodeAt(toStart + i); + if (fromCode !== toCode) break; + else if (fromCode === 47) lastCommonSep = i; + } + let out = ""; + for(i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i){ + if (i === fromEnd || from.charCodeAt(i) === 47) { + if (out.length === 0) out += ".."; + else out += "/.."; + } + } + if (out.length > 0) return out + to.slice(toStart + lastCommonSep); + else { + toStart += lastCommonSep; + if (to.charCodeAt(toStart) === 47) ++toStart; + return to.slice(toStart); + } +} +function toNamespacedPath1(path) { + return path; +} +function dirname1(path) { + assertPath(path); + if (path.length === 0) return "."; + const hasRoot = path.charCodeAt(0) === 47; + let end = -1; + let matchedSlash = true; + for(let i = path.length - 1; i >= 1; --i){ + if (path.charCodeAt(i) === 47) { + if (!matchedSlash) { + end = i; + break; + } + } else { + matchedSlash = false; + } + } + if (end === -1) return hasRoot ? "/" : "."; + if (hasRoot && end === 1) return "//"; + return path.slice(0, end); +} +function basename1(path, ext = "") { + if (ext !== undefined && typeof ext !== "string") { + throw new TypeError('"ext" argument must be a string'); + } + assertPath(path); + let start = 0; + let end = -1; + let matchedSlash = true; + let i; + if (ext !== undefined && ext.length > 0 && ext.length <= path.length) { + if (ext.length === path.length && ext === path) return ""; + let extIdx = ext.length - 1; + let firstNonSlashEnd = -1; + for(i = path.length - 1; i >= 0; --i){ + const code = path.charCodeAt(i); + if (code === 47) { + if (!matchedSlash) { + start = i + 1; + break; + } + } else { + if (firstNonSlashEnd === -1) { + matchedSlash = false; + firstNonSlashEnd = i + 1; + } + if (extIdx >= 0) { + if (code === ext.charCodeAt(extIdx)) { + if (--extIdx === -1) { + end = i; + } + } else { + extIdx = -1; + end = firstNonSlashEnd; + } + } + } + } + if (start === end) end = firstNonSlashEnd; + else if (end === -1) end = path.length; + return path.slice(start, end); + } else { + for(i = path.length - 1; i >= 0; --i){ + if (path.charCodeAt(i) === 47) { + if (!matchedSlash) { + start = i + 1; + break; + } + } else if (end === -1) { + matchedSlash = false; + end = i + 1; + } + } + if (end === -1) return ""; + return path.slice(start, end); + } +} +function extname1(path) { + assertPath(path); + let startDot = -1; + let startPart = 0; + let end = -1; + let matchedSlash = true; + let preDotState = 0; + for(let i = path.length - 1; i >= 0; --i){ + const code = path.charCodeAt(i); + if (code === 47) { + if (!matchedSlash) { + startPart = i + 1; + break; + } + continue; + } + if (end === -1) { + matchedSlash = false; + end = i + 1; + } + if (code === 46) { + if (startDot === -1) startDot = i; + else if (preDotState !== 1) preDotState = 1; + } else if (startDot !== -1) { + preDotState = -1; + } + } + if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) { + return ""; + } + return path.slice(startDot, end); +} +function format1(pathObject) { + if (pathObject === null || typeof pathObject !== "object") { + throw new TypeError(`The "pathObject" argument must be of type Object. Received type ${typeof pathObject}`); + } + return _format("/", pathObject); +} +function parse1(path) { + assertPath(path); + const ret = { + root: "", + dir: "", + base: "", + ext: "", + name: "" + }; + if (path.length === 0) return ret; + const isAbsolute = path.charCodeAt(0) === 47; + let start; + if (isAbsolute) { + ret.root = "/"; + start = 1; + } else { + start = 0; + } + let startDot = -1; + let startPart = 0; + let end = -1; + let matchedSlash = true; + let i = path.length - 1; + let preDotState = 0; + for(; i >= start; --i){ + const code = path.charCodeAt(i); + if (code === 47) { + if (!matchedSlash) { + startPart = i + 1; + break; + } + continue; + } + if (end === -1) { + matchedSlash = false; + end = i + 1; + } + if (code === 46) { + if (startDot === -1) startDot = i; + else if (preDotState !== 1) preDotState = 1; + } else if (startDot !== -1) { + preDotState = -1; + } + } + if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) { + if (end !== -1) { + if (startPart === 0 && isAbsolute) { + ret.base = ret.name = path.slice(1, end); + } else { + ret.base = ret.name = path.slice(startPart, end); + } + } + } else { + if (startPart === 0 && isAbsolute) { + ret.name = path.slice(1, startDot); + ret.base = path.slice(1, end); + } else { + ret.name = path.slice(startPart, startDot); + ret.base = path.slice(startPart, end); + } + ret.ext = path.slice(startDot, end); + } + if (startPart > 0) ret.dir = path.slice(0, startPart - 1); + else if (isAbsolute) ret.dir = "/"; + return ret; +} +function fromFileUrl1(url) { + url = url instanceof URL ? url : new URL(url); + if (url.protocol != "file:") { + throw new TypeError("Must be a file URL."); + } + return decodeURIComponent(url.pathname.replace(/%(?![0-9A-Fa-f]{2})/g, "%25")); +} +function toFileUrl1(path) { + if (!isAbsolute1(path)) { + throw new TypeError("Must be an absolute path."); + } + const url = new URL("file:///"); + url.pathname = encodeWhitespace(path.replace(/%/g, "%25").replace(/\\/g, "%5C")); + return url; +} +const mod1 = { + sep: sep1, + delimiter: delimiter1, + resolve: resolve1, + normalize: normalize1, + isAbsolute: isAbsolute1, + join: join1, + relative: relative1, + toNamespacedPath: toNamespacedPath1, + dirname: dirname1, + basename: basename1, + extname: extname1, + format: format1, + parse: parse1, + fromFileUrl: fromFileUrl1, + toFileUrl: toFileUrl1 +}; +const path = isWindows ? mod : mod1; +const { join: join2 , normalize: normalize2 } = path; +const path1 = isWindows ? mod : mod1; +const { basename: basename2 , delimiter: delimiter2 , dirname: dirname2 , extname: extname2 , format: format2 , fromFileUrl: fromFileUrl2 , isAbsolute: isAbsolute2 , join: join3 , normalize: normalize3 , parse: parse2 , relative: relative2 , resolve: resolve2 , sep: sep2 , toFileUrl: toFileUrl2 , toNamespacedPath: toNamespacedPath2 } = path1; +function isCloser(value) { + return typeof value === "object" && value != null && "close" in value && typeof value["close"] === "function"; +} +function readableStreamFromReader(reader, options = {}) { + const { autoClose =true , chunkSize =16_640 , strategy } = options; + return new ReadableStream({ + async pull (controller) { + const chunk = new Uint8Array(chunkSize); + try { + const read = await reader.read(chunk); + if (read === null) { + if (isCloser(reader) && autoClose) { + reader.close(); + } + controller.close(); + return; + } + controller.enqueue(chunk.subarray(0, read)); + } catch (e) { + controller.error(e); + if (isCloser(reader)) { + reader.close(); + } + } + }, + cancel () { + if (isCloser(reader) && autoClose) { + reader.close(); + } + } + }, strategy); +} +const importMeta = { + url: "https://deno.land/std@0.140.0/examples/chat/server.ts", + main: import.meta.main +}; +const clients = new Map(); +let clientId = 0; +function dispatch(msg) { + for (const client of clients.values()){ + client.send(msg); + } +} +function wsHandler(ws) { + const id = ++clientId; + clients.set(id, ws); + ws.onopen = ()=>{ + dispatch(`Connected: [${id}]`); + }; + ws.onmessage = (e)=>{ + console.log(`msg:${id}`, e.data); + dispatch(`[${id}]: ${e.data}`); + }; + ws.onclose = ()=>{ + clients.delete(id); + dispatch(`Closed: [${id}]`); + }; +} +async function requestHandler(req) { + const pathname = new URL(req.request.url).pathname; + if (req.request.method === "GET" && pathname === "/") { + const u = new URL("./index.html", importMeta.url); + if (u.protocol.startsWith("http")) { + fetch(u.href).then(async (resp)=>{ + const body = new Uint8Array(await resp.arrayBuffer()); + req.respondWith(new Response(body, { + status: resp.status, + headers: { + "content-type": "text/html" + } + })); + }); + } else { + const file = await Deno.open(fromFileUrl2(u)); + req.respondWith(new Response(readableStreamFromReader(file), { + status: 200, + headers: { + "content-type": "text/html" + } + })); + } + } else if (req.request.method === "GET" && pathname === "/favicon.ico") { + req.respondWith(Response.redirect("https://deno.land/favicon.ico", 302)); + } else if (req.request.method === "GET" && pathname === "/ws") { + const { socket , response } = Deno.upgradeWebSocket(req.request); + wsHandler(socket); + req.respondWith(response); + } +} +const server = Deno.listen({ + port: 8080 +}); +console.log("chat server starting on :8080...."); +for await (const conn of server){ + (async ()=>{ + const httpConn = Deno.serveHttp(conn); + for await (const requestEvent of httpConn){ + requestHandler(requestEvent); + } + })(); +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["https://deno.land/std@0.140.0/_util/os.ts","https://deno.land/std@0.140.0/path/_constants.ts","https://deno.land/std@0.140.0/path/_util.ts","https://deno.land/std@0.140.0/_util/assert.ts","https://deno.land/std@0.140.0/path/win32.ts","https://deno.land/std@0.140.0/path/posix.ts","https://deno.land/std@0.140.0/path/glob.ts","https://deno.land/std@0.140.0/path/mod.ts","https://deno.land/std@0.140.0/streams/conversion.ts","https://deno.land/std@0.140.0/examples/chat/server.ts"],"sourcesContent":["// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.\n// This module is browser compatible.\n\nexport type OSType = \"windows\" | \"linux\" | \"darwin\";\n\nexport const osType: OSType = (() => {\n  // deno-lint-ignore no-explicit-any\n  const { Deno } = globalThis as any;\n  if (typeof Deno?.build?.os === \"string\") {\n    return Deno.build.os;\n  }\n\n  // deno-lint-ignore no-explicit-any\n  const { navigator } = globalThis as any;\n  if (navigator?.appVersion?.includes?.(\"Win\")) {\n    return \"windows\";\n  }\n\n  return \"linux\";\n})();\n\nexport const isWindows = osType === \"windows\";\nexport const isLinux = osType === \"linux\";\n","// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.\n// Copyright the Browserify authors. MIT License.\n// Ported from https://github.com/browserify/path-browserify/\n// This module is browser compatible.\n\n// Alphabet chars.\nexport const CHAR_UPPERCASE_A = 65; /* A */\nexport const CHAR_LOWERCASE_A = 97; /* a */\nexport const CHAR_UPPERCASE_Z = 90; /* Z */\nexport const CHAR_LOWERCASE_Z = 122; /* z */\n\n// Non-alphabetic chars.\nexport const CHAR_DOT = 46; /* . */\nexport const CHAR_FORWARD_SLASH = 47; /* / */\nexport const CHAR_BACKWARD_SLASH = 92; /* \\ */\nexport const CHAR_VERTICAL_LINE = 124; /* | */\nexport const CHAR_COLON = 58; /* : */\nexport const CHAR_QUESTION_MARK = 63; /* ? */\nexport const CHAR_UNDERSCORE = 95; /* _ */\nexport const CHAR_LINE_FEED = 10; /* \\n */\nexport const CHAR_CARRIAGE_RETURN = 13; /* \\r */\nexport const CHAR_TAB = 9; /* \\t */\nexport const CHAR_FORM_FEED = 12; /* \\f */\nexport const CHAR_EXCLAMATION_MARK = 33; /* ! */\nexport const CHAR_HASH = 35; /* # */\nexport const CHAR_SPACE = 32; /*   */\nexport const CHAR_NO_BREAK_SPACE = 160; /* \\u00A0 */\nexport const CHAR_ZERO_WIDTH_NOBREAK_SPACE = 65279; /* \\uFEFF */\nexport const CHAR_LEFT_SQUARE_BRACKET = 91; /* [ */\nexport const CHAR_RIGHT_SQUARE_BRACKET = 93; /* ] */\nexport const CHAR_LEFT_ANGLE_BRACKET = 60; /* < */\nexport const CHAR_RIGHT_ANGLE_BRACKET = 62; /* > */\nexport const CHAR_LEFT_CURLY_BRACKET = 123; /* { */\nexport const CHAR_RIGHT_CURLY_BRACKET = 125; /* } */\nexport const CHAR_HYPHEN_MINUS = 45; /* - */\nexport const CHAR_PLUS = 43; /* + */\nexport const CHAR_DOUBLE_QUOTE = 34; /* \" */\nexport const CHAR_SINGLE_QUOTE = 39; /* ' */\nexport const CHAR_PERCENT = 37; /* % */\nexport const CHAR_SEMICOLON = 59; /* ; */\nexport const CHAR_CIRCUMFLEX_ACCENT = 94; /* ^ */\nexport const CHAR_GRAVE_ACCENT = 96; /* ` */\nexport const CHAR_AT = 64; /* @ */\nexport const CHAR_AMPERSAND = 38; /* & */\nexport const CHAR_EQUAL = 61; /* = */\n\n// Digits\nexport const CHAR_0 = 48; /* 0 */\nexport const CHAR_9 = 57; /* 9 */\n","// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.\n// Copyright the Browserify authors. MIT License.\n// Ported from https://github.com/browserify/path-browserify/\n// This module is browser compatible.\n\nimport type { FormatInputPathObject } from \"./_interface.ts\";\nimport {\n  CHAR_BACKWARD_SLASH,\n  CHAR_DOT,\n  CHAR_FORWARD_SLASH,\n  CHAR_LOWERCASE_A,\n  CHAR_LOWERCASE_Z,\n  CHAR_UPPERCASE_A,\n  CHAR_UPPERCASE_Z,\n} from \"./_constants.ts\";\n\nexport function assertPath(path: string): void {\n  if (typeof path !== \"string\") {\n    throw new TypeError(\n      `Path must be a string. Received ${JSON.stringify(path)}`,\n    );\n  }\n}\n\nexport function isPosixPathSeparator(code: number): boolean {\n  return code === CHAR_FORWARD_SLASH;\n}\n\nexport function isPathSeparator(code: number): boolean {\n  return isPosixPathSeparator(code) || code === CHAR_BACKWARD_SLASH;\n}\n\nexport function isWindowsDeviceRoot(code: number): boolean {\n  return (\n    (code >= CHAR_LOWERCASE_A && code <= CHAR_LOWERCASE_Z) ||\n    (code >= CHAR_UPPERCASE_A && code <= CHAR_UPPERCASE_Z)\n  );\n}\n\n// Resolves . and .. elements in a path with directory names\nexport function normalizeString(\n  path: string,\n  allowAboveRoot: boolean,\n  separator: string,\n  isPathSeparator: (code: number) => boolean,\n): string {\n  let res = \"\";\n  let lastSegmentLength = 0;\n  let lastSlash = -1;\n  let dots = 0;\n  let code: number | undefined;\n  for (let i = 0, len = path.length; i <= len; ++i) {\n    if (i < len) code = path.charCodeAt(i);\n    else if (isPathSeparator(code!)) break;\n    else code = CHAR_FORWARD_SLASH;\n\n    if (isPathSeparator(code!)) {\n      if (lastSlash === i - 1 || dots === 1) {\n        // NOOP\n      } else if (lastSlash !== i - 1 && dots === 2) {\n        if (\n          res.length < 2 ||\n          lastSegmentLength !== 2 ||\n          res.charCodeAt(res.length - 1) !== CHAR_DOT ||\n          res.charCodeAt(res.length - 2) !== CHAR_DOT\n        ) {\n          if (res.length > 2) {\n            const lastSlashIndex = res.lastIndexOf(separator);\n            if (lastSlashIndex === -1) {\n              res = \"\";\n              lastSegmentLength = 0;\n            } else {\n              res = res.slice(0, lastSlashIndex);\n              lastSegmentLength = res.length - 1 - res.lastIndexOf(separator);\n            }\n            lastSlash = i;\n            dots = 0;\n            continue;\n          } else if (res.length === 2 || res.length === 1) {\n            res = \"\";\n            lastSegmentLength = 0;\n            lastSlash = i;\n            dots = 0;\n            continue;\n          }\n        }\n        if (allowAboveRoot) {\n          if (res.length > 0) res += `${separator}..`;\n          else res = \"..\";\n          lastSegmentLength = 2;\n        }\n      } else {\n        if (res.length > 0) res += separator + path.slice(lastSlash + 1, i);\n        else res = path.slice(lastSlash + 1, i);\n        lastSegmentLength = i - lastSlash - 1;\n      }\n      lastSlash = i;\n      dots = 0;\n    } else if (code === CHAR_DOT && dots !== -1) {\n      ++dots;\n    } else {\n      dots = -1;\n    }\n  }\n  return res;\n}\n\nexport function _format(\n  sep: string,\n  pathObject: FormatInputPathObject,\n): string {\n  const dir: string | undefined = pathObject.dir || pathObject.root;\n  const base: string = pathObject.base ||\n    (pathObject.name || \"\") + (pathObject.ext || \"\");\n  if (!dir) return base;\n  if (dir === pathObject.root) return dir + base;\n  return dir + sep + base;\n}\n\nconst WHITESPACE_ENCODINGS: Record<string, string> = {\n  \"\\u0009\": \"%09\",\n  \"\\u000A\": \"%0A\",\n  \"\\u000B\": \"%0B\",\n  \"\\u000C\": \"%0C\",\n  \"\\u000D\": \"%0D\",\n  \"\\u0020\": \"%20\",\n};\n\nexport function encodeWhitespace(string: string): string {\n  return string.replaceAll(/[\\s]/g, (c) => {\n    return WHITESPACE_ENCODINGS[c] ?? c;\n  });\n}\n","// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.\n// This module is browser compatible.\n\nexport class DenoStdInternalError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"DenoStdInternalError\";\n  }\n}\n\n/** Make an assertion, if not `true`, then throw. */\nexport function assert(expr: unknown, msg = \"\"): asserts expr {\n  if (!expr) {\n    throw new DenoStdInternalError(msg);\n  }\n}\n","// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.\n// Copyright the Browserify authors. MIT License.\n// Ported from https://github.com/browserify/path-browserify/\n// This module is browser compatible.\n\nimport type { FormatInputPathObject, ParsedPath } from \"./_interface.ts\";\nimport {\n  CHAR_BACKWARD_SLASH,\n  CHAR_COLON,\n  CHAR_DOT,\n  CHAR_QUESTION_MARK,\n} from \"./_constants.ts\";\n\nimport {\n  _format,\n  assertPath,\n  encodeWhitespace,\n  isPathSeparator,\n  isWindowsDeviceRoot,\n  normalizeString,\n} from \"./_util.ts\";\nimport { assert } from \"../_util/assert.ts\";\n\nexport const sep = \"\\\\\";\nexport const delimiter = \";\";\n\n/**\n * Resolves path segments into a `path`\n * @param pathSegments to process to path\n */\nexport function resolve(...pathSegments: string[]): string {\n  let resolvedDevice = \"\";\n  let resolvedTail = \"\";\n  let resolvedAbsolute = false;\n\n  for (let i = pathSegments.length - 1; i >= -1; i--) {\n    let path: string;\n    // deno-lint-ignore no-explicit-any\n    const { Deno } = globalThis as any;\n    if (i >= 0) {\n      path = pathSegments[i];\n    } else if (!resolvedDevice) {\n      if (typeof Deno?.cwd !== \"function\") {\n        throw new TypeError(\"Resolved a drive-letter-less path without a CWD.\");\n      }\n      path = Deno.cwd();\n    } else {\n      if (\n        typeof Deno?.env?.get !== \"function\" || typeof Deno?.cwd !== \"function\"\n      ) {\n        throw new TypeError(\"Resolved a relative path without a CWD.\");\n      }\n      path = Deno.cwd();\n\n      // Verify that a cwd was found and that it actually points\n      // to our drive. If not, default to the drive's root.\n      if (\n        path === undefined ||\n        path.slice(0, 3).toLowerCase() !== `${resolvedDevice.toLowerCase()}\\\\`\n      ) {\n        path = `${resolvedDevice}\\\\`;\n      }\n    }\n\n    assertPath(path);\n\n    const len = path.length;\n\n    // Skip empty entries\n    if (len === 0) continue;\n\n    let rootEnd = 0;\n    let device = \"\";\n    let isAbsolute = false;\n    const code = path.charCodeAt(0);\n\n    // Try to match a root\n    if (len > 1) {\n      if (isPathSeparator(code)) {\n        // Possible UNC root\n\n        // If we started with a separator, we know we at least have an\n        // absolute path of some kind (UNC or otherwise)\n        isAbsolute = true;\n\n        if (isPathSeparator(path.charCodeAt(1))) {\n          // Matched double path separator at beginning\n          let j = 2;\n          let last = j;\n          // Match 1 or more non-path separators\n          for (; j < len; ++j) {\n            if (isPathSeparator(path.charCodeAt(j))) break;\n          }\n          if (j < len && j !== last) {\n            const firstPart = path.slice(last, j);\n            // Matched!\n            last = j;\n            // Match 1 or more path separators\n            for (; j < len; ++j) {\n              if (!isPathSeparator(path.charCodeAt(j))) break;\n            }\n            if (j < len && j !== last) {\n              // Matched!\n              last = j;\n              // Match 1 or more non-path separators\n              for (; j < len; ++j) {\n                if (isPathSeparator(path.charCodeAt(j))) break;\n              }\n              if (j === len) {\n                // We matched a UNC root only\n                device = `\\\\\\\\${firstPart}\\\\${path.slice(last)}`;\n                rootEnd = j;\n              } else if (j !== last) {\n                // We matched a UNC root with leftovers\n\n                device = `\\\\\\\\${firstPart}\\\\${path.slice(last, j)}`;\n                rootEnd = j;\n              }\n            }\n          }\n        } else {\n          rootEnd = 1;\n        }\n      } else if (isWindowsDeviceRoot(code)) {\n        // Possible device root\n\n        if (path.charCodeAt(1) === CHAR_COLON) {\n          device = path.slice(0, 2);\n          rootEnd = 2;\n          if (len > 2) {\n            if (isPathSeparator(path.charCodeAt(2))) {\n              // Treat separator following drive name as an absolute path\n              // indicator\n              isAbsolute = true;\n              rootEnd = 3;\n            }\n          }\n        }\n      }\n    } else if (isPathSeparator(code)) {\n      // `path` contains just a path separator\n      rootEnd = 1;\n      isAbsolute = true;\n    }\n\n    if (\n      device.length > 0 &&\n      resolvedDevice.length > 0 &&\n      device.toLowerCase() !== resolvedDevice.toLowerCase()\n    ) {\n      // This path points to another device so it is not applicable\n      continue;\n    }\n\n    if (resolvedDevice.length === 0 && device.length > 0) {\n      resolvedDevice = device;\n    }\n    if (!resolvedAbsolute) {\n      resolvedTail = `${path.slice(rootEnd)}\\\\${resolvedTail}`;\n      resolvedAbsolute = isAbsolute;\n    }\n\n    if (resolvedAbsolute && resolvedDevice.length > 0) break;\n  }\n\n  // At this point the path should be resolved to a full absolute path,\n  // but handle relative paths to be safe (might happen when process.cwd()\n  // fails)\n\n  // Normalize the tail path\n  resolvedTail = normalizeString(\n    resolvedTail,\n    !resolvedAbsolute,\n    \"\\\\\",\n    isPathSeparator,\n  );\n\n  return resolvedDevice + (resolvedAbsolute ? \"\\\\\" : \"\") + resolvedTail || \".\";\n}\n\n/**\n * Normalizes a `path`\n * @param path to normalize\n */\nexport function normalize(path: string): string {\n  assertPath(path);\n  const len = path.length;\n  if (len === 0) return \".\";\n  let rootEnd = 0;\n  let device: string | undefined;\n  let isAbsolute = false;\n  const code = path.charCodeAt(0);\n\n  // Try to match a root\n  if (len > 1) {\n    if (isPathSeparator(code)) {\n      // Possible UNC root\n\n      // If we started with a separator, we know we at least have an absolute\n      // path of some kind (UNC or otherwise)\n      isAbsolute = true;\n\n      if (isPathSeparator(path.charCodeAt(1))) {\n        // Matched double path separator at beginning\n        let j = 2;\n        let last = j;\n        // Match 1 or more non-path separators\n        for (; j < len; ++j) {\n          if (isPathSeparator(path.charCodeAt(j))) break;\n        }\n        if (j < len && j !== last) {\n          const firstPart = path.slice(last, j);\n          // Matched!\n          last = j;\n          // Match 1 or more path separators\n          for (; j < len; ++j) {\n            if (!isPathSeparator(path.charCodeAt(j))) break;\n          }\n          if (j < len && j !== last) {\n            // Matched!\n            last = j;\n            // Match 1 or more non-path separators\n            for (; j < len; ++j) {\n              if (isPathSeparator(path.charCodeAt(j))) break;\n            }\n            if (j === len) {\n              // We matched a UNC root only\n              // Return the normalized version of the UNC root since there\n              // is nothing left to process\n\n              return `\\\\\\\\${firstPart}\\\\${path.slice(last)}\\\\`;\n            } else if (j !== last) {\n              // We matched a UNC root with leftovers\n\n              device = `\\\\\\\\${firstPart}\\\\${path.slice(last, j)}`;\n              rootEnd = j;\n            }\n          }\n        }\n      } else {\n        rootEnd = 1;\n      }\n    } else if (isWindowsDeviceRoot(code)) {\n      // Possible device root\n\n      if (path.charCodeAt(1) === CHAR_COLON) {\n        device = path.slice(0, 2);\n        rootEnd = 2;\n        if (len > 2) {\n          if (isPathSeparator(path.charCodeAt(2))) {\n            // Treat separator following drive name as an absolute path\n            // indicator\n            isAbsolute = true;\n            rootEnd = 3;\n          }\n        }\n      }\n    }\n  } else if (isPathSeparator(code)) {\n    // `path` contains just a path separator, exit early to avoid unnecessary\n    // work\n    return \"\\\\\";\n  }\n\n  let tail: string;\n  if (rootEnd < len) {\n    tail = normalizeString(\n      path.slice(rootEnd),\n      !isAbsolute,\n      \"\\\\\",\n      isPathSeparator,\n    );\n  } else {\n    tail = \"\";\n  }\n  if (tail.length === 0 && !isAbsolute) tail = \".\";\n  if (tail.length > 0 && isPathSeparator(path.charCodeAt(len - 1))) {\n    tail += \"\\\\\";\n  }\n  if (device === undefined) {\n    if (isAbsolute) {\n      if (tail.length > 0) return `\\\\${tail}`;\n      else return \"\\\\\";\n    } else if (tail.length > 0) {\n      return tail;\n    } else {\n      return \"\";\n    }\n  } else if (isAbsolute) {\n    if (tail.length > 0) return `${device}\\\\${tail}`;\n    else return `${device}\\\\`;\n  } else if (tail.length > 0) {\n    return device + tail;\n  } else {\n    return device;\n  }\n}\n\n/**\n * Verifies whether path is absolute\n * @param path to verify\n */\nexport function isAbsolute(path: string): boolean {\n  assertPath(path);\n  const len = path.length;\n  if (len === 0) return false;\n\n  const code = path.charCodeAt(0);\n  if (isPathSeparator(code)) {\n    return true;\n  } else if (isWindowsDeviceRoot(code)) {\n    // Possible device root\n\n    if (len > 2 && path.charCodeAt(1) === CHAR_COLON) {\n      if (isPathSeparator(path.charCodeAt(2))) return true;\n    }\n  }\n  return false;\n}\n\n/**\n * Join all given a sequence of `paths`,then normalizes the resulting path.\n * @param paths to be joined and normalized\n */\nexport function join(...paths: string[]): string {\n  const pathsCount = paths.length;\n  if (pathsCount === 0) return \".\";\n\n  let joined: string | undefined;\n  let firstPart: string | null = null;\n  for (let i = 0; i < pathsCount; ++i) {\n    const path = paths[i];\n    assertPath(path);\n    if (path.length > 0) {\n      if (joined === undefined) joined = firstPart = path;\n      else joined += `\\\\${path}`;\n    }\n  }\n\n  if (joined === undefined) return \".\";\n\n  // Make sure that the joined path doesn't start with two slashes, because\n  // normalize() will mistake it for an UNC path then.\n  //\n  // This step is skipped when it is very clear that the user actually\n  // intended to point at an UNC path. This is assumed when the first\n  // non-empty string arguments starts with exactly two slashes followed by\n  // at least one more non-slash character.\n  //\n  // Note that for normalize() to treat a path as an UNC path it needs to\n  // have at least 2 components, so we don't filter for that here.\n  // This means that the user can use join to construct UNC paths from\n  // a server name and a share name; for example:\n  //   path.join('//server', 'share') -> '\\\\\\\\server\\\\share\\\\')\n  let needsReplace = true;\n  let slashCount = 0;\n  assert(firstPart != null);\n  if (isPathSeparator(firstPart.charCodeAt(0))) {\n    ++slashCount;\n    const firstLen = firstPart.length;\n    if (firstLen > 1) {\n      if (isPathSeparator(firstPart.charCodeAt(1))) {\n        ++slashCount;\n        if (firstLen > 2) {\n          if (isPathSeparator(firstPart.charCodeAt(2))) ++slashCount;\n          else {\n            // We matched a UNC path in the first part\n            needsReplace = false;\n          }\n        }\n      }\n    }\n  }\n  if (needsReplace) {\n    // Find any more consecutive slashes we need to replace\n    for (; slashCount < joined.length; ++slashCount) {\n      if (!isPathSeparator(joined.charCodeAt(slashCount))) break;\n    }\n\n    // Replace the slashes if needed\n    if (slashCount >= 2) joined = `\\\\${joined.slice(slashCount)}`;\n  }\n\n  return normalize(joined);\n}\n\n/**\n * It will solve the relative path from `from` to `to`, for instance:\n *  from = 'C:\\\\orandea\\\\test\\\\aaa'\n *  to = 'C:\\\\orandea\\\\impl\\\\bbb'\n * The output of the function should be: '..\\\\..\\\\impl\\\\bbb'\n * @param from relative path\n * @param to relative path\n */\nexport function relative(from: string, to: string): string {\n  assertPath(from);\n  assertPath(to);\n\n  if (from === to) return \"\";\n\n  const fromOrig = resolve(from);\n  const toOrig = resolve(to);\n\n  if (fromOrig === toOrig) return \"\";\n\n  from = fromOrig.toLowerCase();\n  to = toOrig.toLowerCase();\n\n  if (from === to) return \"\";\n\n  // Trim any leading backslashes\n  let fromStart = 0;\n  let fromEnd = from.length;\n  for (; fromStart < fromEnd; ++fromStart) {\n    if (from.charCodeAt(fromStart) !== CHAR_BACKWARD_SLASH) break;\n  }\n  // Trim trailing backslashes (applicable to UNC paths only)\n  for (; fromEnd - 1 > fromStart; --fromEnd) {\n    if (from.charCodeAt(fromEnd - 1) !== CHAR_BACKWARD_SLASH) break;\n  }\n  const fromLen = fromEnd - fromStart;\n\n  // Trim any leading backslashes\n  let toStart = 0;\n  let toEnd = to.length;\n  for (; toStart < toEnd; ++toStart) {\n    if (to.charCodeAt(toStart) !== CHAR_BACKWARD_SLASH) break;\n  }\n  // Trim trailing backslashes (applicable to UNC paths only)\n  for (; toEnd - 1 > toStart; --toEnd) {\n    if (to.charCodeAt(toEnd - 1) !== CHAR_BACKWARD_SLASH) break;\n  }\n  const toLen = toEnd - toStart;\n\n  // Compare paths to find the longest common path from root\n  const length = fromLen < toLen ? fromLen : toLen;\n  let lastCommonSep = -1;\n  let i = 0;\n  for (; i <= length; ++i) {\n    if (i === length) {\n      if (toLen > length) {\n        if (to.charCodeAt(toStart + i) === CHAR_BACKWARD_SLASH) {\n          // We get here if `from` is the exact base path for `to`.\n          // For example: from='C:\\\\foo\\\\bar'; to='C:\\\\foo\\\\bar\\\\baz'\n          return toOrig.slice(toStart + i + 1);\n        } else if (i === 2) {\n          // We get here if `from` is the device root.\n          // For example: from='C:\\\\'; to='C:\\\\foo'\n          return toOrig.slice(toStart + i);\n        }\n      }\n      if (fromLen > length) {\n        if (from.charCodeAt(fromStart + i) === CHAR_BACKWARD_SLASH) {\n          // We get here if `to` is the exact base path for `from`.\n          // For example: from='C:\\\\foo\\\\bar'; to='C:\\\\foo'\n          lastCommonSep = i;\n        } else if (i === 2) {\n          // We get here if `to` is the device root.\n          // For example: from='C:\\\\foo\\\\bar'; to='C:\\\\'\n          lastCommonSep = 3;\n        }\n      }\n      break;\n    }\n    const fromCode = from.charCodeAt(fromStart + i);\n    const toCode = to.charCodeAt(toStart + i);\n    if (fromCode !== toCode) break;\n    else if (fromCode === CHAR_BACKWARD_SLASH) lastCommonSep = i;\n  }\n\n  // We found a mismatch before the first common path separator was seen, so\n  // return the original `to`.\n  if (i !== length && lastCommonSep === -1) {\n    return toOrig;\n  }\n\n  let out = \"\";\n  if (lastCommonSep === -1) lastCommonSep = 0;\n  // Generate the relative path based on the path difference between `to` and\n  // `from`\n  for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {\n    if (i === fromEnd || from.charCodeAt(i) === CHAR_BACKWARD_SLASH) {\n      if (out.length === 0) out += \"..\";\n      else out += \"\\\\..\";\n    }\n  }\n\n  // Lastly, append the rest of the destination (`to`) path that comes after\n  // the common path parts\n  if (out.length > 0) {\n    return out + toOrig.slice(toStart + lastCommonSep, toEnd);\n  } else {\n    toStart += lastCommonSep;\n    if (toOrig.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) ++toStart;\n    return toOrig.slice(toStart, toEnd);\n  }\n}\n\n/**\n * Resolves path to a namespace path\n * @param path to resolve to namespace\n */\nexport function toNamespacedPath(path: string): string {\n  // Note: this will *probably* throw somewhere.\n  if (typeof path !== \"string\") return path;\n  if (path.length === 0) return \"\";\n\n  const resolvedPath = resolve(path);\n\n  if (resolvedPath.length >= 3) {\n    if (resolvedPath.charCodeAt(0) === CHAR_BACKWARD_SLASH) {\n      // Possible UNC root\n\n      if (resolvedPath.charCodeAt(1) === CHAR_BACKWARD_SLASH) {\n        const code = resolvedPath.charCodeAt(2);\n        if (code !== CHAR_QUESTION_MARK && code !== CHAR_DOT) {\n          // Matched non-long UNC root, convert the path to a long UNC path\n          return `\\\\\\\\?\\\\UNC\\\\${resolvedPath.slice(2)}`;\n        }\n      }\n    } else if (isWindowsDeviceRoot(resolvedPath.charCodeAt(0))) {\n      // Possible device root\n\n      if (\n        resolvedPath.charCodeAt(1) === CHAR_COLON &&\n        resolvedPath.charCodeAt(2) === CHAR_BACKWARD_SLASH\n      ) {\n        // Matched device root, convert the path to a long UNC path\n        return `\\\\\\\\?\\\\${resolvedPath}`;\n      }\n    }\n  }\n\n  return path;\n}\n\n/**\n * Return the directory name of a `path`.\n * @param path to determine name for\n */\nexport function dirname(path: string): string {\n  assertPath(path);\n  const len = path.length;\n  if (len === 0) return \".\";\n  let rootEnd = -1;\n  let end = -1;\n  let matchedSlash = true;\n  let offset = 0;\n  const code = path.charCodeAt(0);\n\n  // Try to match a root\n  if (len > 1) {\n    if (isPathSeparator(code)) {\n      // Possible UNC root\n\n      rootEnd = offset = 1;\n\n      if (isPathSeparator(path.charCodeAt(1))) {\n        // Matched double path separator at beginning\n        let j = 2;\n        let last = j;\n        // Match 1 or more non-path separators\n        for (; j < len; ++j) {\n          if (isPathSeparator(path.charCodeAt(j))) break;\n        }\n        if (j < len && j !== last) {\n          // Matched!\n          last = j;\n          // Match 1 or more path separators\n          for (; j < len; ++j) {\n            if (!isPathSeparator(path.charCodeAt(j))) break;\n          }\n          if (j < len && j !== last) {\n            // Matched!\n            last = j;\n            // Match 1 or more non-path separators\n            for (; j < len; ++j) {\n              if (isPathSeparator(path.charCodeAt(j))) break;\n            }\n            if (j === len) {\n              // We matched a UNC root only\n              return path;\n            }\n            if (j !== last) {\n              // We matched a UNC root with leftovers\n\n              // Offset by 1 to include the separator after the UNC root to\n              // treat it as a \"normal root\" on top of a (UNC) root\n              rootEnd = offset = j + 1;\n            }\n          }\n        }\n      }\n    } else if (isWindowsDeviceRoot(code)) {\n      // Possible device root\n\n      if (path.charCodeAt(1) === CHAR_COLON) {\n        rootEnd = offset = 2;\n        if (len > 2) {\n          if (isPathSeparator(path.charCodeAt(2))) rootEnd = offset = 3;\n        }\n      }\n    }\n  } else if (isPathSeparator(code)) {\n    // `path` contains just a path separator, exit early to avoid\n    // unnecessary work\n    return path;\n  }\n\n  for (let i = len - 1; i >= offset; --i) {\n    if (isPathSeparator(path.charCodeAt(i))) {\n      if (!matchedSlash) {\n        end = i;\n        break;\n      }\n    } else {\n      // We saw the first non-path separator\n      matchedSlash = false;\n    }\n  }\n\n  if (end === -1) {\n    if (rootEnd === -1) return \".\";\n    else end = rootEnd;\n  }\n  return path.slice(0, end);\n}\n\n/**\n * Return the last portion of a `path`. Trailing directory separators are ignored.\n * @param path to process\n * @param ext of path directory\n */\nexport function basename(path: string, ext = \"\"): string {\n  if (ext !== undefined && typeof ext !== \"string\") {\n    throw new TypeError('\"ext\" argument must be a string');\n  }\n\n  assertPath(path);\n\n  let start = 0;\n  let end = -1;\n  let matchedSlash = true;\n  let i: number;\n\n  // Check for a drive letter prefix so as not to mistake the following\n  // path separator as an extra separator at the end of the path that can be\n  // disregarded\n  if (path.length >= 2) {\n    const drive = path.charCodeAt(0);\n    if (isWindowsDeviceRoot(drive)) {\n      if (path.charCodeAt(1) === CHAR_COLON) start = 2;\n    }\n  }\n\n  if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {\n    if (ext.length === path.length && ext === path) return \"\";\n    let extIdx = ext.length - 1;\n    let firstNonSlashEnd = -1;\n    for (i = path.length - 1; i >= start; --i) {\n      const code = path.charCodeAt(i);\n      if (isPathSeparator(code)) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          start = i + 1;\n          break;\n        }\n      } else {\n        if (firstNonSlashEnd === -1) {\n          // We saw the first non-path separator, remember this index in case\n          // we need it if the extension ends up not matching\n          matchedSlash = false;\n          firstNonSlashEnd = i + 1;\n        }\n        if (extIdx >= 0) {\n          // Try to match the explicit extension\n          if (code === ext.charCodeAt(extIdx)) {\n            if (--extIdx === -1) {\n              // We matched the extension, so mark this as the end of our path\n              // component\n              end = i;\n            }\n          } else {\n            // Extension does not match, so our result is the entire path\n            // component\n            extIdx = -1;\n            end = firstNonSlashEnd;\n          }\n        }\n      }\n    }\n\n    if (start === end) end = firstNonSlashEnd;\n    else if (end === -1) end = path.length;\n    return path.slice(start, end);\n  } else {\n    for (i = path.length - 1; i >= start; --i) {\n      if (isPathSeparator(path.charCodeAt(i))) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          start = i + 1;\n          break;\n        }\n      } else if (end === -1) {\n        // We saw the first non-path separator, mark this as the end of our\n        // path component\n        matchedSlash = false;\n        end = i + 1;\n      }\n    }\n\n    if (end === -1) return \"\";\n    return path.slice(start, end);\n  }\n}\n\n/**\n * Return the extension of the `path` with leading period.\n * @param path with extension\n * @returns extension (ex. for `file.ts` returns `.ts`)\n */\nexport function extname(path: string): string {\n  assertPath(path);\n  let start = 0;\n  let startDot = -1;\n  let startPart = 0;\n  let end = -1;\n  let matchedSlash = true;\n  // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find\n  let preDotState = 0;\n\n  // Check for a drive letter prefix so as not to mistake the following\n  // path separator as an extra separator at the end of the path that can be\n  // disregarded\n\n  if (\n    path.length >= 2 &&\n    path.charCodeAt(1) === CHAR_COLON &&\n    isWindowsDeviceRoot(path.charCodeAt(0))\n  ) {\n    start = startPart = 2;\n  }\n\n  for (let i = path.length - 1; i >= start; --i) {\n    const code = path.charCodeAt(i);\n    if (isPathSeparator(code)) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now\n      if (!matchedSlash) {\n        startPart = i + 1;\n        break;\n      }\n      continue;\n    }\n    if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension\n      matchedSlash = false;\n      end = i + 1;\n    }\n    if (code === CHAR_DOT) {\n      // If this is our first dot, mark it as the start of our extension\n      if (startDot === -1) startDot = i;\n      else if (preDotState !== 1) preDotState = 1;\n    } else if (startDot !== -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension\n      preDotState = -1;\n    }\n  }\n\n  if (\n    startDot === -1 ||\n    end === -1 ||\n    // We saw a non-dot character immediately before the dot\n    preDotState === 0 ||\n    // The (right-most) trimmed path component is exactly '..'\n    (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)\n  ) {\n    return \"\";\n  }\n  return path.slice(startDot, end);\n}\n\n/**\n * Generate a path from `FormatInputPathObject` object.\n * @param pathObject with path\n */\nexport function format(pathObject: FormatInputPathObject): string {\n  if (pathObject === null || typeof pathObject !== \"object\") {\n    throw new TypeError(\n      `The \"pathObject\" argument must be of type Object. Received type ${typeof pathObject}`,\n    );\n  }\n  return _format(\"\\\\\", pathObject);\n}\n\n/**\n * Return a `ParsedPath` object of the `path`.\n * @param path to process\n */\nexport function parse(path: string): ParsedPath {\n  assertPath(path);\n\n  const ret: ParsedPath = { root: \"\", dir: \"\", base: \"\", ext: \"\", name: \"\" };\n\n  const len = path.length;\n  if (len === 0) return ret;\n\n  let rootEnd = 0;\n  let code = path.charCodeAt(0);\n\n  // Try to match a root\n  if (len > 1) {\n    if (isPathSeparator(code)) {\n      // Possible UNC root\n\n      rootEnd = 1;\n      if (isPathSeparator(path.charCodeAt(1))) {\n        // Matched double path separator at beginning\n        let j = 2;\n        let last = j;\n        // Match 1 or more non-path separators\n        for (; j < len; ++j) {\n          if (isPathSeparator(path.charCodeAt(j))) break;\n        }\n        if (j < len && j !== last) {\n          // Matched!\n          last = j;\n          // Match 1 or more path separators\n          for (; j < len; ++j) {\n            if (!isPathSeparator(path.charCodeAt(j))) break;\n          }\n          if (j < len && j !== last) {\n            // Matched!\n            last = j;\n            // Match 1 or more non-path separators\n            for (; j < len; ++j) {\n              if (isPathSeparator(path.charCodeAt(j))) break;\n            }\n            if (j === len) {\n              // We matched a UNC root only\n\n              rootEnd = j;\n            } else if (j !== last) {\n              // We matched a UNC root with leftovers\n\n              rootEnd = j + 1;\n            }\n          }\n        }\n      }\n    } else if (isWindowsDeviceRoot(code)) {\n      // Possible device root\n\n      if (path.charCodeAt(1) === CHAR_COLON) {\n        rootEnd = 2;\n        if (len > 2) {\n          if (isPathSeparator(path.charCodeAt(2))) {\n            if (len === 3) {\n              // `path` contains just a drive root, exit early to avoid\n              // unnecessary work\n              ret.root = ret.dir = path;\n              return ret;\n            }\n            rootEnd = 3;\n          }\n        } else {\n          // `path` contains just a drive root, exit early to avoid\n          // unnecessary work\n          ret.root = ret.dir = path;\n          return ret;\n        }\n      }\n    }\n  } else if (isPathSeparator(code)) {\n    // `path` contains just a path separator, exit early to avoid\n    // unnecessary work\n    ret.root = ret.dir = path;\n    return ret;\n  }\n\n  if (rootEnd > 0) ret.root = path.slice(0, rootEnd);\n\n  let startDot = -1;\n  let startPart = rootEnd;\n  let end = -1;\n  let matchedSlash = true;\n  let i = path.length - 1;\n\n  // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find\n  let preDotState = 0;\n\n  // Get non-dir info\n  for (; i >= rootEnd; --i) {\n    code = path.charCodeAt(i);\n    if (isPathSeparator(code)) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now\n      if (!matchedSlash) {\n        startPart = i + 1;\n        break;\n      }\n      continue;\n    }\n    if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension\n      matchedSlash = false;\n      end = i + 1;\n    }\n    if (code === CHAR_DOT) {\n      // If this is our first dot, mark it as the start of our extension\n      if (startDot === -1) startDot = i;\n      else if (preDotState !== 1) preDotState = 1;\n    } else if (startDot !== -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension\n      preDotState = -1;\n    }\n  }\n\n  if (\n    startDot === -1 ||\n    end === -1 ||\n    // We saw a non-dot character immediately before the dot\n    preDotState === 0 ||\n    // The (right-most) trimmed path component is exactly '..'\n    (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)\n  ) {\n    if (end !== -1) {\n      ret.base = ret.name = path.slice(startPart, end);\n    }\n  } else {\n    ret.name = path.slice(startPart, startDot);\n    ret.base = path.slice(startPart, end);\n    ret.ext = path.slice(startDot, end);\n  }\n\n  // If the directory is the root, use the entire root as the `dir` including\n  // the trailing slash if any (`C:\\abc` -> `C:\\`). Otherwise, strip out the\n  // trailing slash (`C:\\abc\\def` -> `C:\\abc`).\n  if (startPart > 0 && startPart !== rootEnd) {\n    ret.dir = path.slice(0, startPart - 1);\n  } else ret.dir = ret.root;\n\n  return ret;\n}\n\n/**\n * Converts a file URL to a path string.\n *\n * ```ts\n *      import { fromFileUrl } from \"./win32.ts\";\n *      fromFileUrl(\"file:///home/foo\"); // \"\\\\home\\\\foo\"\n *      fromFileUrl(\"file:///C:/Users/foo\"); // \"C:\\\\Users\\\\foo\"\n *      fromFileUrl(\"file://localhost/home/foo\"); // \"\\\\\\\\localhost\\\\home\\\\foo\"\n * ```\n * @param url of a file URL\n */\nexport function fromFileUrl(url: string | URL): string {\n  url = url instanceof URL ? url : new URL(url);\n  if (url.protocol != \"file:\") {\n    throw new TypeError(\"Must be a file URL.\");\n  }\n  let path = decodeURIComponent(\n    url.pathname.replace(/\\//g, \"\\\\\").replace(/%(?![0-9A-Fa-f]{2})/g, \"%25\"),\n  ).replace(/^\\\\*([A-Za-z]:)(\\\\|$)/, \"$1\\\\\");\n  if (url.hostname != \"\") {\n    // Note: The `URL` implementation guarantees that the drive letter and\n    // hostname are mutually exclusive. Otherwise it would not have been valid\n    // to append the hostname and path like this.\n    path = `\\\\\\\\${url.hostname}${path}`;\n  }\n  return path;\n}\n\n/**\n * Converts a path string to a file URL.\n *\n * ```ts\n *      import { toFileUrl } from \"./win32.ts\";\n *      toFileUrl(\"\\\\home\\\\foo\"); // new URL(\"file:///home/foo\")\n *      toFileUrl(\"C:\\\\Users\\\\foo\"); // new URL(\"file:///C:/Users/foo\")\n *      toFileUrl(\"\\\\\\\\127.0.0.1\\\\home\\\\foo\"); // new URL(\"file://127.0.0.1/home/foo\")\n * ```\n * @param path to convert to file URL\n */\nexport function toFileUrl(path: string): URL {\n  if (!isAbsolute(path)) {\n    throw new TypeError(\"Must be an absolute path.\");\n  }\n  const [, hostname, pathname] = path.match(\n    /^(?:[/\\\\]{2}([^/\\\\]+)(?=[/\\\\](?:[^/\\\\]|$)))?(.*)/,\n  )!;\n  const url = new URL(\"file:///\");\n  url.pathname = encodeWhitespace(pathname.replace(/%/g, \"%25\"));\n  if (hostname != null && hostname != \"localhost\") {\n    url.hostname = hostname;\n    if (!url.hostname) {\n      throw new TypeError(\"Invalid hostname.\");\n    }\n  }\n  return url;\n}\n","// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.\n// Copyright the Browserify authors. MIT License.\n// Ported from https://github.com/browserify/path-browserify/\n// This module is browser compatible.\n\nimport type { FormatInputPathObject, ParsedPath } from \"./_interface.ts\";\nimport { CHAR_DOT, CHAR_FORWARD_SLASH } from \"./_constants.ts\";\n\nimport {\n  _format,\n  assertPath,\n  encodeWhitespace,\n  isPosixPathSeparator,\n  normalizeString,\n} from \"./_util.ts\";\n\nexport const sep = \"/\";\nexport const delimiter = \":\";\n\n// path.resolve([from ...], to)\n/**\n * Resolves `pathSegments` into an absolute path.\n * @param pathSegments an array of path segments\n */\nexport function resolve(...pathSegments: string[]): string {\n  let resolvedPath = \"\";\n  let resolvedAbsolute = false;\n\n  for (let i = pathSegments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n    let path: string;\n\n    if (i >= 0) path = pathSegments[i];\n    else {\n      // deno-lint-ignore no-explicit-any\n      const { Deno } = globalThis as any;\n      if (typeof Deno?.cwd !== \"function\") {\n        throw new TypeError(\"Resolved a relative path without a CWD.\");\n      }\n      path = Deno.cwd();\n    }\n\n    assertPath(path);\n\n    // Skip empty entries\n    if (path.length === 0) {\n      continue;\n    }\n\n    resolvedPath = `${path}/${resolvedPath}`;\n    resolvedAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;\n  }\n\n  // At this point the path should be resolved to a full absolute path, but\n  // handle relative paths to be safe (might happen when process.cwd() fails)\n\n  // Normalize the path\n  resolvedPath = normalizeString(\n    resolvedPath,\n    !resolvedAbsolute,\n    \"/\",\n    isPosixPathSeparator,\n  );\n\n  if (resolvedAbsolute) {\n    if (resolvedPath.length > 0) return `/${resolvedPath}`;\n    else return \"/\";\n  } else if (resolvedPath.length > 0) return resolvedPath;\n  else return \".\";\n}\n\n/**\n * Normalize the `path`, resolving `'..'` and `'.'` segments.\n * @param path to be normalized\n */\nexport function normalize(path: string): string {\n  assertPath(path);\n\n  if (path.length === 0) return \".\";\n\n  const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;\n  const trailingSeparator =\n    path.charCodeAt(path.length - 1) === CHAR_FORWARD_SLASH;\n\n  // Normalize the path\n  path = normalizeString(path, !isAbsolute, \"/\", isPosixPathSeparator);\n\n  if (path.length === 0 && !isAbsolute) path = \".\";\n  if (path.length > 0 && trailingSeparator) path += \"/\";\n\n  if (isAbsolute) return `/${path}`;\n  return path;\n}\n\n/**\n * Verifies whether provided path is absolute\n * @param path to be verified as absolute\n */\nexport function isAbsolute(path: string): boolean {\n  assertPath(path);\n  return path.length > 0 && path.charCodeAt(0) === CHAR_FORWARD_SLASH;\n}\n\n/**\n * Join all given a sequence of `paths`,then normalizes the resulting path.\n * @param paths to be joined and normalized\n */\nexport function join(...paths: string[]): string {\n  if (paths.length === 0) return \".\";\n  let joined: string | undefined;\n  for (let i = 0, len = paths.length; i < len; ++i) {\n    const path = paths[i];\n    assertPath(path);\n    if (path.length > 0) {\n      if (!joined) joined = path;\n      else joined += `/${path}`;\n    }\n  }\n  if (!joined) return \".\";\n  return normalize(joined);\n}\n\n/**\n * Return the relative path from `from` to `to` based on current working directory.\n * @param from path in current working directory\n * @param to path in current working directory\n */\nexport function relative(from: string, to: string): string {\n  assertPath(from);\n  assertPath(to);\n\n  if (from === to) return \"\";\n\n  from = resolve(from);\n  to = resolve(to);\n\n  if (from === to) return \"\";\n\n  // Trim any leading backslashes\n  let fromStart = 1;\n  const fromEnd = from.length;\n  for (; fromStart < fromEnd; ++fromStart) {\n    if (from.charCodeAt(fromStart) !== CHAR_FORWARD_SLASH) break;\n  }\n  const fromLen = fromEnd - fromStart;\n\n  // Trim any leading backslashes\n  let toStart = 1;\n  const toEnd = to.length;\n  for (; toStart < toEnd; ++toStart) {\n    if (to.charCodeAt(toStart) !== CHAR_FORWARD_SLASH) break;\n  }\n  const toLen = toEnd - toStart;\n\n  // Compare paths to find the longest common path from root\n  const length = fromLen < toLen ? fromLen : toLen;\n  let lastCommonSep = -1;\n  let i = 0;\n  for (; i <= length; ++i) {\n    if (i === length) {\n      if (toLen > length) {\n        if (to.charCodeAt(toStart + i) === CHAR_FORWARD_SLASH) {\n          // We get here if `from` is the exact base path for `to`.\n          // For example: from='/foo/bar'; to='/foo/bar/baz'\n          return to.slice(toStart + i + 1);\n        } else if (i === 0) {\n          // We get here if `from` is the root\n          // For example: from='/'; to='/foo'\n          return to.slice(toStart + i);\n        }\n      } else if (fromLen > length) {\n        if (from.charCodeAt(fromStart + i) === CHAR_FORWARD_SLASH) {\n          // We get here if `to` is the exact base path for `from`.\n          // For example: from='/foo/bar/baz'; to='/foo/bar'\n          lastCommonSep = i;\n        } else if (i === 0) {\n          // We get here if `to` is the root.\n          // For example: from='/foo'; to='/'\n          lastCommonSep = 0;\n        }\n      }\n      break;\n    }\n    const fromCode = from.charCodeAt(fromStart + i);\n    const toCode = to.charCodeAt(toStart + i);\n    if (fromCode !== toCode) break;\n    else if (fromCode === CHAR_FORWARD_SLASH) lastCommonSep = i;\n  }\n\n  let out = \"\";\n  // Generate the relative path based on the path difference between `to`\n  // and `from`\n  for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {\n    if (i === fromEnd || from.charCodeAt(i) === CHAR_FORWARD_SLASH) {\n      if (out.length === 0) out += \"..\";\n      else out += \"/..\";\n    }\n  }\n\n  // Lastly, append the rest of the destination (`to`) path that comes after\n  // the common path parts\n  if (out.length > 0) return out + to.slice(toStart + lastCommonSep);\n  else {\n    toStart += lastCommonSep;\n    if (to.charCodeAt(toStart) === CHAR_FORWARD_SLASH) ++toStart;\n    return to.slice(toStart);\n  }\n}\n\n/**\n * Resolves path to a namespace path\n * @param path to resolve to namespace\n */\nexport function toNamespacedPath(path: string): string {\n  // Non-op on posix systems\n  return path;\n}\n\n/**\n * Return the directory name of a `path`.\n * @param path to determine name for\n */\nexport function dirname(path: string): string {\n  assertPath(path);\n  if (path.length === 0) return \".\";\n  const hasRoot = path.charCodeAt(0) === CHAR_FORWARD_SLASH;\n  let end = -1;\n  let matchedSlash = true;\n  for (let i = path.length - 1; i >= 1; --i) {\n    if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {\n      if (!matchedSlash) {\n        end = i;\n        break;\n      }\n    } else {\n      // We saw the first non-path separator\n      matchedSlash = false;\n    }\n  }\n\n  if (end === -1) return hasRoot ? \"/\" : \".\";\n  if (hasRoot && end === 1) return \"//\";\n  return path.slice(0, end);\n}\n\n/**\n * Return the last portion of a `path`. Trailing directory separators are ignored.\n * @param path to process\n * @param ext of path directory\n */\nexport function basename(path: string, ext = \"\"): string {\n  if (ext !== undefined && typeof ext !== \"string\") {\n    throw new TypeError('\"ext\" argument must be a string');\n  }\n  assertPath(path);\n\n  let start = 0;\n  let end = -1;\n  let matchedSlash = true;\n  let i: number;\n\n  if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {\n    if (ext.length === path.length && ext === path) return \"\";\n    let extIdx = ext.length - 1;\n    let firstNonSlashEnd = -1;\n    for (i = path.length - 1; i >= 0; --i) {\n      const code = path.charCodeAt(i);\n      if (code === CHAR_FORWARD_SLASH) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          start = i + 1;\n          break;\n        }\n      } else {\n        if (firstNonSlashEnd === -1) {\n          // We saw the first non-path separator, remember this index in case\n          // we need it if the extension ends up not matching\n          matchedSlash = false;\n          firstNonSlashEnd = i + 1;\n        }\n        if (extIdx >= 0) {\n          // Try to match the explicit extension\n          if (code === ext.charCodeAt(extIdx)) {\n            if (--extIdx === -1) {\n              // We matched the extension, so mark this as the end of our path\n              // component\n              end = i;\n            }\n          } else {\n            // Extension does not match, so our result is the entire path\n            // component\n            extIdx = -1;\n            end = firstNonSlashEnd;\n          }\n        }\n      }\n    }\n\n    if (start === end) end = firstNonSlashEnd;\n    else if (end === -1) end = path.length;\n    return path.slice(start, end);\n  } else {\n    for (i = path.length - 1; i >= 0; --i) {\n      if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          start = i + 1;\n          break;\n        }\n      } else if (end === -1) {\n        // We saw the first non-path separator, mark this as the end of our\n        // path component\n        matchedSlash = false;\n        end = i + 1;\n      }\n    }\n\n    if (end === -1) return \"\";\n    return path.slice(start, end);\n  }\n}\n\n/**\n * Return the extension of the `path` with leading period.\n * @param path with extension\n * @returns extension (ex. for `file.ts` returns `.ts`)\n */\nexport function extname(path: string): string {\n  assertPath(path);\n  let startDot = -1;\n  let startPart = 0;\n  let end = -1;\n  let matchedSlash = true;\n  // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find\n  let preDotState = 0;\n  for (let i = path.length - 1; i >= 0; --i) {\n    const code = path.charCodeAt(i);\n    if (code === CHAR_FORWARD_SLASH) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now\n      if (!matchedSlash) {\n        startPart = i + 1;\n        break;\n      }\n      continue;\n    }\n    if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension\n      matchedSlash = false;\n      end = i + 1;\n    }\n    if (code === CHAR_DOT) {\n      // If this is our first dot, mark it as the start of our extension\n      if (startDot === -1) startDot = i;\n      else if (preDotState !== 1) preDotState = 1;\n    } else if (startDot !== -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension\n      preDotState = -1;\n    }\n  }\n\n  if (\n    startDot === -1 ||\n    end === -1 ||\n    // We saw a non-dot character immediately before the dot\n    preDotState === 0 ||\n    // The (right-most) trimmed path component is exactly '..'\n    (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)\n  ) {\n    return \"\";\n  }\n  return path.slice(startDot, end);\n}\n\n/**\n * Generate a path from `FormatInputPathObject` object.\n * @param pathObject with path\n */\nexport function format(pathObject: FormatInputPathObject): string {\n  if (pathObject === null || typeof pathObject !== \"object\") {\n    throw new TypeError(\n      `The \"pathObject\" argument must be of type Object. Received type ${typeof pathObject}`,\n    );\n  }\n  return _format(\"/\", pathObject);\n}\n\n/**\n * Return a `ParsedPath` object of the `path`.\n * @param path to process\n */\nexport function parse(path: string): ParsedPath {\n  assertPath(path);\n\n  const ret: ParsedPath = { root: \"\", dir: \"\", base: \"\", ext: \"\", name: \"\" };\n  if (path.length === 0) return ret;\n  const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;\n  let start: number;\n  if (isAbsolute) {\n    ret.root = \"/\";\n    start = 1;\n  } else {\n    start = 0;\n  }\n  let startDot = -1;\n  let startPart = 0;\n  let end = -1;\n  let matchedSlash = true;\n  let i = path.length - 1;\n\n  // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find\n  let preDotState = 0;\n\n  // Get non-dir info\n  for (; i >= start; --i) {\n    const code = path.charCodeAt(i);\n    if (code === CHAR_FORWARD_SLASH) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now\n      if (!matchedSlash) {\n        startPart = i + 1;\n        break;\n      }\n      continue;\n    }\n    if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension\n      matchedSlash = false;\n      end = i + 1;\n    }\n    if (code === CHAR_DOT) {\n      // If this is our first dot, mark it as the start of our extension\n      if (startDot === -1) startDot = i;\n      else if (preDotState !== 1) preDotState = 1;\n    } else if (startDot !== -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension\n      preDotState = -1;\n    }\n  }\n\n  if (\n    startDot === -1 ||\n    end === -1 ||\n    // We saw a non-dot character immediately before the dot\n    preDotState === 0 ||\n    // The (right-most) trimmed path component is exactly '..'\n    (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)\n  ) {\n    if (end !== -1) {\n      if (startPart === 0 && isAbsolute) {\n        ret.base = ret.name = path.slice(1, end);\n      } else {\n        ret.base = ret.name = path.slice(startPart, end);\n      }\n    }\n  } else {\n    if (startPart === 0 && isAbsolute) {\n      ret.name = path.slice(1, startDot);\n      ret.base = path.slice(1, end);\n    } else {\n      ret.name = path.slice(startPart, startDot);\n      ret.base = path.slice(startPart, end);\n    }\n    ret.ext = path.slice(startDot, end);\n  }\n\n  if (startPart > 0) ret.dir = path.slice(0, startPart - 1);\n  else if (isAbsolute) ret.dir = \"/\";\n\n  return ret;\n}\n\n/**\n * Converts a file URL to a path string.\n *\n * ```ts\n *      import { fromFileUrl } from \"./posix.ts\";\n *      fromFileUrl(\"file:///home/foo\"); // \"/home/foo\"\n * ```\n * @param url of a file URL\n */\nexport function fromFileUrl(url: string | URL): string {\n  url = url instanceof URL ? url : new URL(url);\n  if (url.protocol != \"file:\") {\n    throw new TypeError(\"Must be a file URL.\");\n  }\n  return decodeURIComponent(\n    url.pathname.replace(/%(?![0-9A-Fa-f]{2})/g, \"%25\"),\n  );\n}\n\n/**\n * Converts a path string to a file URL.\n *\n * ```ts\n *      import { toFileUrl } from \"./posix.ts\";\n *      toFileUrl(\"/home/foo\"); // new URL(\"file:///home/foo\")\n * ```\n * @param path to convert to file URL\n */\nexport function toFileUrl(path: string): URL {\n  if (!isAbsolute(path)) {\n    throw new TypeError(\"Must be an absolute path.\");\n  }\n  const url = new URL(\"file:///\");\n  url.pathname = encodeWhitespace(\n    path.replace(/%/g, \"%25\").replace(/\\\\/g, \"%5C\"),\n  );\n  return url;\n}\n","// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.\n// This module is browser compatible.\n\nimport { isWindows, osType } from \"../_util/os.ts\";\nimport { SEP, SEP_PATTERN } from \"./separator.ts\";\nimport * as _win32 from \"./win32.ts\";\nimport * as _posix from \"./posix.ts\";\nimport type { OSType } from \"../_util/os.ts\";\n\nconst path = isWindows ? _win32 : _posix;\nconst { join, normalize } = path;\n\nexport interface GlobOptions {\n  /** Extended glob syntax.\n   * See https://www.linuxjournal.com/content/bash-extended-globbing. Defaults\n   * to true. */\n  extended?: boolean;\n  /** Globstar syntax.\n   * See https://www.linuxjournal.com/content/globstar-new-bash-globbing-option.\n   * If false, `**` is treated like `*`. Defaults to true. */\n  globstar?: boolean;\n  /** Whether globstar should be case insensitive. */\n  caseInsensitive?: boolean;\n  /** Operating system. Defaults to the native OS. */\n  os?: OSType;\n}\n\nexport type GlobToRegExpOptions = GlobOptions;\n\nconst regExpEscapeChars = [\n  \"!\",\n  \"$\",\n  \"(\",\n  \")\",\n  \"*\",\n  \"+\",\n  \".\",\n  \"=\",\n  \"?\",\n  \"[\",\n  \"\\\\\",\n  \"^\",\n  \"{\",\n  \"|\",\n];\nconst rangeEscapeChars = [\"-\", \"\\\\\", \"]\"];\n\n/** Convert a glob string to a regular expression.\n *\n * Tries to match bash glob expansion as closely as possible.\n *\n * Basic glob syntax:\n * - `*` - Matches everything without leaving the path segment.\n * - `?` - Matches any single character.\n * - `{foo,bar}` - Matches `foo` or `bar`.\n * - `[abcd]` - Matches `a`, `b`, `c` or `d`.\n * - `[a-d]` - Matches `a`, `b`, `c` or `d`.\n * - `[!abcd]` - Matches any single character besides `a`, `b`, `c` or `d`.\n * - `[[:<class>:]]` - Matches any character belonging to `<class>`.\n *     - `[[:alnum:]]` - Matches any digit or letter.\n *     - `[[:digit:]abc]` - Matches any digit, `a`, `b` or `c`.\n *     - See https://facelessuser.github.io/wcmatch/glob/#posix-character-classes\n *       for a complete list of supported character classes.\n * - `\\` - Escapes the next character for an `os` other than `\"windows\"`.\n * - \\` - Escapes the next character for `os` set to `\"windows\"`.\n * - `/` - Path separator.\n * - `\\` - Additional path separator only for `os` set to `\"windows\"`.\n *\n * Extended syntax:\n * - Requires `{ extended: true }`.\n * - `?(foo|bar)` - Matches 0 or 1 instance of `{foo,bar}`.\n * - `@(foo|bar)` - Matches 1 instance of `{foo,bar}`. They behave the same.\n * - `*(foo|bar)` - Matches _n_ instances of `{foo,bar}`.\n * - `+(foo|bar)` - Matches _n > 0_ instances of `{foo,bar}`.\n * - `!(foo|bar)` - Matches anything other than `{foo,bar}`.\n * - See https://www.linuxjournal.com/content/bash-extended-globbing.\n *\n * Globstar syntax:\n * - Requires `{ globstar: true }`.\n * - `**` - Matches any number of any path segments.\n *     - Must comprise its entire path segment in the provided glob.\n * - See https://www.linuxjournal.com/content/globstar-new-bash-globbing-option.\n *\n * Note the following properties:\n * - The generated `RegExp` is anchored at both start and end.\n * - Repeating and trailing separators are tolerated. Trailing separators in the\n *   provided glob have no meaning and are discarded.\n * - Absolute globs will only match absolute paths, etc.\n * - Empty globs will match nothing.\n * - Any special glob syntax must be contained to one path segment. For example,\n *   `?(foo|bar/baz)` is invalid. The separator will take precedence and the\n *   first segment ends with an unclosed group.\n * - If a path segment ends with unclosed groups or a dangling escape prefix, a\n *   parse error has occurred. Every character for that segment is taken\n *   literally in this event.\n *\n * Limitations:\n * - A negative group like `!(foo|bar)` will wrongly be converted to a negative\n *   look-ahead followed by a wildcard. This means that `!(foo).js` will wrongly\n *   fail to match `foobar.js`, even though `foobar` is not `foo`. Effectively,\n *   `!(foo|bar)` is treated like `!(@(foo|bar)*)`. This will work correctly if\n *   the group occurs not nested at the end of the segment. */\nexport function globToRegExp(\n  glob: string,\n  {\n    extended = true,\n    globstar: globstarOption = true,\n    os = osType,\n    caseInsensitive = false,\n  }: GlobToRegExpOptions = {},\n): RegExp {\n  if (glob == \"\") {\n    return /(?!)/;\n  }\n\n  const sep = os == \"windows\" ? \"(?:\\\\\\\\|/)+\" : \"/+\";\n  const sepMaybe = os == \"windows\" ? \"(?:\\\\\\\\|/)*\" : \"/*\";\n  const seps = os == \"windows\" ? [\"\\\\\", \"/\"] : [\"/\"];\n  const globstar = os == \"windows\"\n    ? \"(?:[^\\\\\\\\/]*(?:\\\\\\\\|/|$)+)*\"\n    : \"(?:[^/]*(?:/|$)+)*\";\n  const wildcard = os == \"windows\" ? \"[^\\\\\\\\/]*\" : \"[^/]*\";\n  const escapePrefix = os == \"windows\" ? \"`\" : \"\\\\\";\n\n  // Remove trailing separators.\n  let newLength = glob.length;\n  for (; newLength > 1 && seps.includes(glob[newLength - 1]); newLength--);\n  glob = glob.slice(0, newLength);\n\n  let regExpString = \"\";\n\n  // Terminates correctly. Trust that `j` is incremented every iteration.\n  for (let j = 0; j < glob.length;) {\n    let segment = \"\";\n    const groupStack: string[] = [];\n    let inRange = false;\n    let inEscape = false;\n    let endsWithSep = false;\n    let i = j;\n\n    // Terminates with `i` at the non-inclusive end of the current segment.\n    for (; i < glob.length && !seps.includes(glob[i]); i++) {\n      if (inEscape) {\n        inEscape = false;\n        const escapeChars = inRange ? rangeEscapeChars : regExpEscapeChars;\n        segment += escapeChars.includes(glob[i]) ? `\\\\${glob[i]}` : glob[i];\n        continue;\n      }\n\n      if (glob[i] == escapePrefix) {\n        inEscape = true;\n        continue;\n      }\n\n      if (glob[i] == \"[\") {\n        if (!inRange) {\n          inRange = true;\n          segment += \"[\";\n          if (glob[i + 1] == \"!\") {\n            i++;\n            segment += \"^\";\n          } else if (glob[i + 1] == \"^\") {\n            i++;\n            segment += \"\\\\^\";\n          }\n          continue;\n        } else if (glob[i + 1] == \":\") {\n          let k = i + 1;\n          let value = \"\";\n          while (glob[k + 1] != null && glob[k + 1] != \":\") {\n            value += glob[k + 1];\n            k++;\n          }\n          if (glob[k + 1] == \":\" && glob[k + 2] == \"]\") {\n            i = k + 2;\n            if (value == \"alnum\") segment += \"\\\\dA-Za-z\";\n            else if (value == \"alpha\") segment += \"A-Za-z\";\n            else if (value == \"ascii\") segment += \"\\x00-\\x7F\";\n            else if (value == \"blank\") segment += \"\\t \";\n            else if (value == \"cntrl\") segment += \"\\x00-\\x1F\\x7F\";\n            else if (value == \"digit\") segment += \"\\\\d\";\n            else if (value == \"graph\") segment += \"\\x21-\\x7E\";\n            else if (value == \"lower\") segment += \"a-z\";\n            else if (value == \"print\") segment += \"\\x20-\\x7E\";\n            else if (value == \"punct\") {\n              segment += \"!\\\"#$%&'()*+,\\\\-./:;<=>?@[\\\\\\\\\\\\]^_‘{|}~\";\n            } else if (value == \"space\") segment += \"\\\\s\\v\";\n            else if (value == \"upper\") segment += \"A-Z\";\n            else if (value == \"word\") segment += \"\\\\w\";\n            else if (value == \"xdigit\") segment += \"\\\\dA-Fa-f\";\n            continue;\n          }\n        }\n      }\n\n      if (glob[i] == \"]\" && inRange) {\n        inRange = false;\n        segment += \"]\";\n        continue;\n      }\n\n      if (inRange) {\n        if (glob[i] == \"\\\\\") {\n          segment += `\\\\\\\\`;\n        } else {\n          segment += glob[i];\n        }\n        continue;\n      }\n\n      if (\n        glob[i] == \")\" && groupStack.length > 0 &&\n        groupStack[groupStack.length - 1] != \"BRACE\"\n      ) {\n        segment += \")\";\n        const type = groupStack.pop()!;\n        if (type == \"!\") {\n          segment += wildcard;\n        } else if (type != \"@\") {\n          segment += type;\n        }\n        continue;\n      }\n\n      if (\n        glob[i] == \"|\" && groupStack.length > 0 &&\n        groupStack[groupStack.length - 1] != \"BRACE\"\n      ) {\n        segment += \"|\";\n        continue;\n      }\n\n      if (glob[i] == \"+\" && extended && glob[i + 1] == \"(\") {\n        i++;\n        groupStack.push(\"+\");\n        segment += \"(?:\";\n        continue;\n      }\n\n      if (glob[i] == \"@\" && extended && glob[i + 1] == \"(\") {\n        i++;\n        groupStack.push(\"@\");\n        segment += \"(?:\";\n        continue;\n      }\n\n      if (glob[i] == \"?\") {\n        if (extended && glob[i + 1] == \"(\") {\n          i++;\n          groupStack.push(\"?\");\n          segment += \"(?:\";\n        } else {\n          segment += \".\";\n        }\n        continue;\n      }\n\n      if (glob[i] == \"!\" && extended && glob[i + 1] == \"(\") {\n        i++;\n        groupStack.push(\"!\");\n        segment += \"(?!\";\n        continue;\n      }\n\n      if (glob[i] == \"{\") {\n        groupStack.push(\"BRACE\");\n        segment += \"(?:\";\n        continue;\n      }\n\n      if (glob[i] == \"}\" && groupStack[groupStack.length - 1] == \"BRACE\") {\n        groupStack.pop();\n        segment += \")\";\n        continue;\n      }\n\n      if (glob[i] == \",\" && groupStack[groupStack.length - 1] == \"BRACE\") {\n        segment += \"|\";\n        continue;\n      }\n\n      if (glob[i] == \"*\") {\n        if (extended && glob[i + 1] == \"(\") {\n          i++;\n          groupStack.push(\"*\");\n          segment += \"(?:\";\n        } else {\n          const prevChar = glob[i - 1];\n          let numStars = 1;\n          while (glob[i + 1] == \"*\") {\n            i++;\n            numStars++;\n          }\n          const nextChar = glob[i + 1];\n          if (\n            globstarOption && numStars == 2 &&\n            [...seps, undefined].includes(prevChar) &&\n            [...seps, undefined].includes(nextChar)\n          ) {\n            segment += globstar;\n            endsWithSep = true;\n          } else {\n            segment += wildcard;\n          }\n        }\n        continue;\n      }\n\n      segment += regExpEscapeChars.includes(glob[i]) ? `\\\\${glob[i]}` : glob[i];\n    }\n\n    // Check for unclosed groups or a dangling backslash.\n    if (groupStack.length > 0 || inRange || inEscape) {\n      // Parse failure. Take all characters from this segment literally.\n      segment = \"\";\n      for (const c of glob.slice(j, i)) {\n        segment += regExpEscapeChars.includes(c) ? `\\\\${c}` : c;\n        endsWithSep = false;\n      }\n    }\n\n    regExpString += segment;\n    if (!endsWithSep) {\n      regExpString += i < glob.length ? sep : sepMaybe;\n      endsWithSep = true;\n    }\n\n    // Terminates with `i` at the start of the next segment.\n    while (seps.includes(glob[i])) i++;\n\n    // Check that the next value of `j` is indeed higher than the current value.\n    if (!(i > j)) {\n      throw new Error(\"Assertion failure: i > j (potential infinite loop)\");\n    }\n    j = i;\n  }\n\n  regExpString = `^${regExpString}$`;\n  return new RegExp(regExpString, caseInsensitive ? \"i\" : \"\");\n}\n\n/** Test whether the given string is a glob */\nexport function isGlob(str: string): boolean {\n  const chars: Record<string, string> = { \"{\": \"}\", \"(\": \")\", \"[\": \"]\" };\n  const regex =\n    /\\\\(.)|(^!|\\*|\\?|[\\].+)]\\?|\\[[^\\\\\\]]+\\]|\\{[^\\\\}]+\\}|\\(\\?[:!=][^\\\\)]+\\)|\\([^|]+\\|[^\\\\)]+\\))/;\n\n  if (str === \"\") {\n    return false;\n  }\n\n  let match: RegExpExecArray | null;\n\n  while ((match = regex.exec(str))) {\n    if (match[2]) return true;\n    let idx = match.index + match[0].length;\n\n    // if an open bracket/brace/paren is escaped,\n    // set the index to the next closing character\n    const open = match[1];\n    const close = open ? chars[open] : null;\n    if (open && close) {\n      const n = str.indexOf(close, idx);\n      if (n !== -1) {\n        idx = n + 1;\n      }\n    }\n\n    str = str.slice(idx);\n  }\n\n  return false;\n}\n\n/** Like normalize(), but doesn't collapse \"**\\/..\" when `globstar` is true. */\nexport function normalizeGlob(\n  glob: string,\n  { globstar = false }: GlobOptions = {},\n): string {\n  if (glob.match(/\\0/g)) {\n    throw new Error(`Glob contains invalid characters: \"${glob}\"`);\n  }\n  if (!globstar) {\n    return normalize(glob);\n  }\n  const s = SEP_PATTERN.source;\n  const badParentPattern = new RegExp(\n    `(?<=(${s}|^)\\\\*\\\\*${s})\\\\.\\\\.(?=${s}|$)`,\n    \"g\",\n  );\n  return normalize(glob.replace(badParentPattern, \"\\0\")).replace(/\\0/g, \"..\");\n}\n\n/** Like join(), but doesn't collapse \"**\\/..\" when `globstar` is true. */\nexport function joinGlobs(\n  globs: string[],\n  { extended = true, globstar = false }: GlobOptions = {},\n): string {\n  if (!globstar || globs.length == 0) {\n    return join(...globs);\n  }\n  if (globs.length === 0) return \".\";\n  let joined: string | undefined;\n  for (const glob of globs) {\n    const path = glob;\n    if (path.length > 0) {\n      if (!joined) joined = path;\n      else joined += `${SEP}${path}`;\n    }\n  }\n  if (!joined) return \".\";\n  return normalizeGlob(joined, { extended, globstar });\n}\n","// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.\n// Copyright the Browserify authors. MIT License.\n\n/**\n * Ported mostly from https://github.com/browserify/path-browserify/\n * This module is browser compatible.\n * @module\n */\n\nimport { isWindows } from \"../_util/os.ts\";\nimport * as _win32 from \"./win32.ts\";\nimport * as _posix from \"./posix.ts\";\n\nconst path = isWindows ? _win32 : _posix;\n\nexport const win32 = _win32;\nexport const posix = _posix;\nexport const {\n  basename,\n  delimiter,\n  dirname,\n  extname,\n  format,\n  fromFileUrl,\n  isAbsolute,\n  join,\n  normalize,\n  parse,\n  relative,\n  resolve,\n  sep,\n  toFileUrl,\n  toNamespacedPath,\n} = path;\n\nexport * from \"./common.ts\";\nexport { SEP, SEP_PATTERN } from \"./separator.ts\";\nexport * from \"./_interface.ts\";\nexport * from \"./glob.ts\";\n","// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.\n\nimport { Buffer } from \"../io/buffer.ts\";\n\nconst DEFAULT_CHUNK_SIZE = 16_640;\nconst DEFAULT_BUFFER_SIZE = 32 * 1024;\n\nfunction isCloser(value: unknown): value is Deno.Closer {\n  return typeof value === \"object\" && value != null && \"close\" in value &&\n    // deno-lint-ignore no-explicit-any\n    typeof (value as Record<string, any>)[\"close\"] === \"function\";\n}\n\n/** Create a `Deno.Reader` from an iterable of `Uint8Array`s.\n *\n * ```ts\n *      import { readerFromIterable } from \"./conversion.ts\";\n *\n *      const file = await Deno.open(\"metrics.txt\", { write: true });\n *      const reader = readerFromIterable((async function* () {\n *        while (true) {\n *          await new Promise((r) => setTimeout(r, 1000));\n *          const message = `data: ${JSON.stringify(Deno.metrics())}\\n\\n`;\n *          yield new TextEncoder().encode(message);\n *        }\n *      })());\n *      await Deno.copy(reader, file);\n * ```\n */\nexport function readerFromIterable(\n  iterable: Iterable<Uint8Array> | AsyncIterable<Uint8Array>,\n): Deno.Reader {\n  const iterator: Iterator<Uint8Array> | AsyncIterator<Uint8Array> =\n    (iterable as AsyncIterable<Uint8Array>)[Symbol.asyncIterator]?.() ??\n      (iterable as Iterable<Uint8Array>)[Symbol.iterator]?.();\n  const buffer = new Buffer();\n  return {\n    async read(p: Uint8Array): Promise<number | null> {\n      if (buffer.length == 0) {\n        const result = await iterator.next();\n        if (result.done) {\n          return null;\n        } else {\n          if (result.value.byteLength <= p.byteLength) {\n            p.set(result.value);\n            return result.value.byteLength;\n          }\n          p.set(result.value.subarray(0, p.byteLength));\n          await writeAll(buffer, result.value.subarray(p.byteLength));\n          return p.byteLength;\n        }\n      } else {\n        const n = await buffer.read(p);\n        if (n == null) {\n          return this.read(p);\n        }\n        return n;\n      }\n    },\n  };\n}\n\n/** Create a `Writer` from a `WritableStreamDefaultWriter`. */\nexport function writerFromStreamWriter(\n  streamWriter: WritableStreamDefaultWriter<Uint8Array>,\n): Deno.Writer {\n  return {\n    async write(p: Uint8Array): Promise<number> {\n      await streamWriter.ready;\n      await streamWriter.write(p);\n      return p.length;\n    },\n  };\n}\n\n/** Create a `Reader` from a `ReadableStreamDefaultReader`. */\nexport function readerFromStreamReader(\n  streamReader: ReadableStreamDefaultReader<Uint8Array>,\n): Deno.Reader {\n  const buffer = new Buffer();\n\n  return {\n    async read(p: Uint8Array): Promise<number | null> {\n      if (buffer.empty()) {\n        const res = await streamReader.read();\n        if (res.done) {\n          return null; // EOF\n        }\n\n        await writeAll(buffer, res.value);\n      }\n\n      return buffer.read(p);\n    },\n  };\n}\n\nexport interface WritableStreamFromWriterOptions {\n  /**\n   * If the `writer` is also a `Deno.Closer`, automatically close the `writer`\n   * when the stream is closed, aborted, or a write error occurs.\n   *\n   * Defaults to `true`. */\n  autoClose?: boolean;\n}\n\n/** Create a `WritableStream` from a `Writer`. */\nexport function writableStreamFromWriter(\n  writer: Deno.Writer,\n  options: WritableStreamFromWriterOptions = {},\n): WritableStream<Uint8Array> {\n  const { autoClose = true } = options;\n\n  return new WritableStream({\n    async write(chunk, controller) {\n      try {\n        await writeAll(writer, chunk);\n      } catch (e) {\n        controller.error(e);\n        if (isCloser(writer) && autoClose) {\n          writer.close();\n        }\n      }\n    },\n    close() {\n      if (isCloser(writer) && autoClose) {\n        writer.close();\n      }\n    },\n    abort() {\n      if (isCloser(writer) && autoClose) {\n        writer.close();\n      }\n    },\n  });\n}\n\n/** Create a `ReadableStream` from any kind of iterable.\n *\n * ```ts\n *      import { readableStreamFromIterable } from \"./conversion.ts\";\n *\n *      const r1 = readableStreamFromIterable([\"foo, bar, baz\"]);\n *      const r2 = readableStreamFromIterable(async function* () {\n *        await new Promise(((r) => setTimeout(r, 1000)));\n *        yield \"foo\";\n *        await new Promise(((r) => setTimeout(r, 1000)));\n *        yield \"bar\";\n *        await new Promise(((r) => setTimeout(r, 1000)));\n *        yield \"baz\";\n *      }());\n * ```\n *\n * If the produced iterator (`iterable[Symbol.asyncIterator]()` or\n * `iterable[Symbol.iterator]()`) is a generator, or more specifically is found\n * to have a `.throw()` method on it, that will be called upon\n * `readableStream.cancel()`. This is the case for the second input type above:\n *\n * ```ts\n * import { readableStreamFromIterable } from \"./conversion.ts\";\n *\n * const r3 = readableStreamFromIterable(async function* () {\n *   try {\n *     yield \"foo\";\n *   } catch (error) {\n *     console.log(error); // Error: Cancelled by consumer.\n *   }\n * }());\n * const reader = r3.getReader();\n * console.log(await reader.read()); // { value: \"foo\", done: false }\n * await reader.cancel(new Error(\"Cancelled by consumer.\"));\n * ```\n */\nexport function readableStreamFromIterable<T>(\n  iterable: Iterable<T> | AsyncIterable<T>,\n): ReadableStream<T> {\n  const iterator: Iterator<T> | AsyncIterator<T> =\n    (iterable as AsyncIterable<T>)[Symbol.asyncIterator]?.() ??\n      (iterable as Iterable<T>)[Symbol.iterator]?.();\n  return new ReadableStream({\n    async pull(controller) {\n      const { value, done } = await iterator.next();\n      if (done) {\n        controller.close();\n      } else {\n        controller.enqueue(value);\n      }\n    },\n    async cancel(reason) {\n      if (typeof iterator.throw == \"function\") {\n        try {\n          await iterator.throw(reason);\n        } catch { /* `iterator.throw()` always throws on site. We catch it. */ }\n      }\n    },\n  });\n}\n\nexport interface ReadableStreamFromReaderOptions {\n  /** If the `reader` is also a `Deno.Closer`, automatically close the `reader`\n   * when `EOF` is encountered, or a read error occurs.\n   *\n   * Defaults to `true`. */\n  autoClose?: boolean;\n\n  /** The size of chunks to allocate to read, the default is ~16KiB, which is\n   * the maximum size that Deno operations can currently support. */\n  chunkSize?: number;\n\n  /** The queuing strategy to create the `ReadableStream` with. */\n  strategy?: { highWaterMark?: number | undefined; size?: undefined };\n}\n\n/**\n * Create a `ReadableStream<Uint8Array>` from from a `Deno.Reader`.\n *\n * When the pull algorithm is called on the stream, a chunk from the reader\n * will be read.  When `null` is returned from the reader, the stream will be\n * closed along with the reader (if it is also a `Deno.Closer`).\n *\n * An example converting a `Deno.FsFile` into a readable stream:\n *\n * ```ts\n * import { readableStreamFromReader } from \"./mod.ts\";\n *\n * const file = await Deno.open(\"./file.txt\", { read: true });\n * const fileStream = readableStreamFromReader(file);\n * ```\n */\nexport function readableStreamFromReader(\n  reader: Deno.Reader | (Deno.Reader & Deno.Closer),\n  options: ReadableStreamFromReaderOptions = {},\n): ReadableStream<Uint8Array> {\n  const {\n    autoClose = true,\n    chunkSize = DEFAULT_CHUNK_SIZE,\n    strategy,\n  } = options;\n\n  return new ReadableStream({\n    async pull(controller) {\n      const chunk = new Uint8Array(chunkSize);\n      try {\n        const read = await reader.read(chunk);\n        if (read === null) {\n          if (isCloser(reader) && autoClose) {\n            reader.close();\n          }\n          controller.close();\n          return;\n        }\n        controller.enqueue(chunk.subarray(0, read));\n      } catch (e) {\n        controller.error(e);\n        if (isCloser(reader)) {\n          reader.close();\n        }\n      }\n    },\n    cancel() {\n      if (isCloser(reader) && autoClose) {\n        reader.close();\n      }\n    },\n  }, strategy);\n}\n\n/** Read Reader `r` until EOF (`null`) and resolve to the content as\n * Uint8Array`.\n *\n * ```ts\n * import { Buffer } from \"../io/buffer.ts\";\n * import { readAll } from \"./conversion.ts\";\n *\n * // Example from stdin\n * const stdinContent = await readAll(Deno.stdin);\n *\n * // Example from file\n * const file = await Deno.open(\"my_file.txt\", {read: true});\n * const myFileContent = await readAll(file);\n * Deno.close(file.rid);\n *\n * // Example from buffer\n * const myData = new Uint8Array(100);\n * // ... fill myData array with data\n * const reader = new Buffer(myData.buffer);\n * const bufferContent = await readAll(reader);\n * ```\n */\nexport async function readAll(r: Deno.Reader): Promise<Uint8Array> {\n  const buf = new Buffer();\n  await buf.readFrom(r);\n  return buf.bytes();\n}\n\n/** Synchronously reads Reader `r` until EOF (`null`) and returns the content\n * as `Uint8Array`.\n *\n * ```ts\n * import { Buffer } from \"../io/buffer.ts\";\n * import { readAllSync } from \"./conversion.ts\";\n *\n * // Example from stdin\n * const stdinContent = readAllSync(Deno.stdin);\n *\n * // Example from file\n * const file = Deno.openSync(\"my_file.txt\", {read: true});\n * const myFileContent = readAllSync(file);\n * Deno.close(file.rid);\n *\n * // Example from buffer\n * const myData = new Uint8Array(100);\n * // ... fill myData array with data\n * const reader = new Buffer(myData.buffer);\n * const bufferContent = readAllSync(reader);\n * ```\n */\nexport function readAllSync(r: Deno.ReaderSync): Uint8Array {\n  const buf = new Buffer();\n  buf.readFromSync(r);\n  return buf.bytes();\n}\n\n/** Write all the content of the array buffer (`arr`) to the writer (`w`).\n *\n * ```ts\n * import { Buffer } from \"../io/buffer.ts\";\n * import { writeAll } from \"./conversion.ts\";\n\n * // Example writing to stdout\n * let contentBytes = new TextEncoder().encode(\"Hello World\");\n * await writeAll(Deno.stdout, contentBytes);\n *\n * // Example writing to file\n * contentBytes = new TextEncoder().encode(\"Hello World\");\n * const file = await Deno.open('test.file', {write: true});\n * await writeAll(file, contentBytes);\n * Deno.close(file.rid);\n *\n * // Example writing to buffer\n * contentBytes = new TextEncoder().encode(\"Hello World\");\n * const writer = new Buffer();\n * await writeAll(writer, contentBytes);\n * console.log(writer.bytes().length);  // 11\n * ```\n */\nexport async function writeAll(w: Deno.Writer, arr: Uint8Array) {\n  let nwritten = 0;\n  while (nwritten < arr.length) {\n    nwritten += await w.write(arr.subarray(nwritten));\n  }\n}\n\n/** Synchronously write all the content of the array buffer (`arr`) to the\n * writer (`w`).\n *\n * ```ts\n * import { Buffer } from \"../io/buffer.ts\";\n * import { writeAllSync } from \"./conversion.ts\";\n *\n * // Example writing to stdout\n * let contentBytes = new TextEncoder().encode(\"Hello World\");\n * writeAllSync(Deno.stdout, contentBytes);\n *\n * // Example writing to file\n * contentBytes = new TextEncoder().encode(\"Hello World\");\n * const file = Deno.openSync('test.file', {write: true});\n * writeAllSync(file, contentBytes);\n * Deno.close(file.rid);\n *\n * // Example writing to buffer\n * contentBytes = new TextEncoder().encode(\"Hello World\");\n * const writer = new Buffer();\n * writeAllSync(writer, contentBytes);\n * console.log(writer.bytes().length);  // 11\n * ```\n */\nexport function writeAllSync(w: Deno.WriterSync, arr: Uint8Array): void {\n  let nwritten = 0;\n  while (nwritten < arr.length) {\n    nwritten += w.writeSync(arr.subarray(nwritten));\n  }\n}\n\n/** Turns a Reader, `r`, into an async iterator.\n *\n * ```ts\n * import { iterateReader } from \"./conversion.ts\";\n *\n * let f = await Deno.open(\"/etc/passwd\");\n * for await (const chunk of iterateReader(f)) {\n *   console.log(chunk);\n * }\n * f.close();\n * ```\n *\n * Second argument can be used to tune size of a buffer.\n * Default size of the buffer is 32kB.\n *\n * ```ts\n * import { iterateReader } from \"./conversion.ts\";\n *\n * let f = await Deno.open(\"/etc/passwd\");\n * const it = iterateReader(f, {\n *   bufSize: 1024 * 1024\n * });\n * for await (const chunk of it) {\n *   console.log(chunk);\n * }\n * f.close();\n * ```\n *\n * Iterator uses an internal buffer of fixed size for efficiency; it returns\n * a view on that buffer on each iteration. It is therefore caller's\n * responsibility to copy contents of the buffer if needed; otherwise the\n * next iteration will overwrite contents of previously returned chunk.\n */\nexport async function* iterateReader(\n  r: Deno.Reader,\n  options?: {\n    bufSize?: number;\n  },\n): AsyncIterableIterator<Uint8Array> {\n  const bufSize = options?.bufSize ?? DEFAULT_BUFFER_SIZE;\n  const b = new Uint8Array(bufSize);\n  while (true) {\n    const result = await r.read(b);\n    if (result === null) {\n      break;\n    }\n\n    yield b.subarray(0, result);\n  }\n}\n\n/** Turns a ReaderSync, `r`, into an iterator.\n *\n * ```ts\n * import { iterateReaderSync } from \"./conversion.ts\";\n *\n * let f = Deno.openSync(\"/etc/passwd\");\n * for (const chunk of iterateReaderSync(f)) {\n *   console.log(chunk);\n * }\n * f.close();\n * ```\n *\n * Second argument can be used to tune size of a buffer.\n * Default size of the buffer is 32kB.\n *\n * ```ts\n * import { iterateReaderSync } from \"./conversion.ts\";\n\n * let f = await Deno.open(\"/etc/passwd\");\n * const iter = iterateReaderSync(f, {\n *   bufSize: 1024 * 1024\n * });\n * for (const chunk of iter) {\n *   console.log(chunk);\n * }\n * f.close();\n * ```\n *\n * Iterator uses an internal buffer of fixed size for efficiency; it returns\n * a view on that buffer on each iteration. It is therefore caller's\n * responsibility to copy contents of the buffer if needed; otherwise the\n * next iteration will overwrite contents of previously returned chunk.\n */\nexport function* iterateReaderSync(\n  r: Deno.ReaderSync,\n  options?: {\n    bufSize?: number;\n  },\n): IterableIterator<Uint8Array> {\n  const bufSize = options?.bufSize ?? DEFAULT_BUFFER_SIZE;\n  const b = new Uint8Array(bufSize);\n  while (true) {\n    const result = r.readSync(b);\n    if (result === null) {\n      break;\n    }\n\n    yield b.subarray(0, result);\n  }\n}\n\n/** Copies from `src` to `dst` until either EOF (`null`) is read from `src` or\n * an error occurs. It resolves to the number of bytes copied or rejects with\n * the first error encountered while copying.\n *\n * ```ts\n * import { copy } from \"./conversion.ts\";\n *\n * const source = await Deno.open(\"my_file.txt\");\n * const bytesCopied1 = await copy(source, Deno.stdout);\n * const destination = await Deno.create(\"my_file_2.txt\");\n * const bytesCopied2 = await copy(source, destination);\n * ```\n *\n * @param src The source to copy from\n * @param dst The destination to copy to\n * @param options Can be used to tune size of the buffer. Default size is 32kB\n */\nexport async function copy(\n  src: Deno.Reader,\n  dst: Deno.Writer,\n  options?: {\n    bufSize?: number;\n  },\n): Promise<number> {\n  let n = 0;\n  const bufSize = options?.bufSize ?? DEFAULT_BUFFER_SIZE;\n  const b = new Uint8Array(bufSize);\n  let gotEOF = false;\n  while (gotEOF === false) {\n    const result = await src.read(b);\n    if (result === null) {\n      gotEOF = true;\n    } else {\n      let nwritten = 0;\n      while (nwritten < result) {\n        nwritten += await dst.write(b.subarray(nwritten, result));\n      }\n      n += nwritten;\n    }\n  }\n  return n;\n}\n","// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.\nimport { fromFileUrl } from \"../../path/mod.ts\";\nimport { readableStreamFromReader } from \"../../streams/conversion.ts\";\n\nconst clients = new Map<number, WebSocket>();\nlet clientId = 0;\nfunction dispatch(msg: string): void {\n  for (const client of clients.values()) {\n    client.send(msg);\n  }\n}\n\nfunction wsHandler(ws: WebSocket) {\n  const id = ++clientId;\n  clients.set(id, ws);\n  ws.onopen = () => {\n    dispatch(`Connected: [${id}]`);\n  };\n  ws.onmessage = (e) => {\n    console.log(`msg:${id}`, e.data);\n    dispatch(`[${id}]: ${e.data}`);\n  };\n  ws.onclose = () => {\n    clients.delete(id);\n    dispatch(`Closed: [${id}]`);\n  };\n}\n\nasync function requestHandler(req: Deno.RequestEvent) {\n  const pathname = new URL(req.request.url).pathname;\n  if (req.request.method === \"GET\" && pathname === \"/\") {\n    //Serve with hack\n    const u = new URL(\"./index.html\", import.meta.url);\n    if (u.protocol.startsWith(\"http\")) {\n      // server launched by deno run http(s)://.../server.ts,\n      fetch(u.href).then(async (resp) => {\n        const body = new Uint8Array(await resp.arrayBuffer());\n        req.respondWith(\n          new Response(body, {\n            status: resp.status,\n            headers: {\n              \"content-type\": \"text/html\",\n            },\n          }),\n        );\n      });\n    } else {\n      // server launched by deno run ./server.ts\n      const file = await Deno.open(fromFileUrl(u));\n      req.respondWith(\n        new Response(readableStreamFromReader(file), {\n          status: 200,\n          headers: {\n            \"content-type\": \"text/html\",\n          },\n        }),\n      );\n    }\n  } else if (\n    req.request.method === \"GET\" && pathname === \"/favicon.ico\"\n  ) {\n    req.respondWith(Response.redirect(\"https://deno.land/favicon.ico\", 302));\n  } else if (req.request.method === \"GET\" && pathname === \"/ws\") {\n    const { socket, response } = Deno.upgradeWebSocket(req.request);\n    wsHandler(socket);\n    req.respondWith(response);\n  }\n}\n\nconst server = Deno.listen({ port: 8080 });\nconsole.log(\"chat server starting on :8080....\");\n\nfor await (const conn of server) {\n  (async () => {\n    const httpConn = Deno.serveHttp(conn);\n    for await (const requestEvent of httpConn) {\n      requestHandler(requestEvent);\n    }\n  })();\n}\n"],"names":[],"mappings":"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"} diff --git a/tests/__snapshots__/bundle/source.js b/tests/__snapshots__/bundle/source.js new file mode 100644 index 0000000..6bad4f6 --- /dev/null +++ b/tests/__snapshots__/bundle/source.js @@ -0,0 +1,5 @@ +function hello() { + return "Hello there!"; +} +export { hello as default }; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImZpbGU6Ly8vc3JjLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBkZWZhdWx0IGZ1bmN0aW9uIGhlbGxvKCk6IHN0cmluZyB7XG4gIHJldHVybiBcIkhlbGxvIHRoZXJlIVwiO1xufVxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFlLFNBQVMsUUFBZ0I7SUFDdEMsT0FBTztBQUNUO0FBRkEsNEJBRUMifQ== diff --git a/tests/__snapshots__/bundle/url.js b/tests/__snapshots__/bundle/url.js new file mode 100644 index 0000000..d0b5685 --- /dev/null +++ b/tests/__snapshots__/bundle/url.js @@ -0,0 +1,1185 @@ +const osType = (()=>{ + const { Deno: Deno1 } = globalThis; + if (typeof Deno1?.build?.os === "string") { + return Deno1.build.os; + } + const { navigator } = globalThis; + if (navigator?.appVersion?.includes?.("Win")) { + return "windows"; + } + return "linux"; +})(); +const isWindows = osType === "windows"; +const CHAR_FORWARD_SLASH = 47; +function assertPath(path) { + if (typeof path !== "string") { + throw new TypeError(`Path must be a string. Received ${JSON.stringify(path)}`); + } +} +function isPosixPathSeparator(code) { + return code === 47; +} +function isPathSeparator(code) { + return isPosixPathSeparator(code) || code === 92; +} +function isWindowsDeviceRoot(code) { + return code >= 97 && code <= 122 || code >= 65 && code <= 90; +} +function normalizeString(path, allowAboveRoot, separator, isPathSeparator) { + let res = ""; + let lastSegmentLength = 0; + let lastSlash = -1; + let dots = 0; + let code; + for(let i = 0, len = path.length; i <= len; ++i){ + if (i < len) code = path.charCodeAt(i); + else if (isPathSeparator(code)) break; + else code = CHAR_FORWARD_SLASH; + if (isPathSeparator(code)) { + if (lastSlash === i - 1 || dots === 1) {} else if (lastSlash !== i - 1 && dots === 2) { + if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 || res.charCodeAt(res.length - 2) !== 46) { + if (res.length > 2) { + const lastSlashIndex = res.lastIndexOf(separator); + if (lastSlashIndex === -1) { + res = ""; + lastSegmentLength = 0; + } else { + res = res.slice(0, lastSlashIndex); + lastSegmentLength = res.length - 1 - res.lastIndexOf(separator); + } + lastSlash = i; + dots = 0; + continue; + } else if (res.length === 2 || res.length === 1) { + res = ""; + lastSegmentLength = 0; + lastSlash = i; + dots = 0; + continue; + } + } + if (allowAboveRoot) { + if (res.length > 0) res += `${separator}..`; + else res = ".."; + lastSegmentLength = 2; + } + } else { + if (res.length > 0) res += separator + path.slice(lastSlash + 1, i); + else res = path.slice(lastSlash + 1, i); + lastSegmentLength = i - lastSlash - 1; + } + lastSlash = i; + dots = 0; + } else if (code === 46 && dots !== -1) { + ++dots; + } else { + dots = -1; + } + } + return res; +} +function _format(sep, pathObject) { + const dir = pathObject.dir || pathObject.root; + const base = pathObject.base || (pathObject.name || "") + (pathObject.ext || ""); + if (!dir) return base; + if (dir === pathObject.root) return dir + base; + return dir + sep + base; +} +const WHITESPACE_ENCODINGS = { + "\u0009": "%09", + "\u000A": "%0A", + "\u000B": "%0B", + "\u000C": "%0C", + "\u000D": "%0D", + "\u0020": "%20" +}; +function encodeWhitespace(string) { + return string.replaceAll(/[\s]/g, (c)=>{ + return WHITESPACE_ENCODINGS[c] ?? c; + }); +} +class DenoStdInternalError extends Error { + constructor(message){ + super(message); + this.name = "DenoStdInternalError"; + } +} +function assert(expr, msg = "") { + if (!expr) { + throw new DenoStdInternalError(msg); + } +} +const sep = "\\"; +const delimiter = ";"; +function resolve(...pathSegments) { + let resolvedDevice = ""; + let resolvedTail = ""; + let resolvedAbsolute = false; + for(let i = pathSegments.length - 1; i >= -1; i--){ + let path; + const { Deno: Deno1 } = globalThis; + if (i >= 0) { + path = pathSegments[i]; + } else if (!resolvedDevice) { + if (typeof Deno1?.cwd !== "function") { + throw new TypeError("Resolved a drive-letter-less path without a CWD."); + } + path = Deno1.cwd(); + } else { + if (typeof Deno1?.env?.get !== "function" || typeof Deno1?.cwd !== "function") { + throw new TypeError("Resolved a relative path without a CWD."); + } + path = Deno1.cwd(); + if (path === undefined || path.slice(0, 3).toLowerCase() !== `${resolvedDevice.toLowerCase()}\\`) { + path = `${resolvedDevice}\\`; + } + } + assertPath(path); + const len = path.length; + if (len === 0) continue; + let rootEnd = 0; + let device = ""; + let isAbsolute = false; + const code = path.charCodeAt(0); + if (len > 1) { + if (isPathSeparator(code)) { + isAbsolute = true; + if (isPathSeparator(path.charCodeAt(1))) { + let j = 2; + let last = j; + for(; j < len; ++j){ + if (isPathSeparator(path.charCodeAt(j))) break; + } + if (j < len && j !== last) { + const firstPart = path.slice(last, j); + last = j; + for(; j < len; ++j){ + if (!isPathSeparator(path.charCodeAt(j))) break; + } + if (j < len && j !== last) { + last = j; + for(; j < len; ++j){ + if (isPathSeparator(path.charCodeAt(j))) break; + } + if (j === len) { + device = `\\\\${firstPart}\\${path.slice(last)}`; + rootEnd = j; + } else if (j !== last) { + device = `\\\\${firstPart}\\${path.slice(last, j)}`; + rootEnd = j; + } + } + } + } else { + rootEnd = 1; + } + } else if (isWindowsDeviceRoot(code)) { + if (path.charCodeAt(1) === 58) { + device = path.slice(0, 2); + rootEnd = 2; + if (len > 2) { + if (isPathSeparator(path.charCodeAt(2))) { + isAbsolute = true; + rootEnd = 3; + } + } + } + } + } else if (isPathSeparator(code)) { + rootEnd = 1; + isAbsolute = true; + } + if (device.length > 0 && resolvedDevice.length > 0 && device.toLowerCase() !== resolvedDevice.toLowerCase()) { + continue; + } + if (resolvedDevice.length === 0 && device.length > 0) { + resolvedDevice = device; + } + if (!resolvedAbsolute) { + resolvedTail = `${path.slice(rootEnd)}\\${resolvedTail}`; + resolvedAbsolute = isAbsolute; + } + if (resolvedAbsolute && resolvedDevice.length > 0) break; + } + resolvedTail = normalizeString(resolvedTail, !resolvedAbsolute, "\\", isPathSeparator); + return resolvedDevice + (resolvedAbsolute ? "\\" : "") + resolvedTail || "."; +} +function normalize(path) { + assertPath(path); + const len = path.length; + if (len === 0) return "."; + let rootEnd = 0; + let device; + let isAbsolute = false; + const code = path.charCodeAt(0); + if (len > 1) { + if (isPathSeparator(code)) { + isAbsolute = true; + if (isPathSeparator(path.charCodeAt(1))) { + let j = 2; + let last = j; + for(; j < len; ++j){ + if (isPathSeparator(path.charCodeAt(j))) break; + } + if (j < len && j !== last) { + const firstPart = path.slice(last, j); + last = j; + for(; j < len; ++j){ + if (!isPathSeparator(path.charCodeAt(j))) break; + } + if (j < len && j !== last) { + last = j; + for(; j < len; ++j){ + if (isPathSeparator(path.charCodeAt(j))) break; + } + if (j === len) { + return `\\\\${firstPart}\\${path.slice(last)}\\`; + } else if (j !== last) { + device = `\\\\${firstPart}\\${path.slice(last, j)}`; + rootEnd = j; + } + } + } + } else { + rootEnd = 1; + } + } else if (isWindowsDeviceRoot(code)) { + if (path.charCodeAt(1) === 58) { + device = path.slice(0, 2); + rootEnd = 2; + if (len > 2) { + if (isPathSeparator(path.charCodeAt(2))) { + isAbsolute = true; + rootEnd = 3; + } + } + } + } + } else if (isPathSeparator(code)) { + return "\\"; + } + let tail; + 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; + } +} +function isAbsolute(path) { + assertPath(path); + const len = path.length; + if (len === 0) return false; + const code = path.charCodeAt(0); + if (isPathSeparator(code)) { + return true; + } else if (isWindowsDeviceRoot(code)) { + if (len > 2 && path.charCodeAt(1) === 58) { + if (isPathSeparator(path.charCodeAt(2))) return true; + } + } + return false; +} +function join(...paths) { + const pathsCount = paths.length; + if (pathsCount === 0) return "."; + let joined; + let firstPart = null; + for(let i = 0; i < pathsCount; ++i){ + const path = paths[i]; + assertPath(path); + if (path.length > 0) { + if (joined === undefined) joined = firstPart = path; + else joined += `\\${path}`; + } + } + if (joined === undefined) return "."; + let needsReplace = true; + let slashCount = 0; + assert(firstPart != null); + if (isPathSeparator(firstPart.charCodeAt(0))) { + ++slashCount; + const firstLen = firstPart.length; + if (firstLen > 1) { + if (isPathSeparator(firstPart.charCodeAt(1))) { + ++slashCount; + if (firstLen > 2) { + if (isPathSeparator(firstPart.charCodeAt(2))) ++slashCount; + else { + needsReplace = false; + } + } + } + } + } + if (needsReplace) { + for(; slashCount < joined.length; ++slashCount){ + if (!isPathSeparator(joined.charCodeAt(slashCount))) break; + } + if (slashCount >= 2) joined = `\\${joined.slice(slashCount)}`; + } + return normalize(joined); +} +function relative(from, to) { + assertPath(from); + assertPath(to); + if (from === to) return ""; + const fromOrig = resolve(from); + const toOrig = resolve(to); + if (fromOrig === toOrig) return ""; + from = fromOrig.toLowerCase(); + to = toOrig.toLowerCase(); + if (from === to) return ""; + let fromStart = 0; + let fromEnd = from.length; + for(; fromStart < fromEnd; ++fromStart){ + if (from.charCodeAt(fromStart) !== 92) break; + } + for(; fromEnd - 1 > fromStart; --fromEnd){ + if (from.charCodeAt(fromEnd - 1) !== 92) break; + } + const fromLen = fromEnd - fromStart; + let toStart = 0; + let toEnd = to.length; + for(; toStart < toEnd; ++toStart){ + if (to.charCodeAt(toStart) !== 92) break; + } + for(; toEnd - 1 > toStart; --toEnd){ + if (to.charCodeAt(toEnd - 1) !== 92) break; + } + const toLen = toEnd - toStart; + const length = fromLen < toLen ? fromLen : toLen; + let lastCommonSep = -1; + let i = 0; + for(; i <= length; ++i){ + if (i === length) { + if (toLen > length) { + if (to.charCodeAt(toStart + i) === 92) { + return toOrig.slice(toStart + i + 1); + } else if (i === 2) { + return toOrig.slice(toStart + i); + } + } + if (fromLen > length) { + if (from.charCodeAt(fromStart + i) === 92) { + lastCommonSep = i; + } else if (i === 2) { + lastCommonSep = 3; + } + } + break; + } + const fromCode = from.charCodeAt(fromStart + i); + const toCode = to.charCodeAt(toStart + i); + if (fromCode !== toCode) break; + else if (fromCode === 92) lastCommonSep = i; + } + if (i !== length && lastCommonSep === -1) { + return toOrig; + } + let out = ""; + if (lastCommonSep === -1) lastCommonSep = 0; + for(i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i){ + if (i === fromEnd || from.charCodeAt(i) === 92) { + if (out.length === 0) out += ".."; + else out += "\\.."; + } + } + if (out.length > 0) { + return out + toOrig.slice(toStart + lastCommonSep, toEnd); + } else { + toStart += lastCommonSep; + if (toOrig.charCodeAt(toStart) === 92) ++toStart; + return toOrig.slice(toStart, toEnd); + } +} +function toNamespacedPath(path) { + if (typeof path !== "string") return path; + if (path.length === 0) return ""; + const resolvedPath = resolve(path); + if (resolvedPath.length >= 3) { + if (resolvedPath.charCodeAt(0) === 92) { + if (resolvedPath.charCodeAt(1) === 92) { + const code = resolvedPath.charCodeAt(2); + if (code !== 63 && code !== 46) { + return `\\\\?\\UNC\\${resolvedPath.slice(2)}`; + } + } + } else if (isWindowsDeviceRoot(resolvedPath.charCodeAt(0))) { + if (resolvedPath.charCodeAt(1) === 58 && resolvedPath.charCodeAt(2) === 92) { + return `\\\\?\\${resolvedPath}`; + } + } + } + return path; +} +function dirname(path) { + assertPath(path); + const len = path.length; + if (len === 0) return "."; + let rootEnd = -1; + let end = -1; + let matchedSlash = true; + let offset = 0; + const code = path.charCodeAt(0); + if (len > 1) { + if (isPathSeparator(code)) { + rootEnd = offset = 1; + if (isPathSeparator(path.charCodeAt(1))) { + let j = 2; + let last = j; + for(; j < len; ++j){ + if (isPathSeparator(path.charCodeAt(j))) break; + } + if (j < len && j !== last) { + last = j; + for(; j < len; ++j){ + if (!isPathSeparator(path.charCodeAt(j))) break; + } + if (j < len && j !== last) { + last = j; + for(; j < len; ++j){ + if (isPathSeparator(path.charCodeAt(j))) break; + } + if (j === len) { + return path; + } + if (j !== last) { + rootEnd = offset = j + 1; + } + } + } + } + } else if (isWindowsDeviceRoot(code)) { + if (path.charCodeAt(1) === 58) { + rootEnd = offset = 2; + if (len > 2) { + if (isPathSeparator(path.charCodeAt(2))) rootEnd = offset = 3; + } + } + } + } else if (isPathSeparator(code)) { + return path; + } + for(let i = len - 1; i >= offset; --i){ + if (isPathSeparator(path.charCodeAt(i))) { + if (!matchedSlash) { + end = i; + break; + } + } else { + matchedSlash = false; + } + } + if (end === -1) { + if (rootEnd === -1) return "."; + else end = rootEnd; + } + return path.slice(0, end); +} +function basename(path, ext = "") { + if (ext !== undefined && typeof ext !== "string") { + throw new TypeError('"ext" argument must be a string'); + } + assertPath(path); + let start = 0; + let end = -1; + let matchedSlash = true; + let i; + if (path.length >= 2) { + const drive = path.charCodeAt(0); + if (isWindowsDeviceRoot(drive)) { + if (path.charCodeAt(1) === 58) start = 2; + } + } + if (ext !== undefined && ext.length > 0 && ext.length <= path.length) { + if (ext.length === path.length && ext === path) return ""; + let extIdx = ext.length - 1; + let firstNonSlashEnd = -1; + for(i = path.length - 1; i >= start; --i){ + const code = path.charCodeAt(i); + if (isPathSeparator(code)) { + if (!matchedSlash) { + start = i + 1; + break; + } + } else { + if (firstNonSlashEnd === -1) { + matchedSlash = false; + firstNonSlashEnd = i + 1; + } + if (extIdx >= 0) { + if (code === ext.charCodeAt(extIdx)) { + if (--extIdx === -1) { + end = i; + } + } else { + extIdx = -1; + end = firstNonSlashEnd; + } + } + } + } + if (start === end) end = firstNonSlashEnd; + else if (end === -1) end = path.length; + return path.slice(start, end); + } else { + for(i = path.length - 1; i >= start; --i){ + if (isPathSeparator(path.charCodeAt(i))) { + if (!matchedSlash) { + start = i + 1; + break; + } + } else if (end === -1) { + matchedSlash = false; + end = i + 1; + } + } + if (end === -1) return ""; + return path.slice(start, end); + } +} +function extname(path) { + assertPath(path); + let start = 0; + let startDot = -1; + let startPart = 0; + let end = -1; + let matchedSlash = true; + let preDotState = 0; + if (path.length >= 2 && path.charCodeAt(1) === 58 && isWindowsDeviceRoot(path.charCodeAt(0))) { + start = startPart = 2; + } + for(let i = path.length - 1; i >= start; --i){ + const code = path.charCodeAt(i); + if (isPathSeparator(code)) { + if (!matchedSlash) { + startPart = i + 1; + break; + } + continue; + } + if (end === -1) { + matchedSlash = false; + end = i + 1; + } + if (code === 46) { + if (startDot === -1) startDot = i; + else if (preDotState !== 1) preDotState = 1; + } else if (startDot !== -1) { + preDotState = -1; + } + } + if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) { + return ""; + } + return path.slice(startDot, end); +} +function format(pathObject) { + if (pathObject === null || typeof pathObject !== "object") { + throw new TypeError(`The "pathObject" argument must be of type Object. Received type ${typeof pathObject}`); + } + return _format("\\", pathObject); +} +function parse(path) { + assertPath(path); + const ret = { + root: "", + dir: "", + base: "", + ext: "", + name: "" + }; + const len = path.length; + if (len === 0) return ret; + let rootEnd = 0; + let code = path.charCodeAt(0); + if (len > 1) { + if (isPathSeparator(code)) { + rootEnd = 1; + if (isPathSeparator(path.charCodeAt(1))) { + let j = 2; + let last = j; + for(; j < len; ++j){ + if (isPathSeparator(path.charCodeAt(j))) break; + } + if (j < len && j !== last) { + last = j; + for(; j < len; ++j){ + if (!isPathSeparator(path.charCodeAt(j))) break; + } + if (j < len && j !== last) { + last = j; + for(; j < len; ++j){ + if (isPathSeparator(path.charCodeAt(j))) break; + } + if (j === len) { + rootEnd = j; + } else if (j !== last) { + rootEnd = j + 1; + } + } + } + } + } else if (isWindowsDeviceRoot(code)) { + if (path.charCodeAt(1) === 58) { + rootEnd = 2; + if (len > 2) { + if (isPathSeparator(path.charCodeAt(2))) { + if (len === 3) { + ret.root = ret.dir = path; + return ret; + } + rootEnd = 3; + } + } else { + ret.root = ret.dir = path; + return ret; + } + } + } + } else if (isPathSeparator(code)) { + ret.root = ret.dir = path; + return ret; + } + if (rootEnd > 0) ret.root = path.slice(0, rootEnd); + let startDot = -1; + let startPart = rootEnd; + let end = -1; + let matchedSlash = true; + let i = path.length - 1; + let preDotState = 0; + for(; i >= rootEnd; --i){ + code = path.charCodeAt(i); + if (isPathSeparator(code)) { + if (!matchedSlash) { + startPart = i + 1; + break; + } + continue; + } + if (end === -1) { + matchedSlash = false; + end = i + 1; + } + if (code === 46) { + if (startDot === -1) startDot = i; + else if (preDotState !== 1) preDotState = 1; + } else if (startDot !== -1) { + preDotState = -1; + } + } + if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) { + if (end !== -1) { + ret.base = ret.name = path.slice(startPart, end); + } + } else { + ret.name = path.slice(startPart, startDot); + ret.base = path.slice(startPart, end); + ret.ext = path.slice(startDot, end); + } + if (startPart > 0 && startPart !== rootEnd) { + ret.dir = path.slice(0, startPart - 1); + } else ret.dir = ret.root; + return ret; +} +function fromFileUrl(url) { + url = url instanceof URL ? url : new URL(url); + if (url.protocol != "file:") { + throw new TypeError("Must be a file URL."); + } + let path = decodeURIComponent(url.pathname.replace(/\//g, "\\").replace(/%(?![0-9A-Fa-f]{2})/g, "%25")).replace(/^\\*([A-Za-z]:)(\\|$)/, "$1\\"); + if (url.hostname != "") { + path = `\\\\${url.hostname}${path}`; + } + return path; +} +function toFileUrl(path) { + if (!isAbsolute(path)) { + throw new TypeError("Must be an absolute path."); + } + const [, hostname, pathname] = path.match(/^(?:[/\\]{2}([^/\\]+)(?=[/\\](?:[^/\\]|$)))?(.*)/); + const url = new URL("file:///"); + url.pathname = encodeWhitespace(pathname.replace(/%/g, "%25")); + if (hostname != null && hostname != "localhost") { + url.hostname = hostname; + if (!url.hostname) { + throw new TypeError("Invalid hostname."); + } + } + return url; +} +const mod = { + sep: sep, + delimiter: delimiter, + resolve: resolve, + normalize: normalize, + isAbsolute: isAbsolute, + join: join, + relative: relative, + toNamespacedPath: toNamespacedPath, + dirname: dirname, + basename: basename, + extname: extname, + format: format, + parse: parse, + fromFileUrl: fromFileUrl, + toFileUrl: toFileUrl +}; +const sep1 = "/"; +const delimiter1 = ":"; +function resolve1(...pathSegments) { + let resolvedPath = ""; + let resolvedAbsolute = false; + for(let i = pathSegments.length - 1; i >= -1 && !resolvedAbsolute; i--){ + let path; + if (i >= 0) path = pathSegments[i]; + else { + const { Deno: Deno1 } = globalThis; + if (typeof Deno1?.cwd !== "function") { + throw new TypeError("Resolved a relative path without a CWD."); + } + path = Deno1.cwd(); + } + assertPath(path); + if (path.length === 0) { + continue; + } + resolvedPath = `${path}/${resolvedPath}`; + resolvedAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH; + } + resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute, "/", isPosixPathSeparator); + if (resolvedAbsolute) { + if (resolvedPath.length > 0) return `/${resolvedPath}`; + else return "/"; + } else if (resolvedPath.length > 0) return resolvedPath; + else return "."; +} +function normalize1(path) { + assertPath(path); + if (path.length === 0) return "."; + const isAbsolute = path.charCodeAt(0) === 47; + const trailingSeparator = path.charCodeAt(path.length - 1) === 47; + path = normalizeString(path, !isAbsolute, "/", isPosixPathSeparator); + if (path.length === 0 && !isAbsolute) path = "."; + if (path.length > 0 && trailingSeparator) path += "/"; + if (isAbsolute) return `/${path}`; + return path; +} +function isAbsolute1(path) { + assertPath(path); + return path.length > 0 && path.charCodeAt(0) === 47; +} +function join1(...paths) { + if (paths.length === 0) return "."; + let joined; + for(let i = 0, len = paths.length; i < len; ++i){ + const path = paths[i]; + assertPath(path); + if (path.length > 0) { + if (!joined) joined = path; + else joined += `/${path}`; + } + } + if (!joined) return "."; + return normalize1(joined); +} +function relative1(from, to) { + assertPath(from); + assertPath(to); + if (from === to) return ""; + from = resolve1(from); + to = resolve1(to); + if (from === to) return ""; + let fromStart = 1; + const fromEnd = from.length; + for(; fromStart < fromEnd; ++fromStart){ + if (from.charCodeAt(fromStart) !== 47) break; + } + const fromLen = fromEnd - fromStart; + let toStart = 1; + const toEnd = to.length; + for(; toStart < toEnd; ++toStart){ + if (to.charCodeAt(toStart) !== 47) break; + } + const toLen = toEnd - toStart; + const length = fromLen < toLen ? fromLen : toLen; + let lastCommonSep = -1; + let i = 0; + for(; i <= length; ++i){ + if (i === length) { + if (toLen > length) { + if (to.charCodeAt(toStart + i) === 47) { + return to.slice(toStart + i + 1); + } else if (i === 0) { + return to.slice(toStart + i); + } + } else if (fromLen > length) { + if (from.charCodeAt(fromStart + i) === 47) { + lastCommonSep = i; + } else if (i === 0) { + lastCommonSep = 0; + } + } + break; + } + const fromCode = from.charCodeAt(fromStart + i); + const toCode = to.charCodeAt(toStart + i); + if (fromCode !== toCode) break; + else if (fromCode === 47) lastCommonSep = i; + } + let out = ""; + for(i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i){ + if (i === fromEnd || from.charCodeAt(i) === 47) { + if (out.length === 0) out += ".."; + else out += "/.."; + } + } + if (out.length > 0) return out + to.slice(toStart + lastCommonSep); + else { + toStart += lastCommonSep; + if (to.charCodeAt(toStart) === 47) ++toStart; + return to.slice(toStart); + } +} +function toNamespacedPath1(path) { + return path; +} +function dirname1(path) { + assertPath(path); + if (path.length === 0) return "."; + const hasRoot = path.charCodeAt(0) === 47; + let end = -1; + let matchedSlash = true; + for(let i = path.length - 1; i >= 1; --i){ + if (path.charCodeAt(i) === 47) { + if (!matchedSlash) { + end = i; + break; + } + } else { + matchedSlash = false; + } + } + if (end === -1) return hasRoot ? "/" : "."; + if (hasRoot && end === 1) return "//"; + return path.slice(0, end); +} +function basename1(path, ext = "") { + if (ext !== undefined && typeof ext !== "string") { + throw new TypeError('"ext" argument must be a string'); + } + assertPath(path); + let start = 0; + let end = -1; + let matchedSlash = true; + let i; + if (ext !== undefined && ext.length > 0 && ext.length <= path.length) { + if (ext.length === path.length && ext === path) return ""; + let extIdx = ext.length - 1; + let firstNonSlashEnd = -1; + for(i = path.length - 1; i >= 0; --i){ + const code = path.charCodeAt(i); + if (code === 47) { + if (!matchedSlash) { + start = i + 1; + break; + } + } else { + if (firstNonSlashEnd === -1) { + matchedSlash = false; + firstNonSlashEnd = i + 1; + } + if (extIdx >= 0) { + if (code === ext.charCodeAt(extIdx)) { + if (--extIdx === -1) { + end = i; + } + } else { + extIdx = -1; + end = firstNonSlashEnd; + } + } + } + } + if (start === end) end = firstNonSlashEnd; + else if (end === -1) end = path.length; + return path.slice(start, end); + } else { + for(i = path.length - 1; i >= 0; --i){ + if (path.charCodeAt(i) === 47) { + if (!matchedSlash) { + start = i + 1; + break; + } + } else if (end === -1) { + matchedSlash = false; + end = i + 1; + } + } + if (end === -1) return ""; + return path.slice(start, end); + } +} +function extname1(path) { + assertPath(path); + let startDot = -1; + let startPart = 0; + let end = -1; + let matchedSlash = true; + let preDotState = 0; + for(let i = path.length - 1; i >= 0; --i){ + const code = path.charCodeAt(i); + if (code === 47) { + if (!matchedSlash) { + startPart = i + 1; + break; + } + continue; + } + if (end === -1) { + matchedSlash = false; + end = i + 1; + } + if (code === 46) { + if (startDot === -1) startDot = i; + else if (preDotState !== 1) preDotState = 1; + } else if (startDot !== -1) { + preDotState = -1; + } + } + if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) { + return ""; + } + return path.slice(startDot, end); +} +function format1(pathObject) { + if (pathObject === null || typeof pathObject !== "object") { + throw new TypeError(`The "pathObject" argument must be of type Object. Received type ${typeof pathObject}`); + } + return _format("/", pathObject); +} +function parse1(path) { + assertPath(path); + const ret = { + root: "", + dir: "", + base: "", + ext: "", + name: "" + }; + if (path.length === 0) return ret; + const isAbsolute = path.charCodeAt(0) === 47; + let start; + if (isAbsolute) { + ret.root = "/"; + start = 1; + } else { + start = 0; + } + let startDot = -1; + let startPart = 0; + let end = -1; + let matchedSlash = true; + let i = path.length - 1; + let preDotState = 0; + for(; i >= start; --i){ + const code = path.charCodeAt(i); + if (code === 47) { + if (!matchedSlash) { + startPart = i + 1; + break; + } + continue; + } + if (end === -1) { + matchedSlash = false; + end = i + 1; + } + if (code === 46) { + if (startDot === -1) startDot = i; + else if (preDotState !== 1) preDotState = 1; + } else if (startDot !== -1) { + preDotState = -1; + } + } + if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) { + if (end !== -1) { + if (startPart === 0 && isAbsolute) { + ret.base = ret.name = path.slice(1, end); + } else { + ret.base = ret.name = path.slice(startPart, end); + } + } + } else { + if (startPart === 0 && isAbsolute) { + ret.name = path.slice(1, startDot); + ret.base = path.slice(1, end); + } else { + ret.name = path.slice(startPart, startDot); + ret.base = path.slice(startPart, end); + } + ret.ext = path.slice(startDot, end); + } + if (startPart > 0) ret.dir = path.slice(0, startPart - 1); + else if (isAbsolute) ret.dir = "/"; + return ret; +} +function fromFileUrl1(url) { + url = url instanceof URL ? url : new URL(url); + if (url.protocol != "file:") { + throw new TypeError("Must be a file URL."); + } + return decodeURIComponent(url.pathname.replace(/%(?![0-9A-Fa-f]{2})/g, "%25")); +} +function toFileUrl1(path) { + if (!isAbsolute1(path)) { + throw new TypeError("Must be an absolute path."); + } + const url = new URL("file:///"); + url.pathname = encodeWhitespace(path.replace(/%/g, "%25").replace(/\\/g, "%5C")); + return url; +} +const mod1 = { + sep: sep1, + delimiter: delimiter1, + resolve: resolve1, + normalize: normalize1, + isAbsolute: isAbsolute1, + join: join1, + relative: relative1, + toNamespacedPath: toNamespacedPath1, + dirname: dirname1, + basename: basename1, + extname: extname1, + format: format1, + parse: parse1, + fromFileUrl: fromFileUrl1, + toFileUrl: toFileUrl1 +}; +const path = isWindows ? mod : mod1; +const { join: join2 , normalize: normalize2 } = path; +const path1 = isWindows ? mod : mod1; +const { basename: basename2 , delimiter: delimiter2 , dirname: dirname2 , extname: extname2 , format: format2 , fromFileUrl: fromFileUrl2 , isAbsolute: isAbsolute2 , join: join3 , normalize: normalize3 , parse: parse2 , relative: relative2 , resolve: resolve2 , sep: sep2 , toFileUrl: toFileUrl2 , toNamespacedPath: toNamespacedPath2 } = path1; +function isCloser(value) { + return typeof value === "object" && value != null && "close" in value && typeof value["close"] === "function"; +} +function readableStreamFromReader(reader, options = {}) { + const { autoClose =true , chunkSize =16_640 , strategy } = options; + return new ReadableStream({ + async pull (controller) { + const chunk = new Uint8Array(chunkSize); + try { + const read = await reader.read(chunk); + if (read === null) { + if (isCloser(reader) && autoClose) { + reader.close(); + } + controller.close(); + return; + } + controller.enqueue(chunk.subarray(0, read)); + } catch (e) { + controller.error(e); + if (isCloser(reader)) { + reader.close(); + } + } + }, + cancel () { + if (isCloser(reader) && autoClose) { + reader.close(); + } + } + }, strategy); +} +const importMeta = { + url: "https://deno.land/std@0.140.0/examples/chat/server.ts", + main: import.meta.main +}; +const clients = new Map(); +let clientId = 0; +function dispatch(msg) { + for (const client of clients.values()){ + client.send(msg); + } +} +function wsHandler(ws) { + const id = ++clientId; + clients.set(id, ws); + ws.onopen = ()=>{ + dispatch(`Connected: [${id}]`); + }; + ws.onmessage = (e)=>{ + console.log(`msg:${id}`, e.data); + dispatch(`[${id}]: ${e.data}`); + }; + ws.onclose = ()=>{ + clients.delete(id); + dispatch(`Closed: [${id}]`); + }; +} +async function requestHandler(req) { + const pathname = new URL(req.request.url).pathname; + if (req.request.method === "GET" && pathname === "/") { + const u = new URL("./index.html", importMeta.url); + if (u.protocol.startsWith("http")) { + fetch(u.href).then(async (resp)=>{ + const body = new Uint8Array(await resp.arrayBuffer()); + req.respondWith(new Response(body, { + status: resp.status, + headers: { + "content-type": "text/html" + } + })); + }); + } else { + const file = await Deno.open(fromFileUrl2(u)); + req.respondWith(new Response(readableStreamFromReader(file), { + status: 200, + headers: { + "content-type": "text/html" + } + })); + } + } else if (req.request.method === "GET" && pathname === "/favicon.ico") { + req.respondWith(Response.redirect("https://deno.land/favicon.ico", 302)); + } else if (req.request.method === "GET" && pathname === "/ws") { + const { socket , response } = Deno.upgradeWebSocket(req.request); + wsHandler(socket); + req.respondWith(response); + } +} +const server = Deno.listen({ + port: 8080 +}); +console.log("chat server starting on :8080...."); +for await (const conn of server){ + (async ()=>{ + const httpConn = Deno.serveHttp(conn); + for await (const requestEvent of httpConn){ + requestHandler(requestEvent); + } + })(); +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["https://deno.land/std@0.140.0/_util/os.ts","https://deno.land/std@0.140.0/path/_constants.ts","https://deno.land/std@0.140.0/path/_util.ts","https://deno.land/std@0.140.0/_util/assert.ts","https://deno.land/std@0.140.0/path/win32.ts","https://deno.land/std@0.140.0/path/posix.ts","https://deno.land/std@0.140.0/path/glob.ts","https://deno.land/std@0.140.0/path/mod.ts","https://deno.land/std@0.140.0/streams/conversion.ts","https://deno.land/std@0.140.0/examples/chat/server.ts"],"sourcesContent":["// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.\n// This module is browser compatible.\n\nexport type OSType = \"windows\" | \"linux\" | \"darwin\";\n\nexport const osType: OSType = (() => {\n  // deno-lint-ignore no-explicit-any\n  const { Deno } = globalThis as any;\n  if (typeof Deno?.build?.os === \"string\") {\n    return Deno.build.os;\n  }\n\n  // deno-lint-ignore no-explicit-any\n  const { navigator } = globalThis as any;\n  if (navigator?.appVersion?.includes?.(\"Win\")) {\n    return \"windows\";\n  }\n\n  return \"linux\";\n})();\n\nexport const isWindows = osType === \"windows\";\nexport const isLinux = osType === \"linux\";\n","// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.\n// Copyright the Browserify authors. MIT License.\n// Ported from https://github.com/browserify/path-browserify/\n// This module is browser compatible.\n\n// Alphabet chars.\nexport const CHAR_UPPERCASE_A = 65; /* A */\nexport const CHAR_LOWERCASE_A = 97; /* a */\nexport const CHAR_UPPERCASE_Z = 90; /* Z */\nexport const CHAR_LOWERCASE_Z = 122; /* z */\n\n// Non-alphabetic chars.\nexport const CHAR_DOT = 46; /* . */\nexport const CHAR_FORWARD_SLASH = 47; /* / */\nexport const CHAR_BACKWARD_SLASH = 92; /* \\ */\nexport const CHAR_VERTICAL_LINE = 124; /* | */\nexport const CHAR_COLON = 58; /* : */\nexport const CHAR_QUESTION_MARK = 63; /* ? */\nexport const CHAR_UNDERSCORE = 95; /* _ */\nexport const CHAR_LINE_FEED = 10; /* \\n */\nexport const CHAR_CARRIAGE_RETURN = 13; /* \\r */\nexport const CHAR_TAB = 9; /* \\t */\nexport const CHAR_FORM_FEED = 12; /* \\f */\nexport const CHAR_EXCLAMATION_MARK = 33; /* ! */\nexport const CHAR_HASH = 35; /* # */\nexport const CHAR_SPACE = 32; /*   */\nexport const CHAR_NO_BREAK_SPACE = 160; /* \\u00A0 */\nexport const CHAR_ZERO_WIDTH_NOBREAK_SPACE = 65279; /* \\uFEFF */\nexport const CHAR_LEFT_SQUARE_BRACKET = 91; /* [ */\nexport const CHAR_RIGHT_SQUARE_BRACKET = 93; /* ] */\nexport const CHAR_LEFT_ANGLE_BRACKET = 60; /* < */\nexport const CHAR_RIGHT_ANGLE_BRACKET = 62; /* > */\nexport const CHAR_LEFT_CURLY_BRACKET = 123; /* { */\nexport const CHAR_RIGHT_CURLY_BRACKET = 125; /* } */\nexport const CHAR_HYPHEN_MINUS = 45; /* - */\nexport const CHAR_PLUS = 43; /* + */\nexport const CHAR_DOUBLE_QUOTE = 34; /* \" */\nexport const CHAR_SINGLE_QUOTE = 39; /* ' */\nexport const CHAR_PERCENT = 37; /* % */\nexport const CHAR_SEMICOLON = 59; /* ; */\nexport const CHAR_CIRCUMFLEX_ACCENT = 94; /* ^ */\nexport const CHAR_GRAVE_ACCENT = 96; /* ` */\nexport const CHAR_AT = 64; /* @ */\nexport const CHAR_AMPERSAND = 38; /* & */\nexport const CHAR_EQUAL = 61; /* = */\n\n// Digits\nexport const CHAR_0 = 48; /* 0 */\nexport const CHAR_9 = 57; /* 9 */\n","// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.\n// Copyright the Browserify authors. MIT License.\n// Ported from https://github.com/browserify/path-browserify/\n// This module is browser compatible.\n\nimport type { FormatInputPathObject } from \"./_interface.ts\";\nimport {\n  CHAR_BACKWARD_SLASH,\n  CHAR_DOT,\n  CHAR_FORWARD_SLASH,\n  CHAR_LOWERCASE_A,\n  CHAR_LOWERCASE_Z,\n  CHAR_UPPERCASE_A,\n  CHAR_UPPERCASE_Z,\n} from \"./_constants.ts\";\n\nexport function assertPath(path: string): void {\n  if (typeof path !== \"string\") {\n    throw new TypeError(\n      `Path must be a string. Received ${JSON.stringify(path)}`,\n    );\n  }\n}\n\nexport function isPosixPathSeparator(code: number): boolean {\n  return code === CHAR_FORWARD_SLASH;\n}\n\nexport function isPathSeparator(code: number): boolean {\n  return isPosixPathSeparator(code) || code === CHAR_BACKWARD_SLASH;\n}\n\nexport function isWindowsDeviceRoot(code: number): boolean {\n  return (\n    (code >= CHAR_LOWERCASE_A && code <= CHAR_LOWERCASE_Z) ||\n    (code >= CHAR_UPPERCASE_A && code <= CHAR_UPPERCASE_Z)\n  );\n}\n\n// Resolves . and .. elements in a path with directory names\nexport function normalizeString(\n  path: string,\n  allowAboveRoot: boolean,\n  separator: string,\n  isPathSeparator: (code: number) => boolean,\n): string {\n  let res = \"\";\n  let lastSegmentLength = 0;\n  let lastSlash = -1;\n  let dots = 0;\n  let code: number | undefined;\n  for (let i = 0, len = path.length; i <= len; ++i) {\n    if (i < len) code = path.charCodeAt(i);\n    else if (isPathSeparator(code!)) break;\n    else code = CHAR_FORWARD_SLASH;\n\n    if (isPathSeparator(code!)) {\n      if (lastSlash === i - 1 || dots === 1) {\n        // NOOP\n      } else if (lastSlash !== i - 1 && dots === 2) {\n        if (\n          res.length < 2 ||\n          lastSegmentLength !== 2 ||\n          res.charCodeAt(res.length - 1) !== CHAR_DOT ||\n          res.charCodeAt(res.length - 2) !== CHAR_DOT\n        ) {\n          if (res.length > 2) {\n            const lastSlashIndex = res.lastIndexOf(separator);\n            if (lastSlashIndex === -1) {\n              res = \"\";\n              lastSegmentLength = 0;\n            } else {\n              res = res.slice(0, lastSlashIndex);\n              lastSegmentLength = res.length - 1 - res.lastIndexOf(separator);\n            }\n            lastSlash = i;\n            dots = 0;\n            continue;\n          } else if (res.length === 2 || res.length === 1) {\n            res = \"\";\n            lastSegmentLength = 0;\n            lastSlash = i;\n            dots = 0;\n            continue;\n          }\n        }\n        if (allowAboveRoot) {\n          if (res.length > 0) res += `${separator}..`;\n          else res = \"..\";\n          lastSegmentLength = 2;\n        }\n      } else {\n        if (res.length > 0) res += separator + path.slice(lastSlash + 1, i);\n        else res = path.slice(lastSlash + 1, i);\n        lastSegmentLength = i - lastSlash - 1;\n      }\n      lastSlash = i;\n      dots = 0;\n    } else if (code === CHAR_DOT && dots !== -1) {\n      ++dots;\n    } else {\n      dots = -1;\n    }\n  }\n  return res;\n}\n\nexport function _format(\n  sep: string,\n  pathObject: FormatInputPathObject,\n): string {\n  const dir: string | undefined = pathObject.dir || pathObject.root;\n  const base: string = pathObject.base ||\n    (pathObject.name || \"\") + (pathObject.ext || \"\");\n  if (!dir) return base;\n  if (dir === pathObject.root) return dir + base;\n  return dir + sep + base;\n}\n\nconst WHITESPACE_ENCODINGS: Record<string, string> = {\n  \"\\u0009\": \"%09\",\n  \"\\u000A\": \"%0A\",\n  \"\\u000B\": \"%0B\",\n  \"\\u000C\": \"%0C\",\n  \"\\u000D\": \"%0D\",\n  \"\\u0020\": \"%20\",\n};\n\nexport function encodeWhitespace(string: string): string {\n  return string.replaceAll(/[\\s]/g, (c) => {\n    return WHITESPACE_ENCODINGS[c] ?? c;\n  });\n}\n","// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.\n// This module is browser compatible.\n\nexport class DenoStdInternalError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"DenoStdInternalError\";\n  }\n}\n\n/** Make an assertion, if not `true`, then throw. */\nexport function assert(expr: unknown, msg = \"\"): asserts expr {\n  if (!expr) {\n    throw new DenoStdInternalError(msg);\n  }\n}\n","// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.\n// Copyright the Browserify authors. MIT License.\n// Ported from https://github.com/browserify/path-browserify/\n// This module is browser compatible.\n\nimport type { FormatInputPathObject, ParsedPath } from \"./_interface.ts\";\nimport {\n  CHAR_BACKWARD_SLASH,\n  CHAR_COLON,\n  CHAR_DOT,\n  CHAR_QUESTION_MARK,\n} from \"./_constants.ts\";\n\nimport {\n  _format,\n  assertPath,\n  encodeWhitespace,\n  isPathSeparator,\n  isWindowsDeviceRoot,\n  normalizeString,\n} from \"./_util.ts\";\nimport { assert } from \"../_util/assert.ts\";\n\nexport const sep = \"\\\\\";\nexport const delimiter = \";\";\n\n/**\n * Resolves path segments into a `path`\n * @param pathSegments to process to path\n */\nexport function resolve(...pathSegments: string[]): string {\n  let resolvedDevice = \"\";\n  let resolvedTail = \"\";\n  let resolvedAbsolute = false;\n\n  for (let i = pathSegments.length - 1; i >= -1; i--) {\n    let path: string;\n    // deno-lint-ignore no-explicit-any\n    const { Deno } = globalThis as any;\n    if (i >= 0) {\n      path = pathSegments[i];\n    } else if (!resolvedDevice) {\n      if (typeof Deno?.cwd !== \"function\") {\n        throw new TypeError(\"Resolved a drive-letter-less path without a CWD.\");\n      }\n      path = Deno.cwd();\n    } else {\n      if (\n        typeof Deno?.env?.get !== \"function\" || typeof Deno?.cwd !== \"function\"\n      ) {\n        throw new TypeError(\"Resolved a relative path without a CWD.\");\n      }\n      path = Deno.cwd();\n\n      // Verify that a cwd was found and that it actually points\n      // to our drive. If not, default to the drive's root.\n      if (\n        path === undefined ||\n        path.slice(0, 3).toLowerCase() !== `${resolvedDevice.toLowerCase()}\\\\`\n      ) {\n        path = `${resolvedDevice}\\\\`;\n      }\n    }\n\n    assertPath(path);\n\n    const len = path.length;\n\n    // Skip empty entries\n    if (len === 0) continue;\n\n    let rootEnd = 0;\n    let device = \"\";\n    let isAbsolute = false;\n    const code = path.charCodeAt(0);\n\n    // Try to match a root\n    if (len > 1) {\n      if (isPathSeparator(code)) {\n        // Possible UNC root\n\n        // If we started with a separator, we know we at least have an\n        // absolute path of some kind (UNC or otherwise)\n        isAbsolute = true;\n\n        if (isPathSeparator(path.charCodeAt(1))) {\n          // Matched double path separator at beginning\n          let j = 2;\n          let last = j;\n          // Match 1 or more non-path separators\n          for (; j < len; ++j) {\n            if (isPathSeparator(path.charCodeAt(j))) break;\n          }\n          if (j < len && j !== last) {\n            const firstPart = path.slice(last, j);\n            // Matched!\n            last = j;\n            // Match 1 or more path separators\n            for (; j < len; ++j) {\n              if (!isPathSeparator(path.charCodeAt(j))) break;\n            }\n            if (j < len && j !== last) {\n              // Matched!\n              last = j;\n              // Match 1 or more non-path separators\n              for (; j < len; ++j) {\n                if (isPathSeparator(path.charCodeAt(j))) break;\n              }\n              if (j === len) {\n                // We matched a UNC root only\n                device = `\\\\\\\\${firstPart}\\\\${path.slice(last)}`;\n                rootEnd = j;\n              } else if (j !== last) {\n                // We matched a UNC root with leftovers\n\n                device = `\\\\\\\\${firstPart}\\\\${path.slice(last, j)}`;\n                rootEnd = j;\n              }\n            }\n          }\n        } else {\n          rootEnd = 1;\n        }\n      } else if (isWindowsDeviceRoot(code)) {\n        // Possible device root\n\n        if (path.charCodeAt(1) === CHAR_COLON) {\n          device = path.slice(0, 2);\n          rootEnd = 2;\n          if (len > 2) {\n            if (isPathSeparator(path.charCodeAt(2))) {\n              // Treat separator following drive name as an absolute path\n              // indicator\n              isAbsolute = true;\n              rootEnd = 3;\n            }\n          }\n        }\n      }\n    } else if (isPathSeparator(code)) {\n      // `path` contains just a path separator\n      rootEnd = 1;\n      isAbsolute = true;\n    }\n\n    if (\n      device.length > 0 &&\n      resolvedDevice.length > 0 &&\n      device.toLowerCase() !== resolvedDevice.toLowerCase()\n    ) {\n      // This path points to another device so it is not applicable\n      continue;\n    }\n\n    if (resolvedDevice.length === 0 && device.length > 0) {\n      resolvedDevice = device;\n    }\n    if (!resolvedAbsolute) {\n      resolvedTail = `${path.slice(rootEnd)}\\\\${resolvedTail}`;\n      resolvedAbsolute = isAbsolute;\n    }\n\n    if (resolvedAbsolute && resolvedDevice.length > 0) break;\n  }\n\n  // At this point the path should be resolved to a full absolute path,\n  // but handle relative paths to be safe (might happen when process.cwd()\n  // fails)\n\n  // Normalize the tail path\n  resolvedTail = normalizeString(\n    resolvedTail,\n    !resolvedAbsolute,\n    \"\\\\\",\n    isPathSeparator,\n  );\n\n  return resolvedDevice + (resolvedAbsolute ? \"\\\\\" : \"\") + resolvedTail || \".\";\n}\n\n/**\n * Normalizes a `path`\n * @param path to normalize\n */\nexport function normalize(path: string): string {\n  assertPath(path);\n  const len = path.length;\n  if (len === 0) return \".\";\n  let rootEnd = 0;\n  let device: string | undefined;\n  let isAbsolute = false;\n  const code = path.charCodeAt(0);\n\n  // Try to match a root\n  if (len > 1) {\n    if (isPathSeparator(code)) {\n      // Possible UNC root\n\n      // If we started with a separator, we know we at least have an absolute\n      // path of some kind (UNC or otherwise)\n      isAbsolute = true;\n\n      if (isPathSeparator(path.charCodeAt(1))) {\n        // Matched double path separator at beginning\n        let j = 2;\n        let last = j;\n        // Match 1 or more non-path separators\n        for (; j < len; ++j) {\n          if (isPathSeparator(path.charCodeAt(j))) break;\n        }\n        if (j < len && j !== last) {\n          const firstPart = path.slice(last, j);\n          // Matched!\n          last = j;\n          // Match 1 or more path separators\n          for (; j < len; ++j) {\n            if (!isPathSeparator(path.charCodeAt(j))) break;\n          }\n          if (j < len && j !== last) {\n            // Matched!\n            last = j;\n            // Match 1 or more non-path separators\n            for (; j < len; ++j) {\n              if (isPathSeparator(path.charCodeAt(j))) break;\n            }\n            if (j === len) {\n              // We matched a UNC root only\n              // Return the normalized version of the UNC root since there\n              // is nothing left to process\n\n              return `\\\\\\\\${firstPart}\\\\${path.slice(last)}\\\\`;\n            } else if (j !== last) {\n              // We matched a UNC root with leftovers\n\n              device = `\\\\\\\\${firstPart}\\\\${path.slice(last, j)}`;\n              rootEnd = j;\n            }\n          }\n        }\n      } else {\n        rootEnd = 1;\n      }\n    } else if (isWindowsDeviceRoot(code)) {\n      // Possible device root\n\n      if (path.charCodeAt(1) === CHAR_COLON) {\n        device = path.slice(0, 2);\n        rootEnd = 2;\n        if (len > 2) {\n          if (isPathSeparator(path.charCodeAt(2))) {\n            // Treat separator following drive name as an absolute path\n            // indicator\n            isAbsolute = true;\n            rootEnd = 3;\n          }\n        }\n      }\n    }\n  } else if (isPathSeparator(code)) {\n    // `path` contains just a path separator, exit early to avoid unnecessary\n    // work\n    return \"\\\\\";\n  }\n\n  let tail: string;\n  if (rootEnd < len) {\n    tail = normalizeString(\n      path.slice(rootEnd),\n      !isAbsolute,\n      \"\\\\\",\n      isPathSeparator,\n    );\n  } else {\n    tail = \"\";\n  }\n  if (tail.length === 0 && !isAbsolute) tail = \".\";\n  if (tail.length > 0 && isPathSeparator(path.charCodeAt(len - 1))) {\n    tail += \"\\\\\";\n  }\n  if (device === undefined) {\n    if (isAbsolute) {\n      if (tail.length > 0) return `\\\\${tail}`;\n      else return \"\\\\\";\n    } else if (tail.length > 0) {\n      return tail;\n    } else {\n      return \"\";\n    }\n  } else if (isAbsolute) {\n    if (tail.length > 0) return `${device}\\\\${tail}`;\n    else return `${device}\\\\`;\n  } else if (tail.length > 0) {\n    return device + tail;\n  } else {\n    return device;\n  }\n}\n\n/**\n * Verifies whether path is absolute\n * @param path to verify\n */\nexport function isAbsolute(path: string): boolean {\n  assertPath(path);\n  const len = path.length;\n  if (len === 0) return false;\n\n  const code = path.charCodeAt(0);\n  if (isPathSeparator(code)) {\n    return true;\n  } else if (isWindowsDeviceRoot(code)) {\n    // Possible device root\n\n    if (len > 2 && path.charCodeAt(1) === CHAR_COLON) {\n      if (isPathSeparator(path.charCodeAt(2))) return true;\n    }\n  }\n  return false;\n}\n\n/**\n * Join all given a sequence of `paths`,then normalizes the resulting path.\n * @param paths to be joined and normalized\n */\nexport function join(...paths: string[]): string {\n  const pathsCount = paths.length;\n  if (pathsCount === 0) return \".\";\n\n  let joined: string | undefined;\n  let firstPart: string | null = null;\n  for (let i = 0; i < pathsCount; ++i) {\n    const path = paths[i];\n    assertPath(path);\n    if (path.length > 0) {\n      if (joined === undefined) joined = firstPart = path;\n      else joined += `\\\\${path}`;\n    }\n  }\n\n  if (joined === undefined) return \".\";\n\n  // Make sure that the joined path doesn't start with two slashes, because\n  // normalize() will mistake it for an UNC path then.\n  //\n  // This step is skipped when it is very clear that the user actually\n  // intended to point at an UNC path. This is assumed when the first\n  // non-empty string arguments starts with exactly two slashes followed by\n  // at least one more non-slash character.\n  //\n  // Note that for normalize() to treat a path as an UNC path it needs to\n  // have at least 2 components, so we don't filter for that here.\n  // This means that the user can use join to construct UNC paths from\n  // a server name and a share name; for example:\n  //   path.join('//server', 'share') -> '\\\\\\\\server\\\\share\\\\')\n  let needsReplace = true;\n  let slashCount = 0;\n  assert(firstPart != null);\n  if (isPathSeparator(firstPart.charCodeAt(0))) {\n    ++slashCount;\n    const firstLen = firstPart.length;\n    if (firstLen > 1) {\n      if (isPathSeparator(firstPart.charCodeAt(1))) {\n        ++slashCount;\n        if (firstLen > 2) {\n          if (isPathSeparator(firstPart.charCodeAt(2))) ++slashCount;\n          else {\n            // We matched a UNC path in the first part\n            needsReplace = false;\n          }\n        }\n      }\n    }\n  }\n  if (needsReplace) {\n    // Find any more consecutive slashes we need to replace\n    for (; slashCount < joined.length; ++slashCount) {\n      if (!isPathSeparator(joined.charCodeAt(slashCount))) break;\n    }\n\n    // Replace the slashes if needed\n    if (slashCount >= 2) joined = `\\\\${joined.slice(slashCount)}`;\n  }\n\n  return normalize(joined);\n}\n\n/**\n * It will solve the relative path from `from` to `to`, for instance:\n *  from = 'C:\\\\orandea\\\\test\\\\aaa'\n *  to = 'C:\\\\orandea\\\\impl\\\\bbb'\n * The output of the function should be: '..\\\\..\\\\impl\\\\bbb'\n * @param from relative path\n * @param to relative path\n */\nexport function relative(from: string, to: string): string {\n  assertPath(from);\n  assertPath(to);\n\n  if (from === to) return \"\";\n\n  const fromOrig = resolve(from);\n  const toOrig = resolve(to);\n\n  if (fromOrig === toOrig) return \"\";\n\n  from = fromOrig.toLowerCase();\n  to = toOrig.toLowerCase();\n\n  if (from === to) return \"\";\n\n  // Trim any leading backslashes\n  let fromStart = 0;\n  let fromEnd = from.length;\n  for (; fromStart < fromEnd; ++fromStart) {\n    if (from.charCodeAt(fromStart) !== CHAR_BACKWARD_SLASH) break;\n  }\n  // Trim trailing backslashes (applicable to UNC paths only)\n  for (; fromEnd - 1 > fromStart; --fromEnd) {\n    if (from.charCodeAt(fromEnd - 1) !== CHAR_BACKWARD_SLASH) break;\n  }\n  const fromLen = fromEnd - fromStart;\n\n  // Trim any leading backslashes\n  let toStart = 0;\n  let toEnd = to.length;\n  for (; toStart < toEnd; ++toStart) {\n    if (to.charCodeAt(toStart) !== CHAR_BACKWARD_SLASH) break;\n  }\n  // Trim trailing backslashes (applicable to UNC paths only)\n  for (; toEnd - 1 > toStart; --toEnd) {\n    if (to.charCodeAt(toEnd - 1) !== CHAR_BACKWARD_SLASH) break;\n  }\n  const toLen = toEnd - toStart;\n\n  // Compare paths to find the longest common path from root\n  const length = fromLen < toLen ? fromLen : toLen;\n  let lastCommonSep = -1;\n  let i = 0;\n  for (; i <= length; ++i) {\n    if (i === length) {\n      if (toLen > length) {\n        if (to.charCodeAt(toStart + i) === CHAR_BACKWARD_SLASH) {\n          // We get here if `from` is the exact base path for `to`.\n          // For example: from='C:\\\\foo\\\\bar'; to='C:\\\\foo\\\\bar\\\\baz'\n          return toOrig.slice(toStart + i + 1);\n        } else if (i === 2) {\n          // We get here if `from` is the device root.\n          // For example: from='C:\\\\'; to='C:\\\\foo'\n          return toOrig.slice(toStart + i);\n        }\n      }\n      if (fromLen > length) {\n        if (from.charCodeAt(fromStart + i) === CHAR_BACKWARD_SLASH) {\n          // We get here if `to` is the exact base path for `from`.\n          // For example: from='C:\\\\foo\\\\bar'; to='C:\\\\foo'\n          lastCommonSep = i;\n        } else if (i === 2) {\n          // We get here if `to` is the device root.\n          // For example: from='C:\\\\foo\\\\bar'; to='C:\\\\'\n          lastCommonSep = 3;\n        }\n      }\n      break;\n    }\n    const fromCode = from.charCodeAt(fromStart + i);\n    const toCode = to.charCodeAt(toStart + i);\n    if (fromCode !== toCode) break;\n    else if (fromCode === CHAR_BACKWARD_SLASH) lastCommonSep = i;\n  }\n\n  // We found a mismatch before the first common path separator was seen, so\n  // return the original `to`.\n  if (i !== length && lastCommonSep === -1) {\n    return toOrig;\n  }\n\n  let out = \"\";\n  if (lastCommonSep === -1) lastCommonSep = 0;\n  // Generate the relative path based on the path difference between `to` and\n  // `from`\n  for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {\n    if (i === fromEnd || from.charCodeAt(i) === CHAR_BACKWARD_SLASH) {\n      if (out.length === 0) out += \"..\";\n      else out += \"\\\\..\";\n    }\n  }\n\n  // Lastly, append the rest of the destination (`to`) path that comes after\n  // the common path parts\n  if (out.length > 0) {\n    return out + toOrig.slice(toStart + lastCommonSep, toEnd);\n  } else {\n    toStart += lastCommonSep;\n    if (toOrig.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) ++toStart;\n    return toOrig.slice(toStart, toEnd);\n  }\n}\n\n/**\n * Resolves path to a namespace path\n * @param path to resolve to namespace\n */\nexport function toNamespacedPath(path: string): string {\n  // Note: this will *probably* throw somewhere.\n  if (typeof path !== \"string\") return path;\n  if (path.length === 0) return \"\";\n\n  const resolvedPath = resolve(path);\n\n  if (resolvedPath.length >= 3) {\n    if (resolvedPath.charCodeAt(0) === CHAR_BACKWARD_SLASH) {\n      // Possible UNC root\n\n      if (resolvedPath.charCodeAt(1) === CHAR_BACKWARD_SLASH) {\n        const code = resolvedPath.charCodeAt(2);\n        if (code !== CHAR_QUESTION_MARK && code !== CHAR_DOT) {\n          // Matched non-long UNC root, convert the path to a long UNC path\n          return `\\\\\\\\?\\\\UNC\\\\${resolvedPath.slice(2)}`;\n        }\n      }\n    } else if (isWindowsDeviceRoot(resolvedPath.charCodeAt(0))) {\n      // Possible device root\n\n      if (\n        resolvedPath.charCodeAt(1) === CHAR_COLON &&\n        resolvedPath.charCodeAt(2) === CHAR_BACKWARD_SLASH\n      ) {\n        // Matched device root, convert the path to a long UNC path\n        return `\\\\\\\\?\\\\${resolvedPath}`;\n      }\n    }\n  }\n\n  return path;\n}\n\n/**\n * Return the directory name of a `path`.\n * @param path to determine name for\n */\nexport function dirname(path: string): string {\n  assertPath(path);\n  const len = path.length;\n  if (len === 0) return \".\";\n  let rootEnd = -1;\n  let end = -1;\n  let matchedSlash = true;\n  let offset = 0;\n  const code = path.charCodeAt(0);\n\n  // Try to match a root\n  if (len > 1) {\n    if (isPathSeparator(code)) {\n      // Possible UNC root\n\n      rootEnd = offset = 1;\n\n      if (isPathSeparator(path.charCodeAt(1))) {\n        // Matched double path separator at beginning\n        let j = 2;\n        let last = j;\n        // Match 1 or more non-path separators\n        for (; j < len; ++j) {\n          if (isPathSeparator(path.charCodeAt(j))) break;\n        }\n        if (j < len && j !== last) {\n          // Matched!\n          last = j;\n          // Match 1 or more path separators\n          for (; j < len; ++j) {\n            if (!isPathSeparator(path.charCodeAt(j))) break;\n          }\n          if (j < len && j !== last) {\n            // Matched!\n            last = j;\n            // Match 1 or more non-path separators\n            for (; j < len; ++j) {\n              if (isPathSeparator(path.charCodeAt(j))) break;\n            }\n            if (j === len) {\n              // We matched a UNC root only\n              return path;\n            }\n            if (j !== last) {\n              // We matched a UNC root with leftovers\n\n              // Offset by 1 to include the separator after the UNC root to\n              // treat it as a \"normal root\" on top of a (UNC) root\n              rootEnd = offset = j + 1;\n            }\n          }\n        }\n      }\n    } else if (isWindowsDeviceRoot(code)) {\n      // Possible device root\n\n      if (path.charCodeAt(1) === CHAR_COLON) {\n        rootEnd = offset = 2;\n        if (len > 2) {\n          if (isPathSeparator(path.charCodeAt(2))) rootEnd = offset = 3;\n        }\n      }\n    }\n  } else if (isPathSeparator(code)) {\n    // `path` contains just a path separator, exit early to avoid\n    // unnecessary work\n    return path;\n  }\n\n  for (let i = len - 1; i >= offset; --i) {\n    if (isPathSeparator(path.charCodeAt(i))) {\n      if (!matchedSlash) {\n        end = i;\n        break;\n      }\n    } else {\n      // We saw the first non-path separator\n      matchedSlash = false;\n    }\n  }\n\n  if (end === -1) {\n    if (rootEnd === -1) return \".\";\n    else end = rootEnd;\n  }\n  return path.slice(0, end);\n}\n\n/**\n * Return the last portion of a `path`. Trailing directory separators are ignored.\n * @param path to process\n * @param ext of path directory\n */\nexport function basename(path: string, ext = \"\"): string {\n  if (ext !== undefined && typeof ext !== \"string\") {\n    throw new TypeError('\"ext\" argument must be a string');\n  }\n\n  assertPath(path);\n\n  let start = 0;\n  let end = -1;\n  let matchedSlash = true;\n  let i: number;\n\n  // Check for a drive letter prefix so as not to mistake the following\n  // path separator as an extra separator at the end of the path that can be\n  // disregarded\n  if (path.length >= 2) {\n    const drive = path.charCodeAt(0);\n    if (isWindowsDeviceRoot(drive)) {\n      if (path.charCodeAt(1) === CHAR_COLON) start = 2;\n    }\n  }\n\n  if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {\n    if (ext.length === path.length && ext === path) return \"\";\n    let extIdx = ext.length - 1;\n    let firstNonSlashEnd = -1;\n    for (i = path.length - 1; i >= start; --i) {\n      const code = path.charCodeAt(i);\n      if (isPathSeparator(code)) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          start = i + 1;\n          break;\n        }\n      } else {\n        if (firstNonSlashEnd === -1) {\n          // We saw the first non-path separator, remember this index in case\n          // we need it if the extension ends up not matching\n          matchedSlash = false;\n          firstNonSlashEnd = i + 1;\n        }\n        if (extIdx >= 0) {\n          // Try to match the explicit extension\n          if (code === ext.charCodeAt(extIdx)) {\n            if (--extIdx === -1) {\n              // We matched the extension, so mark this as the end of our path\n              // component\n              end = i;\n            }\n          } else {\n            // Extension does not match, so our result is the entire path\n            // component\n            extIdx = -1;\n            end = firstNonSlashEnd;\n          }\n        }\n      }\n    }\n\n    if (start === end) end = firstNonSlashEnd;\n    else if (end === -1) end = path.length;\n    return path.slice(start, end);\n  } else {\n    for (i = path.length - 1; i >= start; --i) {\n      if (isPathSeparator(path.charCodeAt(i))) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          start = i + 1;\n          break;\n        }\n      } else if (end === -1) {\n        // We saw the first non-path separator, mark this as the end of our\n        // path component\n        matchedSlash = false;\n        end = i + 1;\n      }\n    }\n\n    if (end === -1) return \"\";\n    return path.slice(start, end);\n  }\n}\n\n/**\n * Return the extension of the `path` with leading period.\n * @param path with extension\n * @returns extension (ex. for `file.ts` returns `.ts`)\n */\nexport function extname(path: string): string {\n  assertPath(path);\n  let start = 0;\n  let startDot = -1;\n  let startPart = 0;\n  let end = -1;\n  let matchedSlash = true;\n  // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find\n  let preDotState = 0;\n\n  // Check for a drive letter prefix so as not to mistake the following\n  // path separator as an extra separator at the end of the path that can be\n  // disregarded\n\n  if (\n    path.length >= 2 &&\n    path.charCodeAt(1) === CHAR_COLON &&\n    isWindowsDeviceRoot(path.charCodeAt(0))\n  ) {\n    start = startPart = 2;\n  }\n\n  for (let i = path.length - 1; i >= start; --i) {\n    const code = path.charCodeAt(i);\n    if (isPathSeparator(code)) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now\n      if (!matchedSlash) {\n        startPart = i + 1;\n        break;\n      }\n      continue;\n    }\n    if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension\n      matchedSlash = false;\n      end = i + 1;\n    }\n    if (code === CHAR_DOT) {\n      // If this is our first dot, mark it as the start of our extension\n      if (startDot === -1) startDot = i;\n      else if (preDotState !== 1) preDotState = 1;\n    } else if (startDot !== -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension\n      preDotState = -1;\n    }\n  }\n\n  if (\n    startDot === -1 ||\n    end === -1 ||\n    // We saw a non-dot character immediately before the dot\n    preDotState === 0 ||\n    // The (right-most) trimmed path component is exactly '..'\n    (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)\n  ) {\n    return \"\";\n  }\n  return path.slice(startDot, end);\n}\n\n/**\n * Generate a path from `FormatInputPathObject` object.\n * @param pathObject with path\n */\nexport function format(pathObject: FormatInputPathObject): string {\n  if (pathObject === null || typeof pathObject !== \"object\") {\n    throw new TypeError(\n      `The \"pathObject\" argument must be of type Object. Received type ${typeof pathObject}`,\n    );\n  }\n  return _format(\"\\\\\", pathObject);\n}\n\n/**\n * Return a `ParsedPath` object of the `path`.\n * @param path to process\n */\nexport function parse(path: string): ParsedPath {\n  assertPath(path);\n\n  const ret: ParsedPath = { root: \"\", dir: \"\", base: \"\", ext: \"\", name: \"\" };\n\n  const len = path.length;\n  if (len === 0) return ret;\n\n  let rootEnd = 0;\n  let code = path.charCodeAt(0);\n\n  // Try to match a root\n  if (len > 1) {\n    if (isPathSeparator(code)) {\n      // Possible UNC root\n\n      rootEnd = 1;\n      if (isPathSeparator(path.charCodeAt(1))) {\n        // Matched double path separator at beginning\n        let j = 2;\n        let last = j;\n        // Match 1 or more non-path separators\n        for (; j < len; ++j) {\n          if (isPathSeparator(path.charCodeAt(j))) break;\n        }\n        if (j < len && j !== last) {\n          // Matched!\n          last = j;\n          // Match 1 or more path separators\n          for (; j < len; ++j) {\n            if (!isPathSeparator(path.charCodeAt(j))) break;\n          }\n          if (j < len && j !== last) {\n            // Matched!\n            last = j;\n            // Match 1 or more non-path separators\n            for (; j < len; ++j) {\n              if (isPathSeparator(path.charCodeAt(j))) break;\n            }\n            if (j === len) {\n              // We matched a UNC root only\n\n              rootEnd = j;\n            } else if (j !== last) {\n              // We matched a UNC root with leftovers\n\n              rootEnd = j + 1;\n            }\n          }\n        }\n      }\n    } else if (isWindowsDeviceRoot(code)) {\n      // Possible device root\n\n      if (path.charCodeAt(1) === CHAR_COLON) {\n        rootEnd = 2;\n        if (len > 2) {\n          if (isPathSeparator(path.charCodeAt(2))) {\n            if (len === 3) {\n              // `path` contains just a drive root, exit early to avoid\n              // unnecessary work\n              ret.root = ret.dir = path;\n              return ret;\n            }\n            rootEnd = 3;\n          }\n        } else {\n          // `path` contains just a drive root, exit early to avoid\n          // unnecessary work\n          ret.root = ret.dir = path;\n          return ret;\n        }\n      }\n    }\n  } else if (isPathSeparator(code)) {\n    // `path` contains just a path separator, exit early to avoid\n    // unnecessary work\n    ret.root = ret.dir = path;\n    return ret;\n  }\n\n  if (rootEnd > 0) ret.root = path.slice(0, rootEnd);\n\n  let startDot = -1;\n  let startPart = rootEnd;\n  let end = -1;\n  let matchedSlash = true;\n  let i = path.length - 1;\n\n  // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find\n  let preDotState = 0;\n\n  // Get non-dir info\n  for (; i >= rootEnd; --i) {\n    code = path.charCodeAt(i);\n    if (isPathSeparator(code)) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now\n      if (!matchedSlash) {\n        startPart = i + 1;\n        break;\n      }\n      continue;\n    }\n    if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension\n      matchedSlash = false;\n      end = i + 1;\n    }\n    if (code === CHAR_DOT) {\n      // If this is our first dot, mark it as the start of our extension\n      if (startDot === -1) startDot = i;\n      else if (preDotState !== 1) preDotState = 1;\n    } else if (startDot !== -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension\n      preDotState = -1;\n    }\n  }\n\n  if (\n    startDot === -1 ||\n    end === -1 ||\n    // We saw a non-dot character immediately before the dot\n    preDotState === 0 ||\n    // The (right-most) trimmed path component is exactly '..'\n    (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)\n  ) {\n    if (end !== -1) {\n      ret.base = ret.name = path.slice(startPart, end);\n    }\n  } else {\n    ret.name = path.slice(startPart, startDot);\n    ret.base = path.slice(startPart, end);\n    ret.ext = path.slice(startDot, end);\n  }\n\n  // If the directory is the root, use the entire root as the `dir` including\n  // the trailing slash if any (`C:\\abc` -> `C:\\`). Otherwise, strip out the\n  // trailing slash (`C:\\abc\\def` -> `C:\\abc`).\n  if (startPart > 0 && startPart !== rootEnd) {\n    ret.dir = path.slice(0, startPart - 1);\n  } else ret.dir = ret.root;\n\n  return ret;\n}\n\n/**\n * Converts a file URL to a path string.\n *\n * ```ts\n *      import { fromFileUrl } from \"./win32.ts\";\n *      fromFileUrl(\"file:///home/foo\"); // \"\\\\home\\\\foo\"\n *      fromFileUrl(\"file:///C:/Users/foo\"); // \"C:\\\\Users\\\\foo\"\n *      fromFileUrl(\"file://localhost/home/foo\"); // \"\\\\\\\\localhost\\\\home\\\\foo\"\n * ```\n * @param url of a file URL\n */\nexport function fromFileUrl(url: string | URL): string {\n  url = url instanceof URL ? url : new URL(url);\n  if (url.protocol != \"file:\") {\n    throw new TypeError(\"Must be a file URL.\");\n  }\n  let path = decodeURIComponent(\n    url.pathname.replace(/\\//g, \"\\\\\").replace(/%(?![0-9A-Fa-f]{2})/g, \"%25\"),\n  ).replace(/^\\\\*([A-Za-z]:)(\\\\|$)/, \"$1\\\\\");\n  if (url.hostname != \"\") {\n    // Note: The `URL` implementation guarantees that the drive letter and\n    // hostname are mutually exclusive. Otherwise it would not have been valid\n    // to append the hostname and path like this.\n    path = `\\\\\\\\${url.hostname}${path}`;\n  }\n  return path;\n}\n\n/**\n * Converts a path string to a file URL.\n *\n * ```ts\n *      import { toFileUrl } from \"./win32.ts\";\n *      toFileUrl(\"\\\\home\\\\foo\"); // new URL(\"file:///home/foo\")\n *      toFileUrl(\"C:\\\\Users\\\\foo\"); // new URL(\"file:///C:/Users/foo\")\n *      toFileUrl(\"\\\\\\\\127.0.0.1\\\\home\\\\foo\"); // new URL(\"file://127.0.0.1/home/foo\")\n * ```\n * @param path to convert to file URL\n */\nexport function toFileUrl(path: string): URL {\n  if (!isAbsolute(path)) {\n    throw new TypeError(\"Must be an absolute path.\");\n  }\n  const [, hostname, pathname] = path.match(\n    /^(?:[/\\\\]{2}([^/\\\\]+)(?=[/\\\\](?:[^/\\\\]|$)))?(.*)/,\n  )!;\n  const url = new URL(\"file:///\");\n  url.pathname = encodeWhitespace(pathname.replace(/%/g, \"%25\"));\n  if (hostname != null && hostname != \"localhost\") {\n    url.hostname = hostname;\n    if (!url.hostname) {\n      throw new TypeError(\"Invalid hostname.\");\n    }\n  }\n  return url;\n}\n","// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.\n// Copyright the Browserify authors. MIT License.\n// Ported from https://github.com/browserify/path-browserify/\n// This module is browser compatible.\n\nimport type { FormatInputPathObject, ParsedPath } from \"./_interface.ts\";\nimport { CHAR_DOT, CHAR_FORWARD_SLASH } from \"./_constants.ts\";\n\nimport {\n  _format,\n  assertPath,\n  encodeWhitespace,\n  isPosixPathSeparator,\n  normalizeString,\n} from \"./_util.ts\";\n\nexport const sep = \"/\";\nexport const delimiter = \":\";\n\n// path.resolve([from ...], to)\n/**\n * Resolves `pathSegments` into an absolute path.\n * @param pathSegments an array of path segments\n */\nexport function resolve(...pathSegments: string[]): string {\n  let resolvedPath = \"\";\n  let resolvedAbsolute = false;\n\n  for (let i = pathSegments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n    let path: string;\n\n    if (i >= 0) path = pathSegments[i];\n    else {\n      // deno-lint-ignore no-explicit-any\n      const { Deno } = globalThis as any;\n      if (typeof Deno?.cwd !== \"function\") {\n        throw new TypeError(\"Resolved a relative path without a CWD.\");\n      }\n      path = Deno.cwd();\n    }\n\n    assertPath(path);\n\n    // Skip empty entries\n    if (path.length === 0) {\n      continue;\n    }\n\n    resolvedPath = `${path}/${resolvedPath}`;\n    resolvedAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;\n  }\n\n  // At this point the path should be resolved to a full absolute path, but\n  // handle relative paths to be safe (might happen when process.cwd() fails)\n\n  // Normalize the path\n  resolvedPath = normalizeString(\n    resolvedPath,\n    !resolvedAbsolute,\n    \"/\",\n    isPosixPathSeparator,\n  );\n\n  if (resolvedAbsolute) {\n    if (resolvedPath.length > 0) return `/${resolvedPath}`;\n    else return \"/\";\n  } else if (resolvedPath.length > 0) return resolvedPath;\n  else return \".\";\n}\n\n/**\n * Normalize the `path`, resolving `'..'` and `'.'` segments.\n * @param path to be normalized\n */\nexport function normalize(path: string): string {\n  assertPath(path);\n\n  if (path.length === 0) return \".\";\n\n  const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;\n  const trailingSeparator =\n    path.charCodeAt(path.length - 1) === CHAR_FORWARD_SLASH;\n\n  // Normalize the path\n  path = normalizeString(path, !isAbsolute, \"/\", isPosixPathSeparator);\n\n  if (path.length === 0 && !isAbsolute) path = \".\";\n  if (path.length > 0 && trailingSeparator) path += \"/\";\n\n  if (isAbsolute) return `/${path}`;\n  return path;\n}\n\n/**\n * Verifies whether provided path is absolute\n * @param path to be verified as absolute\n */\nexport function isAbsolute(path: string): boolean {\n  assertPath(path);\n  return path.length > 0 && path.charCodeAt(0) === CHAR_FORWARD_SLASH;\n}\n\n/**\n * Join all given a sequence of `paths`,then normalizes the resulting path.\n * @param paths to be joined and normalized\n */\nexport function join(...paths: string[]): string {\n  if (paths.length === 0) return \".\";\n  let joined: string | undefined;\n  for (let i = 0, len = paths.length; i < len; ++i) {\n    const path = paths[i];\n    assertPath(path);\n    if (path.length > 0) {\n      if (!joined) joined = path;\n      else joined += `/${path}`;\n    }\n  }\n  if (!joined) return \".\";\n  return normalize(joined);\n}\n\n/**\n * Return the relative path from `from` to `to` based on current working directory.\n * @param from path in current working directory\n * @param to path in current working directory\n */\nexport function relative(from: string, to: string): string {\n  assertPath(from);\n  assertPath(to);\n\n  if (from === to) return \"\";\n\n  from = resolve(from);\n  to = resolve(to);\n\n  if (from === to) return \"\";\n\n  // Trim any leading backslashes\n  let fromStart = 1;\n  const fromEnd = from.length;\n  for (; fromStart < fromEnd; ++fromStart) {\n    if (from.charCodeAt(fromStart) !== CHAR_FORWARD_SLASH) break;\n  }\n  const fromLen = fromEnd - fromStart;\n\n  // Trim any leading backslashes\n  let toStart = 1;\n  const toEnd = to.length;\n  for (; toStart < toEnd; ++toStart) {\n    if (to.charCodeAt(toStart) !== CHAR_FORWARD_SLASH) break;\n  }\n  const toLen = toEnd - toStart;\n\n  // Compare paths to find the longest common path from root\n  const length = fromLen < toLen ? fromLen : toLen;\n  let lastCommonSep = -1;\n  let i = 0;\n  for (; i <= length; ++i) {\n    if (i === length) {\n      if (toLen > length) {\n        if (to.charCodeAt(toStart + i) === CHAR_FORWARD_SLASH) {\n          // We get here if `from` is the exact base path for `to`.\n          // For example: from='/foo/bar'; to='/foo/bar/baz'\n          return to.slice(toStart + i + 1);\n        } else if (i === 0) {\n          // We get here if `from` is the root\n          // For example: from='/'; to='/foo'\n          return to.slice(toStart + i);\n        }\n      } else if (fromLen > length) {\n        if (from.charCodeAt(fromStart + i) === CHAR_FORWARD_SLASH) {\n          // We get here if `to` is the exact base path for `from`.\n          // For example: from='/foo/bar/baz'; to='/foo/bar'\n          lastCommonSep = i;\n        } else if (i === 0) {\n          // We get here if `to` is the root.\n          // For example: from='/foo'; to='/'\n          lastCommonSep = 0;\n        }\n      }\n      break;\n    }\n    const fromCode = from.charCodeAt(fromStart + i);\n    const toCode = to.charCodeAt(toStart + i);\n    if (fromCode !== toCode) break;\n    else if (fromCode === CHAR_FORWARD_SLASH) lastCommonSep = i;\n  }\n\n  let out = \"\";\n  // Generate the relative path based on the path difference between `to`\n  // and `from`\n  for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {\n    if (i === fromEnd || from.charCodeAt(i) === CHAR_FORWARD_SLASH) {\n      if (out.length === 0) out += \"..\";\n      else out += \"/..\";\n    }\n  }\n\n  // Lastly, append the rest of the destination (`to`) path that comes after\n  // the common path parts\n  if (out.length > 0) return out + to.slice(toStart + lastCommonSep);\n  else {\n    toStart += lastCommonSep;\n    if (to.charCodeAt(toStart) === CHAR_FORWARD_SLASH) ++toStart;\n    return to.slice(toStart);\n  }\n}\n\n/**\n * Resolves path to a namespace path\n * @param path to resolve to namespace\n */\nexport function toNamespacedPath(path: string): string {\n  // Non-op on posix systems\n  return path;\n}\n\n/**\n * Return the directory name of a `path`.\n * @param path to determine name for\n */\nexport function dirname(path: string): string {\n  assertPath(path);\n  if (path.length === 0) return \".\";\n  const hasRoot = path.charCodeAt(0) === CHAR_FORWARD_SLASH;\n  let end = -1;\n  let matchedSlash = true;\n  for (let i = path.length - 1; i >= 1; --i) {\n    if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {\n      if (!matchedSlash) {\n        end = i;\n        break;\n      }\n    } else {\n      // We saw the first non-path separator\n      matchedSlash = false;\n    }\n  }\n\n  if (end === -1) return hasRoot ? \"/\" : \".\";\n  if (hasRoot && end === 1) return \"//\";\n  return path.slice(0, end);\n}\n\n/**\n * Return the last portion of a `path`. Trailing directory separators are ignored.\n * @param path to process\n * @param ext of path directory\n */\nexport function basename(path: string, ext = \"\"): string {\n  if (ext !== undefined && typeof ext !== \"string\") {\n    throw new TypeError('\"ext\" argument must be a string');\n  }\n  assertPath(path);\n\n  let start = 0;\n  let end = -1;\n  let matchedSlash = true;\n  let i: number;\n\n  if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {\n    if (ext.length === path.length && ext === path) return \"\";\n    let extIdx = ext.length - 1;\n    let firstNonSlashEnd = -1;\n    for (i = path.length - 1; i >= 0; --i) {\n      const code = path.charCodeAt(i);\n      if (code === CHAR_FORWARD_SLASH) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          start = i + 1;\n          break;\n        }\n      } else {\n        if (firstNonSlashEnd === -1) {\n          // We saw the first non-path separator, remember this index in case\n          // we need it if the extension ends up not matching\n          matchedSlash = false;\n          firstNonSlashEnd = i + 1;\n        }\n        if (extIdx >= 0) {\n          // Try to match the explicit extension\n          if (code === ext.charCodeAt(extIdx)) {\n            if (--extIdx === -1) {\n              // We matched the extension, so mark this as the end of our path\n              // component\n              end = i;\n            }\n          } else {\n            // Extension does not match, so our result is the entire path\n            // component\n            extIdx = -1;\n            end = firstNonSlashEnd;\n          }\n        }\n      }\n    }\n\n    if (start === end) end = firstNonSlashEnd;\n    else if (end === -1) end = path.length;\n    return path.slice(start, end);\n  } else {\n    for (i = path.length - 1; i >= 0; --i) {\n      if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          start = i + 1;\n          break;\n        }\n      } else if (end === -1) {\n        // We saw the first non-path separator, mark this as the end of our\n        // path component\n        matchedSlash = false;\n        end = i + 1;\n      }\n    }\n\n    if (end === -1) return \"\";\n    return path.slice(start, end);\n  }\n}\n\n/**\n * Return the extension of the `path` with leading period.\n * @param path with extension\n * @returns extension (ex. for `file.ts` returns `.ts`)\n */\nexport function extname(path: string): string {\n  assertPath(path);\n  let startDot = -1;\n  let startPart = 0;\n  let end = -1;\n  let matchedSlash = true;\n  // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find\n  let preDotState = 0;\n  for (let i = path.length - 1; i >= 0; --i) {\n    const code = path.charCodeAt(i);\n    if (code === CHAR_FORWARD_SLASH) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now\n      if (!matchedSlash) {\n        startPart = i + 1;\n        break;\n      }\n      continue;\n    }\n    if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension\n      matchedSlash = false;\n      end = i + 1;\n    }\n    if (code === CHAR_DOT) {\n      // If this is our first dot, mark it as the start of our extension\n      if (startDot === -1) startDot = i;\n      else if (preDotState !== 1) preDotState = 1;\n    } else if (startDot !== -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension\n      preDotState = -1;\n    }\n  }\n\n  if (\n    startDot === -1 ||\n    end === -1 ||\n    // We saw a non-dot character immediately before the dot\n    preDotState === 0 ||\n    // The (right-most) trimmed path component is exactly '..'\n    (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)\n  ) {\n    return \"\";\n  }\n  return path.slice(startDot, end);\n}\n\n/**\n * Generate a path from `FormatInputPathObject` object.\n * @param pathObject with path\n */\nexport function format(pathObject: FormatInputPathObject): string {\n  if (pathObject === null || typeof pathObject !== \"object\") {\n    throw new TypeError(\n      `The \"pathObject\" argument must be of type Object. Received type ${typeof pathObject}`,\n    );\n  }\n  return _format(\"/\", pathObject);\n}\n\n/**\n * Return a `ParsedPath` object of the `path`.\n * @param path to process\n */\nexport function parse(path: string): ParsedPath {\n  assertPath(path);\n\n  const ret: ParsedPath = { root: \"\", dir: \"\", base: \"\", ext: \"\", name: \"\" };\n  if (path.length === 0) return ret;\n  const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;\n  let start: number;\n  if (isAbsolute) {\n    ret.root = \"/\";\n    start = 1;\n  } else {\n    start = 0;\n  }\n  let startDot = -1;\n  let startPart = 0;\n  let end = -1;\n  let matchedSlash = true;\n  let i = path.length - 1;\n\n  // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find\n  let preDotState = 0;\n\n  // Get non-dir info\n  for (; i >= start; --i) {\n    const code = path.charCodeAt(i);\n    if (code === CHAR_FORWARD_SLASH) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now\n      if (!matchedSlash) {\n        startPart = i + 1;\n        break;\n      }\n      continue;\n    }\n    if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension\n      matchedSlash = false;\n      end = i + 1;\n    }\n    if (code === CHAR_DOT) {\n      // If this is our first dot, mark it as the start of our extension\n      if (startDot === -1) startDot = i;\n      else if (preDotState !== 1) preDotState = 1;\n    } else if (startDot !== -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension\n      preDotState = -1;\n    }\n  }\n\n  if (\n    startDot === -1 ||\n    end === -1 ||\n    // We saw a non-dot character immediately before the dot\n    preDotState === 0 ||\n    // The (right-most) trimmed path component is exactly '..'\n    (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)\n  ) {\n    if (end !== -1) {\n      if (startPart === 0 && isAbsolute) {\n        ret.base = ret.name = path.slice(1, end);\n      } else {\n        ret.base = ret.name = path.slice(startPart, end);\n      }\n    }\n  } else {\n    if (startPart === 0 && isAbsolute) {\n      ret.name = path.slice(1, startDot);\n      ret.base = path.slice(1, end);\n    } else {\n      ret.name = path.slice(startPart, startDot);\n      ret.base = path.slice(startPart, end);\n    }\n    ret.ext = path.slice(startDot, end);\n  }\n\n  if (startPart > 0) ret.dir = path.slice(0, startPart - 1);\n  else if (isAbsolute) ret.dir = \"/\";\n\n  return ret;\n}\n\n/**\n * Converts a file URL to a path string.\n *\n * ```ts\n *      import { fromFileUrl } from \"./posix.ts\";\n *      fromFileUrl(\"file:///home/foo\"); // \"/home/foo\"\n * ```\n * @param url of a file URL\n */\nexport function fromFileUrl(url: string | URL): string {\n  url = url instanceof URL ? url : new URL(url);\n  if (url.protocol != \"file:\") {\n    throw new TypeError(\"Must be a file URL.\");\n  }\n  return decodeURIComponent(\n    url.pathname.replace(/%(?![0-9A-Fa-f]{2})/g, \"%25\"),\n  );\n}\n\n/**\n * Converts a path string to a file URL.\n *\n * ```ts\n *      import { toFileUrl } from \"./posix.ts\";\n *      toFileUrl(\"/home/foo\"); // new URL(\"file:///home/foo\")\n * ```\n * @param path to convert to file URL\n */\nexport function toFileUrl(path: string): URL {\n  if (!isAbsolute(path)) {\n    throw new TypeError(\"Must be an absolute path.\");\n  }\n  const url = new URL(\"file:///\");\n  url.pathname = encodeWhitespace(\n    path.replace(/%/g, \"%25\").replace(/\\\\/g, \"%5C\"),\n  );\n  return url;\n}\n","// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.\n// This module is browser compatible.\n\nimport { isWindows, osType } from \"../_util/os.ts\";\nimport { SEP, SEP_PATTERN } from \"./separator.ts\";\nimport * as _win32 from \"./win32.ts\";\nimport * as _posix from \"./posix.ts\";\nimport type { OSType } from \"../_util/os.ts\";\n\nconst path = isWindows ? _win32 : _posix;\nconst { join, normalize } = path;\n\nexport interface GlobOptions {\n  /** Extended glob syntax.\n   * See https://www.linuxjournal.com/content/bash-extended-globbing. Defaults\n   * to true. */\n  extended?: boolean;\n  /** Globstar syntax.\n   * See https://www.linuxjournal.com/content/globstar-new-bash-globbing-option.\n   * If false, `**` is treated like `*`. Defaults to true. */\n  globstar?: boolean;\n  /** Whether globstar should be case insensitive. */\n  caseInsensitive?: boolean;\n  /** Operating system. Defaults to the native OS. */\n  os?: OSType;\n}\n\nexport type GlobToRegExpOptions = GlobOptions;\n\nconst regExpEscapeChars = [\n  \"!\",\n  \"$\",\n  \"(\",\n  \")\",\n  \"*\",\n  \"+\",\n  \".\",\n  \"=\",\n  \"?\",\n  \"[\",\n  \"\\\\\",\n  \"^\",\n  \"{\",\n  \"|\",\n];\nconst rangeEscapeChars = [\"-\", \"\\\\\", \"]\"];\n\n/** Convert a glob string to a regular expression.\n *\n * Tries to match bash glob expansion as closely as possible.\n *\n * Basic glob syntax:\n * - `*` - Matches everything without leaving the path segment.\n * - `?` - Matches any single character.\n * - `{foo,bar}` - Matches `foo` or `bar`.\n * - `[abcd]` - Matches `a`, `b`, `c` or `d`.\n * - `[a-d]` - Matches `a`, `b`, `c` or `d`.\n * - `[!abcd]` - Matches any single character besides `a`, `b`, `c` or `d`.\n * - `[[:<class>:]]` - Matches any character belonging to `<class>`.\n *     - `[[:alnum:]]` - Matches any digit or letter.\n *     - `[[:digit:]abc]` - Matches any digit, `a`, `b` or `c`.\n *     - See https://facelessuser.github.io/wcmatch/glob/#posix-character-classes\n *       for a complete list of supported character classes.\n * - `\\` - Escapes the next character for an `os` other than `\"windows\"`.\n * - \\` - Escapes the next character for `os` set to `\"windows\"`.\n * - `/` - Path separator.\n * - `\\` - Additional path separator only for `os` set to `\"windows\"`.\n *\n * Extended syntax:\n * - Requires `{ extended: true }`.\n * - `?(foo|bar)` - Matches 0 or 1 instance of `{foo,bar}`.\n * - `@(foo|bar)` - Matches 1 instance of `{foo,bar}`. They behave the same.\n * - `*(foo|bar)` - Matches _n_ instances of `{foo,bar}`.\n * - `+(foo|bar)` - Matches _n > 0_ instances of `{foo,bar}`.\n * - `!(foo|bar)` - Matches anything other than `{foo,bar}`.\n * - See https://www.linuxjournal.com/content/bash-extended-globbing.\n *\n * Globstar syntax:\n * - Requires `{ globstar: true }`.\n * - `**` - Matches any number of any path segments.\n *     - Must comprise its entire path segment in the provided glob.\n * - See https://www.linuxjournal.com/content/globstar-new-bash-globbing-option.\n *\n * Note the following properties:\n * - The generated `RegExp` is anchored at both start and end.\n * - Repeating and trailing separators are tolerated. Trailing separators in the\n *   provided glob have no meaning and are discarded.\n * - Absolute globs will only match absolute paths, etc.\n * - Empty globs will match nothing.\n * - Any special glob syntax must be contained to one path segment. For example,\n *   `?(foo|bar/baz)` is invalid. The separator will take precedence and the\n *   first segment ends with an unclosed group.\n * - If a path segment ends with unclosed groups or a dangling escape prefix, a\n *   parse error has occurred. Every character for that segment is taken\n *   literally in this event.\n *\n * Limitations:\n * - A negative group like `!(foo|bar)` will wrongly be converted to a negative\n *   look-ahead followed by a wildcard. This means that `!(foo).js` will wrongly\n *   fail to match `foobar.js`, even though `foobar` is not `foo`. Effectively,\n *   `!(foo|bar)` is treated like `!(@(foo|bar)*)`. This will work correctly if\n *   the group occurs not nested at the end of the segment. */\nexport function globToRegExp(\n  glob: string,\n  {\n    extended = true,\n    globstar: globstarOption = true,\n    os = osType,\n    caseInsensitive = false,\n  }: GlobToRegExpOptions = {},\n): RegExp {\n  if (glob == \"\") {\n    return /(?!)/;\n  }\n\n  const sep = os == \"windows\" ? \"(?:\\\\\\\\|/)+\" : \"/+\";\n  const sepMaybe = os == \"windows\" ? \"(?:\\\\\\\\|/)*\" : \"/*\";\n  const seps = os == \"windows\" ? [\"\\\\\", \"/\"] : [\"/\"];\n  const globstar = os == \"windows\"\n    ? \"(?:[^\\\\\\\\/]*(?:\\\\\\\\|/|$)+)*\"\n    : \"(?:[^/]*(?:/|$)+)*\";\n  const wildcard = os == \"windows\" ? \"[^\\\\\\\\/]*\" : \"[^/]*\";\n  const escapePrefix = os == \"windows\" ? \"`\" : \"\\\\\";\n\n  // Remove trailing separators.\n  let newLength = glob.length;\n  for (; newLength > 1 && seps.includes(glob[newLength - 1]); newLength--);\n  glob = glob.slice(0, newLength);\n\n  let regExpString = \"\";\n\n  // Terminates correctly. Trust that `j` is incremented every iteration.\n  for (let j = 0; j < glob.length;) {\n    let segment = \"\";\n    const groupStack: string[] = [];\n    let inRange = false;\n    let inEscape = false;\n    let endsWithSep = false;\n    let i = j;\n\n    // Terminates with `i` at the non-inclusive end of the current segment.\n    for (; i < glob.length && !seps.includes(glob[i]); i++) {\n      if (inEscape) {\n        inEscape = false;\n        const escapeChars = inRange ? rangeEscapeChars : regExpEscapeChars;\n        segment += escapeChars.includes(glob[i]) ? `\\\\${glob[i]}` : glob[i];\n        continue;\n      }\n\n      if (glob[i] == escapePrefix) {\n        inEscape = true;\n        continue;\n      }\n\n      if (glob[i] == \"[\") {\n        if (!inRange) {\n          inRange = true;\n          segment += \"[\";\n          if (glob[i + 1] == \"!\") {\n            i++;\n            segment += \"^\";\n          } else if (glob[i + 1] == \"^\") {\n            i++;\n            segment += \"\\\\^\";\n          }\n          continue;\n        } else if (glob[i + 1] == \":\") {\n          let k = i + 1;\n          let value = \"\";\n          while (glob[k + 1] != null && glob[k + 1] != \":\") {\n            value += glob[k + 1];\n            k++;\n          }\n          if (glob[k + 1] == \":\" && glob[k + 2] == \"]\") {\n            i = k + 2;\n            if (value == \"alnum\") segment += \"\\\\dA-Za-z\";\n            else if (value == \"alpha\") segment += \"A-Za-z\";\n            else if (value == \"ascii\") segment += \"\\x00-\\x7F\";\n            else if (value == \"blank\") segment += \"\\t \";\n            else if (value == \"cntrl\") segment += \"\\x00-\\x1F\\x7F\";\n            else if (value == \"digit\") segment += \"\\\\d\";\n            else if (value == \"graph\") segment += \"\\x21-\\x7E\";\n            else if (value == \"lower\") segment += \"a-z\";\n            else if (value == \"print\") segment += \"\\x20-\\x7E\";\n            else if (value == \"punct\") {\n              segment += \"!\\\"#$%&'()*+,\\\\-./:;<=>?@[\\\\\\\\\\\\]^_‘{|}~\";\n            } else if (value == \"space\") segment += \"\\\\s\\v\";\n            else if (value == \"upper\") segment += \"A-Z\";\n            else if (value == \"word\") segment += \"\\\\w\";\n            else if (value == \"xdigit\") segment += \"\\\\dA-Fa-f\";\n            continue;\n          }\n        }\n      }\n\n      if (glob[i] == \"]\" && inRange) {\n        inRange = false;\n        segment += \"]\";\n        continue;\n      }\n\n      if (inRange) {\n        if (glob[i] == \"\\\\\") {\n          segment += `\\\\\\\\`;\n        } else {\n          segment += glob[i];\n        }\n        continue;\n      }\n\n      if (\n        glob[i] == \")\" && groupStack.length > 0 &&\n        groupStack[groupStack.length - 1] != \"BRACE\"\n      ) {\n        segment += \")\";\n        const type = groupStack.pop()!;\n        if (type == \"!\") {\n          segment += wildcard;\n        } else if (type != \"@\") {\n          segment += type;\n        }\n        continue;\n      }\n\n      if (\n        glob[i] == \"|\" && groupStack.length > 0 &&\n        groupStack[groupStack.length - 1] != \"BRACE\"\n      ) {\n        segment += \"|\";\n        continue;\n      }\n\n      if (glob[i] == \"+\" && extended && glob[i + 1] == \"(\") {\n        i++;\n        groupStack.push(\"+\");\n        segment += \"(?:\";\n        continue;\n      }\n\n      if (glob[i] == \"@\" && extended && glob[i + 1] == \"(\") {\n        i++;\n        groupStack.push(\"@\");\n        segment += \"(?:\";\n        continue;\n      }\n\n      if (glob[i] == \"?\") {\n        if (extended && glob[i + 1] == \"(\") {\n          i++;\n          groupStack.push(\"?\");\n          segment += \"(?:\";\n        } else {\n          segment += \".\";\n        }\n        continue;\n      }\n\n      if (glob[i] == \"!\" && extended && glob[i + 1] == \"(\") {\n        i++;\n        groupStack.push(\"!\");\n        segment += \"(?!\";\n        continue;\n      }\n\n      if (glob[i] == \"{\") {\n        groupStack.push(\"BRACE\");\n        segment += \"(?:\";\n        continue;\n      }\n\n      if (glob[i] == \"}\" && groupStack[groupStack.length - 1] == \"BRACE\") {\n        groupStack.pop();\n        segment += \")\";\n        continue;\n      }\n\n      if (glob[i] == \",\" && groupStack[groupStack.length - 1] == \"BRACE\") {\n        segment += \"|\";\n        continue;\n      }\n\n      if (glob[i] == \"*\") {\n        if (extended && glob[i + 1] == \"(\") {\n          i++;\n          groupStack.push(\"*\");\n          segment += \"(?:\";\n        } else {\n          const prevChar = glob[i - 1];\n          let numStars = 1;\n          while (glob[i + 1] == \"*\") {\n            i++;\n            numStars++;\n          }\n          const nextChar = glob[i + 1];\n          if (\n            globstarOption && numStars == 2 &&\n            [...seps, undefined].includes(prevChar) &&\n            [...seps, undefined].includes(nextChar)\n          ) {\n            segment += globstar;\n            endsWithSep = true;\n          } else {\n            segment += wildcard;\n          }\n        }\n        continue;\n      }\n\n      segment += regExpEscapeChars.includes(glob[i]) ? `\\\\${glob[i]}` : glob[i];\n    }\n\n    // Check for unclosed groups or a dangling backslash.\n    if (groupStack.length > 0 || inRange || inEscape) {\n      // Parse failure. Take all characters from this segment literally.\n      segment = \"\";\n      for (const c of glob.slice(j, i)) {\n        segment += regExpEscapeChars.includes(c) ? `\\\\${c}` : c;\n        endsWithSep = false;\n      }\n    }\n\n    regExpString += segment;\n    if (!endsWithSep) {\n      regExpString += i < glob.length ? sep : sepMaybe;\n      endsWithSep = true;\n    }\n\n    // Terminates with `i` at the start of the next segment.\n    while (seps.includes(glob[i])) i++;\n\n    // Check that the next value of `j` is indeed higher than the current value.\n    if (!(i > j)) {\n      throw new Error(\"Assertion failure: i > j (potential infinite loop)\");\n    }\n    j = i;\n  }\n\n  regExpString = `^${regExpString}$`;\n  return new RegExp(regExpString, caseInsensitive ? \"i\" : \"\");\n}\n\n/** Test whether the given string is a glob */\nexport function isGlob(str: string): boolean {\n  const chars: Record<string, string> = { \"{\": \"}\", \"(\": \")\", \"[\": \"]\" };\n  const regex =\n    /\\\\(.)|(^!|\\*|\\?|[\\].+)]\\?|\\[[^\\\\\\]]+\\]|\\{[^\\\\}]+\\}|\\(\\?[:!=][^\\\\)]+\\)|\\([^|]+\\|[^\\\\)]+\\))/;\n\n  if (str === \"\") {\n    return false;\n  }\n\n  let match: RegExpExecArray | null;\n\n  while ((match = regex.exec(str))) {\n    if (match[2]) return true;\n    let idx = match.index + match[0].length;\n\n    // if an open bracket/brace/paren is escaped,\n    // set the index to the next closing character\n    const open = match[1];\n    const close = open ? chars[open] : null;\n    if (open && close) {\n      const n = str.indexOf(close, idx);\n      if (n !== -1) {\n        idx = n + 1;\n      }\n    }\n\n    str = str.slice(idx);\n  }\n\n  return false;\n}\n\n/** Like normalize(), but doesn't collapse \"**\\/..\" when `globstar` is true. */\nexport function normalizeGlob(\n  glob: string,\n  { globstar = false }: GlobOptions = {},\n): string {\n  if (glob.match(/\\0/g)) {\n    throw new Error(`Glob contains invalid characters: \"${glob}\"`);\n  }\n  if (!globstar) {\n    return normalize(glob);\n  }\n  const s = SEP_PATTERN.source;\n  const badParentPattern = new RegExp(\n    `(?<=(${s}|^)\\\\*\\\\*${s})\\\\.\\\\.(?=${s}|$)`,\n    \"g\",\n  );\n  return normalize(glob.replace(badParentPattern, \"\\0\")).replace(/\\0/g, \"..\");\n}\n\n/** Like join(), but doesn't collapse \"**\\/..\" when `globstar` is true. */\nexport function joinGlobs(\n  globs: string[],\n  { extended = true, globstar = false }: GlobOptions = {},\n): string {\n  if (!globstar || globs.length == 0) {\n    return join(...globs);\n  }\n  if (globs.length === 0) return \".\";\n  let joined: string | undefined;\n  for (const glob of globs) {\n    const path = glob;\n    if (path.length > 0) {\n      if (!joined) joined = path;\n      else joined += `${SEP}${path}`;\n    }\n  }\n  if (!joined) return \".\";\n  return normalizeGlob(joined, { extended, globstar });\n}\n","// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.\n// Copyright the Browserify authors. MIT License.\n\n/**\n * Ported mostly from https://github.com/browserify/path-browserify/\n * This module is browser compatible.\n * @module\n */\n\nimport { isWindows } from \"../_util/os.ts\";\nimport * as _win32 from \"./win32.ts\";\nimport * as _posix from \"./posix.ts\";\n\nconst path = isWindows ? _win32 : _posix;\n\nexport const win32 = _win32;\nexport const posix = _posix;\nexport const {\n  basename,\n  delimiter,\n  dirname,\n  extname,\n  format,\n  fromFileUrl,\n  isAbsolute,\n  join,\n  normalize,\n  parse,\n  relative,\n  resolve,\n  sep,\n  toFileUrl,\n  toNamespacedPath,\n} = path;\n\nexport * from \"./common.ts\";\nexport { SEP, SEP_PATTERN } from \"./separator.ts\";\nexport * from \"./_interface.ts\";\nexport * from \"./glob.ts\";\n","// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.\n\nimport { Buffer } from \"../io/buffer.ts\";\n\nconst DEFAULT_CHUNK_SIZE = 16_640;\nconst DEFAULT_BUFFER_SIZE = 32 * 1024;\n\nfunction isCloser(value: unknown): value is Deno.Closer {\n  return typeof value === \"object\" && value != null && \"close\" in value &&\n    // deno-lint-ignore no-explicit-any\n    typeof (value as Record<string, any>)[\"close\"] === \"function\";\n}\n\n/** Create a `Deno.Reader` from an iterable of `Uint8Array`s.\n *\n * ```ts\n *      import { readerFromIterable } from \"./conversion.ts\";\n *\n *      const file = await Deno.open(\"metrics.txt\", { write: true });\n *      const reader = readerFromIterable((async function* () {\n *        while (true) {\n *          await new Promise((r) => setTimeout(r, 1000));\n *          const message = `data: ${JSON.stringify(Deno.metrics())}\\n\\n`;\n *          yield new TextEncoder().encode(message);\n *        }\n *      })());\n *      await Deno.copy(reader, file);\n * ```\n */\nexport function readerFromIterable(\n  iterable: Iterable<Uint8Array> | AsyncIterable<Uint8Array>,\n): Deno.Reader {\n  const iterator: Iterator<Uint8Array> | AsyncIterator<Uint8Array> =\n    (iterable as AsyncIterable<Uint8Array>)[Symbol.asyncIterator]?.() ??\n      (iterable as Iterable<Uint8Array>)[Symbol.iterator]?.();\n  const buffer = new Buffer();\n  return {\n    async read(p: Uint8Array): Promise<number | null> {\n      if (buffer.length == 0) {\n        const result = await iterator.next();\n        if (result.done) {\n          return null;\n        } else {\n          if (result.value.byteLength <= p.byteLength) {\n            p.set(result.value);\n            return result.value.byteLength;\n          }\n          p.set(result.value.subarray(0, p.byteLength));\n          await writeAll(buffer, result.value.subarray(p.byteLength));\n          return p.byteLength;\n        }\n      } else {\n        const n = await buffer.read(p);\n        if (n == null) {\n          return this.read(p);\n        }\n        return n;\n      }\n    },\n  };\n}\n\n/** Create a `Writer` from a `WritableStreamDefaultWriter`. */\nexport function writerFromStreamWriter(\n  streamWriter: WritableStreamDefaultWriter<Uint8Array>,\n): Deno.Writer {\n  return {\n    async write(p: Uint8Array): Promise<number> {\n      await streamWriter.ready;\n      await streamWriter.write(p);\n      return p.length;\n    },\n  };\n}\n\n/** Create a `Reader` from a `ReadableStreamDefaultReader`. */\nexport function readerFromStreamReader(\n  streamReader: ReadableStreamDefaultReader<Uint8Array>,\n): Deno.Reader {\n  const buffer = new Buffer();\n\n  return {\n    async read(p: Uint8Array): Promise<number | null> {\n      if (buffer.empty()) {\n        const res = await streamReader.read();\n        if (res.done) {\n          return null; // EOF\n        }\n\n        await writeAll(buffer, res.value);\n      }\n\n      return buffer.read(p);\n    },\n  };\n}\n\nexport interface WritableStreamFromWriterOptions {\n  /**\n   * If the `writer` is also a `Deno.Closer`, automatically close the `writer`\n   * when the stream is closed, aborted, or a write error occurs.\n   *\n   * Defaults to `true`. */\n  autoClose?: boolean;\n}\n\n/** Create a `WritableStream` from a `Writer`. */\nexport function writableStreamFromWriter(\n  writer: Deno.Writer,\n  options: WritableStreamFromWriterOptions = {},\n): WritableStream<Uint8Array> {\n  const { autoClose = true } = options;\n\n  return new WritableStream({\n    async write(chunk, controller) {\n      try {\n        await writeAll(writer, chunk);\n      } catch (e) {\n        controller.error(e);\n        if (isCloser(writer) && autoClose) {\n          writer.close();\n        }\n      }\n    },\n    close() {\n      if (isCloser(writer) && autoClose) {\n        writer.close();\n      }\n    },\n    abort() {\n      if (isCloser(writer) && autoClose) {\n        writer.close();\n      }\n    },\n  });\n}\n\n/** Create a `ReadableStream` from any kind of iterable.\n *\n * ```ts\n *      import { readableStreamFromIterable } from \"./conversion.ts\";\n *\n *      const r1 = readableStreamFromIterable([\"foo, bar, baz\"]);\n *      const r2 = readableStreamFromIterable(async function* () {\n *        await new Promise(((r) => setTimeout(r, 1000)));\n *        yield \"foo\";\n *        await new Promise(((r) => setTimeout(r, 1000)));\n *        yield \"bar\";\n *        await new Promise(((r) => setTimeout(r, 1000)));\n *        yield \"baz\";\n *      }());\n * ```\n *\n * If the produced iterator (`iterable[Symbol.asyncIterator]()` or\n * `iterable[Symbol.iterator]()`) is a generator, or more specifically is found\n * to have a `.throw()` method on it, that will be called upon\n * `readableStream.cancel()`. This is the case for the second input type above:\n *\n * ```ts\n * import { readableStreamFromIterable } from \"./conversion.ts\";\n *\n * const r3 = readableStreamFromIterable(async function* () {\n *   try {\n *     yield \"foo\";\n *   } catch (error) {\n *     console.log(error); // Error: Cancelled by consumer.\n *   }\n * }());\n * const reader = r3.getReader();\n * console.log(await reader.read()); // { value: \"foo\", done: false }\n * await reader.cancel(new Error(\"Cancelled by consumer.\"));\n * ```\n */\nexport function readableStreamFromIterable<T>(\n  iterable: Iterable<T> | AsyncIterable<T>,\n): ReadableStream<T> {\n  const iterator: Iterator<T> | AsyncIterator<T> =\n    (iterable as AsyncIterable<T>)[Symbol.asyncIterator]?.() ??\n      (iterable as Iterable<T>)[Symbol.iterator]?.();\n  return new ReadableStream({\n    async pull(controller) {\n      const { value, done } = await iterator.next();\n      if (done) {\n        controller.close();\n      } else {\n        controller.enqueue(value);\n      }\n    },\n    async cancel(reason) {\n      if (typeof iterator.throw == \"function\") {\n        try {\n          await iterator.throw(reason);\n        } catch { /* `iterator.throw()` always throws on site. We catch it. */ }\n      }\n    },\n  });\n}\n\nexport interface ReadableStreamFromReaderOptions {\n  /** If the `reader` is also a `Deno.Closer`, automatically close the `reader`\n   * when `EOF` is encountered, or a read error occurs.\n   *\n   * Defaults to `true`. */\n  autoClose?: boolean;\n\n  /** The size of chunks to allocate to read, the default is ~16KiB, which is\n   * the maximum size that Deno operations can currently support. */\n  chunkSize?: number;\n\n  /** The queuing strategy to create the `ReadableStream` with. */\n  strategy?: { highWaterMark?: number | undefined; size?: undefined };\n}\n\n/**\n * Create a `ReadableStream<Uint8Array>` from from a `Deno.Reader`.\n *\n * When the pull algorithm is called on the stream, a chunk from the reader\n * will be read.  When `null` is returned from the reader, the stream will be\n * closed along with the reader (if it is also a `Deno.Closer`).\n *\n * An example converting a `Deno.FsFile` into a readable stream:\n *\n * ```ts\n * import { readableStreamFromReader } from \"./mod.ts\";\n *\n * const file = await Deno.open(\"./file.txt\", { read: true });\n * const fileStream = readableStreamFromReader(file);\n * ```\n */\nexport function readableStreamFromReader(\n  reader: Deno.Reader | (Deno.Reader & Deno.Closer),\n  options: ReadableStreamFromReaderOptions = {},\n): ReadableStream<Uint8Array> {\n  const {\n    autoClose = true,\n    chunkSize = DEFAULT_CHUNK_SIZE,\n    strategy,\n  } = options;\n\n  return new ReadableStream({\n    async pull(controller) {\n      const chunk = new Uint8Array(chunkSize);\n      try {\n        const read = await reader.read(chunk);\n        if (read === null) {\n          if (isCloser(reader) && autoClose) {\n            reader.close();\n          }\n          controller.close();\n          return;\n        }\n        controller.enqueue(chunk.subarray(0, read));\n      } catch (e) {\n        controller.error(e);\n        if (isCloser(reader)) {\n          reader.close();\n        }\n      }\n    },\n    cancel() {\n      if (isCloser(reader) && autoClose) {\n        reader.close();\n      }\n    },\n  }, strategy);\n}\n\n/** Read Reader `r` until EOF (`null`) and resolve to the content as\n * Uint8Array`.\n *\n * ```ts\n * import { Buffer } from \"../io/buffer.ts\";\n * import { readAll } from \"./conversion.ts\";\n *\n * // Example from stdin\n * const stdinContent = await readAll(Deno.stdin);\n *\n * // Example from file\n * const file = await Deno.open(\"my_file.txt\", {read: true});\n * const myFileContent = await readAll(file);\n * Deno.close(file.rid);\n *\n * // Example from buffer\n * const myData = new Uint8Array(100);\n * // ... fill myData array with data\n * const reader = new Buffer(myData.buffer);\n * const bufferContent = await readAll(reader);\n * ```\n */\nexport async function readAll(r: Deno.Reader): Promise<Uint8Array> {\n  const buf = new Buffer();\n  await buf.readFrom(r);\n  return buf.bytes();\n}\n\n/** Synchronously reads Reader `r` until EOF (`null`) and returns the content\n * as `Uint8Array`.\n *\n * ```ts\n * import { Buffer } from \"../io/buffer.ts\";\n * import { readAllSync } from \"./conversion.ts\";\n *\n * // Example from stdin\n * const stdinContent = readAllSync(Deno.stdin);\n *\n * // Example from file\n * const file = Deno.openSync(\"my_file.txt\", {read: true});\n * const myFileContent = readAllSync(file);\n * Deno.close(file.rid);\n *\n * // Example from buffer\n * const myData = new Uint8Array(100);\n * // ... fill myData array with data\n * const reader = new Buffer(myData.buffer);\n * const bufferContent = readAllSync(reader);\n * ```\n */\nexport function readAllSync(r: Deno.ReaderSync): Uint8Array {\n  const buf = new Buffer();\n  buf.readFromSync(r);\n  return buf.bytes();\n}\n\n/** Write all the content of the array buffer (`arr`) to the writer (`w`).\n *\n * ```ts\n * import { Buffer } from \"../io/buffer.ts\";\n * import { writeAll } from \"./conversion.ts\";\n\n * // Example writing to stdout\n * let contentBytes = new TextEncoder().encode(\"Hello World\");\n * await writeAll(Deno.stdout, contentBytes);\n *\n * // Example writing to file\n * contentBytes = new TextEncoder().encode(\"Hello World\");\n * const file = await Deno.open('test.file', {write: true});\n * await writeAll(file, contentBytes);\n * Deno.close(file.rid);\n *\n * // Example writing to buffer\n * contentBytes = new TextEncoder().encode(\"Hello World\");\n * const writer = new Buffer();\n * await writeAll(writer, contentBytes);\n * console.log(writer.bytes().length);  // 11\n * ```\n */\nexport async function writeAll(w: Deno.Writer, arr: Uint8Array) {\n  let nwritten = 0;\n  while (nwritten < arr.length) {\n    nwritten += await w.write(arr.subarray(nwritten));\n  }\n}\n\n/** Synchronously write all the content of the array buffer (`arr`) to the\n * writer (`w`).\n *\n * ```ts\n * import { Buffer } from \"../io/buffer.ts\";\n * import { writeAllSync } from \"./conversion.ts\";\n *\n * // Example writing to stdout\n * let contentBytes = new TextEncoder().encode(\"Hello World\");\n * writeAllSync(Deno.stdout, contentBytes);\n *\n * // Example writing to file\n * contentBytes = new TextEncoder().encode(\"Hello World\");\n * const file = Deno.openSync('test.file', {write: true});\n * writeAllSync(file, contentBytes);\n * Deno.close(file.rid);\n *\n * // Example writing to buffer\n * contentBytes = new TextEncoder().encode(\"Hello World\");\n * const writer = new Buffer();\n * writeAllSync(writer, contentBytes);\n * console.log(writer.bytes().length);  // 11\n * ```\n */\nexport function writeAllSync(w: Deno.WriterSync, arr: Uint8Array): void {\n  let nwritten = 0;\n  while (nwritten < arr.length) {\n    nwritten += w.writeSync(arr.subarray(nwritten));\n  }\n}\n\n/** Turns a Reader, `r`, into an async iterator.\n *\n * ```ts\n * import { iterateReader } from \"./conversion.ts\";\n *\n * let f = await Deno.open(\"/etc/passwd\");\n * for await (const chunk of iterateReader(f)) {\n *   console.log(chunk);\n * }\n * f.close();\n * ```\n *\n * Second argument can be used to tune size of a buffer.\n * Default size of the buffer is 32kB.\n *\n * ```ts\n * import { iterateReader } from \"./conversion.ts\";\n *\n * let f = await Deno.open(\"/etc/passwd\");\n * const it = iterateReader(f, {\n *   bufSize: 1024 * 1024\n * });\n * for await (const chunk of it) {\n *   console.log(chunk);\n * }\n * f.close();\n * ```\n *\n * Iterator uses an internal buffer of fixed size for efficiency; it returns\n * a view on that buffer on each iteration. It is therefore caller's\n * responsibility to copy contents of the buffer if needed; otherwise the\n * next iteration will overwrite contents of previously returned chunk.\n */\nexport async function* iterateReader(\n  r: Deno.Reader,\n  options?: {\n    bufSize?: number;\n  },\n): AsyncIterableIterator<Uint8Array> {\n  const bufSize = options?.bufSize ?? DEFAULT_BUFFER_SIZE;\n  const b = new Uint8Array(bufSize);\n  while (true) {\n    const result = await r.read(b);\n    if (result === null) {\n      break;\n    }\n\n    yield b.subarray(0, result);\n  }\n}\n\n/** Turns a ReaderSync, `r`, into an iterator.\n *\n * ```ts\n * import { iterateReaderSync } from \"./conversion.ts\";\n *\n * let f = Deno.openSync(\"/etc/passwd\");\n * for (const chunk of iterateReaderSync(f)) {\n *   console.log(chunk);\n * }\n * f.close();\n * ```\n *\n * Second argument can be used to tune size of a buffer.\n * Default size of the buffer is 32kB.\n *\n * ```ts\n * import { iterateReaderSync } from \"./conversion.ts\";\n\n * let f = await Deno.open(\"/etc/passwd\");\n * const iter = iterateReaderSync(f, {\n *   bufSize: 1024 * 1024\n * });\n * for (const chunk of iter) {\n *   console.log(chunk);\n * }\n * f.close();\n * ```\n *\n * Iterator uses an internal buffer of fixed size for efficiency; it returns\n * a view on that buffer on each iteration. It is therefore caller's\n * responsibility to copy contents of the buffer if needed; otherwise the\n * next iteration will overwrite contents of previously returned chunk.\n */\nexport function* iterateReaderSync(\n  r: Deno.ReaderSync,\n  options?: {\n    bufSize?: number;\n  },\n): IterableIterator<Uint8Array> {\n  const bufSize = options?.bufSize ?? DEFAULT_BUFFER_SIZE;\n  const b = new Uint8Array(bufSize);\n  while (true) {\n    const result = r.readSync(b);\n    if (result === null) {\n      break;\n    }\n\n    yield b.subarray(0, result);\n  }\n}\n\n/** Copies from `src` to `dst` until either EOF (`null`) is read from `src` or\n * an error occurs. It resolves to the number of bytes copied or rejects with\n * the first error encountered while copying.\n *\n * ```ts\n * import { copy } from \"./conversion.ts\";\n *\n * const source = await Deno.open(\"my_file.txt\");\n * const bytesCopied1 = await copy(source, Deno.stdout);\n * const destination = await Deno.create(\"my_file_2.txt\");\n * const bytesCopied2 = await copy(source, destination);\n * ```\n *\n * @param src The source to copy from\n * @param dst The destination to copy to\n * @param options Can be used to tune size of the buffer. Default size is 32kB\n */\nexport async function copy(\n  src: Deno.Reader,\n  dst: Deno.Writer,\n  options?: {\n    bufSize?: number;\n  },\n): Promise<number> {\n  let n = 0;\n  const bufSize = options?.bufSize ?? DEFAULT_BUFFER_SIZE;\n  const b = new Uint8Array(bufSize);\n  let gotEOF = false;\n  while (gotEOF === false) {\n    const result = await src.read(b);\n    if (result === null) {\n      gotEOF = true;\n    } else {\n      let nwritten = 0;\n      while (nwritten < result) {\n        nwritten += await dst.write(b.subarray(nwritten, result));\n      }\n      n += nwritten;\n    }\n  }\n  return n;\n}\n","// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.\nimport { fromFileUrl } from \"../../path/mod.ts\";\nimport { readableStreamFromReader } from \"../../streams/conversion.ts\";\n\nconst clients = new Map<number, WebSocket>();\nlet clientId = 0;\nfunction dispatch(msg: string): void {\n  for (const client of clients.values()) {\n    client.send(msg);\n  }\n}\n\nfunction wsHandler(ws: WebSocket) {\n  const id = ++clientId;\n  clients.set(id, ws);\n  ws.onopen = () => {\n    dispatch(`Connected: [${id}]`);\n  };\n  ws.onmessage = (e) => {\n    console.log(`msg:${id}`, e.data);\n    dispatch(`[${id}]: ${e.data}`);\n  };\n  ws.onclose = () => {\n    clients.delete(id);\n    dispatch(`Closed: [${id}]`);\n  };\n}\n\nasync function requestHandler(req: Deno.RequestEvent) {\n  const pathname = new URL(req.request.url).pathname;\n  if (req.request.method === \"GET\" && pathname === \"/\") {\n    //Serve with hack\n    const u = new URL(\"./index.html\", import.meta.url);\n    if (u.protocol.startsWith(\"http\")) {\n      // server launched by deno run http(s)://.../server.ts,\n      fetch(u.href).then(async (resp) => {\n        const body = new Uint8Array(await resp.arrayBuffer());\n        req.respondWith(\n          new Response(body, {\n            status: resp.status,\n            headers: {\n              \"content-type\": \"text/html\",\n            },\n          }),\n        );\n      });\n    } else {\n      // server launched by deno run ./server.ts\n      const file = await Deno.open(fromFileUrl(u));\n      req.respondWith(\n        new Response(readableStreamFromReader(file), {\n          status: 200,\n          headers: {\n            \"content-type\": \"text/html\",\n          },\n        }),\n      );\n    }\n  } else if (\n    req.request.method === \"GET\" && pathname === \"/favicon.ico\"\n  ) {\n    req.respondWith(Response.redirect(\"https://deno.land/favicon.ico\", 302));\n  } else if (req.request.method === \"GET\" && pathname === \"/ws\") {\n    const { socket, response } = Deno.upgradeWebSocket(req.request);\n    wsHandler(socket);\n    req.respondWith(response);\n  }\n}\n\nconst server = Deno.listen({ port: 8080 });\nconsole.log(\"chat server starting on :8080....\");\n\nfor await (const conn of server) {\n  (async () => {\n    const httpConn = Deno.serveHttp(conn);\n    for await (const requestEvent of httpConn) {\n      requestHandler(requestEvent);\n    }\n  })();\n}\n"],"names":[],"mappings":"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"} diff --git a/tests/__snapshots__/transpile/absolute/mapping.json b/tests/__snapshots__/transpile/absolute/mapping.json new file mode 100644 index 0000000..48d4dd4 --- /dev/null +++ b/tests/__snapshots__/transpile/absolute/mapping.json @@ -0,0 +1,3 @@ +{ + "file:///testdata/mod.ts": "0BJ1Cp_wwHSv6YnJzSlY2UlxpSc.js" +} diff --git a/tests/__snapshots__/transpile/absolute/modules/0BJ1Cp_wwHSv6YnJzSlY2UlxpSc.js b/tests/__snapshots__/transpile/absolute/modules/0BJ1Cp_wwHSv6YnJzSlY2UlxpSc.js new file mode 100644 index 0000000..e4c29b2 --- /dev/null +++ b/tests/__snapshots__/transpile/absolute/modules/0BJ1Cp_wwHSv6YnJzSlY2UlxpSc.js @@ -0,0 +1,4 @@ +export default function hello() { + return "Hello there!"; +} +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImZpbGU6Ly8vdGVzdGRhdGEvbW9kLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBkZWZhdWx0IGZ1bmN0aW9uIGhlbGxvKCk6IHN0cmluZyB7XG4gIHJldHVybiBcIkhlbGxvIHRoZXJlIVwiO1xufVxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGVBQWUsU0FBUyxRQUFnQjtJQUN0QyxPQUFPO0FBQ1QsQ0FBQyJ9 \ No newline at end of file diff --git a/tests/__snapshots__/transpile/relative/mapping.json b/tests/__snapshots__/transpile/relative/mapping.json new file mode 100644 index 0000000..48d4dd4 --- /dev/null +++ b/tests/__snapshots__/transpile/relative/mapping.json @@ -0,0 +1,3 @@ +{ + "file:///testdata/mod.ts": "0BJ1Cp_wwHSv6YnJzSlY2UlxpSc.js" +} diff --git a/tests/__snapshots__/transpile/relative/modules/0BJ1Cp_wwHSv6YnJzSlY2UlxpSc.js b/tests/__snapshots__/transpile/relative/modules/0BJ1Cp_wwHSv6YnJzSlY2UlxpSc.js new file mode 100644 index 0000000..e4c29b2 --- /dev/null +++ b/tests/__snapshots__/transpile/relative/modules/0BJ1Cp_wwHSv6YnJzSlY2UlxpSc.js @@ -0,0 +1,4 @@ +export default function hello() { + return "Hello there!"; +} +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImZpbGU6Ly8vdGVzdGRhdGEvbW9kLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBkZWZhdWx0IGZ1bmN0aW9uIGhlbGxvKCk6IHN0cmluZyB7XG4gIHJldHVybiBcIkhlbGxvIHRoZXJlIVwiO1xufVxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGVBQWUsU0FBUyxRQUFnQjtJQUN0QyxPQUFPO0FBQ1QsQ0FBQyJ9 \ No newline at end of file diff --git a/tests/__snapshots__/transpile/remote/mapping.json b/tests/__snapshots__/transpile/remote/mapping.json new file mode 100644 index 0000000..02f1832 --- /dev/null +++ b/tests/__snapshots__/transpile/remote/mapping.json @@ -0,0 +1,20 @@ +{ + "https://deno.land/std@0.140.0/_util/assert.ts": "nhMTTXGO1bgNtQ_bGZFJE0b7hWs.js", + "https://deno.land/std@0.140.0/_util/os.ts": "ebsv4XtKEF8sxrDsnkLX8K9VdOA.js", + "https://deno.land/std@0.140.0/bytes/bytes_list.ts": "p5wE1hCF6dGYMZ41YnIQs2go2is.js", + "https://deno.land/std@0.140.0/bytes/equals.ts": "jO4Cj24EIKVTiTvdPctAVhckzgg.js", + "https://deno.land/std@0.140.0/bytes/mod.ts": "WStdDhyHbKYy_C9CJ39RDks1VaY.js", + "https://deno.land/std@0.140.0/examples/chat/server.ts": "VR9N5EtRGYTL6BL2wtaFnqW-AuA.js", + "https://deno.land/std@0.140.0/io/buffer.ts": "npEsX-46oQUgZNw2Jkxv5i4eWDM.js", + "https://deno.land/std@0.140.0/io/types.d.ts": "7HctcYJMo9RPESb8_8SnGpYMx1U.js", + "https://deno.land/std@0.140.0/path/_constants.ts": "WzxVr2Q8XtUlLvHc6jsTVQR8Mnc.js", + "https://deno.land/std@0.140.0/path/_interface.ts": "wme9EIsCB7sfOz5qC_CSLRYajRk.js", + "https://deno.land/std@0.140.0/path/_util.ts": "7VWYTDioIHKQJaGRjtUtSbiHVG8.js", + "https://deno.land/std@0.140.0/path/common.ts": "WKh_-mE6UYta1pB11lfX_WOvFQ8.js", + "https://deno.land/std@0.140.0/path/glob.ts": "6asWNnLz5gIIvWCigeWDpbWva1Y.js", + "https://deno.land/std@0.140.0/path/mod.ts": "VUHr_YUyq8otV9YiIbexaSOfQCs.js", + "https://deno.land/std@0.140.0/path/posix.ts": "kWDlQkpYLFWxtJdAejga3vZCeeM.js", + "https://deno.land/std@0.140.0/path/separator.ts": "TPW77jtLW1NbcwGdiav4OHTJd6g.js", + "https://deno.land/std@0.140.0/path/win32.ts": "WPpXvFGuxwYeU5ay2bDrdG4fV_g.js", + "https://deno.land/std@0.140.0/streams/conversion.ts": "ZD3DgFZlCOXbEC8b6k6GmMtkN3g.js" +} diff --git a/tests/__snapshots__/transpile/remote/modules/6asWNnLz5gIIvWCigeWDpbWva1Y.js b/tests/__snapshots__/transpile/remote/modules/6asWNnLz5gIIvWCigeWDpbWva1Y.js new file mode 100644 index 0000000..bcb9c67 --- /dev/null +++ b/tests/__snapshots__/transpile/remote/modules/6asWNnLz5gIIvWCigeWDpbWva1Y.js @@ -0,0 +1,346 @@ +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. +import { isWindows, osType } from "../_util/os.ts"; +import { SEP, SEP_PATTERN } from "./separator.ts"; +import * as _win32 from "./win32.ts"; +import * as _posix from "./posix.ts"; +const path = isWindows ? _win32 : _posix; +const { join , normalize } = path; +const regExpEscapeChars = [ + "!", + "$", + "(", + ")", + "*", + "+", + ".", + "=", + "?", + "[", + "\\", + "^", + "{", + "|" +]; +const rangeEscapeChars = [ + "-", + "\\", + "]" +]; +/** Convert a glob string to a regular expression. + * + * Tries to match bash glob expansion as closely as possible. + * + * Basic glob syntax: + * - `*` - Matches everything without leaving the path segment. + * - `?` - Matches any single character. + * - `{foo,bar}` - Matches `foo` or `bar`. + * - `[abcd]` - Matches `a`, `b`, `c` or `d`. + * - `[a-d]` - Matches `a`, `b`, `c` or `d`. + * - `[!abcd]` - Matches any single character besides `a`, `b`, `c` or `d`. + * - `[[::]]` - Matches any character belonging to ``. + * - `[[:alnum:]]` - Matches any digit or letter. + * - `[[:digit:]abc]` - Matches any digit, `a`, `b` or `c`. + * - See https://facelessuser.github.io/wcmatch/glob/#posix-character-classes + * for a complete list of supported character classes. + * - `\` - Escapes the next character for an `os` other than `"windows"`. + * - \` - Escapes the next character for `os` set to `"windows"`. + * - `/` - Path separator. + * - `\` - Additional path separator only for `os` set to `"windows"`. + * + * Extended syntax: + * - Requires `{ extended: true }`. + * - `?(foo|bar)` - Matches 0 or 1 instance of `{foo,bar}`. + * - `@(foo|bar)` - Matches 1 instance of `{foo,bar}`. They behave the same. + * - `*(foo|bar)` - Matches _n_ instances of `{foo,bar}`. + * - `+(foo|bar)` - Matches _n > 0_ instances of `{foo,bar}`. + * - `!(foo|bar)` - Matches anything other than `{foo,bar}`. + * - See https://www.linuxjournal.com/content/bash-extended-globbing. + * + * Globstar syntax: + * - Requires `{ globstar: true }`. + * - `**` - Matches any number of any path segments. + * - Must comprise its entire path segment in the provided glob. + * - See https://www.linuxjournal.com/content/globstar-new-bash-globbing-option. + * + * Note the following properties: + * - The generated `RegExp` is anchored at both start and end. + * - Repeating and trailing separators are tolerated. Trailing separators in the + * provided glob have no meaning and are discarded. + * - Absolute globs will only match absolute paths, etc. + * - Empty globs will match nothing. + * - Any special glob syntax must be contained to one path segment. For example, + * `?(foo|bar/baz)` is invalid. The separator will take precedence and the + * first segment ends with an unclosed group. + * - If a path segment ends with unclosed groups or a dangling escape prefix, a + * parse error has occurred. Every character for that segment is taken + * literally in this event. + * + * Limitations: + * - A negative group like `!(foo|bar)` will wrongly be converted to a negative + * look-ahead followed by a wildcard. This means that `!(foo).js` will wrongly + * fail to match `foobar.js`, even though `foobar` is not `foo`. Effectively, + * `!(foo|bar)` is treated like `!(@(foo|bar)*)`. This will work correctly if + * the group occurs not nested at the end of the segment. */ export function globToRegExp(glob, { extended =true , globstar: globstarOption = true , os =osType , caseInsensitive =false } = {}) { + if (glob == "") { + return /(?!)/; + } + const sep = os == "windows" ? "(?:\\\\|/)+" : "/+"; + const sepMaybe = os == "windows" ? "(?:\\\\|/)*" : "/*"; + const seps = os == "windows" ? [ + "\\", + "/" + ] : [ + "/" + ]; + const globstar = os == "windows" ? "(?:[^\\\\/]*(?:\\\\|/|$)+)*" : "(?:[^/]*(?:/|$)+)*"; + const wildcard = os == "windows" ? "[^\\\\/]*" : "[^/]*"; + const escapePrefix = os == "windows" ? "`" : "\\"; + // Remove trailing separators. + let newLength = glob.length; + for(; newLength > 1 && seps.includes(glob[newLength - 1]); newLength--); + glob = glob.slice(0, newLength); + let regExpString = ""; + // Terminates correctly. Trust that `j` is incremented every iteration. + for(let j = 0; j < glob.length;){ + let segment = ""; + const groupStack = []; + let inRange = false; + let inEscape = false; + let endsWithSep = false; + let i = j; + // Terminates with `i` at the non-inclusive end of the current segment. + for(; i < glob.length && !seps.includes(glob[i]); i++){ + if (inEscape) { + inEscape = false; + const escapeChars = inRange ? rangeEscapeChars : regExpEscapeChars; + segment += escapeChars.includes(glob[i]) ? `\\${glob[i]}` : glob[i]; + continue; + } + if (glob[i] == escapePrefix) { + inEscape = true; + continue; + } + if (glob[i] == "[") { + if (!inRange) { + inRange = true; + segment += "["; + if (glob[i + 1] == "!") { + i++; + segment += "^"; + } else if (glob[i + 1] == "^") { + i++; + segment += "\\^"; + } + continue; + } else if (glob[i + 1] == ":") { + let k = i + 1; + let value = ""; + while(glob[k + 1] != null && glob[k + 1] != ":"){ + value += glob[k + 1]; + k++; + } + if (glob[k + 1] == ":" && glob[k + 2] == "]") { + i = k + 2; + if (value == "alnum") segment += "\\dA-Za-z"; + else if (value == "alpha") segment += "A-Za-z"; + else if (value == "ascii") segment += "\x00-\x7F"; + else if (value == "blank") segment += "\t "; + else if (value == "cntrl") segment += "\x00-\x1F\x7F"; + else if (value == "digit") segment += "\\d"; + else if (value == "graph") segment += "\x21-\x7E"; + else if (value == "lower") segment += "a-z"; + else if (value == "print") segment += "\x20-\x7E"; + else if (value == "punct") { + segment += "!\"#$%&'()*+,\\-./:;<=>?@[\\\\\\]^_‘{|}~"; + } else if (value == "space") segment += "\\s\v"; + else if (value == "upper") segment += "A-Z"; + else if (value == "word") segment += "\\w"; + else if (value == "xdigit") segment += "\\dA-Fa-f"; + continue; + } + } + } + if (glob[i] == "]" && inRange) { + inRange = false; + segment += "]"; + continue; + } + if (inRange) { + if (glob[i] == "\\") { + segment += `\\\\`; + } else { + segment += glob[i]; + } + continue; + } + if (glob[i] == ")" && groupStack.length > 0 && groupStack[groupStack.length - 1] != "BRACE") { + segment += ")"; + const type = groupStack.pop(); + if (type == "!") { + segment += wildcard; + } else if (type != "@") { + segment += type; + } + continue; + } + if (glob[i] == "|" && groupStack.length > 0 && groupStack[groupStack.length - 1] != "BRACE") { + segment += "|"; + continue; + } + if (glob[i] == "+" && extended && glob[i + 1] == "(") { + i++; + groupStack.push("+"); + segment += "(?:"; + continue; + } + if (glob[i] == "@" && extended && glob[i + 1] == "(") { + i++; + groupStack.push("@"); + segment += "(?:"; + continue; + } + if (glob[i] == "?") { + if (extended && glob[i + 1] == "(") { + i++; + groupStack.push("?"); + segment += "(?:"; + } else { + segment += "."; + } + continue; + } + if (glob[i] == "!" && extended && glob[i + 1] == "(") { + i++; + groupStack.push("!"); + segment += "(?!"; + continue; + } + if (glob[i] == "{") { + groupStack.push("BRACE"); + segment += "(?:"; + continue; + } + if (glob[i] == "}" && groupStack[groupStack.length - 1] == "BRACE") { + groupStack.pop(); + segment += ")"; + continue; + } + if (glob[i] == "," && groupStack[groupStack.length - 1] == "BRACE") { + segment += "|"; + continue; + } + if (glob[i] == "*") { + if (extended && glob[i + 1] == "(") { + i++; + groupStack.push("*"); + segment += "(?:"; + } else { + const prevChar = glob[i - 1]; + let numStars = 1; + while(glob[i + 1] == "*"){ + i++; + numStars++; + } + const nextChar = glob[i + 1]; + if (globstarOption && numStars == 2 && [ + ...seps, + undefined + ].includes(prevChar) && [ + ...seps, + undefined + ].includes(nextChar)) { + segment += globstar; + endsWithSep = true; + } else { + segment += wildcard; + } + } + continue; + } + segment += regExpEscapeChars.includes(glob[i]) ? `\\${glob[i]}` : glob[i]; + } + // Check for unclosed groups or a dangling backslash. + if (groupStack.length > 0 || inRange || inEscape) { + // Parse failure. Take all characters from this segment literally. + segment = ""; + for (const c of glob.slice(j, i)){ + segment += regExpEscapeChars.includes(c) ? `\\${c}` : c; + endsWithSep = false; + } + } + regExpString += segment; + if (!endsWithSep) { + regExpString += i < glob.length ? sep : sepMaybe; + endsWithSep = true; + } + // Terminates with `i` at the start of the next segment. + while(seps.includes(glob[i]))i++; + // Check that the next value of `j` is indeed higher than the current value. + if (!(i > j)) { + throw new Error("Assertion failure: i > j (potential infinite loop)"); + } + j = i; + } + regExpString = `^${regExpString}$`; + return new RegExp(regExpString, caseInsensitive ? "i" : ""); +} +/** Test whether the given string is a glob */ export function isGlob(str) { + const chars = { + "{": "}", + "(": ")", + "[": "]" + }; + const regex = /\\(.)|(^!|\*|\?|[\].+)]\?|\[[^\\\]]+\]|\{[^\\}]+\}|\(\?[:!=][^\\)]+\)|\([^|]+\|[^\\)]+\))/; + if (str === "") { + return false; + } + let match; + while(match = regex.exec(str)){ + if (match[2]) return true; + let idx = match.index + match[0].length; + // if an open bracket/brace/paren is escaped, + // set the index to the next closing character + const open = match[1]; + const close = open ? chars[open] : null; + if (open && close) { + const n = str.indexOf(close, idx); + if (n !== -1) { + idx = n + 1; + } + } + str = str.slice(idx); + } + return false; +} +/** Like normalize(), but doesn't collapse "**\/.." when `globstar` is true. */ export function normalizeGlob(glob, { globstar =false } = {}) { + if (glob.match(/\0/g)) { + throw new Error(`Glob contains invalid characters: "${glob}"`); + } + if (!globstar) { + return normalize(glob); + } + const s = SEP_PATTERN.source; + const badParentPattern = new RegExp(`(?<=(${s}|^)\\*\\*${s})\\.\\.(?=${s}|$)`, "g"); + return normalize(glob.replace(badParentPattern, "\0")).replace(/\0/g, ".."); +} +/** Like join(), but doesn't collapse "**\/.." when `globstar` is true. */ export function joinGlobs(globs, { extended =true , globstar =false } = {}) { + if (!globstar || globs.length == 0) { + return join(...globs); + } + if (globs.length === 0) return "."; + let joined; + for (const glob of globs){ + const path = glob; + if (path.length > 0) { + if (!joined) joined = path; + else joined += `${SEP}${path}`; + } + } + if (!joined) return "."; + return normalizeGlob(joined, { + extended, + globstar + }); +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["https://deno.land/std@0.140.0/path/glob.ts"],"sourcesContent":["// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.\n// This module is browser compatible.\n\nimport { isWindows, osType } from \"../_util/os.ts\";\nimport { SEP, SEP_PATTERN } from \"./separator.ts\";\nimport * as _win32 from \"./win32.ts\";\nimport * as _posix from \"./posix.ts\";\nimport type { OSType } from \"../_util/os.ts\";\n\nconst path = isWindows ? _win32 : _posix;\nconst { join, normalize } = path;\n\nexport interface GlobOptions {\n  /** Extended glob syntax.\n   * See https://www.linuxjournal.com/content/bash-extended-globbing. Defaults\n   * to true. */\n  extended?: boolean;\n  /** Globstar syntax.\n   * See https://www.linuxjournal.com/content/globstar-new-bash-globbing-option.\n   * If false, `**` is treated like `*`. Defaults to true. */\n  globstar?: boolean;\n  /** Whether globstar should be case insensitive. */\n  caseInsensitive?: boolean;\n  /** Operating system. Defaults to the native OS. */\n  os?: OSType;\n}\n\nexport type GlobToRegExpOptions = GlobOptions;\n\nconst regExpEscapeChars = [\n  \"!\",\n  \"$\",\n  \"(\",\n  \")\",\n  \"*\",\n  \"+\",\n  \".\",\n  \"=\",\n  \"?\",\n  \"[\",\n  \"\\\\\",\n  \"^\",\n  \"{\",\n  \"|\",\n];\nconst rangeEscapeChars = [\"-\", \"\\\\\", \"]\"];\n\n/** Convert a glob string to a regular expression.\n *\n * Tries to match bash glob expansion as closely as possible.\n *\n * Basic glob syntax:\n * - `*` - Matches everything without leaving the path segment.\n * - `?` - Matches any single character.\n * - `{foo,bar}` - Matches `foo` or `bar`.\n * - `[abcd]` - Matches `a`, `b`, `c` or `d`.\n * - `[a-d]` - Matches `a`, `b`, `c` or `d`.\n * - `[!abcd]` - Matches any single character besides `a`, `b`, `c` or `d`.\n * - `[[:<class>:]]` - Matches any character belonging to `<class>`.\n *     - `[[:alnum:]]` - Matches any digit or letter.\n *     - `[[:digit:]abc]` - Matches any digit, `a`, `b` or `c`.\n *     - See https://facelessuser.github.io/wcmatch/glob/#posix-character-classes\n *       for a complete list of supported character classes.\n * - `\\` - Escapes the next character for an `os` other than `\"windows\"`.\n * - \\` - Escapes the next character for `os` set to `\"windows\"`.\n * - `/` - Path separator.\n * - `\\` - Additional path separator only for `os` set to `\"windows\"`.\n *\n * Extended syntax:\n * - Requires `{ extended: true }`.\n * - `?(foo|bar)` - Matches 0 or 1 instance of `{foo,bar}`.\n * - `@(foo|bar)` - Matches 1 instance of `{foo,bar}`. They behave the same.\n * - `*(foo|bar)` - Matches _n_ instances of `{foo,bar}`.\n * - `+(foo|bar)` - Matches _n > 0_ instances of `{foo,bar}`.\n * - `!(foo|bar)` - Matches anything other than `{foo,bar}`.\n * - See https://www.linuxjournal.com/content/bash-extended-globbing.\n *\n * Globstar syntax:\n * - Requires `{ globstar: true }`.\n * - `**` - Matches any number of any path segments.\n *     - Must comprise its entire path segment in the provided glob.\n * - See https://www.linuxjournal.com/content/globstar-new-bash-globbing-option.\n *\n * Note the following properties:\n * - The generated `RegExp` is anchored at both start and end.\n * - Repeating and trailing separators are tolerated. Trailing separators in the\n *   provided glob have no meaning and are discarded.\n * - Absolute globs will only match absolute paths, etc.\n * - Empty globs will match nothing.\n * - Any special glob syntax must be contained to one path segment. For example,\n *   `?(foo|bar/baz)` is invalid. The separator will take precedence and the\n *   first segment ends with an unclosed group.\n * - If a path segment ends with unclosed groups or a dangling escape prefix, a\n *   parse error has occurred. Every character for that segment is taken\n *   literally in this event.\n *\n * Limitations:\n * - A negative group like `!(foo|bar)` will wrongly be converted to a negative\n *   look-ahead followed by a wildcard. This means that `!(foo).js` will wrongly\n *   fail to match `foobar.js`, even though `foobar` is not `foo`. Effectively,\n *   `!(foo|bar)` is treated like `!(@(foo|bar)*)`. This will work correctly if\n *   the group occurs not nested at the end of the segment. */\nexport function globToRegExp(\n  glob: string,\n  {\n    extended = true,\n    globstar: globstarOption = true,\n    os = osType,\n    caseInsensitive = false,\n  }: GlobToRegExpOptions = {},\n): RegExp {\n  if (glob == \"\") {\n    return /(?!)/;\n  }\n\n  const sep = os == \"windows\" ? \"(?:\\\\\\\\|/)+\" : \"/+\";\n  const sepMaybe = os == \"windows\" ? \"(?:\\\\\\\\|/)*\" : \"/*\";\n  const seps = os == \"windows\" ? [\"\\\\\", \"/\"] : [\"/\"];\n  const globstar = os == \"windows\"\n    ? \"(?:[^\\\\\\\\/]*(?:\\\\\\\\|/|$)+)*\"\n    : \"(?:[^/]*(?:/|$)+)*\";\n  const wildcard = os == \"windows\" ? \"[^\\\\\\\\/]*\" : \"[^/]*\";\n  const escapePrefix = os == \"windows\" ? \"`\" : \"\\\\\";\n\n  // Remove trailing separators.\n  let newLength = glob.length;\n  for (; newLength > 1 && seps.includes(glob[newLength - 1]); newLength--);\n  glob = glob.slice(0, newLength);\n\n  let regExpString = \"\";\n\n  // Terminates correctly. Trust that `j` is incremented every iteration.\n  for (let j = 0; j < glob.length;) {\n    let segment = \"\";\n    const groupStack: string[] = [];\n    let inRange = false;\n    let inEscape = false;\n    let endsWithSep = false;\n    let i = j;\n\n    // Terminates with `i` at the non-inclusive end of the current segment.\n    for (; i < glob.length && !seps.includes(glob[i]); i++) {\n      if (inEscape) {\n        inEscape = false;\n        const escapeChars = inRange ? rangeEscapeChars : regExpEscapeChars;\n        segment += escapeChars.includes(glob[i]) ? `\\\\${glob[i]}` : glob[i];\n        continue;\n      }\n\n      if (glob[i] == escapePrefix) {\n        inEscape = true;\n        continue;\n      }\n\n      if (glob[i] == \"[\") {\n        if (!inRange) {\n          inRange = true;\n          segment += \"[\";\n          if (glob[i + 1] == \"!\") {\n            i++;\n            segment += \"^\";\n          } else if (glob[i + 1] == \"^\") {\n            i++;\n            segment += \"\\\\^\";\n          }\n          continue;\n        } else if (glob[i + 1] == \":\") {\n          let k = i + 1;\n          let value = \"\";\n          while (glob[k + 1] != null && glob[k + 1] != \":\") {\n            value += glob[k + 1];\n            k++;\n          }\n          if (glob[k + 1] == \":\" && glob[k + 2] == \"]\") {\n            i = k + 2;\n            if (value == \"alnum\") segment += \"\\\\dA-Za-z\";\n            else if (value == \"alpha\") segment += \"A-Za-z\";\n            else if (value == \"ascii\") segment += \"\\x00-\\x7F\";\n            else if (value == \"blank\") segment += \"\\t \";\n            else if (value == \"cntrl\") segment += \"\\x00-\\x1F\\x7F\";\n            else if (value == \"digit\") segment += \"\\\\d\";\n            else if (value == \"graph\") segment += \"\\x21-\\x7E\";\n            else if (value == \"lower\") segment += \"a-z\";\n            else if (value == \"print\") segment += \"\\x20-\\x7E\";\n            else if (value == \"punct\") {\n              segment += \"!\\\"#$%&'()*+,\\\\-./:;<=>?@[\\\\\\\\\\\\]^_‘{|}~\";\n            } else if (value == \"space\") segment += \"\\\\s\\v\";\n            else if (value == \"upper\") segment += \"A-Z\";\n            else if (value == \"word\") segment += \"\\\\w\";\n            else if (value == \"xdigit\") segment += \"\\\\dA-Fa-f\";\n            continue;\n          }\n        }\n      }\n\n      if (glob[i] == \"]\" && inRange) {\n        inRange = false;\n        segment += \"]\";\n        continue;\n      }\n\n      if (inRange) {\n        if (glob[i] == \"\\\\\") {\n          segment += `\\\\\\\\`;\n        } else {\n          segment += glob[i];\n        }\n        continue;\n      }\n\n      if (\n        glob[i] == \")\" && groupStack.length > 0 &&\n        groupStack[groupStack.length - 1] != \"BRACE\"\n      ) {\n        segment += \")\";\n        const type = groupStack.pop()!;\n        if (type == \"!\") {\n          segment += wildcard;\n        } else if (type != \"@\") {\n          segment += type;\n        }\n        continue;\n      }\n\n      if (\n        glob[i] == \"|\" && groupStack.length > 0 &&\n        groupStack[groupStack.length - 1] != \"BRACE\"\n      ) {\n        segment += \"|\";\n        continue;\n      }\n\n      if (glob[i] == \"+\" && extended && glob[i + 1] == \"(\") {\n        i++;\n        groupStack.push(\"+\");\n        segment += \"(?:\";\n        continue;\n      }\n\n      if (glob[i] == \"@\" && extended && glob[i + 1] == \"(\") {\n        i++;\n        groupStack.push(\"@\");\n        segment += \"(?:\";\n        continue;\n      }\n\n      if (glob[i] == \"?\") {\n        if (extended && glob[i + 1] == \"(\") {\n          i++;\n          groupStack.push(\"?\");\n          segment += \"(?:\";\n        } else {\n          segment += \".\";\n        }\n        continue;\n      }\n\n      if (glob[i] == \"!\" && extended && glob[i + 1] == \"(\") {\n        i++;\n        groupStack.push(\"!\");\n        segment += \"(?!\";\n        continue;\n      }\n\n      if (glob[i] == \"{\") {\n        groupStack.push(\"BRACE\");\n        segment += \"(?:\";\n        continue;\n      }\n\n      if (glob[i] == \"}\" && groupStack[groupStack.length - 1] == \"BRACE\") {\n        groupStack.pop();\n        segment += \")\";\n        continue;\n      }\n\n      if (glob[i] == \",\" && groupStack[groupStack.length - 1] == \"BRACE\") {\n        segment += \"|\";\n        continue;\n      }\n\n      if (glob[i] == \"*\") {\n        if (extended && glob[i + 1] == \"(\") {\n          i++;\n          groupStack.push(\"*\");\n          segment += \"(?:\";\n        } else {\n          const prevChar = glob[i - 1];\n          let numStars = 1;\n          while (glob[i + 1] == \"*\") {\n            i++;\n            numStars++;\n          }\n          const nextChar = glob[i + 1];\n          if (\n            globstarOption && numStars == 2 &&\n            [...seps, undefined].includes(prevChar) &&\n            [...seps, undefined].includes(nextChar)\n          ) {\n            segment += globstar;\n            endsWithSep = true;\n          } else {\n            segment += wildcard;\n          }\n        }\n        continue;\n      }\n\n      segment += regExpEscapeChars.includes(glob[i]) ? `\\\\${glob[i]}` : glob[i];\n    }\n\n    // Check for unclosed groups or a dangling backslash.\n    if (groupStack.length > 0 || inRange || inEscape) {\n      // Parse failure. Take all characters from this segment literally.\n      segment = \"\";\n      for (const c of glob.slice(j, i)) {\n        segment += regExpEscapeChars.includes(c) ? `\\\\${c}` : c;\n        endsWithSep = false;\n      }\n    }\n\n    regExpString += segment;\n    if (!endsWithSep) {\n      regExpString += i < glob.length ? sep : sepMaybe;\n      endsWithSep = true;\n    }\n\n    // Terminates with `i` at the start of the next segment.\n    while (seps.includes(glob[i])) i++;\n\n    // Check that the next value of `j` is indeed higher than the current value.\n    if (!(i > j)) {\n      throw new Error(\"Assertion failure: i > j (potential infinite loop)\");\n    }\n    j = i;\n  }\n\n  regExpString = `^${regExpString}$`;\n  return new RegExp(regExpString, caseInsensitive ? \"i\" : \"\");\n}\n\n/** Test whether the given string is a glob */\nexport function isGlob(str: string): boolean {\n  const chars: Record<string, string> = { \"{\": \"}\", \"(\": \")\", \"[\": \"]\" };\n  const regex =\n    /\\\\(.)|(^!|\\*|\\?|[\\].+)]\\?|\\[[^\\\\\\]]+\\]|\\{[^\\\\}]+\\}|\\(\\?[:!=][^\\\\)]+\\)|\\([^|]+\\|[^\\\\)]+\\))/;\n\n  if (str === \"\") {\n    return false;\n  }\n\n  let match: RegExpExecArray | null;\n\n  while ((match = regex.exec(str))) {\n    if (match[2]) return true;\n    let idx = match.index + match[0].length;\n\n    // if an open bracket/brace/paren is escaped,\n    // set the index to the next closing character\n    const open = match[1];\n    const close = open ? chars[open] : null;\n    if (open && close) {\n      const n = str.indexOf(close, idx);\n      if (n !== -1) {\n        idx = n + 1;\n      }\n    }\n\n    str = str.slice(idx);\n  }\n\n  return false;\n}\n\n/** Like normalize(), but doesn't collapse \"**\\/..\" when `globstar` is true. */\nexport function normalizeGlob(\n  glob: string,\n  { globstar = false }: GlobOptions = {},\n): string {\n  if (glob.match(/\\0/g)) {\n    throw new Error(`Glob contains invalid characters: \"${glob}\"`);\n  }\n  if (!globstar) {\n    return normalize(glob);\n  }\n  const s = SEP_PATTERN.source;\n  const badParentPattern = new RegExp(\n    `(?<=(${s}|^)\\\\*\\\\*${s})\\\\.\\\\.(?=${s}|$)`,\n    \"g\",\n  );\n  return normalize(glob.replace(badParentPattern, \"\\0\")).replace(/\\0/g, \"..\");\n}\n\n/** Like join(), but doesn't collapse \"**\\/..\" when `globstar` is true. */\nexport function joinGlobs(\n  globs: string[],\n  { extended = true, globstar = false }: GlobOptions = {},\n): string {\n  if (!globstar || globs.length == 0) {\n    return join(...globs);\n  }\n  if (globs.length === 0) return \".\";\n  let joined: string | undefined;\n  for (const glob of globs) {\n    const path = glob;\n    if (path.length > 0) {\n      if (!joined) joined = path;\n      else joined += `${SEP}${path}`;\n    }\n  }\n  if (!joined) return \".\";\n  return normalizeGlob(joined, { extended, globstar });\n}\n"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/tests/__snapshots__/transpile/remote/modules/7HctcYJMo9RPESb8_8SnGpYMx1U.js b/tests/__snapshots__/transpile/remote/modules/7HctcYJMo9RPESb8_8SnGpYMx1U.js new file mode 100644 index 0000000..b7663e5 --- /dev/null +++ b/tests/__snapshots__/transpile/remote/modules/7HctcYJMo9RPESb8_8SnGpYMx1U.js @@ -0,0 +1,2 @@ +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImh0dHBzOi8vZGVuby5sYW5kL3N0ZEAwLjE0MC4wL2lvL3R5cGVzLmQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLy8gQ29weXJpZ2h0IDIwMTgtMjAyMiB0aGUgRGVubyBhdXRob3JzLiBBbGwgcmlnaHRzIHJlc2VydmVkLiBNSVQgbGljZW5zZS5cblxuZXhwb3J0IGludGVyZmFjZSBSZWFkZXIge1xuICAvKiogUmVhZHMgdXAgdG8gYHAuYnl0ZUxlbmd0aGAgYnl0ZXMgaW50byBgcGAuIEl0IHJlc29sdmVzIHRvIHRoZSBudW1iZXIgb2ZcbiAgICogYnl0ZXMgcmVhZCAoYDBgIDwgYG5gIDw9IGBwLmJ5dGVMZW5ndGhgKSBhbmQgcmVqZWN0cyBpZiBhbnkgZXJyb3JcbiAgICogZW5jb3VudGVyZWQuIEV2ZW4gaWYgYHJlYWQoKWAgcmVzb2x2ZXMgdG8gYG5gIDwgYHAuYnl0ZUxlbmd0aGAsIGl0IG1heVxuICAgKiB1c2UgYWxsIG9mIGBwYCBhcyBzY3JhdGNoIHNwYWNlIGR1cmluZyB0aGUgY2FsbC4gSWYgc29tZSBkYXRhIGlzXG4gICAqIGF2YWlsYWJsZSBidXQgbm90IGBwLmJ5dGVMZW5ndGhgIGJ5dGVzLCBgcmVhZCgpYCBjb252ZW50aW9uYWxseSByZXNvbHZlc1xuICAgKiB0byB3aGF0IGlzIGF2YWlsYWJsZSBpbnN0ZWFkIG9mIHdhaXRpbmcgZm9yIG1vcmUuXG4gICAqXG4gICAqIFdoZW4gYHJlYWQoKWAgZW5jb3VudGVycyBlbmQtb2YtZmlsZSBjb25kaXRpb24sIGl0IHJlc29sdmVzIHRvIEVPRlxuICAgKiAoYG51bGxgKS5cbiAgICpcbiAgICogV2hlbiBgcmVhZCgpYCBlbmNvdW50ZXJzIGFuIGVycm9yLCBpdCByZWplY3RzIHdpdGggYW4gZXJyb3IuXG4gICAqXG4gICAqIENhbGxlcnMgc2hvdWxkIGFsd2F5cyBwcm9jZXNzIHRoZSBgbmAgPiBgMGAgYnl0ZXMgcmV0dXJuZWQgYmVmb3JlXG4gICAqIGNvbnNpZGVyaW5nIHRoZSBFT0YgKGBudWxsYCkuIERvaW5nIHNvIGNvcnJlY3RseSBoYW5kbGVzIEkvTyBlcnJvcnMgdGhhdFxuICAgKiBoYXBwZW4gYWZ0ZXIgcmVhZGluZyBzb21lIGJ5dGVzIGFuZCBhbHNvIGJvdGggb2YgdGhlIGFsbG93ZWQgRU9GXG4gICAqIGJlaGF2aW9ycy5cbiAgICpcbiAgICogSW1wbGVtZW50YXRpb25zIHNob3VsZCBub3QgcmV0YWluIGEgcmVmZXJlbmNlIHRvIGBwYC5cbiAgICpcbiAgICogVXNlIGl0ZXIoKSBmcm9tIGh0dHBzOi8vZGVuby5sYW5kL3N0ZC9pby91dGlsLnRzIHRvIHR1cm4gYSBSZWFkZXIgaW50byBhblxuICAgKiBBc3luY0l0ZXJhdG9yLlxuICAgKi9cbiAgcmVhZChwOiBVaW50OEFycmF5KTogUHJvbWlzZTxudW1iZXIgfCBudWxsPjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBSZWFkZXJTeW5jIHtcbiAgLyoqIFJlYWRzIHVwIHRvIGBwLmJ5dGVMZW5ndGhgIGJ5dGVzIGludG8gYHBgLiBJdCByZXNvbHZlcyB0byB0aGUgbnVtYmVyXG4gICAqIG9mIGJ5dGVzIHJlYWQgKGAwYCA8IGBuYCA8PSBgcC5ieXRlTGVuZ3RoYCkgYW5kIHJlamVjdHMgaWYgYW55IGVycm9yXG4gICAqIGVuY291bnRlcmVkLiBFdmVuIGlmIGByZWFkKClgIHJldHVybnMgYG5gIDwgYHAuYnl0ZUxlbmd0aGAsIGl0IG1heSB1c2VcbiAgICogYWxsIG9mIGBwYCBhcyBzY3JhdGNoIHNwYWNlIGR1cmluZyB0aGUgY2FsbC4gSWYgc29tZSBkYXRhIGlzIGF2YWlsYWJsZVxuICAgKiBidXQgbm90IGBwLmJ5dGVMZW5ndGhgIGJ5dGVzLCBgcmVhZCgpYCBjb252ZW50aW9uYWxseSByZXR1cm5zIHdoYXQgaXNcbiAgICogYXZhaWxhYmxlIGluc3RlYWQgb2Ygd2FpdGluZyBmb3IgbW9yZS5cbiAgICpcbiAgICogV2hlbiBgcmVhZFN5bmMoKWAgZW5jb3VudGVycyBlbmQtb2YtZmlsZSBjb25kaXRpb24sIGl0IHJldHVybnMgRU9GXG4gICAqIChgbnVsbGApLlxuICAgKlxuICAgKiBXaGVuIGByZWFkU3luYygpYCBlbmNvdW50ZXJzIGFuIGVycm9yLCBpdCB0aHJvd3Mgd2l0aCBhbiBlcnJvci5cbiAgICpcbiAgICogQ2FsbGVycyBzaG91bGQgYWx3YXlzIHByb2Nlc3MgdGhlIGBuYCA+IGAwYCBieXRlcyByZXR1cm5lZCBiZWZvcmVcbiAgICogY29uc2lkZXJpbmcgdGhlIEVPRiAoYG51bGxgKS4gRG9pbmcgc28gY29ycmVjdGx5IGhhbmRsZXMgSS9PIGVycm9ycyB0aGF0IGhhcHBlblxuICAgKiBhZnRlciByZWFkaW5nIHNvbWUgYnl0ZXMgYW5kIGFsc28gYm90aCBvZiB0aGUgYWxsb3dlZCBFT0YgYmVoYXZpb3JzLlxuICAgKlxuICAgKiBJbXBsZW1lbnRhdGlvbnMgc2hvdWxkIG5vdCByZXRhaW4gYSByZWZlcmVuY2UgdG8gYHBgLlxuICAgKlxuICAgKiBVc2UgaXRlclN5bmMoKSBmcm9tIGh0dHBzOi8vZGVuby5sYW5kL3N0ZC9pby91dGlsLnRzIHRvIHR1cm4gYSBSZWFkZXJTeW5jXG4gICAqIGludG8gYW4gSXRlcmF0b3IuXG4gICAqL1xuICByZWFkU3luYyhwOiBVaW50OEFycmF5KTogbnVtYmVyIHwgbnVsbDtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBXcml0ZXIge1xuICAvKiogV3JpdGVzIGBwLmJ5dGVMZW5ndGhgIGJ5dGVzIGZyb20gYHBgIHRvIHRoZSB1bmRlcmx5aW5nIGRhdGEgc3RyZWFtLiBJdFxuICAgKiByZXNvbHZlcyB0byB0aGUgbnVtYmVyIG9mIGJ5dGVzIHdyaXR0ZW4gZnJvbSBgcGAgKGAwYCA8PSBgbmAgPD1cbiAgICogYHAuYnl0ZUxlbmd0aGApIG9yIHJlamVjdCB3aXRoIHRoZSBlcnJvciBlbmNvdW50ZXJlZCB0aGF0IGNhdXNlZCB0aGVcbiAgICogd3JpdGUgdG8gc3RvcCBlYXJseS4gYHdyaXRlKClgIG11c3QgcmVqZWN0IHdpdGggYSBub24tbnVsbCBlcnJvciBpZlxuICAgKiB3b3VsZCByZXNvbHZlIHRvIGBuYCA8IGBwLmJ5dGVMZW5ndGhgLiBgd3JpdGUoKWAgbXVzdCBub3QgbW9kaWZ5IHRoZVxuICAgKiBzbGljZSBkYXRhLCBldmVuIHRlbXBvcmFyaWx5LlxuICAgKlxuICAgKiBJbXBsZW1lbnRhdGlvbnMgc2hvdWxkIG5vdCByZXRhaW4gYSByZWZlcmVuY2UgdG8gYHBgLlxuICAgKi9cbiAgd3JpdGUocDogVWludDhBcnJheSk6IFByb21pc2U8bnVtYmVyPjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBXcml0ZXJTeW5jIHtcbiAgLyoqIFdyaXRlcyBgcC5ieXRlTGVuZ3RoYCBieXRlcyBmcm9tIGBwYCB0byB0aGUgdW5kZXJseWluZyBkYXRhXG4gICAqIHN0cmVhbS4gSXQgcmV0dXJucyB0aGUgbnVtYmVyIG9mIGJ5dGVzIHdyaXR0ZW4gZnJvbSBgcGAgKGAwYCA8PSBgbmBcbiAgICogPD0gYHAuYnl0ZUxlbmd0aGApIGFuZCBhbnkgZXJyb3IgZW5jb3VudGVyZWQgdGhhdCBjYXVzZWQgdGhlIHdyaXRlIHRvXG4gICAqIHN0b3AgZWFybHkuIGB3cml0ZVN5bmMoKWAgbXVzdCB0aHJvdyBhIG5vbi1udWxsIGVycm9yIGlmIGl0IHJldHVybnMgYG5gIDxcbiAgICogYHAuYnl0ZUxlbmd0aGAuIGB3cml0ZVN5bmMoKWAgbXVzdCBub3QgbW9kaWZ5IHRoZSBzbGljZSBkYXRhLCBldmVuXG4gICAqIHRlbXBvcmFyaWx5LlxuICAgKlxuICAgKiBJbXBsZW1lbnRhdGlvbnMgc2hvdWxkIG5vdCByZXRhaW4gYSByZWZlcmVuY2UgdG8gYHBgLlxuICAgKi9cbiAgd3JpdGVTeW5jKHA6IFVpbnQ4QXJyYXkpOiBudW1iZXI7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgQ2xvc2VyIHtcbiAgY2xvc2UoKTogdm9pZDtcbn1cbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwwRUFBMEUifQ== \ No newline at end of file diff --git a/tests/__snapshots__/transpile/remote/modules/7VWYTDioIHKQJaGRjtUtSbiHVG8.js b/tests/__snapshots__/transpile/remote/modules/7VWYTDioIHKQJaGRjtUtSbiHVG8.js new file mode 100644 index 0000000..18b20d4 --- /dev/null +++ b/tests/__snapshots__/transpile/remote/modules/7VWYTDioIHKQJaGRjtUtSbiHVG8.js @@ -0,0 +1,96 @@ +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +// Copyright the Browserify authors. MIT License. +// Ported from https://github.com/browserify/path-browserify/ +// This module is browser compatible. +import { CHAR_BACKWARD_SLASH, CHAR_DOT, CHAR_FORWARD_SLASH, CHAR_LOWERCASE_A, CHAR_LOWERCASE_Z, CHAR_UPPERCASE_A, CHAR_UPPERCASE_Z } from "./_constants.ts"; +export function assertPath(path) { + if (typeof path !== "string") { + throw new TypeError(`Path must be a string. Received ${JSON.stringify(path)}`); + } +} +export function isPosixPathSeparator(code) { + return code === CHAR_FORWARD_SLASH; +} +export function isPathSeparator(code) { + return isPosixPathSeparator(code) || code === CHAR_BACKWARD_SLASH; +} +export function isWindowsDeviceRoot(code) { + return code >= CHAR_LOWERCASE_A && code <= CHAR_LOWERCASE_Z || code >= CHAR_UPPERCASE_A && code <= CHAR_UPPERCASE_Z; +} +// Resolves . and .. elements in a path with directory names +export function normalizeString(path, allowAboveRoot, separator, isPathSeparator) { + let res = ""; + let lastSegmentLength = 0; + let lastSlash = -1; + let dots = 0; + let code; + for(let i = 0, len = path.length; i <= len; ++i){ + if (i < len) code = path.charCodeAt(i); + else if (isPathSeparator(code)) break; + else code = CHAR_FORWARD_SLASH; + if (isPathSeparator(code)) { + if (lastSlash === i - 1 || dots === 1) { + // NOOP + } else if (lastSlash !== i - 1 && dots === 2) { + if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== CHAR_DOT || res.charCodeAt(res.length - 2) !== CHAR_DOT) { + if (res.length > 2) { + const lastSlashIndex = res.lastIndexOf(separator); + if (lastSlashIndex === -1) { + res = ""; + lastSegmentLength = 0; + } else { + res = res.slice(0, lastSlashIndex); + lastSegmentLength = res.length - 1 - res.lastIndexOf(separator); + } + lastSlash = i; + dots = 0; + continue; + } else if (res.length === 2 || res.length === 1) { + res = ""; + lastSegmentLength = 0; + lastSlash = i; + dots = 0; + continue; + } + } + if (allowAboveRoot) { + if (res.length > 0) res += `${separator}..`; + else res = ".."; + lastSegmentLength = 2; + } + } else { + if (res.length > 0) res += separator + path.slice(lastSlash + 1, i); + else res = path.slice(lastSlash + 1, i); + lastSegmentLength = i - lastSlash - 1; + } + lastSlash = i; + dots = 0; + } else if (code === CHAR_DOT && dots !== -1) { + ++dots; + } else { + dots = -1; + } + } + return res; +} +export function _format(sep, pathObject) { + const dir = pathObject.dir || pathObject.root; + const base = pathObject.base || (pathObject.name || "") + (pathObject.ext || ""); + if (!dir) return base; + if (dir === pathObject.root) return dir + base; + return dir + sep + base; +} +const WHITESPACE_ENCODINGS = { + "\u0009": "%09", + "\u000A": "%0A", + "\u000B": "%0B", + "\u000C": "%0C", + "\u000D": "%0D", + "\u0020": "%20" +}; +export function encodeWhitespace(string) { + return string.replaceAll(/[\s]/g, (c)=>{ + return WHITESPACE_ENCODINGS[c] ?? c; + }); +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["https://deno.land/std@0.140.0/path/_util.ts"],"sourcesContent":["// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.\n// Copyright the Browserify authors. MIT License.\n// Ported from https://github.com/browserify/path-browserify/\n// This module is browser compatible.\n\nimport type { FormatInputPathObject } from \"./_interface.ts\";\nimport {\n  CHAR_BACKWARD_SLASH,\n  CHAR_DOT,\n  CHAR_FORWARD_SLASH,\n  CHAR_LOWERCASE_A,\n  CHAR_LOWERCASE_Z,\n  CHAR_UPPERCASE_A,\n  CHAR_UPPERCASE_Z,\n} from \"./_constants.ts\";\n\nexport function assertPath(path: string): void {\n  if (typeof path !== \"string\") {\n    throw new TypeError(\n      `Path must be a string. Received ${JSON.stringify(path)}`,\n    );\n  }\n}\n\nexport function isPosixPathSeparator(code: number): boolean {\n  return code === CHAR_FORWARD_SLASH;\n}\n\nexport function isPathSeparator(code: number): boolean {\n  return isPosixPathSeparator(code) || code === CHAR_BACKWARD_SLASH;\n}\n\nexport function isWindowsDeviceRoot(code: number): boolean {\n  return (\n    (code >= CHAR_LOWERCASE_A && code <= CHAR_LOWERCASE_Z) ||\n    (code >= CHAR_UPPERCASE_A && code <= CHAR_UPPERCASE_Z)\n  );\n}\n\n// Resolves . and .. elements in a path with directory names\nexport function normalizeString(\n  path: string,\n  allowAboveRoot: boolean,\n  separator: string,\n  isPathSeparator: (code: number) => boolean,\n): string {\n  let res = \"\";\n  let lastSegmentLength = 0;\n  let lastSlash = -1;\n  let dots = 0;\n  let code: number | undefined;\n  for (let i = 0, len = path.length; i <= len; ++i) {\n    if (i < len) code = path.charCodeAt(i);\n    else if (isPathSeparator(code!)) break;\n    else code = CHAR_FORWARD_SLASH;\n\n    if (isPathSeparator(code!)) {\n      if (lastSlash === i - 1 || dots === 1) {\n        // NOOP\n      } else if (lastSlash !== i - 1 && dots === 2) {\n        if (\n          res.length < 2 ||\n          lastSegmentLength !== 2 ||\n          res.charCodeAt(res.length - 1) !== CHAR_DOT ||\n          res.charCodeAt(res.length - 2) !== CHAR_DOT\n        ) {\n          if (res.length > 2) {\n            const lastSlashIndex = res.lastIndexOf(separator);\n            if (lastSlashIndex === -1) {\n              res = \"\";\n              lastSegmentLength = 0;\n            } else {\n              res = res.slice(0, lastSlashIndex);\n              lastSegmentLength = res.length - 1 - res.lastIndexOf(separator);\n            }\n            lastSlash = i;\n            dots = 0;\n            continue;\n          } else if (res.length === 2 || res.length === 1) {\n            res = \"\";\n            lastSegmentLength = 0;\n            lastSlash = i;\n            dots = 0;\n            continue;\n          }\n        }\n        if (allowAboveRoot) {\n          if (res.length > 0) res += `${separator}..`;\n          else res = \"..\";\n          lastSegmentLength = 2;\n        }\n      } else {\n        if (res.length > 0) res += separator + path.slice(lastSlash + 1, i);\n        else res = path.slice(lastSlash + 1, i);\n        lastSegmentLength = i - lastSlash - 1;\n      }\n      lastSlash = i;\n      dots = 0;\n    } else if (code === CHAR_DOT && dots !== -1) {\n      ++dots;\n    } else {\n      dots = -1;\n    }\n  }\n  return res;\n}\n\nexport function _format(\n  sep: string,\n  pathObject: FormatInputPathObject,\n): string {\n  const dir: string | undefined = pathObject.dir || pathObject.root;\n  const base: string = pathObject.base ||\n    (pathObject.name || \"\") + (pathObject.ext || \"\");\n  if (!dir) return base;\n  if (dir === pathObject.root) return dir + base;\n  return dir + sep + base;\n}\n\nconst WHITESPACE_ENCODINGS: Record<string, string> = {\n  \"\\u0009\": \"%09\",\n  \"\\u000A\": \"%0A\",\n  \"\\u000B\": \"%0B\",\n  \"\\u000C\": \"%0C\",\n  \"\\u000D\": \"%0D\",\n  \"\\u0020\": \"%20\",\n};\n\nexport function encodeWhitespace(string: string): string {\n  return string.replaceAll(/[\\s]/g, (c) => {\n    return WHITESPACE_ENCODINGS[c] ?? c;\n  });\n}\n"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/tests/__snapshots__/transpile/remote/modules/TPW77jtLW1NbcwGdiav4OHTJd6g.js b/tests/__snapshots__/transpile/remote/modules/TPW77jtLW1NbcwGdiav4OHTJd6g.js new file mode 100644 index 0000000..f7ecf64 --- /dev/null +++ b/tests/__snapshots__/transpile/remote/modules/TPW77jtLW1NbcwGdiav4OHTJd6g.js @@ -0,0 +1,6 @@ +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. +import { isWindows } from "../_util/os.ts"; +export const SEP = isWindows ? "\\" : "/"; +export const SEP_PATTERN = isWindows ? /[\\/]+/ : /\/+/; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImh0dHBzOi8vZGVuby5sYW5kL3N0ZEAwLjE0MC4wL3BhdGgvc2VwYXJhdG9yLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAyMDE4LTIwMjIgdGhlIERlbm8gYXV0aG9ycy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gTUlUIGxpY2Vuc2UuXG4vLyBUaGlzIG1vZHVsZSBpcyBicm93c2VyIGNvbXBhdGlibGUuXG5cbmltcG9ydCB7IGlzV2luZG93cyB9IGZyb20gXCIuLi9fdXRpbC9vcy50c1wiO1xuXG5leHBvcnQgY29uc3QgU0VQID0gaXNXaW5kb3dzID8gXCJcXFxcXCIgOiBcIi9cIjtcbmV4cG9ydCBjb25zdCBTRVBfUEFUVEVSTiA9IGlzV2luZG93cyA/IC9bXFxcXC9dKy8gOiAvXFwvKy87XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsMEVBQTBFO0FBQzFFLHFDQUFxQztBQUVyQyxTQUFTLFNBQVMsUUFBUSxpQkFBaUI7QUFFM0MsT0FBTyxNQUFNLE1BQU0sWUFBWSxPQUFPLEdBQUcsQ0FBQztBQUMxQyxPQUFPLE1BQU0sY0FBYyxZQUFZLFdBQVcsS0FBSyxDQUFDIn0= \ No newline at end of file diff --git a/tests/__snapshots__/transpile/remote/modules/VR9N5EtRGYTL6BL2wtaFnqW-AuA.js b/tests/__snapshots__/transpile/remote/modules/VR9N5EtRGYTL6BL2wtaFnqW-AuA.js new file mode 100644 index 0000000..ef1880e --- /dev/null +++ b/tests/__snapshots__/transpile/remote/modules/VR9N5EtRGYTL6BL2wtaFnqW-AuA.js @@ -0,0 +1,72 @@ +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +import { fromFileUrl } from "../../path/mod.ts"; +import { readableStreamFromReader } from "../../streams/conversion.ts"; +const clients = new Map(); +let clientId = 0; +function dispatch(msg) { + for (const client of clients.values()){ + client.send(msg); + } +} +function wsHandler(ws) { + const id = ++clientId; + clients.set(id, ws); + ws.onopen = ()=>{ + dispatch(`Connected: [${id}]`); + }; + ws.onmessage = (e)=>{ + console.log(`msg:${id}`, e.data); + dispatch(`[${id}]: ${e.data}`); + }; + ws.onclose = ()=>{ + clients.delete(id); + dispatch(`Closed: [${id}]`); + }; +} +async function requestHandler(req) { + const pathname = new URL(req.request.url).pathname; + if (req.request.method === "GET" && pathname === "/") { + //Serve with hack + const u = new URL("./index.html", import.meta.url); + if (u.protocol.startsWith("http")) { + // server launched by deno run http(s)://.../server.ts, + fetch(u.href).then(async (resp)=>{ + const body = new Uint8Array(await resp.arrayBuffer()); + req.respondWith(new Response(body, { + status: resp.status, + headers: { + "content-type": "text/html" + } + })); + }); + } else { + // server launched by deno run ./server.ts + const file = await Deno.open(fromFileUrl(u)); + req.respondWith(new Response(readableStreamFromReader(file), { + status: 200, + headers: { + "content-type": "text/html" + } + })); + } + } else if (req.request.method === "GET" && pathname === "/favicon.ico") { + req.respondWith(Response.redirect("https://deno.land/favicon.ico", 302)); + } else if (req.request.method === "GET" && pathname === "/ws") { + const { socket , response } = Deno.upgradeWebSocket(req.request); + wsHandler(socket); + req.respondWith(response); + } +} +const server = Deno.listen({ + port: 8080 +}); +console.log("chat server starting on :8080...."); +for await (const conn of server){ + (async ()=>{ + const httpConn = Deno.serveHttp(conn); + for await (const requestEvent of httpConn){ + requestHandler(requestEvent); + } + })(); +} +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImh0dHBzOi8vZGVuby5sYW5kL3N0ZEAwLjE0MC4wL2V4YW1wbGVzL2NoYXQvc2VydmVyLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAyMDE4LTIwMjIgdGhlIERlbm8gYXV0aG9ycy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gTUlUIGxpY2Vuc2UuXG5pbXBvcnQgeyBmcm9tRmlsZVVybCB9IGZyb20gXCIuLi8uLi9wYXRoL21vZC50c1wiO1xuaW1wb3J0IHsgcmVhZGFibGVTdHJlYW1Gcm9tUmVhZGVyIH0gZnJvbSBcIi4uLy4uL3N0cmVhbXMvY29udmVyc2lvbi50c1wiO1xuXG5jb25zdCBjbGllbnRzID0gbmV3IE1hcDxudW1iZXIsIFdlYlNvY2tldD4oKTtcbmxldCBjbGllbnRJZCA9IDA7XG5mdW5jdGlvbiBkaXNwYXRjaChtc2c6IHN0cmluZyk6IHZvaWQge1xuICBmb3IgKGNvbnN0IGNsaWVudCBvZiBjbGllbnRzLnZhbHVlcygpKSB7XG4gICAgY2xpZW50LnNlbmQobXNnKTtcbiAgfVxufVxuXG5mdW5jdGlvbiB3c0hhbmRsZXIod3M6IFdlYlNvY2tldCkge1xuICBjb25zdCBpZCA9ICsrY2xpZW50SWQ7XG4gIGNsaWVudHMuc2V0KGlkLCB3cyk7XG4gIHdzLm9ub3BlbiA9ICgpID0+IHtcbiAgICBkaXNwYXRjaChgQ29ubmVjdGVkOiBbJHtpZH1dYCk7XG4gIH07XG4gIHdzLm9ubWVzc2FnZSA9IChlKSA9PiB7XG4gICAgY29uc29sZS5sb2coYG1zZzoke2lkfWAsIGUuZGF0YSk7XG4gICAgZGlzcGF0Y2goYFske2lkfV06ICR7ZS5kYXRhfWApO1xuICB9O1xuICB3cy5vbmNsb3NlID0gKCkgPT4ge1xuICAgIGNsaWVudHMuZGVsZXRlKGlkKTtcbiAgICBkaXNwYXRjaChgQ2xvc2VkOiBbJHtpZH1dYCk7XG4gIH07XG59XG5cbmFzeW5jIGZ1bmN0aW9uIHJlcXVlc3RIYW5kbGVyKHJlcTogRGVuby5SZXF1ZXN0RXZlbnQpIHtcbiAgY29uc3QgcGF0aG5hbWUgPSBuZXcgVVJMKHJlcS5yZXF1ZXN0LnVybCkucGF0aG5hbWU7XG4gIGlmIChyZXEucmVxdWVzdC5tZXRob2QgPT09IFwiR0VUXCIgJiYgcGF0aG5hbWUgPT09IFwiL1wiKSB7XG4gICAgLy9TZXJ2ZSB3aXRoIGhhY2tcbiAgICBjb25zdCB1ID0gbmV3IFVSTChcIi4vaW5kZXguaHRtbFwiLCBpbXBvcnQubWV0YS51cmwpO1xuICAgIGlmICh1LnByb3RvY29sLnN0YXJ0c1dpdGgoXCJodHRwXCIpKSB7XG4gICAgICAvLyBzZXJ2ZXIgbGF1bmNoZWQgYnkgZGVubyBydW4gaHR0cChzKTovLy4uLi9zZXJ2ZXIudHMsXG4gICAgICBmZXRjaCh1LmhyZWYpLnRoZW4oYXN5bmMgKHJlc3ApID0+IHtcbiAgICAgICAgY29uc3QgYm9keSA9IG5ldyBVaW50OEFycmF5KGF3YWl0IHJlc3AuYXJyYXlCdWZmZXIoKSk7XG4gICAgICAgIHJlcS5yZXNwb25kV2l0aChcbiAgICAgICAgICBuZXcgUmVzcG9uc2UoYm9keSwge1xuICAgICAgICAgICAgc3RhdHVzOiByZXNwLnN0YXR1cyxcbiAgICAgICAgICAgIGhlYWRlcnM6IHtcbiAgICAgICAgICAgICAgXCJjb250ZW50LXR5cGVcIjogXCJ0ZXh0L2h0bWxcIixcbiAgICAgICAgICAgIH0sXG4gICAgICAgICAgfSksXG4gICAgICAgICk7XG4gICAgICB9KTtcbiAgICB9IGVsc2Uge1xuICAgICAgLy8gc2VydmVyIGxhdW5jaGVkIGJ5IGRlbm8gcnVuIC4vc2VydmVyLnRzXG4gICAgICBjb25zdCBmaWxlID0gYXdhaXQgRGVuby5vcGVuKGZyb21GaWxlVXJsKHUpKTtcbiAgICAgIHJlcS5yZXNwb25kV2l0aChcbiAgICAgICAgbmV3IFJlc3BvbnNlKHJlYWRhYmxlU3RyZWFtRnJvbVJlYWRlcihmaWxlKSwge1xuICAgICAgICAgIHN0YXR1czogMjAwLFxuICAgICAgICAgIGhlYWRlcnM6IHtcbiAgICAgICAgICAgIFwiY29udGVudC10eXBlXCI6IFwidGV4dC9odG1sXCIsXG4gICAgICAgICAgfSxcbiAgICAgICAgfSksXG4gICAgICApO1xuICAgIH1cbiAgfSBlbHNlIGlmIChcbiAgICByZXEucmVxdWVzdC5tZXRob2QgPT09IFwiR0VUXCIgJiYgcGF0aG5hbWUgPT09IFwiL2Zhdmljb24uaWNvXCJcbiAgKSB7XG4gICAgcmVxLnJlc3BvbmRXaXRoKFJlc3BvbnNlLnJlZGlyZWN0KFwiaHR0cHM6Ly9kZW5vLmxhbmQvZmF2aWNvbi5pY29cIiwgMzAyKSk7XG4gIH0gZWxzZSBpZiAocmVxLnJlcXVlc3QubWV0aG9kID09PSBcIkdFVFwiICYmIHBhdGhuYW1lID09PSBcIi93c1wiKSB7XG4gICAgY29uc3QgeyBzb2NrZXQsIHJlc3BvbnNlIH0gPSBEZW5vLnVwZ3JhZGVXZWJTb2NrZXQocmVxLnJlcXVlc3QpO1xuICAgIHdzSGFuZGxlcihzb2NrZXQpO1xuICAgIHJlcS5yZXNwb25kV2l0aChyZXNwb25zZSk7XG4gIH1cbn1cblxuY29uc3Qgc2VydmVyID0gRGVuby5saXN0ZW4oeyBwb3J0OiA4MDgwIH0pO1xuY29uc29sZS5sb2coXCJjaGF0IHNlcnZlciBzdGFydGluZyBvbiA6ODA4MC4uLi5cIik7XG5cbmZvciBhd2FpdCAoY29uc3QgY29ubiBvZiBzZXJ2ZXIpIHtcbiAgKGFzeW5jICgpID0+IHtcbiAgICBjb25zdCBodHRwQ29ubiA9IERlbm8uc2VydmVIdHRwKGNvbm4pO1xuICAgIGZvciBhd2FpdCAoY29uc3QgcmVxdWVzdEV2ZW50IG9mIGh0dHBDb25uKSB7XG4gICAgICByZXF1ZXN0SGFuZGxlcihyZXF1ZXN0RXZlbnQpO1xuICAgIH1cbiAgfSkoKTtcbn1cbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwwRUFBMEU7QUFDMUUsU0FBUyxXQUFXLFFBQVEsb0JBQW9CO0FBQ2hELFNBQVMsd0JBQXdCLFFBQVEsOEJBQThCO0FBRXZFLE1BQU0sVUFBVSxJQUFJO0FBQ3BCLElBQUksV0FBVztBQUNmLFNBQVMsU0FBUyxHQUFXLEVBQVE7SUFDbkMsS0FBSyxNQUFNLFVBQVUsUUFBUSxNQUFNLEdBQUk7UUFDckMsT0FBTyxJQUFJLENBQUM7SUFDZDtBQUNGO0FBRUEsU0FBUyxVQUFVLEVBQWEsRUFBRTtJQUNoQyxNQUFNLEtBQUssRUFBRTtJQUNiLFFBQVEsR0FBRyxDQUFDLElBQUk7SUFDaEIsR0FBRyxNQUFNLEdBQUcsSUFBTTtRQUNoQixTQUFTLENBQUMsWUFBWSxFQUFFLEdBQUcsQ0FBQyxDQUFDO0lBQy9CO0lBQ0EsR0FBRyxTQUFTLEdBQUcsQ0FBQyxJQUFNO1FBQ3BCLFFBQVEsR0FBRyxDQUFDLENBQUMsSUFBSSxFQUFFLEdBQUcsQ0FBQyxFQUFFLEVBQUUsSUFBSTtRQUMvQixTQUFTLENBQUMsQ0FBQyxFQUFFLEdBQUcsR0FBRyxFQUFFLEVBQUUsSUFBSSxDQUFDLENBQUM7SUFDL0I7SUFDQSxHQUFHLE9BQU8sR0FBRyxJQUFNO1FBQ2pCLFFBQVEsTUFBTSxDQUFDO1FBQ2YsU0FBUyxDQUFDLFNBQVMsRUFBRSxHQUFHLENBQUMsQ0FBQztJQUM1QjtBQUNGO0FBRUEsZUFBZSxlQUFlLEdBQXNCLEVBQUU7SUFDcEQsTUFBTSxXQUFXLElBQUksSUFBSSxJQUFJLE9BQU8sQ0FBQyxHQUFHLEVBQUUsUUFBUTtJQUNsRCxJQUFJLElBQUksT0FBTyxDQUFDLE1BQU0sS0FBSyxTQUFTLGFBQWEsS0FBSztRQUNwRCxpQkFBaUI7UUFDakIsTUFBTSxJQUFJLElBQUksSUFBSSxnQkFBZ0IsWUFBWSxHQUFHO1FBQ2pELElBQUksRUFBRSxRQUFRLENBQUMsVUFBVSxDQUFDLFNBQVM7WUFDakMsdURBQXVEO1lBQ3ZELE1BQU0sRUFBRSxJQUFJLEVBQUUsSUFBSSxDQUFDLE9BQU8sT0FBUztnQkFDakMsTUFBTSxPQUFPLElBQUksV0FBVyxNQUFNLEtBQUssV0FBVztnQkFDbEQsSUFBSSxXQUFXLENBQ2IsSUFBSSxTQUFTLE1BQU07b0JBQ2pCLFFBQVEsS0FBSyxNQUFNO29CQUNuQixTQUFTO3dCQUNQLGdCQUFnQjtvQkFDbEI7Z0JBQ0Y7WUFFSjtRQUNGLE9BQU87WUFDTCwwQ0FBMEM7WUFDMUMsTUFBTSxPQUFPLE1BQU0sS0FBSyxJQUFJLENBQUMsWUFBWTtZQUN6QyxJQUFJLFdBQVcsQ0FDYixJQUFJLFNBQVMseUJBQXlCLE9BQU87Z0JBQzNDLFFBQVE7Z0JBQ1IsU0FBUztvQkFDUCxnQkFBZ0I7Z0JBQ2xCO1lBQ0Y7UUFFSixDQUFDO0lBQ0gsT0FBTyxJQUNMLElBQUksT0FBTyxDQUFDLE1BQU0sS0FBSyxTQUFTLGFBQWEsZ0JBQzdDO1FBQ0EsSUFBSSxXQUFXLENBQUMsU0FBUyxRQUFRLENBQUMsaUNBQWlDO0lBQ3JFLE9BQU8sSUFBSSxJQUFJLE9BQU8sQ0FBQyxNQUFNLEtBQUssU0FBUyxhQUFhLE9BQU87UUFDN0QsTUFBTSxFQUFFLE9BQU0sRUFBRSxTQUFRLEVBQUUsR0FBRyxLQUFLLGdCQUFnQixDQUFDLElBQUksT0FBTztRQUM5RCxVQUFVO1FBQ1YsSUFBSSxXQUFXLENBQUM7SUFDbEIsQ0FBQztBQUNIO0FBRUEsTUFBTSxTQUFTLEtBQUssTUFBTSxDQUFDO0lBQUUsTUFBTTtBQUFLO0FBQ3hDLFFBQVEsR0FBRyxDQUFDO0FBRVosV0FBVyxNQUFNLFFBQVEsT0FBUTtJQUM5QixDQUFBLFVBQVk7UUFDWCxNQUFNLFdBQVcsS0FBSyxTQUFTLENBQUM7UUFDaEMsV0FBVyxNQUFNLGdCQUFnQixTQUFVO1lBQ3pDLGVBQWU7UUFDakI7SUFDRixDQUFBO0FBQ0YifQ== \ No newline at end of file diff --git a/tests/__snapshots__/transpile/remote/modules/VUHr_YUyq8otV9YiIbexaSOfQCs.js b/tests/__snapshots__/transpile/remote/modules/VUHr_YUyq8otV9YiIbexaSOfQCs.js new file mode 100644 index 0000000..3ee16ef --- /dev/null +++ b/tests/__snapshots__/transpile/remote/modules/VUHr_YUyq8otV9YiIbexaSOfQCs.js @@ -0,0 +1,18 @@ +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +// Copyright the Browserify authors. MIT License. +/** + * Ported mostly from https://github.com/browserify/path-browserify/ + * This module is browser compatible. + * @module + */ import { isWindows } from "../_util/os.ts"; +import * as _win32 from "./win32.ts"; +import * as _posix from "./posix.ts"; +const path = isWindows ? _win32 : _posix; +export const win32 = _win32; +export const posix = _posix; +export const { basename , delimiter , dirname , extname , format , fromFileUrl , isAbsolute , join , normalize , parse , relative , resolve , sep , toFileUrl , toNamespacedPath } = path; +export * from "./common.ts"; +export { SEP, SEP_PATTERN } from "./separator.ts"; +export * from "./_interface.ts"; +export * from "./glob.ts"; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImh0dHBzOi8vZGVuby5sYW5kL3N0ZEAwLjE0MC4wL3BhdGgvbW9kLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAyMDE4LTIwMjIgdGhlIERlbm8gYXV0aG9ycy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gTUlUIGxpY2Vuc2UuXG4vLyBDb3B5cmlnaHQgdGhlIEJyb3dzZXJpZnkgYXV0aG9ycy4gTUlUIExpY2Vuc2UuXG5cbi8qKlxuICogUG9ydGVkIG1vc3RseSBmcm9tIGh0dHBzOi8vZ2l0aHViLmNvbS9icm93c2VyaWZ5L3BhdGgtYnJvd3NlcmlmeS9cbiAqIFRoaXMgbW9kdWxlIGlzIGJyb3dzZXIgY29tcGF0aWJsZS5cbiAqIEBtb2R1bGVcbiAqL1xuXG5pbXBvcnQgeyBpc1dpbmRvd3MgfSBmcm9tIFwiLi4vX3V0aWwvb3MudHNcIjtcbmltcG9ydCAqIGFzIF93aW4zMiBmcm9tIFwiLi93aW4zMi50c1wiO1xuaW1wb3J0ICogYXMgX3Bvc2l4IGZyb20gXCIuL3Bvc2l4LnRzXCI7XG5cbmNvbnN0IHBhdGggPSBpc1dpbmRvd3MgPyBfd2luMzIgOiBfcG9zaXg7XG5cbmV4cG9ydCBjb25zdCB3aW4zMiA9IF93aW4zMjtcbmV4cG9ydCBjb25zdCBwb3NpeCA9IF9wb3NpeDtcbmV4cG9ydCBjb25zdCB7XG4gIGJhc2VuYW1lLFxuICBkZWxpbWl0ZXIsXG4gIGRpcm5hbWUsXG4gIGV4dG5hbWUsXG4gIGZvcm1hdCxcbiAgZnJvbUZpbGVVcmwsXG4gIGlzQWJzb2x1dGUsXG4gIGpvaW4sXG4gIG5vcm1hbGl6ZSxcbiAgcGFyc2UsXG4gIHJlbGF0aXZlLFxuICByZXNvbHZlLFxuICBzZXAsXG4gIHRvRmlsZVVybCxcbiAgdG9OYW1lc3BhY2VkUGF0aCxcbn0gPSBwYXRoO1xuXG5leHBvcnQgKiBmcm9tIFwiLi9jb21tb24udHNcIjtcbmV4cG9ydCB7IFNFUCwgU0VQX1BBVFRFUk4gfSBmcm9tIFwiLi9zZXBhcmF0b3IudHNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL19pbnRlcmZhY2UudHNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2dsb2IudHNcIjtcbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwwRUFBMEU7QUFDMUUsaURBQWlEO0FBRWpEOzs7O0NBSUMsR0FFRCxTQUFTLFNBQVMsUUFBUSxpQkFBaUI7QUFDM0MsWUFBWSxZQUFZLGFBQWE7QUFDckMsWUFBWSxZQUFZLGFBQWE7QUFFckMsTUFBTSxPQUFPLFlBQVksU0FBUyxNQUFNO0FBRXhDLE9BQU8sTUFBTSxRQUFRLE9BQU87QUFDNUIsT0FBTyxNQUFNLFFBQVEsT0FBTztBQUM1QixPQUFPLE1BQU0sRUFDWCxTQUFRLEVBQ1IsVUFBUyxFQUNULFFBQU8sRUFDUCxRQUFPLEVBQ1AsT0FBTSxFQUNOLFlBQVcsRUFDWCxXQUFVLEVBQ1YsS0FBSSxFQUNKLFVBQVMsRUFDVCxNQUFLLEVBQ0wsU0FBUSxFQUNSLFFBQU8sRUFDUCxJQUFHLEVBQ0gsVUFBUyxFQUNULGlCQUFnQixFQUNqQixHQUFHLEtBQUs7QUFFVCxjQUFjLGNBQWM7QUFDNUIsU0FBUyxHQUFHLEVBQUUsV0FBVyxRQUFRLGlCQUFpQjtBQUNsRCxjQUFjLGtCQUFrQjtBQUNoQyxjQUFjLFlBQVkifQ== \ No newline at end of file diff --git a/tests/__snapshots__/transpile/remote/modules/WKh_-mE6UYta1pB11lfX_WOvFQ8.js b/tests/__snapshots__/transpile/remote/modules/WKh_-mE6UYta1pB11lfX_WOvFQ8.js new file mode 100644 index 0000000..a5d3b86 --- /dev/null +++ b/tests/__snapshots__/transpile/remote/modules/WKh_-mE6UYta1pB11lfX_WOvFQ8.js @@ -0,0 +1,36 @@ +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. +import { SEP } from "./separator.ts"; +/** Determines the common path from a set of paths, using an optional separator, + * which defaults to the OS default separator. + * + * ```ts + * import { common } from "https://deno.land/std@$STD_VERSION/path/mod.ts"; + * const p = common([ + * "./deno/std/path/mod.ts", + * "./deno/std/fs/mod.ts", + * ]); + * console.log(p); // "./deno/std/" + * ``` + */ export function common(paths, sep = SEP) { + const [first = "", ...remaining] = paths; + if (first === "" || remaining.length === 0) { + return first.substring(0, first.lastIndexOf(sep) + 1); + } + const parts = first.split(sep); + let endOfPrefix = parts.length; + for (const path of remaining){ + const compare = path.split(sep); + for(let i = 0; i < endOfPrefix; i++){ + if (compare[i] !== parts[i]) { + endOfPrefix = i; + } + } + if (endOfPrefix === 0) { + return ""; + } + } + const prefix = parts.slice(0, endOfPrefix).join(sep); + return prefix.endsWith(sep) ? prefix : `${prefix}${sep}`; +} +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/tests/__snapshots__/transpile/remote/modules/WPpXvFGuxwYeU5ay2bDrdG4fV_g.js b/tests/__snapshots__/transpile/remote/modules/WPpXvFGuxwYeU5ay2bDrdG4fV_g.js new file mode 100644 index 0000000..ca8ef1e --- /dev/null +++ b/tests/__snapshots__/transpile/remote/modules/WPpXvFGuxwYeU5ay2bDrdG4fV_g.js @@ -0,0 +1,852 @@ +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +// Copyright the Browserify authors. MIT License. +// Ported from https://github.com/browserify/path-browserify/ +// This module is browser compatible. +import { CHAR_BACKWARD_SLASH, CHAR_COLON, CHAR_DOT, CHAR_QUESTION_MARK } from "./_constants.ts"; +import { _format, assertPath, encodeWhitespace, isPathSeparator, isWindowsDeviceRoot, normalizeString } from "./_util.ts"; +import { assert } from "../_util/assert.ts"; +export const sep = "\\"; +export const delimiter = ";"; +/** + * Resolves path segments into a `path` + * @param pathSegments to process to path + */ export function resolve(...pathSegments) { + let resolvedDevice = ""; + let resolvedTail = ""; + let resolvedAbsolute = false; + for(let i = pathSegments.length - 1; i >= -1; i--){ + let path; + // deno-lint-ignore no-explicit-any + const { Deno } = globalThis; + if (i >= 0) { + path = pathSegments[i]; + } else if (!resolvedDevice) { + if (typeof Deno?.cwd !== "function") { + throw new TypeError("Resolved a drive-letter-less path without a CWD."); + } + path = Deno.cwd(); + } else { + if (typeof Deno?.env?.get !== "function" || typeof Deno?.cwd !== "function") { + throw new TypeError("Resolved a relative path without a CWD."); + } + path = Deno.cwd(); + // Verify that a cwd was found and that it actually points + // to our drive. If not, default to the drive's root. + if (path === undefined || path.slice(0, 3).toLowerCase() !== `${resolvedDevice.toLowerCase()}\\`) { + path = `${resolvedDevice}\\`; + } + } + assertPath(path); + const len = path.length; + // Skip empty entries + if (len === 0) continue; + let rootEnd = 0; + let device = ""; + 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 + device = `\\\\${firstPart}\\${path.slice(last)}`; + rootEnd = j; + } 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 + rootEnd = 1; + isAbsolute = true; + } + if (device.length > 0 && resolvedDevice.length > 0 && device.toLowerCase() !== resolvedDevice.toLowerCase()) { + continue; + } + if (resolvedDevice.length === 0 && device.length > 0) { + resolvedDevice = device; + } + if (!resolvedAbsolute) { + resolvedTail = `${path.slice(rootEnd)}\\${resolvedTail}`; + resolvedAbsolute = isAbsolute; + } + if (resolvedAbsolute && resolvedDevice.length > 0) break; + } + // At this point the path should be resolved to a full absolute path, + // but handle relative paths to be safe (might happen when process.cwd() + // fails) + // Normalize the tail path + resolvedTail = normalizeString(resolvedTail, !resolvedAbsolute, "\\", isPathSeparator); + return resolvedDevice + (resolvedAbsolute ? "\\" : "") + resolvedTail || "."; +} +/** + * Normalizes a `path` + * @param path to normalize + */ export function normalize(path) { + assertPath(path); + const len = path.length; + if (len === 0) return "."; + let rootEnd = 0; + let device; + 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; + 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; + } +} +/** + * Verifies whether path is absolute + * @param path to verify + */ export function isAbsolute(path) { + assertPath(path); + const len = path.length; + if (len === 0) return false; + const code = path.charCodeAt(0); + if (isPathSeparator(code)) { + return true; + } else if (isWindowsDeviceRoot(code)) { + // Possible device root + if (len > 2 && path.charCodeAt(1) === CHAR_COLON) { + if (isPathSeparator(path.charCodeAt(2))) return true; + } + } + return false; +} +/** + * Join all given a sequence of `paths`,then normalizes the resulting path. + * @param paths to be joined and normalized + */ export function join(...paths) { + const pathsCount = paths.length; + if (pathsCount === 0) return "."; + let joined; + let firstPart = null; + for(let i = 0; i < pathsCount; ++i){ + const path = paths[i]; + assertPath(path); + if (path.length > 0) { + if (joined === undefined) joined = firstPart = path; + else joined += `\\${path}`; + } + } + if (joined === undefined) return "."; + // Make sure that the joined path doesn't start with two slashes, because + // normalize() will mistake it for an UNC path then. + // + // This step is skipped when it is very clear that the user actually + // intended to point at an UNC path. This is assumed when the first + // non-empty string arguments starts with exactly two slashes followed by + // at least one more non-slash character. + // + // Note that for normalize() to treat a path as an UNC path it needs to + // have at least 2 components, so we don't filter for that here. + // This means that the user can use join to construct UNC paths from + // a server name and a share name; for example: + // path.join('//server', 'share') -> '\\\\server\\share\\') + let needsReplace = true; + let slashCount = 0; + assert(firstPart != null); + if (isPathSeparator(firstPart.charCodeAt(0))) { + ++slashCount; + const firstLen = firstPart.length; + if (firstLen > 1) { + if (isPathSeparator(firstPart.charCodeAt(1))) { + ++slashCount; + if (firstLen > 2) { + if (isPathSeparator(firstPart.charCodeAt(2))) ++slashCount; + else { + // We matched a UNC path in the first part + needsReplace = false; + } + } + } + } + } + if (needsReplace) { + // Find any more consecutive slashes we need to replace + for(; slashCount < joined.length; ++slashCount){ + if (!isPathSeparator(joined.charCodeAt(slashCount))) break; + } + // Replace the slashes if needed + if (slashCount >= 2) joined = `\\${joined.slice(slashCount)}`; + } + return normalize(joined); +} +/** + * It will solve the relative path from `from` to `to`, for instance: + * from = 'C:\\orandea\\test\\aaa' + * to = 'C:\\orandea\\impl\\bbb' + * The output of the function should be: '..\\..\\impl\\bbb' + * @param from relative path + * @param to relative path + */ export function relative(from, to) { + assertPath(from); + assertPath(to); + if (from === to) return ""; + const fromOrig = resolve(from); + const toOrig = resolve(to); + if (fromOrig === toOrig) return ""; + from = fromOrig.toLowerCase(); + to = toOrig.toLowerCase(); + if (from === to) return ""; + // Trim any leading backslashes + let fromStart = 0; + let fromEnd = from.length; + for(; fromStart < fromEnd; ++fromStart){ + if (from.charCodeAt(fromStart) !== CHAR_BACKWARD_SLASH) break; + } + // Trim trailing backslashes (applicable to UNC paths only) + for(; fromEnd - 1 > fromStart; --fromEnd){ + if (from.charCodeAt(fromEnd - 1) !== CHAR_BACKWARD_SLASH) break; + } + const fromLen = fromEnd - fromStart; + // Trim any leading backslashes + let toStart = 0; + let toEnd = to.length; + for(; toStart < toEnd; ++toStart){ + if (to.charCodeAt(toStart) !== CHAR_BACKWARD_SLASH) break; + } + // Trim trailing backslashes (applicable to UNC paths only) + for(; toEnd - 1 > toStart; --toEnd){ + if (to.charCodeAt(toEnd - 1) !== CHAR_BACKWARD_SLASH) break; + } + const toLen = toEnd - toStart; + // Compare paths to find the longest common path from root + const length = fromLen < toLen ? fromLen : toLen; + let lastCommonSep = -1; + let i = 0; + for(; i <= length; ++i){ + if (i === length) { + if (toLen > length) { + if (to.charCodeAt(toStart + i) === CHAR_BACKWARD_SLASH) { + // We get here if `from` is the exact base path for `to`. + // For example: from='C:\\foo\\bar'; to='C:\\foo\\bar\\baz' + return toOrig.slice(toStart + i + 1); + } else if (i === 2) { + // We get here if `from` is the device root. + // For example: from='C:\\'; to='C:\\foo' + return toOrig.slice(toStart + i); + } + } + if (fromLen > length) { + if (from.charCodeAt(fromStart + i) === CHAR_BACKWARD_SLASH) { + // We get here if `to` is the exact base path for `from`. + // For example: from='C:\\foo\\bar'; to='C:\\foo' + lastCommonSep = i; + } else if (i === 2) { + // We get here if `to` is the device root. + // For example: from='C:\\foo\\bar'; to='C:\\' + lastCommonSep = 3; + } + } + break; + } + const fromCode = from.charCodeAt(fromStart + i); + const toCode = to.charCodeAt(toStart + i); + if (fromCode !== toCode) break; + else if (fromCode === CHAR_BACKWARD_SLASH) lastCommonSep = i; + } + // We found a mismatch before the first common path separator was seen, so + // return the original `to`. + if (i !== length && lastCommonSep === -1) { + return toOrig; + } + let out = ""; + if (lastCommonSep === -1) lastCommonSep = 0; + // Generate the relative path based on the path difference between `to` and + // `from` + for(i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i){ + if (i === fromEnd || from.charCodeAt(i) === CHAR_BACKWARD_SLASH) { + if (out.length === 0) out += ".."; + else out += "\\.."; + } + } + // Lastly, append the rest of the destination (`to`) path that comes after + // the common path parts + if (out.length > 0) { + return out + toOrig.slice(toStart + lastCommonSep, toEnd); + } else { + toStart += lastCommonSep; + if (toOrig.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) ++toStart; + return toOrig.slice(toStart, toEnd); + } +} +/** + * Resolves path to a namespace path + * @param path to resolve to namespace + */ export function toNamespacedPath(path) { + // Note: this will *probably* throw somewhere. + if (typeof path !== "string") return path; + if (path.length === 0) return ""; + const resolvedPath = resolve(path); + if (resolvedPath.length >= 3) { + if (resolvedPath.charCodeAt(0) === CHAR_BACKWARD_SLASH) { + // Possible UNC root + if (resolvedPath.charCodeAt(1) === CHAR_BACKWARD_SLASH) { + const code = resolvedPath.charCodeAt(2); + if (code !== CHAR_QUESTION_MARK && code !== CHAR_DOT) { + // Matched non-long UNC root, convert the path to a long UNC path + return `\\\\?\\UNC\\${resolvedPath.slice(2)}`; + } + } + } else if (isWindowsDeviceRoot(resolvedPath.charCodeAt(0))) { + // Possible device root + if (resolvedPath.charCodeAt(1) === CHAR_COLON && resolvedPath.charCodeAt(2) === CHAR_BACKWARD_SLASH) { + // Matched device root, convert the path to a long UNC path + return `\\\\?\\${resolvedPath}`; + } + } + } + return path; +} +/** + * Return the directory name of a `path`. + * @param path to determine name for + */ export function dirname(path) { + assertPath(path); + const len = path.length; + if (len === 0) return "."; + let rootEnd = -1; + let end = -1; + let matchedSlash = true; + let offset = 0; + const code = path.charCodeAt(0); + // Try to match a root + if (len > 1) { + if (isPathSeparator(code)) { + // Possible UNC root + rootEnd = offset = 1; + 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) { + // 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 path; + } + if (j !== last) { + // We matched a UNC root with leftovers + // Offset by 1 to include the separator after the UNC root to + // treat it as a "normal root" on top of a (UNC) root + rootEnd = offset = j + 1; + } + } + } + } + } else if (isWindowsDeviceRoot(code)) { + // Possible device root + if (path.charCodeAt(1) === CHAR_COLON) { + rootEnd = offset = 2; + if (len > 2) { + if (isPathSeparator(path.charCodeAt(2))) rootEnd = offset = 3; + } + } + } + } else if (isPathSeparator(code)) { + // `path` contains just a path separator, exit early to avoid + // unnecessary work + return path; + } + for(let i = len - 1; i >= offset; --i){ + if (isPathSeparator(path.charCodeAt(i))) { + if (!matchedSlash) { + end = i; + break; + } + } else { + // We saw the first non-path separator + matchedSlash = false; + } + } + if (end === -1) { + if (rootEnd === -1) return "."; + else end = rootEnd; + } + return path.slice(0, end); +} +/** + * Return the last portion of a `path`. Trailing directory separators are ignored. + * @param path to process + * @param ext of path directory + */ export function basename(path, ext = "") { + if (ext !== undefined && typeof ext !== "string") { + throw new TypeError('"ext" argument must be a string'); + } + assertPath(path); + let start = 0; + let end = -1; + let matchedSlash = true; + let i; + // Check for a drive letter prefix so as not to mistake the following + // path separator as an extra separator at the end of the path that can be + // disregarded + if (path.length >= 2) { + const drive = path.charCodeAt(0); + if (isWindowsDeviceRoot(drive)) { + if (path.charCodeAt(1) === CHAR_COLON) start = 2; + } + } + if (ext !== undefined && ext.length > 0 && ext.length <= path.length) { + if (ext.length === path.length && ext === path) return ""; + let extIdx = ext.length - 1; + let firstNonSlashEnd = -1; + for(i = path.length - 1; i >= start; --i){ + const code = path.charCodeAt(i); + if (isPathSeparator(code)) { + // If we reached a path separator that was not part of a set of path + // separators at the end of the string, stop now + if (!matchedSlash) { + start = i + 1; + break; + } + } else { + if (firstNonSlashEnd === -1) { + // We saw the first non-path separator, remember this index in case + // we need it if the extension ends up not matching + matchedSlash = false; + firstNonSlashEnd = i + 1; + } + if (extIdx >= 0) { + // Try to match the explicit extension + if (code === ext.charCodeAt(extIdx)) { + if (--extIdx === -1) { + // We matched the extension, so mark this as the end of our path + // component + end = i; + } + } else { + // Extension does not match, so our result is the entire path + // component + extIdx = -1; + end = firstNonSlashEnd; + } + } + } + } + if (start === end) end = firstNonSlashEnd; + else if (end === -1) end = path.length; + return path.slice(start, end); + } else { + for(i = path.length - 1; i >= start; --i){ + if (isPathSeparator(path.charCodeAt(i))) { + // If we reached a path separator that was not part of a set of path + // separators at the end of the string, stop now + if (!matchedSlash) { + start = i + 1; + break; + } + } else if (end === -1) { + // We saw the first non-path separator, mark this as the end of our + // path component + matchedSlash = false; + end = i + 1; + } + } + if (end === -1) return ""; + return path.slice(start, end); + } +} +/** + * Return the extension of the `path` with leading period. + * @param path with extension + * @returns extension (ex. for `file.ts` returns `.ts`) + */ export function extname(path) { + assertPath(path); + let start = 0; + let startDot = -1; + let startPart = 0; + let end = -1; + let matchedSlash = true; + // Track the state of characters (if any) we see before our first dot and + // after any path separator we find + let preDotState = 0; + // Check for a drive letter prefix so as not to mistake the following + // path separator as an extra separator at the end of the path that can be + // disregarded + if (path.length >= 2 && path.charCodeAt(1) === CHAR_COLON && isWindowsDeviceRoot(path.charCodeAt(0))) { + start = startPart = 2; + } + for(let i = path.length - 1; i >= start; --i){ + const code = path.charCodeAt(i); + if (isPathSeparator(code)) { + // If we reached a path separator that was not part of a set of path + // separators at the end of the string, stop now + if (!matchedSlash) { + startPart = i + 1; + break; + } + continue; + } + if (end === -1) { + // We saw the first non-path separator, mark this as the end of our + // extension + matchedSlash = false; + end = i + 1; + } + if (code === CHAR_DOT) { + // If this is our first dot, mark it as the start of our extension + if (startDot === -1) startDot = i; + else if (preDotState !== 1) preDotState = 1; + } else if (startDot !== -1) { + // We saw a non-dot and non-path separator before our dot, so we should + // have a good chance at having a non-empty extension + preDotState = -1; + } + } + if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot + preDotState === 0 || // The (right-most) trimmed path component is exactly '..' + preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) { + return ""; + } + return path.slice(startDot, end); +} +/** + * Generate a path from `FormatInputPathObject` object. + * @param pathObject with path + */ export function format(pathObject) { + if (pathObject === null || typeof pathObject !== "object") { + throw new TypeError(`The "pathObject" argument must be of type Object. Received type ${typeof pathObject}`); + } + return _format("\\", pathObject); +} +/** + * Return a `ParsedPath` object of the `path`. + * @param path to process + */ export function parse(path) { + assertPath(path); + const ret = { + root: "", + dir: "", + base: "", + ext: "", + name: "" + }; + const len = path.length; + if (len === 0) return ret; + let rootEnd = 0; + let code = path.charCodeAt(0); + // Try to match a root + if (len > 1) { + if (isPathSeparator(code)) { + // Possible UNC root + rootEnd = 1; + 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) { + // 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 + rootEnd = j; + } else if (j !== last) { + // We matched a UNC root with leftovers + rootEnd = j + 1; + } + } + } + } + } else if (isWindowsDeviceRoot(code)) { + // Possible device root + if (path.charCodeAt(1) === CHAR_COLON) { + rootEnd = 2; + if (len > 2) { + if (isPathSeparator(path.charCodeAt(2))) { + if (len === 3) { + // `path` contains just a drive root, exit early to avoid + // unnecessary work + ret.root = ret.dir = path; + return ret; + } + rootEnd = 3; + } + } else { + // `path` contains just a drive root, exit early to avoid + // unnecessary work + ret.root = ret.dir = path; + return ret; + } + } + } + } else if (isPathSeparator(code)) { + // `path` contains just a path separator, exit early to avoid + // unnecessary work + ret.root = ret.dir = path; + return ret; + } + if (rootEnd > 0) ret.root = path.slice(0, rootEnd); + let startDot = -1; + let startPart = rootEnd; + let end = -1; + let matchedSlash = true; + let i = path.length - 1; + // Track the state of characters (if any) we see before our first dot and + // after any path separator we find + let preDotState = 0; + // Get non-dir info + for(; i >= rootEnd; --i){ + code = path.charCodeAt(i); + if (isPathSeparator(code)) { + // If we reached a path separator that was not part of a set of path + // separators at the end of the string, stop now + if (!matchedSlash) { + startPart = i + 1; + break; + } + continue; + } + if (end === -1) { + // We saw the first non-path separator, mark this as the end of our + // extension + matchedSlash = false; + end = i + 1; + } + if (code === CHAR_DOT) { + // If this is our first dot, mark it as the start of our extension + if (startDot === -1) startDot = i; + else if (preDotState !== 1) preDotState = 1; + } else if (startDot !== -1) { + // We saw a non-dot and non-path separator before our dot, so we should + // have a good chance at having a non-empty extension + preDotState = -1; + } + } + if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot + preDotState === 0 || // The (right-most) trimmed path component is exactly '..' + preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) { + if (end !== -1) { + ret.base = ret.name = path.slice(startPart, end); + } + } else { + ret.name = path.slice(startPart, startDot); + ret.base = path.slice(startPart, end); + ret.ext = path.slice(startDot, end); + } + // If the directory is the root, use the entire root as the `dir` including + // the trailing slash if any (`C:\abc` -> `C:\`). Otherwise, strip out the + // trailing slash (`C:\abc\def` -> `C:\abc`). + if (startPart > 0 && startPart !== rootEnd) { + ret.dir = path.slice(0, startPart - 1); + } else ret.dir = ret.root; + return ret; +} +/** + * Converts a file URL to a path string. + * + * ```ts + * import { fromFileUrl } from "./win32.ts"; + * fromFileUrl("file:///home/foo"); // "\\home\\foo" + * fromFileUrl("file:///C:/Users/foo"); // "C:\\Users\\foo" + * fromFileUrl("file://localhost/home/foo"); // "\\\\localhost\\home\\foo" + * ``` + * @param url of a file URL + */ export function fromFileUrl(url) { + url = url instanceof URL ? url : new URL(url); + if (url.protocol != "file:") { + throw new TypeError("Must be a file URL."); + } + let path = decodeURIComponent(url.pathname.replace(/\//g, "\\").replace(/%(?![0-9A-Fa-f]{2})/g, "%25")).replace(/^\\*([A-Za-z]:)(\\|$)/, "$1\\"); + if (url.hostname != "") { + // Note: The `URL` implementation guarantees that the drive letter and + // hostname are mutually exclusive. Otherwise it would not have been valid + // to append the hostname and path like this. + path = `\\\\${url.hostname}${path}`; + } + return path; +} +/** + * Converts a path string to a file URL. + * + * ```ts + * import { toFileUrl } from "./win32.ts"; + * toFileUrl("\\home\\foo"); // new URL("file:///home/foo") + * toFileUrl("C:\\Users\\foo"); // new URL("file:///C:/Users/foo") + * toFileUrl("\\\\127.0.0.1\\home\\foo"); // new URL("file://127.0.0.1/home/foo") + * ``` + * @param path to convert to file URL + */ export function toFileUrl(path) { + if (!isAbsolute(path)) { + throw new TypeError("Must be an absolute path."); + } + const [, hostname, pathname] = path.match(/^(?:[/\\]{2}([^/\\]+)(?=[/\\](?:[^/\\]|$)))?(.*)/); + const url = new URL("file:///"); + url.pathname = encodeWhitespace(pathname.replace(/%/g, "%25")); + if (hostname != null && hostname != "localhost") { + url.hostname = hostname; + if (!url.hostname) { + throw new TypeError("Invalid hostname."); + } + } + return url; +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["https://deno.land/std@0.140.0/path/win32.ts"],"sourcesContent":["// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.\n// Copyright the Browserify authors. MIT License.\n// Ported from https://github.com/browserify/path-browserify/\n// This module is browser compatible.\n\nimport type { FormatInputPathObject, ParsedPath } from \"./_interface.ts\";\nimport {\n  CHAR_BACKWARD_SLASH,\n  CHAR_COLON,\n  CHAR_DOT,\n  CHAR_QUESTION_MARK,\n} from \"./_constants.ts\";\n\nimport {\n  _format,\n  assertPath,\n  encodeWhitespace,\n  isPathSeparator,\n  isWindowsDeviceRoot,\n  normalizeString,\n} from \"./_util.ts\";\nimport { assert } from \"../_util/assert.ts\";\n\nexport const sep = \"\\\\\";\nexport const delimiter = \";\";\n\n/**\n * Resolves path segments into a `path`\n * @param pathSegments to process to path\n */\nexport function resolve(...pathSegments: string[]): string {\n  let resolvedDevice = \"\";\n  let resolvedTail = \"\";\n  let resolvedAbsolute = false;\n\n  for (let i = pathSegments.length - 1; i >= -1; i--) {\n    let path: string;\n    // deno-lint-ignore no-explicit-any\n    const { Deno } = globalThis as any;\n    if (i >= 0) {\n      path = pathSegments[i];\n    } else if (!resolvedDevice) {\n      if (typeof Deno?.cwd !== \"function\") {\n        throw new TypeError(\"Resolved a drive-letter-less path without a CWD.\");\n      }\n      path = Deno.cwd();\n    } else {\n      if (\n        typeof Deno?.env?.get !== \"function\" || typeof Deno?.cwd !== \"function\"\n      ) {\n        throw new TypeError(\"Resolved a relative path without a CWD.\");\n      }\n      path = Deno.cwd();\n\n      // Verify that a cwd was found and that it actually points\n      // to our drive. If not, default to the drive's root.\n      if (\n        path === undefined ||\n        path.slice(0, 3).toLowerCase() !== `${resolvedDevice.toLowerCase()}\\\\`\n      ) {\n        path = `${resolvedDevice}\\\\`;\n      }\n    }\n\n    assertPath(path);\n\n    const len = path.length;\n\n    // Skip empty entries\n    if (len === 0) continue;\n\n    let rootEnd = 0;\n    let device = \"\";\n    let isAbsolute = false;\n    const code = path.charCodeAt(0);\n\n    // Try to match a root\n    if (len > 1) {\n      if (isPathSeparator(code)) {\n        // Possible UNC root\n\n        // If we started with a separator, we know we at least have an\n        // absolute path of some kind (UNC or otherwise)\n        isAbsolute = true;\n\n        if (isPathSeparator(path.charCodeAt(1))) {\n          // Matched double path separator at beginning\n          let j = 2;\n          let last = j;\n          // Match 1 or more non-path separators\n          for (; j < len; ++j) {\n            if (isPathSeparator(path.charCodeAt(j))) break;\n          }\n          if (j < len && j !== last) {\n            const firstPart = path.slice(last, j);\n            // Matched!\n            last = j;\n            // Match 1 or more path separators\n            for (; j < len; ++j) {\n              if (!isPathSeparator(path.charCodeAt(j))) break;\n            }\n            if (j < len && j !== last) {\n              // Matched!\n              last = j;\n              // Match 1 or more non-path separators\n              for (; j < len; ++j) {\n                if (isPathSeparator(path.charCodeAt(j))) break;\n              }\n              if (j === len) {\n                // We matched a UNC root only\n                device = `\\\\\\\\${firstPart}\\\\${path.slice(last)}`;\n                rootEnd = j;\n              } else if (j !== last) {\n                // We matched a UNC root with leftovers\n\n                device = `\\\\\\\\${firstPart}\\\\${path.slice(last, j)}`;\n                rootEnd = j;\n              }\n            }\n          }\n        } else {\n          rootEnd = 1;\n        }\n      } else if (isWindowsDeviceRoot(code)) {\n        // Possible device root\n\n        if (path.charCodeAt(1) === CHAR_COLON) {\n          device = path.slice(0, 2);\n          rootEnd = 2;\n          if (len > 2) {\n            if (isPathSeparator(path.charCodeAt(2))) {\n              // Treat separator following drive name as an absolute path\n              // indicator\n              isAbsolute = true;\n              rootEnd = 3;\n            }\n          }\n        }\n      }\n    } else if (isPathSeparator(code)) {\n      // `path` contains just a path separator\n      rootEnd = 1;\n      isAbsolute = true;\n    }\n\n    if (\n      device.length > 0 &&\n      resolvedDevice.length > 0 &&\n      device.toLowerCase() !== resolvedDevice.toLowerCase()\n    ) {\n      // This path points to another device so it is not applicable\n      continue;\n    }\n\n    if (resolvedDevice.length === 0 && device.length > 0) {\n      resolvedDevice = device;\n    }\n    if (!resolvedAbsolute) {\n      resolvedTail = `${path.slice(rootEnd)}\\\\${resolvedTail}`;\n      resolvedAbsolute = isAbsolute;\n    }\n\n    if (resolvedAbsolute && resolvedDevice.length > 0) break;\n  }\n\n  // At this point the path should be resolved to a full absolute path,\n  // but handle relative paths to be safe (might happen when process.cwd()\n  // fails)\n\n  // Normalize the tail path\n  resolvedTail = normalizeString(\n    resolvedTail,\n    !resolvedAbsolute,\n    \"\\\\\",\n    isPathSeparator,\n  );\n\n  return resolvedDevice + (resolvedAbsolute ? \"\\\\\" : \"\") + resolvedTail || \".\";\n}\n\n/**\n * Normalizes a `path`\n * @param path to normalize\n */\nexport function normalize(path: string): string {\n  assertPath(path);\n  const len = path.length;\n  if (len === 0) return \".\";\n  let rootEnd = 0;\n  let device: string | undefined;\n  let isAbsolute = false;\n  const code = path.charCodeAt(0);\n\n  // Try to match a root\n  if (len > 1) {\n    if (isPathSeparator(code)) {\n      // Possible UNC root\n\n      // If we started with a separator, we know we at least have an absolute\n      // path of some kind (UNC or otherwise)\n      isAbsolute = true;\n\n      if (isPathSeparator(path.charCodeAt(1))) {\n        // Matched double path separator at beginning\n        let j = 2;\n        let last = j;\n        // Match 1 or more non-path separators\n        for (; j < len; ++j) {\n          if (isPathSeparator(path.charCodeAt(j))) break;\n        }\n        if (j < len && j !== last) {\n          const firstPart = path.slice(last, j);\n          // Matched!\n          last = j;\n          // Match 1 or more path separators\n          for (; j < len; ++j) {\n            if (!isPathSeparator(path.charCodeAt(j))) break;\n          }\n          if (j < len && j !== last) {\n            // Matched!\n            last = j;\n            // Match 1 or more non-path separators\n            for (; j < len; ++j) {\n              if (isPathSeparator(path.charCodeAt(j))) break;\n            }\n            if (j === len) {\n              // We matched a UNC root only\n              // Return the normalized version of the UNC root since there\n              // is nothing left to process\n\n              return `\\\\\\\\${firstPart}\\\\${path.slice(last)}\\\\`;\n            } else if (j !== last) {\n              // We matched a UNC root with leftovers\n\n              device = `\\\\\\\\${firstPart}\\\\${path.slice(last, j)}`;\n              rootEnd = j;\n            }\n          }\n        }\n      } else {\n        rootEnd = 1;\n      }\n    } else if (isWindowsDeviceRoot(code)) {\n      // Possible device root\n\n      if (path.charCodeAt(1) === CHAR_COLON) {\n        device = path.slice(0, 2);\n        rootEnd = 2;\n        if (len > 2) {\n          if (isPathSeparator(path.charCodeAt(2))) {\n            // Treat separator following drive name as an absolute path\n            // indicator\n            isAbsolute = true;\n            rootEnd = 3;\n          }\n        }\n      }\n    }\n  } else if (isPathSeparator(code)) {\n    // `path` contains just a path separator, exit early to avoid unnecessary\n    // work\n    return \"\\\\\";\n  }\n\n  let tail: string;\n  if (rootEnd < len) {\n    tail = normalizeString(\n      path.slice(rootEnd),\n      !isAbsolute,\n      \"\\\\\",\n      isPathSeparator,\n    );\n  } else {\n    tail = \"\";\n  }\n  if (tail.length === 0 && !isAbsolute) tail = \".\";\n  if (tail.length > 0 && isPathSeparator(path.charCodeAt(len - 1))) {\n    tail += \"\\\\\";\n  }\n  if (device === undefined) {\n    if (isAbsolute) {\n      if (tail.length > 0) return `\\\\${tail}`;\n      else return \"\\\\\";\n    } else if (tail.length > 0) {\n      return tail;\n    } else {\n      return \"\";\n    }\n  } else if (isAbsolute) {\n    if (tail.length > 0) return `${device}\\\\${tail}`;\n    else return `${device}\\\\`;\n  } else if (tail.length > 0) {\n    return device + tail;\n  } else {\n    return device;\n  }\n}\n\n/**\n * Verifies whether path is absolute\n * @param path to verify\n */\nexport function isAbsolute(path: string): boolean {\n  assertPath(path);\n  const len = path.length;\n  if (len === 0) return false;\n\n  const code = path.charCodeAt(0);\n  if (isPathSeparator(code)) {\n    return true;\n  } else if (isWindowsDeviceRoot(code)) {\n    // Possible device root\n\n    if (len > 2 && path.charCodeAt(1) === CHAR_COLON) {\n      if (isPathSeparator(path.charCodeAt(2))) return true;\n    }\n  }\n  return false;\n}\n\n/**\n * Join all given a sequence of `paths`,then normalizes the resulting path.\n * @param paths to be joined and normalized\n */\nexport function join(...paths: string[]): string {\n  const pathsCount = paths.length;\n  if (pathsCount === 0) return \".\";\n\n  let joined: string | undefined;\n  let firstPart: string | null = null;\n  for (let i = 0; i < pathsCount; ++i) {\n    const path = paths[i];\n    assertPath(path);\n    if (path.length > 0) {\n      if (joined === undefined) joined = firstPart = path;\n      else joined += `\\\\${path}`;\n    }\n  }\n\n  if (joined === undefined) return \".\";\n\n  // Make sure that the joined path doesn't start with two slashes, because\n  // normalize() will mistake it for an UNC path then.\n  //\n  // This step is skipped when it is very clear that the user actually\n  // intended to point at an UNC path. This is assumed when the first\n  // non-empty string arguments starts with exactly two slashes followed by\n  // at least one more non-slash character.\n  //\n  // Note that for normalize() to treat a path as an UNC path it needs to\n  // have at least 2 components, so we don't filter for that here.\n  // This means that the user can use join to construct UNC paths from\n  // a server name and a share name; for example:\n  //   path.join('//server', 'share') -> '\\\\\\\\server\\\\share\\\\')\n  let needsReplace = true;\n  let slashCount = 0;\n  assert(firstPart != null);\n  if (isPathSeparator(firstPart.charCodeAt(0))) {\n    ++slashCount;\n    const firstLen = firstPart.length;\n    if (firstLen > 1) {\n      if (isPathSeparator(firstPart.charCodeAt(1))) {\n        ++slashCount;\n        if (firstLen > 2) {\n          if (isPathSeparator(firstPart.charCodeAt(2))) ++slashCount;\n          else {\n            // We matched a UNC path in the first part\n            needsReplace = false;\n          }\n        }\n      }\n    }\n  }\n  if (needsReplace) {\n    // Find any more consecutive slashes we need to replace\n    for (; slashCount < joined.length; ++slashCount) {\n      if (!isPathSeparator(joined.charCodeAt(slashCount))) break;\n    }\n\n    // Replace the slashes if needed\n    if (slashCount >= 2) joined = `\\\\${joined.slice(slashCount)}`;\n  }\n\n  return normalize(joined);\n}\n\n/**\n * It will solve the relative path from `from` to `to`, for instance:\n *  from = 'C:\\\\orandea\\\\test\\\\aaa'\n *  to = 'C:\\\\orandea\\\\impl\\\\bbb'\n * The output of the function should be: '..\\\\..\\\\impl\\\\bbb'\n * @param from relative path\n * @param to relative path\n */\nexport function relative(from: string, to: string): string {\n  assertPath(from);\n  assertPath(to);\n\n  if (from === to) return \"\";\n\n  const fromOrig = resolve(from);\n  const toOrig = resolve(to);\n\n  if (fromOrig === toOrig) return \"\";\n\n  from = fromOrig.toLowerCase();\n  to = toOrig.toLowerCase();\n\n  if (from === to) return \"\";\n\n  // Trim any leading backslashes\n  let fromStart = 0;\n  let fromEnd = from.length;\n  for (; fromStart < fromEnd; ++fromStart) {\n    if (from.charCodeAt(fromStart) !== CHAR_BACKWARD_SLASH) break;\n  }\n  // Trim trailing backslashes (applicable to UNC paths only)\n  for (; fromEnd - 1 > fromStart; --fromEnd) {\n    if (from.charCodeAt(fromEnd - 1) !== CHAR_BACKWARD_SLASH) break;\n  }\n  const fromLen = fromEnd - fromStart;\n\n  // Trim any leading backslashes\n  let toStart = 0;\n  let toEnd = to.length;\n  for (; toStart < toEnd; ++toStart) {\n    if (to.charCodeAt(toStart) !== CHAR_BACKWARD_SLASH) break;\n  }\n  // Trim trailing backslashes (applicable to UNC paths only)\n  for (; toEnd - 1 > toStart; --toEnd) {\n    if (to.charCodeAt(toEnd - 1) !== CHAR_BACKWARD_SLASH) break;\n  }\n  const toLen = toEnd - toStart;\n\n  // Compare paths to find the longest common path from root\n  const length = fromLen < toLen ? fromLen : toLen;\n  let lastCommonSep = -1;\n  let i = 0;\n  for (; i <= length; ++i) {\n    if (i === length) {\n      if (toLen > length) {\n        if (to.charCodeAt(toStart + i) === CHAR_BACKWARD_SLASH) {\n          // We get here if `from` is the exact base path for `to`.\n          // For example: from='C:\\\\foo\\\\bar'; to='C:\\\\foo\\\\bar\\\\baz'\n          return toOrig.slice(toStart + i + 1);\n        } else if (i === 2) {\n          // We get here if `from` is the device root.\n          // For example: from='C:\\\\'; to='C:\\\\foo'\n          return toOrig.slice(toStart + i);\n        }\n      }\n      if (fromLen > length) {\n        if (from.charCodeAt(fromStart + i) === CHAR_BACKWARD_SLASH) {\n          // We get here if `to` is the exact base path for `from`.\n          // For example: from='C:\\\\foo\\\\bar'; to='C:\\\\foo'\n          lastCommonSep = i;\n        } else if (i === 2) {\n          // We get here if `to` is the device root.\n          // For example: from='C:\\\\foo\\\\bar'; to='C:\\\\'\n          lastCommonSep = 3;\n        }\n      }\n      break;\n    }\n    const fromCode = from.charCodeAt(fromStart + i);\n    const toCode = to.charCodeAt(toStart + i);\n    if (fromCode !== toCode) break;\n    else if (fromCode === CHAR_BACKWARD_SLASH) lastCommonSep = i;\n  }\n\n  // We found a mismatch before the first common path separator was seen, so\n  // return the original `to`.\n  if (i !== length && lastCommonSep === -1) {\n    return toOrig;\n  }\n\n  let out = \"\";\n  if (lastCommonSep === -1) lastCommonSep = 0;\n  // Generate the relative path based on the path difference between `to` and\n  // `from`\n  for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {\n    if (i === fromEnd || from.charCodeAt(i) === CHAR_BACKWARD_SLASH) {\n      if (out.length === 0) out += \"..\";\n      else out += \"\\\\..\";\n    }\n  }\n\n  // Lastly, append the rest of the destination (`to`) path that comes after\n  // the common path parts\n  if (out.length > 0) {\n    return out + toOrig.slice(toStart + lastCommonSep, toEnd);\n  } else {\n    toStart += lastCommonSep;\n    if (toOrig.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) ++toStart;\n    return toOrig.slice(toStart, toEnd);\n  }\n}\n\n/**\n * Resolves path to a namespace path\n * @param path to resolve to namespace\n */\nexport function toNamespacedPath(path: string): string {\n  // Note: this will *probably* throw somewhere.\n  if (typeof path !== \"string\") return path;\n  if (path.length === 0) return \"\";\n\n  const resolvedPath = resolve(path);\n\n  if (resolvedPath.length >= 3) {\n    if (resolvedPath.charCodeAt(0) === CHAR_BACKWARD_SLASH) {\n      // Possible UNC root\n\n      if (resolvedPath.charCodeAt(1) === CHAR_BACKWARD_SLASH) {\n        const code = resolvedPath.charCodeAt(2);\n        if (code !== CHAR_QUESTION_MARK && code !== CHAR_DOT) {\n          // Matched non-long UNC root, convert the path to a long UNC path\n          return `\\\\\\\\?\\\\UNC\\\\${resolvedPath.slice(2)}`;\n        }\n      }\n    } else if (isWindowsDeviceRoot(resolvedPath.charCodeAt(0))) {\n      // Possible device root\n\n      if (\n        resolvedPath.charCodeAt(1) === CHAR_COLON &&\n        resolvedPath.charCodeAt(2) === CHAR_BACKWARD_SLASH\n      ) {\n        // Matched device root, convert the path to a long UNC path\n        return `\\\\\\\\?\\\\${resolvedPath}`;\n      }\n    }\n  }\n\n  return path;\n}\n\n/**\n * Return the directory name of a `path`.\n * @param path to determine name for\n */\nexport function dirname(path: string): string {\n  assertPath(path);\n  const len = path.length;\n  if (len === 0) return \".\";\n  let rootEnd = -1;\n  let end = -1;\n  let matchedSlash = true;\n  let offset = 0;\n  const code = path.charCodeAt(0);\n\n  // Try to match a root\n  if (len > 1) {\n    if (isPathSeparator(code)) {\n      // Possible UNC root\n\n      rootEnd = offset = 1;\n\n      if (isPathSeparator(path.charCodeAt(1))) {\n        // Matched double path separator at beginning\n        let j = 2;\n        let last = j;\n        // Match 1 or more non-path separators\n        for (; j < len; ++j) {\n          if (isPathSeparator(path.charCodeAt(j))) break;\n        }\n        if (j < len && j !== last) {\n          // Matched!\n          last = j;\n          // Match 1 or more path separators\n          for (; j < len; ++j) {\n            if (!isPathSeparator(path.charCodeAt(j))) break;\n          }\n          if (j < len && j !== last) {\n            // Matched!\n            last = j;\n            // Match 1 or more non-path separators\n            for (; j < len; ++j) {\n              if (isPathSeparator(path.charCodeAt(j))) break;\n            }\n            if (j === len) {\n              // We matched a UNC root only\n              return path;\n            }\n            if (j !== last) {\n              // We matched a UNC root with leftovers\n\n              // Offset by 1 to include the separator after the UNC root to\n              // treat it as a \"normal root\" on top of a (UNC) root\n              rootEnd = offset = j + 1;\n            }\n          }\n        }\n      }\n    } else if (isWindowsDeviceRoot(code)) {\n      // Possible device root\n\n      if (path.charCodeAt(1) === CHAR_COLON) {\n        rootEnd = offset = 2;\n        if (len > 2) {\n          if (isPathSeparator(path.charCodeAt(2))) rootEnd = offset = 3;\n        }\n      }\n    }\n  } else if (isPathSeparator(code)) {\n    // `path` contains just a path separator, exit early to avoid\n    // unnecessary work\n    return path;\n  }\n\n  for (let i = len - 1; i >= offset; --i) {\n    if (isPathSeparator(path.charCodeAt(i))) {\n      if (!matchedSlash) {\n        end = i;\n        break;\n      }\n    } else {\n      // We saw the first non-path separator\n      matchedSlash = false;\n    }\n  }\n\n  if (end === -1) {\n    if (rootEnd === -1) return \".\";\n    else end = rootEnd;\n  }\n  return path.slice(0, end);\n}\n\n/**\n * Return the last portion of a `path`. Trailing directory separators are ignored.\n * @param path to process\n * @param ext of path directory\n */\nexport function basename(path: string, ext = \"\"): string {\n  if (ext !== undefined && typeof ext !== \"string\") {\n    throw new TypeError('\"ext\" argument must be a string');\n  }\n\n  assertPath(path);\n\n  let start = 0;\n  let end = -1;\n  let matchedSlash = true;\n  let i: number;\n\n  // Check for a drive letter prefix so as not to mistake the following\n  // path separator as an extra separator at the end of the path that can be\n  // disregarded\n  if (path.length >= 2) {\n    const drive = path.charCodeAt(0);\n    if (isWindowsDeviceRoot(drive)) {\n      if (path.charCodeAt(1) === CHAR_COLON) start = 2;\n    }\n  }\n\n  if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {\n    if (ext.length === path.length && ext === path) return \"\";\n    let extIdx = ext.length - 1;\n    let firstNonSlashEnd = -1;\n    for (i = path.length - 1; i >= start; --i) {\n      const code = path.charCodeAt(i);\n      if (isPathSeparator(code)) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          start = i + 1;\n          break;\n        }\n      } else {\n        if (firstNonSlashEnd === -1) {\n          // We saw the first non-path separator, remember this index in case\n          // we need it if the extension ends up not matching\n          matchedSlash = false;\n          firstNonSlashEnd = i + 1;\n        }\n        if (extIdx >= 0) {\n          // Try to match the explicit extension\n          if (code === ext.charCodeAt(extIdx)) {\n            if (--extIdx === -1) {\n              // We matched the extension, so mark this as the end of our path\n              // component\n              end = i;\n            }\n          } else {\n            // Extension does not match, so our result is the entire path\n            // component\n            extIdx = -1;\n            end = firstNonSlashEnd;\n          }\n        }\n      }\n    }\n\n    if (start === end) end = firstNonSlashEnd;\n    else if (end === -1) end = path.length;\n    return path.slice(start, end);\n  } else {\n    for (i = path.length - 1; i >= start; --i) {\n      if (isPathSeparator(path.charCodeAt(i))) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          start = i + 1;\n          break;\n        }\n      } else if (end === -1) {\n        // We saw the first non-path separator, mark this as the end of our\n        // path component\n        matchedSlash = false;\n        end = i + 1;\n      }\n    }\n\n    if (end === -1) return \"\";\n    return path.slice(start, end);\n  }\n}\n\n/**\n * Return the extension of the `path` with leading period.\n * @param path with extension\n * @returns extension (ex. for `file.ts` returns `.ts`)\n */\nexport function extname(path: string): string {\n  assertPath(path);\n  let start = 0;\n  let startDot = -1;\n  let startPart = 0;\n  let end = -1;\n  let matchedSlash = true;\n  // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find\n  let preDotState = 0;\n\n  // Check for a drive letter prefix so as not to mistake the following\n  // path separator as an extra separator at the end of the path that can be\n  // disregarded\n\n  if (\n    path.length >= 2 &&\n    path.charCodeAt(1) === CHAR_COLON &&\n    isWindowsDeviceRoot(path.charCodeAt(0))\n  ) {\n    start = startPart = 2;\n  }\n\n  for (let i = path.length - 1; i >= start; --i) {\n    const code = path.charCodeAt(i);\n    if (isPathSeparator(code)) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now\n      if (!matchedSlash) {\n        startPart = i + 1;\n        break;\n      }\n      continue;\n    }\n    if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension\n      matchedSlash = false;\n      end = i + 1;\n    }\n    if (code === CHAR_DOT) {\n      // If this is our first dot, mark it as the start of our extension\n      if (startDot === -1) startDot = i;\n      else if (preDotState !== 1) preDotState = 1;\n    } else if (startDot !== -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension\n      preDotState = -1;\n    }\n  }\n\n  if (\n    startDot === -1 ||\n    end === -1 ||\n    // We saw a non-dot character immediately before the dot\n    preDotState === 0 ||\n    // The (right-most) trimmed path component is exactly '..'\n    (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)\n  ) {\n    return \"\";\n  }\n  return path.slice(startDot, end);\n}\n\n/**\n * Generate a path from `FormatInputPathObject` object.\n * @param pathObject with path\n */\nexport function format(pathObject: FormatInputPathObject): string {\n  if (pathObject === null || typeof pathObject !== \"object\") {\n    throw new TypeError(\n      `The \"pathObject\" argument must be of type Object. Received type ${typeof pathObject}`,\n    );\n  }\n  return _format(\"\\\\\", pathObject);\n}\n\n/**\n * Return a `ParsedPath` object of the `path`.\n * @param path to process\n */\nexport function parse(path: string): ParsedPath {\n  assertPath(path);\n\n  const ret: ParsedPath = { root: \"\", dir: \"\", base: \"\", ext: \"\", name: \"\" };\n\n  const len = path.length;\n  if (len === 0) return ret;\n\n  let rootEnd = 0;\n  let code = path.charCodeAt(0);\n\n  // Try to match a root\n  if (len > 1) {\n    if (isPathSeparator(code)) {\n      // Possible UNC root\n\n      rootEnd = 1;\n      if (isPathSeparator(path.charCodeAt(1))) {\n        // Matched double path separator at beginning\n        let j = 2;\n        let last = j;\n        // Match 1 or more non-path separators\n        for (; j < len; ++j) {\n          if (isPathSeparator(path.charCodeAt(j))) break;\n        }\n        if (j < len && j !== last) {\n          // Matched!\n          last = j;\n          // Match 1 or more path separators\n          for (; j < len; ++j) {\n            if (!isPathSeparator(path.charCodeAt(j))) break;\n          }\n          if (j < len && j !== last) {\n            // Matched!\n            last = j;\n            // Match 1 or more non-path separators\n            for (; j < len; ++j) {\n              if (isPathSeparator(path.charCodeAt(j))) break;\n            }\n            if (j === len) {\n              // We matched a UNC root only\n\n              rootEnd = j;\n            } else if (j !== last) {\n              // We matched a UNC root with leftovers\n\n              rootEnd = j + 1;\n            }\n          }\n        }\n      }\n    } else if (isWindowsDeviceRoot(code)) {\n      // Possible device root\n\n      if (path.charCodeAt(1) === CHAR_COLON) {\n        rootEnd = 2;\n        if (len > 2) {\n          if (isPathSeparator(path.charCodeAt(2))) {\n            if (len === 3) {\n              // `path` contains just a drive root, exit early to avoid\n              // unnecessary work\n              ret.root = ret.dir = path;\n              return ret;\n            }\n            rootEnd = 3;\n          }\n        } else {\n          // `path` contains just a drive root, exit early to avoid\n          // unnecessary work\n          ret.root = ret.dir = path;\n          return ret;\n        }\n      }\n    }\n  } else if (isPathSeparator(code)) {\n    // `path` contains just a path separator, exit early to avoid\n    // unnecessary work\n    ret.root = ret.dir = path;\n    return ret;\n  }\n\n  if (rootEnd > 0) ret.root = path.slice(0, rootEnd);\n\n  let startDot = -1;\n  let startPart = rootEnd;\n  let end = -1;\n  let matchedSlash = true;\n  let i = path.length - 1;\n\n  // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find\n  let preDotState = 0;\n\n  // Get non-dir info\n  for (; i >= rootEnd; --i) {\n    code = path.charCodeAt(i);\n    if (isPathSeparator(code)) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now\n      if (!matchedSlash) {\n        startPart = i + 1;\n        break;\n      }\n      continue;\n    }\n    if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension\n      matchedSlash = false;\n      end = i + 1;\n    }\n    if (code === CHAR_DOT) {\n      // If this is our first dot, mark it as the start of our extension\n      if (startDot === -1) startDot = i;\n      else if (preDotState !== 1) preDotState = 1;\n    } else if (startDot !== -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension\n      preDotState = -1;\n    }\n  }\n\n  if (\n    startDot === -1 ||\n    end === -1 ||\n    // We saw a non-dot character immediately before the dot\n    preDotState === 0 ||\n    // The (right-most) trimmed path component is exactly '..'\n    (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)\n  ) {\n    if (end !== -1) {\n      ret.base = ret.name = path.slice(startPart, end);\n    }\n  } else {\n    ret.name = path.slice(startPart, startDot);\n    ret.base = path.slice(startPart, end);\n    ret.ext = path.slice(startDot, end);\n  }\n\n  // If the directory is the root, use the entire root as the `dir` including\n  // the trailing slash if any (`C:\\abc` -> `C:\\`). Otherwise, strip out the\n  // trailing slash (`C:\\abc\\def` -> `C:\\abc`).\n  if (startPart > 0 && startPart !== rootEnd) {\n    ret.dir = path.slice(0, startPart - 1);\n  } else ret.dir = ret.root;\n\n  return ret;\n}\n\n/**\n * Converts a file URL to a path string.\n *\n * ```ts\n *      import { fromFileUrl } from \"./win32.ts\";\n *      fromFileUrl(\"file:///home/foo\"); // \"\\\\home\\\\foo\"\n *      fromFileUrl(\"file:///C:/Users/foo\"); // \"C:\\\\Users\\\\foo\"\n *      fromFileUrl(\"file://localhost/home/foo\"); // \"\\\\\\\\localhost\\\\home\\\\foo\"\n * ```\n * @param url of a file URL\n */\nexport function fromFileUrl(url: string | URL): string {\n  url = url instanceof URL ? url : new URL(url);\n  if (url.protocol != \"file:\") {\n    throw new TypeError(\"Must be a file URL.\");\n  }\n  let path = decodeURIComponent(\n    url.pathname.replace(/\\//g, \"\\\\\").replace(/%(?![0-9A-Fa-f]{2})/g, \"%25\"),\n  ).replace(/^\\\\*([A-Za-z]:)(\\\\|$)/, \"$1\\\\\");\n  if (url.hostname != \"\") {\n    // Note: The `URL` implementation guarantees that the drive letter and\n    // hostname are mutually exclusive. Otherwise it would not have been valid\n    // to append the hostname and path like this.\n    path = `\\\\\\\\${url.hostname}${path}`;\n  }\n  return path;\n}\n\n/**\n * Converts a path string to a file URL.\n *\n * ```ts\n *      import { toFileUrl } from \"./win32.ts\";\n *      toFileUrl(\"\\\\home\\\\foo\"); // new URL(\"file:///home/foo\")\n *      toFileUrl(\"C:\\\\Users\\\\foo\"); // new URL(\"file:///C:/Users/foo\")\n *      toFileUrl(\"\\\\\\\\127.0.0.1\\\\home\\\\foo\"); // new URL(\"file://127.0.0.1/home/foo\")\n * ```\n * @param path to convert to file URL\n */\nexport function toFileUrl(path: string): URL {\n  if (!isAbsolute(path)) {\n    throw new TypeError(\"Must be an absolute path.\");\n  }\n  const [, hostname, pathname] = path.match(\n    /^(?:[/\\\\]{2}([^/\\\\]+)(?=[/\\\\](?:[^/\\\\]|$)))?(.*)/,\n  )!;\n  const url = new URL(\"file:///\");\n  url.pathname = encodeWhitespace(pathname.replace(/%/g, \"%25\"));\n  if (hostname != null && hostname != \"localhost\") {\n    url.hostname = hostname;\n    if (!url.hostname) {\n      throw new TypeError(\"Invalid hostname.\");\n    }\n  }\n  return url;\n}\n"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/tests/__snapshots__/transpile/remote/modules/WStdDhyHbKYy_C9CJ39RDks1VaY.js b/tests/__snapshots__/transpile/remote/modules/WStdDhyHbKYy_C9CJ39RDks1VaY.js new file mode 100644 index 0000000..bd10af7 --- /dev/null +++ b/tests/__snapshots__/transpile/remote/modules/WStdDhyHbKYy_C9CJ39RDks1VaY.js @@ -0,0 +1,228 @@ +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. +/** + * Provides helper functions to manipulate `Uint8Array` byte slices that are not + * included on the `Uint8Array` prototype. + * + * @module + */ /** Returns the index of the first occurrence of the needle array in the source + * array, or -1 if it is not present. + * + * A start index can be specified as the third argument that begins the search + * at that given index. The start index defaults to the start of the array. + * + * The complexity of this function is O(source.lenth * needle.length). + * + * ```ts + * import { indexOfNeedle } from "./mod.ts"; + * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]); + * const needle = new Uint8Array([1, 2]); + * console.log(indexOfNeedle(source, needle)); // 1 + * console.log(indexOfNeedle(source, needle, 2)); // 3 + * ``` + */ export function indexOfNeedle(source, needle, start = 0) { + if (start >= source.length) { + return -1; + } + if (start < 0) { + start = Math.max(0, source.length + start); + } + const s = needle[0]; + for(let i = start; i < source.length; i++){ + if (source[i] !== s) continue; + const pin = i; + let matched = 1; + let j = i; + while(matched < needle.length){ + j++; + if (source[j] !== needle[j - pin]) { + break; + } + matched++; + } + if (matched === needle.length) { + return pin; + } + } + return -1; +} +/** Returns the index of the last occurrence of the needle array in the source + * array, or -1 if it is not present. + * + * A start index can be specified as the third argument that begins the search + * at that given index. The start index defaults to the end of the array. + * + * The complexity of this function is O(source.lenth * needle.length). + * + * ```ts + * import { lastIndexOfNeedle } from "./mod.ts"; + * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]); + * const needle = new Uint8Array([1, 2]); + * console.log(lastIndexOfNeedle(source, needle)); // 5 + * console.log(lastIndexOfNeedle(source, needle, 4)); // 3 + * ``` + */ export function lastIndexOfNeedle(source, needle, start = source.length - 1) { + if (start < 0) { + return -1; + } + if (start >= source.length) { + start = source.length - 1; + } + const e = needle[needle.length - 1]; + for(let i = start; i >= 0; i--){ + if (source[i] !== e) continue; + const pin = i; + let matched = 1; + let j = i; + while(matched < needle.length){ + j--; + if (source[j] !== needle[needle.length - 1 - (pin - j)]) { + break; + } + matched++; + } + if (matched === needle.length) { + return pin - needle.length + 1; + } + } + return -1; +} +/** Returns true if the prefix array appears at the start of the source array, + * false otherwise. + * + * The complexity of this function is O(prefix.length). + * + * ```ts + * import { startsWith } from "./mod.ts"; + * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]); + * const prefix = new Uint8Array([0, 1, 2]); + * console.log(startsWith(source, prefix)); // true + * ``` + */ export function startsWith(source, prefix) { + for(let i = 0, max = prefix.length; i < max; i++){ + if (source[i] !== prefix[i]) return false; + } + return true; +} +/** Returns true if the suffix array appears at the end of the source array, + * false otherwise. + * + * The complexity of this function is O(suffix.length). + * + * ```ts + * import { endsWith } from "./mod.ts"; + * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]); + * const suffix = new Uint8Array([1, 2, 3]); + * console.log(endsWith(source, suffix)); // true + * ``` + */ export function endsWith(source, suffix) { + for(let srci = source.length - 1, sfxi = suffix.length - 1; sfxi >= 0; srci--, sfxi--){ + if (source[srci] !== suffix[sfxi]) return false; + } + return true; +} +/** Returns a new Uint8Array composed of `count` repetitions of the `source` + * array. + * + * If `count` is negative, a `RangeError` is thrown. + * + * ```ts + * import { repeat } from "./mod.ts"; + * const source = new Uint8Array([0, 1, 2]); + * console.log(repeat(source, 3)); // [0, 1, 2, 0, 1, 2, 0, 1, 2] + * console.log(repeat(source, 0)); // [] + * console.log(repeat(source, -1)); // RangeError + * ``` + */ export function repeat(source, count) { + if (count === 0) { + return new Uint8Array(); + } + if (count < 0) { + throw new RangeError("bytes: negative repeat count"); + } else if (source.length * count / count !== source.length) { + throw new Error("bytes: repeat count causes overflow"); + } + const int = Math.floor(count); + if (int !== count) { + throw new Error("bytes: repeat count must be an integer"); + } + const nb = new Uint8Array(source.length * count); + let bp = copy(source, nb); + for(; bp < nb.length; bp *= 2){ + copy(nb.slice(0, bp), nb, bp); + } + return nb; +} +/** Concatenate the given arrays into a new Uint8Array. + * + * ```ts + * import { concat } from "./mod.ts"; + * const a = new Uint8Array([0, 1, 2]); + * const b = new Uint8Array([3, 4, 5]); + * console.log(concat(a, b)); // [0, 1, 2, 3, 4, 5] + */ export function concat(...buf) { + let length = 0; + for (const b of buf){ + length += b.length; + } + const output = new Uint8Array(length); + let index = 0; + for (const b of buf){ + output.set(b, index); + index += b.length; + } + return output; +} +/** Returns true if the source array contains the needle array, false otherwise. + * + * A start index can be specified as the third argument that begins the search + * at that given index. The start index defaults to the beginning of the array. + * + * The complexity of this function is O(source.length * needle.length). + * + * ```ts + * import { includesNeedle } from "./mod.ts"; + * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]); + * const needle = new Uint8Array([1, 2]); + * console.log(includesNeedle(source, needle)); // true + * console.log(includesNeedle(source, needle, 6)); // false + * ``` + */ export function includesNeedle(source, needle, start = 0) { + return indexOfNeedle(source, needle, start) !== -1; +} +/** Copy bytes from the `src` array to the `dst` array. Returns the number of + * bytes copied. + * + * If the `src` array is larger than what the `dst` array can hold, only the + * amount of bytes that fit in the `dst` array are copied. + * + * An offset can be specified as the third argument that begins the copy at + * that given index in the `dst` array. The offset defaults to the beginning of + * the array. + * + * ```ts + * import { copy } from "./mod.ts"; + * const src = new Uint8Array([9, 8, 7]); + * const dst = new Uint8Array([0, 1, 2, 3, 4, 5]); + * console.log(copy(src, dst)); // 3 + * console.log(dst); // [9, 8, 7, 3, 4, 5] + * ``` + * + * ```ts + * import { copy } from "./mod.ts"; + * const src = new Uint8Array([1, 1, 1, 1]); + * const dst = new Uint8Array([0, 0, 0, 0]); + * console.log(copy(src, dst, 1)); // 3 + * console.log(dst); // [0, 1, 1, 1] + * ``` + */ export function copy(src, dst, off = 0) { + off = Math.max(0, Math.min(off, dst.byteLength)); + const dstBytesAvailable = dst.byteLength - off; + if (src.byteLength > dstBytesAvailable) { + src = src.subarray(0, dstBytesAvailable); + } + dst.set(src, off); + return src.byteLength; +} +export { equals } from "./equals.ts"; +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["https://deno.land/std@0.140.0/bytes/mod.ts"],"sourcesContent":["// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.\n// This module is browser compatible.\n\n/**\n * Provides helper functions to manipulate `Uint8Array` byte slices that are not\n * included on the `Uint8Array` prototype.\n *\n * @module\n */\n\n/** Returns the index of the first occurrence of the needle array in the source\n * array, or -1 if it is not present.\n *\n * A start index can be specified as the third argument that begins the search\n * at that given index. The start index defaults to the start of the array.\n *\n * The complexity of this function is O(source.lenth * needle.length).\n *\n * ```ts\n * import { indexOfNeedle } from \"./mod.ts\";\n * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);\n * const needle = new Uint8Array([1, 2]);\n * console.log(indexOfNeedle(source, needle)); // 1\n * console.log(indexOfNeedle(source, needle, 2)); // 3\n * ```\n */\nexport function indexOfNeedle(\n  source: Uint8Array,\n  needle: Uint8Array,\n  start = 0,\n): number {\n  if (start >= source.length) {\n    return -1;\n  }\n  if (start < 0) {\n    start = Math.max(0, source.length + start);\n  }\n  const s = needle[0];\n  for (let i = start; i < source.length; i++) {\n    if (source[i] !== s) continue;\n    const pin = i;\n    let matched = 1;\n    let j = i;\n    while (matched < needle.length) {\n      j++;\n      if (source[j] !== needle[j - pin]) {\n        break;\n      }\n      matched++;\n    }\n    if (matched === needle.length) {\n      return pin;\n    }\n  }\n  return -1;\n}\n\n/** Returns the index of the last occurrence of the needle array in the source\n * array, or -1 if it is not present.\n *\n * A start index can be specified as the third argument that begins the search\n * at that given index. The start index defaults to the end of the array.\n *\n * The complexity of this function is O(source.lenth * needle.length).\n *\n * ```ts\n * import { lastIndexOfNeedle } from \"./mod.ts\";\n * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);\n * const needle = new Uint8Array([1, 2]);\n * console.log(lastIndexOfNeedle(source, needle)); // 5\n * console.log(lastIndexOfNeedle(source, needle, 4)); // 3\n * ```\n */\nexport function lastIndexOfNeedle(\n  source: Uint8Array,\n  needle: Uint8Array,\n  start = source.length - 1,\n): number {\n  if (start < 0) {\n    return -1;\n  }\n  if (start >= source.length) {\n    start = source.length - 1;\n  }\n  const e = needle[needle.length - 1];\n  for (let i = start; i >= 0; i--) {\n    if (source[i] !== e) continue;\n    const pin = i;\n    let matched = 1;\n    let j = i;\n    while (matched < needle.length) {\n      j--;\n      if (source[j] !== needle[needle.length - 1 - (pin - j)]) {\n        break;\n      }\n      matched++;\n    }\n    if (matched === needle.length) {\n      return pin - needle.length + 1;\n    }\n  }\n  return -1;\n}\n\n/** Returns true if the prefix array appears at the start of the source array,\n * false otherwise.\n *\n * The complexity of this function is O(prefix.length).\n *\n * ```ts\n * import { startsWith } from \"./mod.ts\";\n * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);\n * const prefix = new Uint8Array([0, 1, 2]);\n * console.log(startsWith(source, prefix)); // true\n * ```\n */\nexport function startsWith(source: Uint8Array, prefix: Uint8Array): boolean {\n  for (let i = 0, max = prefix.length; i < max; i++) {\n    if (source[i] !== prefix[i]) return false;\n  }\n  return true;\n}\n\n/** Returns true if the suffix array appears at the end of the source array,\n * false otherwise.\n *\n * The complexity of this function is O(suffix.length).\n *\n * ```ts\n * import { endsWith } from \"./mod.ts\";\n * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);\n * const suffix = new Uint8Array([1, 2, 3]);\n * console.log(endsWith(source, suffix)); // true\n * ```\n */\nexport function endsWith(source: Uint8Array, suffix: Uint8Array): boolean {\n  for (\n    let srci = source.length - 1, sfxi = suffix.length - 1;\n    sfxi >= 0;\n    srci--, sfxi--\n  ) {\n    if (source[srci] !== suffix[sfxi]) return false;\n  }\n  return true;\n}\n\n/** Returns a new Uint8Array composed of `count` repetitions of the `source`\n * array.\n *\n * If `count` is negative, a `RangeError` is thrown.\n *\n * ```ts\n * import { repeat } from \"./mod.ts\";\n * const source = new Uint8Array([0, 1, 2]);\n * console.log(repeat(source, 3)); // [0, 1, 2, 0, 1, 2, 0, 1, 2]\n * console.log(repeat(source, 0)); // []\n * console.log(repeat(source, -1)); // RangeError\n * ```\n */\nexport function repeat(source: Uint8Array, count: number): Uint8Array {\n  if (count === 0) {\n    return new Uint8Array();\n  }\n\n  if (count < 0) {\n    throw new RangeError(\"bytes: negative repeat count\");\n  } else if ((source.length * count) / count !== source.length) {\n    throw new Error(\"bytes: repeat count causes overflow\");\n  }\n\n  const int = Math.floor(count);\n\n  if (int !== count) {\n    throw new Error(\"bytes: repeat count must be an integer\");\n  }\n\n  const nb = new Uint8Array(source.length * count);\n\n  let bp = copy(source, nb);\n\n  for (; bp < nb.length; bp *= 2) {\n    copy(nb.slice(0, bp), nb, bp);\n  }\n\n  return nb;\n}\n\n/** Concatenate the given arrays into a new Uint8Array.\n *\n * ```ts\n * import { concat } from \"./mod.ts\";\n * const a = new Uint8Array([0, 1, 2]);\n * const b = new Uint8Array([3, 4, 5]);\n * console.log(concat(a, b)); // [0, 1, 2, 3, 4, 5]\n */\nexport function concat(...buf: Uint8Array[]): Uint8Array {\n  let length = 0;\n  for (const b of buf) {\n    length += b.length;\n  }\n\n  const output = new Uint8Array(length);\n  let index = 0;\n  for (const b of buf) {\n    output.set(b, index);\n    index += b.length;\n  }\n\n  return output;\n}\n\n/** Returns true if the source array contains the needle array, false otherwise.\n *\n * A start index can be specified as the third argument that begins the search\n * at that given index. The start index defaults to the beginning of the array.\n *\n * The complexity of this function is O(source.length * needle.length).\n *\n * ```ts\n * import { includesNeedle } from \"./mod.ts\";\n * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);\n * const needle = new Uint8Array([1, 2]);\n * console.log(includesNeedle(source, needle)); // true\n * console.log(includesNeedle(source, needle, 6)); // false\n * ```\n */\nexport function includesNeedle(\n  source: Uint8Array,\n  needle: Uint8Array,\n  start = 0,\n): boolean {\n  return indexOfNeedle(source, needle, start) !== -1;\n}\n\n/** Copy bytes from the `src` array to the `dst` array. Returns the number of\n * bytes copied.\n *\n * If the `src` array is larger than what the `dst` array can hold, only the\n * amount of bytes that fit in the `dst` array are copied.\n *\n * An offset can be specified as the third argument that begins the copy at\n * that given index in the `dst` array. The offset defaults to the beginning of\n * the array.\n *\n * ```ts\n * import { copy } from \"./mod.ts\";\n * const src = new Uint8Array([9, 8, 7]);\n * const dst = new Uint8Array([0, 1, 2, 3, 4, 5]);\n * console.log(copy(src, dst)); // 3\n * console.log(dst); // [9, 8, 7, 3, 4, 5]\n * ```\n *\n * ```ts\n * import { copy } from \"./mod.ts\";\n * const src = new Uint8Array([1, 1, 1, 1]);\n * const dst = new Uint8Array([0, 0, 0, 0]);\n * console.log(copy(src, dst, 1)); // 3\n * console.log(dst); // [0, 1, 1, 1]\n * ```\n */\nexport function copy(src: Uint8Array, dst: Uint8Array, off = 0): number {\n  off = Math.max(0, Math.min(off, dst.byteLength));\n  const dstBytesAvailable = dst.byteLength - off;\n  if (src.byteLength > dstBytesAvailable) {\n    src = src.subarray(0, dstBytesAvailable);\n  }\n  dst.set(src, off);\n  return src.byteLength;\n}\n\nexport { equals } from \"./equals.ts\";\n"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/tests/__snapshots__/transpile/remote/modules/WzxVr2Q8XtUlLvHc6jsTVQR8Mnc.js b/tests/__snapshots__/transpile/remote/modules/WzxVr2Q8XtUlLvHc6jsTVQR8Mnc.js new file mode 100644 index 0000000..3767f70 --- /dev/null +++ b/tests/__snapshots__/transpile/remote/modules/WzxVr2Q8XtUlLvHc6jsTVQR8Mnc.js @@ -0,0 +1,47 @@ +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +// Copyright the Browserify authors. MIT License. +// Ported from https://github.com/browserify/path-browserify/ +// This module is browser compatible. +// Alphabet chars. +export const CHAR_UPPERCASE_A = 65; /* A */ +export const CHAR_LOWERCASE_A = 97; /* a */ +export const CHAR_UPPERCASE_Z = 90; /* Z */ +export const CHAR_LOWERCASE_Z = 122; /* z */ +// Non-alphabetic chars. +export const CHAR_DOT = 46; /* . */ +export const CHAR_FORWARD_SLASH = 47; /* / */ +export const CHAR_BACKWARD_SLASH = 92; /* \ */ +export const CHAR_VERTICAL_LINE = 124; /* | */ +export const CHAR_COLON = 58; /* : */ +export const CHAR_QUESTION_MARK = 63; /* ? */ +export const CHAR_UNDERSCORE = 95; /* _ */ +export const CHAR_LINE_FEED = 10; /* \n */ +export const CHAR_CARRIAGE_RETURN = 13; /* \r */ +export const CHAR_TAB = 9; /* \t */ +export const CHAR_FORM_FEED = 12; /* \f */ +export const CHAR_EXCLAMATION_MARK = 33; /* ! */ +export const CHAR_HASH = 35; /* # */ +export const CHAR_SPACE = 32; /* */ +export const CHAR_NO_BREAK_SPACE = 160; /* \u00A0 */ +export const CHAR_ZERO_WIDTH_NOBREAK_SPACE = 65279; /* \uFEFF */ +export const CHAR_LEFT_SQUARE_BRACKET = 91; /* [ */ +export const CHAR_RIGHT_SQUARE_BRACKET = 93; /* ] */ +export const CHAR_LEFT_ANGLE_BRACKET = 60; /* < */ +export const CHAR_RIGHT_ANGLE_BRACKET = 62; /* > */ +export const CHAR_LEFT_CURLY_BRACKET = 123; /* { */ +export const CHAR_RIGHT_CURLY_BRACKET = 125; /* } */ +export const CHAR_HYPHEN_MINUS = 45; /* - */ +export const CHAR_PLUS = 43; /* + */ +export const CHAR_DOUBLE_QUOTE = 34; /* " */ +export const CHAR_SINGLE_QUOTE = 39; /* ' */ +export const CHAR_PERCENT = 37; /* % */ +export const CHAR_SEMICOLON = 59; /* ; */ +export const CHAR_CIRCUMFLEX_ACCENT = 94; /* ^ */ +export const CHAR_GRAVE_ACCENT = 96; /* ` */ +export const CHAR_AT = 64; /* @ */ +export const CHAR_AMPERSAND = 38; /* & */ +export const CHAR_EQUAL = 61; /* = */ +// Digits +export const CHAR_0 = 48; /* 0 */ +export const CHAR_9 = 57; /* 9 */ +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImh0dHBzOi8vZGVuby5sYW5kL3N0ZEAwLjE0MC4wL3BhdGgvX2NvbnN0YW50cy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAxOC0yMDIyIHRoZSBEZW5vIGF1dGhvcnMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIE1JVCBsaWNlbnNlLlxuLy8gQ29weXJpZ2h0IHRoZSBCcm93c2VyaWZ5IGF1dGhvcnMuIE1JVCBMaWNlbnNlLlxuLy8gUG9ydGVkIGZyb20gaHR0cHM6Ly9naXRodWIuY29tL2Jyb3dzZXJpZnkvcGF0aC1icm93c2VyaWZ5L1xuLy8gVGhpcyBtb2R1bGUgaXMgYnJvd3NlciBjb21wYXRpYmxlLlxuXG4vLyBBbHBoYWJldCBjaGFycy5cbmV4cG9ydCBjb25zdCBDSEFSX1VQUEVSQ0FTRV9BID0gNjU7IC8qIEEgKi9cbmV4cG9ydCBjb25zdCBDSEFSX0xPV0VSQ0FTRV9BID0gOTc7IC8qIGEgKi9cbmV4cG9ydCBjb25zdCBDSEFSX1VQUEVSQ0FTRV9aID0gOTA7IC8qIFogKi9cbmV4cG9ydCBjb25zdCBDSEFSX0xPV0VSQ0FTRV9aID0gMTIyOyAvKiB6ICovXG5cbi8vIE5vbi1hbHBoYWJldGljIGNoYXJzLlxuZXhwb3J0IGNvbnN0IENIQVJfRE9UID0gNDY7IC8qIC4gKi9cbmV4cG9ydCBjb25zdCBDSEFSX0ZPUldBUkRfU0xBU0ggPSA0NzsgLyogLyAqL1xuZXhwb3J0IGNvbnN0IENIQVJfQkFDS1dBUkRfU0xBU0ggPSA5MjsgLyogXFwgKi9cbmV4cG9ydCBjb25zdCBDSEFSX1ZFUlRJQ0FMX0xJTkUgPSAxMjQ7IC8qIHwgKi9cbmV4cG9ydCBjb25zdCBDSEFSX0NPTE9OID0gNTg7IC8qIDogKi9cbmV4cG9ydCBjb25zdCBDSEFSX1FVRVNUSU9OX01BUksgPSA2MzsgLyogPyAqL1xuZXhwb3J0IGNvbnN0IENIQVJfVU5ERVJTQ09SRSA9IDk1OyAvKiBfICovXG5leHBvcnQgY29uc3QgQ0hBUl9MSU5FX0ZFRUQgPSAxMDsgLyogXFxuICovXG5leHBvcnQgY29uc3QgQ0hBUl9DQVJSSUFHRV9SRVRVUk4gPSAxMzsgLyogXFxyICovXG5leHBvcnQgY29uc3QgQ0hBUl9UQUIgPSA5OyAvKiBcXHQgKi9cbmV4cG9ydCBjb25zdCBDSEFSX0ZPUk1fRkVFRCA9IDEyOyAvKiBcXGYgKi9cbmV4cG9ydCBjb25zdCBDSEFSX0VYQ0xBTUFUSU9OX01BUksgPSAzMzsgLyogISAqL1xuZXhwb3J0IGNvbnN0IENIQVJfSEFTSCA9IDM1OyAvKiAjICovXG5leHBvcnQgY29uc3QgQ0hBUl9TUEFDRSA9IDMyOyAvKiAgICovXG5leHBvcnQgY29uc3QgQ0hBUl9OT19CUkVBS19TUEFDRSA9IDE2MDsgLyogXFx1MDBBMCAqL1xuZXhwb3J0IGNvbnN0IENIQVJfWkVST19XSURUSF9OT0JSRUFLX1NQQUNFID0gNjUyNzk7IC8qIFxcdUZFRkYgKi9cbmV4cG9ydCBjb25zdCBDSEFSX0xFRlRfU1FVQVJFX0JSQUNLRVQgPSA5MTsgLyogWyAqL1xuZXhwb3J0IGNvbnN0IENIQVJfUklHSFRfU1FVQVJFX0JSQUNLRVQgPSA5MzsgLyogXSAqL1xuZXhwb3J0IGNvbnN0IENIQVJfTEVGVF9BTkdMRV9CUkFDS0VUID0gNjA7IC8qIDwgKi9cbmV4cG9ydCBjb25zdCBDSEFSX1JJR0hUX0FOR0xFX0JSQUNLRVQgPSA2MjsgLyogPiAqL1xuZXhwb3J0IGNvbnN0IENIQVJfTEVGVF9DVVJMWV9CUkFDS0VUID0gMTIzOyAvKiB7ICovXG5leHBvcnQgY29uc3QgQ0hBUl9SSUdIVF9DVVJMWV9CUkFDS0VUID0gMTI1OyAvKiB9ICovXG5leHBvcnQgY29uc3QgQ0hBUl9IWVBIRU5fTUlOVVMgPSA0NTsgLyogLSAqL1xuZXhwb3J0IGNvbnN0IENIQVJfUExVUyA9IDQzOyAvKiArICovXG5leHBvcnQgY29uc3QgQ0hBUl9ET1VCTEVfUVVPVEUgPSAzNDsgLyogXCIgKi9cbmV4cG9ydCBjb25zdCBDSEFSX1NJTkdMRV9RVU9URSA9IDM5OyAvKiAnICovXG5leHBvcnQgY29uc3QgQ0hBUl9QRVJDRU5UID0gMzc7IC8qICUgKi9cbmV4cG9ydCBjb25zdCBDSEFSX1NFTUlDT0xPTiA9IDU5OyAvKiA7ICovXG5leHBvcnQgY29uc3QgQ0hBUl9DSVJDVU1GTEVYX0FDQ0VOVCA9IDk0OyAvKiBeICovXG5leHBvcnQgY29uc3QgQ0hBUl9HUkFWRV9BQ0NFTlQgPSA5NjsgLyogYCAqL1xuZXhwb3J0IGNvbnN0IENIQVJfQVQgPSA2NDsgLyogQCAqL1xuZXhwb3J0IGNvbnN0IENIQVJfQU1QRVJTQU5EID0gMzg7IC8qICYgKi9cbmV4cG9ydCBjb25zdCBDSEFSX0VRVUFMID0gNjE7IC8qID0gKi9cblxuLy8gRGlnaXRzXG5leHBvcnQgY29uc3QgQ0hBUl8wID0gNDg7IC8qIDAgKi9cbmV4cG9ydCBjb25zdCBDSEFSXzkgPSA1NzsgLyogOSAqL1xuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDBFQUEwRTtBQUMxRSxpREFBaUQ7QUFDakQsNkRBQTZEO0FBQzdELHFDQUFxQztBQUVyQyxrQkFBa0I7QUFDbEIsT0FBTyxNQUFNLG1CQUFtQixHQUFHLENBQUMsS0FBSztBQUN6QyxPQUFPLE1BQU0sbUJBQW1CLEdBQUcsQ0FBQyxLQUFLO0FBQ3pDLE9BQU8sTUFBTSxtQkFBbUIsR0FBRyxDQUFDLEtBQUs7QUFDekMsT0FBTyxNQUFNLG1CQUFtQixJQUFJLENBQUMsS0FBSztBQUUxQyx3QkFBd0I7QUFDeEIsT0FBTyxNQUFNLFdBQVcsR0FBRyxDQUFDLEtBQUs7QUFDakMsT0FBTyxNQUFNLHFCQUFxQixHQUFHLENBQUMsS0FBSztBQUMzQyxPQUFPLE1BQU0sc0JBQXNCLEdBQUcsQ0FBQyxLQUFLO0FBQzVDLE9BQU8sTUFBTSxxQkFBcUIsSUFBSSxDQUFDLEtBQUs7QUFDNUMsT0FBTyxNQUFNLGFBQWEsR0FBRyxDQUFDLEtBQUs7QUFDbkMsT0FBTyxNQUFNLHFCQUFxQixHQUFHLENBQUMsS0FBSztBQUMzQyxPQUFPLE1BQU0sa0JBQWtCLEdBQUcsQ0FBQyxLQUFLO0FBQ3hDLE9BQU8sTUFBTSxpQkFBaUIsR0FBRyxDQUFDLE1BQU07QUFDeEMsT0FBTyxNQUFNLHVCQUF1QixHQUFHLENBQUMsTUFBTTtBQUM5QyxPQUFPLE1BQU0sV0FBVyxFQUFFLENBQUMsTUFBTTtBQUNqQyxPQUFPLE1BQU0saUJBQWlCLEdBQUcsQ0FBQyxNQUFNO0FBQ3hDLE9BQU8sTUFBTSx3QkFBd0IsR0FBRyxDQUFDLEtBQUs7QUFDOUMsT0FBTyxNQUFNLFlBQVksR0FBRyxDQUFDLEtBQUs7QUFDbEMsT0FBTyxNQUFNLGFBQWEsR0FBRyxDQUFDLEtBQUs7QUFDbkMsT0FBTyxNQUFNLHNCQUFzQixJQUFJLENBQUMsVUFBVTtBQUNsRCxPQUFPLE1BQU0sZ0NBQWdDLE1BQU0sQ0FBQyxVQUFVO0FBQzlELE9BQU8sTUFBTSwyQkFBMkIsR0FBRyxDQUFDLEtBQUs7QUFDakQsT0FBTyxNQUFNLDRCQUE0QixHQUFHLENBQUMsS0FBSztBQUNsRCxPQUFPLE1BQU0sMEJBQTBCLEdBQUcsQ0FBQyxLQUFLO0FBQ2hELE9BQU8sTUFBTSwyQkFBMkIsR0FBRyxDQUFDLEtBQUs7QUFDakQsT0FBTyxNQUFNLDBCQUEwQixJQUFJLENBQUMsS0FBSztBQUNqRCxPQUFPLE1BQU0sMkJBQTJCLElBQUksQ0FBQyxLQUFLO0FBQ2xELE9BQU8sTUFBTSxvQkFBb0IsR0FBRyxDQUFDLEtBQUs7QUFDMUMsT0FBTyxNQUFNLFlBQVksR0FBRyxDQUFDLEtBQUs7QUFDbEMsT0FBTyxNQUFNLG9CQUFvQixHQUFHLENBQUMsS0FBSztBQUMxQyxPQUFPLE1BQU0sb0JBQW9CLEdBQUcsQ0FBQyxLQUFLO0FBQzFDLE9BQU8sTUFBTSxlQUFlLEdBQUcsQ0FBQyxLQUFLO0FBQ3JDLE9BQU8sTUFBTSxpQkFBaUIsR0FBRyxDQUFDLEtBQUs7QUFDdkMsT0FBTyxNQUFNLHlCQUF5QixHQUFHLENBQUMsS0FBSztBQUMvQyxPQUFPLE1BQU0sb0JBQW9CLEdBQUcsQ0FBQyxLQUFLO0FBQzFDLE9BQU8sTUFBTSxVQUFVLEdBQUcsQ0FBQyxLQUFLO0FBQ2hDLE9BQU8sTUFBTSxpQkFBaUIsR0FBRyxDQUFDLEtBQUs7QUFDdkMsT0FBTyxNQUFNLGFBQWEsR0FBRyxDQUFDLEtBQUs7QUFFbkMsU0FBUztBQUNULE9BQU8sTUFBTSxTQUFTLEdBQUcsQ0FBQyxLQUFLO0FBQy9CLE9BQU8sTUFBTSxTQUFTLEdBQUcsQ0FBQyxLQUFLIn0= \ No newline at end of file diff --git a/tests/__snapshots__/transpile/remote/modules/ZD3DgFZlCOXbEC8b6k6GmMtkN3g.js b/tests/__snapshots__/transpile/remote/modules/ZD3DgFZlCOXbEC8b6k6GmMtkN3g.js new file mode 100644 index 0000000..0fdef86 --- /dev/null +++ b/tests/__snapshots__/transpile/remote/modules/ZD3DgFZlCOXbEC8b6k6GmMtkN3g.js @@ -0,0 +1,430 @@ +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +import { Buffer } from "../io/buffer.ts"; +const DEFAULT_CHUNK_SIZE = 16_640; +const DEFAULT_BUFFER_SIZE = 32 * 1024; +function isCloser(value) { + return typeof value === "object" && value != null && "close" in value && // deno-lint-ignore no-explicit-any + typeof value["close"] === "function"; +} +/** Create a `Deno.Reader` from an iterable of `Uint8Array`s. + * + * ```ts + * import { readerFromIterable } from "./conversion.ts"; + * + * const file = await Deno.open("metrics.txt", { write: true }); + * const reader = readerFromIterable((async function* () { + * while (true) { + * await new Promise((r) => setTimeout(r, 1000)); + * const message = `data: ${JSON.stringify(Deno.metrics())}\n\n`; + * yield new TextEncoder().encode(message); + * } + * })()); + * await Deno.copy(reader, file); + * ``` + */ export function readerFromIterable(iterable) { + const iterator = iterable[Symbol.asyncIterator]?.() ?? iterable[Symbol.iterator]?.(); + const buffer = new Buffer(); + return { + async read (p) { + if (buffer.length == 0) { + const result = await iterator.next(); + if (result.done) { + return null; + } else { + if (result.value.byteLength <= p.byteLength) { + p.set(result.value); + return result.value.byteLength; + } + p.set(result.value.subarray(0, p.byteLength)); + await writeAll(buffer, result.value.subarray(p.byteLength)); + return p.byteLength; + } + } else { + const n = await buffer.read(p); + if (n == null) { + return this.read(p); + } + return n; + } + } + }; +} +/** Create a `Writer` from a `WritableStreamDefaultWriter`. */ export function writerFromStreamWriter(streamWriter) { + return { + async write (p) { + await streamWriter.ready; + await streamWriter.write(p); + return p.length; + } + }; +} +/** Create a `Reader` from a `ReadableStreamDefaultReader`. */ export function readerFromStreamReader(streamReader) { + const buffer = new Buffer(); + return { + async read (p) { + if (buffer.empty()) { + const res = await streamReader.read(); + if (res.done) { + return null; // EOF + } + await writeAll(buffer, res.value); + } + return buffer.read(p); + } + }; +} +/** Create a `WritableStream` from a `Writer`. */ export function writableStreamFromWriter(writer, options = {}) { + const { autoClose =true } = options; + return new WritableStream({ + async write (chunk, controller) { + try { + await writeAll(writer, chunk); + } catch (e) { + controller.error(e); + if (isCloser(writer) && autoClose) { + writer.close(); + } + } + }, + close () { + if (isCloser(writer) && autoClose) { + writer.close(); + } + }, + abort () { + if (isCloser(writer) && autoClose) { + writer.close(); + } + } + }); +} +/** Create a `ReadableStream` from any kind of iterable. + * + * ```ts + * import { readableStreamFromIterable } from "./conversion.ts"; + * + * const r1 = readableStreamFromIterable(["foo, bar, baz"]); + * const r2 = readableStreamFromIterable(async function* () { + * await new Promise(((r) => setTimeout(r, 1000))); + * yield "foo"; + * await new Promise(((r) => setTimeout(r, 1000))); + * yield "bar"; + * await new Promise(((r) => setTimeout(r, 1000))); + * yield "baz"; + * }()); + * ``` + * + * If the produced iterator (`iterable[Symbol.asyncIterator]()` or + * `iterable[Symbol.iterator]()`) is a generator, or more specifically is found + * to have a `.throw()` method on it, that will be called upon + * `readableStream.cancel()`. This is the case for the second input type above: + * + * ```ts + * import { readableStreamFromIterable } from "./conversion.ts"; + * + * const r3 = readableStreamFromIterable(async function* () { + * try { + * yield "foo"; + * } catch (error) { + * console.log(error); // Error: Cancelled by consumer. + * } + * }()); + * const reader = r3.getReader(); + * console.log(await reader.read()); // { value: "foo", done: false } + * await reader.cancel(new Error("Cancelled by consumer.")); + * ``` + */ export function readableStreamFromIterable(iterable) { + const iterator = iterable[Symbol.asyncIterator]?.() ?? iterable[Symbol.iterator]?.(); + return new ReadableStream({ + async pull (controller) { + const { value , done } = await iterator.next(); + if (done) { + controller.close(); + } else { + controller.enqueue(value); + } + }, + async cancel (reason) { + if (typeof iterator.throw == "function") { + try { + await iterator.throw(reason); + } catch {} + } + } + }); +} +/** + * Create a `ReadableStream` from from a `Deno.Reader`. + * + * When the pull algorithm is called on the stream, a chunk from the reader + * will be read. When `null` is returned from the reader, the stream will be + * closed along with the reader (if it is also a `Deno.Closer`). + * + * An example converting a `Deno.FsFile` into a readable stream: + * + * ```ts + * import { readableStreamFromReader } from "./mod.ts"; + * + * const file = await Deno.open("./file.txt", { read: true }); + * const fileStream = readableStreamFromReader(file); + * ``` + */ export function readableStreamFromReader(reader, options = {}) { + const { autoClose =true , chunkSize =DEFAULT_CHUNK_SIZE , strategy } = options; + return new ReadableStream({ + async pull (controller) { + const chunk = new Uint8Array(chunkSize); + try { + const read = await reader.read(chunk); + if (read === null) { + if (isCloser(reader) && autoClose) { + reader.close(); + } + controller.close(); + return; + } + controller.enqueue(chunk.subarray(0, read)); + } catch (e) { + controller.error(e); + if (isCloser(reader)) { + reader.close(); + } + } + }, + cancel () { + if (isCloser(reader) && autoClose) { + reader.close(); + } + } + }, strategy); +} +/** Read Reader `r` until EOF (`null`) and resolve to the content as + * Uint8Array`. + * + * ```ts + * import { Buffer } from "../io/buffer.ts"; + * import { readAll } from "./conversion.ts"; + * + * // Example from stdin + * const stdinContent = await readAll(Deno.stdin); + * + * // Example from file + * const file = await Deno.open("my_file.txt", {read: true}); + * const myFileContent = await readAll(file); + * Deno.close(file.rid); + * + * // Example from buffer + * const myData = new Uint8Array(100); + * // ... fill myData array with data + * const reader = new Buffer(myData.buffer); + * const bufferContent = await readAll(reader); + * ``` + */ export async function readAll(r) { + const buf = new Buffer(); + await buf.readFrom(r); + return buf.bytes(); +} +/** Synchronously reads Reader `r` until EOF (`null`) and returns the content + * as `Uint8Array`. + * + * ```ts + * import { Buffer } from "../io/buffer.ts"; + * import { readAllSync } from "./conversion.ts"; + * + * // Example from stdin + * const stdinContent = readAllSync(Deno.stdin); + * + * // Example from file + * const file = Deno.openSync("my_file.txt", {read: true}); + * const myFileContent = readAllSync(file); + * Deno.close(file.rid); + * + * // Example from buffer + * const myData = new Uint8Array(100); + * // ... fill myData array with data + * const reader = new Buffer(myData.buffer); + * const bufferContent = readAllSync(reader); + * ``` + */ export function readAllSync(r) { + const buf = new Buffer(); + buf.readFromSync(r); + return buf.bytes(); +} +/** Write all the content of the array buffer (`arr`) to the writer (`w`). + * + * ```ts + * import { Buffer } from "../io/buffer.ts"; + * import { writeAll } from "./conversion.ts"; + + * // Example writing to stdout + * let contentBytes = new TextEncoder().encode("Hello World"); + * await writeAll(Deno.stdout, contentBytes); + * + * // Example writing to file + * contentBytes = new TextEncoder().encode("Hello World"); + * const file = await Deno.open('test.file', {write: true}); + * await writeAll(file, contentBytes); + * Deno.close(file.rid); + * + * // Example writing to buffer + * contentBytes = new TextEncoder().encode("Hello World"); + * const writer = new Buffer(); + * await writeAll(writer, contentBytes); + * console.log(writer.bytes().length); // 11 + * ``` + */ export async function writeAll(w, arr) { + let nwritten = 0; + while(nwritten < arr.length){ + nwritten += await w.write(arr.subarray(nwritten)); + } +} +/** Synchronously write all the content of the array buffer (`arr`) to the + * writer (`w`). + * + * ```ts + * import { Buffer } from "../io/buffer.ts"; + * import { writeAllSync } from "./conversion.ts"; + * + * // Example writing to stdout + * let contentBytes = new TextEncoder().encode("Hello World"); + * writeAllSync(Deno.stdout, contentBytes); + * + * // Example writing to file + * contentBytes = new TextEncoder().encode("Hello World"); + * const file = Deno.openSync('test.file', {write: true}); + * writeAllSync(file, contentBytes); + * Deno.close(file.rid); + * + * // Example writing to buffer + * contentBytes = new TextEncoder().encode("Hello World"); + * const writer = new Buffer(); + * writeAllSync(writer, contentBytes); + * console.log(writer.bytes().length); // 11 + * ``` + */ export function writeAllSync(w, arr) { + let nwritten = 0; + while(nwritten < arr.length){ + nwritten += w.writeSync(arr.subarray(nwritten)); + } +} +/** Turns a Reader, `r`, into an async iterator. + * + * ```ts + * import { iterateReader } from "./conversion.ts"; + * + * let f = await Deno.open("/etc/passwd"); + * for await (const chunk of iterateReader(f)) { + * console.log(chunk); + * } + * f.close(); + * ``` + * + * Second argument can be used to tune size of a buffer. + * Default size of the buffer is 32kB. + * + * ```ts + * import { iterateReader } from "./conversion.ts"; + * + * let f = await Deno.open("/etc/passwd"); + * const it = iterateReader(f, { + * bufSize: 1024 * 1024 + * }); + * for await (const chunk of it) { + * console.log(chunk); + * } + * f.close(); + * ``` + * + * Iterator uses an internal buffer of fixed size for efficiency; it returns + * a view on that buffer on each iteration. It is therefore caller's + * responsibility to copy contents of the buffer if needed; otherwise the + * next iteration will overwrite contents of previously returned chunk. + */ export async function* iterateReader(r, options) { + const bufSize = options?.bufSize ?? DEFAULT_BUFFER_SIZE; + const b = new Uint8Array(bufSize); + while(true){ + const result = await r.read(b); + if (result === null) { + break; + } + yield b.subarray(0, result); + } +} +/** Turns a ReaderSync, `r`, into an iterator. + * + * ```ts + * import { iterateReaderSync } from "./conversion.ts"; + * + * let f = Deno.openSync("/etc/passwd"); + * for (const chunk of iterateReaderSync(f)) { + * console.log(chunk); + * } + * f.close(); + * ``` + * + * Second argument can be used to tune size of a buffer. + * Default size of the buffer is 32kB. + * + * ```ts + * import { iterateReaderSync } from "./conversion.ts"; + + * let f = await Deno.open("/etc/passwd"); + * const iter = iterateReaderSync(f, { + * bufSize: 1024 * 1024 + * }); + * for (const chunk of iter) { + * console.log(chunk); + * } + * f.close(); + * ``` + * + * Iterator uses an internal buffer of fixed size for efficiency; it returns + * a view on that buffer on each iteration. It is therefore caller's + * responsibility to copy contents of the buffer if needed; otherwise the + * next iteration will overwrite contents of previously returned chunk. + */ export function* iterateReaderSync(r, options) { + const bufSize = options?.bufSize ?? DEFAULT_BUFFER_SIZE; + const b = new Uint8Array(bufSize); + while(true){ + const result = r.readSync(b); + if (result === null) { + break; + } + yield b.subarray(0, result); + } +} +/** Copies from `src` to `dst` until either EOF (`null`) is read from `src` or + * an error occurs. It resolves to the number of bytes copied or rejects with + * the first error encountered while copying. + * + * ```ts + * import { copy } from "./conversion.ts"; + * + * const source = await Deno.open("my_file.txt"); + * const bytesCopied1 = await copy(source, Deno.stdout); + * const destination = await Deno.create("my_file_2.txt"); + * const bytesCopied2 = await copy(source, destination); + * ``` + * + * @param src The source to copy from + * @param dst The destination to copy to + * @param options Can be used to tune size of the buffer. Default size is 32kB + */ export async function copy(src, dst, options) { + let n = 0; + const bufSize = options?.bufSize ?? DEFAULT_BUFFER_SIZE; + const b = new Uint8Array(bufSize); + let gotEOF = false; + while(gotEOF === false){ + const result = await src.read(b); + if (result === null) { + gotEOF = true; + } else { + let nwritten = 0; + while(nwritten < result){ + nwritten += await dst.write(b.subarray(nwritten, result)); + } + n += nwritten; + } + } + return n; +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["https://deno.land/std@0.140.0/streams/conversion.ts"],"sourcesContent":["// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.\n\nimport { Buffer } from \"../io/buffer.ts\";\n\nconst DEFAULT_CHUNK_SIZE = 16_640;\nconst DEFAULT_BUFFER_SIZE = 32 * 1024;\n\nfunction isCloser(value: unknown): value is Deno.Closer {\n  return typeof value === \"object\" && value != null && \"close\" in value &&\n    // deno-lint-ignore no-explicit-any\n    typeof (value as Record<string, any>)[\"close\"] === \"function\";\n}\n\n/** Create a `Deno.Reader` from an iterable of `Uint8Array`s.\n *\n * ```ts\n *      import { readerFromIterable } from \"./conversion.ts\";\n *\n *      const file = await Deno.open(\"metrics.txt\", { write: true });\n *      const reader = readerFromIterable((async function* () {\n *        while (true) {\n *          await new Promise((r) => setTimeout(r, 1000));\n *          const message = `data: ${JSON.stringify(Deno.metrics())}\\n\\n`;\n *          yield new TextEncoder().encode(message);\n *        }\n *      })());\n *      await Deno.copy(reader, file);\n * ```\n */\nexport function readerFromIterable(\n  iterable: Iterable<Uint8Array> | AsyncIterable<Uint8Array>,\n): Deno.Reader {\n  const iterator: Iterator<Uint8Array> | AsyncIterator<Uint8Array> =\n    (iterable as AsyncIterable<Uint8Array>)[Symbol.asyncIterator]?.() ??\n      (iterable as Iterable<Uint8Array>)[Symbol.iterator]?.();\n  const buffer = new Buffer();\n  return {\n    async read(p: Uint8Array): Promise<number | null> {\n      if (buffer.length == 0) {\n        const result = await iterator.next();\n        if (result.done) {\n          return null;\n        } else {\n          if (result.value.byteLength <= p.byteLength) {\n            p.set(result.value);\n            return result.value.byteLength;\n          }\n          p.set(result.value.subarray(0, p.byteLength));\n          await writeAll(buffer, result.value.subarray(p.byteLength));\n          return p.byteLength;\n        }\n      } else {\n        const n = await buffer.read(p);\n        if (n == null) {\n          return this.read(p);\n        }\n        return n;\n      }\n    },\n  };\n}\n\n/** Create a `Writer` from a `WritableStreamDefaultWriter`. */\nexport function writerFromStreamWriter(\n  streamWriter: WritableStreamDefaultWriter<Uint8Array>,\n): Deno.Writer {\n  return {\n    async write(p: Uint8Array): Promise<number> {\n      await streamWriter.ready;\n      await streamWriter.write(p);\n      return p.length;\n    },\n  };\n}\n\n/** Create a `Reader` from a `ReadableStreamDefaultReader`. */\nexport function readerFromStreamReader(\n  streamReader: ReadableStreamDefaultReader<Uint8Array>,\n): Deno.Reader {\n  const buffer = new Buffer();\n\n  return {\n    async read(p: Uint8Array): Promise<number | null> {\n      if (buffer.empty()) {\n        const res = await streamReader.read();\n        if (res.done) {\n          return null; // EOF\n        }\n\n        await writeAll(buffer, res.value);\n      }\n\n      return buffer.read(p);\n    },\n  };\n}\n\nexport interface WritableStreamFromWriterOptions {\n  /**\n   * If the `writer` is also a `Deno.Closer`, automatically close the `writer`\n   * when the stream is closed, aborted, or a write error occurs.\n   *\n   * Defaults to `true`. */\n  autoClose?: boolean;\n}\n\n/** Create a `WritableStream` from a `Writer`. */\nexport function writableStreamFromWriter(\n  writer: Deno.Writer,\n  options: WritableStreamFromWriterOptions = {},\n): WritableStream<Uint8Array> {\n  const { autoClose = true } = options;\n\n  return new WritableStream({\n    async write(chunk, controller) {\n      try {\n        await writeAll(writer, chunk);\n      } catch (e) {\n        controller.error(e);\n        if (isCloser(writer) && autoClose) {\n          writer.close();\n        }\n      }\n    },\n    close() {\n      if (isCloser(writer) && autoClose) {\n        writer.close();\n      }\n    },\n    abort() {\n      if (isCloser(writer) && autoClose) {\n        writer.close();\n      }\n    },\n  });\n}\n\n/** Create a `ReadableStream` from any kind of iterable.\n *\n * ```ts\n *      import { readableStreamFromIterable } from \"./conversion.ts\";\n *\n *      const r1 = readableStreamFromIterable([\"foo, bar, baz\"]);\n *      const r2 = readableStreamFromIterable(async function* () {\n *        await new Promise(((r) => setTimeout(r, 1000)));\n *        yield \"foo\";\n *        await new Promise(((r) => setTimeout(r, 1000)));\n *        yield \"bar\";\n *        await new Promise(((r) => setTimeout(r, 1000)));\n *        yield \"baz\";\n *      }());\n * ```\n *\n * If the produced iterator (`iterable[Symbol.asyncIterator]()` or\n * `iterable[Symbol.iterator]()`) is a generator, or more specifically is found\n * to have a `.throw()` method on it, that will be called upon\n * `readableStream.cancel()`. This is the case for the second input type above:\n *\n * ```ts\n * import { readableStreamFromIterable } from \"./conversion.ts\";\n *\n * const r3 = readableStreamFromIterable(async function* () {\n *   try {\n *     yield \"foo\";\n *   } catch (error) {\n *     console.log(error); // Error: Cancelled by consumer.\n *   }\n * }());\n * const reader = r3.getReader();\n * console.log(await reader.read()); // { value: \"foo\", done: false }\n * await reader.cancel(new Error(\"Cancelled by consumer.\"));\n * ```\n */\nexport function readableStreamFromIterable<T>(\n  iterable: Iterable<T> | AsyncIterable<T>,\n): ReadableStream<T> {\n  const iterator: Iterator<T> | AsyncIterator<T> =\n    (iterable as AsyncIterable<T>)[Symbol.asyncIterator]?.() ??\n      (iterable as Iterable<T>)[Symbol.iterator]?.();\n  return new ReadableStream({\n    async pull(controller) {\n      const { value, done } = await iterator.next();\n      if (done) {\n        controller.close();\n      } else {\n        controller.enqueue(value);\n      }\n    },\n    async cancel(reason) {\n      if (typeof iterator.throw == \"function\") {\n        try {\n          await iterator.throw(reason);\n        } catch { /* `iterator.throw()` always throws on site. We catch it. */ }\n      }\n    },\n  });\n}\n\nexport interface ReadableStreamFromReaderOptions {\n  /** If the `reader` is also a `Deno.Closer`, automatically close the `reader`\n   * when `EOF` is encountered, or a read error occurs.\n   *\n   * Defaults to `true`. */\n  autoClose?: boolean;\n\n  /** The size of chunks to allocate to read, the default is ~16KiB, which is\n   * the maximum size that Deno operations can currently support. */\n  chunkSize?: number;\n\n  /** The queuing strategy to create the `ReadableStream` with. */\n  strategy?: { highWaterMark?: number | undefined; size?: undefined };\n}\n\n/**\n * Create a `ReadableStream<Uint8Array>` from from a `Deno.Reader`.\n *\n * When the pull algorithm is called on the stream, a chunk from the reader\n * will be read.  When `null` is returned from the reader, the stream will be\n * closed along with the reader (if it is also a `Deno.Closer`).\n *\n * An example converting a `Deno.FsFile` into a readable stream:\n *\n * ```ts\n * import { readableStreamFromReader } from \"./mod.ts\";\n *\n * const file = await Deno.open(\"./file.txt\", { read: true });\n * const fileStream = readableStreamFromReader(file);\n * ```\n */\nexport function readableStreamFromReader(\n  reader: Deno.Reader | (Deno.Reader & Deno.Closer),\n  options: ReadableStreamFromReaderOptions = {},\n): ReadableStream<Uint8Array> {\n  const {\n    autoClose = true,\n    chunkSize = DEFAULT_CHUNK_SIZE,\n    strategy,\n  } = options;\n\n  return new ReadableStream({\n    async pull(controller) {\n      const chunk = new Uint8Array(chunkSize);\n      try {\n        const read = await reader.read(chunk);\n        if (read === null) {\n          if (isCloser(reader) && autoClose) {\n            reader.close();\n          }\n          controller.close();\n          return;\n        }\n        controller.enqueue(chunk.subarray(0, read));\n      } catch (e) {\n        controller.error(e);\n        if (isCloser(reader)) {\n          reader.close();\n        }\n      }\n    },\n    cancel() {\n      if (isCloser(reader) && autoClose) {\n        reader.close();\n      }\n    },\n  }, strategy);\n}\n\n/** Read Reader `r` until EOF (`null`) and resolve to the content as\n * Uint8Array`.\n *\n * ```ts\n * import { Buffer } from \"../io/buffer.ts\";\n * import { readAll } from \"./conversion.ts\";\n *\n * // Example from stdin\n * const stdinContent = await readAll(Deno.stdin);\n *\n * // Example from file\n * const file = await Deno.open(\"my_file.txt\", {read: true});\n * const myFileContent = await readAll(file);\n * Deno.close(file.rid);\n *\n * // Example from buffer\n * const myData = new Uint8Array(100);\n * // ... fill myData array with data\n * const reader = new Buffer(myData.buffer);\n * const bufferContent = await readAll(reader);\n * ```\n */\nexport async function readAll(r: Deno.Reader): Promise<Uint8Array> {\n  const buf = new Buffer();\n  await buf.readFrom(r);\n  return buf.bytes();\n}\n\n/** Synchronously reads Reader `r` until EOF (`null`) and returns the content\n * as `Uint8Array`.\n *\n * ```ts\n * import { Buffer } from \"../io/buffer.ts\";\n * import { readAllSync } from \"./conversion.ts\";\n *\n * // Example from stdin\n * const stdinContent = readAllSync(Deno.stdin);\n *\n * // Example from file\n * const file = Deno.openSync(\"my_file.txt\", {read: true});\n * const myFileContent = readAllSync(file);\n * Deno.close(file.rid);\n *\n * // Example from buffer\n * const myData = new Uint8Array(100);\n * // ... fill myData array with data\n * const reader = new Buffer(myData.buffer);\n * const bufferContent = readAllSync(reader);\n * ```\n */\nexport function readAllSync(r: Deno.ReaderSync): Uint8Array {\n  const buf = new Buffer();\n  buf.readFromSync(r);\n  return buf.bytes();\n}\n\n/** Write all the content of the array buffer (`arr`) to the writer (`w`).\n *\n * ```ts\n * import { Buffer } from \"../io/buffer.ts\";\n * import { writeAll } from \"./conversion.ts\";\n\n * // Example writing to stdout\n * let contentBytes = new TextEncoder().encode(\"Hello World\");\n * await writeAll(Deno.stdout, contentBytes);\n *\n * // Example writing to file\n * contentBytes = new TextEncoder().encode(\"Hello World\");\n * const file = await Deno.open('test.file', {write: true});\n * await writeAll(file, contentBytes);\n * Deno.close(file.rid);\n *\n * // Example writing to buffer\n * contentBytes = new TextEncoder().encode(\"Hello World\");\n * const writer = new Buffer();\n * await writeAll(writer, contentBytes);\n * console.log(writer.bytes().length);  // 11\n * ```\n */\nexport async function writeAll(w: Deno.Writer, arr: Uint8Array) {\n  let nwritten = 0;\n  while (nwritten < arr.length) {\n    nwritten += await w.write(arr.subarray(nwritten));\n  }\n}\n\n/** Synchronously write all the content of the array buffer (`arr`) to the\n * writer (`w`).\n *\n * ```ts\n * import { Buffer } from \"../io/buffer.ts\";\n * import { writeAllSync } from \"./conversion.ts\";\n *\n * // Example writing to stdout\n * let contentBytes = new TextEncoder().encode(\"Hello World\");\n * writeAllSync(Deno.stdout, contentBytes);\n *\n * // Example writing to file\n * contentBytes = new TextEncoder().encode(\"Hello World\");\n * const file = Deno.openSync('test.file', {write: true});\n * writeAllSync(file, contentBytes);\n * Deno.close(file.rid);\n *\n * // Example writing to buffer\n * contentBytes = new TextEncoder().encode(\"Hello World\");\n * const writer = new Buffer();\n * writeAllSync(writer, contentBytes);\n * console.log(writer.bytes().length);  // 11\n * ```\n */\nexport function writeAllSync(w: Deno.WriterSync, arr: Uint8Array): void {\n  let nwritten = 0;\n  while (nwritten < arr.length) {\n    nwritten += w.writeSync(arr.subarray(nwritten));\n  }\n}\n\n/** Turns a Reader, `r`, into an async iterator.\n *\n * ```ts\n * import { iterateReader } from \"./conversion.ts\";\n *\n * let f = await Deno.open(\"/etc/passwd\");\n * for await (const chunk of iterateReader(f)) {\n *   console.log(chunk);\n * }\n * f.close();\n * ```\n *\n * Second argument can be used to tune size of a buffer.\n * Default size of the buffer is 32kB.\n *\n * ```ts\n * import { iterateReader } from \"./conversion.ts\";\n *\n * let f = await Deno.open(\"/etc/passwd\");\n * const it = iterateReader(f, {\n *   bufSize: 1024 * 1024\n * });\n * for await (const chunk of it) {\n *   console.log(chunk);\n * }\n * f.close();\n * ```\n *\n * Iterator uses an internal buffer of fixed size for efficiency; it returns\n * a view on that buffer on each iteration. It is therefore caller's\n * responsibility to copy contents of the buffer if needed; otherwise the\n * next iteration will overwrite contents of previously returned chunk.\n */\nexport async function* iterateReader(\n  r: Deno.Reader,\n  options?: {\n    bufSize?: number;\n  },\n): AsyncIterableIterator<Uint8Array> {\n  const bufSize = options?.bufSize ?? DEFAULT_BUFFER_SIZE;\n  const b = new Uint8Array(bufSize);\n  while (true) {\n    const result = await r.read(b);\n    if (result === null) {\n      break;\n    }\n\n    yield b.subarray(0, result);\n  }\n}\n\n/** Turns a ReaderSync, `r`, into an iterator.\n *\n * ```ts\n * import { iterateReaderSync } from \"./conversion.ts\";\n *\n * let f = Deno.openSync(\"/etc/passwd\");\n * for (const chunk of iterateReaderSync(f)) {\n *   console.log(chunk);\n * }\n * f.close();\n * ```\n *\n * Second argument can be used to tune size of a buffer.\n * Default size of the buffer is 32kB.\n *\n * ```ts\n * import { iterateReaderSync } from \"./conversion.ts\";\n\n * let f = await Deno.open(\"/etc/passwd\");\n * const iter = iterateReaderSync(f, {\n *   bufSize: 1024 * 1024\n * });\n * for (const chunk of iter) {\n *   console.log(chunk);\n * }\n * f.close();\n * ```\n *\n * Iterator uses an internal buffer of fixed size for efficiency; it returns\n * a view on that buffer on each iteration. It is therefore caller's\n * responsibility to copy contents of the buffer if needed; otherwise the\n * next iteration will overwrite contents of previously returned chunk.\n */\nexport function* iterateReaderSync(\n  r: Deno.ReaderSync,\n  options?: {\n    bufSize?: number;\n  },\n): IterableIterator<Uint8Array> {\n  const bufSize = options?.bufSize ?? DEFAULT_BUFFER_SIZE;\n  const b = new Uint8Array(bufSize);\n  while (true) {\n    const result = r.readSync(b);\n    if (result === null) {\n      break;\n    }\n\n    yield b.subarray(0, result);\n  }\n}\n\n/** Copies from `src` to `dst` until either EOF (`null`) is read from `src` or\n * an error occurs. It resolves to the number of bytes copied or rejects with\n * the first error encountered while copying.\n *\n * ```ts\n * import { copy } from \"./conversion.ts\";\n *\n * const source = await Deno.open(\"my_file.txt\");\n * const bytesCopied1 = await copy(source, Deno.stdout);\n * const destination = await Deno.create(\"my_file_2.txt\");\n * const bytesCopied2 = await copy(source, destination);\n * ```\n *\n * @param src The source to copy from\n * @param dst The destination to copy to\n * @param options Can be used to tune size of the buffer. Default size is 32kB\n */\nexport async function copy(\n  src: Deno.Reader,\n  dst: Deno.Writer,\n  options?: {\n    bufSize?: number;\n  },\n): Promise<number> {\n  let n = 0;\n  const bufSize = options?.bufSize ?? DEFAULT_BUFFER_SIZE;\n  const b = new Uint8Array(bufSize);\n  let gotEOF = false;\n  while (gotEOF === false) {\n    const result = await src.read(b);\n    if (result === null) {\n      gotEOF = true;\n    } else {\n      let nwritten = 0;\n      while (nwritten < result) {\n        nwritten += await dst.write(b.subarray(nwritten, result));\n      }\n      n += nwritten;\n    }\n  }\n  return n;\n}\n"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/tests/__snapshots__/transpile/remote/modules/ebsv4XtKEF8sxrDsnkLX8K9VdOA.js b/tests/__snapshots__/transpile/remote/modules/ebsv4XtKEF8sxrDsnkLX8K9VdOA.js new file mode 100644 index 0000000..30e11f0 --- /dev/null +++ b/tests/__snapshots__/transpile/remote/modules/ebsv4XtKEF8sxrDsnkLX8K9VdOA.js @@ -0,0 +1,18 @@ +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. +export const osType = (()=>{ + // deno-lint-ignore no-explicit-any + const { Deno } = globalThis; + if (typeof Deno?.build?.os === "string") { + return Deno.build.os; + } + // deno-lint-ignore no-explicit-any + const { navigator } = globalThis; + if (navigator?.appVersion?.includes?.("Win")) { + return "windows"; + } + return "linux"; +})(); +export const isWindows = osType === "windows"; +export const isLinux = osType === "linux"; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImh0dHBzOi8vZGVuby5sYW5kL3N0ZEAwLjE0MC4wL191dGlsL29zLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAyMDE4LTIwMjIgdGhlIERlbm8gYXV0aG9ycy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gTUlUIGxpY2Vuc2UuXG4vLyBUaGlzIG1vZHVsZSBpcyBicm93c2VyIGNvbXBhdGlibGUuXG5cbmV4cG9ydCB0eXBlIE9TVHlwZSA9IFwid2luZG93c1wiIHwgXCJsaW51eFwiIHwgXCJkYXJ3aW5cIjtcblxuZXhwb3J0IGNvbnN0IG9zVHlwZTogT1NUeXBlID0gKCgpID0+IHtcbiAgLy8gZGVuby1saW50LWlnbm9yZSBuby1leHBsaWNpdC1hbnlcbiAgY29uc3QgeyBEZW5vIH0gPSBnbG9iYWxUaGlzIGFzIGFueTtcbiAgaWYgKHR5cGVvZiBEZW5vPy5idWlsZD8ub3MgPT09IFwic3RyaW5nXCIpIHtcbiAgICByZXR1cm4gRGVuby5idWlsZC5vcztcbiAgfVxuXG4gIC8vIGRlbm8tbGludC1pZ25vcmUgbm8tZXhwbGljaXQtYW55XG4gIGNvbnN0IHsgbmF2aWdhdG9yIH0gPSBnbG9iYWxUaGlzIGFzIGFueTtcbiAgaWYgKG5hdmlnYXRvcj8uYXBwVmVyc2lvbj8uaW5jbHVkZXM/LihcIldpblwiKSkge1xuICAgIHJldHVybiBcIndpbmRvd3NcIjtcbiAgfVxuXG4gIHJldHVybiBcImxpbnV4XCI7XG59KSgpO1xuXG5leHBvcnQgY29uc3QgaXNXaW5kb3dzID0gb3NUeXBlID09PSBcIndpbmRvd3NcIjtcbmV4cG9ydCBjb25zdCBpc0xpbnV4ID0gb3NUeXBlID09PSBcImxpbnV4XCI7XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsMEVBQTBFO0FBQzFFLHFDQUFxQztBQUlyQyxPQUFPLE1BQU0sU0FBaUIsQUFBQyxDQUFBLElBQU07SUFDbkMsbUNBQW1DO0lBQ25DLE1BQU0sRUFBRSxLQUFJLEVBQUUsR0FBRztJQUNqQixJQUFJLE9BQU8sTUFBTSxPQUFPLE9BQU8sVUFBVTtRQUN2QyxPQUFPLEtBQUssS0FBSyxDQUFDLEVBQUU7SUFDdEIsQ0FBQztJQUVELG1DQUFtQztJQUNuQyxNQUFNLEVBQUUsVUFBUyxFQUFFLEdBQUc7SUFDdEIsSUFBSSxXQUFXLFlBQVksV0FBVyxRQUFRO1FBQzVDLE9BQU87SUFDVCxDQUFDO0lBRUQsT0FBTztBQUNULENBQUEsSUFBSztBQUVMLE9BQU8sTUFBTSxZQUFZLFdBQVcsVUFBVTtBQUM5QyxPQUFPLE1BQU0sVUFBVSxXQUFXLFFBQVEifQ== \ No newline at end of file diff --git a/tests/__snapshots__/transpile/remote/modules/jO4Cj24EIKVTiTvdPctAVhckzgg.js b/tests/__snapshots__/transpile/remote/modules/jO4Cj24EIKVTiTvdPctAVhckzgg.js new file mode 100644 index 0000000..121d0d0 --- /dev/null +++ b/tests/__snapshots__/transpile/remote/modules/jO4Cj24EIKVTiTvdPctAVhckzgg.js @@ -0,0 +1,39 @@ +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. +/** Check whether binary arrays are equal to each other using 8-bit comparisons. + * @private + * @param a first array to check equality + * @param b second array to check equality + */ export function equalsNaive(a, b) { + if (a.length !== b.length) return false; + for(let i = 0; i < b.length; i++){ + if (a[i] !== b[i]) return false; + } + return true; +} +/** Check whether binary arrays are equal to each other using 32-bit comparisons. + * @private + * @param a first array to check equality + * @param b second array to check equality + */ export function equalsSimd(a, b) { + if (a.length !== b.length) return false; + const len = a.length; + const compressable = Math.floor(len / 4); + const compressedA = new Uint32Array(a.buffer, 0, compressable); + const compressedB = new Uint32Array(b.buffer, 0, compressable); + for(let i = compressable * 4; i < len; i++){ + if (a[i] !== b[i]) return false; + } + for(let i = 0; i < compressedA.length; i++){ + if (compressedA[i] !== compressedB[i]) return false; + } + return true; +} +/** Check whether binary arrays are equal to each other. + * @param a first array to check equality + * @param b second array to check equality + */ export function equals(a, b) { + if (a.length < 1000) return equalsNaive(a, b); + return equalsSimd(a, b); +} +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/tests/__snapshots__/transpile/remote/modules/kWDlQkpYLFWxtJdAejga3vZCeeM.js b/tests/__snapshots__/transpile/remote/modules/kWDlQkpYLFWxtJdAejga3vZCeeM.js new file mode 100644 index 0000000..c838ff9 --- /dev/null +++ b/tests/__snapshots__/transpile/remote/modules/kWDlQkpYLFWxtJdAejga3vZCeeM.js @@ -0,0 +1,433 @@ +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +// Copyright the Browserify authors. MIT License. +// Ported from https://github.com/browserify/path-browserify/ +// This module is browser compatible. +import { CHAR_DOT, CHAR_FORWARD_SLASH } from "./_constants.ts"; +import { _format, assertPath, encodeWhitespace, isPosixPathSeparator, normalizeString } from "./_util.ts"; +export const sep = "/"; +export const delimiter = ":"; +// path.resolve([from ...], to) +/** + * Resolves `pathSegments` into an absolute path. + * @param pathSegments an array of path segments + */ export function resolve(...pathSegments) { + let resolvedPath = ""; + let resolvedAbsolute = false; + for(let i = pathSegments.length - 1; i >= -1 && !resolvedAbsolute; i--){ + let path; + if (i >= 0) path = pathSegments[i]; + else { + // deno-lint-ignore no-explicit-any + const { Deno } = globalThis; + if (typeof Deno?.cwd !== "function") { + throw new TypeError("Resolved a relative path without a CWD."); + } + path = Deno.cwd(); + } + assertPath(path); + // Skip empty entries + if (path.length === 0) { + continue; + } + resolvedPath = `${path}/${resolvedPath}`; + resolvedAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH; + } + // At this point the path should be resolved to a full absolute path, but + // handle relative paths to be safe (might happen when process.cwd() fails) + // Normalize the path + resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute, "/", isPosixPathSeparator); + if (resolvedAbsolute) { + if (resolvedPath.length > 0) return `/${resolvedPath}`; + else return "/"; + } else if (resolvedPath.length > 0) return resolvedPath; + else return "."; +} +/** + * Normalize the `path`, resolving `'..'` and `'.'` segments. + * @param path to be normalized + */ export function normalize(path) { + assertPath(path); + if (path.length === 0) return "."; + const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH; + const trailingSeparator = path.charCodeAt(path.length - 1) === CHAR_FORWARD_SLASH; + // 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; +} +/** + * Verifies whether provided path is absolute + * @param path to be verified as absolute + */ export function isAbsolute(path) { + assertPath(path); + return path.length > 0 && path.charCodeAt(0) === CHAR_FORWARD_SLASH; +} +/** + * Join all given a sequence of `paths`,then normalizes the resulting path. + * @param paths to be joined and normalized + */ export function join(...paths) { + if (paths.length === 0) return "."; + let joined; + for(let i = 0, len = paths.length; i < len; ++i){ + const path = paths[i]; + assertPath(path); + if (path.length > 0) { + if (!joined) joined = path; + else joined += `/${path}`; + } + } + if (!joined) return "."; + return normalize(joined); +} +/** + * Return the relative path from `from` to `to` based on current working directory. + * @param from path in current working directory + * @param to path in current working directory + */ export function relative(from, to) { + assertPath(from); + assertPath(to); + if (from === to) return ""; + from = resolve(from); + to = resolve(to); + if (from === to) return ""; + // Trim any leading backslashes + let fromStart = 1; + const fromEnd = from.length; + for(; fromStart < fromEnd; ++fromStart){ + if (from.charCodeAt(fromStart) !== CHAR_FORWARD_SLASH) break; + } + const fromLen = fromEnd - fromStart; + // Trim any leading backslashes + let toStart = 1; + const toEnd = to.length; + for(; toStart < toEnd; ++toStart){ + if (to.charCodeAt(toStart) !== CHAR_FORWARD_SLASH) break; + } + const toLen = toEnd - toStart; + // Compare paths to find the longest common path from root + const length = fromLen < toLen ? fromLen : toLen; + let lastCommonSep = -1; + let i = 0; + for(; i <= length; ++i){ + if (i === length) { + if (toLen > length) { + if (to.charCodeAt(toStart + i) === CHAR_FORWARD_SLASH) { + // We get here if `from` is the exact base path for `to`. + // For example: from='/foo/bar'; to='/foo/bar/baz' + return to.slice(toStart + i + 1); + } else if (i === 0) { + // We get here if `from` is the root + // For example: from='/'; to='/foo' + return to.slice(toStart + i); + } + } else if (fromLen > length) { + if (from.charCodeAt(fromStart + i) === CHAR_FORWARD_SLASH) { + // We get here if `to` is the exact base path for `from`. + // For example: from='/foo/bar/baz'; to='/foo/bar' + lastCommonSep = i; + } else if (i === 0) { + // We get here if `to` is the root. + // For example: from='/foo'; to='/' + lastCommonSep = 0; + } + } + break; + } + const fromCode = from.charCodeAt(fromStart + i); + const toCode = to.charCodeAt(toStart + i); + if (fromCode !== toCode) break; + else if (fromCode === CHAR_FORWARD_SLASH) lastCommonSep = i; + } + let out = ""; + // Generate the relative path based on the path difference between `to` + // and `from` + for(i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i){ + if (i === fromEnd || from.charCodeAt(i) === CHAR_FORWARD_SLASH) { + if (out.length === 0) out += ".."; + else out += "/.."; + } + } + // Lastly, append the rest of the destination (`to`) path that comes after + // the common path parts + if (out.length > 0) return out + to.slice(toStart + lastCommonSep); + else { + toStart += lastCommonSep; + if (to.charCodeAt(toStart) === CHAR_FORWARD_SLASH) ++toStart; + return to.slice(toStart); + } +} +/** + * Resolves path to a namespace path + * @param path to resolve to namespace + */ export function toNamespacedPath(path) { + // Non-op on posix systems + return path; +} +/** + * Return the directory name of a `path`. + * @param path to determine name for + */ export function dirname(path) { + assertPath(path); + if (path.length === 0) return "."; + const hasRoot = path.charCodeAt(0) === CHAR_FORWARD_SLASH; + let end = -1; + let matchedSlash = true; + for(let i = path.length - 1; i >= 1; --i){ + if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) { + if (!matchedSlash) { + end = i; + break; + } + } else { + // We saw the first non-path separator + matchedSlash = false; + } + } + if (end === -1) return hasRoot ? "/" : "."; + if (hasRoot && end === 1) return "//"; + return path.slice(0, end); +} +/** + * Return the last portion of a `path`. Trailing directory separators are ignored. + * @param path to process + * @param ext of path directory + */ export function basename(path, ext = "") { + if (ext !== undefined && typeof ext !== "string") { + throw new TypeError('"ext" argument must be a string'); + } + assertPath(path); + let start = 0; + let end = -1; + let matchedSlash = true; + let i; + if (ext !== undefined && ext.length > 0 && ext.length <= path.length) { + if (ext.length === path.length && ext === path) return ""; + let extIdx = ext.length - 1; + let firstNonSlashEnd = -1; + for(i = path.length - 1; i >= 0; --i){ + const code = path.charCodeAt(i); + if (code === CHAR_FORWARD_SLASH) { + // If we reached a path separator that was not part of a set of path + // separators at the end of the string, stop now + if (!matchedSlash) { + start = i + 1; + break; + } + } else { + if (firstNonSlashEnd === -1) { + // We saw the first non-path separator, remember this index in case + // we need it if the extension ends up not matching + matchedSlash = false; + firstNonSlashEnd = i + 1; + } + if (extIdx >= 0) { + // Try to match the explicit extension + if (code === ext.charCodeAt(extIdx)) { + if (--extIdx === -1) { + // We matched the extension, so mark this as the end of our path + // component + end = i; + } + } else { + // Extension does not match, so our result is the entire path + // component + extIdx = -1; + end = firstNonSlashEnd; + } + } + } + } + if (start === end) end = firstNonSlashEnd; + else if (end === -1) end = path.length; + return path.slice(start, end); + } else { + for(i = path.length - 1; i >= 0; --i){ + if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) { + // If we reached a path separator that was not part of a set of path + // separators at the end of the string, stop now + if (!matchedSlash) { + start = i + 1; + break; + } + } else if (end === -1) { + // We saw the first non-path separator, mark this as the end of our + // path component + matchedSlash = false; + end = i + 1; + } + } + if (end === -1) return ""; + return path.slice(start, end); + } +} +/** + * Return the extension of the `path` with leading period. + * @param path with extension + * @returns extension (ex. for `file.ts` returns `.ts`) + */ export function extname(path) { + assertPath(path); + let startDot = -1; + let startPart = 0; + let end = -1; + let matchedSlash = true; + // Track the state of characters (if any) we see before our first dot and + // after any path separator we find + let preDotState = 0; + for(let i = path.length - 1; i >= 0; --i){ + const code = path.charCodeAt(i); + if (code === CHAR_FORWARD_SLASH) { + // If we reached a path separator that was not part of a set of path + // separators at the end of the string, stop now + if (!matchedSlash) { + startPart = i + 1; + break; + } + continue; + } + if (end === -1) { + // We saw the first non-path separator, mark this as the end of our + // extension + matchedSlash = false; + end = i + 1; + } + if (code === CHAR_DOT) { + // If this is our first dot, mark it as the start of our extension + if (startDot === -1) startDot = i; + else if (preDotState !== 1) preDotState = 1; + } else if (startDot !== -1) { + // We saw a non-dot and non-path separator before our dot, so we should + // have a good chance at having a non-empty extension + preDotState = -1; + } + } + if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot + preDotState === 0 || // The (right-most) trimmed path component is exactly '..' + preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) { + return ""; + } + return path.slice(startDot, end); +} +/** + * Generate a path from `FormatInputPathObject` object. + * @param pathObject with path + */ export function format(pathObject) { + if (pathObject === null || typeof pathObject !== "object") { + throw new TypeError(`The "pathObject" argument must be of type Object. Received type ${typeof pathObject}`); + } + return _format("/", pathObject); +} +/** + * Return a `ParsedPath` object of the `path`. + * @param path to process + */ export function parse(path) { + assertPath(path); + const ret = { + root: "", + dir: "", + base: "", + ext: "", + name: "" + }; + if (path.length === 0) return ret; + const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH; + let start; + if (isAbsolute) { + ret.root = "/"; + start = 1; + } else { + start = 0; + } + let startDot = -1; + let startPart = 0; + let end = -1; + let matchedSlash = true; + let i = path.length - 1; + // Track the state of characters (if any) we see before our first dot and + // after any path separator we find + let preDotState = 0; + // Get non-dir info + for(; i >= start; --i){ + const code = path.charCodeAt(i); + if (code === CHAR_FORWARD_SLASH) { + // If we reached a path separator that was not part of a set of path + // separators at the end of the string, stop now + if (!matchedSlash) { + startPart = i + 1; + break; + } + continue; + } + if (end === -1) { + // We saw the first non-path separator, mark this as the end of our + // extension + matchedSlash = false; + end = i + 1; + } + if (code === CHAR_DOT) { + // If this is our first dot, mark it as the start of our extension + if (startDot === -1) startDot = i; + else if (preDotState !== 1) preDotState = 1; + } else if (startDot !== -1) { + // We saw a non-dot and non-path separator before our dot, so we should + // have a good chance at having a non-empty extension + preDotState = -1; + } + } + if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot + preDotState === 0 || // The (right-most) trimmed path component is exactly '..' + preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) { + if (end !== -1) { + if (startPart === 0 && isAbsolute) { + ret.base = ret.name = path.slice(1, end); + } else { + ret.base = ret.name = path.slice(startPart, end); + } + } + } else { + if (startPart === 0 && isAbsolute) { + ret.name = path.slice(1, startDot); + ret.base = path.slice(1, end); + } else { + ret.name = path.slice(startPart, startDot); + ret.base = path.slice(startPart, end); + } + ret.ext = path.slice(startDot, end); + } + if (startPart > 0) ret.dir = path.slice(0, startPart - 1); + else if (isAbsolute) ret.dir = "/"; + return ret; +} +/** + * Converts a file URL to a path string. + * + * ```ts + * import { fromFileUrl } from "./posix.ts"; + * fromFileUrl("file:///home/foo"); // "/home/foo" + * ``` + * @param url of a file URL + */ export function fromFileUrl(url) { + url = url instanceof URL ? url : new URL(url); + if (url.protocol != "file:") { + throw new TypeError("Must be a file URL."); + } + return decodeURIComponent(url.pathname.replace(/%(?![0-9A-Fa-f]{2})/g, "%25")); +} +/** + * Converts a path string to a file URL. + * + * ```ts + * import { toFileUrl } from "./posix.ts"; + * toFileUrl("/home/foo"); // new URL("file:///home/foo") + * ``` + * @param path to convert to file URL + */ export function toFileUrl(path) { + if (!isAbsolute(path)) { + throw new TypeError("Must be an absolute path."); + } + const url = new URL("file:///"); + url.pathname = encodeWhitespace(path.replace(/%/g, "%25").replace(/\\/g, "%5C")); + return url; +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["https://deno.land/std@0.140.0/path/posix.ts"],"sourcesContent":["// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.\n// Copyright the Browserify authors. MIT License.\n// Ported from https://github.com/browserify/path-browserify/\n// This module is browser compatible.\n\nimport type { FormatInputPathObject, ParsedPath } from \"./_interface.ts\";\nimport { CHAR_DOT, CHAR_FORWARD_SLASH } from \"./_constants.ts\";\n\nimport {\n  _format,\n  assertPath,\n  encodeWhitespace,\n  isPosixPathSeparator,\n  normalizeString,\n} from \"./_util.ts\";\n\nexport const sep = \"/\";\nexport const delimiter = \":\";\n\n// path.resolve([from ...], to)\n/**\n * Resolves `pathSegments` into an absolute path.\n * @param pathSegments an array of path segments\n */\nexport function resolve(...pathSegments: string[]): string {\n  let resolvedPath = \"\";\n  let resolvedAbsolute = false;\n\n  for (let i = pathSegments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n    let path: string;\n\n    if (i >= 0) path = pathSegments[i];\n    else {\n      // deno-lint-ignore no-explicit-any\n      const { Deno } = globalThis as any;\n      if (typeof Deno?.cwd !== \"function\") {\n        throw new TypeError(\"Resolved a relative path without a CWD.\");\n      }\n      path = Deno.cwd();\n    }\n\n    assertPath(path);\n\n    // Skip empty entries\n    if (path.length === 0) {\n      continue;\n    }\n\n    resolvedPath = `${path}/${resolvedPath}`;\n    resolvedAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;\n  }\n\n  // At this point the path should be resolved to a full absolute path, but\n  // handle relative paths to be safe (might happen when process.cwd() fails)\n\n  // Normalize the path\n  resolvedPath = normalizeString(\n    resolvedPath,\n    !resolvedAbsolute,\n    \"/\",\n    isPosixPathSeparator,\n  );\n\n  if (resolvedAbsolute) {\n    if (resolvedPath.length > 0) return `/${resolvedPath}`;\n    else return \"/\";\n  } else if (resolvedPath.length > 0) return resolvedPath;\n  else return \".\";\n}\n\n/**\n * Normalize the `path`, resolving `'..'` and `'.'` segments.\n * @param path to be normalized\n */\nexport function normalize(path: string): string {\n  assertPath(path);\n\n  if (path.length === 0) return \".\";\n\n  const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;\n  const trailingSeparator =\n    path.charCodeAt(path.length - 1) === CHAR_FORWARD_SLASH;\n\n  // Normalize the path\n  path = normalizeString(path, !isAbsolute, \"/\", isPosixPathSeparator);\n\n  if (path.length === 0 && !isAbsolute) path = \".\";\n  if (path.length > 0 && trailingSeparator) path += \"/\";\n\n  if (isAbsolute) return `/${path}`;\n  return path;\n}\n\n/**\n * Verifies whether provided path is absolute\n * @param path to be verified as absolute\n */\nexport function isAbsolute(path: string): boolean {\n  assertPath(path);\n  return path.length > 0 && path.charCodeAt(0) === CHAR_FORWARD_SLASH;\n}\n\n/**\n * Join all given a sequence of `paths`,then normalizes the resulting path.\n * @param paths to be joined and normalized\n */\nexport function join(...paths: string[]): string {\n  if (paths.length === 0) return \".\";\n  let joined: string | undefined;\n  for (let i = 0, len = paths.length; i < len; ++i) {\n    const path = paths[i];\n    assertPath(path);\n    if (path.length > 0) {\n      if (!joined) joined = path;\n      else joined += `/${path}`;\n    }\n  }\n  if (!joined) return \".\";\n  return normalize(joined);\n}\n\n/**\n * Return the relative path from `from` to `to` based on current working directory.\n * @param from path in current working directory\n * @param to path in current working directory\n */\nexport function relative(from: string, to: string): string {\n  assertPath(from);\n  assertPath(to);\n\n  if (from === to) return \"\";\n\n  from = resolve(from);\n  to = resolve(to);\n\n  if (from === to) return \"\";\n\n  // Trim any leading backslashes\n  let fromStart = 1;\n  const fromEnd = from.length;\n  for (; fromStart < fromEnd; ++fromStart) {\n    if (from.charCodeAt(fromStart) !== CHAR_FORWARD_SLASH) break;\n  }\n  const fromLen = fromEnd - fromStart;\n\n  // Trim any leading backslashes\n  let toStart = 1;\n  const toEnd = to.length;\n  for (; toStart < toEnd; ++toStart) {\n    if (to.charCodeAt(toStart) !== CHAR_FORWARD_SLASH) break;\n  }\n  const toLen = toEnd - toStart;\n\n  // Compare paths to find the longest common path from root\n  const length = fromLen < toLen ? fromLen : toLen;\n  let lastCommonSep = -1;\n  let i = 0;\n  for (; i <= length; ++i) {\n    if (i === length) {\n      if (toLen > length) {\n        if (to.charCodeAt(toStart + i) === CHAR_FORWARD_SLASH) {\n          // We get here if `from` is the exact base path for `to`.\n          // For example: from='/foo/bar'; to='/foo/bar/baz'\n          return to.slice(toStart + i + 1);\n        } else if (i === 0) {\n          // We get here if `from` is the root\n          // For example: from='/'; to='/foo'\n          return to.slice(toStart + i);\n        }\n      } else if (fromLen > length) {\n        if (from.charCodeAt(fromStart + i) === CHAR_FORWARD_SLASH) {\n          // We get here if `to` is the exact base path for `from`.\n          // For example: from='/foo/bar/baz'; to='/foo/bar'\n          lastCommonSep = i;\n        } else if (i === 0) {\n          // We get here if `to` is the root.\n          // For example: from='/foo'; to='/'\n          lastCommonSep = 0;\n        }\n      }\n      break;\n    }\n    const fromCode = from.charCodeAt(fromStart + i);\n    const toCode = to.charCodeAt(toStart + i);\n    if (fromCode !== toCode) break;\n    else if (fromCode === CHAR_FORWARD_SLASH) lastCommonSep = i;\n  }\n\n  let out = \"\";\n  // Generate the relative path based on the path difference between `to`\n  // and `from`\n  for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {\n    if (i === fromEnd || from.charCodeAt(i) === CHAR_FORWARD_SLASH) {\n      if (out.length === 0) out += \"..\";\n      else out += \"/..\";\n    }\n  }\n\n  // Lastly, append the rest of the destination (`to`) path that comes after\n  // the common path parts\n  if (out.length > 0) return out + to.slice(toStart + lastCommonSep);\n  else {\n    toStart += lastCommonSep;\n    if (to.charCodeAt(toStart) === CHAR_FORWARD_SLASH) ++toStart;\n    return to.slice(toStart);\n  }\n}\n\n/**\n * Resolves path to a namespace path\n * @param path to resolve to namespace\n */\nexport function toNamespacedPath(path: string): string {\n  // Non-op on posix systems\n  return path;\n}\n\n/**\n * Return the directory name of a `path`.\n * @param path to determine name for\n */\nexport function dirname(path: string): string {\n  assertPath(path);\n  if (path.length === 0) return \".\";\n  const hasRoot = path.charCodeAt(0) === CHAR_FORWARD_SLASH;\n  let end = -1;\n  let matchedSlash = true;\n  for (let i = path.length - 1; i >= 1; --i) {\n    if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {\n      if (!matchedSlash) {\n        end = i;\n        break;\n      }\n    } else {\n      // We saw the first non-path separator\n      matchedSlash = false;\n    }\n  }\n\n  if (end === -1) return hasRoot ? \"/\" : \".\";\n  if (hasRoot && end === 1) return \"//\";\n  return path.slice(0, end);\n}\n\n/**\n * Return the last portion of a `path`. Trailing directory separators are ignored.\n * @param path to process\n * @param ext of path directory\n */\nexport function basename(path: string, ext = \"\"): string {\n  if (ext !== undefined && typeof ext !== \"string\") {\n    throw new TypeError('\"ext\" argument must be a string');\n  }\n  assertPath(path);\n\n  let start = 0;\n  let end = -1;\n  let matchedSlash = true;\n  let i: number;\n\n  if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {\n    if (ext.length === path.length && ext === path) return \"\";\n    let extIdx = ext.length - 1;\n    let firstNonSlashEnd = -1;\n    for (i = path.length - 1; i >= 0; --i) {\n      const code = path.charCodeAt(i);\n      if (code === CHAR_FORWARD_SLASH) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          start = i + 1;\n          break;\n        }\n      } else {\n        if (firstNonSlashEnd === -1) {\n          // We saw the first non-path separator, remember this index in case\n          // we need it if the extension ends up not matching\n          matchedSlash = false;\n          firstNonSlashEnd = i + 1;\n        }\n        if (extIdx >= 0) {\n          // Try to match the explicit extension\n          if (code === ext.charCodeAt(extIdx)) {\n            if (--extIdx === -1) {\n              // We matched the extension, so mark this as the end of our path\n              // component\n              end = i;\n            }\n          } else {\n            // Extension does not match, so our result is the entire path\n            // component\n            extIdx = -1;\n            end = firstNonSlashEnd;\n          }\n        }\n      }\n    }\n\n    if (start === end) end = firstNonSlashEnd;\n    else if (end === -1) end = path.length;\n    return path.slice(start, end);\n  } else {\n    for (i = path.length - 1; i >= 0; --i) {\n      if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          start = i + 1;\n          break;\n        }\n      } else if (end === -1) {\n        // We saw the first non-path separator, mark this as the end of our\n        // path component\n        matchedSlash = false;\n        end = i + 1;\n      }\n    }\n\n    if (end === -1) return \"\";\n    return path.slice(start, end);\n  }\n}\n\n/**\n * Return the extension of the `path` with leading period.\n * @param path with extension\n * @returns extension (ex. for `file.ts` returns `.ts`)\n */\nexport function extname(path: string): string {\n  assertPath(path);\n  let startDot = -1;\n  let startPart = 0;\n  let end = -1;\n  let matchedSlash = true;\n  // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find\n  let preDotState = 0;\n  for (let i = path.length - 1; i >= 0; --i) {\n    const code = path.charCodeAt(i);\n    if (code === CHAR_FORWARD_SLASH) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now\n      if (!matchedSlash) {\n        startPart = i + 1;\n        break;\n      }\n      continue;\n    }\n    if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension\n      matchedSlash = false;\n      end = i + 1;\n    }\n    if (code === CHAR_DOT) {\n      // If this is our first dot, mark it as the start of our extension\n      if (startDot === -1) startDot = i;\n      else if (preDotState !== 1) preDotState = 1;\n    } else if (startDot !== -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension\n      preDotState = -1;\n    }\n  }\n\n  if (\n    startDot === -1 ||\n    end === -1 ||\n    // We saw a non-dot character immediately before the dot\n    preDotState === 0 ||\n    // The (right-most) trimmed path component is exactly '..'\n    (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)\n  ) {\n    return \"\";\n  }\n  return path.slice(startDot, end);\n}\n\n/**\n * Generate a path from `FormatInputPathObject` object.\n * @param pathObject with path\n */\nexport function format(pathObject: FormatInputPathObject): string {\n  if (pathObject === null || typeof pathObject !== \"object\") {\n    throw new TypeError(\n      `The \"pathObject\" argument must be of type Object. Received type ${typeof pathObject}`,\n    );\n  }\n  return _format(\"/\", pathObject);\n}\n\n/**\n * Return a `ParsedPath` object of the `path`.\n * @param path to process\n */\nexport function parse(path: string): ParsedPath {\n  assertPath(path);\n\n  const ret: ParsedPath = { root: \"\", dir: \"\", base: \"\", ext: \"\", name: \"\" };\n  if (path.length === 0) return ret;\n  const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;\n  let start: number;\n  if (isAbsolute) {\n    ret.root = \"/\";\n    start = 1;\n  } else {\n    start = 0;\n  }\n  let startDot = -1;\n  let startPart = 0;\n  let end = -1;\n  let matchedSlash = true;\n  let i = path.length - 1;\n\n  // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find\n  let preDotState = 0;\n\n  // Get non-dir info\n  for (; i >= start; --i) {\n    const code = path.charCodeAt(i);\n    if (code === CHAR_FORWARD_SLASH) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now\n      if (!matchedSlash) {\n        startPart = i + 1;\n        break;\n      }\n      continue;\n    }\n    if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension\n      matchedSlash = false;\n      end = i + 1;\n    }\n    if (code === CHAR_DOT) {\n      // If this is our first dot, mark it as the start of our extension\n      if (startDot === -1) startDot = i;\n      else if (preDotState !== 1) preDotState = 1;\n    } else if (startDot !== -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension\n      preDotState = -1;\n    }\n  }\n\n  if (\n    startDot === -1 ||\n    end === -1 ||\n    // We saw a non-dot character immediately before the dot\n    preDotState === 0 ||\n    // The (right-most) trimmed path component is exactly '..'\n    (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)\n  ) {\n    if (end !== -1) {\n      if (startPart === 0 && isAbsolute) {\n        ret.base = ret.name = path.slice(1, end);\n      } else {\n        ret.base = ret.name = path.slice(startPart, end);\n      }\n    }\n  } else {\n    if (startPart === 0 && isAbsolute) {\n      ret.name = path.slice(1, startDot);\n      ret.base = path.slice(1, end);\n    } else {\n      ret.name = path.slice(startPart, startDot);\n      ret.base = path.slice(startPart, end);\n    }\n    ret.ext = path.slice(startDot, end);\n  }\n\n  if (startPart > 0) ret.dir = path.slice(0, startPart - 1);\n  else if (isAbsolute) ret.dir = \"/\";\n\n  return ret;\n}\n\n/**\n * Converts a file URL to a path string.\n *\n * ```ts\n *      import { fromFileUrl } from \"./posix.ts\";\n *      fromFileUrl(\"file:///home/foo\"); // \"/home/foo\"\n * ```\n * @param url of a file URL\n */\nexport function fromFileUrl(url: string | URL): string {\n  url = url instanceof URL ? url : new URL(url);\n  if (url.protocol != \"file:\") {\n    throw new TypeError(\"Must be a file URL.\");\n  }\n  return decodeURIComponent(\n    url.pathname.replace(/%(?![0-9A-Fa-f]{2})/g, \"%25\"),\n  );\n}\n\n/**\n * Converts a path string to a file URL.\n *\n * ```ts\n *      import { toFileUrl } from \"./posix.ts\";\n *      toFileUrl(\"/home/foo\"); // new URL(\"file:///home/foo\")\n * ```\n * @param path to convert to file URL\n */\nexport function toFileUrl(path: string): URL {\n  if (!isAbsolute(path)) {\n    throw new TypeError(\"Must be an absolute path.\");\n  }\n  const url = new URL(\"file:///\");\n  url.pathname = encodeWhitespace(\n    path.replace(/%/g, \"%25\").replace(/\\\\/g, \"%5C\"),\n  );\n  return url;\n}\n"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/tests/__snapshots__/transpile/remote/modules/nhMTTXGO1bgNtQ_bGZFJE0b7hWs.js b/tests/__snapshots__/transpile/remote/modules/nhMTTXGO1bgNtQ_bGZFJE0b7hWs.js new file mode 100644 index 0000000..fc8cdf6 --- /dev/null +++ b/tests/__snapshots__/transpile/remote/modules/nhMTTXGO1bgNtQ_bGZFJE0b7hWs.js @@ -0,0 +1,14 @@ +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. +export class DenoStdInternalError extends Error { + constructor(message){ + super(message); + this.name = "DenoStdInternalError"; + } +} +/** Make an assertion, if not `true`, then throw. */ export function assert(expr, msg = "") { + if (!expr) { + throw new DenoStdInternalError(msg); + } +} +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImh0dHBzOi8vZGVuby5sYW5kL3N0ZEAwLjE0MC4wL191dGlsL2Fzc2VydC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAxOC0yMDIyIHRoZSBEZW5vIGF1dGhvcnMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIE1JVCBsaWNlbnNlLlxuLy8gVGhpcyBtb2R1bGUgaXMgYnJvd3NlciBjb21wYXRpYmxlLlxuXG5leHBvcnQgY2xhc3MgRGVub1N0ZEludGVybmFsRXJyb3IgZXh0ZW5kcyBFcnJvciB7XG4gIGNvbnN0cnVjdG9yKG1lc3NhZ2U6IHN0cmluZykge1xuICAgIHN1cGVyKG1lc3NhZ2UpO1xuICAgIHRoaXMubmFtZSA9IFwiRGVub1N0ZEludGVybmFsRXJyb3JcIjtcbiAgfVxufVxuXG4vKiogTWFrZSBhbiBhc3NlcnRpb24sIGlmIG5vdCBgdHJ1ZWAsIHRoZW4gdGhyb3cuICovXG5leHBvcnQgZnVuY3Rpb24gYXNzZXJ0KGV4cHI6IHVua25vd24sIG1zZyA9IFwiXCIpOiBhc3NlcnRzIGV4cHIge1xuICBpZiAoIWV4cHIpIHtcbiAgICB0aHJvdyBuZXcgRGVub1N0ZEludGVybmFsRXJyb3IobXNnKTtcbiAgfVxufVxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDBFQUEwRTtBQUMxRSxxQ0FBcUM7QUFFckMsT0FBTyxNQUFNLDZCQUE2QjtJQUN4QyxZQUFZLE9BQWUsQ0FBRTtRQUMzQixLQUFLLENBQUM7UUFDTixJQUFJLENBQUMsSUFBSSxHQUFHO0lBQ2Q7QUFDRixDQUFDO0FBRUQsa0RBQWtELEdBQ2xELE9BQU8sU0FBUyxPQUFPLElBQWEsRUFBRSxNQUFNLEVBQUUsRUFBZ0I7SUFDNUQsSUFBSSxDQUFDLE1BQU07UUFDVCxNQUFNLElBQUkscUJBQXFCLEtBQUs7SUFDdEMsQ0FBQztBQUNILENBQUMifQ== \ No newline at end of file diff --git a/tests/__snapshots__/transpile/remote/modules/npEsX-46oQUgZNw2Jkxv5i4eWDM.js b/tests/__snapshots__/transpile/remote/modules/npEsX-46oQUgZNw2Jkxv5i4eWDM.js new file mode 100644 index 0000000..04be5a3 --- /dev/null +++ b/tests/__snapshots__/transpile/remote/modules/npEsX-46oQUgZNw2Jkxv5i4eWDM.js @@ -0,0 +1,851 @@ +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +import { assert } from "../_util/assert.ts"; +import { BytesList } from "../bytes/bytes_list.ts"; +import { concat, copy } from "../bytes/mod.ts"; +// MIN_READ is the minimum ArrayBuffer size passed to a read call by +// buffer.ReadFrom. As long as the Buffer has at least MIN_READ bytes beyond +// what is required to hold the contents of r, readFrom() will not grow the +// underlying buffer. +const MIN_READ = 32 * 1024; +const MAX_SIZE = 2 ** 32 - 2; +/** A variable-sized buffer of bytes with `read()` and `write()` methods. + * + * Buffer is almost always used with some I/O like files and sockets. It allows + * one to buffer up a download from a socket. Buffer grows and shrinks as + * necessary. + * + * Buffer is NOT the same thing as Node's Buffer. Node's Buffer was created in + * 2009 before JavaScript had the concept of ArrayBuffers. It's simply a + * non-standard ArrayBuffer. + * + * ArrayBuffer is a fixed memory allocation. Buffer is implemented on top of + * ArrayBuffer. + * + * Based on [Go Buffer](https://golang.org/pkg/bytes/#Buffer). */ export class Buffer { + #buf; + #off = 0; + constructor(ab){ + this.#buf = ab === undefined ? new Uint8Array(0) : new Uint8Array(ab); + } + /** Returns a slice holding the unread portion of the buffer. + * + * The slice is valid for use only until the next buffer modification (that + * is, only until the next call to a method like `read()`, `write()`, + * `reset()`, or `truncate()`). If `options.copy` is false the slice aliases the buffer content at + * least until the next buffer modification, so immediate changes to the + * slice will affect the result of future reads. + * @param options Defaults to `{ copy: true }` + */ bytes(options = { + copy: true + }) { + if (options.copy === false) return this.#buf.subarray(this.#off); + return this.#buf.slice(this.#off); + } + /** Returns whether the unread portion of the buffer is empty. */ empty() { + return this.#buf.byteLength <= this.#off; + } + /** A read only number of bytes of the unread portion of the buffer. */ get length() { + return this.#buf.byteLength - this.#off; + } + /** The read only capacity of the buffer's underlying byte slice, that is, + * the total space allocated for the buffer's data. */ get capacity() { + return this.#buf.buffer.byteLength; + } + /** Discards all but the first `n` unread bytes from the buffer but + * continues to use the same allocated storage. It throws if `n` is + * negative or greater than the length of the buffer. */ truncate(n) { + if (n === 0) { + this.reset(); + return; + } + if (n < 0 || n > this.length) { + throw Error("bytes.Buffer: truncation out of range"); + } + this.#reslice(this.#off + n); + } + reset() { + this.#reslice(0); + this.#off = 0; + } + #tryGrowByReslice(n) { + const l = this.#buf.byteLength; + if (n <= this.capacity - l) { + this.#reslice(l + n); + return l; + } + return -1; + } + #reslice(len) { + assert(len <= this.#buf.buffer.byteLength); + this.#buf = new Uint8Array(this.#buf.buffer, 0, len); + } + /** Reads the next `p.length` bytes from the buffer or until the buffer is + * drained. Returns the number of bytes read. If the buffer has no data to + * return, the return is EOF (`null`). */ readSync(p) { + if (this.empty()) { + // Buffer is empty, reset to recover space. + this.reset(); + if (p.byteLength === 0) { + // this edge case is tested in 'bufferReadEmptyAtEOF' test + return 0; + } + return null; + } + const nread = copy(this.#buf.subarray(this.#off), p); + this.#off += nread; + return nread; + } + /** Reads the next `p.length` bytes from the buffer or until the buffer is + * drained. Resolves to the number of bytes read. If the buffer has no + * data to return, resolves to EOF (`null`). + * + * NOTE: This methods reads bytes synchronously; it's provided for + * compatibility with `Reader` interfaces. + */ read(p) { + const rr = this.readSync(p); + return Promise.resolve(rr); + } + writeSync(p) { + const m = this.#grow(p.byteLength); + return copy(p, this.#buf, m); + } + /** NOTE: This methods writes bytes synchronously; it's provided for + * compatibility with `Writer` interface. */ write(p) { + const n = this.writeSync(p); + return Promise.resolve(n); + } + #grow(n) { + const m = this.length; + // If buffer is empty, reset to recover space. + if (m === 0 && this.#off !== 0) { + this.reset(); + } + // Fast: Try to grow by means of a reslice. + const i = this.#tryGrowByReslice(n); + if (i >= 0) { + return i; + } + const c = this.capacity; + if (n <= Math.floor(c / 2) - m) { + // We can slide things down instead of allocating a new + // ArrayBuffer. We only need m+n <= c to slide, but + // we instead let capacity get twice as large so we + // don't spend all our time copying. + copy(this.#buf.subarray(this.#off), this.#buf); + } else if (c + n > MAX_SIZE) { + throw new Error("The buffer cannot be grown beyond the maximum size."); + } else { + // Not enough space anywhere, we need to allocate. + const buf = new Uint8Array(Math.min(2 * c + n, MAX_SIZE)); + copy(this.#buf.subarray(this.#off), buf); + this.#buf = buf; + } + // Restore this.#off and len(this.#buf). + this.#off = 0; + this.#reslice(Math.min(m + n, MAX_SIZE)); + return m; + } + /** Grows the buffer's capacity, if necessary, to guarantee space for + * another `n` bytes. After `.grow(n)`, at least `n` bytes can be written to + * the buffer without another allocation. If `n` is negative, `.grow()` will + * throw. If the buffer can't grow it will throw an error. + * + * Based on Go Lang's + * [Buffer.Grow](https://golang.org/pkg/bytes/#Buffer.Grow). */ grow(n) { + if (n < 0) { + throw Error("Buffer.grow: negative count"); + } + const m = this.#grow(n); + this.#reslice(m); + } + /** Reads data from `r` until EOF (`null`) and appends it to the buffer, + * growing the buffer as needed. It resolves to the number of bytes read. + * If the buffer becomes too large, `.readFrom()` will reject with an error. + * + * Based on Go Lang's + * [Buffer.ReadFrom](https://golang.org/pkg/bytes/#Buffer.ReadFrom). */ async readFrom(r) { + let n = 0; + const tmp = new Uint8Array(MIN_READ); + while(true){ + const shouldGrow = this.capacity - this.length < MIN_READ; + // read into tmp buffer if there's not enough room + // otherwise read directly into the internal buffer + const buf = shouldGrow ? tmp : new Uint8Array(this.#buf.buffer, this.length); + const nread = await r.read(buf); + if (nread === null) { + return n; + } + // write will grow if needed + if (shouldGrow) this.writeSync(buf.subarray(0, nread)); + else this.#reslice(this.length + nread); + n += nread; + } + } + /** Reads data from `r` until EOF (`null`) and appends it to the buffer, + * growing the buffer as needed. It returns the number of bytes read. If the + * buffer becomes too large, `.readFromSync()` will throw an error. + * + * Based on Go Lang's + * [Buffer.ReadFrom](https://golang.org/pkg/bytes/#Buffer.ReadFrom). */ readFromSync(r) { + let n = 0; + const tmp = new Uint8Array(MIN_READ); + while(true){ + const shouldGrow = this.capacity - this.length < MIN_READ; + // read into tmp buffer if there's not enough room + // otherwise read directly into the internal buffer + const buf = shouldGrow ? tmp : new Uint8Array(this.#buf.buffer, this.length); + const nread = r.readSync(buf); + if (nread === null) { + return n; + } + // write will grow if needed + if (shouldGrow) this.writeSync(buf.subarray(0, nread)); + else this.#reslice(this.length + nread); + n += nread; + } + } +} +const DEFAULT_BUF_SIZE = 4096; +const MIN_BUF_SIZE = 16; +const MAX_CONSECUTIVE_EMPTY_READS = 100; +const CR = "\r".charCodeAt(0); +const LF = "\n".charCodeAt(0); +export class BufferFullError extends Error { + partial; + name; + constructor(partial){ + super("Buffer full"); + this.partial = partial; + this.name = "BufferFullError"; + } +} +export class PartialReadError extends Error { + name = "PartialReadError"; + partial; + constructor(){ + super("Encountered UnexpectedEof, data only partially read"); + } +} +/** BufReader implements buffering for a Reader object. */ export class BufReader { + #buf; + #rd; + #r = 0; + #w = 0; + #eof = false; + // private lastByte: number; + // private lastCharSize: number; + /** return new BufReader unless r is BufReader */ static create(r, size = DEFAULT_BUF_SIZE) { + return r instanceof BufReader ? r : new BufReader(r, size); + } + constructor(rd, size = DEFAULT_BUF_SIZE){ + if (size < MIN_BUF_SIZE) { + size = MIN_BUF_SIZE; + } + this.#reset(new Uint8Array(size), rd); + } + /** Returns the size of the underlying buffer in bytes. */ size() { + return this.#buf.byteLength; + } + buffered() { + return this.#w - this.#r; + } + // Reads a new chunk into the buffer. + #fill = async ()=>{ + // Slide existing data to beginning. + if (this.#r > 0) { + this.#buf.copyWithin(0, this.#r, this.#w); + this.#w -= this.#r; + this.#r = 0; + } + if (this.#w >= this.#buf.byteLength) { + throw Error("bufio: tried to fill full buffer"); + } + // Read new data: try a limited number of times. + for(let i = MAX_CONSECUTIVE_EMPTY_READS; i > 0; i--){ + const rr = await this.#rd.read(this.#buf.subarray(this.#w)); + if (rr === null) { + this.#eof = true; + return; + } + assert(rr >= 0, "negative read"); + this.#w += rr; + if (rr > 0) { + return; + } + } + throw new Error(`No progress after ${MAX_CONSECUTIVE_EMPTY_READS} read() calls`); + }; + /** Discards any buffered data, resets all state, and switches + * the buffered reader to read from r. + */ reset(r) { + this.#reset(this.#buf, r); + } + #reset = (buf, rd)=>{ + this.#buf = buf; + this.#rd = rd; + this.#eof = false; + // this.lastByte = -1; + // this.lastCharSize = -1; + }; + /** reads data into p. + * It returns the number of bytes read into p. + * The bytes are taken from at most one Read on the underlying Reader, + * hence n may be less than len(p). + * To read exactly len(p) bytes, use io.ReadFull(b, p). + */ async read(p) { + let rr = p.byteLength; + if (p.byteLength === 0) return rr; + if (this.#r === this.#w) { + if (p.byteLength >= this.#buf.byteLength) { + // Large read, empty buffer. + // Read directly into p to avoid copy. + const rr = await this.#rd.read(p); + const nread = rr ?? 0; + assert(nread >= 0, "negative read"); + // if (rr.nread > 0) { + // this.lastByte = p[rr.nread - 1]; + // this.lastCharSize = -1; + // } + return rr; + } + // One read. + // Do not use this.fill, which will loop. + this.#r = 0; + this.#w = 0; + rr = await this.#rd.read(this.#buf); + if (rr === 0 || rr === null) return rr; + assert(rr >= 0, "negative read"); + this.#w += rr; + } + // copy as much as we can + const copied = copy(this.#buf.subarray(this.#r, this.#w), p, 0); + this.#r += copied; + // this.lastByte = this.buf[this.r - 1]; + // this.lastCharSize = -1; + return copied; + } + /** reads exactly `p.length` bytes into `p`. + * + * If successful, `p` is returned. + * + * If the end of the underlying stream has been reached, and there are no more + * bytes available in the buffer, `readFull()` returns `null` instead. + * + * An error is thrown if some bytes could be read, but not enough to fill `p` + * entirely before the underlying stream reported an error or EOF. Any error + * thrown will have a `partial` property that indicates the slice of the + * buffer that has been successfully filled with data. + * + * Ported from https://golang.org/pkg/io/#ReadFull + */ async readFull(p) { + let bytesRead = 0; + while(bytesRead < p.length){ + try { + const rr = await this.read(p.subarray(bytesRead)); + if (rr === null) { + if (bytesRead === 0) { + return null; + } else { + throw new PartialReadError(); + } + } + bytesRead += rr; + } catch (err) { + if (err instanceof PartialReadError) { + err.partial = p.subarray(0, bytesRead); + } else if (err instanceof Error) { + const e = new PartialReadError(); + e.partial = p.subarray(0, bytesRead); + e.stack = err.stack; + e.message = err.message; + e.cause = err.cause; + throw err; + } + throw err; + } + } + return p; + } + /** Returns the next byte [0, 255] or `null`. */ async readByte() { + while(this.#r === this.#w){ + if (this.#eof) return null; + await this.#fill(); // buffer is empty. + } + const c = this.#buf[this.#r]; + this.#r++; + // this.lastByte = c; + return c; + } + /** readString() reads until the first occurrence of delim in the input, + * returning a string containing the data up to and including the delimiter. + * If ReadString encounters an error before finding a delimiter, + * it returns the data read before the error and the error itself + * (often `null`). + * ReadString returns err != nil if and only if the returned data does not end + * in delim. + * For simple uses, a Scanner may be more convenient. + */ async readString(delim) { + if (delim.length !== 1) { + throw new Error("Delimiter should be a single character"); + } + const buffer = await this.readSlice(delim.charCodeAt(0)); + if (buffer === null) return null; + return new TextDecoder().decode(buffer); + } + /** `readLine()` is a low-level line-reading primitive. Most callers should + * use `readString('\n')` instead or use a Scanner. + * + * `readLine()` tries to return a single line, not including the end-of-line + * bytes. If the line was too long for the buffer then `more` is set and the + * beginning of the line is returned. The rest of the line will be returned + * from future calls. `more` will be false when returning the last fragment + * of the line. The returned buffer is only valid until the next call to + * `readLine()`. + * + * The text returned from ReadLine does not include the line end ("\r\n" or + * "\n"). + * + * When the end of the underlying stream is reached, the final bytes in the + * stream are returned. No indication or error is given if the input ends + * without a final line end. When there are no more trailing bytes to read, + * `readLine()` returns `null`. + * + * Calling `unreadByte()` after `readLine()` will always unread the last byte + * read (possibly a character belonging to the line end) even if that byte is + * not part of the line returned by `readLine()`. + */ async readLine() { + let line = null; + try { + line = await this.readSlice(LF); + } catch (err) { + if (err instanceof Deno.errors.BadResource) { + throw err; + } + let partial; + if (err instanceof PartialReadError) { + partial = err.partial; + assert(partial instanceof Uint8Array, "bufio: caught error from `readSlice()` without `partial` property"); + } + // Don't throw if `readSlice()` failed with `BufferFullError`, instead we + // just return whatever is available and set the `more` flag. + if (!(err instanceof BufferFullError)) { + throw err; + } + partial = err.partial; + // Handle the case where "\r\n" straddles the buffer. + if (!this.#eof && partial && partial.byteLength > 0 && partial[partial.byteLength - 1] === CR) { + // Put the '\r' back on buf and drop it from line. + // Let the next call to ReadLine check for "\r\n". + assert(this.#r > 0, "bufio: tried to rewind past start of buffer"); + this.#r--; + partial = partial.subarray(0, partial.byteLength - 1); + } + if (partial) { + return { + line: partial, + more: !this.#eof + }; + } + } + if (line === null) { + return null; + } + if (line.byteLength === 0) { + return { + line, + more: false + }; + } + if (line[line.byteLength - 1] == LF) { + let drop = 1; + if (line.byteLength > 1 && line[line.byteLength - 2] === CR) { + drop = 2; + } + line = line.subarray(0, line.byteLength - drop); + } + return { + line, + more: false + }; + } + /** `readSlice()` reads until the first occurrence of `delim` in the input, + * returning a slice pointing at the bytes in the buffer. The bytes stop + * being valid at the next read. + * + * If `readSlice()` encounters an error before finding a delimiter, or the + * buffer fills without finding a delimiter, it throws an error with a + * `partial` property that contains the entire buffer. + * + * If `readSlice()` encounters the end of the underlying stream and there are + * any bytes left in the buffer, the rest of the buffer is returned. In other + * words, EOF is always treated as a delimiter. Once the buffer is empty, + * it returns `null`. + * + * Because the data returned from `readSlice()` will be overwritten by the + * next I/O operation, most clients should use `readString()` instead. + */ async readSlice(delim) { + let s = 0; // search start index + let slice; + while(true){ + // Search buffer. + let i = this.#buf.subarray(this.#r + s, this.#w).indexOf(delim); + if (i >= 0) { + i += s; + slice = this.#buf.subarray(this.#r, this.#r + i + 1); + this.#r += i + 1; + break; + } + // EOF? + if (this.#eof) { + if (this.#r === this.#w) { + return null; + } + slice = this.#buf.subarray(this.#r, this.#w); + this.#r = this.#w; + break; + } + // Buffer full? + if (this.buffered() >= this.#buf.byteLength) { + this.#r = this.#w; + // #4521 The internal buffer should not be reused across reads because it causes corruption of data. + const oldbuf = this.#buf; + const newbuf = this.#buf.slice(0); + this.#buf = newbuf; + throw new BufferFullError(oldbuf); + } + s = this.#w - this.#r; // do not rescan area we scanned before + // Buffer is not full. + try { + await this.#fill(); + } catch (err) { + if (err instanceof PartialReadError) { + err.partial = slice; + } else if (err instanceof Error) { + const e = new PartialReadError(); + e.partial = slice; + e.stack = err.stack; + e.message = err.message; + e.cause = err.cause; + throw err; + } + throw err; + } + } + // Handle last byte, if any. + // const i = slice.byteLength - 1; + // if (i >= 0) { + // this.lastByte = slice[i]; + // this.lastCharSize = -1 + // } + return slice; + } + /** `peek()` returns the next `n` bytes without advancing the reader. The + * bytes stop being valid at the next read call. + * + * When the end of the underlying stream is reached, but there are unread + * bytes left in the buffer, those bytes are returned. If there are no bytes + * left in the buffer, it returns `null`. + * + * If an error is encountered before `n` bytes are available, `peek()` throws + * an error with the `partial` property set to a slice of the buffer that + * contains the bytes that were available before the error occurred. + */ async peek(n) { + if (n < 0) { + throw Error("negative count"); + } + let avail = this.#w - this.#r; + while(avail < n && avail < this.#buf.byteLength && !this.#eof){ + try { + await this.#fill(); + } catch (err) { + if (err instanceof PartialReadError) { + err.partial = this.#buf.subarray(this.#r, this.#w); + } else if (err instanceof Error) { + const e = new PartialReadError(); + e.partial = this.#buf.subarray(this.#r, this.#w); + e.stack = err.stack; + e.message = err.message; + e.cause = err.cause; + throw err; + } + throw err; + } + avail = this.#w - this.#r; + } + if (avail === 0 && this.#eof) { + return null; + } else if (avail < n && this.#eof) { + return this.#buf.subarray(this.#r, this.#r + avail); + } else if (avail < n) { + throw new BufferFullError(this.#buf.subarray(this.#r, this.#w)); + } + return this.#buf.subarray(this.#r, this.#r + n); + } +} +class AbstractBufBase { + buf; + usedBufferBytes = 0; + err = null; + constructor(buf){ + this.buf = buf; + } + /** Size returns the size of the underlying buffer in bytes. */ size() { + return this.buf.byteLength; + } + /** Returns how many bytes are unused in the buffer. */ available() { + return this.buf.byteLength - this.usedBufferBytes; + } + /** buffered returns the number of bytes that have been written into the + * current buffer. + */ buffered() { + return this.usedBufferBytes; + } +} +/** BufWriter implements buffering for an deno.Writer object. + * If an error occurs writing to a Writer, no more data will be + * accepted and all subsequent writes, and flush(), will return the error. + * After all data has been written, the client should call the + * flush() method to guarantee all data has been forwarded to + * the underlying deno.Writer. + */ export class BufWriter extends AbstractBufBase { + #writer; + /** return new BufWriter unless writer is BufWriter */ static create(writer, size = DEFAULT_BUF_SIZE) { + return writer instanceof BufWriter ? writer : new BufWriter(writer, size); + } + constructor(writer, size = DEFAULT_BUF_SIZE){ + super(new Uint8Array(size <= 0 ? DEFAULT_BUF_SIZE : size)); + this.#writer = writer; + } + /** Discards any unflushed buffered data, clears any error, and + * resets buffer to write its output to w. + */ reset(w) { + this.err = null; + this.usedBufferBytes = 0; + this.#writer = w; + } + /** Flush writes any buffered data to the underlying io.Writer. */ async flush() { + if (this.err !== null) throw this.err; + if (this.usedBufferBytes === 0) return; + try { + const p = this.buf.subarray(0, this.usedBufferBytes); + let nwritten = 0; + while(nwritten < p.length){ + nwritten += await this.#writer.write(p.subarray(nwritten)); + } + } catch (e) { + if (e instanceof Error) { + this.err = e; + } + throw e; + } + this.buf = new Uint8Array(this.buf.length); + this.usedBufferBytes = 0; + } + /** Writes the contents of `data` into the buffer. If the contents won't fully + * fit into the buffer, those bytes that can are copied into the buffer, the + * buffer is the flushed to the writer and the remaining bytes are copied into + * the now empty buffer. + * + * @return the number of bytes written to the buffer. + */ async write(data) { + if (this.err !== null) throw this.err; + if (data.length === 0) return 0; + let totalBytesWritten = 0; + let numBytesWritten = 0; + while(data.byteLength > this.available()){ + if (this.buffered() === 0) { + // Large write, empty buffer. + // Write directly from data to avoid copy. + try { + numBytesWritten = await this.#writer.write(data); + } catch (e) { + if (e instanceof Error) { + this.err = e; + } + throw e; + } + } else { + numBytesWritten = copy(data, this.buf, this.usedBufferBytes); + this.usedBufferBytes += numBytesWritten; + await this.flush(); + } + totalBytesWritten += numBytesWritten; + data = data.subarray(numBytesWritten); + } + numBytesWritten = copy(data, this.buf, this.usedBufferBytes); + this.usedBufferBytes += numBytesWritten; + totalBytesWritten += numBytesWritten; + return totalBytesWritten; + } +} +/** BufWriterSync implements buffering for a deno.WriterSync object. + * If an error occurs writing to a WriterSync, no more data will be + * accepted and all subsequent writes, and flush(), will return the error. + * After all data has been written, the client should call the + * flush() method to guarantee all data has been forwarded to + * the underlying deno.WriterSync. + */ export class BufWriterSync extends AbstractBufBase { + #writer; + /** return new BufWriterSync unless writer is BufWriterSync */ static create(writer, size = DEFAULT_BUF_SIZE) { + return writer instanceof BufWriterSync ? writer : new BufWriterSync(writer, size); + } + constructor(writer, size = DEFAULT_BUF_SIZE){ + super(new Uint8Array(size <= 0 ? DEFAULT_BUF_SIZE : size)); + this.#writer = writer; + } + /** Discards any unflushed buffered data, clears any error, and + * resets buffer to write its output to w. + */ reset(w) { + this.err = null; + this.usedBufferBytes = 0; + this.#writer = w; + } + /** Flush writes any buffered data to the underlying io.WriterSync. */ flush() { + if (this.err !== null) throw this.err; + if (this.usedBufferBytes === 0) return; + try { + const p = this.buf.subarray(0, this.usedBufferBytes); + let nwritten = 0; + while(nwritten < p.length){ + nwritten += this.#writer.writeSync(p.subarray(nwritten)); + } + } catch (e) { + if (e instanceof Error) { + this.err = e; + } + throw e; + } + this.buf = new Uint8Array(this.buf.length); + this.usedBufferBytes = 0; + } + /** Writes the contents of `data` into the buffer. If the contents won't fully + * fit into the buffer, those bytes that can are copied into the buffer, the + * buffer is the flushed to the writer and the remaining bytes are copied into + * the now empty buffer. + * + * @return the number of bytes written to the buffer. + */ writeSync(data) { + if (this.err !== null) throw this.err; + if (data.length === 0) return 0; + let totalBytesWritten = 0; + let numBytesWritten = 0; + while(data.byteLength > this.available()){ + if (this.buffered() === 0) { + // Large write, empty buffer. + // Write directly from data to avoid copy. + try { + numBytesWritten = this.#writer.writeSync(data); + } catch (e) { + if (e instanceof Error) { + this.err = e; + } + throw e; + } + } else { + numBytesWritten = copy(data, this.buf, this.usedBufferBytes); + this.usedBufferBytes += numBytesWritten; + this.flush(); + } + totalBytesWritten += numBytesWritten; + data = data.subarray(numBytesWritten); + } + numBytesWritten = copy(data, this.buf, this.usedBufferBytes); + this.usedBufferBytes += numBytesWritten; + totalBytesWritten += numBytesWritten; + return totalBytesWritten; + } +} +/** Generate longest proper prefix which is also suffix array. */ function createLPS(pat) { + const lps = new Uint8Array(pat.length); + lps[0] = 0; + let prefixEnd = 0; + let i = 1; + while(i < lps.length){ + if (pat[i] == pat[prefixEnd]) { + prefixEnd++; + lps[i] = prefixEnd; + i++; + } else if (prefixEnd === 0) { + lps[i] = 0; + i++; + } else { + prefixEnd = lps[prefixEnd - 1]; + } + } + return lps; +} +/** Read delimited bytes from a Reader. */ export async function* readDelim(reader, delim) { + // Avoid unicode problems + const delimLen = delim.length; + const delimLPS = createLPS(delim); + const chunks = new BytesList(); + const bufSize = Math.max(1024, delimLen + 1); + // Modified KMP + let inspectIndex = 0; + let matchIndex = 0; + while(true){ + const inspectArr = new Uint8Array(bufSize); + const result = await reader.read(inspectArr); + if (result === null) { + // Yield last chunk. + yield chunks.concat(); + return; + } else if (result < 0) { + // Discard all remaining and silently fail. + return; + } + chunks.add(inspectArr, 0, result); + let localIndex = 0; + while(inspectIndex < chunks.size()){ + if (inspectArr[localIndex] === delim[matchIndex]) { + inspectIndex++; + localIndex++; + matchIndex++; + if (matchIndex === delimLen) { + // Full match + const matchEnd = inspectIndex - delimLen; + const readyBytes = chunks.slice(0, matchEnd); + yield readyBytes; + // Reset match, different from KMP. + chunks.shift(inspectIndex); + inspectIndex = 0; + matchIndex = 0; + } + } else { + if (matchIndex === 0) { + inspectIndex++; + localIndex++; + } else { + matchIndex = delimLPS[matchIndex - 1]; + } + } + } + } +} +/** Read delimited strings from a Reader. */ export async function* readStringDelim(reader, delim, decoderOpts) { + const encoder = new TextEncoder(); + const decoder = new TextDecoder(decoderOpts?.encoding, decoderOpts); + for await (const chunk of readDelim(reader, encoder.encode(delim))){ + yield decoder.decode(chunk); + } +} +/** Read strings line-by-line from a Reader. */ export async function* readLines(reader, decoderOpts) { + const bufReader = new BufReader(reader); + let chunks = []; + const decoder = new TextDecoder(decoderOpts?.encoding, decoderOpts); + while(true){ + const res = await bufReader.readLine(); + if (!res) { + if (chunks.length > 0) { + yield decoder.decode(concat(...chunks)); + } + break; + } + chunks.push(res.line); + if (!res.more) { + yield decoder.decode(concat(...chunks)); + chunks = []; + } + } +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["https://deno.land/std@0.140.0/io/buffer.ts"],"sourcesContent":["// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.\nimport { assert } from \"../_util/assert.ts\";\nimport { BytesList } from \"../bytes/bytes_list.ts\";\nimport { concat, copy } from \"../bytes/mod.ts\";\nimport type { Reader, ReaderSync, Writer, WriterSync } from \"./types.d.ts\";\n\n// MIN_READ is the minimum ArrayBuffer size passed to a read call by\n// buffer.ReadFrom. As long as the Buffer has at least MIN_READ bytes beyond\n// what is required to hold the contents of r, readFrom() will not grow the\n// underlying buffer.\nconst MIN_READ = 32 * 1024;\nconst MAX_SIZE = 2 ** 32 - 2;\n\n/** A variable-sized buffer of bytes with `read()` and `write()` methods.\n *\n * Buffer is almost always used with some I/O like files and sockets. It allows\n * one to buffer up a download from a socket. Buffer grows and shrinks as\n * necessary.\n *\n * Buffer is NOT the same thing as Node's Buffer. Node's Buffer was created in\n * 2009 before JavaScript had the concept of ArrayBuffers. It's simply a\n * non-standard ArrayBuffer.\n *\n * ArrayBuffer is a fixed memory allocation. Buffer is implemented on top of\n * ArrayBuffer.\n *\n * Based on [Go Buffer](https://golang.org/pkg/bytes/#Buffer). */\n\nexport class Buffer {\n  #buf: Uint8Array; // contents are the bytes buf[off : len(buf)]\n  #off = 0; // read at buf[off], write at buf[buf.byteLength]\n\n  constructor(ab?: ArrayBufferLike | ArrayLike<number>) {\n    this.#buf = ab === undefined ? new Uint8Array(0) : new Uint8Array(ab);\n  }\n\n  /** Returns a slice holding the unread portion of the buffer.\n   *\n   * The slice is valid for use only until the next buffer modification (that\n   * is, only until the next call to a method like `read()`, `write()`,\n   * `reset()`, or `truncate()`). If `options.copy` is false the slice aliases the buffer content at\n   * least until the next buffer modification, so immediate changes to the\n   * slice will affect the result of future reads.\n   * @param options Defaults to `{ copy: true }`\n   */\n  bytes(options = { copy: true }): Uint8Array {\n    if (options.copy === false) return this.#buf.subarray(this.#off);\n    return this.#buf.slice(this.#off);\n  }\n\n  /** Returns whether the unread portion of the buffer is empty. */\n  empty(): boolean {\n    return this.#buf.byteLength <= this.#off;\n  }\n\n  /** A read only number of bytes of the unread portion of the buffer. */\n  get length(): number {\n    return this.#buf.byteLength - this.#off;\n  }\n\n  /** The read only capacity of the buffer's underlying byte slice, that is,\n   * the total space allocated for the buffer's data. */\n  get capacity(): number {\n    return this.#buf.buffer.byteLength;\n  }\n\n  /** Discards all but the first `n` unread bytes from the buffer but\n   * continues to use the same allocated storage. It throws if `n` is\n   * negative or greater than the length of the buffer. */\n  truncate(n: number): void {\n    if (n === 0) {\n      this.reset();\n      return;\n    }\n    if (n < 0 || n > this.length) {\n      throw Error(\"bytes.Buffer: truncation out of range\");\n    }\n    this.#reslice(this.#off + n);\n  }\n\n  reset(): void {\n    this.#reslice(0);\n    this.#off = 0;\n  }\n\n  #tryGrowByReslice(n: number) {\n    const l = this.#buf.byteLength;\n    if (n <= this.capacity - l) {\n      this.#reslice(l + n);\n      return l;\n    }\n    return -1;\n  }\n\n  #reslice(len: number) {\n    assert(len <= this.#buf.buffer.byteLength);\n    this.#buf = new Uint8Array(this.#buf.buffer, 0, len);\n  }\n\n  /** Reads the next `p.length` bytes from the buffer or until the buffer is\n   * drained. Returns the number of bytes read. If the buffer has no data to\n   * return, the return is EOF (`null`). */\n  readSync(p: Uint8Array): number | null {\n    if (this.empty()) {\n      // Buffer is empty, reset to recover space.\n      this.reset();\n      if (p.byteLength === 0) {\n        // this edge case is tested in 'bufferReadEmptyAtEOF' test\n        return 0;\n      }\n      return null;\n    }\n    const nread = copy(this.#buf.subarray(this.#off), p);\n    this.#off += nread;\n    return nread;\n  }\n\n  /** Reads the next `p.length` bytes from the buffer or until the buffer is\n   * drained. Resolves to the number of bytes read. If the buffer has no\n   * data to return, resolves to EOF (`null`).\n   *\n   * NOTE: This methods reads bytes synchronously; it's provided for\n   * compatibility with `Reader` interfaces.\n   */\n  read(p: Uint8Array): Promise<number | null> {\n    const rr = this.readSync(p);\n    return Promise.resolve(rr);\n  }\n\n  writeSync(p: Uint8Array): number {\n    const m = this.#grow(p.byteLength);\n    return copy(p, this.#buf, m);\n  }\n\n  /** NOTE: This methods writes bytes synchronously; it's provided for\n   * compatibility with `Writer` interface. */\n  write(p: Uint8Array): Promise<number> {\n    const n = this.writeSync(p);\n    return Promise.resolve(n);\n  }\n\n  #grow(n: number) {\n    const m = this.length;\n    // If buffer is empty, reset to recover space.\n    if (m === 0 && this.#off !== 0) {\n      this.reset();\n    }\n    // Fast: Try to grow by means of a reslice.\n    const i = this.#tryGrowByReslice(n);\n    if (i >= 0) {\n      return i;\n    }\n    const c = this.capacity;\n    if (n <= Math.floor(c / 2) - m) {\n      // We can slide things down instead of allocating a new\n      // ArrayBuffer. We only need m+n <= c to slide, but\n      // we instead let capacity get twice as large so we\n      // don't spend all our time copying.\n      copy(this.#buf.subarray(this.#off), this.#buf);\n    } else if (c + n > MAX_SIZE) {\n      throw new Error(\"The buffer cannot be grown beyond the maximum size.\");\n    } else {\n      // Not enough space anywhere, we need to allocate.\n      const buf = new Uint8Array(Math.min(2 * c + n, MAX_SIZE));\n      copy(this.#buf.subarray(this.#off), buf);\n      this.#buf = buf;\n    }\n    // Restore this.#off and len(this.#buf).\n    this.#off = 0;\n    this.#reslice(Math.min(m + n, MAX_SIZE));\n    return m;\n  }\n\n  /** Grows the buffer's capacity, if necessary, to guarantee space for\n   * another `n` bytes. After `.grow(n)`, at least `n` bytes can be written to\n   * the buffer without another allocation. If `n` is negative, `.grow()` will\n   * throw. If the buffer can't grow it will throw an error.\n   *\n   * Based on Go Lang's\n   * [Buffer.Grow](https://golang.org/pkg/bytes/#Buffer.Grow). */\n  grow(n: number): void {\n    if (n < 0) {\n      throw Error(\"Buffer.grow: negative count\");\n    }\n    const m = this.#grow(n);\n    this.#reslice(m);\n  }\n\n  /** Reads data from `r` until EOF (`null`) and appends it to the buffer,\n   * growing the buffer as needed. It resolves to the number of bytes read.\n   * If the buffer becomes too large, `.readFrom()` will reject with an error.\n   *\n   * Based on Go Lang's\n   * [Buffer.ReadFrom](https://golang.org/pkg/bytes/#Buffer.ReadFrom). */\n  async readFrom(r: Reader): Promise<number> {\n    let n = 0;\n    const tmp = new Uint8Array(MIN_READ);\n    while (true) {\n      const shouldGrow = this.capacity - this.length < MIN_READ;\n      // read into tmp buffer if there's not enough room\n      // otherwise read directly into the internal buffer\n      const buf = shouldGrow\n        ? tmp\n        : new Uint8Array(this.#buf.buffer, this.length);\n\n      const nread = await r.read(buf);\n      if (nread === null) {\n        return n;\n      }\n\n      // write will grow if needed\n      if (shouldGrow) this.writeSync(buf.subarray(0, nread));\n      else this.#reslice(this.length + nread);\n\n      n += nread;\n    }\n  }\n\n  /** Reads data from `r` until EOF (`null`) and appends it to the buffer,\n   * growing the buffer as needed. It returns the number of bytes read. If the\n   * buffer becomes too large, `.readFromSync()` will throw an error.\n   *\n   * Based on Go Lang's\n   * [Buffer.ReadFrom](https://golang.org/pkg/bytes/#Buffer.ReadFrom). */\n  readFromSync(r: ReaderSync): number {\n    let n = 0;\n    const tmp = new Uint8Array(MIN_READ);\n    while (true) {\n      const shouldGrow = this.capacity - this.length < MIN_READ;\n      // read into tmp buffer if there's not enough room\n      // otherwise read directly into the internal buffer\n      const buf = shouldGrow\n        ? tmp\n        : new Uint8Array(this.#buf.buffer, this.length);\n\n      const nread = r.readSync(buf);\n      if (nread === null) {\n        return n;\n      }\n\n      // write will grow if needed\n      if (shouldGrow) this.writeSync(buf.subarray(0, nread));\n      else this.#reslice(this.length + nread);\n\n      n += nread;\n    }\n  }\n}\n\nconst DEFAULT_BUF_SIZE = 4096;\nconst MIN_BUF_SIZE = 16;\nconst MAX_CONSECUTIVE_EMPTY_READS = 100;\nconst CR = \"\\r\".charCodeAt(0);\nconst LF = \"\\n\".charCodeAt(0);\n\nexport class BufferFullError extends Error {\n  override name = \"BufferFullError\";\n  constructor(public partial: Uint8Array) {\n    super(\"Buffer full\");\n  }\n}\n\nexport class PartialReadError extends Error {\n  override name = \"PartialReadError\";\n  partial?: Uint8Array;\n  constructor() {\n    super(\"Encountered UnexpectedEof, data only partially read\");\n  }\n}\n\n/** Result type returned by of BufReader.readLine(). */\nexport interface ReadLineResult {\n  line: Uint8Array;\n  more: boolean;\n}\n\n/** BufReader implements buffering for a Reader object. */\nexport class BufReader implements Reader {\n  #buf!: Uint8Array;\n  #rd!: Reader; // Reader provided by caller.\n  #r = 0; // buf read position.\n  #w = 0; // buf write position.\n  #eof = false;\n  // private lastByte: number;\n  // private lastCharSize: number;\n\n  /** return new BufReader unless r is BufReader */\n  static create(r: Reader, size: number = DEFAULT_BUF_SIZE): BufReader {\n    return r instanceof BufReader ? r : new BufReader(r, size);\n  }\n\n  constructor(rd: Reader, size: number = DEFAULT_BUF_SIZE) {\n    if (size < MIN_BUF_SIZE) {\n      size = MIN_BUF_SIZE;\n    }\n    this.#reset(new Uint8Array(size), rd);\n  }\n\n  /** Returns the size of the underlying buffer in bytes. */\n  size(): number {\n    return this.#buf.byteLength;\n  }\n\n  buffered(): number {\n    return this.#w - this.#r;\n  }\n\n  // Reads a new chunk into the buffer.\n  #fill = async () => {\n    // Slide existing data to beginning.\n    if (this.#r > 0) {\n      this.#buf.copyWithin(0, this.#r, this.#w);\n      this.#w -= this.#r;\n      this.#r = 0;\n    }\n\n    if (this.#w >= this.#buf.byteLength) {\n      throw Error(\"bufio: tried to fill full buffer\");\n    }\n\n    // Read new data: try a limited number of times.\n    for (let i = MAX_CONSECUTIVE_EMPTY_READS; i > 0; i--) {\n      const rr = await this.#rd.read(this.#buf.subarray(this.#w));\n      if (rr === null) {\n        this.#eof = true;\n        return;\n      }\n      assert(rr >= 0, \"negative read\");\n      this.#w += rr;\n      if (rr > 0) {\n        return;\n      }\n    }\n\n    throw new Error(\n      `No progress after ${MAX_CONSECUTIVE_EMPTY_READS} read() calls`,\n    );\n  };\n\n  /** Discards any buffered data, resets all state, and switches\n   * the buffered reader to read from r.\n   */\n  reset(r: Reader): void {\n    this.#reset(this.#buf, r);\n  }\n\n  #reset = (buf: Uint8Array, rd: Reader): void => {\n    this.#buf = buf;\n    this.#rd = rd;\n    this.#eof = false;\n    // this.lastByte = -1;\n    // this.lastCharSize = -1;\n  };\n\n  /** reads data into p.\n   * It returns the number of bytes read into p.\n   * The bytes are taken from at most one Read on the underlying Reader,\n   * hence n may be less than len(p).\n   * To read exactly len(p) bytes, use io.ReadFull(b, p).\n   */\n  async read(p: Uint8Array): Promise<number | null> {\n    let rr: number | null = p.byteLength;\n    if (p.byteLength === 0) return rr;\n\n    if (this.#r === this.#w) {\n      if (p.byteLength >= this.#buf.byteLength) {\n        // Large read, empty buffer.\n        // Read directly into p to avoid copy.\n        const rr = await this.#rd.read(p);\n        const nread = rr ?? 0;\n        assert(nread >= 0, \"negative read\");\n        // if (rr.nread > 0) {\n        //   this.lastByte = p[rr.nread - 1];\n        //   this.lastCharSize = -1;\n        // }\n        return rr;\n      }\n\n      // One read.\n      // Do not use this.fill, which will loop.\n      this.#r = 0;\n      this.#w = 0;\n      rr = await this.#rd.read(this.#buf);\n      if (rr === 0 || rr === null) return rr;\n      assert(rr >= 0, \"negative read\");\n      this.#w += rr;\n    }\n\n    // copy as much as we can\n    const copied = copy(this.#buf.subarray(this.#r, this.#w), p, 0);\n    this.#r += copied;\n    // this.lastByte = this.buf[this.r - 1];\n    // this.lastCharSize = -1;\n    return copied;\n  }\n\n  /** reads exactly `p.length` bytes into `p`.\n   *\n   * If successful, `p` is returned.\n   *\n   * If the end of the underlying stream has been reached, and there are no more\n   * bytes available in the buffer, `readFull()` returns `null` instead.\n   *\n   * An error is thrown if some bytes could be read, but not enough to fill `p`\n   * entirely before the underlying stream reported an error or EOF. Any error\n   * thrown will have a `partial` property that indicates the slice of the\n   * buffer that has been successfully filled with data.\n   *\n   * Ported from https://golang.org/pkg/io/#ReadFull\n   */\n  async readFull(p: Uint8Array): Promise<Uint8Array | null> {\n    let bytesRead = 0;\n    while (bytesRead < p.length) {\n      try {\n        const rr = await this.read(p.subarray(bytesRead));\n        if (rr === null) {\n          if (bytesRead === 0) {\n            return null;\n          } else {\n            throw new PartialReadError();\n          }\n        }\n        bytesRead += rr;\n      } catch (err) {\n        if (err instanceof PartialReadError) {\n          err.partial = p.subarray(0, bytesRead);\n        } else if (err instanceof Error) {\n          const e = new PartialReadError();\n          e.partial = p.subarray(0, bytesRead);\n          e.stack = err.stack;\n          e.message = err.message;\n          e.cause = err.cause;\n          throw err;\n        }\n        throw err;\n      }\n    }\n    return p;\n  }\n\n  /** Returns the next byte [0, 255] or `null`. */\n  async readByte(): Promise<number | null> {\n    while (this.#r === this.#w) {\n      if (this.#eof) return null;\n      await this.#fill(); // buffer is empty.\n    }\n    const c = this.#buf[this.#r];\n    this.#r++;\n    // this.lastByte = c;\n    return c;\n  }\n\n  /** readString() reads until the first occurrence of delim in the input,\n   * returning a string containing the data up to and including the delimiter.\n   * If ReadString encounters an error before finding a delimiter,\n   * it returns the data read before the error and the error itself\n   * (often `null`).\n   * ReadString returns err != nil if and only if the returned data does not end\n   * in delim.\n   * For simple uses, a Scanner may be more convenient.\n   */\n  async readString(delim: string): Promise<string | null> {\n    if (delim.length !== 1) {\n      throw new Error(\"Delimiter should be a single character\");\n    }\n    const buffer = await this.readSlice(delim.charCodeAt(0));\n    if (buffer === null) return null;\n    return new TextDecoder().decode(buffer);\n  }\n\n  /** `readLine()` is a low-level line-reading primitive. Most callers should\n   * use `readString('\\n')` instead or use a Scanner.\n   *\n   * `readLine()` tries to return a single line, not including the end-of-line\n   * bytes. If the line was too long for the buffer then `more` is set and the\n   * beginning of the line is returned. The rest of the line will be returned\n   * from future calls. `more` will be false when returning the last fragment\n   * of the line. The returned buffer is only valid until the next call to\n   * `readLine()`.\n   *\n   * The text returned from ReadLine does not include the line end (\"\\r\\n\" or\n   * \"\\n\").\n   *\n   * When the end of the underlying stream is reached, the final bytes in the\n   * stream are returned. No indication or error is given if the input ends\n   * without a final line end. When there are no more trailing bytes to read,\n   * `readLine()` returns `null`.\n   *\n   * Calling `unreadByte()` after `readLine()` will always unread the last byte\n   * read (possibly a character belonging to the line end) even if that byte is\n   * not part of the line returned by `readLine()`.\n   */\n  async readLine(): Promise<ReadLineResult | null> {\n    let line: Uint8Array | null = null;\n\n    try {\n      line = await this.readSlice(LF);\n    } catch (err) {\n      if (err instanceof Deno.errors.BadResource) {\n        throw err;\n      }\n      let partial;\n      if (err instanceof PartialReadError) {\n        partial = err.partial;\n        assert(\n          partial instanceof Uint8Array,\n          \"bufio: caught error from `readSlice()` without `partial` property\",\n        );\n      }\n\n      // Don't throw if `readSlice()` failed with `BufferFullError`, instead we\n      // just return whatever is available and set the `more` flag.\n      if (!(err instanceof BufferFullError)) {\n        throw err;\n      }\n\n      partial = err.partial;\n\n      // Handle the case where \"\\r\\n\" straddles the buffer.\n      if (\n        !this.#eof && partial &&\n        partial.byteLength > 0 &&\n        partial[partial.byteLength - 1] === CR\n      ) {\n        // Put the '\\r' back on buf and drop it from line.\n        // Let the next call to ReadLine check for \"\\r\\n\".\n        assert(this.#r > 0, \"bufio: tried to rewind past start of buffer\");\n        this.#r--;\n        partial = partial.subarray(0, partial.byteLength - 1);\n      }\n\n      if (partial) {\n        return { line: partial, more: !this.#eof };\n      }\n    }\n\n    if (line === null) {\n      return null;\n    }\n\n    if (line.byteLength === 0) {\n      return { line, more: false };\n    }\n\n    if (line[line.byteLength - 1] == LF) {\n      let drop = 1;\n      if (line.byteLength > 1 && line[line.byteLength - 2] === CR) {\n        drop = 2;\n      }\n      line = line.subarray(0, line.byteLength - drop);\n    }\n    return { line, more: false };\n  }\n\n  /** `readSlice()` reads until the first occurrence of `delim` in the input,\n   * returning a slice pointing at the bytes in the buffer. The bytes stop\n   * being valid at the next read.\n   *\n   * If `readSlice()` encounters an error before finding a delimiter, or the\n   * buffer fills without finding a delimiter, it throws an error with a\n   * `partial` property that contains the entire buffer.\n   *\n   * If `readSlice()` encounters the end of the underlying stream and there are\n   * any bytes left in the buffer, the rest of the buffer is returned. In other\n   * words, EOF is always treated as a delimiter. Once the buffer is empty,\n   * it returns `null`.\n   *\n   * Because the data returned from `readSlice()` will be overwritten by the\n   * next I/O operation, most clients should use `readString()` instead.\n   */\n  async readSlice(delim: number): Promise<Uint8Array | null> {\n    let s = 0; // search start index\n    let slice: Uint8Array | undefined;\n\n    while (true) {\n      // Search buffer.\n      let i = this.#buf.subarray(this.#r + s, this.#w).indexOf(delim);\n      if (i >= 0) {\n        i += s;\n        slice = this.#buf.subarray(this.#r, this.#r + i + 1);\n        this.#r += i + 1;\n        break;\n      }\n\n      // EOF?\n      if (this.#eof) {\n        if (this.#r === this.#w) {\n          return null;\n        }\n        slice = this.#buf.subarray(this.#r, this.#w);\n        this.#r = this.#w;\n        break;\n      }\n\n      // Buffer full?\n      if (this.buffered() >= this.#buf.byteLength) {\n        this.#r = this.#w;\n        // #4521 The internal buffer should not be reused across reads because it causes corruption of data.\n        const oldbuf = this.#buf;\n        const newbuf = this.#buf.slice(0);\n        this.#buf = newbuf;\n        throw new BufferFullError(oldbuf);\n      }\n\n      s = this.#w - this.#r; // do not rescan area we scanned before\n\n      // Buffer is not full.\n      try {\n        await this.#fill();\n      } catch (err) {\n        if (err instanceof PartialReadError) {\n          err.partial = slice;\n        } else if (err instanceof Error) {\n          const e = new PartialReadError();\n          e.partial = slice;\n          e.stack = err.stack;\n          e.message = err.message;\n          e.cause = err.cause;\n          throw err;\n        }\n        throw err;\n      }\n    }\n\n    // Handle last byte, if any.\n    // const i = slice.byteLength - 1;\n    // if (i >= 0) {\n    //   this.lastByte = slice[i];\n    //   this.lastCharSize = -1\n    // }\n\n    return slice;\n  }\n\n  /** `peek()` returns the next `n` bytes without advancing the reader. The\n   * bytes stop being valid at the next read call.\n   *\n   * When the end of the underlying stream is reached, but there are unread\n   * bytes left in the buffer, those bytes are returned. If there are no bytes\n   * left in the buffer, it returns `null`.\n   *\n   * If an error is encountered before `n` bytes are available, `peek()` throws\n   * an error with the `partial` property set to a slice of the buffer that\n   * contains the bytes that were available before the error occurred.\n   */\n  async peek(n: number): Promise<Uint8Array | null> {\n    if (n < 0) {\n      throw Error(\"negative count\");\n    }\n\n    let avail = this.#w - this.#r;\n    while (avail < n && avail < this.#buf.byteLength && !this.#eof) {\n      try {\n        await this.#fill();\n      } catch (err) {\n        if (err instanceof PartialReadError) {\n          err.partial = this.#buf.subarray(this.#r, this.#w);\n        } else if (err instanceof Error) {\n          const e = new PartialReadError();\n          e.partial = this.#buf.subarray(this.#r, this.#w);\n          e.stack = err.stack;\n          e.message = err.message;\n          e.cause = err.cause;\n          throw err;\n        }\n        throw err;\n      }\n      avail = this.#w - this.#r;\n    }\n\n    if (avail === 0 && this.#eof) {\n      return null;\n    } else if (avail < n && this.#eof) {\n      return this.#buf.subarray(this.#r, this.#r + avail);\n    } else if (avail < n) {\n      throw new BufferFullError(this.#buf.subarray(this.#r, this.#w));\n    }\n\n    return this.#buf.subarray(this.#r, this.#r + n);\n  }\n}\n\nabstract class AbstractBufBase {\n  buf: Uint8Array;\n  usedBufferBytes = 0;\n  err: Error | null = null;\n\n  constructor(buf: Uint8Array) {\n    this.buf = buf;\n  }\n\n  /** Size returns the size of the underlying buffer in bytes. */\n  size(): number {\n    return this.buf.byteLength;\n  }\n\n  /** Returns how many bytes are unused in the buffer. */\n  available(): number {\n    return this.buf.byteLength - this.usedBufferBytes;\n  }\n\n  /** buffered returns the number of bytes that have been written into the\n   * current buffer.\n   */\n  buffered(): number {\n    return this.usedBufferBytes;\n  }\n}\n\n/** BufWriter implements buffering for an deno.Writer object.\n * If an error occurs writing to a Writer, no more data will be\n * accepted and all subsequent writes, and flush(), will return the error.\n * After all data has been written, the client should call the\n * flush() method to guarantee all data has been forwarded to\n * the underlying deno.Writer.\n */\nexport class BufWriter extends AbstractBufBase implements Writer {\n  #writer: Writer;\n\n  /** return new BufWriter unless writer is BufWriter */\n  static create(writer: Writer, size: number = DEFAULT_BUF_SIZE): BufWriter {\n    return writer instanceof BufWriter ? writer : new BufWriter(writer, size);\n  }\n\n  constructor(writer: Writer, size: number = DEFAULT_BUF_SIZE) {\n    super(new Uint8Array(size <= 0 ? DEFAULT_BUF_SIZE : size));\n    this.#writer = writer;\n  }\n\n  /** Discards any unflushed buffered data, clears any error, and\n   * resets buffer to write its output to w.\n   */\n  reset(w: Writer): void {\n    this.err = null;\n    this.usedBufferBytes = 0;\n    this.#writer = w;\n  }\n\n  /** Flush writes any buffered data to the underlying io.Writer. */\n  async flush() {\n    if (this.err !== null) throw this.err;\n    if (this.usedBufferBytes === 0) return;\n\n    try {\n      const p = this.buf.subarray(0, this.usedBufferBytes);\n      let nwritten = 0;\n      while (nwritten < p.length) {\n        nwritten += await this.#writer.write(p.subarray(nwritten));\n      }\n    } catch (e) {\n      if (e instanceof Error) {\n        this.err = e;\n      }\n      throw e;\n    }\n\n    this.buf = new Uint8Array(this.buf.length);\n    this.usedBufferBytes = 0;\n  }\n\n  /** Writes the contents of `data` into the buffer.  If the contents won't fully\n   * fit into the buffer, those bytes that can are copied into the buffer, the\n   * buffer is the flushed to the writer and the remaining bytes are copied into\n   * the now empty buffer.\n   *\n   * @return the number of bytes written to the buffer.\n   */\n  async write(data: Uint8Array): Promise<number> {\n    if (this.err !== null) throw this.err;\n    if (data.length === 0) return 0;\n\n    let totalBytesWritten = 0;\n    let numBytesWritten = 0;\n    while (data.byteLength > this.available()) {\n      if (this.buffered() === 0) {\n        // Large write, empty buffer.\n        // Write directly from data to avoid copy.\n        try {\n          numBytesWritten = await this.#writer.write(data);\n        } catch (e) {\n          if (e instanceof Error) {\n            this.err = e;\n          }\n          throw e;\n        }\n      } else {\n        numBytesWritten = copy(data, this.buf, this.usedBufferBytes);\n        this.usedBufferBytes += numBytesWritten;\n        await this.flush();\n      }\n      totalBytesWritten += numBytesWritten;\n      data = data.subarray(numBytesWritten);\n    }\n\n    numBytesWritten = copy(data, this.buf, this.usedBufferBytes);\n    this.usedBufferBytes += numBytesWritten;\n    totalBytesWritten += numBytesWritten;\n    return totalBytesWritten;\n  }\n}\n\n/** BufWriterSync implements buffering for a deno.WriterSync object.\n * If an error occurs writing to a WriterSync, no more data will be\n * accepted and all subsequent writes, and flush(), will return the error.\n * After all data has been written, the client should call the\n * flush() method to guarantee all data has been forwarded to\n * the underlying deno.WriterSync.\n */\nexport class BufWriterSync extends AbstractBufBase implements WriterSync {\n  #writer: WriterSync;\n\n  /** return new BufWriterSync unless writer is BufWriterSync */\n  static create(\n    writer: WriterSync,\n    size: number = DEFAULT_BUF_SIZE,\n  ): BufWriterSync {\n    return writer instanceof BufWriterSync\n      ? writer\n      : new BufWriterSync(writer, size);\n  }\n\n  constructor(writer: WriterSync, size: number = DEFAULT_BUF_SIZE) {\n    super(new Uint8Array(size <= 0 ? DEFAULT_BUF_SIZE : size));\n    this.#writer = writer;\n  }\n\n  /** Discards any unflushed buffered data, clears any error, and\n   * resets buffer to write its output to w.\n   */\n  reset(w: WriterSync): void {\n    this.err = null;\n    this.usedBufferBytes = 0;\n    this.#writer = w;\n  }\n\n  /** Flush writes any buffered data to the underlying io.WriterSync. */\n  flush(): void {\n    if (this.err !== null) throw this.err;\n    if (this.usedBufferBytes === 0) return;\n\n    try {\n      const p = this.buf.subarray(0, this.usedBufferBytes);\n      let nwritten = 0;\n      while (nwritten < p.length) {\n        nwritten += this.#writer.writeSync(p.subarray(nwritten));\n      }\n    } catch (e) {\n      if (e instanceof Error) {\n        this.err = e;\n      }\n      throw e;\n    }\n\n    this.buf = new Uint8Array(this.buf.length);\n    this.usedBufferBytes = 0;\n  }\n\n  /** Writes the contents of `data` into the buffer.  If the contents won't fully\n   * fit into the buffer, those bytes that can are copied into the buffer, the\n   * buffer is the flushed to the writer and the remaining bytes are copied into\n   * the now empty buffer.\n   *\n   * @return the number of bytes written to the buffer.\n   */\n  writeSync(data: Uint8Array): number {\n    if (this.err !== null) throw this.err;\n    if (data.length === 0) return 0;\n\n    let totalBytesWritten = 0;\n    let numBytesWritten = 0;\n    while (data.byteLength > this.available()) {\n      if (this.buffered() === 0) {\n        // Large write, empty buffer.\n        // Write directly from data to avoid copy.\n        try {\n          numBytesWritten = this.#writer.writeSync(data);\n        } catch (e) {\n          if (e instanceof Error) {\n            this.err = e;\n          }\n          throw e;\n        }\n      } else {\n        numBytesWritten = copy(data, this.buf, this.usedBufferBytes);\n        this.usedBufferBytes += numBytesWritten;\n        this.flush();\n      }\n      totalBytesWritten += numBytesWritten;\n      data = data.subarray(numBytesWritten);\n    }\n\n    numBytesWritten = copy(data, this.buf, this.usedBufferBytes);\n    this.usedBufferBytes += numBytesWritten;\n    totalBytesWritten += numBytesWritten;\n    return totalBytesWritten;\n  }\n}\n\n/** Generate longest proper prefix which is also suffix array. */\nfunction createLPS(pat: Uint8Array): Uint8Array {\n  const lps = new Uint8Array(pat.length);\n  lps[0] = 0;\n  let prefixEnd = 0;\n  let i = 1;\n  while (i < lps.length) {\n    if (pat[i] == pat[prefixEnd]) {\n      prefixEnd++;\n      lps[i] = prefixEnd;\n      i++;\n    } else if (prefixEnd === 0) {\n      lps[i] = 0;\n      i++;\n    } else {\n      prefixEnd = lps[prefixEnd - 1];\n    }\n  }\n  return lps;\n}\n\n/** Read delimited bytes from a Reader. */\nexport async function* readDelim(\n  reader: Reader,\n  delim: Uint8Array,\n): AsyncIterableIterator<Uint8Array> {\n  // Avoid unicode problems\n  const delimLen = delim.length;\n  const delimLPS = createLPS(delim);\n  const chunks = new BytesList();\n  const bufSize = Math.max(1024, delimLen + 1);\n\n  // Modified KMP\n  let inspectIndex = 0;\n  let matchIndex = 0;\n  while (true) {\n    const inspectArr = new Uint8Array(bufSize);\n    const result = await reader.read(inspectArr);\n    if (result === null) {\n      // Yield last chunk.\n      yield chunks.concat();\n      return;\n    } else if (result < 0) {\n      // Discard all remaining and silently fail.\n      return;\n    }\n    chunks.add(inspectArr, 0, result);\n    let localIndex = 0;\n    while (inspectIndex < chunks.size()) {\n      if (inspectArr[localIndex] === delim[matchIndex]) {\n        inspectIndex++;\n        localIndex++;\n        matchIndex++;\n        if (matchIndex === delimLen) {\n          // Full match\n          const matchEnd = inspectIndex - delimLen;\n          const readyBytes = chunks.slice(0, matchEnd);\n          yield readyBytes;\n          // Reset match, different from KMP.\n          chunks.shift(inspectIndex);\n          inspectIndex = 0;\n          matchIndex = 0;\n        }\n      } else {\n        if (matchIndex === 0) {\n          inspectIndex++;\n          localIndex++;\n        } else {\n          matchIndex = delimLPS[matchIndex - 1];\n        }\n      }\n    }\n  }\n}\n\n/** Read delimited strings from a Reader. */\nexport async function* readStringDelim(\n  reader: Reader,\n  delim: string,\n  decoderOpts?: {\n    encoding?: string;\n    fatal?: boolean;\n    ignoreBOM?: boolean;\n  },\n): AsyncIterableIterator<string> {\n  const encoder = new TextEncoder();\n  const decoder = new TextDecoder(decoderOpts?.encoding, decoderOpts);\n  for await (const chunk of readDelim(reader, encoder.encode(delim))) {\n    yield decoder.decode(chunk);\n  }\n}\n\n/** Read strings line-by-line from a Reader. */\nexport async function* readLines(\n  reader: Reader,\n  decoderOpts?: {\n    encoding?: string;\n    fatal?: boolean;\n    ignoreBOM?: boolean;\n  },\n): AsyncIterableIterator<string> {\n  const bufReader = new BufReader(reader);\n  let chunks: Uint8Array[] = [];\n  const decoder = new TextDecoder(decoderOpts?.encoding, decoderOpts);\n  while (true) {\n    const res = await bufReader.readLine();\n    if (!res) {\n      if (chunks.length > 0) {\n        yield decoder.decode(concat(...chunks));\n      }\n      break;\n    }\n    chunks.push(res.line);\n    if (!res.more) {\n      yield decoder.decode(concat(...chunks));\n      chunks = [];\n    }\n  }\n}\n"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/tests/__snapshots__/transpile/remote/modules/p5wE1hCF6dGYMZ41YnIQs2go2is.js b/tests/__snapshots__/transpile/remote/modules/p5wE1hCF6dGYMZ41YnIQs2go2is.js new file mode 100644 index 0000000..d414e93 --- /dev/null +++ b/tests/__snapshots__/transpile/remote/modules/p5wE1hCF6dGYMZ41YnIQs2go2is.js @@ -0,0 +1,140 @@ +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. +/** + * An abstraction of multiple Uint8Arrays + */ export class BytesList { + len = 0; + chunks = []; + constructor(){} + /** + * Total size of bytes + */ size() { + return this.len; + } + /** + * Push bytes with given offset infos + */ add(value, start = 0, end = value.byteLength) { + if (value.byteLength === 0 || end - start === 0) { + return; + } + checkRange(start, end, value.byteLength); + this.chunks.push({ + value, + end, + start, + offset: this.len + }); + this.len += end - start; + } + /** + * Drop head `n` bytes. + */ shift(n) { + if (n === 0) { + return; + } + if (this.len <= n) { + this.chunks = []; + this.len = 0; + return; + } + const idx = this.getChunkIndex(n); + this.chunks.splice(0, idx); + const [chunk] = this.chunks; + if (chunk) { + const diff = n - chunk.offset; + chunk.start += diff; + } + let offset = 0; + for (const chunk of this.chunks){ + chunk.offset = offset; + offset += chunk.end - chunk.start; + } + this.len = offset; + } + /** + * Find chunk index in which `pos` locates by binary-search + * returns -1 if out of range + */ getChunkIndex(pos) { + let max = this.chunks.length; + let min = 0; + while(true){ + const i = min + Math.floor((max - min) / 2); + if (i < 0 || this.chunks.length <= i) { + return -1; + } + const { offset , start , end } = this.chunks[i]; + const len = end - start; + if (offset <= pos && pos < offset + len) { + return i; + } else if (offset + len <= pos) { + min = i + 1; + } else { + max = i - 1; + } + } + } + /** + * Get indexed byte from chunks + */ get(i) { + if (i < 0 || this.len <= i) { + throw new Error("out of range"); + } + const idx = this.getChunkIndex(i); + const { value , offset , start } = this.chunks[idx]; + return value[start + i - offset]; + } + /** + * Iterator of bytes from given position + */ *iterator(start = 0) { + const startIdx = this.getChunkIndex(start); + if (startIdx < 0) return; + const first = this.chunks[startIdx]; + let firstOffset = start - first.offset; + for(let i = startIdx; i < this.chunks.length; i++){ + const chunk = this.chunks[i]; + for(let j = chunk.start + firstOffset; j < chunk.end; j++){ + yield chunk.value[j]; + } + firstOffset = 0; + } + } + /** + * Returns subset of bytes copied + */ slice(start, end = this.len) { + if (end === start) { + return new Uint8Array(); + } + checkRange(start, end, this.len); + const result = new Uint8Array(end - start); + const startIdx = this.getChunkIndex(start); + const endIdx = this.getChunkIndex(end - 1); + let written = 0; + for(let i = startIdx; i < endIdx; i++){ + const chunk = this.chunks[i]; + const len = chunk.end - chunk.start; + result.set(chunk.value.subarray(chunk.start, chunk.end), written); + written += len; + } + const last = this.chunks[endIdx]; + const rest = end - start - written; + result.set(last.value.subarray(last.start, last.start + rest), written); + return result; + } + /** + * Concatenate chunks into single Uint8Array copied. + */ concat() { + const result = new Uint8Array(this.len); + let sum = 0; + for (const { value , start , end } of this.chunks){ + result.set(value.subarray(start, end), sum); + sum += end - start; + } + return result; + } +} +function checkRange(start, end, len) { + if (start < 0 || len < start || end < 0 || len < end || end < start) { + throw new Error("invalid range"); + } +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["https://deno.land/std@0.140.0/bytes/bytes_list.ts"],"sourcesContent":["// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.\n// This module is browser compatible.\n\n/**\n * An abstraction of multiple Uint8Arrays\n */\nexport class BytesList {\n  private len = 0;\n  private chunks: {\n    value: Uint8Array;\n    start: number; // start offset from head of chunk\n    end: number; // end offset from head of chunk\n    offset: number; // offset of head in all bytes\n  }[] = [];\n  constructor() {}\n\n  /**\n   * Total size of bytes\n   */\n  size() {\n    return this.len;\n  }\n  /**\n   * Push bytes with given offset infos\n   */\n  add(value: Uint8Array, start = 0, end = value.byteLength) {\n    if (value.byteLength === 0 || end - start === 0) {\n      return;\n    }\n    checkRange(start, end, value.byteLength);\n    this.chunks.push({\n      value,\n      end,\n      start,\n      offset: this.len,\n    });\n    this.len += end - start;\n  }\n\n  /**\n   * Drop head `n` bytes.\n   */\n  shift(n: number) {\n    if (n === 0) {\n      return;\n    }\n    if (this.len <= n) {\n      this.chunks = [];\n      this.len = 0;\n      return;\n    }\n    const idx = this.getChunkIndex(n);\n    this.chunks.splice(0, idx);\n    const [chunk] = this.chunks;\n    if (chunk) {\n      const diff = n - chunk.offset;\n      chunk.start += diff;\n    }\n    let offset = 0;\n    for (const chunk of this.chunks) {\n      chunk.offset = offset;\n      offset += chunk.end - chunk.start;\n    }\n    this.len = offset;\n  }\n\n  /**\n   * Find chunk index in which `pos` locates by binary-search\n   * returns -1 if out of range\n   */\n  getChunkIndex(pos: number): number {\n    let max = this.chunks.length;\n    let min = 0;\n    while (true) {\n      const i = min + Math.floor((max - min) / 2);\n      if (i < 0 || this.chunks.length <= i) {\n        return -1;\n      }\n      const { offset, start, end } = this.chunks[i];\n      const len = end - start;\n      if (offset <= pos && pos < offset + len) {\n        return i;\n      } else if (offset + len <= pos) {\n        min = i + 1;\n      } else {\n        max = i - 1;\n      }\n    }\n  }\n\n  /**\n   * Get indexed byte from chunks\n   */\n  get(i: number): number {\n    if (i < 0 || this.len <= i) {\n      throw new Error(\"out of range\");\n    }\n    const idx = this.getChunkIndex(i);\n    const { value, offset, start } = this.chunks[idx];\n    return value[start + i - offset];\n  }\n\n  /**\n   * Iterator of bytes from given position\n   */\n  *iterator(start = 0): IterableIterator<number> {\n    const startIdx = this.getChunkIndex(start);\n    if (startIdx < 0) return;\n    const first = this.chunks[startIdx];\n    let firstOffset = start - first.offset;\n    for (let i = startIdx; i < this.chunks.length; i++) {\n      const chunk = this.chunks[i];\n      for (let j = chunk.start + firstOffset; j < chunk.end; j++) {\n        yield chunk.value[j];\n      }\n      firstOffset = 0;\n    }\n  }\n\n  /**\n   * Returns subset of bytes copied\n   */\n  slice(start: number, end: number = this.len): Uint8Array {\n    if (end === start) {\n      return new Uint8Array();\n    }\n    checkRange(start, end, this.len);\n    const result = new Uint8Array(end - start);\n    const startIdx = this.getChunkIndex(start);\n    const endIdx = this.getChunkIndex(end - 1);\n    let written = 0;\n    for (let i = startIdx; i < endIdx; i++) {\n      const chunk = this.chunks[i];\n      const len = chunk.end - chunk.start;\n      result.set(chunk.value.subarray(chunk.start, chunk.end), written);\n      written += len;\n    }\n    const last = this.chunks[endIdx];\n    const rest = end - start - written;\n    result.set(last.value.subarray(last.start, last.start + rest), written);\n    return result;\n  }\n  /**\n   * Concatenate chunks into single Uint8Array copied.\n   */\n  concat(): Uint8Array {\n    const result = new Uint8Array(this.len);\n    let sum = 0;\n    for (const { value, start, end } of this.chunks) {\n      result.set(value.subarray(start, end), sum);\n      sum += end - start;\n    }\n    return result;\n  }\n}\n\nfunction checkRange(start: number, end: number, len: number) {\n  if (start < 0 || len < start || end < 0 || len < end || end < start) {\n    throw new Error(\"invalid range\");\n  }\n}\n"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/tests/__snapshots__/transpile/remote/modules/wme9EIsCB7sfOz5qC_CSLRYajRk.js b/tests/__snapshots__/transpile/remote/modules/wme9EIsCB7sfOz5qC_CSLRYajRk.js new file mode 100644 index 0000000..e057dad --- /dev/null +++ b/tests/__snapshots__/transpile/remote/modules/wme9EIsCB7sfOz5qC_CSLRYajRk.js @@ -0,0 +1,5 @@ +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. +/** + * A parsed path object generated by path.parse() or consumed by path.format(). + */ //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImh0dHBzOi8vZGVuby5sYW5kL3N0ZEAwLjE0MC4wL3BhdGgvX2ludGVyZmFjZS50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAxOC0yMDIyIHRoZSBEZW5vIGF1dGhvcnMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIE1JVCBsaWNlbnNlLlxuLy8gVGhpcyBtb2R1bGUgaXMgYnJvd3NlciBjb21wYXRpYmxlLlxuXG4vKipcbiAqIEEgcGFyc2VkIHBhdGggb2JqZWN0IGdlbmVyYXRlZCBieSBwYXRoLnBhcnNlKCkgb3IgY29uc3VtZWQgYnkgcGF0aC5mb3JtYXQoKS5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBQYXJzZWRQYXRoIHtcbiAgLyoqXG4gICAqIFRoZSByb290IG9mIHRoZSBwYXRoIHN1Y2ggYXMgJy8nIG9yICdjOlxcJ1xuICAgKi9cbiAgcm9vdDogc3RyaW5nO1xuICAvKipcbiAgICogVGhlIGZ1bGwgZGlyZWN0b3J5IHBhdGggc3VjaCBhcyAnL2hvbWUvdXNlci9kaXInIG9yICdjOlxccGF0aFxcZGlyJ1xuICAgKi9cbiAgZGlyOiBzdHJpbmc7XG4gIC8qKlxuICAgKiBUaGUgZmlsZSBuYW1lIGluY2x1ZGluZyBleHRlbnNpb24gKGlmIGFueSkgc3VjaCBhcyAnaW5kZXguaHRtbCdcbiAgICovXG4gIGJhc2U6IHN0cmluZztcbiAgLyoqXG4gICAqIFRoZSBmaWxlIGV4dGVuc2lvbiAoaWYgYW55KSBzdWNoIGFzICcuaHRtbCdcbiAgICovXG4gIGV4dDogc3RyaW5nO1xuICAvKipcbiAgICogVGhlIGZpbGUgbmFtZSB3aXRob3V0IGV4dGVuc2lvbiAoaWYgYW55KSBzdWNoIGFzICdpbmRleCdcbiAgICovXG4gIG5hbWU6IHN0cmluZztcbn1cblxuZXhwb3J0IHR5cGUgRm9ybWF0SW5wdXRQYXRoT2JqZWN0ID0gUGFydGlhbDxQYXJzZWRQYXRoPjtcbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwwRUFBMEU7QUFDMUUscUNBQXFDO0FBRXJDOztDQUVDLEdBQ0QifQ== \ No newline at end of file diff --git a/tests/__snapshots__/transpile/source/mapping.json b/tests/__snapshots__/transpile/source/mapping.json new file mode 100644 index 0000000..b81962b --- /dev/null +++ b/tests/__snapshots__/transpile/source/mapping.json @@ -0,0 +1,3 @@ +{ + "file:///src.ts": "FX-W_GgTo-jcLMQCWKy5udxEtG0.js" +} diff --git a/tests/__snapshots__/transpile/source/modules/FX-W_GgTo-jcLMQCWKy5udxEtG0.js b/tests/__snapshots__/transpile/source/modules/FX-W_GgTo-jcLMQCWKy5udxEtG0.js new file mode 100644 index 0000000..af83a0f --- /dev/null +++ b/tests/__snapshots__/transpile/source/modules/FX-W_GgTo-jcLMQCWKy5udxEtG0.js @@ -0,0 +1,4 @@ +export default function hello() { + return "Hello there!"; +} +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImZpbGU6Ly8vc3JjLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBkZWZhdWx0IGZ1bmN0aW9uIGhlbGxvKCk6IHN0cmluZyB7XG4gIHJldHVybiBcIkhlbGxvIHRoZXJlIVwiO1xufVxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGVBQWUsU0FBUyxRQUFnQjtJQUN0QyxPQUFPO0FBQ1QsQ0FBQyJ9 \ No newline at end of file diff --git a/tests/__snapshots__/transpile/url/mapping.json b/tests/__snapshots__/transpile/url/mapping.json new file mode 100644 index 0000000..02f1832 --- /dev/null +++ b/tests/__snapshots__/transpile/url/mapping.json @@ -0,0 +1,20 @@ +{ + "https://deno.land/std@0.140.0/_util/assert.ts": "nhMTTXGO1bgNtQ_bGZFJE0b7hWs.js", + "https://deno.land/std@0.140.0/_util/os.ts": "ebsv4XtKEF8sxrDsnkLX8K9VdOA.js", + "https://deno.land/std@0.140.0/bytes/bytes_list.ts": "p5wE1hCF6dGYMZ41YnIQs2go2is.js", + "https://deno.land/std@0.140.0/bytes/equals.ts": "jO4Cj24EIKVTiTvdPctAVhckzgg.js", + "https://deno.land/std@0.140.0/bytes/mod.ts": "WStdDhyHbKYy_C9CJ39RDks1VaY.js", + "https://deno.land/std@0.140.0/examples/chat/server.ts": "VR9N5EtRGYTL6BL2wtaFnqW-AuA.js", + "https://deno.land/std@0.140.0/io/buffer.ts": "npEsX-46oQUgZNw2Jkxv5i4eWDM.js", + "https://deno.land/std@0.140.0/io/types.d.ts": "7HctcYJMo9RPESb8_8SnGpYMx1U.js", + "https://deno.land/std@0.140.0/path/_constants.ts": "WzxVr2Q8XtUlLvHc6jsTVQR8Mnc.js", + "https://deno.land/std@0.140.0/path/_interface.ts": "wme9EIsCB7sfOz5qC_CSLRYajRk.js", + "https://deno.land/std@0.140.0/path/_util.ts": "7VWYTDioIHKQJaGRjtUtSbiHVG8.js", + "https://deno.land/std@0.140.0/path/common.ts": "WKh_-mE6UYta1pB11lfX_WOvFQ8.js", + "https://deno.land/std@0.140.0/path/glob.ts": "6asWNnLz5gIIvWCigeWDpbWva1Y.js", + "https://deno.land/std@0.140.0/path/mod.ts": "VUHr_YUyq8otV9YiIbexaSOfQCs.js", + "https://deno.land/std@0.140.0/path/posix.ts": "kWDlQkpYLFWxtJdAejga3vZCeeM.js", + "https://deno.land/std@0.140.0/path/separator.ts": "TPW77jtLW1NbcwGdiav4OHTJd6g.js", + "https://deno.land/std@0.140.0/path/win32.ts": "WPpXvFGuxwYeU5ay2bDrdG4fV_g.js", + "https://deno.land/std@0.140.0/streams/conversion.ts": "ZD3DgFZlCOXbEC8b6k6GmMtkN3g.js" +} diff --git a/tests/__snapshots__/transpile/url/modules/6asWNnLz5gIIvWCigeWDpbWva1Y.js b/tests/__snapshots__/transpile/url/modules/6asWNnLz5gIIvWCigeWDpbWva1Y.js new file mode 100644 index 0000000..bcb9c67 --- /dev/null +++ b/tests/__snapshots__/transpile/url/modules/6asWNnLz5gIIvWCigeWDpbWva1Y.js @@ -0,0 +1,346 @@ +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. +import { isWindows, osType } from "../_util/os.ts"; +import { SEP, SEP_PATTERN } from "./separator.ts"; +import * as _win32 from "./win32.ts"; +import * as _posix from "./posix.ts"; +const path = isWindows ? _win32 : _posix; +const { join , normalize } = path; +const regExpEscapeChars = [ + "!", + "$", + "(", + ")", + "*", + "+", + ".", + "=", + "?", + "[", + "\\", + "^", + "{", + "|" +]; +const rangeEscapeChars = [ + "-", + "\\", + "]" +]; +/** Convert a glob string to a regular expression. + * + * Tries to match bash glob expansion as closely as possible. + * + * Basic glob syntax: + * - `*` - Matches everything without leaving the path segment. + * - `?` - Matches any single character. + * - `{foo,bar}` - Matches `foo` or `bar`. + * - `[abcd]` - Matches `a`, `b`, `c` or `d`. + * - `[a-d]` - Matches `a`, `b`, `c` or `d`. + * - `[!abcd]` - Matches any single character besides `a`, `b`, `c` or `d`. + * - `[[::]]` - Matches any character belonging to ``. + * - `[[:alnum:]]` - Matches any digit or letter. + * - `[[:digit:]abc]` - Matches any digit, `a`, `b` or `c`. + * - See https://facelessuser.github.io/wcmatch/glob/#posix-character-classes + * for a complete list of supported character classes. + * - `\` - Escapes the next character for an `os` other than `"windows"`. + * - \` - Escapes the next character for `os` set to `"windows"`. + * - `/` - Path separator. + * - `\` - Additional path separator only for `os` set to `"windows"`. + * + * Extended syntax: + * - Requires `{ extended: true }`. + * - `?(foo|bar)` - Matches 0 or 1 instance of `{foo,bar}`. + * - `@(foo|bar)` - Matches 1 instance of `{foo,bar}`. They behave the same. + * - `*(foo|bar)` - Matches _n_ instances of `{foo,bar}`. + * - `+(foo|bar)` - Matches _n > 0_ instances of `{foo,bar}`. + * - `!(foo|bar)` - Matches anything other than `{foo,bar}`. + * - See https://www.linuxjournal.com/content/bash-extended-globbing. + * + * Globstar syntax: + * - Requires `{ globstar: true }`. + * - `**` - Matches any number of any path segments. + * - Must comprise its entire path segment in the provided glob. + * - See https://www.linuxjournal.com/content/globstar-new-bash-globbing-option. + * + * Note the following properties: + * - The generated `RegExp` is anchored at both start and end. + * - Repeating and trailing separators are tolerated. Trailing separators in the + * provided glob have no meaning and are discarded. + * - Absolute globs will only match absolute paths, etc. + * - Empty globs will match nothing. + * - Any special glob syntax must be contained to one path segment. For example, + * `?(foo|bar/baz)` is invalid. The separator will take precedence and the + * first segment ends with an unclosed group. + * - If a path segment ends with unclosed groups or a dangling escape prefix, a + * parse error has occurred. Every character for that segment is taken + * literally in this event. + * + * Limitations: + * - A negative group like `!(foo|bar)` will wrongly be converted to a negative + * look-ahead followed by a wildcard. This means that `!(foo).js` will wrongly + * fail to match `foobar.js`, even though `foobar` is not `foo`. Effectively, + * `!(foo|bar)` is treated like `!(@(foo|bar)*)`. This will work correctly if + * the group occurs not nested at the end of the segment. */ export function globToRegExp(glob, { extended =true , globstar: globstarOption = true , os =osType , caseInsensitive =false } = {}) { + if (glob == "") { + return /(?!)/; + } + const sep = os == "windows" ? "(?:\\\\|/)+" : "/+"; + const sepMaybe = os == "windows" ? "(?:\\\\|/)*" : "/*"; + const seps = os == "windows" ? [ + "\\", + "/" + ] : [ + "/" + ]; + const globstar = os == "windows" ? "(?:[^\\\\/]*(?:\\\\|/|$)+)*" : "(?:[^/]*(?:/|$)+)*"; + const wildcard = os == "windows" ? "[^\\\\/]*" : "[^/]*"; + const escapePrefix = os == "windows" ? "`" : "\\"; + // Remove trailing separators. + let newLength = glob.length; + for(; newLength > 1 && seps.includes(glob[newLength - 1]); newLength--); + glob = glob.slice(0, newLength); + let regExpString = ""; + // Terminates correctly. Trust that `j` is incremented every iteration. + for(let j = 0; j < glob.length;){ + let segment = ""; + const groupStack = []; + let inRange = false; + let inEscape = false; + let endsWithSep = false; + let i = j; + // Terminates with `i` at the non-inclusive end of the current segment. + for(; i < glob.length && !seps.includes(glob[i]); i++){ + if (inEscape) { + inEscape = false; + const escapeChars = inRange ? rangeEscapeChars : regExpEscapeChars; + segment += escapeChars.includes(glob[i]) ? `\\${glob[i]}` : glob[i]; + continue; + } + if (glob[i] == escapePrefix) { + inEscape = true; + continue; + } + if (glob[i] == "[") { + if (!inRange) { + inRange = true; + segment += "["; + if (glob[i + 1] == "!") { + i++; + segment += "^"; + } else if (glob[i + 1] == "^") { + i++; + segment += "\\^"; + } + continue; + } else if (glob[i + 1] == ":") { + let k = i + 1; + let value = ""; + while(glob[k + 1] != null && glob[k + 1] != ":"){ + value += glob[k + 1]; + k++; + } + if (glob[k + 1] == ":" && glob[k + 2] == "]") { + i = k + 2; + if (value == "alnum") segment += "\\dA-Za-z"; + else if (value == "alpha") segment += "A-Za-z"; + else if (value == "ascii") segment += "\x00-\x7F"; + else if (value == "blank") segment += "\t "; + else if (value == "cntrl") segment += "\x00-\x1F\x7F"; + else if (value == "digit") segment += "\\d"; + else if (value == "graph") segment += "\x21-\x7E"; + else if (value == "lower") segment += "a-z"; + else if (value == "print") segment += "\x20-\x7E"; + else if (value == "punct") { + segment += "!\"#$%&'()*+,\\-./:;<=>?@[\\\\\\]^_‘{|}~"; + } else if (value == "space") segment += "\\s\v"; + else if (value == "upper") segment += "A-Z"; + else if (value == "word") segment += "\\w"; + else if (value == "xdigit") segment += "\\dA-Fa-f"; + continue; + } + } + } + if (glob[i] == "]" && inRange) { + inRange = false; + segment += "]"; + continue; + } + if (inRange) { + if (glob[i] == "\\") { + segment += `\\\\`; + } else { + segment += glob[i]; + } + continue; + } + if (glob[i] == ")" && groupStack.length > 0 && groupStack[groupStack.length - 1] != "BRACE") { + segment += ")"; + const type = groupStack.pop(); + if (type == "!") { + segment += wildcard; + } else if (type != "@") { + segment += type; + } + continue; + } + if (glob[i] == "|" && groupStack.length > 0 && groupStack[groupStack.length - 1] != "BRACE") { + segment += "|"; + continue; + } + if (glob[i] == "+" && extended && glob[i + 1] == "(") { + i++; + groupStack.push("+"); + segment += "(?:"; + continue; + } + if (glob[i] == "@" && extended && glob[i + 1] == "(") { + i++; + groupStack.push("@"); + segment += "(?:"; + continue; + } + if (glob[i] == "?") { + if (extended && glob[i + 1] == "(") { + i++; + groupStack.push("?"); + segment += "(?:"; + } else { + segment += "."; + } + continue; + } + if (glob[i] == "!" && extended && glob[i + 1] == "(") { + i++; + groupStack.push("!"); + segment += "(?!"; + continue; + } + if (glob[i] == "{") { + groupStack.push("BRACE"); + segment += "(?:"; + continue; + } + if (glob[i] == "}" && groupStack[groupStack.length - 1] == "BRACE") { + groupStack.pop(); + segment += ")"; + continue; + } + if (glob[i] == "," && groupStack[groupStack.length - 1] == "BRACE") { + segment += "|"; + continue; + } + if (glob[i] == "*") { + if (extended && glob[i + 1] == "(") { + i++; + groupStack.push("*"); + segment += "(?:"; + } else { + const prevChar = glob[i - 1]; + let numStars = 1; + while(glob[i + 1] == "*"){ + i++; + numStars++; + } + const nextChar = glob[i + 1]; + if (globstarOption && numStars == 2 && [ + ...seps, + undefined + ].includes(prevChar) && [ + ...seps, + undefined + ].includes(nextChar)) { + segment += globstar; + endsWithSep = true; + } else { + segment += wildcard; + } + } + continue; + } + segment += regExpEscapeChars.includes(glob[i]) ? `\\${glob[i]}` : glob[i]; + } + // Check for unclosed groups or a dangling backslash. + if (groupStack.length > 0 || inRange || inEscape) { + // Parse failure. Take all characters from this segment literally. + segment = ""; + for (const c of glob.slice(j, i)){ + segment += regExpEscapeChars.includes(c) ? `\\${c}` : c; + endsWithSep = false; + } + } + regExpString += segment; + if (!endsWithSep) { + regExpString += i < glob.length ? sep : sepMaybe; + endsWithSep = true; + } + // Terminates with `i` at the start of the next segment. + while(seps.includes(glob[i]))i++; + // Check that the next value of `j` is indeed higher than the current value. + if (!(i > j)) { + throw new Error("Assertion failure: i > j (potential infinite loop)"); + } + j = i; + } + regExpString = `^${regExpString}$`; + return new RegExp(regExpString, caseInsensitive ? "i" : ""); +} +/** Test whether the given string is a glob */ export function isGlob(str) { + const chars = { + "{": "}", + "(": ")", + "[": "]" + }; + const regex = /\\(.)|(^!|\*|\?|[\].+)]\?|\[[^\\\]]+\]|\{[^\\}]+\}|\(\?[:!=][^\\)]+\)|\([^|]+\|[^\\)]+\))/; + if (str === "") { + return false; + } + let match; + while(match = regex.exec(str)){ + if (match[2]) return true; + let idx = match.index + match[0].length; + // if an open bracket/brace/paren is escaped, + // set the index to the next closing character + const open = match[1]; + const close = open ? chars[open] : null; + if (open && close) { + const n = str.indexOf(close, idx); + if (n !== -1) { + idx = n + 1; + } + } + str = str.slice(idx); + } + return false; +} +/** Like normalize(), but doesn't collapse "**\/.." when `globstar` is true. */ export function normalizeGlob(glob, { globstar =false } = {}) { + if (glob.match(/\0/g)) { + throw new Error(`Glob contains invalid characters: "${glob}"`); + } + if (!globstar) { + return normalize(glob); + } + const s = SEP_PATTERN.source; + const badParentPattern = new RegExp(`(?<=(${s}|^)\\*\\*${s})\\.\\.(?=${s}|$)`, "g"); + return normalize(glob.replace(badParentPattern, "\0")).replace(/\0/g, ".."); +} +/** Like join(), but doesn't collapse "**\/.." when `globstar` is true. */ export function joinGlobs(globs, { extended =true , globstar =false } = {}) { + if (!globstar || globs.length == 0) { + return join(...globs); + } + if (globs.length === 0) return "."; + let joined; + for (const glob of globs){ + const path = glob; + if (path.length > 0) { + if (!joined) joined = path; + else joined += `${SEP}${path}`; + } + } + if (!joined) return "."; + return normalizeGlob(joined, { + extended, + globstar + }); +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["https://deno.land/std@0.140.0/path/glob.ts"],"sourcesContent":["// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.\n// This module is browser compatible.\n\nimport { isWindows, osType } from \"../_util/os.ts\";\nimport { SEP, SEP_PATTERN } from \"./separator.ts\";\nimport * as _win32 from \"./win32.ts\";\nimport * as _posix from \"./posix.ts\";\nimport type { OSType } from \"../_util/os.ts\";\n\nconst path = isWindows ? _win32 : _posix;\nconst { join, normalize } = path;\n\nexport interface GlobOptions {\n  /** Extended glob syntax.\n   * See https://www.linuxjournal.com/content/bash-extended-globbing. Defaults\n   * to true. */\n  extended?: boolean;\n  /** Globstar syntax.\n   * See https://www.linuxjournal.com/content/globstar-new-bash-globbing-option.\n   * If false, `**` is treated like `*`. Defaults to true. */\n  globstar?: boolean;\n  /** Whether globstar should be case insensitive. */\n  caseInsensitive?: boolean;\n  /** Operating system. Defaults to the native OS. */\n  os?: OSType;\n}\n\nexport type GlobToRegExpOptions = GlobOptions;\n\nconst regExpEscapeChars = [\n  \"!\",\n  \"$\",\n  \"(\",\n  \")\",\n  \"*\",\n  \"+\",\n  \".\",\n  \"=\",\n  \"?\",\n  \"[\",\n  \"\\\\\",\n  \"^\",\n  \"{\",\n  \"|\",\n];\nconst rangeEscapeChars = [\"-\", \"\\\\\", \"]\"];\n\n/** Convert a glob string to a regular expression.\n *\n * Tries to match bash glob expansion as closely as possible.\n *\n * Basic glob syntax:\n * - `*` - Matches everything without leaving the path segment.\n * - `?` - Matches any single character.\n * - `{foo,bar}` - Matches `foo` or `bar`.\n * - `[abcd]` - Matches `a`, `b`, `c` or `d`.\n * - `[a-d]` - Matches `a`, `b`, `c` or `d`.\n * - `[!abcd]` - Matches any single character besides `a`, `b`, `c` or `d`.\n * - `[[:<class>:]]` - Matches any character belonging to `<class>`.\n *     - `[[:alnum:]]` - Matches any digit or letter.\n *     - `[[:digit:]abc]` - Matches any digit, `a`, `b` or `c`.\n *     - See https://facelessuser.github.io/wcmatch/glob/#posix-character-classes\n *       for a complete list of supported character classes.\n * - `\\` - Escapes the next character for an `os` other than `\"windows\"`.\n * - \\` - Escapes the next character for `os` set to `\"windows\"`.\n * - `/` - Path separator.\n * - `\\` - Additional path separator only for `os` set to `\"windows\"`.\n *\n * Extended syntax:\n * - Requires `{ extended: true }`.\n * - `?(foo|bar)` - Matches 0 or 1 instance of `{foo,bar}`.\n * - `@(foo|bar)` - Matches 1 instance of `{foo,bar}`. They behave the same.\n * - `*(foo|bar)` - Matches _n_ instances of `{foo,bar}`.\n * - `+(foo|bar)` - Matches _n > 0_ instances of `{foo,bar}`.\n * - `!(foo|bar)` - Matches anything other than `{foo,bar}`.\n * - See https://www.linuxjournal.com/content/bash-extended-globbing.\n *\n * Globstar syntax:\n * - Requires `{ globstar: true }`.\n * - `**` - Matches any number of any path segments.\n *     - Must comprise its entire path segment in the provided glob.\n * - See https://www.linuxjournal.com/content/globstar-new-bash-globbing-option.\n *\n * Note the following properties:\n * - The generated `RegExp` is anchored at both start and end.\n * - Repeating and trailing separators are tolerated. Trailing separators in the\n *   provided glob have no meaning and are discarded.\n * - Absolute globs will only match absolute paths, etc.\n * - Empty globs will match nothing.\n * - Any special glob syntax must be contained to one path segment. For example,\n *   `?(foo|bar/baz)` is invalid. The separator will take precedence and the\n *   first segment ends with an unclosed group.\n * - If a path segment ends with unclosed groups or a dangling escape prefix, a\n *   parse error has occurred. Every character for that segment is taken\n *   literally in this event.\n *\n * Limitations:\n * - A negative group like `!(foo|bar)` will wrongly be converted to a negative\n *   look-ahead followed by a wildcard. This means that `!(foo).js` will wrongly\n *   fail to match `foobar.js`, even though `foobar` is not `foo`. Effectively,\n *   `!(foo|bar)` is treated like `!(@(foo|bar)*)`. This will work correctly if\n *   the group occurs not nested at the end of the segment. */\nexport function globToRegExp(\n  glob: string,\n  {\n    extended = true,\n    globstar: globstarOption = true,\n    os = osType,\n    caseInsensitive = false,\n  }: GlobToRegExpOptions = {},\n): RegExp {\n  if (glob == \"\") {\n    return /(?!)/;\n  }\n\n  const sep = os == \"windows\" ? \"(?:\\\\\\\\|/)+\" : \"/+\";\n  const sepMaybe = os == \"windows\" ? \"(?:\\\\\\\\|/)*\" : \"/*\";\n  const seps = os == \"windows\" ? [\"\\\\\", \"/\"] : [\"/\"];\n  const globstar = os == \"windows\"\n    ? \"(?:[^\\\\\\\\/]*(?:\\\\\\\\|/|$)+)*\"\n    : \"(?:[^/]*(?:/|$)+)*\";\n  const wildcard = os == \"windows\" ? \"[^\\\\\\\\/]*\" : \"[^/]*\";\n  const escapePrefix = os == \"windows\" ? \"`\" : \"\\\\\";\n\n  // Remove trailing separators.\n  let newLength = glob.length;\n  for (; newLength > 1 && seps.includes(glob[newLength - 1]); newLength--);\n  glob = glob.slice(0, newLength);\n\n  let regExpString = \"\";\n\n  // Terminates correctly. Trust that `j` is incremented every iteration.\n  for (let j = 0; j < glob.length;) {\n    let segment = \"\";\n    const groupStack: string[] = [];\n    let inRange = false;\n    let inEscape = false;\n    let endsWithSep = false;\n    let i = j;\n\n    // Terminates with `i` at the non-inclusive end of the current segment.\n    for (; i < glob.length && !seps.includes(glob[i]); i++) {\n      if (inEscape) {\n        inEscape = false;\n        const escapeChars = inRange ? rangeEscapeChars : regExpEscapeChars;\n        segment += escapeChars.includes(glob[i]) ? `\\\\${glob[i]}` : glob[i];\n        continue;\n      }\n\n      if (glob[i] == escapePrefix) {\n        inEscape = true;\n        continue;\n      }\n\n      if (glob[i] == \"[\") {\n        if (!inRange) {\n          inRange = true;\n          segment += \"[\";\n          if (glob[i + 1] == \"!\") {\n            i++;\n            segment += \"^\";\n          } else if (glob[i + 1] == \"^\") {\n            i++;\n            segment += \"\\\\^\";\n          }\n          continue;\n        } else if (glob[i + 1] == \":\") {\n          let k = i + 1;\n          let value = \"\";\n          while (glob[k + 1] != null && glob[k + 1] != \":\") {\n            value += glob[k + 1];\n            k++;\n          }\n          if (glob[k + 1] == \":\" && glob[k + 2] == \"]\") {\n            i = k + 2;\n            if (value == \"alnum\") segment += \"\\\\dA-Za-z\";\n            else if (value == \"alpha\") segment += \"A-Za-z\";\n            else if (value == \"ascii\") segment += \"\\x00-\\x7F\";\n            else if (value == \"blank\") segment += \"\\t \";\n            else if (value == \"cntrl\") segment += \"\\x00-\\x1F\\x7F\";\n            else if (value == \"digit\") segment += \"\\\\d\";\n            else if (value == \"graph\") segment += \"\\x21-\\x7E\";\n            else if (value == \"lower\") segment += \"a-z\";\n            else if (value == \"print\") segment += \"\\x20-\\x7E\";\n            else if (value == \"punct\") {\n              segment += \"!\\\"#$%&'()*+,\\\\-./:;<=>?@[\\\\\\\\\\\\]^_‘{|}~\";\n            } else if (value == \"space\") segment += \"\\\\s\\v\";\n            else if (value == \"upper\") segment += \"A-Z\";\n            else if (value == \"word\") segment += \"\\\\w\";\n            else if (value == \"xdigit\") segment += \"\\\\dA-Fa-f\";\n            continue;\n          }\n        }\n      }\n\n      if (glob[i] == \"]\" && inRange) {\n        inRange = false;\n        segment += \"]\";\n        continue;\n      }\n\n      if (inRange) {\n        if (glob[i] == \"\\\\\") {\n          segment += `\\\\\\\\`;\n        } else {\n          segment += glob[i];\n        }\n        continue;\n      }\n\n      if (\n        glob[i] == \")\" && groupStack.length > 0 &&\n        groupStack[groupStack.length - 1] != \"BRACE\"\n      ) {\n        segment += \")\";\n        const type = groupStack.pop()!;\n        if (type == \"!\") {\n          segment += wildcard;\n        } else if (type != \"@\") {\n          segment += type;\n        }\n        continue;\n      }\n\n      if (\n        glob[i] == \"|\" && groupStack.length > 0 &&\n        groupStack[groupStack.length - 1] != \"BRACE\"\n      ) {\n        segment += \"|\";\n        continue;\n      }\n\n      if (glob[i] == \"+\" && extended && glob[i + 1] == \"(\") {\n        i++;\n        groupStack.push(\"+\");\n        segment += \"(?:\";\n        continue;\n      }\n\n      if (glob[i] == \"@\" && extended && glob[i + 1] == \"(\") {\n        i++;\n        groupStack.push(\"@\");\n        segment += \"(?:\";\n        continue;\n      }\n\n      if (glob[i] == \"?\") {\n        if (extended && glob[i + 1] == \"(\") {\n          i++;\n          groupStack.push(\"?\");\n          segment += \"(?:\";\n        } else {\n          segment += \".\";\n        }\n        continue;\n      }\n\n      if (glob[i] == \"!\" && extended && glob[i + 1] == \"(\") {\n        i++;\n        groupStack.push(\"!\");\n        segment += \"(?!\";\n        continue;\n      }\n\n      if (glob[i] == \"{\") {\n        groupStack.push(\"BRACE\");\n        segment += \"(?:\";\n        continue;\n      }\n\n      if (glob[i] == \"}\" && groupStack[groupStack.length - 1] == \"BRACE\") {\n        groupStack.pop();\n        segment += \")\";\n        continue;\n      }\n\n      if (glob[i] == \",\" && groupStack[groupStack.length - 1] == \"BRACE\") {\n        segment += \"|\";\n        continue;\n      }\n\n      if (glob[i] == \"*\") {\n        if (extended && glob[i + 1] == \"(\") {\n          i++;\n          groupStack.push(\"*\");\n          segment += \"(?:\";\n        } else {\n          const prevChar = glob[i - 1];\n          let numStars = 1;\n          while (glob[i + 1] == \"*\") {\n            i++;\n            numStars++;\n          }\n          const nextChar = glob[i + 1];\n          if (\n            globstarOption && numStars == 2 &&\n            [...seps, undefined].includes(prevChar) &&\n            [...seps, undefined].includes(nextChar)\n          ) {\n            segment += globstar;\n            endsWithSep = true;\n          } else {\n            segment += wildcard;\n          }\n        }\n        continue;\n      }\n\n      segment += regExpEscapeChars.includes(glob[i]) ? `\\\\${glob[i]}` : glob[i];\n    }\n\n    // Check for unclosed groups or a dangling backslash.\n    if (groupStack.length > 0 || inRange || inEscape) {\n      // Parse failure. Take all characters from this segment literally.\n      segment = \"\";\n      for (const c of glob.slice(j, i)) {\n        segment += regExpEscapeChars.includes(c) ? `\\\\${c}` : c;\n        endsWithSep = false;\n      }\n    }\n\n    regExpString += segment;\n    if (!endsWithSep) {\n      regExpString += i < glob.length ? sep : sepMaybe;\n      endsWithSep = true;\n    }\n\n    // Terminates with `i` at the start of the next segment.\n    while (seps.includes(glob[i])) i++;\n\n    // Check that the next value of `j` is indeed higher than the current value.\n    if (!(i > j)) {\n      throw new Error(\"Assertion failure: i > j (potential infinite loop)\");\n    }\n    j = i;\n  }\n\n  regExpString = `^${regExpString}$`;\n  return new RegExp(regExpString, caseInsensitive ? \"i\" : \"\");\n}\n\n/** Test whether the given string is a glob */\nexport function isGlob(str: string): boolean {\n  const chars: Record<string, string> = { \"{\": \"}\", \"(\": \")\", \"[\": \"]\" };\n  const regex =\n    /\\\\(.)|(^!|\\*|\\?|[\\].+)]\\?|\\[[^\\\\\\]]+\\]|\\{[^\\\\}]+\\}|\\(\\?[:!=][^\\\\)]+\\)|\\([^|]+\\|[^\\\\)]+\\))/;\n\n  if (str === \"\") {\n    return false;\n  }\n\n  let match: RegExpExecArray | null;\n\n  while ((match = regex.exec(str))) {\n    if (match[2]) return true;\n    let idx = match.index + match[0].length;\n\n    // if an open bracket/brace/paren is escaped,\n    // set the index to the next closing character\n    const open = match[1];\n    const close = open ? chars[open] : null;\n    if (open && close) {\n      const n = str.indexOf(close, idx);\n      if (n !== -1) {\n        idx = n + 1;\n      }\n    }\n\n    str = str.slice(idx);\n  }\n\n  return false;\n}\n\n/** Like normalize(), but doesn't collapse \"**\\/..\" when `globstar` is true. */\nexport function normalizeGlob(\n  glob: string,\n  { globstar = false }: GlobOptions = {},\n): string {\n  if (glob.match(/\\0/g)) {\n    throw new Error(`Glob contains invalid characters: \"${glob}\"`);\n  }\n  if (!globstar) {\n    return normalize(glob);\n  }\n  const s = SEP_PATTERN.source;\n  const badParentPattern = new RegExp(\n    `(?<=(${s}|^)\\\\*\\\\*${s})\\\\.\\\\.(?=${s}|$)`,\n    \"g\",\n  );\n  return normalize(glob.replace(badParentPattern, \"\\0\")).replace(/\\0/g, \"..\");\n}\n\n/** Like join(), but doesn't collapse \"**\\/..\" when `globstar` is true. */\nexport function joinGlobs(\n  globs: string[],\n  { extended = true, globstar = false }: GlobOptions = {},\n): string {\n  if (!globstar || globs.length == 0) {\n    return join(...globs);\n  }\n  if (globs.length === 0) return \".\";\n  let joined: string | undefined;\n  for (const glob of globs) {\n    const path = glob;\n    if (path.length > 0) {\n      if (!joined) joined = path;\n      else joined += `${SEP}${path}`;\n    }\n  }\n  if (!joined) return \".\";\n  return normalizeGlob(joined, { extended, globstar });\n}\n"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/tests/__snapshots__/transpile/url/modules/7HctcYJMo9RPESb8_8SnGpYMx1U.js b/tests/__snapshots__/transpile/url/modules/7HctcYJMo9RPESb8_8SnGpYMx1U.js new file mode 100644 index 0000000..b7663e5 --- /dev/null +++ b/tests/__snapshots__/transpile/url/modules/7HctcYJMo9RPESb8_8SnGpYMx1U.js @@ -0,0 +1,2 @@ +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/tests/__snapshots__/transpile/url/modules/7VWYTDioIHKQJaGRjtUtSbiHVG8.js b/tests/__snapshots__/transpile/url/modules/7VWYTDioIHKQJaGRjtUtSbiHVG8.js new file mode 100644 index 0000000..18b20d4 --- /dev/null +++ b/tests/__snapshots__/transpile/url/modules/7VWYTDioIHKQJaGRjtUtSbiHVG8.js @@ -0,0 +1,96 @@ +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +// Copyright the Browserify authors. MIT License. +// Ported from https://github.com/browserify/path-browserify/ +// This module is browser compatible. +import { CHAR_BACKWARD_SLASH, CHAR_DOT, CHAR_FORWARD_SLASH, CHAR_LOWERCASE_A, CHAR_LOWERCASE_Z, CHAR_UPPERCASE_A, CHAR_UPPERCASE_Z } from "./_constants.ts"; +export function assertPath(path) { + if (typeof path !== "string") { + throw new TypeError(`Path must be a string. Received ${JSON.stringify(path)}`); + } +} +export function isPosixPathSeparator(code) { + return code === CHAR_FORWARD_SLASH; +} +export function isPathSeparator(code) { + return isPosixPathSeparator(code) || code === CHAR_BACKWARD_SLASH; +} +export function isWindowsDeviceRoot(code) { + return code >= CHAR_LOWERCASE_A && code <= CHAR_LOWERCASE_Z || code >= CHAR_UPPERCASE_A && code <= CHAR_UPPERCASE_Z; +} +// Resolves . and .. elements in a path with directory names +export function normalizeString(path, allowAboveRoot, separator, isPathSeparator) { + let res = ""; + let lastSegmentLength = 0; + let lastSlash = -1; + let dots = 0; + let code; + for(let i = 0, len = path.length; i <= len; ++i){ + if (i < len) code = path.charCodeAt(i); + else if (isPathSeparator(code)) break; + else code = CHAR_FORWARD_SLASH; + if (isPathSeparator(code)) { + if (lastSlash === i - 1 || dots === 1) { + // NOOP + } else if (lastSlash !== i - 1 && dots === 2) { + if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== CHAR_DOT || res.charCodeAt(res.length - 2) !== CHAR_DOT) { + if (res.length > 2) { + const lastSlashIndex = res.lastIndexOf(separator); + if (lastSlashIndex === -1) { + res = ""; + lastSegmentLength = 0; + } else { + res = res.slice(0, lastSlashIndex); + lastSegmentLength = res.length - 1 - res.lastIndexOf(separator); + } + lastSlash = i; + dots = 0; + continue; + } else if (res.length === 2 || res.length === 1) { + res = ""; + lastSegmentLength = 0; + lastSlash = i; + dots = 0; + continue; + } + } + if (allowAboveRoot) { + if (res.length > 0) res += `${separator}..`; + else res = ".."; + lastSegmentLength = 2; + } + } else { + if (res.length > 0) res += separator + path.slice(lastSlash + 1, i); + else res = path.slice(lastSlash + 1, i); + lastSegmentLength = i - lastSlash - 1; + } + lastSlash = i; + dots = 0; + } else if (code === CHAR_DOT && dots !== -1) { + ++dots; + } else { + dots = -1; + } + } + return res; +} +export function _format(sep, pathObject) { + const dir = pathObject.dir || pathObject.root; + const base = pathObject.base || (pathObject.name || "") + (pathObject.ext || ""); + if (!dir) return base; + if (dir === pathObject.root) return dir + base; + return dir + sep + base; +} +const WHITESPACE_ENCODINGS = { + "\u0009": "%09", + "\u000A": "%0A", + "\u000B": "%0B", + "\u000C": "%0C", + "\u000D": "%0D", + "\u0020": "%20" +}; +export function encodeWhitespace(string) { + return string.replaceAll(/[\s]/g, (c)=>{ + return WHITESPACE_ENCODINGS[c] ?? c; + }); +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["https://deno.land/std@0.140.0/path/_util.ts"],"sourcesContent":["// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.\n// Copyright the Browserify authors. MIT License.\n// Ported from https://github.com/browserify/path-browserify/\n// This module is browser compatible.\n\nimport type { FormatInputPathObject } from \"./_interface.ts\";\nimport {\n  CHAR_BACKWARD_SLASH,\n  CHAR_DOT,\n  CHAR_FORWARD_SLASH,\n  CHAR_LOWERCASE_A,\n  CHAR_LOWERCASE_Z,\n  CHAR_UPPERCASE_A,\n  CHAR_UPPERCASE_Z,\n} from \"./_constants.ts\";\n\nexport function assertPath(path: string): void {\n  if (typeof path !== \"string\") {\n    throw new TypeError(\n      `Path must be a string. Received ${JSON.stringify(path)}`,\n    );\n  }\n}\n\nexport function isPosixPathSeparator(code: number): boolean {\n  return code === CHAR_FORWARD_SLASH;\n}\n\nexport function isPathSeparator(code: number): boolean {\n  return isPosixPathSeparator(code) || code === CHAR_BACKWARD_SLASH;\n}\n\nexport function isWindowsDeviceRoot(code: number): boolean {\n  return (\n    (code >= CHAR_LOWERCASE_A && code <= CHAR_LOWERCASE_Z) ||\n    (code >= CHAR_UPPERCASE_A && code <= CHAR_UPPERCASE_Z)\n  );\n}\n\n// Resolves . and .. elements in a path with directory names\nexport function normalizeString(\n  path: string,\n  allowAboveRoot: boolean,\n  separator: string,\n  isPathSeparator: (code: number) => boolean,\n): string {\n  let res = \"\";\n  let lastSegmentLength = 0;\n  let lastSlash = -1;\n  let dots = 0;\n  let code: number | undefined;\n  for (let i = 0, len = path.length; i <= len; ++i) {\n    if (i < len) code = path.charCodeAt(i);\n    else if (isPathSeparator(code!)) break;\n    else code = CHAR_FORWARD_SLASH;\n\n    if (isPathSeparator(code!)) {\n      if (lastSlash === i - 1 || dots === 1) {\n        // NOOP\n      } else if (lastSlash !== i - 1 && dots === 2) {\n        if (\n          res.length < 2 ||\n          lastSegmentLength !== 2 ||\n          res.charCodeAt(res.length - 1) !== CHAR_DOT ||\n          res.charCodeAt(res.length - 2) !== CHAR_DOT\n        ) {\n          if (res.length > 2) {\n            const lastSlashIndex = res.lastIndexOf(separator);\n            if (lastSlashIndex === -1) {\n              res = \"\";\n              lastSegmentLength = 0;\n            } else {\n              res = res.slice(0, lastSlashIndex);\n              lastSegmentLength = res.length - 1 - res.lastIndexOf(separator);\n            }\n            lastSlash = i;\n            dots = 0;\n            continue;\n          } else if (res.length === 2 || res.length === 1) {\n            res = \"\";\n            lastSegmentLength = 0;\n            lastSlash = i;\n            dots = 0;\n            continue;\n          }\n        }\n        if (allowAboveRoot) {\n          if (res.length > 0) res += `${separator}..`;\n          else res = \"..\";\n          lastSegmentLength = 2;\n        }\n      } else {\n        if (res.length > 0) res += separator + path.slice(lastSlash + 1, i);\n        else res = path.slice(lastSlash + 1, i);\n        lastSegmentLength = i - lastSlash - 1;\n      }\n      lastSlash = i;\n      dots = 0;\n    } else if (code === CHAR_DOT && dots !== -1) {\n      ++dots;\n    } else {\n      dots = -1;\n    }\n  }\n  return res;\n}\n\nexport function _format(\n  sep: string,\n  pathObject: FormatInputPathObject,\n): string {\n  const dir: string | undefined = pathObject.dir || pathObject.root;\n  const base: string = pathObject.base ||\n    (pathObject.name || \"\") + (pathObject.ext || \"\");\n  if (!dir) return base;\n  if (dir === pathObject.root) return dir + base;\n  return dir + sep + base;\n}\n\nconst WHITESPACE_ENCODINGS: Record<string, string> = {\n  \"\\u0009\": \"%09\",\n  \"\\u000A\": \"%0A\",\n  \"\\u000B\": \"%0B\",\n  \"\\u000C\": \"%0C\",\n  \"\\u000D\": \"%0D\",\n  \"\\u0020\": \"%20\",\n};\n\nexport function encodeWhitespace(string: string): string {\n  return string.replaceAll(/[\\s]/g, (c) => {\n    return WHITESPACE_ENCODINGS[c] ?? c;\n  });\n}\n"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/tests/__snapshots__/transpile/url/modules/TPW77jtLW1NbcwGdiav4OHTJd6g.js b/tests/__snapshots__/transpile/url/modules/TPW77jtLW1NbcwGdiav4OHTJd6g.js new file mode 100644 index 0000000..f7ecf64 --- /dev/null +++ b/tests/__snapshots__/transpile/url/modules/TPW77jtLW1NbcwGdiav4OHTJd6g.js @@ -0,0 +1,6 @@ +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. +import { isWindows } from "../_util/os.ts"; +export const SEP = isWindows ? "\\" : "/"; +export const SEP_PATTERN = isWindows ? /[\\/]+/ : /\/+/; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImh0dHBzOi8vZGVuby5sYW5kL3N0ZEAwLjE0MC4wL3BhdGgvc2VwYXJhdG9yLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAyMDE4LTIwMjIgdGhlIERlbm8gYXV0aG9ycy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gTUlUIGxpY2Vuc2UuXG4vLyBUaGlzIG1vZHVsZSBpcyBicm93c2VyIGNvbXBhdGlibGUuXG5cbmltcG9ydCB7IGlzV2luZG93cyB9IGZyb20gXCIuLi9fdXRpbC9vcy50c1wiO1xuXG5leHBvcnQgY29uc3QgU0VQID0gaXNXaW5kb3dzID8gXCJcXFxcXCIgOiBcIi9cIjtcbmV4cG9ydCBjb25zdCBTRVBfUEFUVEVSTiA9IGlzV2luZG93cyA/IC9bXFxcXC9dKy8gOiAvXFwvKy87XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsMEVBQTBFO0FBQzFFLHFDQUFxQztBQUVyQyxTQUFTLFNBQVMsUUFBUSxpQkFBaUI7QUFFM0MsT0FBTyxNQUFNLE1BQU0sWUFBWSxPQUFPLEdBQUcsQ0FBQztBQUMxQyxPQUFPLE1BQU0sY0FBYyxZQUFZLFdBQVcsS0FBSyxDQUFDIn0= \ No newline at end of file diff --git a/tests/__snapshots__/transpile/url/modules/VR9N5EtRGYTL6BL2wtaFnqW-AuA.js b/tests/__snapshots__/transpile/url/modules/VR9N5EtRGYTL6BL2wtaFnqW-AuA.js new file mode 100644 index 0000000..ef1880e --- /dev/null +++ b/tests/__snapshots__/transpile/url/modules/VR9N5EtRGYTL6BL2wtaFnqW-AuA.js @@ -0,0 +1,72 @@ +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +import { fromFileUrl } from "../../path/mod.ts"; +import { readableStreamFromReader } from "../../streams/conversion.ts"; +const clients = new Map(); +let clientId = 0; +function dispatch(msg) { + for (const client of clients.values()){ + client.send(msg); + } +} +function wsHandler(ws) { + const id = ++clientId; + clients.set(id, ws); + ws.onopen = ()=>{ + dispatch(`Connected: [${id}]`); + }; + ws.onmessage = (e)=>{ + console.log(`msg:${id}`, e.data); + dispatch(`[${id}]: ${e.data}`); + }; + ws.onclose = ()=>{ + clients.delete(id); + dispatch(`Closed: [${id}]`); + }; +} +async function requestHandler(req) { + const pathname = new URL(req.request.url).pathname; + if (req.request.method === "GET" && pathname === "/") { + //Serve with hack + const u = new URL("./index.html", import.meta.url); + if (u.protocol.startsWith("http")) { + // server launched by deno run http(s)://.../server.ts, + fetch(u.href).then(async (resp)=>{ + const body = new Uint8Array(await resp.arrayBuffer()); + req.respondWith(new Response(body, { + status: resp.status, + headers: { + "content-type": "text/html" + } + })); + }); + } else { + // server launched by deno run ./server.ts + const file = await Deno.open(fromFileUrl(u)); + req.respondWith(new Response(readableStreamFromReader(file), { + status: 200, + headers: { + "content-type": "text/html" + } + })); + } + } else if (req.request.method === "GET" && pathname === "/favicon.ico") { + req.respondWith(Response.redirect("https://deno.land/favicon.ico", 302)); + } else if (req.request.method === "GET" && pathname === "/ws") { + const { socket , response } = Deno.upgradeWebSocket(req.request); + wsHandler(socket); + req.respondWith(response); + } +} +const server = Deno.listen({ + port: 8080 +}); +console.log("chat server starting on :8080...."); +for await (const conn of server){ + (async ()=>{ + const httpConn = Deno.serveHttp(conn); + for await (const requestEvent of httpConn){ + requestHandler(requestEvent); + } + })(); +} +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/tests/__snapshots__/transpile/url/modules/VUHr_YUyq8otV9YiIbexaSOfQCs.js b/tests/__snapshots__/transpile/url/modules/VUHr_YUyq8otV9YiIbexaSOfQCs.js new file mode 100644 index 0000000..3ee16ef --- /dev/null +++ b/tests/__snapshots__/transpile/url/modules/VUHr_YUyq8otV9YiIbexaSOfQCs.js @@ -0,0 +1,18 @@ +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +// Copyright the Browserify authors. MIT License. +/** + * Ported mostly from https://github.com/browserify/path-browserify/ + * This module is browser compatible. + * @module + */ import { isWindows } from "../_util/os.ts"; +import * as _win32 from "./win32.ts"; +import * as _posix from "./posix.ts"; +const path = isWindows ? _win32 : _posix; +export const win32 = _win32; +export const posix = _posix; +export const { basename , delimiter , dirname , extname , format , fromFileUrl , isAbsolute , join , normalize , parse , relative , resolve , sep , toFileUrl , toNamespacedPath } = path; +export * from "./common.ts"; +export { SEP, SEP_PATTERN } from "./separator.ts"; +export * from "./_interface.ts"; +export * from "./glob.ts"; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImh0dHBzOi8vZGVuby5sYW5kL3N0ZEAwLjE0MC4wL3BhdGgvbW9kLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAyMDE4LTIwMjIgdGhlIERlbm8gYXV0aG9ycy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gTUlUIGxpY2Vuc2UuXG4vLyBDb3B5cmlnaHQgdGhlIEJyb3dzZXJpZnkgYXV0aG9ycy4gTUlUIExpY2Vuc2UuXG5cbi8qKlxuICogUG9ydGVkIG1vc3RseSBmcm9tIGh0dHBzOi8vZ2l0aHViLmNvbS9icm93c2VyaWZ5L3BhdGgtYnJvd3NlcmlmeS9cbiAqIFRoaXMgbW9kdWxlIGlzIGJyb3dzZXIgY29tcGF0aWJsZS5cbiAqIEBtb2R1bGVcbiAqL1xuXG5pbXBvcnQgeyBpc1dpbmRvd3MgfSBmcm9tIFwiLi4vX3V0aWwvb3MudHNcIjtcbmltcG9ydCAqIGFzIF93aW4zMiBmcm9tIFwiLi93aW4zMi50c1wiO1xuaW1wb3J0ICogYXMgX3Bvc2l4IGZyb20gXCIuL3Bvc2l4LnRzXCI7XG5cbmNvbnN0IHBhdGggPSBpc1dpbmRvd3MgPyBfd2luMzIgOiBfcG9zaXg7XG5cbmV4cG9ydCBjb25zdCB3aW4zMiA9IF93aW4zMjtcbmV4cG9ydCBjb25zdCBwb3NpeCA9IF9wb3NpeDtcbmV4cG9ydCBjb25zdCB7XG4gIGJhc2VuYW1lLFxuICBkZWxpbWl0ZXIsXG4gIGRpcm5hbWUsXG4gIGV4dG5hbWUsXG4gIGZvcm1hdCxcbiAgZnJvbUZpbGVVcmwsXG4gIGlzQWJzb2x1dGUsXG4gIGpvaW4sXG4gIG5vcm1hbGl6ZSxcbiAgcGFyc2UsXG4gIHJlbGF0aXZlLFxuICByZXNvbHZlLFxuICBzZXAsXG4gIHRvRmlsZVVybCxcbiAgdG9OYW1lc3BhY2VkUGF0aCxcbn0gPSBwYXRoO1xuXG5leHBvcnQgKiBmcm9tIFwiLi9jb21tb24udHNcIjtcbmV4cG9ydCB7IFNFUCwgU0VQX1BBVFRFUk4gfSBmcm9tIFwiLi9zZXBhcmF0b3IudHNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL19pbnRlcmZhY2UudHNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2dsb2IudHNcIjtcbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwwRUFBMEU7QUFDMUUsaURBQWlEO0FBRWpEOzs7O0NBSUMsR0FFRCxTQUFTLFNBQVMsUUFBUSxpQkFBaUI7QUFDM0MsWUFBWSxZQUFZLGFBQWE7QUFDckMsWUFBWSxZQUFZLGFBQWE7QUFFckMsTUFBTSxPQUFPLFlBQVksU0FBUyxNQUFNO0FBRXhDLE9BQU8sTUFBTSxRQUFRLE9BQU87QUFDNUIsT0FBTyxNQUFNLFFBQVEsT0FBTztBQUM1QixPQUFPLE1BQU0sRUFDWCxTQUFRLEVBQ1IsVUFBUyxFQUNULFFBQU8sRUFDUCxRQUFPLEVBQ1AsT0FBTSxFQUNOLFlBQVcsRUFDWCxXQUFVLEVBQ1YsS0FBSSxFQUNKLFVBQVMsRUFDVCxNQUFLLEVBQ0wsU0FBUSxFQUNSLFFBQU8sRUFDUCxJQUFHLEVBQ0gsVUFBUyxFQUNULGlCQUFnQixFQUNqQixHQUFHLEtBQUs7QUFFVCxjQUFjLGNBQWM7QUFDNUIsU0FBUyxHQUFHLEVBQUUsV0FBVyxRQUFRLGlCQUFpQjtBQUNsRCxjQUFjLGtCQUFrQjtBQUNoQyxjQUFjLFlBQVkifQ== \ No newline at end of file diff --git a/tests/__snapshots__/transpile/url/modules/WKh_-mE6UYta1pB11lfX_WOvFQ8.js b/tests/__snapshots__/transpile/url/modules/WKh_-mE6UYta1pB11lfX_WOvFQ8.js new file mode 100644 index 0000000..a5d3b86 --- /dev/null +++ b/tests/__snapshots__/transpile/url/modules/WKh_-mE6UYta1pB11lfX_WOvFQ8.js @@ -0,0 +1,36 @@ +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. +import { SEP } from "./separator.ts"; +/** Determines the common path from a set of paths, using an optional separator, + * which defaults to the OS default separator. + * + * ```ts + * import { common } from "https://deno.land/std@$STD_VERSION/path/mod.ts"; + * const p = common([ + * "./deno/std/path/mod.ts", + * "./deno/std/fs/mod.ts", + * ]); + * console.log(p); // "./deno/std/" + * ``` + */ export function common(paths, sep = SEP) { + const [first = "", ...remaining] = paths; + if (first === "" || remaining.length === 0) { + return first.substring(0, first.lastIndexOf(sep) + 1); + } + const parts = first.split(sep); + let endOfPrefix = parts.length; + for (const path of remaining){ + const compare = path.split(sep); + for(let i = 0; i < endOfPrefix; i++){ + if (compare[i] !== parts[i]) { + endOfPrefix = i; + } + } + if (endOfPrefix === 0) { + return ""; + } + } + const prefix = parts.slice(0, endOfPrefix).join(sep); + return prefix.endsWith(sep) ? prefix : `${prefix}${sep}`; +} +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/tests/__snapshots__/transpile/url/modules/WPpXvFGuxwYeU5ay2bDrdG4fV_g.js b/tests/__snapshots__/transpile/url/modules/WPpXvFGuxwYeU5ay2bDrdG4fV_g.js new file mode 100644 index 0000000..ca8ef1e --- /dev/null +++ b/tests/__snapshots__/transpile/url/modules/WPpXvFGuxwYeU5ay2bDrdG4fV_g.js @@ -0,0 +1,852 @@ +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +// Copyright the Browserify authors. MIT License. +// Ported from https://github.com/browserify/path-browserify/ +// This module is browser compatible. +import { CHAR_BACKWARD_SLASH, CHAR_COLON, CHAR_DOT, CHAR_QUESTION_MARK } from "./_constants.ts"; +import { _format, assertPath, encodeWhitespace, isPathSeparator, isWindowsDeviceRoot, normalizeString } from "./_util.ts"; +import { assert } from "../_util/assert.ts"; +export const sep = "\\"; +export const delimiter = ";"; +/** + * Resolves path segments into a `path` + * @param pathSegments to process to path + */ export function resolve(...pathSegments) { + let resolvedDevice = ""; + let resolvedTail = ""; + let resolvedAbsolute = false; + for(let i = pathSegments.length - 1; i >= -1; i--){ + let path; + // deno-lint-ignore no-explicit-any + const { Deno } = globalThis; + if (i >= 0) { + path = pathSegments[i]; + } else if (!resolvedDevice) { + if (typeof Deno?.cwd !== "function") { + throw new TypeError("Resolved a drive-letter-less path without a CWD."); + } + path = Deno.cwd(); + } else { + if (typeof Deno?.env?.get !== "function" || typeof Deno?.cwd !== "function") { + throw new TypeError("Resolved a relative path without a CWD."); + } + path = Deno.cwd(); + // Verify that a cwd was found and that it actually points + // to our drive. If not, default to the drive's root. + if (path === undefined || path.slice(0, 3).toLowerCase() !== `${resolvedDevice.toLowerCase()}\\`) { + path = `${resolvedDevice}\\`; + } + } + assertPath(path); + const len = path.length; + // Skip empty entries + if (len === 0) continue; + let rootEnd = 0; + let device = ""; + 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 + device = `\\\\${firstPart}\\${path.slice(last)}`; + rootEnd = j; + } 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 + rootEnd = 1; + isAbsolute = true; + } + if (device.length > 0 && resolvedDevice.length > 0 && device.toLowerCase() !== resolvedDevice.toLowerCase()) { + continue; + } + if (resolvedDevice.length === 0 && device.length > 0) { + resolvedDevice = device; + } + if (!resolvedAbsolute) { + resolvedTail = `${path.slice(rootEnd)}\\${resolvedTail}`; + resolvedAbsolute = isAbsolute; + } + if (resolvedAbsolute && resolvedDevice.length > 0) break; + } + // At this point the path should be resolved to a full absolute path, + // but handle relative paths to be safe (might happen when process.cwd() + // fails) + // Normalize the tail path + resolvedTail = normalizeString(resolvedTail, !resolvedAbsolute, "\\", isPathSeparator); + return resolvedDevice + (resolvedAbsolute ? "\\" : "") + resolvedTail || "."; +} +/** + * Normalizes a `path` + * @param path to normalize + */ export function normalize(path) { + assertPath(path); + const len = path.length; + if (len === 0) return "."; + let rootEnd = 0; + let device; + 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; + 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; + } +} +/** + * Verifies whether path is absolute + * @param path to verify + */ export function isAbsolute(path) { + assertPath(path); + const len = path.length; + if (len === 0) return false; + const code = path.charCodeAt(0); + if (isPathSeparator(code)) { + return true; + } else if (isWindowsDeviceRoot(code)) { + // Possible device root + if (len > 2 && path.charCodeAt(1) === CHAR_COLON) { + if (isPathSeparator(path.charCodeAt(2))) return true; + } + } + return false; +} +/** + * Join all given a sequence of `paths`,then normalizes the resulting path. + * @param paths to be joined and normalized + */ export function join(...paths) { + const pathsCount = paths.length; + if (pathsCount === 0) return "."; + let joined; + let firstPart = null; + for(let i = 0; i < pathsCount; ++i){ + const path = paths[i]; + assertPath(path); + if (path.length > 0) { + if (joined === undefined) joined = firstPart = path; + else joined += `\\${path}`; + } + } + if (joined === undefined) return "."; + // Make sure that the joined path doesn't start with two slashes, because + // normalize() will mistake it for an UNC path then. + // + // This step is skipped when it is very clear that the user actually + // intended to point at an UNC path. This is assumed when the first + // non-empty string arguments starts with exactly two slashes followed by + // at least one more non-slash character. + // + // Note that for normalize() to treat a path as an UNC path it needs to + // have at least 2 components, so we don't filter for that here. + // This means that the user can use join to construct UNC paths from + // a server name and a share name; for example: + // path.join('//server', 'share') -> '\\\\server\\share\\') + let needsReplace = true; + let slashCount = 0; + assert(firstPart != null); + if (isPathSeparator(firstPart.charCodeAt(0))) { + ++slashCount; + const firstLen = firstPart.length; + if (firstLen > 1) { + if (isPathSeparator(firstPart.charCodeAt(1))) { + ++slashCount; + if (firstLen > 2) { + if (isPathSeparator(firstPart.charCodeAt(2))) ++slashCount; + else { + // We matched a UNC path in the first part + needsReplace = false; + } + } + } + } + } + if (needsReplace) { + // Find any more consecutive slashes we need to replace + for(; slashCount < joined.length; ++slashCount){ + if (!isPathSeparator(joined.charCodeAt(slashCount))) break; + } + // Replace the slashes if needed + if (slashCount >= 2) joined = `\\${joined.slice(slashCount)}`; + } + return normalize(joined); +} +/** + * It will solve the relative path from `from` to `to`, for instance: + * from = 'C:\\orandea\\test\\aaa' + * to = 'C:\\orandea\\impl\\bbb' + * The output of the function should be: '..\\..\\impl\\bbb' + * @param from relative path + * @param to relative path + */ export function relative(from, to) { + assertPath(from); + assertPath(to); + if (from === to) return ""; + const fromOrig = resolve(from); + const toOrig = resolve(to); + if (fromOrig === toOrig) return ""; + from = fromOrig.toLowerCase(); + to = toOrig.toLowerCase(); + if (from === to) return ""; + // Trim any leading backslashes + let fromStart = 0; + let fromEnd = from.length; + for(; fromStart < fromEnd; ++fromStart){ + if (from.charCodeAt(fromStart) !== CHAR_BACKWARD_SLASH) break; + } + // Trim trailing backslashes (applicable to UNC paths only) + for(; fromEnd - 1 > fromStart; --fromEnd){ + if (from.charCodeAt(fromEnd - 1) !== CHAR_BACKWARD_SLASH) break; + } + const fromLen = fromEnd - fromStart; + // Trim any leading backslashes + let toStart = 0; + let toEnd = to.length; + for(; toStart < toEnd; ++toStart){ + if (to.charCodeAt(toStart) !== CHAR_BACKWARD_SLASH) break; + } + // Trim trailing backslashes (applicable to UNC paths only) + for(; toEnd - 1 > toStart; --toEnd){ + if (to.charCodeAt(toEnd - 1) !== CHAR_BACKWARD_SLASH) break; + } + const toLen = toEnd - toStart; + // Compare paths to find the longest common path from root + const length = fromLen < toLen ? fromLen : toLen; + let lastCommonSep = -1; + let i = 0; + for(; i <= length; ++i){ + if (i === length) { + if (toLen > length) { + if (to.charCodeAt(toStart + i) === CHAR_BACKWARD_SLASH) { + // We get here if `from` is the exact base path for `to`. + // For example: from='C:\\foo\\bar'; to='C:\\foo\\bar\\baz' + return toOrig.slice(toStart + i + 1); + } else if (i === 2) { + // We get here if `from` is the device root. + // For example: from='C:\\'; to='C:\\foo' + return toOrig.slice(toStart + i); + } + } + if (fromLen > length) { + if (from.charCodeAt(fromStart + i) === CHAR_BACKWARD_SLASH) { + // We get here if `to` is the exact base path for `from`. + // For example: from='C:\\foo\\bar'; to='C:\\foo' + lastCommonSep = i; + } else if (i === 2) { + // We get here if `to` is the device root. + // For example: from='C:\\foo\\bar'; to='C:\\' + lastCommonSep = 3; + } + } + break; + } + const fromCode = from.charCodeAt(fromStart + i); + const toCode = to.charCodeAt(toStart + i); + if (fromCode !== toCode) break; + else if (fromCode === CHAR_BACKWARD_SLASH) lastCommonSep = i; + } + // We found a mismatch before the first common path separator was seen, so + // return the original `to`. + if (i !== length && lastCommonSep === -1) { + return toOrig; + } + let out = ""; + if (lastCommonSep === -1) lastCommonSep = 0; + // Generate the relative path based on the path difference between `to` and + // `from` + for(i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i){ + if (i === fromEnd || from.charCodeAt(i) === CHAR_BACKWARD_SLASH) { + if (out.length === 0) out += ".."; + else out += "\\.."; + } + } + // Lastly, append the rest of the destination (`to`) path that comes after + // the common path parts + if (out.length > 0) { + return out + toOrig.slice(toStart + lastCommonSep, toEnd); + } else { + toStart += lastCommonSep; + if (toOrig.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) ++toStart; + return toOrig.slice(toStart, toEnd); + } +} +/** + * Resolves path to a namespace path + * @param path to resolve to namespace + */ export function toNamespacedPath(path) { + // Note: this will *probably* throw somewhere. + if (typeof path !== "string") return path; + if (path.length === 0) return ""; + const resolvedPath = resolve(path); + if (resolvedPath.length >= 3) { + if (resolvedPath.charCodeAt(0) === CHAR_BACKWARD_SLASH) { + // Possible UNC root + if (resolvedPath.charCodeAt(1) === CHAR_BACKWARD_SLASH) { + const code = resolvedPath.charCodeAt(2); + if (code !== CHAR_QUESTION_MARK && code !== CHAR_DOT) { + // Matched non-long UNC root, convert the path to a long UNC path + return `\\\\?\\UNC\\${resolvedPath.slice(2)}`; + } + } + } else if (isWindowsDeviceRoot(resolvedPath.charCodeAt(0))) { + // Possible device root + if (resolvedPath.charCodeAt(1) === CHAR_COLON && resolvedPath.charCodeAt(2) === CHAR_BACKWARD_SLASH) { + // Matched device root, convert the path to a long UNC path + return `\\\\?\\${resolvedPath}`; + } + } + } + return path; +} +/** + * Return the directory name of a `path`. + * @param path to determine name for + */ export function dirname(path) { + assertPath(path); + const len = path.length; + if (len === 0) return "."; + let rootEnd = -1; + let end = -1; + let matchedSlash = true; + let offset = 0; + const code = path.charCodeAt(0); + // Try to match a root + if (len > 1) { + if (isPathSeparator(code)) { + // Possible UNC root + rootEnd = offset = 1; + 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) { + // 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 path; + } + if (j !== last) { + // We matched a UNC root with leftovers + // Offset by 1 to include the separator after the UNC root to + // treat it as a "normal root" on top of a (UNC) root + rootEnd = offset = j + 1; + } + } + } + } + } else if (isWindowsDeviceRoot(code)) { + // Possible device root + if (path.charCodeAt(1) === CHAR_COLON) { + rootEnd = offset = 2; + if (len > 2) { + if (isPathSeparator(path.charCodeAt(2))) rootEnd = offset = 3; + } + } + } + } else if (isPathSeparator(code)) { + // `path` contains just a path separator, exit early to avoid + // unnecessary work + return path; + } + for(let i = len - 1; i >= offset; --i){ + if (isPathSeparator(path.charCodeAt(i))) { + if (!matchedSlash) { + end = i; + break; + } + } else { + // We saw the first non-path separator + matchedSlash = false; + } + } + if (end === -1) { + if (rootEnd === -1) return "."; + else end = rootEnd; + } + return path.slice(0, end); +} +/** + * Return the last portion of a `path`. Trailing directory separators are ignored. + * @param path to process + * @param ext of path directory + */ export function basename(path, ext = "") { + if (ext !== undefined && typeof ext !== "string") { + throw new TypeError('"ext" argument must be a string'); + } + assertPath(path); + let start = 0; + let end = -1; + let matchedSlash = true; + let i; + // Check for a drive letter prefix so as not to mistake the following + // path separator as an extra separator at the end of the path that can be + // disregarded + if (path.length >= 2) { + const drive = path.charCodeAt(0); + if (isWindowsDeviceRoot(drive)) { + if (path.charCodeAt(1) === CHAR_COLON) start = 2; + } + } + if (ext !== undefined && ext.length > 0 && ext.length <= path.length) { + if (ext.length === path.length && ext === path) return ""; + let extIdx = ext.length - 1; + let firstNonSlashEnd = -1; + for(i = path.length - 1; i >= start; --i){ + const code = path.charCodeAt(i); + if (isPathSeparator(code)) { + // If we reached a path separator that was not part of a set of path + // separators at the end of the string, stop now + if (!matchedSlash) { + start = i + 1; + break; + } + } else { + if (firstNonSlashEnd === -1) { + // We saw the first non-path separator, remember this index in case + // we need it if the extension ends up not matching + matchedSlash = false; + firstNonSlashEnd = i + 1; + } + if (extIdx >= 0) { + // Try to match the explicit extension + if (code === ext.charCodeAt(extIdx)) { + if (--extIdx === -1) { + // We matched the extension, so mark this as the end of our path + // component + end = i; + } + } else { + // Extension does not match, so our result is the entire path + // component + extIdx = -1; + end = firstNonSlashEnd; + } + } + } + } + if (start === end) end = firstNonSlashEnd; + else if (end === -1) end = path.length; + return path.slice(start, end); + } else { + for(i = path.length - 1; i >= start; --i){ + if (isPathSeparator(path.charCodeAt(i))) { + // If we reached a path separator that was not part of a set of path + // separators at the end of the string, stop now + if (!matchedSlash) { + start = i + 1; + break; + } + } else if (end === -1) { + // We saw the first non-path separator, mark this as the end of our + // path component + matchedSlash = false; + end = i + 1; + } + } + if (end === -1) return ""; + return path.slice(start, end); + } +} +/** + * Return the extension of the `path` with leading period. + * @param path with extension + * @returns extension (ex. for `file.ts` returns `.ts`) + */ export function extname(path) { + assertPath(path); + let start = 0; + let startDot = -1; + let startPart = 0; + let end = -1; + let matchedSlash = true; + // Track the state of characters (if any) we see before our first dot and + // after any path separator we find + let preDotState = 0; + // Check for a drive letter prefix so as not to mistake the following + // path separator as an extra separator at the end of the path that can be + // disregarded + if (path.length >= 2 && path.charCodeAt(1) === CHAR_COLON && isWindowsDeviceRoot(path.charCodeAt(0))) { + start = startPart = 2; + } + for(let i = path.length - 1; i >= start; --i){ + const code = path.charCodeAt(i); + if (isPathSeparator(code)) { + // If we reached a path separator that was not part of a set of path + // separators at the end of the string, stop now + if (!matchedSlash) { + startPart = i + 1; + break; + } + continue; + } + if (end === -1) { + // We saw the first non-path separator, mark this as the end of our + // extension + matchedSlash = false; + end = i + 1; + } + if (code === CHAR_DOT) { + // If this is our first dot, mark it as the start of our extension + if (startDot === -1) startDot = i; + else if (preDotState !== 1) preDotState = 1; + } else if (startDot !== -1) { + // We saw a non-dot and non-path separator before our dot, so we should + // have a good chance at having a non-empty extension + preDotState = -1; + } + } + if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot + preDotState === 0 || // The (right-most) trimmed path component is exactly '..' + preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) { + return ""; + } + return path.slice(startDot, end); +} +/** + * Generate a path from `FormatInputPathObject` object. + * @param pathObject with path + */ export function format(pathObject) { + if (pathObject === null || typeof pathObject !== "object") { + throw new TypeError(`The "pathObject" argument must be of type Object. Received type ${typeof pathObject}`); + } + return _format("\\", pathObject); +} +/** + * Return a `ParsedPath` object of the `path`. + * @param path to process + */ export function parse(path) { + assertPath(path); + const ret = { + root: "", + dir: "", + base: "", + ext: "", + name: "" + }; + const len = path.length; + if (len === 0) return ret; + let rootEnd = 0; + let code = path.charCodeAt(0); + // Try to match a root + if (len > 1) { + if (isPathSeparator(code)) { + // Possible UNC root + rootEnd = 1; + 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) { + // 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 + rootEnd = j; + } else if (j !== last) { + // We matched a UNC root with leftovers + rootEnd = j + 1; + } + } + } + } + } else if (isWindowsDeviceRoot(code)) { + // Possible device root + if (path.charCodeAt(1) === CHAR_COLON) { + rootEnd = 2; + if (len > 2) { + if (isPathSeparator(path.charCodeAt(2))) { + if (len === 3) { + // `path` contains just a drive root, exit early to avoid + // unnecessary work + ret.root = ret.dir = path; + return ret; + } + rootEnd = 3; + } + } else { + // `path` contains just a drive root, exit early to avoid + // unnecessary work + ret.root = ret.dir = path; + return ret; + } + } + } + } else if (isPathSeparator(code)) { + // `path` contains just a path separator, exit early to avoid + // unnecessary work + ret.root = ret.dir = path; + return ret; + } + if (rootEnd > 0) ret.root = path.slice(0, rootEnd); + let startDot = -1; + let startPart = rootEnd; + let end = -1; + let matchedSlash = true; + let i = path.length - 1; + // Track the state of characters (if any) we see before our first dot and + // after any path separator we find + let preDotState = 0; + // Get non-dir info + for(; i >= rootEnd; --i){ + code = path.charCodeAt(i); + if (isPathSeparator(code)) { + // If we reached a path separator that was not part of a set of path + // separators at the end of the string, stop now + if (!matchedSlash) { + startPart = i + 1; + break; + } + continue; + } + if (end === -1) { + // We saw the first non-path separator, mark this as the end of our + // extension + matchedSlash = false; + end = i + 1; + } + if (code === CHAR_DOT) { + // If this is our first dot, mark it as the start of our extension + if (startDot === -1) startDot = i; + else if (preDotState !== 1) preDotState = 1; + } else if (startDot !== -1) { + // We saw a non-dot and non-path separator before our dot, so we should + // have a good chance at having a non-empty extension + preDotState = -1; + } + } + if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot + preDotState === 0 || // The (right-most) trimmed path component is exactly '..' + preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) { + if (end !== -1) { + ret.base = ret.name = path.slice(startPart, end); + } + } else { + ret.name = path.slice(startPart, startDot); + ret.base = path.slice(startPart, end); + ret.ext = path.slice(startDot, end); + } + // If the directory is the root, use the entire root as the `dir` including + // the trailing slash if any (`C:\abc` -> `C:\`). Otherwise, strip out the + // trailing slash (`C:\abc\def` -> `C:\abc`). + if (startPart > 0 && startPart !== rootEnd) { + ret.dir = path.slice(0, startPart - 1); + } else ret.dir = ret.root; + return ret; +} +/** + * Converts a file URL to a path string. + * + * ```ts + * import { fromFileUrl } from "./win32.ts"; + * fromFileUrl("file:///home/foo"); // "\\home\\foo" + * fromFileUrl("file:///C:/Users/foo"); // "C:\\Users\\foo" + * fromFileUrl("file://localhost/home/foo"); // "\\\\localhost\\home\\foo" + * ``` + * @param url of a file URL + */ export function fromFileUrl(url) { + url = url instanceof URL ? url : new URL(url); + if (url.protocol != "file:") { + throw new TypeError("Must be a file URL."); + } + let path = decodeURIComponent(url.pathname.replace(/\//g, "\\").replace(/%(?![0-9A-Fa-f]{2})/g, "%25")).replace(/^\\*([A-Za-z]:)(\\|$)/, "$1\\"); + if (url.hostname != "") { + // Note: The `URL` implementation guarantees that the drive letter and + // hostname are mutually exclusive. Otherwise it would not have been valid + // to append the hostname and path like this. + path = `\\\\${url.hostname}${path}`; + } + return path; +} +/** + * Converts a path string to a file URL. + * + * ```ts + * import { toFileUrl } from "./win32.ts"; + * toFileUrl("\\home\\foo"); // new URL("file:///home/foo") + * toFileUrl("C:\\Users\\foo"); // new URL("file:///C:/Users/foo") + * toFileUrl("\\\\127.0.0.1\\home\\foo"); // new URL("file://127.0.0.1/home/foo") + * ``` + * @param path to convert to file URL + */ export function toFileUrl(path) { + if (!isAbsolute(path)) { + throw new TypeError("Must be an absolute path."); + } + const [, hostname, pathname] = path.match(/^(?:[/\\]{2}([^/\\]+)(?=[/\\](?:[^/\\]|$)))?(.*)/); + const url = new URL("file:///"); + url.pathname = encodeWhitespace(pathname.replace(/%/g, "%25")); + if (hostname != null && hostname != "localhost") { + url.hostname = hostname; + if (!url.hostname) { + throw new TypeError("Invalid hostname."); + } + } + return url; +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["https://deno.land/std@0.140.0/path/win32.ts"],"sourcesContent":["// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.\n// Copyright the Browserify authors. MIT License.\n// Ported from https://github.com/browserify/path-browserify/\n// This module is browser compatible.\n\nimport type { FormatInputPathObject, ParsedPath } from \"./_interface.ts\";\nimport {\n  CHAR_BACKWARD_SLASH,\n  CHAR_COLON,\n  CHAR_DOT,\n  CHAR_QUESTION_MARK,\n} from \"./_constants.ts\";\n\nimport {\n  _format,\n  assertPath,\n  encodeWhitespace,\n  isPathSeparator,\n  isWindowsDeviceRoot,\n  normalizeString,\n} from \"./_util.ts\";\nimport { assert } from \"../_util/assert.ts\";\n\nexport const sep = \"\\\\\";\nexport const delimiter = \";\";\n\n/**\n * Resolves path segments into a `path`\n * @param pathSegments to process to path\n */\nexport function resolve(...pathSegments: string[]): string {\n  let resolvedDevice = \"\";\n  let resolvedTail = \"\";\n  let resolvedAbsolute = false;\n\n  for (let i = pathSegments.length - 1; i >= -1; i--) {\n    let path: string;\n    // deno-lint-ignore no-explicit-any\n    const { Deno } = globalThis as any;\n    if (i >= 0) {\n      path = pathSegments[i];\n    } else if (!resolvedDevice) {\n      if (typeof Deno?.cwd !== \"function\") {\n        throw new TypeError(\"Resolved a drive-letter-less path without a CWD.\");\n      }\n      path = Deno.cwd();\n    } else {\n      if (\n        typeof Deno?.env?.get !== \"function\" || typeof Deno?.cwd !== \"function\"\n      ) {\n        throw new TypeError(\"Resolved a relative path without a CWD.\");\n      }\n      path = Deno.cwd();\n\n      // Verify that a cwd was found and that it actually points\n      // to our drive. If not, default to the drive's root.\n      if (\n        path === undefined ||\n        path.slice(0, 3).toLowerCase() !== `${resolvedDevice.toLowerCase()}\\\\`\n      ) {\n        path = `${resolvedDevice}\\\\`;\n      }\n    }\n\n    assertPath(path);\n\n    const len = path.length;\n\n    // Skip empty entries\n    if (len === 0) continue;\n\n    let rootEnd = 0;\n    let device = \"\";\n    let isAbsolute = false;\n    const code = path.charCodeAt(0);\n\n    // Try to match a root\n    if (len > 1) {\n      if (isPathSeparator(code)) {\n        // Possible UNC root\n\n        // If we started with a separator, we know we at least have an\n        // absolute path of some kind (UNC or otherwise)\n        isAbsolute = true;\n\n        if (isPathSeparator(path.charCodeAt(1))) {\n          // Matched double path separator at beginning\n          let j = 2;\n          let last = j;\n          // Match 1 or more non-path separators\n          for (; j < len; ++j) {\n            if (isPathSeparator(path.charCodeAt(j))) break;\n          }\n          if (j < len && j !== last) {\n            const firstPart = path.slice(last, j);\n            // Matched!\n            last = j;\n            // Match 1 or more path separators\n            for (; j < len; ++j) {\n              if (!isPathSeparator(path.charCodeAt(j))) break;\n            }\n            if (j < len && j !== last) {\n              // Matched!\n              last = j;\n              // Match 1 or more non-path separators\n              for (; j < len; ++j) {\n                if (isPathSeparator(path.charCodeAt(j))) break;\n              }\n              if (j === len) {\n                // We matched a UNC root only\n                device = `\\\\\\\\${firstPart}\\\\${path.slice(last)}`;\n                rootEnd = j;\n              } else if (j !== last) {\n                // We matched a UNC root with leftovers\n\n                device = `\\\\\\\\${firstPart}\\\\${path.slice(last, j)}`;\n                rootEnd = j;\n              }\n            }\n          }\n        } else {\n          rootEnd = 1;\n        }\n      } else if (isWindowsDeviceRoot(code)) {\n        // Possible device root\n\n        if (path.charCodeAt(1) === CHAR_COLON) {\n          device = path.slice(0, 2);\n          rootEnd = 2;\n          if (len > 2) {\n            if (isPathSeparator(path.charCodeAt(2))) {\n              // Treat separator following drive name as an absolute path\n              // indicator\n              isAbsolute = true;\n              rootEnd = 3;\n            }\n          }\n        }\n      }\n    } else if (isPathSeparator(code)) {\n      // `path` contains just a path separator\n      rootEnd = 1;\n      isAbsolute = true;\n    }\n\n    if (\n      device.length > 0 &&\n      resolvedDevice.length > 0 &&\n      device.toLowerCase() !== resolvedDevice.toLowerCase()\n    ) {\n      // This path points to another device so it is not applicable\n      continue;\n    }\n\n    if (resolvedDevice.length === 0 && device.length > 0) {\n      resolvedDevice = device;\n    }\n    if (!resolvedAbsolute) {\n      resolvedTail = `${path.slice(rootEnd)}\\\\${resolvedTail}`;\n      resolvedAbsolute = isAbsolute;\n    }\n\n    if (resolvedAbsolute && resolvedDevice.length > 0) break;\n  }\n\n  // At this point the path should be resolved to a full absolute path,\n  // but handle relative paths to be safe (might happen when process.cwd()\n  // fails)\n\n  // Normalize the tail path\n  resolvedTail = normalizeString(\n    resolvedTail,\n    !resolvedAbsolute,\n    \"\\\\\",\n    isPathSeparator,\n  );\n\n  return resolvedDevice + (resolvedAbsolute ? \"\\\\\" : \"\") + resolvedTail || \".\";\n}\n\n/**\n * Normalizes a `path`\n * @param path to normalize\n */\nexport function normalize(path: string): string {\n  assertPath(path);\n  const len = path.length;\n  if (len === 0) return \".\";\n  let rootEnd = 0;\n  let device: string | undefined;\n  let isAbsolute = false;\n  const code = path.charCodeAt(0);\n\n  // Try to match a root\n  if (len > 1) {\n    if (isPathSeparator(code)) {\n      // Possible UNC root\n\n      // If we started with a separator, we know we at least have an absolute\n      // path of some kind (UNC or otherwise)\n      isAbsolute = true;\n\n      if (isPathSeparator(path.charCodeAt(1))) {\n        // Matched double path separator at beginning\n        let j = 2;\n        let last = j;\n        // Match 1 or more non-path separators\n        for (; j < len; ++j) {\n          if (isPathSeparator(path.charCodeAt(j))) break;\n        }\n        if (j < len && j !== last) {\n          const firstPart = path.slice(last, j);\n          // Matched!\n          last = j;\n          // Match 1 or more path separators\n          for (; j < len; ++j) {\n            if (!isPathSeparator(path.charCodeAt(j))) break;\n          }\n          if (j < len && j !== last) {\n            // Matched!\n            last = j;\n            // Match 1 or more non-path separators\n            for (; j < len; ++j) {\n              if (isPathSeparator(path.charCodeAt(j))) break;\n            }\n            if (j === len) {\n              // We matched a UNC root only\n              // Return the normalized version of the UNC root since there\n              // is nothing left to process\n\n              return `\\\\\\\\${firstPart}\\\\${path.slice(last)}\\\\`;\n            } else if (j !== last) {\n              // We matched a UNC root with leftovers\n\n              device = `\\\\\\\\${firstPart}\\\\${path.slice(last, j)}`;\n              rootEnd = j;\n            }\n          }\n        }\n      } else {\n        rootEnd = 1;\n      }\n    } else if (isWindowsDeviceRoot(code)) {\n      // Possible device root\n\n      if (path.charCodeAt(1) === CHAR_COLON) {\n        device = path.slice(0, 2);\n        rootEnd = 2;\n        if (len > 2) {\n          if (isPathSeparator(path.charCodeAt(2))) {\n            // Treat separator following drive name as an absolute path\n            // indicator\n            isAbsolute = true;\n            rootEnd = 3;\n          }\n        }\n      }\n    }\n  } else if (isPathSeparator(code)) {\n    // `path` contains just a path separator, exit early to avoid unnecessary\n    // work\n    return \"\\\\\";\n  }\n\n  let tail: string;\n  if (rootEnd < len) {\n    tail = normalizeString(\n      path.slice(rootEnd),\n      !isAbsolute,\n      \"\\\\\",\n      isPathSeparator,\n    );\n  } else {\n    tail = \"\";\n  }\n  if (tail.length === 0 && !isAbsolute) tail = \".\";\n  if (tail.length > 0 && isPathSeparator(path.charCodeAt(len - 1))) {\n    tail += \"\\\\\";\n  }\n  if (device === undefined) {\n    if (isAbsolute) {\n      if (tail.length > 0) return `\\\\${tail}`;\n      else return \"\\\\\";\n    } else if (tail.length > 0) {\n      return tail;\n    } else {\n      return \"\";\n    }\n  } else if (isAbsolute) {\n    if (tail.length > 0) return `${device}\\\\${tail}`;\n    else return `${device}\\\\`;\n  } else if (tail.length > 0) {\n    return device + tail;\n  } else {\n    return device;\n  }\n}\n\n/**\n * Verifies whether path is absolute\n * @param path to verify\n */\nexport function isAbsolute(path: string): boolean {\n  assertPath(path);\n  const len = path.length;\n  if (len === 0) return false;\n\n  const code = path.charCodeAt(0);\n  if (isPathSeparator(code)) {\n    return true;\n  } else if (isWindowsDeviceRoot(code)) {\n    // Possible device root\n\n    if (len > 2 && path.charCodeAt(1) === CHAR_COLON) {\n      if (isPathSeparator(path.charCodeAt(2))) return true;\n    }\n  }\n  return false;\n}\n\n/**\n * Join all given a sequence of `paths`,then normalizes the resulting path.\n * @param paths to be joined and normalized\n */\nexport function join(...paths: string[]): string {\n  const pathsCount = paths.length;\n  if (pathsCount === 0) return \".\";\n\n  let joined: string | undefined;\n  let firstPart: string | null = null;\n  for (let i = 0; i < pathsCount; ++i) {\n    const path = paths[i];\n    assertPath(path);\n    if (path.length > 0) {\n      if (joined === undefined) joined = firstPart = path;\n      else joined += `\\\\${path}`;\n    }\n  }\n\n  if (joined === undefined) return \".\";\n\n  // Make sure that the joined path doesn't start with two slashes, because\n  // normalize() will mistake it for an UNC path then.\n  //\n  // This step is skipped when it is very clear that the user actually\n  // intended to point at an UNC path. This is assumed when the first\n  // non-empty string arguments starts with exactly two slashes followed by\n  // at least one more non-slash character.\n  //\n  // Note that for normalize() to treat a path as an UNC path it needs to\n  // have at least 2 components, so we don't filter for that here.\n  // This means that the user can use join to construct UNC paths from\n  // a server name and a share name; for example:\n  //   path.join('//server', 'share') -> '\\\\\\\\server\\\\share\\\\')\n  let needsReplace = true;\n  let slashCount = 0;\n  assert(firstPart != null);\n  if (isPathSeparator(firstPart.charCodeAt(0))) {\n    ++slashCount;\n    const firstLen = firstPart.length;\n    if (firstLen > 1) {\n      if (isPathSeparator(firstPart.charCodeAt(1))) {\n        ++slashCount;\n        if (firstLen > 2) {\n          if (isPathSeparator(firstPart.charCodeAt(2))) ++slashCount;\n          else {\n            // We matched a UNC path in the first part\n            needsReplace = false;\n          }\n        }\n      }\n    }\n  }\n  if (needsReplace) {\n    // Find any more consecutive slashes we need to replace\n    for (; slashCount < joined.length; ++slashCount) {\n      if (!isPathSeparator(joined.charCodeAt(slashCount))) break;\n    }\n\n    // Replace the slashes if needed\n    if (slashCount >= 2) joined = `\\\\${joined.slice(slashCount)}`;\n  }\n\n  return normalize(joined);\n}\n\n/**\n * It will solve the relative path from `from` to `to`, for instance:\n *  from = 'C:\\\\orandea\\\\test\\\\aaa'\n *  to = 'C:\\\\orandea\\\\impl\\\\bbb'\n * The output of the function should be: '..\\\\..\\\\impl\\\\bbb'\n * @param from relative path\n * @param to relative path\n */\nexport function relative(from: string, to: string): string {\n  assertPath(from);\n  assertPath(to);\n\n  if (from === to) return \"\";\n\n  const fromOrig = resolve(from);\n  const toOrig = resolve(to);\n\n  if (fromOrig === toOrig) return \"\";\n\n  from = fromOrig.toLowerCase();\n  to = toOrig.toLowerCase();\n\n  if (from === to) return \"\";\n\n  // Trim any leading backslashes\n  let fromStart = 0;\n  let fromEnd = from.length;\n  for (; fromStart < fromEnd; ++fromStart) {\n    if (from.charCodeAt(fromStart) !== CHAR_BACKWARD_SLASH) break;\n  }\n  // Trim trailing backslashes (applicable to UNC paths only)\n  for (; fromEnd - 1 > fromStart; --fromEnd) {\n    if (from.charCodeAt(fromEnd - 1) !== CHAR_BACKWARD_SLASH) break;\n  }\n  const fromLen = fromEnd - fromStart;\n\n  // Trim any leading backslashes\n  let toStart = 0;\n  let toEnd = to.length;\n  for (; toStart < toEnd; ++toStart) {\n    if (to.charCodeAt(toStart) !== CHAR_BACKWARD_SLASH) break;\n  }\n  // Trim trailing backslashes (applicable to UNC paths only)\n  for (; toEnd - 1 > toStart; --toEnd) {\n    if (to.charCodeAt(toEnd - 1) !== CHAR_BACKWARD_SLASH) break;\n  }\n  const toLen = toEnd - toStart;\n\n  // Compare paths to find the longest common path from root\n  const length = fromLen < toLen ? fromLen : toLen;\n  let lastCommonSep = -1;\n  let i = 0;\n  for (; i <= length; ++i) {\n    if (i === length) {\n      if (toLen > length) {\n        if (to.charCodeAt(toStart + i) === CHAR_BACKWARD_SLASH) {\n          // We get here if `from` is the exact base path for `to`.\n          // For example: from='C:\\\\foo\\\\bar'; to='C:\\\\foo\\\\bar\\\\baz'\n          return toOrig.slice(toStart + i + 1);\n        } else if (i === 2) {\n          // We get here if `from` is the device root.\n          // For example: from='C:\\\\'; to='C:\\\\foo'\n          return toOrig.slice(toStart + i);\n        }\n      }\n      if (fromLen > length) {\n        if (from.charCodeAt(fromStart + i) === CHAR_BACKWARD_SLASH) {\n          // We get here if `to` is the exact base path for `from`.\n          // For example: from='C:\\\\foo\\\\bar'; to='C:\\\\foo'\n          lastCommonSep = i;\n        } else if (i === 2) {\n          // We get here if `to` is the device root.\n          // For example: from='C:\\\\foo\\\\bar'; to='C:\\\\'\n          lastCommonSep = 3;\n        }\n      }\n      break;\n    }\n    const fromCode = from.charCodeAt(fromStart + i);\n    const toCode = to.charCodeAt(toStart + i);\n    if (fromCode !== toCode) break;\n    else if (fromCode === CHAR_BACKWARD_SLASH) lastCommonSep = i;\n  }\n\n  // We found a mismatch before the first common path separator was seen, so\n  // return the original `to`.\n  if (i !== length && lastCommonSep === -1) {\n    return toOrig;\n  }\n\n  let out = \"\";\n  if (lastCommonSep === -1) lastCommonSep = 0;\n  // Generate the relative path based on the path difference between `to` and\n  // `from`\n  for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {\n    if (i === fromEnd || from.charCodeAt(i) === CHAR_BACKWARD_SLASH) {\n      if (out.length === 0) out += \"..\";\n      else out += \"\\\\..\";\n    }\n  }\n\n  // Lastly, append the rest of the destination (`to`) path that comes after\n  // the common path parts\n  if (out.length > 0) {\n    return out + toOrig.slice(toStart + lastCommonSep, toEnd);\n  } else {\n    toStart += lastCommonSep;\n    if (toOrig.charCodeAt(toStart) === CHAR_BACKWARD_SLASH) ++toStart;\n    return toOrig.slice(toStart, toEnd);\n  }\n}\n\n/**\n * Resolves path to a namespace path\n * @param path to resolve to namespace\n */\nexport function toNamespacedPath(path: string): string {\n  // Note: this will *probably* throw somewhere.\n  if (typeof path !== \"string\") return path;\n  if (path.length === 0) return \"\";\n\n  const resolvedPath = resolve(path);\n\n  if (resolvedPath.length >= 3) {\n    if (resolvedPath.charCodeAt(0) === CHAR_BACKWARD_SLASH) {\n      // Possible UNC root\n\n      if (resolvedPath.charCodeAt(1) === CHAR_BACKWARD_SLASH) {\n        const code = resolvedPath.charCodeAt(2);\n        if (code !== CHAR_QUESTION_MARK && code !== CHAR_DOT) {\n          // Matched non-long UNC root, convert the path to a long UNC path\n          return `\\\\\\\\?\\\\UNC\\\\${resolvedPath.slice(2)}`;\n        }\n      }\n    } else if (isWindowsDeviceRoot(resolvedPath.charCodeAt(0))) {\n      // Possible device root\n\n      if (\n        resolvedPath.charCodeAt(1) === CHAR_COLON &&\n        resolvedPath.charCodeAt(2) === CHAR_BACKWARD_SLASH\n      ) {\n        // Matched device root, convert the path to a long UNC path\n        return `\\\\\\\\?\\\\${resolvedPath}`;\n      }\n    }\n  }\n\n  return path;\n}\n\n/**\n * Return the directory name of a `path`.\n * @param path to determine name for\n */\nexport function dirname(path: string): string {\n  assertPath(path);\n  const len = path.length;\n  if (len === 0) return \".\";\n  let rootEnd = -1;\n  let end = -1;\n  let matchedSlash = true;\n  let offset = 0;\n  const code = path.charCodeAt(0);\n\n  // Try to match a root\n  if (len > 1) {\n    if (isPathSeparator(code)) {\n      // Possible UNC root\n\n      rootEnd = offset = 1;\n\n      if (isPathSeparator(path.charCodeAt(1))) {\n        // Matched double path separator at beginning\n        let j = 2;\n        let last = j;\n        // Match 1 or more non-path separators\n        for (; j < len; ++j) {\n          if (isPathSeparator(path.charCodeAt(j))) break;\n        }\n        if (j < len && j !== last) {\n          // Matched!\n          last = j;\n          // Match 1 or more path separators\n          for (; j < len; ++j) {\n            if (!isPathSeparator(path.charCodeAt(j))) break;\n          }\n          if (j < len && j !== last) {\n            // Matched!\n            last = j;\n            // Match 1 or more non-path separators\n            for (; j < len; ++j) {\n              if (isPathSeparator(path.charCodeAt(j))) break;\n            }\n            if (j === len) {\n              // We matched a UNC root only\n              return path;\n            }\n            if (j !== last) {\n              // We matched a UNC root with leftovers\n\n              // Offset by 1 to include the separator after the UNC root to\n              // treat it as a \"normal root\" on top of a (UNC) root\n              rootEnd = offset = j + 1;\n            }\n          }\n        }\n      }\n    } else if (isWindowsDeviceRoot(code)) {\n      // Possible device root\n\n      if (path.charCodeAt(1) === CHAR_COLON) {\n        rootEnd = offset = 2;\n        if (len > 2) {\n          if (isPathSeparator(path.charCodeAt(2))) rootEnd = offset = 3;\n        }\n      }\n    }\n  } else if (isPathSeparator(code)) {\n    // `path` contains just a path separator, exit early to avoid\n    // unnecessary work\n    return path;\n  }\n\n  for (let i = len - 1; i >= offset; --i) {\n    if (isPathSeparator(path.charCodeAt(i))) {\n      if (!matchedSlash) {\n        end = i;\n        break;\n      }\n    } else {\n      // We saw the first non-path separator\n      matchedSlash = false;\n    }\n  }\n\n  if (end === -1) {\n    if (rootEnd === -1) return \".\";\n    else end = rootEnd;\n  }\n  return path.slice(0, end);\n}\n\n/**\n * Return the last portion of a `path`. Trailing directory separators are ignored.\n * @param path to process\n * @param ext of path directory\n */\nexport function basename(path: string, ext = \"\"): string {\n  if (ext !== undefined && typeof ext !== \"string\") {\n    throw new TypeError('\"ext\" argument must be a string');\n  }\n\n  assertPath(path);\n\n  let start = 0;\n  let end = -1;\n  let matchedSlash = true;\n  let i: number;\n\n  // Check for a drive letter prefix so as not to mistake the following\n  // path separator as an extra separator at the end of the path that can be\n  // disregarded\n  if (path.length >= 2) {\n    const drive = path.charCodeAt(0);\n    if (isWindowsDeviceRoot(drive)) {\n      if (path.charCodeAt(1) === CHAR_COLON) start = 2;\n    }\n  }\n\n  if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {\n    if (ext.length === path.length && ext === path) return \"\";\n    let extIdx = ext.length - 1;\n    let firstNonSlashEnd = -1;\n    for (i = path.length - 1; i >= start; --i) {\n      const code = path.charCodeAt(i);\n      if (isPathSeparator(code)) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          start = i + 1;\n          break;\n        }\n      } else {\n        if (firstNonSlashEnd === -1) {\n          // We saw the first non-path separator, remember this index in case\n          // we need it if the extension ends up not matching\n          matchedSlash = false;\n          firstNonSlashEnd = i + 1;\n        }\n        if (extIdx >= 0) {\n          // Try to match the explicit extension\n          if (code === ext.charCodeAt(extIdx)) {\n            if (--extIdx === -1) {\n              // We matched the extension, so mark this as the end of our path\n              // component\n              end = i;\n            }\n          } else {\n            // Extension does not match, so our result is the entire path\n            // component\n            extIdx = -1;\n            end = firstNonSlashEnd;\n          }\n        }\n      }\n    }\n\n    if (start === end) end = firstNonSlashEnd;\n    else if (end === -1) end = path.length;\n    return path.slice(start, end);\n  } else {\n    for (i = path.length - 1; i >= start; --i) {\n      if (isPathSeparator(path.charCodeAt(i))) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          start = i + 1;\n          break;\n        }\n      } else if (end === -1) {\n        // We saw the first non-path separator, mark this as the end of our\n        // path component\n        matchedSlash = false;\n        end = i + 1;\n      }\n    }\n\n    if (end === -1) return \"\";\n    return path.slice(start, end);\n  }\n}\n\n/**\n * Return the extension of the `path` with leading period.\n * @param path with extension\n * @returns extension (ex. for `file.ts` returns `.ts`)\n */\nexport function extname(path: string): string {\n  assertPath(path);\n  let start = 0;\n  let startDot = -1;\n  let startPart = 0;\n  let end = -1;\n  let matchedSlash = true;\n  // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find\n  let preDotState = 0;\n\n  // Check for a drive letter prefix so as not to mistake the following\n  // path separator as an extra separator at the end of the path that can be\n  // disregarded\n\n  if (\n    path.length >= 2 &&\n    path.charCodeAt(1) === CHAR_COLON &&\n    isWindowsDeviceRoot(path.charCodeAt(0))\n  ) {\n    start = startPart = 2;\n  }\n\n  for (let i = path.length - 1; i >= start; --i) {\n    const code = path.charCodeAt(i);\n    if (isPathSeparator(code)) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now\n      if (!matchedSlash) {\n        startPart = i + 1;\n        break;\n      }\n      continue;\n    }\n    if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension\n      matchedSlash = false;\n      end = i + 1;\n    }\n    if (code === CHAR_DOT) {\n      // If this is our first dot, mark it as the start of our extension\n      if (startDot === -1) startDot = i;\n      else if (preDotState !== 1) preDotState = 1;\n    } else if (startDot !== -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension\n      preDotState = -1;\n    }\n  }\n\n  if (\n    startDot === -1 ||\n    end === -1 ||\n    // We saw a non-dot character immediately before the dot\n    preDotState === 0 ||\n    // The (right-most) trimmed path component is exactly '..'\n    (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)\n  ) {\n    return \"\";\n  }\n  return path.slice(startDot, end);\n}\n\n/**\n * Generate a path from `FormatInputPathObject` object.\n * @param pathObject with path\n */\nexport function format(pathObject: FormatInputPathObject): string {\n  if (pathObject === null || typeof pathObject !== \"object\") {\n    throw new TypeError(\n      `The \"pathObject\" argument must be of type Object. Received type ${typeof pathObject}`,\n    );\n  }\n  return _format(\"\\\\\", pathObject);\n}\n\n/**\n * Return a `ParsedPath` object of the `path`.\n * @param path to process\n */\nexport function parse(path: string): ParsedPath {\n  assertPath(path);\n\n  const ret: ParsedPath = { root: \"\", dir: \"\", base: \"\", ext: \"\", name: \"\" };\n\n  const len = path.length;\n  if (len === 0) return ret;\n\n  let rootEnd = 0;\n  let code = path.charCodeAt(0);\n\n  // Try to match a root\n  if (len > 1) {\n    if (isPathSeparator(code)) {\n      // Possible UNC root\n\n      rootEnd = 1;\n      if (isPathSeparator(path.charCodeAt(1))) {\n        // Matched double path separator at beginning\n        let j = 2;\n        let last = j;\n        // Match 1 or more non-path separators\n        for (; j < len; ++j) {\n          if (isPathSeparator(path.charCodeAt(j))) break;\n        }\n        if (j < len && j !== last) {\n          // Matched!\n          last = j;\n          // Match 1 or more path separators\n          for (; j < len; ++j) {\n            if (!isPathSeparator(path.charCodeAt(j))) break;\n          }\n          if (j < len && j !== last) {\n            // Matched!\n            last = j;\n            // Match 1 or more non-path separators\n            for (; j < len; ++j) {\n              if (isPathSeparator(path.charCodeAt(j))) break;\n            }\n            if (j === len) {\n              // We matched a UNC root only\n\n              rootEnd = j;\n            } else if (j !== last) {\n              // We matched a UNC root with leftovers\n\n              rootEnd = j + 1;\n            }\n          }\n        }\n      }\n    } else if (isWindowsDeviceRoot(code)) {\n      // Possible device root\n\n      if (path.charCodeAt(1) === CHAR_COLON) {\n        rootEnd = 2;\n        if (len > 2) {\n          if (isPathSeparator(path.charCodeAt(2))) {\n            if (len === 3) {\n              // `path` contains just a drive root, exit early to avoid\n              // unnecessary work\n              ret.root = ret.dir = path;\n              return ret;\n            }\n            rootEnd = 3;\n          }\n        } else {\n          // `path` contains just a drive root, exit early to avoid\n          // unnecessary work\n          ret.root = ret.dir = path;\n          return ret;\n        }\n      }\n    }\n  } else if (isPathSeparator(code)) {\n    // `path` contains just a path separator, exit early to avoid\n    // unnecessary work\n    ret.root = ret.dir = path;\n    return ret;\n  }\n\n  if (rootEnd > 0) ret.root = path.slice(0, rootEnd);\n\n  let startDot = -1;\n  let startPart = rootEnd;\n  let end = -1;\n  let matchedSlash = true;\n  let i = path.length - 1;\n\n  // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find\n  let preDotState = 0;\n\n  // Get non-dir info\n  for (; i >= rootEnd; --i) {\n    code = path.charCodeAt(i);\n    if (isPathSeparator(code)) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now\n      if (!matchedSlash) {\n        startPart = i + 1;\n        break;\n      }\n      continue;\n    }\n    if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension\n      matchedSlash = false;\n      end = i + 1;\n    }\n    if (code === CHAR_DOT) {\n      // If this is our first dot, mark it as the start of our extension\n      if (startDot === -1) startDot = i;\n      else if (preDotState !== 1) preDotState = 1;\n    } else if (startDot !== -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension\n      preDotState = -1;\n    }\n  }\n\n  if (\n    startDot === -1 ||\n    end === -1 ||\n    // We saw a non-dot character immediately before the dot\n    preDotState === 0 ||\n    // The (right-most) trimmed path component is exactly '..'\n    (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)\n  ) {\n    if (end !== -1) {\n      ret.base = ret.name = path.slice(startPart, end);\n    }\n  } else {\n    ret.name = path.slice(startPart, startDot);\n    ret.base = path.slice(startPart, end);\n    ret.ext = path.slice(startDot, end);\n  }\n\n  // If the directory is the root, use the entire root as the `dir` including\n  // the trailing slash if any (`C:\\abc` -> `C:\\`). Otherwise, strip out the\n  // trailing slash (`C:\\abc\\def` -> `C:\\abc`).\n  if (startPart > 0 && startPart !== rootEnd) {\n    ret.dir = path.slice(0, startPart - 1);\n  } else ret.dir = ret.root;\n\n  return ret;\n}\n\n/**\n * Converts a file URL to a path string.\n *\n * ```ts\n *      import { fromFileUrl } from \"./win32.ts\";\n *      fromFileUrl(\"file:///home/foo\"); // \"\\\\home\\\\foo\"\n *      fromFileUrl(\"file:///C:/Users/foo\"); // \"C:\\\\Users\\\\foo\"\n *      fromFileUrl(\"file://localhost/home/foo\"); // \"\\\\\\\\localhost\\\\home\\\\foo\"\n * ```\n * @param url of a file URL\n */\nexport function fromFileUrl(url: string | URL): string {\n  url = url instanceof URL ? url : new URL(url);\n  if (url.protocol != \"file:\") {\n    throw new TypeError(\"Must be a file URL.\");\n  }\n  let path = decodeURIComponent(\n    url.pathname.replace(/\\//g, \"\\\\\").replace(/%(?![0-9A-Fa-f]{2})/g, \"%25\"),\n  ).replace(/^\\\\*([A-Za-z]:)(\\\\|$)/, \"$1\\\\\");\n  if (url.hostname != \"\") {\n    // Note: The `URL` implementation guarantees that the drive letter and\n    // hostname are mutually exclusive. Otherwise it would not have been valid\n    // to append the hostname and path like this.\n    path = `\\\\\\\\${url.hostname}${path}`;\n  }\n  return path;\n}\n\n/**\n * Converts a path string to a file URL.\n *\n * ```ts\n *      import { toFileUrl } from \"./win32.ts\";\n *      toFileUrl(\"\\\\home\\\\foo\"); // new URL(\"file:///home/foo\")\n *      toFileUrl(\"C:\\\\Users\\\\foo\"); // new URL(\"file:///C:/Users/foo\")\n *      toFileUrl(\"\\\\\\\\127.0.0.1\\\\home\\\\foo\"); // new URL(\"file://127.0.0.1/home/foo\")\n * ```\n * @param path to convert to file URL\n */\nexport function toFileUrl(path: string): URL {\n  if (!isAbsolute(path)) {\n    throw new TypeError(\"Must be an absolute path.\");\n  }\n  const [, hostname, pathname] = path.match(\n    /^(?:[/\\\\]{2}([^/\\\\]+)(?=[/\\\\](?:[^/\\\\]|$)))?(.*)/,\n  )!;\n  const url = new URL(\"file:///\");\n  url.pathname = encodeWhitespace(pathname.replace(/%/g, \"%25\"));\n  if (hostname != null && hostname != \"localhost\") {\n    url.hostname = hostname;\n    if (!url.hostname) {\n      throw new TypeError(\"Invalid hostname.\");\n    }\n  }\n  return url;\n}\n"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/tests/__snapshots__/transpile/url/modules/WStdDhyHbKYy_C9CJ39RDks1VaY.js b/tests/__snapshots__/transpile/url/modules/WStdDhyHbKYy_C9CJ39RDks1VaY.js new file mode 100644 index 0000000..bd10af7 --- /dev/null +++ b/tests/__snapshots__/transpile/url/modules/WStdDhyHbKYy_C9CJ39RDks1VaY.js @@ -0,0 +1,228 @@ +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. +/** + * Provides helper functions to manipulate `Uint8Array` byte slices that are not + * included on the `Uint8Array` prototype. + * + * @module + */ /** Returns the index of the first occurrence of the needle array in the source + * array, or -1 if it is not present. + * + * A start index can be specified as the third argument that begins the search + * at that given index. The start index defaults to the start of the array. + * + * The complexity of this function is O(source.lenth * needle.length). + * + * ```ts + * import { indexOfNeedle } from "./mod.ts"; + * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]); + * const needle = new Uint8Array([1, 2]); + * console.log(indexOfNeedle(source, needle)); // 1 + * console.log(indexOfNeedle(source, needle, 2)); // 3 + * ``` + */ export function indexOfNeedle(source, needle, start = 0) { + if (start >= source.length) { + return -1; + } + if (start < 0) { + start = Math.max(0, source.length + start); + } + const s = needle[0]; + for(let i = start; i < source.length; i++){ + if (source[i] !== s) continue; + const pin = i; + let matched = 1; + let j = i; + while(matched < needle.length){ + j++; + if (source[j] !== needle[j - pin]) { + break; + } + matched++; + } + if (matched === needle.length) { + return pin; + } + } + return -1; +} +/** Returns the index of the last occurrence of the needle array in the source + * array, or -1 if it is not present. + * + * A start index can be specified as the third argument that begins the search + * at that given index. The start index defaults to the end of the array. + * + * The complexity of this function is O(source.lenth * needle.length). + * + * ```ts + * import { lastIndexOfNeedle } from "./mod.ts"; + * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]); + * const needle = new Uint8Array([1, 2]); + * console.log(lastIndexOfNeedle(source, needle)); // 5 + * console.log(lastIndexOfNeedle(source, needle, 4)); // 3 + * ``` + */ export function lastIndexOfNeedle(source, needle, start = source.length - 1) { + if (start < 0) { + return -1; + } + if (start >= source.length) { + start = source.length - 1; + } + const e = needle[needle.length - 1]; + for(let i = start; i >= 0; i--){ + if (source[i] !== e) continue; + const pin = i; + let matched = 1; + let j = i; + while(matched < needle.length){ + j--; + if (source[j] !== needle[needle.length - 1 - (pin - j)]) { + break; + } + matched++; + } + if (matched === needle.length) { + return pin - needle.length + 1; + } + } + return -1; +} +/** Returns true if the prefix array appears at the start of the source array, + * false otherwise. + * + * The complexity of this function is O(prefix.length). + * + * ```ts + * import { startsWith } from "./mod.ts"; + * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]); + * const prefix = new Uint8Array([0, 1, 2]); + * console.log(startsWith(source, prefix)); // true + * ``` + */ export function startsWith(source, prefix) { + for(let i = 0, max = prefix.length; i < max; i++){ + if (source[i] !== prefix[i]) return false; + } + return true; +} +/** Returns true if the suffix array appears at the end of the source array, + * false otherwise. + * + * The complexity of this function is O(suffix.length). + * + * ```ts + * import { endsWith } from "./mod.ts"; + * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]); + * const suffix = new Uint8Array([1, 2, 3]); + * console.log(endsWith(source, suffix)); // true + * ``` + */ export function endsWith(source, suffix) { + for(let srci = source.length - 1, sfxi = suffix.length - 1; sfxi >= 0; srci--, sfxi--){ + if (source[srci] !== suffix[sfxi]) return false; + } + return true; +} +/** Returns a new Uint8Array composed of `count` repetitions of the `source` + * array. + * + * If `count` is negative, a `RangeError` is thrown. + * + * ```ts + * import { repeat } from "./mod.ts"; + * const source = new Uint8Array([0, 1, 2]); + * console.log(repeat(source, 3)); // [0, 1, 2, 0, 1, 2, 0, 1, 2] + * console.log(repeat(source, 0)); // [] + * console.log(repeat(source, -1)); // RangeError + * ``` + */ export function repeat(source, count) { + if (count === 0) { + return new Uint8Array(); + } + if (count < 0) { + throw new RangeError("bytes: negative repeat count"); + } else if (source.length * count / count !== source.length) { + throw new Error("bytes: repeat count causes overflow"); + } + const int = Math.floor(count); + if (int !== count) { + throw new Error("bytes: repeat count must be an integer"); + } + const nb = new Uint8Array(source.length * count); + let bp = copy(source, nb); + for(; bp < nb.length; bp *= 2){ + copy(nb.slice(0, bp), nb, bp); + } + return nb; +} +/** Concatenate the given arrays into a new Uint8Array. + * + * ```ts + * import { concat } from "./mod.ts"; + * const a = new Uint8Array([0, 1, 2]); + * const b = new Uint8Array([3, 4, 5]); + * console.log(concat(a, b)); // [0, 1, 2, 3, 4, 5] + */ export function concat(...buf) { + let length = 0; + for (const b of buf){ + length += b.length; + } + const output = new Uint8Array(length); + let index = 0; + for (const b of buf){ + output.set(b, index); + index += b.length; + } + return output; +} +/** Returns true if the source array contains the needle array, false otherwise. + * + * A start index can be specified as the third argument that begins the search + * at that given index. The start index defaults to the beginning of the array. + * + * The complexity of this function is O(source.length * needle.length). + * + * ```ts + * import { includesNeedle } from "./mod.ts"; + * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]); + * const needle = new Uint8Array([1, 2]); + * console.log(includesNeedle(source, needle)); // true + * console.log(includesNeedle(source, needle, 6)); // false + * ``` + */ export function includesNeedle(source, needle, start = 0) { + return indexOfNeedle(source, needle, start) !== -1; +} +/** Copy bytes from the `src` array to the `dst` array. Returns the number of + * bytes copied. + * + * If the `src` array is larger than what the `dst` array can hold, only the + * amount of bytes that fit in the `dst` array are copied. + * + * An offset can be specified as the third argument that begins the copy at + * that given index in the `dst` array. The offset defaults to the beginning of + * the array. + * + * ```ts + * import { copy } from "./mod.ts"; + * const src = new Uint8Array([9, 8, 7]); + * const dst = new Uint8Array([0, 1, 2, 3, 4, 5]); + * console.log(copy(src, dst)); // 3 + * console.log(dst); // [9, 8, 7, 3, 4, 5] + * ``` + * + * ```ts + * import { copy } from "./mod.ts"; + * const src = new Uint8Array([1, 1, 1, 1]); + * const dst = new Uint8Array([0, 0, 0, 0]); + * console.log(copy(src, dst, 1)); // 3 + * console.log(dst); // [0, 1, 1, 1] + * ``` + */ export function copy(src, dst, off = 0) { + off = Math.max(0, Math.min(off, dst.byteLength)); + const dstBytesAvailable = dst.byteLength - off; + if (src.byteLength > dstBytesAvailable) { + src = src.subarray(0, dstBytesAvailable); + } + dst.set(src, off); + return src.byteLength; +} +export { equals } from "./equals.ts"; +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["https://deno.land/std@0.140.0/bytes/mod.ts"],"sourcesContent":["// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.\n// This module is browser compatible.\n\n/**\n * Provides helper functions to manipulate `Uint8Array` byte slices that are not\n * included on the `Uint8Array` prototype.\n *\n * @module\n */\n\n/** Returns the index of the first occurrence of the needle array in the source\n * array, or -1 if it is not present.\n *\n * A start index can be specified as the third argument that begins the search\n * at that given index. The start index defaults to the start of the array.\n *\n * The complexity of this function is O(source.lenth * needle.length).\n *\n * ```ts\n * import { indexOfNeedle } from \"./mod.ts\";\n * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);\n * const needle = new Uint8Array([1, 2]);\n * console.log(indexOfNeedle(source, needle)); // 1\n * console.log(indexOfNeedle(source, needle, 2)); // 3\n * ```\n */\nexport function indexOfNeedle(\n  source: Uint8Array,\n  needle: Uint8Array,\n  start = 0,\n): number {\n  if (start >= source.length) {\n    return -1;\n  }\n  if (start < 0) {\n    start = Math.max(0, source.length + start);\n  }\n  const s = needle[0];\n  for (let i = start; i < source.length; i++) {\n    if (source[i] !== s) continue;\n    const pin = i;\n    let matched = 1;\n    let j = i;\n    while (matched < needle.length) {\n      j++;\n      if (source[j] !== needle[j - pin]) {\n        break;\n      }\n      matched++;\n    }\n    if (matched === needle.length) {\n      return pin;\n    }\n  }\n  return -1;\n}\n\n/** Returns the index of the last occurrence of the needle array in the source\n * array, or -1 if it is not present.\n *\n * A start index can be specified as the third argument that begins the search\n * at that given index. The start index defaults to the end of the array.\n *\n * The complexity of this function is O(source.lenth * needle.length).\n *\n * ```ts\n * import { lastIndexOfNeedle } from \"./mod.ts\";\n * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);\n * const needle = new Uint8Array([1, 2]);\n * console.log(lastIndexOfNeedle(source, needle)); // 5\n * console.log(lastIndexOfNeedle(source, needle, 4)); // 3\n * ```\n */\nexport function lastIndexOfNeedle(\n  source: Uint8Array,\n  needle: Uint8Array,\n  start = source.length - 1,\n): number {\n  if (start < 0) {\n    return -1;\n  }\n  if (start >= source.length) {\n    start = source.length - 1;\n  }\n  const e = needle[needle.length - 1];\n  for (let i = start; i >= 0; i--) {\n    if (source[i] !== e) continue;\n    const pin = i;\n    let matched = 1;\n    let j = i;\n    while (matched < needle.length) {\n      j--;\n      if (source[j] !== needle[needle.length - 1 - (pin - j)]) {\n        break;\n      }\n      matched++;\n    }\n    if (matched === needle.length) {\n      return pin - needle.length + 1;\n    }\n  }\n  return -1;\n}\n\n/** Returns true if the prefix array appears at the start of the source array,\n * false otherwise.\n *\n * The complexity of this function is O(prefix.length).\n *\n * ```ts\n * import { startsWith } from \"./mod.ts\";\n * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);\n * const prefix = new Uint8Array([0, 1, 2]);\n * console.log(startsWith(source, prefix)); // true\n * ```\n */\nexport function startsWith(source: Uint8Array, prefix: Uint8Array): boolean {\n  for (let i = 0, max = prefix.length; i < max; i++) {\n    if (source[i] !== prefix[i]) return false;\n  }\n  return true;\n}\n\n/** Returns true if the suffix array appears at the end of the source array,\n * false otherwise.\n *\n * The complexity of this function is O(suffix.length).\n *\n * ```ts\n * import { endsWith } from \"./mod.ts\";\n * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);\n * const suffix = new Uint8Array([1, 2, 3]);\n * console.log(endsWith(source, suffix)); // true\n * ```\n */\nexport function endsWith(source: Uint8Array, suffix: Uint8Array): boolean {\n  for (\n    let srci = source.length - 1, sfxi = suffix.length - 1;\n    sfxi >= 0;\n    srci--, sfxi--\n  ) {\n    if (source[srci] !== suffix[sfxi]) return false;\n  }\n  return true;\n}\n\n/** Returns a new Uint8Array composed of `count` repetitions of the `source`\n * array.\n *\n * If `count` is negative, a `RangeError` is thrown.\n *\n * ```ts\n * import { repeat } from \"./mod.ts\";\n * const source = new Uint8Array([0, 1, 2]);\n * console.log(repeat(source, 3)); // [0, 1, 2, 0, 1, 2, 0, 1, 2]\n * console.log(repeat(source, 0)); // []\n * console.log(repeat(source, -1)); // RangeError\n * ```\n */\nexport function repeat(source: Uint8Array, count: number): Uint8Array {\n  if (count === 0) {\n    return new Uint8Array();\n  }\n\n  if (count < 0) {\n    throw new RangeError(\"bytes: negative repeat count\");\n  } else if ((source.length * count) / count !== source.length) {\n    throw new Error(\"bytes: repeat count causes overflow\");\n  }\n\n  const int = Math.floor(count);\n\n  if (int !== count) {\n    throw new Error(\"bytes: repeat count must be an integer\");\n  }\n\n  const nb = new Uint8Array(source.length * count);\n\n  let bp = copy(source, nb);\n\n  for (; bp < nb.length; bp *= 2) {\n    copy(nb.slice(0, bp), nb, bp);\n  }\n\n  return nb;\n}\n\n/** Concatenate the given arrays into a new Uint8Array.\n *\n * ```ts\n * import { concat } from \"./mod.ts\";\n * const a = new Uint8Array([0, 1, 2]);\n * const b = new Uint8Array([3, 4, 5]);\n * console.log(concat(a, b)); // [0, 1, 2, 3, 4, 5]\n */\nexport function concat(...buf: Uint8Array[]): Uint8Array {\n  let length = 0;\n  for (const b of buf) {\n    length += b.length;\n  }\n\n  const output = new Uint8Array(length);\n  let index = 0;\n  for (const b of buf) {\n    output.set(b, index);\n    index += b.length;\n  }\n\n  return output;\n}\n\n/** Returns true if the source array contains the needle array, false otherwise.\n *\n * A start index can be specified as the third argument that begins the search\n * at that given index. The start index defaults to the beginning of the array.\n *\n * The complexity of this function is O(source.length * needle.length).\n *\n * ```ts\n * import { includesNeedle } from \"./mod.ts\";\n * const source = new Uint8Array([0, 1, 2, 1, 2, 1, 2, 3]);\n * const needle = new Uint8Array([1, 2]);\n * console.log(includesNeedle(source, needle)); // true\n * console.log(includesNeedle(source, needle, 6)); // false\n * ```\n */\nexport function includesNeedle(\n  source: Uint8Array,\n  needle: Uint8Array,\n  start = 0,\n): boolean {\n  return indexOfNeedle(source, needle, start) !== -1;\n}\n\n/** Copy bytes from the `src` array to the `dst` array. Returns the number of\n * bytes copied.\n *\n * If the `src` array is larger than what the `dst` array can hold, only the\n * amount of bytes that fit in the `dst` array are copied.\n *\n * An offset can be specified as the third argument that begins the copy at\n * that given index in the `dst` array. The offset defaults to the beginning of\n * the array.\n *\n * ```ts\n * import { copy } from \"./mod.ts\";\n * const src = new Uint8Array([9, 8, 7]);\n * const dst = new Uint8Array([0, 1, 2, 3, 4, 5]);\n * console.log(copy(src, dst)); // 3\n * console.log(dst); // [9, 8, 7, 3, 4, 5]\n * ```\n *\n * ```ts\n * import { copy } from \"./mod.ts\";\n * const src = new Uint8Array([1, 1, 1, 1]);\n * const dst = new Uint8Array([0, 0, 0, 0]);\n * console.log(copy(src, dst, 1)); // 3\n * console.log(dst); // [0, 1, 1, 1]\n * ```\n */\nexport function copy(src: Uint8Array, dst: Uint8Array, off = 0): number {\n  off = Math.max(0, Math.min(off, dst.byteLength));\n  const dstBytesAvailable = dst.byteLength - off;\n  if (src.byteLength > dstBytesAvailable) {\n    src = src.subarray(0, dstBytesAvailable);\n  }\n  dst.set(src, off);\n  return src.byteLength;\n}\n\nexport { equals } from \"./equals.ts\";\n"],"names":[],"mappings":"AAAA,0EAA0E;AAC1E,qCAAqC;AAErC;;;;;CAKC,GAED;;;;;;;;;;;;;;;CAeC,GACD,OAAO,SAAS,cACd,MAAkB,EAClB,MAAkB,EAClB,QAAQ,CAAC,EACD;IACR,IAAI,SAAS,OAAO,MAAM,EAAE;QAC1B,OAAO,CAAC;IACV,CAAC;IACD,IAAI,QAAQ,GAAG;QACb,QAAQ,KAAK,GAAG,CAAC,GAAG,OAAO,MAAM,GAAG;IACtC,CAAC;IACD,MAAM,IAAI,MAAM,CAAC,EAAE;IACnB,IAAK,IAAI,IAAI,OAAO,IAAI,OAAO,MAAM,EAAE,IAAK;QAC1C,IAAI,MAAM,CAAC,EAAE,KAAK,GAAG,QAAS;QAC9B,MAAM,MAAM;QACZ,IAAI,UAAU;QACd,IAAI,IAAI;QACR,MAAO,UAAU,OAAO,MAAM,CAAE;YAC9B;YACA,IAAI,MAAM,CAAC,EAAE,KAAK,MAAM,CAAC,IAAI,IAAI,EAAE;gBACjC,KAAM;YACR,CAAC;YACD;QACF;QACA,IAAI,YAAY,OAAO,MAAM,EAAE;YAC7B,OAAO;QACT,CAAC;IACH;IACA,OAAO,CAAC;AACV,CAAC;AAED;;;;;;;;;;;;;;;CAeC,GACD,OAAO,SAAS,kBACd,MAAkB,EAClB,MAAkB,EAClB,QAAQ,OAAO,MAAM,GAAG,CAAC,EACjB;IACR,IAAI,QAAQ,GAAG;QACb,OAAO,CAAC;IACV,CAAC;IACD,IAAI,SAAS,OAAO,MAAM,EAAE;QAC1B,QAAQ,OAAO,MAAM,GAAG;IAC1B,CAAC;IACD,MAAM,IAAI,MAAM,CAAC,OAAO,MAAM,GAAG,EAAE;IACnC,IAAK,IAAI,IAAI,OAAO,KAAK,GAAG,IAAK;QAC/B,IAAI,MAAM,CAAC,EAAE,KAAK,GAAG,QAAS;QAC9B,MAAM,MAAM;QACZ,IAAI,UAAU;QACd,IAAI,IAAI;QACR,MAAO,UAAU,OAAO,MAAM,CAAE;YAC9B;YACA,IAAI,MAAM,CAAC,EAAE,KAAK,MAAM,CAAC,OAAO,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,EAAE,EAAE;gBACvD,KAAM;YACR,CAAC;YACD;QACF;QACA,IAAI,YAAY,OAAO,MAAM,EAAE;YAC7B,OAAO,MAAM,OAAO,MAAM,GAAG;QAC/B,CAAC;IACH;IACA,OAAO,CAAC;AACV,CAAC;AAED;;;;;;;;;;;CAWC,GACD,OAAO,SAAS,WAAW,MAAkB,EAAE,MAAkB,EAAW;IAC1E,IAAK,IAAI,IAAI,GAAG,MAAM,OAAO,MAAM,EAAE,IAAI,KAAK,IAAK;QACjD,IAAI,MAAM,CAAC,EAAE,KAAK,MAAM,CAAC,EAAE,EAAE,OAAO,KAAK;IAC3C;IACA,OAAO,IAAI;AACb,CAAC;AAED;;;;;;;;;;;CAWC,GACD,OAAO,SAAS,SAAS,MAAkB,EAAE,MAAkB,EAAW;IACxE,IACE,IAAI,OAAO,OAAO,MAAM,GAAG,GAAG,OAAO,OAAO,MAAM,GAAG,GACrD,QAAQ,GACR,QAAQ,MAAM,CACd;QACA,IAAI,MAAM,CAAC,KAAK,KAAK,MAAM,CAAC,KAAK,EAAE,OAAO,KAAK;IACjD;IACA,OAAO,IAAI;AACb,CAAC;AAED;;;;;;;;;;;;CAYC,GACD,OAAO,SAAS,OAAO,MAAkB,EAAE,KAAa,EAAc;IACpE,IAAI,UAAU,GAAG;QACf,OAAO,IAAI;IACb,CAAC;IAED,IAAI,QAAQ,GAAG;QACb,MAAM,IAAI,WAAW,gCAAgC;IACvD,OAAO,IAAI,AAAC,OAAO,MAAM,GAAG,QAAS,UAAU,OAAO,MAAM,EAAE;QAC5D,MAAM,IAAI,MAAM,uCAAuC;IACzD,CAAC;IAED,MAAM,MAAM,KAAK,KAAK,CAAC;IAEvB,IAAI,QAAQ,OAAO;QACjB,MAAM,IAAI,MAAM,0CAA0C;IAC5D,CAAC;IAED,MAAM,KAAK,IAAI,WAAW,OAAO,MAAM,GAAG;IAE1C,IAAI,KAAK,KAAK,QAAQ;IAEtB,MAAO,KAAK,GAAG,MAAM,EAAE,MAAM,EAAG;QAC9B,KAAK,GAAG,KAAK,CAAC,GAAG,KAAK,IAAI;IAC5B;IAEA,OAAO;AACT,CAAC;AAED;;;;;;;CAOC,GACD,OAAO,SAAS,OAAO,GAAG,GAAiB,EAAc;IACvD,IAAI,SAAS;IACb,KAAK,MAAM,KAAK,IAAK;QACnB,UAAU,EAAE,MAAM;IACpB;IAEA,MAAM,SAAS,IAAI,WAAW;IAC9B,IAAI,QAAQ;IACZ,KAAK,MAAM,KAAK,IAAK;QACnB,OAAO,GAAG,CAAC,GAAG;QACd,SAAS,EAAE,MAAM;IACnB;IAEA,OAAO;AACT,CAAC;AAED;;;;;;;;;;;;;;CAcC,GACD,OAAO,SAAS,eACd,MAAkB,EAClB,MAAkB,EAClB,QAAQ,CAAC,EACA;IACT,OAAO,cAAc,QAAQ,QAAQ,WAAW,CAAC;AACnD,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;CAyBC,GACD,OAAO,SAAS,KAAK,GAAe,EAAE,GAAe,EAAE,MAAM,CAAC,EAAU;IACtE,MAAM,KAAK,GAAG,CAAC,GAAG,KAAK,GAAG,CAAC,KAAK,IAAI,UAAU;IAC9C,MAAM,oBAAoB,IAAI,UAAU,GAAG;IAC3C,IAAI,IAAI,UAAU,GAAG,mBAAmB;QACtC,MAAM,IAAI,QAAQ,CAAC,GAAG;IACxB,CAAC;IACD,IAAI,GAAG,CAAC,KAAK;IACb,OAAO,IAAI,UAAU;AACvB,CAAC;AAED,SAAS,MAAM,QAAQ,cAAc"} \ No newline at end of file diff --git a/tests/__snapshots__/transpile/url/modules/WzxVr2Q8XtUlLvHc6jsTVQR8Mnc.js b/tests/__snapshots__/transpile/url/modules/WzxVr2Q8XtUlLvHc6jsTVQR8Mnc.js new file mode 100644 index 0000000..3767f70 --- /dev/null +++ b/tests/__snapshots__/transpile/url/modules/WzxVr2Q8XtUlLvHc6jsTVQR8Mnc.js @@ -0,0 +1,47 @@ +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +// Copyright the Browserify authors. MIT License. +// Ported from https://github.com/browserify/path-browserify/ +// This module is browser compatible. +// Alphabet chars. +export const CHAR_UPPERCASE_A = 65; /* A */ +export const CHAR_LOWERCASE_A = 97; /* a */ +export const CHAR_UPPERCASE_Z = 90; /* Z */ +export const CHAR_LOWERCASE_Z = 122; /* z */ +// Non-alphabetic chars. +export const CHAR_DOT = 46; /* . */ +export const CHAR_FORWARD_SLASH = 47; /* / */ +export const CHAR_BACKWARD_SLASH = 92; /* \ */ +export const CHAR_VERTICAL_LINE = 124; /* | */ +export const CHAR_COLON = 58; /* : */ +export const CHAR_QUESTION_MARK = 63; /* ? */ +export const CHAR_UNDERSCORE = 95; /* _ */ +export const CHAR_LINE_FEED = 10; /* \n */ +export const CHAR_CARRIAGE_RETURN = 13; /* \r */ +export const CHAR_TAB = 9; /* \t */ +export const CHAR_FORM_FEED = 12; /* \f */ +export const CHAR_EXCLAMATION_MARK = 33; /* ! */ +export const CHAR_HASH = 35; /* # */ +export const CHAR_SPACE = 32; /* */ +export const CHAR_NO_BREAK_SPACE = 160; /* \u00A0 */ +export const CHAR_ZERO_WIDTH_NOBREAK_SPACE = 65279; /* \uFEFF */ +export const CHAR_LEFT_SQUARE_BRACKET = 91; /* [ */ +export const CHAR_RIGHT_SQUARE_BRACKET = 93; /* ] */ +export const CHAR_LEFT_ANGLE_BRACKET = 60; /* < */ +export const CHAR_RIGHT_ANGLE_BRACKET = 62; /* > */ +export const CHAR_LEFT_CURLY_BRACKET = 123; /* { */ +export const CHAR_RIGHT_CURLY_BRACKET = 125; /* } */ +export const CHAR_HYPHEN_MINUS = 45; /* - */ +export const CHAR_PLUS = 43; /* + */ +export const CHAR_DOUBLE_QUOTE = 34; /* " */ +export const CHAR_SINGLE_QUOTE = 39; /* ' */ +export const CHAR_PERCENT = 37; /* % */ +export const CHAR_SEMICOLON = 59; /* ; */ +export const CHAR_CIRCUMFLEX_ACCENT = 94; /* ^ */ +export const CHAR_GRAVE_ACCENT = 96; /* ` */ +export const CHAR_AT = 64; /* @ */ +export const CHAR_AMPERSAND = 38; /* & */ +export const CHAR_EQUAL = 61; /* = */ +// Digits +export const CHAR_0 = 48; /* 0 */ +export const CHAR_9 = 57; /* 9 */ +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/tests/__snapshots__/transpile/url/modules/ZD3DgFZlCOXbEC8b6k6GmMtkN3g.js b/tests/__snapshots__/transpile/url/modules/ZD3DgFZlCOXbEC8b6k6GmMtkN3g.js new file mode 100644 index 0000000..0fdef86 --- /dev/null +++ b/tests/__snapshots__/transpile/url/modules/ZD3DgFZlCOXbEC8b6k6GmMtkN3g.js @@ -0,0 +1,430 @@ +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +import { Buffer } from "../io/buffer.ts"; +const DEFAULT_CHUNK_SIZE = 16_640; +const DEFAULT_BUFFER_SIZE = 32 * 1024; +function isCloser(value) { + return typeof value === "object" && value != null && "close" in value && // deno-lint-ignore no-explicit-any + typeof value["close"] === "function"; +} +/** Create a `Deno.Reader` from an iterable of `Uint8Array`s. + * + * ```ts + * import { readerFromIterable } from "./conversion.ts"; + * + * const file = await Deno.open("metrics.txt", { write: true }); + * const reader = readerFromIterable((async function* () { + * while (true) { + * await new Promise((r) => setTimeout(r, 1000)); + * const message = `data: ${JSON.stringify(Deno.metrics())}\n\n`; + * yield new TextEncoder().encode(message); + * } + * })()); + * await Deno.copy(reader, file); + * ``` + */ export function readerFromIterable(iterable) { + const iterator = iterable[Symbol.asyncIterator]?.() ?? iterable[Symbol.iterator]?.(); + const buffer = new Buffer(); + return { + async read (p) { + if (buffer.length == 0) { + const result = await iterator.next(); + if (result.done) { + return null; + } else { + if (result.value.byteLength <= p.byteLength) { + p.set(result.value); + return result.value.byteLength; + } + p.set(result.value.subarray(0, p.byteLength)); + await writeAll(buffer, result.value.subarray(p.byteLength)); + return p.byteLength; + } + } else { + const n = await buffer.read(p); + if (n == null) { + return this.read(p); + } + return n; + } + } + }; +} +/** Create a `Writer` from a `WritableStreamDefaultWriter`. */ export function writerFromStreamWriter(streamWriter) { + return { + async write (p) { + await streamWriter.ready; + await streamWriter.write(p); + return p.length; + } + }; +} +/** Create a `Reader` from a `ReadableStreamDefaultReader`. */ export function readerFromStreamReader(streamReader) { + const buffer = new Buffer(); + return { + async read (p) { + if (buffer.empty()) { + const res = await streamReader.read(); + if (res.done) { + return null; // EOF + } + await writeAll(buffer, res.value); + } + return buffer.read(p); + } + }; +} +/** Create a `WritableStream` from a `Writer`. */ export function writableStreamFromWriter(writer, options = {}) { + const { autoClose =true } = options; + return new WritableStream({ + async write (chunk, controller) { + try { + await writeAll(writer, chunk); + } catch (e) { + controller.error(e); + if (isCloser(writer) && autoClose) { + writer.close(); + } + } + }, + close () { + if (isCloser(writer) && autoClose) { + writer.close(); + } + }, + abort () { + if (isCloser(writer) && autoClose) { + writer.close(); + } + } + }); +} +/** Create a `ReadableStream` from any kind of iterable. + * + * ```ts + * import { readableStreamFromIterable } from "./conversion.ts"; + * + * const r1 = readableStreamFromIterable(["foo, bar, baz"]); + * const r2 = readableStreamFromIterable(async function* () { + * await new Promise(((r) => setTimeout(r, 1000))); + * yield "foo"; + * await new Promise(((r) => setTimeout(r, 1000))); + * yield "bar"; + * await new Promise(((r) => setTimeout(r, 1000))); + * yield "baz"; + * }()); + * ``` + * + * If the produced iterator (`iterable[Symbol.asyncIterator]()` or + * `iterable[Symbol.iterator]()`) is a generator, or more specifically is found + * to have a `.throw()` method on it, that will be called upon + * `readableStream.cancel()`. This is the case for the second input type above: + * + * ```ts + * import { readableStreamFromIterable } from "./conversion.ts"; + * + * const r3 = readableStreamFromIterable(async function* () { + * try { + * yield "foo"; + * } catch (error) { + * console.log(error); // Error: Cancelled by consumer. + * } + * }()); + * const reader = r3.getReader(); + * console.log(await reader.read()); // { value: "foo", done: false } + * await reader.cancel(new Error("Cancelled by consumer.")); + * ``` + */ export function readableStreamFromIterable(iterable) { + const iterator = iterable[Symbol.asyncIterator]?.() ?? iterable[Symbol.iterator]?.(); + return new ReadableStream({ + async pull (controller) { + const { value , done } = await iterator.next(); + if (done) { + controller.close(); + } else { + controller.enqueue(value); + } + }, + async cancel (reason) { + if (typeof iterator.throw == "function") { + try { + await iterator.throw(reason); + } catch {} + } + } + }); +} +/** + * Create a `ReadableStream` from from a `Deno.Reader`. + * + * When the pull algorithm is called on the stream, a chunk from the reader + * will be read. When `null` is returned from the reader, the stream will be + * closed along with the reader (if it is also a `Deno.Closer`). + * + * An example converting a `Deno.FsFile` into a readable stream: + * + * ```ts + * import { readableStreamFromReader } from "./mod.ts"; + * + * const file = await Deno.open("./file.txt", { read: true }); + * const fileStream = readableStreamFromReader(file); + * ``` + */ export function readableStreamFromReader(reader, options = {}) { + const { autoClose =true , chunkSize =DEFAULT_CHUNK_SIZE , strategy } = options; + return new ReadableStream({ + async pull (controller) { + const chunk = new Uint8Array(chunkSize); + try { + const read = await reader.read(chunk); + if (read === null) { + if (isCloser(reader) && autoClose) { + reader.close(); + } + controller.close(); + return; + } + controller.enqueue(chunk.subarray(0, read)); + } catch (e) { + controller.error(e); + if (isCloser(reader)) { + reader.close(); + } + } + }, + cancel () { + if (isCloser(reader) && autoClose) { + reader.close(); + } + } + }, strategy); +} +/** Read Reader `r` until EOF (`null`) and resolve to the content as + * Uint8Array`. + * + * ```ts + * import { Buffer } from "../io/buffer.ts"; + * import { readAll } from "./conversion.ts"; + * + * // Example from stdin + * const stdinContent = await readAll(Deno.stdin); + * + * // Example from file + * const file = await Deno.open("my_file.txt", {read: true}); + * const myFileContent = await readAll(file); + * Deno.close(file.rid); + * + * // Example from buffer + * const myData = new Uint8Array(100); + * // ... fill myData array with data + * const reader = new Buffer(myData.buffer); + * const bufferContent = await readAll(reader); + * ``` + */ export async function readAll(r) { + const buf = new Buffer(); + await buf.readFrom(r); + return buf.bytes(); +} +/** Synchronously reads Reader `r` until EOF (`null`) and returns the content + * as `Uint8Array`. + * + * ```ts + * import { Buffer } from "../io/buffer.ts"; + * import { readAllSync } from "./conversion.ts"; + * + * // Example from stdin + * const stdinContent = readAllSync(Deno.stdin); + * + * // Example from file + * const file = Deno.openSync("my_file.txt", {read: true}); + * const myFileContent = readAllSync(file); + * Deno.close(file.rid); + * + * // Example from buffer + * const myData = new Uint8Array(100); + * // ... fill myData array with data + * const reader = new Buffer(myData.buffer); + * const bufferContent = readAllSync(reader); + * ``` + */ export function readAllSync(r) { + const buf = new Buffer(); + buf.readFromSync(r); + return buf.bytes(); +} +/** Write all the content of the array buffer (`arr`) to the writer (`w`). + * + * ```ts + * import { Buffer } from "../io/buffer.ts"; + * import { writeAll } from "./conversion.ts"; + + * // Example writing to stdout + * let contentBytes = new TextEncoder().encode("Hello World"); + * await writeAll(Deno.stdout, contentBytes); + * + * // Example writing to file + * contentBytes = new TextEncoder().encode("Hello World"); + * const file = await Deno.open('test.file', {write: true}); + * await writeAll(file, contentBytes); + * Deno.close(file.rid); + * + * // Example writing to buffer + * contentBytes = new TextEncoder().encode("Hello World"); + * const writer = new Buffer(); + * await writeAll(writer, contentBytes); + * console.log(writer.bytes().length); // 11 + * ``` + */ export async function writeAll(w, arr) { + let nwritten = 0; + while(nwritten < arr.length){ + nwritten += await w.write(arr.subarray(nwritten)); + } +} +/** Synchronously write all the content of the array buffer (`arr`) to the + * writer (`w`). + * + * ```ts + * import { Buffer } from "../io/buffer.ts"; + * import { writeAllSync } from "./conversion.ts"; + * + * // Example writing to stdout + * let contentBytes = new TextEncoder().encode("Hello World"); + * writeAllSync(Deno.stdout, contentBytes); + * + * // Example writing to file + * contentBytes = new TextEncoder().encode("Hello World"); + * const file = Deno.openSync('test.file', {write: true}); + * writeAllSync(file, contentBytes); + * Deno.close(file.rid); + * + * // Example writing to buffer + * contentBytes = new TextEncoder().encode("Hello World"); + * const writer = new Buffer(); + * writeAllSync(writer, contentBytes); + * console.log(writer.bytes().length); // 11 + * ``` + */ export function writeAllSync(w, arr) { + let nwritten = 0; + while(nwritten < arr.length){ + nwritten += w.writeSync(arr.subarray(nwritten)); + } +} +/** Turns a Reader, `r`, into an async iterator. + * + * ```ts + * import { iterateReader } from "./conversion.ts"; + * + * let f = await Deno.open("/etc/passwd"); + * for await (const chunk of iterateReader(f)) { + * console.log(chunk); + * } + * f.close(); + * ``` + * + * Second argument can be used to tune size of a buffer. + * Default size of the buffer is 32kB. + * + * ```ts + * import { iterateReader } from "./conversion.ts"; + * + * let f = await Deno.open("/etc/passwd"); + * const it = iterateReader(f, { + * bufSize: 1024 * 1024 + * }); + * for await (const chunk of it) { + * console.log(chunk); + * } + * f.close(); + * ``` + * + * Iterator uses an internal buffer of fixed size for efficiency; it returns + * a view on that buffer on each iteration. It is therefore caller's + * responsibility to copy contents of the buffer if needed; otherwise the + * next iteration will overwrite contents of previously returned chunk. + */ export async function* iterateReader(r, options) { + const bufSize = options?.bufSize ?? DEFAULT_BUFFER_SIZE; + const b = new Uint8Array(bufSize); + while(true){ + const result = await r.read(b); + if (result === null) { + break; + } + yield b.subarray(0, result); + } +} +/** Turns a ReaderSync, `r`, into an iterator. + * + * ```ts + * import { iterateReaderSync } from "./conversion.ts"; + * + * let f = Deno.openSync("/etc/passwd"); + * for (const chunk of iterateReaderSync(f)) { + * console.log(chunk); + * } + * f.close(); + * ``` + * + * Second argument can be used to tune size of a buffer. + * Default size of the buffer is 32kB. + * + * ```ts + * import { iterateReaderSync } from "./conversion.ts"; + + * let f = await Deno.open("/etc/passwd"); + * const iter = iterateReaderSync(f, { + * bufSize: 1024 * 1024 + * }); + * for (const chunk of iter) { + * console.log(chunk); + * } + * f.close(); + * ``` + * + * Iterator uses an internal buffer of fixed size for efficiency; it returns + * a view on that buffer on each iteration. It is therefore caller's + * responsibility to copy contents of the buffer if needed; otherwise the + * next iteration will overwrite contents of previously returned chunk. + */ export function* iterateReaderSync(r, options) { + const bufSize = options?.bufSize ?? DEFAULT_BUFFER_SIZE; + const b = new Uint8Array(bufSize); + while(true){ + const result = r.readSync(b); + if (result === null) { + break; + } + yield b.subarray(0, result); + } +} +/** Copies from `src` to `dst` until either EOF (`null`) is read from `src` or + * an error occurs. It resolves to the number of bytes copied or rejects with + * the first error encountered while copying. + * + * ```ts + * import { copy } from "./conversion.ts"; + * + * const source = await Deno.open("my_file.txt"); + * const bytesCopied1 = await copy(source, Deno.stdout); + * const destination = await Deno.create("my_file_2.txt"); + * const bytesCopied2 = await copy(source, destination); + * ``` + * + * @param src The source to copy from + * @param dst The destination to copy to + * @param options Can be used to tune size of the buffer. Default size is 32kB + */ export async function copy(src, dst, options) { + let n = 0; + const bufSize = options?.bufSize ?? DEFAULT_BUFFER_SIZE; + const b = new Uint8Array(bufSize); + let gotEOF = false; + while(gotEOF === false){ + const result = await src.read(b); + if (result === null) { + gotEOF = true; + } else { + let nwritten = 0; + while(nwritten < result){ + nwritten += await dst.write(b.subarray(nwritten, result)); + } + n += nwritten; + } + } + return n; +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["https://deno.land/std@0.140.0/streams/conversion.ts"],"sourcesContent":["// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.\n\nimport { Buffer } from \"../io/buffer.ts\";\n\nconst DEFAULT_CHUNK_SIZE = 16_640;\nconst DEFAULT_BUFFER_SIZE = 32 * 1024;\n\nfunction isCloser(value: unknown): value is Deno.Closer {\n  return typeof value === \"object\" && value != null && \"close\" in value &&\n    // deno-lint-ignore no-explicit-any\n    typeof (value as Record<string, any>)[\"close\"] === \"function\";\n}\n\n/** Create a `Deno.Reader` from an iterable of `Uint8Array`s.\n *\n * ```ts\n *      import { readerFromIterable } from \"./conversion.ts\";\n *\n *      const file = await Deno.open(\"metrics.txt\", { write: true });\n *      const reader = readerFromIterable((async function* () {\n *        while (true) {\n *          await new Promise((r) => setTimeout(r, 1000));\n *          const message = `data: ${JSON.stringify(Deno.metrics())}\\n\\n`;\n *          yield new TextEncoder().encode(message);\n *        }\n *      })());\n *      await Deno.copy(reader, file);\n * ```\n */\nexport function readerFromIterable(\n  iterable: Iterable<Uint8Array> | AsyncIterable<Uint8Array>,\n): Deno.Reader {\n  const iterator: Iterator<Uint8Array> | AsyncIterator<Uint8Array> =\n    (iterable as AsyncIterable<Uint8Array>)[Symbol.asyncIterator]?.() ??\n      (iterable as Iterable<Uint8Array>)[Symbol.iterator]?.();\n  const buffer = new Buffer();\n  return {\n    async read(p: Uint8Array): Promise<number | null> {\n      if (buffer.length == 0) {\n        const result = await iterator.next();\n        if (result.done) {\n          return null;\n        } else {\n          if (result.value.byteLength <= p.byteLength) {\n            p.set(result.value);\n            return result.value.byteLength;\n          }\n          p.set(result.value.subarray(0, p.byteLength));\n          await writeAll(buffer, result.value.subarray(p.byteLength));\n          return p.byteLength;\n        }\n      } else {\n        const n = await buffer.read(p);\n        if (n == null) {\n          return this.read(p);\n        }\n        return n;\n      }\n    },\n  };\n}\n\n/** Create a `Writer` from a `WritableStreamDefaultWriter`. */\nexport function writerFromStreamWriter(\n  streamWriter: WritableStreamDefaultWriter<Uint8Array>,\n): Deno.Writer {\n  return {\n    async write(p: Uint8Array): Promise<number> {\n      await streamWriter.ready;\n      await streamWriter.write(p);\n      return p.length;\n    },\n  };\n}\n\n/** Create a `Reader` from a `ReadableStreamDefaultReader`. */\nexport function readerFromStreamReader(\n  streamReader: ReadableStreamDefaultReader<Uint8Array>,\n): Deno.Reader {\n  const buffer = new Buffer();\n\n  return {\n    async read(p: Uint8Array): Promise<number | null> {\n      if (buffer.empty()) {\n        const res = await streamReader.read();\n        if (res.done) {\n          return null; // EOF\n        }\n\n        await writeAll(buffer, res.value);\n      }\n\n      return buffer.read(p);\n    },\n  };\n}\n\nexport interface WritableStreamFromWriterOptions {\n  /**\n   * If the `writer` is also a `Deno.Closer`, automatically close the `writer`\n   * when the stream is closed, aborted, or a write error occurs.\n   *\n   * Defaults to `true`. */\n  autoClose?: boolean;\n}\n\n/** Create a `WritableStream` from a `Writer`. */\nexport function writableStreamFromWriter(\n  writer: Deno.Writer,\n  options: WritableStreamFromWriterOptions = {},\n): WritableStream<Uint8Array> {\n  const { autoClose = true } = options;\n\n  return new WritableStream({\n    async write(chunk, controller) {\n      try {\n        await writeAll(writer, chunk);\n      } catch (e) {\n        controller.error(e);\n        if (isCloser(writer) && autoClose) {\n          writer.close();\n        }\n      }\n    },\n    close() {\n      if (isCloser(writer) && autoClose) {\n        writer.close();\n      }\n    },\n    abort() {\n      if (isCloser(writer) && autoClose) {\n        writer.close();\n      }\n    },\n  });\n}\n\n/** Create a `ReadableStream` from any kind of iterable.\n *\n * ```ts\n *      import { readableStreamFromIterable } from \"./conversion.ts\";\n *\n *      const r1 = readableStreamFromIterable([\"foo, bar, baz\"]);\n *      const r2 = readableStreamFromIterable(async function* () {\n *        await new Promise(((r) => setTimeout(r, 1000)));\n *        yield \"foo\";\n *        await new Promise(((r) => setTimeout(r, 1000)));\n *        yield \"bar\";\n *        await new Promise(((r) => setTimeout(r, 1000)));\n *        yield \"baz\";\n *      }());\n * ```\n *\n * If the produced iterator (`iterable[Symbol.asyncIterator]()` or\n * `iterable[Symbol.iterator]()`) is a generator, or more specifically is found\n * to have a `.throw()` method on it, that will be called upon\n * `readableStream.cancel()`. This is the case for the second input type above:\n *\n * ```ts\n * import { readableStreamFromIterable } from \"./conversion.ts\";\n *\n * const r3 = readableStreamFromIterable(async function* () {\n *   try {\n *     yield \"foo\";\n *   } catch (error) {\n *     console.log(error); // Error: Cancelled by consumer.\n *   }\n * }());\n * const reader = r3.getReader();\n * console.log(await reader.read()); // { value: \"foo\", done: false }\n * await reader.cancel(new Error(\"Cancelled by consumer.\"));\n * ```\n */\nexport function readableStreamFromIterable<T>(\n  iterable: Iterable<T> | AsyncIterable<T>,\n): ReadableStream<T> {\n  const iterator: Iterator<T> | AsyncIterator<T> =\n    (iterable as AsyncIterable<T>)[Symbol.asyncIterator]?.() ??\n      (iterable as Iterable<T>)[Symbol.iterator]?.();\n  return new ReadableStream({\n    async pull(controller) {\n      const { value, done } = await iterator.next();\n      if (done) {\n        controller.close();\n      } else {\n        controller.enqueue(value);\n      }\n    },\n    async cancel(reason) {\n      if (typeof iterator.throw == \"function\") {\n        try {\n          await iterator.throw(reason);\n        } catch { /* `iterator.throw()` always throws on site. We catch it. */ }\n      }\n    },\n  });\n}\n\nexport interface ReadableStreamFromReaderOptions {\n  /** If the `reader` is also a `Deno.Closer`, automatically close the `reader`\n   * when `EOF` is encountered, or a read error occurs.\n   *\n   * Defaults to `true`. */\n  autoClose?: boolean;\n\n  /** The size of chunks to allocate to read, the default is ~16KiB, which is\n   * the maximum size that Deno operations can currently support. */\n  chunkSize?: number;\n\n  /** The queuing strategy to create the `ReadableStream` with. */\n  strategy?: { highWaterMark?: number | undefined; size?: undefined };\n}\n\n/**\n * Create a `ReadableStream<Uint8Array>` from from a `Deno.Reader`.\n *\n * When the pull algorithm is called on the stream, a chunk from the reader\n * will be read.  When `null` is returned from the reader, the stream will be\n * closed along with the reader (if it is also a `Deno.Closer`).\n *\n * An example converting a `Deno.FsFile` into a readable stream:\n *\n * ```ts\n * import { readableStreamFromReader } from \"./mod.ts\";\n *\n * const file = await Deno.open(\"./file.txt\", { read: true });\n * const fileStream = readableStreamFromReader(file);\n * ```\n */\nexport function readableStreamFromReader(\n  reader: Deno.Reader | (Deno.Reader & Deno.Closer),\n  options: ReadableStreamFromReaderOptions = {},\n): ReadableStream<Uint8Array> {\n  const {\n    autoClose = true,\n    chunkSize = DEFAULT_CHUNK_SIZE,\n    strategy,\n  } = options;\n\n  return new ReadableStream({\n    async pull(controller) {\n      const chunk = new Uint8Array(chunkSize);\n      try {\n        const read = await reader.read(chunk);\n        if (read === null) {\n          if (isCloser(reader) && autoClose) {\n            reader.close();\n          }\n          controller.close();\n          return;\n        }\n        controller.enqueue(chunk.subarray(0, read));\n      } catch (e) {\n        controller.error(e);\n        if (isCloser(reader)) {\n          reader.close();\n        }\n      }\n    },\n    cancel() {\n      if (isCloser(reader) && autoClose) {\n        reader.close();\n      }\n    },\n  }, strategy);\n}\n\n/** Read Reader `r` until EOF (`null`) and resolve to the content as\n * Uint8Array`.\n *\n * ```ts\n * import { Buffer } from \"../io/buffer.ts\";\n * import { readAll } from \"./conversion.ts\";\n *\n * // Example from stdin\n * const stdinContent = await readAll(Deno.stdin);\n *\n * // Example from file\n * const file = await Deno.open(\"my_file.txt\", {read: true});\n * const myFileContent = await readAll(file);\n * Deno.close(file.rid);\n *\n * // Example from buffer\n * const myData = new Uint8Array(100);\n * // ... fill myData array with data\n * const reader = new Buffer(myData.buffer);\n * const bufferContent = await readAll(reader);\n * ```\n */\nexport async function readAll(r: Deno.Reader): Promise<Uint8Array> {\n  const buf = new Buffer();\n  await buf.readFrom(r);\n  return buf.bytes();\n}\n\n/** Synchronously reads Reader `r` until EOF (`null`) and returns the content\n * as `Uint8Array`.\n *\n * ```ts\n * import { Buffer } from \"../io/buffer.ts\";\n * import { readAllSync } from \"./conversion.ts\";\n *\n * // Example from stdin\n * const stdinContent = readAllSync(Deno.stdin);\n *\n * // Example from file\n * const file = Deno.openSync(\"my_file.txt\", {read: true});\n * const myFileContent = readAllSync(file);\n * Deno.close(file.rid);\n *\n * // Example from buffer\n * const myData = new Uint8Array(100);\n * // ... fill myData array with data\n * const reader = new Buffer(myData.buffer);\n * const bufferContent = readAllSync(reader);\n * ```\n */\nexport function readAllSync(r: Deno.ReaderSync): Uint8Array {\n  const buf = new Buffer();\n  buf.readFromSync(r);\n  return buf.bytes();\n}\n\n/** Write all the content of the array buffer (`arr`) to the writer (`w`).\n *\n * ```ts\n * import { Buffer } from \"../io/buffer.ts\";\n * import { writeAll } from \"./conversion.ts\";\n\n * // Example writing to stdout\n * let contentBytes = new TextEncoder().encode(\"Hello World\");\n * await writeAll(Deno.stdout, contentBytes);\n *\n * // Example writing to file\n * contentBytes = new TextEncoder().encode(\"Hello World\");\n * const file = await Deno.open('test.file', {write: true});\n * await writeAll(file, contentBytes);\n * Deno.close(file.rid);\n *\n * // Example writing to buffer\n * contentBytes = new TextEncoder().encode(\"Hello World\");\n * const writer = new Buffer();\n * await writeAll(writer, contentBytes);\n * console.log(writer.bytes().length);  // 11\n * ```\n */\nexport async function writeAll(w: Deno.Writer, arr: Uint8Array) {\n  let nwritten = 0;\n  while (nwritten < arr.length) {\n    nwritten += await w.write(arr.subarray(nwritten));\n  }\n}\n\n/** Synchronously write all the content of the array buffer (`arr`) to the\n * writer (`w`).\n *\n * ```ts\n * import { Buffer } from \"../io/buffer.ts\";\n * import { writeAllSync } from \"./conversion.ts\";\n *\n * // Example writing to stdout\n * let contentBytes = new TextEncoder().encode(\"Hello World\");\n * writeAllSync(Deno.stdout, contentBytes);\n *\n * // Example writing to file\n * contentBytes = new TextEncoder().encode(\"Hello World\");\n * const file = Deno.openSync('test.file', {write: true});\n * writeAllSync(file, contentBytes);\n * Deno.close(file.rid);\n *\n * // Example writing to buffer\n * contentBytes = new TextEncoder().encode(\"Hello World\");\n * const writer = new Buffer();\n * writeAllSync(writer, contentBytes);\n * console.log(writer.bytes().length);  // 11\n * ```\n */\nexport function writeAllSync(w: Deno.WriterSync, arr: Uint8Array): void {\n  let nwritten = 0;\n  while (nwritten < arr.length) {\n    nwritten += w.writeSync(arr.subarray(nwritten));\n  }\n}\n\n/** Turns a Reader, `r`, into an async iterator.\n *\n * ```ts\n * import { iterateReader } from \"./conversion.ts\";\n *\n * let f = await Deno.open(\"/etc/passwd\");\n * for await (const chunk of iterateReader(f)) {\n *   console.log(chunk);\n * }\n * f.close();\n * ```\n *\n * Second argument can be used to tune size of a buffer.\n * Default size of the buffer is 32kB.\n *\n * ```ts\n * import { iterateReader } from \"./conversion.ts\";\n *\n * let f = await Deno.open(\"/etc/passwd\");\n * const it = iterateReader(f, {\n *   bufSize: 1024 * 1024\n * });\n * for await (const chunk of it) {\n *   console.log(chunk);\n * }\n * f.close();\n * ```\n *\n * Iterator uses an internal buffer of fixed size for efficiency; it returns\n * a view on that buffer on each iteration. It is therefore caller's\n * responsibility to copy contents of the buffer if needed; otherwise the\n * next iteration will overwrite contents of previously returned chunk.\n */\nexport async function* iterateReader(\n  r: Deno.Reader,\n  options?: {\n    bufSize?: number;\n  },\n): AsyncIterableIterator<Uint8Array> {\n  const bufSize = options?.bufSize ?? DEFAULT_BUFFER_SIZE;\n  const b = new Uint8Array(bufSize);\n  while (true) {\n    const result = await r.read(b);\n    if (result === null) {\n      break;\n    }\n\n    yield b.subarray(0, result);\n  }\n}\n\n/** Turns a ReaderSync, `r`, into an iterator.\n *\n * ```ts\n * import { iterateReaderSync } from \"./conversion.ts\";\n *\n * let f = Deno.openSync(\"/etc/passwd\");\n * for (const chunk of iterateReaderSync(f)) {\n *   console.log(chunk);\n * }\n * f.close();\n * ```\n *\n * Second argument can be used to tune size of a buffer.\n * Default size of the buffer is 32kB.\n *\n * ```ts\n * import { iterateReaderSync } from \"./conversion.ts\";\n\n * let f = await Deno.open(\"/etc/passwd\");\n * const iter = iterateReaderSync(f, {\n *   bufSize: 1024 * 1024\n * });\n * for (const chunk of iter) {\n *   console.log(chunk);\n * }\n * f.close();\n * ```\n *\n * Iterator uses an internal buffer of fixed size for efficiency; it returns\n * a view on that buffer on each iteration. It is therefore caller's\n * responsibility to copy contents of the buffer if needed; otherwise the\n * next iteration will overwrite contents of previously returned chunk.\n */\nexport function* iterateReaderSync(\n  r: Deno.ReaderSync,\n  options?: {\n    bufSize?: number;\n  },\n): IterableIterator<Uint8Array> {\n  const bufSize = options?.bufSize ?? DEFAULT_BUFFER_SIZE;\n  const b = new Uint8Array(bufSize);\n  while (true) {\n    const result = r.readSync(b);\n    if (result === null) {\n      break;\n    }\n\n    yield b.subarray(0, result);\n  }\n}\n\n/** Copies from `src` to `dst` until either EOF (`null`) is read from `src` or\n * an error occurs. It resolves to the number of bytes copied or rejects with\n * the first error encountered while copying.\n *\n * ```ts\n * import { copy } from \"./conversion.ts\";\n *\n * const source = await Deno.open(\"my_file.txt\");\n * const bytesCopied1 = await copy(source, Deno.stdout);\n * const destination = await Deno.create(\"my_file_2.txt\");\n * const bytesCopied2 = await copy(source, destination);\n * ```\n *\n * @param src The source to copy from\n * @param dst The destination to copy to\n * @param options Can be used to tune size of the buffer. Default size is 32kB\n */\nexport async function copy(\n  src: Deno.Reader,\n  dst: Deno.Writer,\n  options?: {\n    bufSize?: number;\n  },\n): Promise<number> {\n  let n = 0;\n  const bufSize = options?.bufSize ?? DEFAULT_BUFFER_SIZE;\n  const b = new Uint8Array(bufSize);\n  let gotEOF = false;\n  while (gotEOF === false) {\n    const result = await src.read(b);\n    if (result === null) {\n      gotEOF = true;\n    } else {\n      let nwritten = 0;\n      while (nwritten < result) {\n        nwritten += await dst.write(b.subarray(nwritten, result));\n      }\n      n += nwritten;\n    }\n  }\n  return n;\n}\n"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/tests/__snapshots__/transpile/url/modules/ebsv4XtKEF8sxrDsnkLX8K9VdOA.js b/tests/__snapshots__/transpile/url/modules/ebsv4XtKEF8sxrDsnkLX8K9VdOA.js new file mode 100644 index 0000000..30e11f0 --- /dev/null +++ b/tests/__snapshots__/transpile/url/modules/ebsv4XtKEF8sxrDsnkLX8K9VdOA.js @@ -0,0 +1,18 @@ +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. +export const osType = (()=>{ + // deno-lint-ignore no-explicit-any + const { Deno } = globalThis; + if (typeof Deno?.build?.os === "string") { + return Deno.build.os; + } + // deno-lint-ignore no-explicit-any + const { navigator } = globalThis; + if (navigator?.appVersion?.includes?.("Win")) { + return "windows"; + } + return "linux"; +})(); +export const isWindows = osType === "windows"; +export const isLinux = osType === "linux"; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImh0dHBzOi8vZGVuby5sYW5kL3N0ZEAwLjE0MC4wL191dGlsL29zLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAyMDE4LTIwMjIgdGhlIERlbm8gYXV0aG9ycy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4gTUlUIGxpY2Vuc2UuXG4vLyBUaGlzIG1vZHVsZSBpcyBicm93c2VyIGNvbXBhdGlibGUuXG5cbmV4cG9ydCB0eXBlIE9TVHlwZSA9IFwid2luZG93c1wiIHwgXCJsaW51eFwiIHwgXCJkYXJ3aW5cIjtcblxuZXhwb3J0IGNvbnN0IG9zVHlwZTogT1NUeXBlID0gKCgpID0+IHtcbiAgLy8gZGVuby1saW50LWlnbm9yZSBuby1leHBsaWNpdC1hbnlcbiAgY29uc3QgeyBEZW5vIH0gPSBnbG9iYWxUaGlzIGFzIGFueTtcbiAgaWYgKHR5cGVvZiBEZW5vPy5idWlsZD8ub3MgPT09IFwic3RyaW5nXCIpIHtcbiAgICByZXR1cm4gRGVuby5idWlsZC5vcztcbiAgfVxuXG4gIC8vIGRlbm8tbGludC1pZ25vcmUgbm8tZXhwbGljaXQtYW55XG4gIGNvbnN0IHsgbmF2aWdhdG9yIH0gPSBnbG9iYWxUaGlzIGFzIGFueTtcbiAgaWYgKG5hdmlnYXRvcj8uYXBwVmVyc2lvbj8uaW5jbHVkZXM/LihcIldpblwiKSkge1xuICAgIHJldHVybiBcIndpbmRvd3NcIjtcbiAgfVxuXG4gIHJldHVybiBcImxpbnV4XCI7XG59KSgpO1xuXG5leHBvcnQgY29uc3QgaXNXaW5kb3dzID0gb3NUeXBlID09PSBcIndpbmRvd3NcIjtcbmV4cG9ydCBjb25zdCBpc0xpbnV4ID0gb3NUeXBlID09PSBcImxpbnV4XCI7XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsMEVBQTBFO0FBQzFFLHFDQUFxQztBQUlyQyxPQUFPLE1BQU0sU0FBaUIsQUFBQyxDQUFBLElBQU07SUFDbkMsbUNBQW1DO0lBQ25DLE1BQU0sRUFBRSxLQUFJLEVBQUUsR0FBRztJQUNqQixJQUFJLE9BQU8sTUFBTSxPQUFPLE9BQU8sVUFBVTtRQUN2QyxPQUFPLEtBQUssS0FBSyxDQUFDLEVBQUU7SUFDdEIsQ0FBQztJQUVELG1DQUFtQztJQUNuQyxNQUFNLEVBQUUsVUFBUyxFQUFFLEdBQUc7SUFDdEIsSUFBSSxXQUFXLFlBQVksV0FBVyxRQUFRO1FBQzVDLE9BQU87SUFDVCxDQUFDO0lBRUQsT0FBTztBQUNULENBQUEsSUFBSztBQUVMLE9BQU8sTUFBTSxZQUFZLFdBQVcsVUFBVTtBQUM5QyxPQUFPLE1BQU0sVUFBVSxXQUFXLFFBQVEifQ== \ No newline at end of file diff --git a/tests/__snapshots__/transpile/url/modules/jO4Cj24EIKVTiTvdPctAVhckzgg.js b/tests/__snapshots__/transpile/url/modules/jO4Cj24EIKVTiTvdPctAVhckzgg.js new file mode 100644 index 0000000..121d0d0 --- /dev/null +++ b/tests/__snapshots__/transpile/url/modules/jO4Cj24EIKVTiTvdPctAVhckzgg.js @@ -0,0 +1,39 @@ +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. +/** Check whether binary arrays are equal to each other using 8-bit comparisons. + * @private + * @param a first array to check equality + * @param b second array to check equality + */ export function equalsNaive(a, b) { + if (a.length !== b.length) return false; + for(let i = 0; i < b.length; i++){ + if (a[i] !== b[i]) return false; + } + return true; +} +/** Check whether binary arrays are equal to each other using 32-bit comparisons. + * @private + * @param a first array to check equality + * @param b second array to check equality + */ export function equalsSimd(a, b) { + if (a.length !== b.length) return false; + const len = a.length; + const compressable = Math.floor(len / 4); + const compressedA = new Uint32Array(a.buffer, 0, compressable); + const compressedB = new Uint32Array(b.buffer, 0, compressable); + for(let i = compressable * 4; i < len; i++){ + if (a[i] !== b[i]) return false; + } + for(let i = 0; i < compressedA.length; i++){ + if (compressedA[i] !== compressedB[i]) return false; + } + return true; +} +/** Check whether binary arrays are equal to each other. + * @param a first array to check equality + * @param b second array to check equality + */ export function equals(a, b) { + if (a.length < 1000) return equalsNaive(a, b); + return equalsSimd(a, b); +} +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/tests/__snapshots__/transpile/url/modules/kWDlQkpYLFWxtJdAejga3vZCeeM.js b/tests/__snapshots__/transpile/url/modules/kWDlQkpYLFWxtJdAejga3vZCeeM.js new file mode 100644 index 0000000..c838ff9 --- /dev/null +++ b/tests/__snapshots__/transpile/url/modules/kWDlQkpYLFWxtJdAejga3vZCeeM.js @@ -0,0 +1,433 @@ +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +// Copyright the Browserify authors. MIT License. +// Ported from https://github.com/browserify/path-browserify/ +// This module is browser compatible. +import { CHAR_DOT, CHAR_FORWARD_SLASH } from "./_constants.ts"; +import { _format, assertPath, encodeWhitespace, isPosixPathSeparator, normalizeString } from "./_util.ts"; +export const sep = "/"; +export const delimiter = ":"; +// path.resolve([from ...], to) +/** + * Resolves `pathSegments` into an absolute path. + * @param pathSegments an array of path segments + */ export function resolve(...pathSegments) { + let resolvedPath = ""; + let resolvedAbsolute = false; + for(let i = pathSegments.length - 1; i >= -1 && !resolvedAbsolute; i--){ + let path; + if (i >= 0) path = pathSegments[i]; + else { + // deno-lint-ignore no-explicit-any + const { Deno } = globalThis; + if (typeof Deno?.cwd !== "function") { + throw new TypeError("Resolved a relative path without a CWD."); + } + path = Deno.cwd(); + } + assertPath(path); + // Skip empty entries + if (path.length === 0) { + continue; + } + resolvedPath = `${path}/${resolvedPath}`; + resolvedAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH; + } + // At this point the path should be resolved to a full absolute path, but + // handle relative paths to be safe (might happen when process.cwd() fails) + // Normalize the path + resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute, "/", isPosixPathSeparator); + if (resolvedAbsolute) { + if (resolvedPath.length > 0) return `/${resolvedPath}`; + else return "/"; + } else if (resolvedPath.length > 0) return resolvedPath; + else return "."; +} +/** + * Normalize the `path`, resolving `'..'` and `'.'` segments. + * @param path to be normalized + */ export function normalize(path) { + assertPath(path); + if (path.length === 0) return "."; + const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH; + const trailingSeparator = path.charCodeAt(path.length - 1) === CHAR_FORWARD_SLASH; + // 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; +} +/** + * Verifies whether provided path is absolute + * @param path to be verified as absolute + */ export function isAbsolute(path) { + assertPath(path); + return path.length > 0 && path.charCodeAt(0) === CHAR_FORWARD_SLASH; +} +/** + * Join all given a sequence of `paths`,then normalizes the resulting path. + * @param paths to be joined and normalized + */ export function join(...paths) { + if (paths.length === 0) return "."; + let joined; + for(let i = 0, len = paths.length; i < len; ++i){ + const path = paths[i]; + assertPath(path); + if (path.length > 0) { + if (!joined) joined = path; + else joined += `/${path}`; + } + } + if (!joined) return "."; + return normalize(joined); +} +/** + * Return the relative path from `from` to `to` based on current working directory. + * @param from path in current working directory + * @param to path in current working directory + */ export function relative(from, to) { + assertPath(from); + assertPath(to); + if (from === to) return ""; + from = resolve(from); + to = resolve(to); + if (from === to) return ""; + // Trim any leading backslashes + let fromStart = 1; + const fromEnd = from.length; + for(; fromStart < fromEnd; ++fromStart){ + if (from.charCodeAt(fromStart) !== CHAR_FORWARD_SLASH) break; + } + const fromLen = fromEnd - fromStart; + // Trim any leading backslashes + let toStart = 1; + const toEnd = to.length; + for(; toStart < toEnd; ++toStart){ + if (to.charCodeAt(toStart) !== CHAR_FORWARD_SLASH) break; + } + const toLen = toEnd - toStart; + // Compare paths to find the longest common path from root + const length = fromLen < toLen ? fromLen : toLen; + let lastCommonSep = -1; + let i = 0; + for(; i <= length; ++i){ + if (i === length) { + if (toLen > length) { + if (to.charCodeAt(toStart + i) === CHAR_FORWARD_SLASH) { + // We get here if `from` is the exact base path for `to`. + // For example: from='/foo/bar'; to='/foo/bar/baz' + return to.slice(toStart + i + 1); + } else if (i === 0) { + // We get here if `from` is the root + // For example: from='/'; to='/foo' + return to.slice(toStart + i); + } + } else if (fromLen > length) { + if (from.charCodeAt(fromStart + i) === CHAR_FORWARD_SLASH) { + // We get here if `to` is the exact base path for `from`. + // For example: from='/foo/bar/baz'; to='/foo/bar' + lastCommonSep = i; + } else if (i === 0) { + // We get here if `to` is the root. + // For example: from='/foo'; to='/' + lastCommonSep = 0; + } + } + break; + } + const fromCode = from.charCodeAt(fromStart + i); + const toCode = to.charCodeAt(toStart + i); + if (fromCode !== toCode) break; + else if (fromCode === CHAR_FORWARD_SLASH) lastCommonSep = i; + } + let out = ""; + // Generate the relative path based on the path difference between `to` + // and `from` + for(i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i){ + if (i === fromEnd || from.charCodeAt(i) === CHAR_FORWARD_SLASH) { + if (out.length === 0) out += ".."; + else out += "/.."; + } + } + // Lastly, append the rest of the destination (`to`) path that comes after + // the common path parts + if (out.length > 0) return out + to.slice(toStart + lastCommonSep); + else { + toStart += lastCommonSep; + if (to.charCodeAt(toStart) === CHAR_FORWARD_SLASH) ++toStart; + return to.slice(toStart); + } +} +/** + * Resolves path to a namespace path + * @param path to resolve to namespace + */ export function toNamespacedPath(path) { + // Non-op on posix systems + return path; +} +/** + * Return the directory name of a `path`. + * @param path to determine name for + */ export function dirname(path) { + assertPath(path); + if (path.length === 0) return "."; + const hasRoot = path.charCodeAt(0) === CHAR_FORWARD_SLASH; + let end = -1; + let matchedSlash = true; + for(let i = path.length - 1; i >= 1; --i){ + if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) { + if (!matchedSlash) { + end = i; + break; + } + } else { + // We saw the first non-path separator + matchedSlash = false; + } + } + if (end === -1) return hasRoot ? "/" : "."; + if (hasRoot && end === 1) return "//"; + return path.slice(0, end); +} +/** + * Return the last portion of a `path`. Trailing directory separators are ignored. + * @param path to process + * @param ext of path directory + */ export function basename(path, ext = "") { + if (ext !== undefined && typeof ext !== "string") { + throw new TypeError('"ext" argument must be a string'); + } + assertPath(path); + let start = 0; + let end = -1; + let matchedSlash = true; + let i; + if (ext !== undefined && ext.length > 0 && ext.length <= path.length) { + if (ext.length === path.length && ext === path) return ""; + let extIdx = ext.length - 1; + let firstNonSlashEnd = -1; + for(i = path.length - 1; i >= 0; --i){ + const code = path.charCodeAt(i); + if (code === CHAR_FORWARD_SLASH) { + // If we reached a path separator that was not part of a set of path + // separators at the end of the string, stop now + if (!matchedSlash) { + start = i + 1; + break; + } + } else { + if (firstNonSlashEnd === -1) { + // We saw the first non-path separator, remember this index in case + // we need it if the extension ends up not matching + matchedSlash = false; + firstNonSlashEnd = i + 1; + } + if (extIdx >= 0) { + // Try to match the explicit extension + if (code === ext.charCodeAt(extIdx)) { + if (--extIdx === -1) { + // We matched the extension, so mark this as the end of our path + // component + end = i; + } + } else { + // Extension does not match, so our result is the entire path + // component + extIdx = -1; + end = firstNonSlashEnd; + } + } + } + } + if (start === end) end = firstNonSlashEnd; + else if (end === -1) end = path.length; + return path.slice(start, end); + } else { + for(i = path.length - 1; i >= 0; --i){ + if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) { + // If we reached a path separator that was not part of a set of path + // separators at the end of the string, stop now + if (!matchedSlash) { + start = i + 1; + break; + } + } else if (end === -1) { + // We saw the first non-path separator, mark this as the end of our + // path component + matchedSlash = false; + end = i + 1; + } + } + if (end === -1) return ""; + return path.slice(start, end); + } +} +/** + * Return the extension of the `path` with leading period. + * @param path with extension + * @returns extension (ex. for `file.ts` returns `.ts`) + */ export function extname(path) { + assertPath(path); + let startDot = -1; + let startPart = 0; + let end = -1; + let matchedSlash = true; + // Track the state of characters (if any) we see before our first dot and + // after any path separator we find + let preDotState = 0; + for(let i = path.length - 1; i >= 0; --i){ + const code = path.charCodeAt(i); + if (code === CHAR_FORWARD_SLASH) { + // If we reached a path separator that was not part of a set of path + // separators at the end of the string, stop now + if (!matchedSlash) { + startPart = i + 1; + break; + } + continue; + } + if (end === -1) { + // We saw the first non-path separator, mark this as the end of our + // extension + matchedSlash = false; + end = i + 1; + } + if (code === CHAR_DOT) { + // If this is our first dot, mark it as the start of our extension + if (startDot === -1) startDot = i; + else if (preDotState !== 1) preDotState = 1; + } else if (startDot !== -1) { + // We saw a non-dot and non-path separator before our dot, so we should + // have a good chance at having a non-empty extension + preDotState = -1; + } + } + if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot + preDotState === 0 || // The (right-most) trimmed path component is exactly '..' + preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) { + return ""; + } + return path.slice(startDot, end); +} +/** + * Generate a path from `FormatInputPathObject` object. + * @param pathObject with path + */ export function format(pathObject) { + if (pathObject === null || typeof pathObject !== "object") { + throw new TypeError(`The "pathObject" argument must be of type Object. Received type ${typeof pathObject}`); + } + return _format("/", pathObject); +} +/** + * Return a `ParsedPath` object of the `path`. + * @param path to process + */ export function parse(path) { + assertPath(path); + const ret = { + root: "", + dir: "", + base: "", + ext: "", + name: "" + }; + if (path.length === 0) return ret; + const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH; + let start; + if (isAbsolute) { + ret.root = "/"; + start = 1; + } else { + start = 0; + } + let startDot = -1; + let startPart = 0; + let end = -1; + let matchedSlash = true; + let i = path.length - 1; + // Track the state of characters (if any) we see before our first dot and + // after any path separator we find + let preDotState = 0; + // Get non-dir info + for(; i >= start; --i){ + const code = path.charCodeAt(i); + if (code === CHAR_FORWARD_SLASH) { + // If we reached a path separator that was not part of a set of path + // separators at the end of the string, stop now + if (!matchedSlash) { + startPart = i + 1; + break; + } + continue; + } + if (end === -1) { + // We saw the first non-path separator, mark this as the end of our + // extension + matchedSlash = false; + end = i + 1; + } + if (code === CHAR_DOT) { + // If this is our first dot, mark it as the start of our extension + if (startDot === -1) startDot = i; + else if (preDotState !== 1) preDotState = 1; + } else if (startDot !== -1) { + // We saw a non-dot and non-path separator before our dot, so we should + // have a good chance at having a non-empty extension + preDotState = -1; + } + } + if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot + preDotState === 0 || // The (right-most) trimmed path component is exactly '..' + preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) { + if (end !== -1) { + if (startPart === 0 && isAbsolute) { + ret.base = ret.name = path.slice(1, end); + } else { + ret.base = ret.name = path.slice(startPart, end); + } + } + } else { + if (startPart === 0 && isAbsolute) { + ret.name = path.slice(1, startDot); + ret.base = path.slice(1, end); + } else { + ret.name = path.slice(startPart, startDot); + ret.base = path.slice(startPart, end); + } + ret.ext = path.slice(startDot, end); + } + if (startPart > 0) ret.dir = path.slice(0, startPart - 1); + else if (isAbsolute) ret.dir = "/"; + return ret; +} +/** + * Converts a file URL to a path string. + * + * ```ts + * import { fromFileUrl } from "./posix.ts"; + * fromFileUrl("file:///home/foo"); // "/home/foo" + * ``` + * @param url of a file URL + */ export function fromFileUrl(url) { + url = url instanceof URL ? url : new URL(url); + if (url.protocol != "file:") { + throw new TypeError("Must be a file URL."); + } + return decodeURIComponent(url.pathname.replace(/%(?![0-9A-Fa-f]{2})/g, "%25")); +} +/** + * Converts a path string to a file URL. + * + * ```ts + * import { toFileUrl } from "./posix.ts"; + * toFileUrl("/home/foo"); // new URL("file:///home/foo") + * ``` + * @param path to convert to file URL + */ export function toFileUrl(path) { + if (!isAbsolute(path)) { + throw new TypeError("Must be an absolute path."); + } + const url = new URL("file:///"); + url.pathname = encodeWhitespace(path.replace(/%/g, "%25").replace(/\\/g, "%5C")); + return url; +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["https://deno.land/std@0.140.0/path/posix.ts"],"sourcesContent":["// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.\n// Copyright the Browserify authors. MIT License.\n// Ported from https://github.com/browserify/path-browserify/\n// This module is browser compatible.\n\nimport type { FormatInputPathObject, ParsedPath } from \"./_interface.ts\";\nimport { CHAR_DOT, CHAR_FORWARD_SLASH } from \"./_constants.ts\";\n\nimport {\n  _format,\n  assertPath,\n  encodeWhitespace,\n  isPosixPathSeparator,\n  normalizeString,\n} from \"./_util.ts\";\n\nexport const sep = \"/\";\nexport const delimiter = \":\";\n\n// path.resolve([from ...], to)\n/**\n * Resolves `pathSegments` into an absolute path.\n * @param pathSegments an array of path segments\n */\nexport function resolve(...pathSegments: string[]): string {\n  let resolvedPath = \"\";\n  let resolvedAbsolute = false;\n\n  for (let i = pathSegments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n    let path: string;\n\n    if (i >= 0) path = pathSegments[i];\n    else {\n      // deno-lint-ignore no-explicit-any\n      const { Deno } = globalThis as any;\n      if (typeof Deno?.cwd !== \"function\") {\n        throw new TypeError(\"Resolved a relative path without a CWD.\");\n      }\n      path = Deno.cwd();\n    }\n\n    assertPath(path);\n\n    // Skip empty entries\n    if (path.length === 0) {\n      continue;\n    }\n\n    resolvedPath = `${path}/${resolvedPath}`;\n    resolvedAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;\n  }\n\n  // At this point the path should be resolved to a full absolute path, but\n  // handle relative paths to be safe (might happen when process.cwd() fails)\n\n  // Normalize the path\n  resolvedPath = normalizeString(\n    resolvedPath,\n    !resolvedAbsolute,\n    \"/\",\n    isPosixPathSeparator,\n  );\n\n  if (resolvedAbsolute) {\n    if (resolvedPath.length > 0) return `/${resolvedPath}`;\n    else return \"/\";\n  } else if (resolvedPath.length > 0) return resolvedPath;\n  else return \".\";\n}\n\n/**\n * Normalize the `path`, resolving `'..'` and `'.'` segments.\n * @param path to be normalized\n */\nexport function normalize(path: string): string {\n  assertPath(path);\n\n  if (path.length === 0) return \".\";\n\n  const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;\n  const trailingSeparator =\n    path.charCodeAt(path.length - 1) === CHAR_FORWARD_SLASH;\n\n  // Normalize the path\n  path = normalizeString(path, !isAbsolute, \"/\", isPosixPathSeparator);\n\n  if (path.length === 0 && !isAbsolute) path = \".\";\n  if (path.length > 0 && trailingSeparator) path += \"/\";\n\n  if (isAbsolute) return `/${path}`;\n  return path;\n}\n\n/**\n * Verifies whether provided path is absolute\n * @param path to be verified as absolute\n */\nexport function isAbsolute(path: string): boolean {\n  assertPath(path);\n  return path.length > 0 && path.charCodeAt(0) === CHAR_FORWARD_SLASH;\n}\n\n/**\n * Join all given a sequence of `paths`,then normalizes the resulting path.\n * @param paths to be joined and normalized\n */\nexport function join(...paths: string[]): string {\n  if (paths.length === 0) return \".\";\n  let joined: string | undefined;\n  for (let i = 0, len = paths.length; i < len; ++i) {\n    const path = paths[i];\n    assertPath(path);\n    if (path.length > 0) {\n      if (!joined) joined = path;\n      else joined += `/${path}`;\n    }\n  }\n  if (!joined) return \".\";\n  return normalize(joined);\n}\n\n/**\n * Return the relative path from `from` to `to` based on current working directory.\n * @param from path in current working directory\n * @param to path in current working directory\n */\nexport function relative(from: string, to: string): string {\n  assertPath(from);\n  assertPath(to);\n\n  if (from === to) return \"\";\n\n  from = resolve(from);\n  to = resolve(to);\n\n  if (from === to) return \"\";\n\n  // Trim any leading backslashes\n  let fromStart = 1;\n  const fromEnd = from.length;\n  for (; fromStart < fromEnd; ++fromStart) {\n    if (from.charCodeAt(fromStart) !== CHAR_FORWARD_SLASH) break;\n  }\n  const fromLen = fromEnd - fromStart;\n\n  // Trim any leading backslashes\n  let toStart = 1;\n  const toEnd = to.length;\n  for (; toStart < toEnd; ++toStart) {\n    if (to.charCodeAt(toStart) !== CHAR_FORWARD_SLASH) break;\n  }\n  const toLen = toEnd - toStart;\n\n  // Compare paths to find the longest common path from root\n  const length = fromLen < toLen ? fromLen : toLen;\n  let lastCommonSep = -1;\n  let i = 0;\n  for (; i <= length; ++i) {\n    if (i === length) {\n      if (toLen > length) {\n        if (to.charCodeAt(toStart + i) === CHAR_FORWARD_SLASH) {\n          // We get here if `from` is the exact base path for `to`.\n          // For example: from='/foo/bar'; to='/foo/bar/baz'\n          return to.slice(toStart + i + 1);\n        } else if (i === 0) {\n          // We get here if `from` is the root\n          // For example: from='/'; to='/foo'\n          return to.slice(toStart + i);\n        }\n      } else if (fromLen > length) {\n        if (from.charCodeAt(fromStart + i) === CHAR_FORWARD_SLASH) {\n          // We get here if `to` is the exact base path for `from`.\n          // For example: from='/foo/bar/baz'; to='/foo/bar'\n          lastCommonSep = i;\n        } else if (i === 0) {\n          // We get here if `to` is the root.\n          // For example: from='/foo'; to='/'\n          lastCommonSep = 0;\n        }\n      }\n      break;\n    }\n    const fromCode = from.charCodeAt(fromStart + i);\n    const toCode = to.charCodeAt(toStart + i);\n    if (fromCode !== toCode) break;\n    else if (fromCode === CHAR_FORWARD_SLASH) lastCommonSep = i;\n  }\n\n  let out = \"\";\n  // Generate the relative path based on the path difference between `to`\n  // and `from`\n  for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {\n    if (i === fromEnd || from.charCodeAt(i) === CHAR_FORWARD_SLASH) {\n      if (out.length === 0) out += \"..\";\n      else out += \"/..\";\n    }\n  }\n\n  // Lastly, append the rest of the destination (`to`) path that comes after\n  // the common path parts\n  if (out.length > 0) return out + to.slice(toStart + lastCommonSep);\n  else {\n    toStart += lastCommonSep;\n    if (to.charCodeAt(toStart) === CHAR_FORWARD_SLASH) ++toStart;\n    return to.slice(toStart);\n  }\n}\n\n/**\n * Resolves path to a namespace path\n * @param path to resolve to namespace\n */\nexport function toNamespacedPath(path: string): string {\n  // Non-op on posix systems\n  return path;\n}\n\n/**\n * Return the directory name of a `path`.\n * @param path to determine name for\n */\nexport function dirname(path: string): string {\n  assertPath(path);\n  if (path.length === 0) return \".\";\n  const hasRoot = path.charCodeAt(0) === CHAR_FORWARD_SLASH;\n  let end = -1;\n  let matchedSlash = true;\n  for (let i = path.length - 1; i >= 1; --i) {\n    if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {\n      if (!matchedSlash) {\n        end = i;\n        break;\n      }\n    } else {\n      // We saw the first non-path separator\n      matchedSlash = false;\n    }\n  }\n\n  if (end === -1) return hasRoot ? \"/\" : \".\";\n  if (hasRoot && end === 1) return \"//\";\n  return path.slice(0, end);\n}\n\n/**\n * Return the last portion of a `path`. Trailing directory separators are ignored.\n * @param path to process\n * @param ext of path directory\n */\nexport function basename(path: string, ext = \"\"): string {\n  if (ext !== undefined && typeof ext !== \"string\") {\n    throw new TypeError('\"ext\" argument must be a string');\n  }\n  assertPath(path);\n\n  let start = 0;\n  let end = -1;\n  let matchedSlash = true;\n  let i: number;\n\n  if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {\n    if (ext.length === path.length && ext === path) return \"\";\n    let extIdx = ext.length - 1;\n    let firstNonSlashEnd = -1;\n    for (i = path.length - 1; i >= 0; --i) {\n      const code = path.charCodeAt(i);\n      if (code === CHAR_FORWARD_SLASH) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          start = i + 1;\n          break;\n        }\n      } else {\n        if (firstNonSlashEnd === -1) {\n          // We saw the first non-path separator, remember this index in case\n          // we need it if the extension ends up not matching\n          matchedSlash = false;\n          firstNonSlashEnd = i + 1;\n        }\n        if (extIdx >= 0) {\n          // Try to match the explicit extension\n          if (code === ext.charCodeAt(extIdx)) {\n            if (--extIdx === -1) {\n              // We matched the extension, so mark this as the end of our path\n              // component\n              end = i;\n            }\n          } else {\n            // Extension does not match, so our result is the entire path\n            // component\n            extIdx = -1;\n            end = firstNonSlashEnd;\n          }\n        }\n      }\n    }\n\n    if (start === end) end = firstNonSlashEnd;\n    else if (end === -1) end = path.length;\n    return path.slice(start, end);\n  } else {\n    for (i = path.length - 1; i >= 0; --i) {\n      if (path.charCodeAt(i) === CHAR_FORWARD_SLASH) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          start = i + 1;\n          break;\n        }\n      } else if (end === -1) {\n        // We saw the first non-path separator, mark this as the end of our\n        // path component\n        matchedSlash = false;\n        end = i + 1;\n      }\n    }\n\n    if (end === -1) return \"\";\n    return path.slice(start, end);\n  }\n}\n\n/**\n * Return the extension of the `path` with leading period.\n * @param path with extension\n * @returns extension (ex. for `file.ts` returns `.ts`)\n */\nexport function extname(path: string): string {\n  assertPath(path);\n  let startDot = -1;\n  let startPart = 0;\n  let end = -1;\n  let matchedSlash = true;\n  // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find\n  let preDotState = 0;\n  for (let i = path.length - 1; i >= 0; --i) {\n    const code = path.charCodeAt(i);\n    if (code === CHAR_FORWARD_SLASH) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now\n      if (!matchedSlash) {\n        startPart = i + 1;\n        break;\n      }\n      continue;\n    }\n    if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension\n      matchedSlash = false;\n      end = i + 1;\n    }\n    if (code === CHAR_DOT) {\n      // If this is our first dot, mark it as the start of our extension\n      if (startDot === -1) startDot = i;\n      else if (preDotState !== 1) preDotState = 1;\n    } else if (startDot !== -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension\n      preDotState = -1;\n    }\n  }\n\n  if (\n    startDot === -1 ||\n    end === -1 ||\n    // We saw a non-dot character immediately before the dot\n    preDotState === 0 ||\n    // The (right-most) trimmed path component is exactly '..'\n    (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)\n  ) {\n    return \"\";\n  }\n  return path.slice(startDot, end);\n}\n\n/**\n * Generate a path from `FormatInputPathObject` object.\n * @param pathObject with path\n */\nexport function format(pathObject: FormatInputPathObject): string {\n  if (pathObject === null || typeof pathObject !== \"object\") {\n    throw new TypeError(\n      `The \"pathObject\" argument must be of type Object. Received type ${typeof pathObject}`,\n    );\n  }\n  return _format(\"/\", pathObject);\n}\n\n/**\n * Return a `ParsedPath` object of the `path`.\n * @param path to process\n */\nexport function parse(path: string): ParsedPath {\n  assertPath(path);\n\n  const ret: ParsedPath = { root: \"\", dir: \"\", base: \"\", ext: \"\", name: \"\" };\n  if (path.length === 0) return ret;\n  const isAbsolute = path.charCodeAt(0) === CHAR_FORWARD_SLASH;\n  let start: number;\n  if (isAbsolute) {\n    ret.root = \"/\";\n    start = 1;\n  } else {\n    start = 0;\n  }\n  let startDot = -1;\n  let startPart = 0;\n  let end = -1;\n  let matchedSlash = true;\n  let i = path.length - 1;\n\n  // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find\n  let preDotState = 0;\n\n  // Get non-dir info\n  for (; i >= start; --i) {\n    const code = path.charCodeAt(i);\n    if (code === CHAR_FORWARD_SLASH) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now\n      if (!matchedSlash) {\n        startPart = i + 1;\n        break;\n      }\n      continue;\n    }\n    if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension\n      matchedSlash = false;\n      end = i + 1;\n    }\n    if (code === CHAR_DOT) {\n      // If this is our first dot, mark it as the start of our extension\n      if (startDot === -1) startDot = i;\n      else if (preDotState !== 1) preDotState = 1;\n    } else if (startDot !== -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension\n      preDotState = -1;\n    }\n  }\n\n  if (\n    startDot === -1 ||\n    end === -1 ||\n    // We saw a non-dot character immediately before the dot\n    preDotState === 0 ||\n    // The (right-most) trimmed path component is exactly '..'\n    (preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)\n  ) {\n    if (end !== -1) {\n      if (startPart === 0 && isAbsolute) {\n        ret.base = ret.name = path.slice(1, end);\n      } else {\n        ret.base = ret.name = path.slice(startPart, end);\n      }\n    }\n  } else {\n    if (startPart === 0 && isAbsolute) {\n      ret.name = path.slice(1, startDot);\n      ret.base = path.slice(1, end);\n    } else {\n      ret.name = path.slice(startPart, startDot);\n      ret.base = path.slice(startPart, end);\n    }\n    ret.ext = path.slice(startDot, end);\n  }\n\n  if (startPart > 0) ret.dir = path.slice(0, startPart - 1);\n  else if (isAbsolute) ret.dir = \"/\";\n\n  return ret;\n}\n\n/**\n * Converts a file URL to a path string.\n *\n * ```ts\n *      import { fromFileUrl } from \"./posix.ts\";\n *      fromFileUrl(\"file:///home/foo\"); // \"/home/foo\"\n * ```\n * @param url of a file URL\n */\nexport function fromFileUrl(url: string | URL): string {\n  url = url instanceof URL ? url : new URL(url);\n  if (url.protocol != \"file:\") {\n    throw new TypeError(\"Must be a file URL.\");\n  }\n  return decodeURIComponent(\n    url.pathname.replace(/%(?![0-9A-Fa-f]{2})/g, \"%25\"),\n  );\n}\n\n/**\n * Converts a path string to a file URL.\n *\n * ```ts\n *      import { toFileUrl } from \"./posix.ts\";\n *      toFileUrl(\"/home/foo\"); // new URL(\"file:///home/foo\")\n * ```\n * @param path to convert to file URL\n */\nexport function toFileUrl(path: string): URL {\n  if (!isAbsolute(path)) {\n    throw new TypeError(\"Must be an absolute path.\");\n  }\n  const url = new URL(\"file:///\");\n  url.pathname = encodeWhitespace(\n    path.replace(/%/g, \"%25\").replace(/\\\\/g, \"%5C\"),\n  );\n  return url;\n}\n"],"names":[],"mappings":"AAAA,0EAA0E;AAC1E,iDAAiD;AACjD,6DAA6D;AAC7D,qCAAqC;AAGrC,SAAS,QAAQ,EAAE,kBAAkB,QAAQ,kBAAkB;AAE/D,SACE,OAAO,EACP,UAAU,EACV,gBAAgB,EAChB,oBAAoB,EACpB,eAAe,QACV,aAAa;AAEpB,OAAO,MAAM,MAAM,IAAI;AACvB,OAAO,MAAM,YAAY,IAAI;AAE7B,+BAA+B;AAC/B;;;CAGC,GACD,OAAO,SAAS,QAAQ,GAAG,YAAsB,EAAU;IACzD,IAAI,eAAe;IACnB,IAAI,mBAAmB,KAAK;IAE5B,IAAK,IAAI,IAAI,aAAa,MAAM,GAAG,GAAG,KAAK,CAAC,KAAK,CAAC,kBAAkB,IAAK;QACvE,IAAI;QAEJ,IAAI,KAAK,GAAG,OAAO,YAAY,CAAC,EAAE;aAC7B;YACH,mCAAmC;YACnC,MAAM,EAAE,KAAI,EAAE,GAAG;YACjB,IAAI,OAAO,MAAM,QAAQ,YAAY;gBACnC,MAAM,IAAI,UAAU,2CAA2C;YACjE,CAAC;YACD,OAAO,KAAK,GAAG;QACjB,CAAC;QAED,WAAW;QAEX,qBAAqB;QACrB,IAAI,KAAK,MAAM,KAAK,GAAG;YACrB,QAAS;QACX,CAAC;QAED,eAAe,CAAC,EAAE,KAAK,CAAC,EAAE,aAAa,CAAC;QACxC,mBAAmB,KAAK,UAAU,CAAC,OAAO;IAC5C;IAEA,yEAAyE;IACzE,2EAA2E;IAE3E,qBAAqB;IACrB,eAAe,gBACb,cACA,CAAC,kBACD,KACA;IAGF,IAAI,kBAAkB;QACpB,IAAI,aAAa,MAAM,GAAG,GAAG,OAAO,CAAC,CAAC,EAAE,aAAa,CAAC;aACjD,OAAO;IACd,OAAO,IAAI,aAAa,MAAM,GAAG,GAAG,OAAO;SACtC,OAAO;AACd,CAAC;AAED;;;CAGC,GACD,OAAO,SAAS,UAAU,IAAY,EAAU;IAC9C,WAAW;IAEX,IAAI,KAAK,MAAM,KAAK,GAAG,OAAO;IAE9B,MAAM,aAAa,KAAK,UAAU,CAAC,OAAO;IAC1C,MAAM,oBACJ,KAAK,UAAU,CAAC,KAAK,MAAM,GAAG,OAAO;IAEvC,qBAAqB;IACrB,OAAO,gBAAgB,MAAM,CAAC,YAAY,KAAK;IAE/C,IAAI,KAAK,MAAM,KAAK,KAAK,CAAC,YAAY,OAAO;IAC7C,IAAI,KAAK,MAAM,GAAG,KAAK,mBAAmB,QAAQ;IAElD,IAAI,YAAY,OAAO,CAAC,CAAC,EAAE,KAAK,CAAC;IACjC,OAAO;AACT,CAAC;AAED;;;CAGC,GACD,OAAO,SAAS,WAAW,IAAY,EAAW;IAChD,WAAW;IACX,OAAO,KAAK,MAAM,GAAG,KAAK,KAAK,UAAU,CAAC,OAAO;AACnD,CAAC;AAED;;;CAGC,GACD,OAAO,SAAS,KAAK,GAAG,KAAe,EAAU;IAC/C,IAAI,MAAM,MAAM,KAAK,GAAG,OAAO;IAC/B,IAAI;IACJ,IAAK,IAAI,IAAI,GAAG,MAAM,MAAM,MAAM,EAAE,IAAI,KAAK,EAAE,EAAG;QAChD,MAAM,OAAO,KAAK,CAAC,EAAE;QACrB,WAAW;QACX,IAAI,KAAK,MAAM,GAAG,GAAG;YACnB,IAAI,CAAC,QAAQ,SAAS;iBACjB,UAAU,CAAC,CAAC,EAAE,KAAK,CAAC;QAC3B,CAAC;IACH;IACA,IAAI,CAAC,QAAQ,OAAO;IACpB,OAAO,UAAU;AACnB,CAAC;AAED;;;;CAIC,GACD,OAAO,SAAS,SAAS,IAAY,EAAE,EAAU,EAAU;IACzD,WAAW;IACX,WAAW;IAEX,IAAI,SAAS,IAAI,OAAO;IAExB,OAAO,QAAQ;IACf,KAAK,QAAQ;IAEb,IAAI,SAAS,IAAI,OAAO;IAExB,+BAA+B;IAC/B,IAAI,YAAY;IAChB,MAAM,UAAU,KAAK,MAAM;IAC3B,MAAO,YAAY,SAAS,EAAE,UAAW;QACvC,IAAI,KAAK,UAAU,CAAC,eAAe,oBAAoB,KAAM;IAC/D;IACA,MAAM,UAAU,UAAU;IAE1B,+BAA+B;IAC/B,IAAI,UAAU;IACd,MAAM,QAAQ,GAAG,MAAM;IACvB,MAAO,UAAU,OAAO,EAAE,QAAS;QACjC,IAAI,GAAG,UAAU,CAAC,aAAa,oBAAoB,KAAM;IAC3D;IACA,MAAM,QAAQ,QAAQ;IAEtB,0DAA0D;IAC1D,MAAM,SAAS,UAAU,QAAQ,UAAU,KAAK;IAChD,IAAI,gBAAgB,CAAC;IACrB,IAAI,IAAI;IACR,MAAO,KAAK,QAAQ,EAAE,EAAG;QACvB,IAAI,MAAM,QAAQ;YAChB,IAAI,QAAQ,QAAQ;gBAClB,IAAI,GAAG,UAAU,CAAC,UAAU,OAAO,oBAAoB;oBACrD,yDAAyD;oBACzD,kDAAkD;oBAClD,OAAO,GAAG,KAAK,CAAC,UAAU,IAAI;gBAChC,OAAO,IAAI,MAAM,GAAG;oBAClB,oCAAoC;oBACpC,mCAAmC;oBACnC,OAAO,GAAG,KAAK,CAAC,UAAU;gBAC5B,CAAC;YACH,OAAO,IAAI,UAAU,QAAQ;gBAC3B,IAAI,KAAK,UAAU,CAAC,YAAY,OAAO,oBAAoB;oBACzD,yDAAyD;oBACzD,kDAAkD;oBAClD,gBAAgB;gBAClB,OAAO,IAAI,MAAM,GAAG;oBAClB,mCAAmC;oBACnC,mCAAmC;oBACnC,gBAAgB;gBAClB,CAAC;YACH,CAAC;YACD,KAAM;QACR,CAAC;QACD,MAAM,WAAW,KAAK,UAAU,CAAC,YAAY;QAC7C,MAAM,SAAS,GAAG,UAAU,CAAC,UAAU;QACvC,IAAI,aAAa,QAAQ,KAAM;aAC1B,IAAI,aAAa,oBAAoB,gBAAgB;IAC5D;IAEA,IAAI,MAAM;IACV,uEAAuE;IACvE,aAAa;IACb,IAAK,IAAI,YAAY,gBAAgB,GAAG,KAAK,SAAS,EAAE,EAAG;QACzD,IAAI,MAAM,WAAW,KAAK,UAAU,CAAC,OAAO,oBAAoB;YAC9D,IAAI,IAAI,MAAM,KAAK,GAAG,OAAO;iBACxB,OAAO;QACd,CAAC;IACH;IAEA,0EAA0E;IAC1E,wBAAwB;IACxB,IAAI,IAAI,MAAM,GAAG,GAAG,OAAO,MAAM,GAAG,KAAK,CAAC,UAAU;SAC/C;QACH,WAAW;QACX,IAAI,GAAG,UAAU,CAAC,aAAa,oBAAoB,EAAE;QACrD,OAAO,GAAG,KAAK,CAAC;IAClB,CAAC;AACH,CAAC;AAED;;;CAGC,GACD,OAAO,SAAS,iBAAiB,IAAY,EAAU;IACrD,0BAA0B;IAC1B,OAAO;AACT,CAAC;AAED;;;CAGC,GACD,OAAO,SAAS,QAAQ,IAAY,EAAU;IAC5C,WAAW;IACX,IAAI,KAAK,MAAM,KAAK,GAAG,OAAO;IAC9B,MAAM,UAAU,KAAK,UAAU,CAAC,OAAO;IACvC,IAAI,MAAM,CAAC;IACX,IAAI,eAAe,IAAI;IACvB,IAAK,IAAI,IAAI,KAAK,MAAM,GAAG,GAAG,KAAK,GAAG,EAAE,EAAG;QACzC,IAAI,KAAK,UAAU,CAAC,OAAO,oBAAoB;YAC7C,IAAI,CAAC,cAAc;gBACjB,MAAM;gBACN,KAAM;YACR,CAAC;QACH,OAAO;YACL,sCAAsC;YACtC,eAAe,KAAK;QACtB,CAAC;IACH;IAEA,IAAI,QAAQ,CAAC,GAAG,OAAO,UAAU,MAAM,GAAG;IAC1C,IAAI,WAAW,QAAQ,GAAG,OAAO;IACjC,OAAO,KAAK,KAAK,CAAC,GAAG;AACvB,CAAC;AAED;;;;CAIC,GACD,OAAO,SAAS,SAAS,IAAY,EAAE,MAAM,EAAE,EAAU;IACvD,IAAI,QAAQ,aAAa,OAAO,QAAQ,UAAU;QAChD,MAAM,IAAI,UAAU,mCAAmC;IACzD,CAAC;IACD,WAAW;IAEX,IAAI,QAAQ;IACZ,IAAI,MAAM,CAAC;IACX,IAAI,eAAe,IAAI;IACvB,IAAI;IAEJ,IAAI,QAAQ,aAAa,IAAI,MAAM,GAAG,KAAK,IAAI,MAAM,IAAI,KAAK,MAAM,EAAE;QACpE,IAAI,IAAI,MAAM,KAAK,KAAK,MAAM,IAAI,QAAQ,MAAM,OAAO;QACvD,IAAI,SAAS,IAAI,MAAM,GAAG;QAC1B,IAAI,mBAAmB,CAAC;QACxB,IAAK,IAAI,KAAK,MAAM,GAAG,GAAG,KAAK,GAAG,EAAE,EAAG;YACrC,MAAM,OAAO,KAAK,UAAU,CAAC;YAC7B,IAAI,SAAS,oBAAoB;gBAC/B,oEAAoE;gBACpE,gDAAgD;gBAChD,IAAI,CAAC,cAAc;oBACjB,QAAQ,IAAI;oBACZ,KAAM;gBACR,CAAC;YACH,OAAO;gBACL,IAAI,qBAAqB,CAAC,GAAG;oBAC3B,mEAAmE;oBACnE,mDAAmD;oBACnD,eAAe,KAAK;oBACpB,mBAAmB,IAAI;gBACzB,CAAC;gBACD,IAAI,UAAU,GAAG;oBACf,sCAAsC;oBACtC,IAAI,SAAS,IAAI,UAAU,CAAC,SAAS;wBACnC,IAAI,EAAE,WAAW,CAAC,GAAG;4BACnB,gEAAgE;4BAChE,YAAY;4BACZ,MAAM;wBACR,CAAC;oBACH,OAAO;wBACL,6DAA6D;wBAC7D,YAAY;wBACZ,SAAS,CAAC;wBACV,MAAM;oBACR,CAAC;gBACH,CAAC;YACH,CAAC;QACH;QAEA,IAAI,UAAU,KAAK,MAAM;aACpB,IAAI,QAAQ,CAAC,GAAG,MAAM,KAAK,MAAM;QACtC,OAAO,KAAK,KAAK,CAAC,OAAO;IAC3B,OAAO;QACL,IAAK,IAAI,KAAK,MAAM,GAAG,GAAG,KAAK,GAAG,EAAE,EAAG;YACrC,IAAI,KAAK,UAAU,CAAC,OAAO,oBAAoB;gBAC7C,oEAAoE;gBACpE,gDAAgD;gBAChD,IAAI,CAAC,cAAc;oBACjB,QAAQ,IAAI;oBACZ,KAAM;gBACR,CAAC;YACH,OAAO,IAAI,QAAQ,CAAC,GAAG;gBACrB,mEAAmE;gBACnE,iBAAiB;gBACjB,eAAe,KAAK;gBACpB,MAAM,IAAI;YACZ,CAAC;QACH;QAEA,IAAI,QAAQ,CAAC,GAAG,OAAO;QACvB,OAAO,KAAK,KAAK,CAAC,OAAO;IAC3B,CAAC;AACH,CAAC;AAED;;;;CAIC,GACD,OAAO,SAAS,QAAQ,IAAY,EAAU;IAC5C,WAAW;IACX,IAAI,WAAW,CAAC;IAChB,IAAI,YAAY;IAChB,IAAI,MAAM,CAAC;IACX,IAAI,eAAe,IAAI;IACvB,yEAAyE;IACzE,mCAAmC;IACnC,IAAI,cAAc;IAClB,IAAK,IAAI,IAAI,KAAK,MAAM,GAAG,GAAG,KAAK,GAAG,EAAE,EAAG;QACzC,MAAM,OAAO,KAAK,UAAU,CAAC;QAC7B,IAAI,SAAS,oBAAoB;YAC/B,oEAAoE;YACpE,gDAAgD;YAChD,IAAI,CAAC,cAAc;gBACjB,YAAY,IAAI;gBAChB,KAAM;YACR,CAAC;YACD,QAAS;QACX,CAAC;QACD,IAAI,QAAQ,CAAC,GAAG;YACd,mEAAmE;YACnE,YAAY;YACZ,eAAe,KAAK;YACpB,MAAM,IAAI;QACZ,CAAC;QACD,IAAI,SAAS,UAAU;YACrB,kEAAkE;YAClE,IAAI,aAAa,CAAC,GAAG,WAAW;iBAC3B,IAAI,gBAAgB,GAAG,cAAc;QAC5C,OAAO,IAAI,aAAa,CAAC,GAAG;YAC1B,uEAAuE;YACvE,qDAAqD;YACrD,cAAc,CAAC;QACjB,CAAC;IACH;IAEA,IACE,aAAa,CAAC,KACd,QAAQ,CAAC,KACT,wDAAwD;IACxD,gBAAgB,KAChB,0DAA0D;IACzD,gBAAgB,KAAK,aAAa,MAAM,KAAK,aAAa,YAAY,GACvE;QACA,OAAO;IACT,CAAC;IACD,OAAO,KAAK,KAAK,CAAC,UAAU;AAC9B,CAAC;AAED;;;CAGC,GACD,OAAO,SAAS,OAAO,UAAiC,EAAU;IAChE,IAAI,eAAe,IAAI,IAAI,OAAO,eAAe,UAAU;QACzD,MAAM,IAAI,UACR,CAAC,gEAAgE,EAAE,OAAO,WAAW,CAAC,EACtF;IACJ,CAAC;IACD,OAAO,QAAQ,KAAK;AACtB,CAAC;AAED;;;CAGC,GACD,OAAO,SAAS,MAAM,IAAY,EAAc;IAC9C,WAAW;IAEX,MAAM,MAAkB;QAAE,MAAM;QAAI,KAAK;QAAI,MAAM;QAAI,KAAK;QAAI,MAAM;IAAG;IACzE,IAAI,KAAK,MAAM,KAAK,GAAG,OAAO;IAC9B,MAAM,aAAa,KAAK,UAAU,CAAC,OAAO;IAC1C,IAAI;IACJ,IAAI,YAAY;QACd,IAAI,IAAI,GAAG;QACX,QAAQ;IACV,OAAO;QACL,QAAQ;IACV,CAAC;IACD,IAAI,WAAW,CAAC;IAChB,IAAI,YAAY;IAChB,IAAI,MAAM,CAAC;IACX,IAAI,eAAe,IAAI;IACvB,IAAI,IAAI,KAAK,MAAM,GAAG;IAEtB,yEAAyE;IACzE,mCAAmC;IACnC,IAAI,cAAc;IAElB,mBAAmB;IACnB,MAAO,KAAK,OAAO,EAAE,EAAG;QACtB,MAAM,OAAO,KAAK,UAAU,CAAC;QAC7B,IAAI,SAAS,oBAAoB;YAC/B,oEAAoE;YACpE,gDAAgD;YAChD,IAAI,CAAC,cAAc;gBACjB,YAAY,IAAI;gBAChB,KAAM;YACR,CAAC;YACD,QAAS;QACX,CAAC;QACD,IAAI,QAAQ,CAAC,GAAG;YACd,mEAAmE;YACnE,YAAY;YACZ,eAAe,KAAK;YACpB,MAAM,IAAI;QACZ,CAAC;QACD,IAAI,SAAS,UAAU;YACrB,kEAAkE;YAClE,IAAI,aAAa,CAAC,GAAG,WAAW;iBAC3B,IAAI,gBAAgB,GAAG,cAAc;QAC5C,OAAO,IAAI,aAAa,CAAC,GAAG;YAC1B,uEAAuE;YACvE,qDAAqD;YACrD,cAAc,CAAC;QACjB,CAAC;IACH;IAEA,IACE,aAAa,CAAC,KACd,QAAQ,CAAC,KACT,wDAAwD;IACxD,gBAAgB,KAChB,0DAA0D;IACzD,gBAAgB,KAAK,aAAa,MAAM,KAAK,aAAa,YAAY,GACvE;QACA,IAAI,QAAQ,CAAC,GAAG;YACd,IAAI,cAAc,KAAK,YAAY;gBACjC,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,KAAK,KAAK,CAAC,GAAG;YACtC,OAAO;gBACL,IAAI,IAAI,GAAG,IAAI,IAAI,GAAG,KAAK,KAAK,CAAC,WAAW;YAC9C,CAAC;QACH,CAAC;IACH,OAAO;QACL,IAAI,cAAc,KAAK,YAAY;YACjC,IAAI,IAAI,GAAG,KAAK,KAAK,CAAC,GAAG;YACzB,IAAI,IAAI,GAAG,KAAK,KAAK,CAAC,GAAG;QAC3B,OAAO;YACL,IAAI,IAAI,GAAG,KAAK,KAAK,CAAC,WAAW;YACjC,IAAI,IAAI,GAAG,KAAK,KAAK,CAAC,WAAW;QACnC,CAAC;QACD,IAAI,GAAG,GAAG,KAAK,KAAK,CAAC,UAAU;IACjC,CAAC;IAED,IAAI,YAAY,GAAG,IAAI,GAAG,GAAG,KAAK,KAAK,CAAC,GAAG,YAAY;SAClD,IAAI,YAAY,IAAI,GAAG,GAAG;IAE/B,OAAO;AACT,CAAC;AAED;;;;;;;;CAQC,GACD,OAAO,SAAS,YAAY,GAAiB,EAAU;IACrD,MAAM,eAAe,MAAM,MAAM,IAAI,IAAI,IAAI;IAC7C,IAAI,IAAI,QAAQ,IAAI,SAAS;QAC3B,MAAM,IAAI,UAAU,uBAAuB;IAC7C,CAAC;IACD,OAAO,mBACL,IAAI,QAAQ,CAAC,OAAO,CAAC,wBAAwB;AAEjD,CAAC;AAED;;;;;;;;CAQC,GACD,OAAO,SAAS,UAAU,IAAY,EAAO;IAC3C,IAAI,CAAC,WAAW,OAAO;QACrB,MAAM,IAAI,UAAU,6BAA6B;IACnD,CAAC;IACD,MAAM,MAAM,IAAI,IAAI;IACpB,IAAI,QAAQ,GAAG,iBACb,KAAK,OAAO,CAAC,MAAM,OAAO,OAAO,CAAC,OAAO;IAE3C,OAAO;AACT,CAAC"} \ No newline at end of file diff --git a/tests/__snapshots__/transpile/url/modules/nhMTTXGO1bgNtQ_bGZFJE0b7hWs.js b/tests/__snapshots__/transpile/url/modules/nhMTTXGO1bgNtQ_bGZFJE0b7hWs.js new file mode 100644 index 0000000..fc8cdf6 --- /dev/null +++ b/tests/__snapshots__/transpile/url/modules/nhMTTXGO1bgNtQ_bGZFJE0b7hWs.js @@ -0,0 +1,14 @@ +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. +export class DenoStdInternalError extends Error { + constructor(message){ + super(message); + this.name = "DenoStdInternalError"; + } +} +/** Make an assertion, if not `true`, then throw. */ export function assert(expr, msg = "") { + if (!expr) { + throw new DenoStdInternalError(msg); + } +} +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImh0dHBzOi8vZGVuby5sYW5kL3N0ZEAwLjE0MC4wL191dGlsL2Fzc2VydC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAxOC0yMDIyIHRoZSBEZW5vIGF1dGhvcnMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIE1JVCBsaWNlbnNlLlxuLy8gVGhpcyBtb2R1bGUgaXMgYnJvd3NlciBjb21wYXRpYmxlLlxuXG5leHBvcnQgY2xhc3MgRGVub1N0ZEludGVybmFsRXJyb3IgZXh0ZW5kcyBFcnJvciB7XG4gIGNvbnN0cnVjdG9yKG1lc3NhZ2U6IHN0cmluZykge1xuICAgIHN1cGVyKG1lc3NhZ2UpO1xuICAgIHRoaXMubmFtZSA9IFwiRGVub1N0ZEludGVybmFsRXJyb3JcIjtcbiAgfVxufVxuXG4vKiogTWFrZSBhbiBhc3NlcnRpb24sIGlmIG5vdCBgdHJ1ZWAsIHRoZW4gdGhyb3cuICovXG5leHBvcnQgZnVuY3Rpb24gYXNzZXJ0KGV4cHI6IHVua25vd24sIG1zZyA9IFwiXCIpOiBhc3NlcnRzIGV4cHIge1xuICBpZiAoIWV4cHIpIHtcbiAgICB0aHJvdyBuZXcgRGVub1N0ZEludGVybmFsRXJyb3IobXNnKTtcbiAgfVxufVxuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDBFQUEwRTtBQUMxRSxxQ0FBcUM7QUFFckMsT0FBTyxNQUFNLDZCQUE2QjtJQUN4QyxZQUFZLE9BQWUsQ0FBRTtRQUMzQixLQUFLLENBQUM7UUFDTixJQUFJLENBQUMsSUFBSSxHQUFHO0lBQ2Q7QUFDRixDQUFDO0FBRUQsa0RBQWtELEdBQ2xELE9BQU8sU0FBUyxPQUFPLElBQWEsRUFBRSxNQUFNLEVBQUUsRUFBZ0I7SUFDNUQsSUFBSSxDQUFDLE1BQU07UUFDVCxNQUFNLElBQUkscUJBQXFCLEtBQUs7SUFDdEMsQ0FBQztBQUNILENBQUMifQ== \ No newline at end of file diff --git a/tests/__snapshots__/transpile/url/modules/npEsX-46oQUgZNw2Jkxv5i4eWDM.js b/tests/__snapshots__/transpile/url/modules/npEsX-46oQUgZNw2Jkxv5i4eWDM.js new file mode 100644 index 0000000..04be5a3 --- /dev/null +++ b/tests/__snapshots__/transpile/url/modules/npEsX-46oQUgZNw2Jkxv5i4eWDM.js @@ -0,0 +1,851 @@ +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +import { assert } from "../_util/assert.ts"; +import { BytesList } from "../bytes/bytes_list.ts"; +import { concat, copy } from "../bytes/mod.ts"; +// MIN_READ is the minimum ArrayBuffer size passed to a read call by +// buffer.ReadFrom. As long as the Buffer has at least MIN_READ bytes beyond +// what is required to hold the contents of r, readFrom() will not grow the +// underlying buffer. +const MIN_READ = 32 * 1024; +const MAX_SIZE = 2 ** 32 - 2; +/** A variable-sized buffer of bytes with `read()` and `write()` methods. + * + * Buffer is almost always used with some I/O like files and sockets. It allows + * one to buffer up a download from a socket. Buffer grows and shrinks as + * necessary. + * + * Buffer is NOT the same thing as Node's Buffer. Node's Buffer was created in + * 2009 before JavaScript had the concept of ArrayBuffers. It's simply a + * non-standard ArrayBuffer. + * + * ArrayBuffer is a fixed memory allocation. Buffer is implemented on top of + * ArrayBuffer. + * + * Based on [Go Buffer](https://golang.org/pkg/bytes/#Buffer). */ export class Buffer { + #buf; + #off = 0; + constructor(ab){ + this.#buf = ab === undefined ? new Uint8Array(0) : new Uint8Array(ab); + } + /** Returns a slice holding the unread portion of the buffer. + * + * The slice is valid for use only until the next buffer modification (that + * is, only until the next call to a method like `read()`, `write()`, + * `reset()`, or `truncate()`). If `options.copy` is false the slice aliases the buffer content at + * least until the next buffer modification, so immediate changes to the + * slice will affect the result of future reads. + * @param options Defaults to `{ copy: true }` + */ bytes(options = { + copy: true + }) { + if (options.copy === false) return this.#buf.subarray(this.#off); + return this.#buf.slice(this.#off); + } + /** Returns whether the unread portion of the buffer is empty. */ empty() { + return this.#buf.byteLength <= this.#off; + } + /** A read only number of bytes of the unread portion of the buffer. */ get length() { + return this.#buf.byteLength - this.#off; + } + /** The read only capacity of the buffer's underlying byte slice, that is, + * the total space allocated for the buffer's data. */ get capacity() { + return this.#buf.buffer.byteLength; + } + /** Discards all but the first `n` unread bytes from the buffer but + * continues to use the same allocated storage. It throws if `n` is + * negative or greater than the length of the buffer. */ truncate(n) { + if (n === 0) { + this.reset(); + return; + } + if (n < 0 || n > this.length) { + throw Error("bytes.Buffer: truncation out of range"); + } + this.#reslice(this.#off + n); + } + reset() { + this.#reslice(0); + this.#off = 0; + } + #tryGrowByReslice(n) { + const l = this.#buf.byteLength; + if (n <= this.capacity - l) { + this.#reslice(l + n); + return l; + } + return -1; + } + #reslice(len) { + assert(len <= this.#buf.buffer.byteLength); + this.#buf = new Uint8Array(this.#buf.buffer, 0, len); + } + /** Reads the next `p.length` bytes from the buffer or until the buffer is + * drained. Returns the number of bytes read. If the buffer has no data to + * return, the return is EOF (`null`). */ readSync(p) { + if (this.empty()) { + // Buffer is empty, reset to recover space. + this.reset(); + if (p.byteLength === 0) { + // this edge case is tested in 'bufferReadEmptyAtEOF' test + return 0; + } + return null; + } + const nread = copy(this.#buf.subarray(this.#off), p); + this.#off += nread; + return nread; + } + /** Reads the next `p.length` bytes from the buffer or until the buffer is + * drained. Resolves to the number of bytes read. If the buffer has no + * data to return, resolves to EOF (`null`). + * + * NOTE: This methods reads bytes synchronously; it's provided for + * compatibility with `Reader` interfaces. + */ read(p) { + const rr = this.readSync(p); + return Promise.resolve(rr); + } + writeSync(p) { + const m = this.#grow(p.byteLength); + return copy(p, this.#buf, m); + } + /** NOTE: This methods writes bytes synchronously; it's provided for + * compatibility with `Writer` interface. */ write(p) { + const n = this.writeSync(p); + return Promise.resolve(n); + } + #grow(n) { + const m = this.length; + // If buffer is empty, reset to recover space. + if (m === 0 && this.#off !== 0) { + this.reset(); + } + // Fast: Try to grow by means of a reslice. + const i = this.#tryGrowByReslice(n); + if (i >= 0) { + return i; + } + const c = this.capacity; + if (n <= Math.floor(c / 2) - m) { + // We can slide things down instead of allocating a new + // ArrayBuffer. We only need m+n <= c to slide, but + // we instead let capacity get twice as large so we + // don't spend all our time copying. + copy(this.#buf.subarray(this.#off), this.#buf); + } else if (c + n > MAX_SIZE) { + throw new Error("The buffer cannot be grown beyond the maximum size."); + } else { + // Not enough space anywhere, we need to allocate. + const buf = new Uint8Array(Math.min(2 * c + n, MAX_SIZE)); + copy(this.#buf.subarray(this.#off), buf); + this.#buf = buf; + } + // Restore this.#off and len(this.#buf). + this.#off = 0; + this.#reslice(Math.min(m + n, MAX_SIZE)); + return m; + } + /** Grows the buffer's capacity, if necessary, to guarantee space for + * another `n` bytes. After `.grow(n)`, at least `n` bytes can be written to + * the buffer without another allocation. If `n` is negative, `.grow()` will + * throw. If the buffer can't grow it will throw an error. + * + * Based on Go Lang's + * [Buffer.Grow](https://golang.org/pkg/bytes/#Buffer.Grow). */ grow(n) { + if (n < 0) { + throw Error("Buffer.grow: negative count"); + } + const m = this.#grow(n); + this.#reslice(m); + } + /** Reads data from `r` until EOF (`null`) and appends it to the buffer, + * growing the buffer as needed. It resolves to the number of bytes read. + * If the buffer becomes too large, `.readFrom()` will reject with an error. + * + * Based on Go Lang's + * [Buffer.ReadFrom](https://golang.org/pkg/bytes/#Buffer.ReadFrom). */ async readFrom(r) { + let n = 0; + const tmp = new Uint8Array(MIN_READ); + while(true){ + const shouldGrow = this.capacity - this.length < MIN_READ; + // read into tmp buffer if there's not enough room + // otherwise read directly into the internal buffer + const buf = shouldGrow ? tmp : new Uint8Array(this.#buf.buffer, this.length); + const nread = await r.read(buf); + if (nread === null) { + return n; + } + // write will grow if needed + if (shouldGrow) this.writeSync(buf.subarray(0, nread)); + else this.#reslice(this.length + nread); + n += nread; + } + } + /** Reads data from `r` until EOF (`null`) and appends it to the buffer, + * growing the buffer as needed. It returns the number of bytes read. If the + * buffer becomes too large, `.readFromSync()` will throw an error. + * + * Based on Go Lang's + * [Buffer.ReadFrom](https://golang.org/pkg/bytes/#Buffer.ReadFrom). */ readFromSync(r) { + let n = 0; + const tmp = new Uint8Array(MIN_READ); + while(true){ + const shouldGrow = this.capacity - this.length < MIN_READ; + // read into tmp buffer if there's not enough room + // otherwise read directly into the internal buffer + const buf = shouldGrow ? tmp : new Uint8Array(this.#buf.buffer, this.length); + const nread = r.readSync(buf); + if (nread === null) { + return n; + } + // write will grow if needed + if (shouldGrow) this.writeSync(buf.subarray(0, nread)); + else this.#reslice(this.length + nread); + n += nread; + } + } +} +const DEFAULT_BUF_SIZE = 4096; +const MIN_BUF_SIZE = 16; +const MAX_CONSECUTIVE_EMPTY_READS = 100; +const CR = "\r".charCodeAt(0); +const LF = "\n".charCodeAt(0); +export class BufferFullError extends Error { + partial; + name; + constructor(partial){ + super("Buffer full"); + this.partial = partial; + this.name = "BufferFullError"; + } +} +export class PartialReadError extends Error { + name = "PartialReadError"; + partial; + constructor(){ + super("Encountered UnexpectedEof, data only partially read"); + } +} +/** BufReader implements buffering for a Reader object. */ export class BufReader { + #buf; + #rd; + #r = 0; + #w = 0; + #eof = false; + // private lastByte: number; + // private lastCharSize: number; + /** return new BufReader unless r is BufReader */ static create(r, size = DEFAULT_BUF_SIZE) { + return r instanceof BufReader ? r : new BufReader(r, size); + } + constructor(rd, size = DEFAULT_BUF_SIZE){ + if (size < MIN_BUF_SIZE) { + size = MIN_BUF_SIZE; + } + this.#reset(new Uint8Array(size), rd); + } + /** Returns the size of the underlying buffer in bytes. */ size() { + return this.#buf.byteLength; + } + buffered() { + return this.#w - this.#r; + } + // Reads a new chunk into the buffer. + #fill = async ()=>{ + // Slide existing data to beginning. + if (this.#r > 0) { + this.#buf.copyWithin(0, this.#r, this.#w); + this.#w -= this.#r; + this.#r = 0; + } + if (this.#w >= this.#buf.byteLength) { + throw Error("bufio: tried to fill full buffer"); + } + // Read new data: try a limited number of times. + for(let i = MAX_CONSECUTIVE_EMPTY_READS; i > 0; i--){ + const rr = await this.#rd.read(this.#buf.subarray(this.#w)); + if (rr === null) { + this.#eof = true; + return; + } + assert(rr >= 0, "negative read"); + this.#w += rr; + if (rr > 0) { + return; + } + } + throw new Error(`No progress after ${MAX_CONSECUTIVE_EMPTY_READS} read() calls`); + }; + /** Discards any buffered data, resets all state, and switches + * the buffered reader to read from r. + */ reset(r) { + this.#reset(this.#buf, r); + } + #reset = (buf, rd)=>{ + this.#buf = buf; + this.#rd = rd; + this.#eof = false; + // this.lastByte = -1; + // this.lastCharSize = -1; + }; + /** reads data into p. + * It returns the number of bytes read into p. + * The bytes are taken from at most one Read on the underlying Reader, + * hence n may be less than len(p). + * To read exactly len(p) bytes, use io.ReadFull(b, p). + */ async read(p) { + let rr = p.byteLength; + if (p.byteLength === 0) return rr; + if (this.#r === this.#w) { + if (p.byteLength >= this.#buf.byteLength) { + // Large read, empty buffer. + // Read directly into p to avoid copy. + const rr = await this.#rd.read(p); + const nread = rr ?? 0; + assert(nread >= 0, "negative read"); + // if (rr.nread > 0) { + // this.lastByte = p[rr.nread - 1]; + // this.lastCharSize = -1; + // } + return rr; + } + // One read. + // Do not use this.fill, which will loop. + this.#r = 0; + this.#w = 0; + rr = await this.#rd.read(this.#buf); + if (rr === 0 || rr === null) return rr; + assert(rr >= 0, "negative read"); + this.#w += rr; + } + // copy as much as we can + const copied = copy(this.#buf.subarray(this.#r, this.#w), p, 0); + this.#r += copied; + // this.lastByte = this.buf[this.r - 1]; + // this.lastCharSize = -1; + return copied; + } + /** reads exactly `p.length` bytes into `p`. + * + * If successful, `p` is returned. + * + * If the end of the underlying stream has been reached, and there are no more + * bytes available in the buffer, `readFull()` returns `null` instead. + * + * An error is thrown if some bytes could be read, but not enough to fill `p` + * entirely before the underlying stream reported an error or EOF. Any error + * thrown will have a `partial` property that indicates the slice of the + * buffer that has been successfully filled with data. + * + * Ported from https://golang.org/pkg/io/#ReadFull + */ async readFull(p) { + let bytesRead = 0; + while(bytesRead < p.length){ + try { + const rr = await this.read(p.subarray(bytesRead)); + if (rr === null) { + if (bytesRead === 0) { + return null; + } else { + throw new PartialReadError(); + } + } + bytesRead += rr; + } catch (err) { + if (err instanceof PartialReadError) { + err.partial = p.subarray(0, bytesRead); + } else if (err instanceof Error) { + const e = new PartialReadError(); + e.partial = p.subarray(0, bytesRead); + e.stack = err.stack; + e.message = err.message; + e.cause = err.cause; + throw err; + } + throw err; + } + } + return p; + } + /** Returns the next byte [0, 255] or `null`. */ async readByte() { + while(this.#r === this.#w){ + if (this.#eof) return null; + await this.#fill(); // buffer is empty. + } + const c = this.#buf[this.#r]; + this.#r++; + // this.lastByte = c; + return c; + } + /** readString() reads until the first occurrence of delim in the input, + * returning a string containing the data up to and including the delimiter. + * If ReadString encounters an error before finding a delimiter, + * it returns the data read before the error and the error itself + * (often `null`). + * ReadString returns err != nil if and only if the returned data does not end + * in delim. + * For simple uses, a Scanner may be more convenient. + */ async readString(delim) { + if (delim.length !== 1) { + throw new Error("Delimiter should be a single character"); + } + const buffer = await this.readSlice(delim.charCodeAt(0)); + if (buffer === null) return null; + return new TextDecoder().decode(buffer); + } + /** `readLine()` is a low-level line-reading primitive. Most callers should + * use `readString('\n')` instead or use a Scanner. + * + * `readLine()` tries to return a single line, not including the end-of-line + * bytes. If the line was too long for the buffer then `more` is set and the + * beginning of the line is returned. The rest of the line will be returned + * from future calls. `more` will be false when returning the last fragment + * of the line. The returned buffer is only valid until the next call to + * `readLine()`. + * + * The text returned from ReadLine does not include the line end ("\r\n" or + * "\n"). + * + * When the end of the underlying stream is reached, the final bytes in the + * stream are returned. No indication or error is given if the input ends + * without a final line end. When there are no more trailing bytes to read, + * `readLine()` returns `null`. + * + * Calling `unreadByte()` after `readLine()` will always unread the last byte + * read (possibly a character belonging to the line end) even if that byte is + * not part of the line returned by `readLine()`. + */ async readLine() { + let line = null; + try { + line = await this.readSlice(LF); + } catch (err) { + if (err instanceof Deno.errors.BadResource) { + throw err; + } + let partial; + if (err instanceof PartialReadError) { + partial = err.partial; + assert(partial instanceof Uint8Array, "bufio: caught error from `readSlice()` without `partial` property"); + } + // Don't throw if `readSlice()` failed with `BufferFullError`, instead we + // just return whatever is available and set the `more` flag. + if (!(err instanceof BufferFullError)) { + throw err; + } + partial = err.partial; + // Handle the case where "\r\n" straddles the buffer. + if (!this.#eof && partial && partial.byteLength > 0 && partial[partial.byteLength - 1] === CR) { + // Put the '\r' back on buf and drop it from line. + // Let the next call to ReadLine check for "\r\n". + assert(this.#r > 0, "bufio: tried to rewind past start of buffer"); + this.#r--; + partial = partial.subarray(0, partial.byteLength - 1); + } + if (partial) { + return { + line: partial, + more: !this.#eof + }; + } + } + if (line === null) { + return null; + } + if (line.byteLength === 0) { + return { + line, + more: false + }; + } + if (line[line.byteLength - 1] == LF) { + let drop = 1; + if (line.byteLength > 1 && line[line.byteLength - 2] === CR) { + drop = 2; + } + line = line.subarray(0, line.byteLength - drop); + } + return { + line, + more: false + }; + } + /** `readSlice()` reads until the first occurrence of `delim` in the input, + * returning a slice pointing at the bytes in the buffer. The bytes stop + * being valid at the next read. + * + * If `readSlice()` encounters an error before finding a delimiter, or the + * buffer fills without finding a delimiter, it throws an error with a + * `partial` property that contains the entire buffer. + * + * If `readSlice()` encounters the end of the underlying stream and there are + * any bytes left in the buffer, the rest of the buffer is returned. In other + * words, EOF is always treated as a delimiter. Once the buffer is empty, + * it returns `null`. + * + * Because the data returned from `readSlice()` will be overwritten by the + * next I/O operation, most clients should use `readString()` instead. + */ async readSlice(delim) { + let s = 0; // search start index + let slice; + while(true){ + // Search buffer. + let i = this.#buf.subarray(this.#r + s, this.#w).indexOf(delim); + if (i >= 0) { + i += s; + slice = this.#buf.subarray(this.#r, this.#r + i + 1); + this.#r += i + 1; + break; + } + // EOF? + if (this.#eof) { + if (this.#r === this.#w) { + return null; + } + slice = this.#buf.subarray(this.#r, this.#w); + this.#r = this.#w; + break; + } + // Buffer full? + if (this.buffered() >= this.#buf.byteLength) { + this.#r = this.#w; + // #4521 The internal buffer should not be reused across reads because it causes corruption of data. + const oldbuf = this.#buf; + const newbuf = this.#buf.slice(0); + this.#buf = newbuf; + throw new BufferFullError(oldbuf); + } + s = this.#w - this.#r; // do not rescan area we scanned before + // Buffer is not full. + try { + await this.#fill(); + } catch (err) { + if (err instanceof PartialReadError) { + err.partial = slice; + } else if (err instanceof Error) { + const e = new PartialReadError(); + e.partial = slice; + e.stack = err.stack; + e.message = err.message; + e.cause = err.cause; + throw err; + } + throw err; + } + } + // Handle last byte, if any. + // const i = slice.byteLength - 1; + // if (i >= 0) { + // this.lastByte = slice[i]; + // this.lastCharSize = -1 + // } + return slice; + } + /** `peek()` returns the next `n` bytes without advancing the reader. The + * bytes stop being valid at the next read call. + * + * When the end of the underlying stream is reached, but there are unread + * bytes left in the buffer, those bytes are returned. If there are no bytes + * left in the buffer, it returns `null`. + * + * If an error is encountered before `n` bytes are available, `peek()` throws + * an error with the `partial` property set to a slice of the buffer that + * contains the bytes that were available before the error occurred. + */ async peek(n) { + if (n < 0) { + throw Error("negative count"); + } + let avail = this.#w - this.#r; + while(avail < n && avail < this.#buf.byteLength && !this.#eof){ + try { + await this.#fill(); + } catch (err) { + if (err instanceof PartialReadError) { + err.partial = this.#buf.subarray(this.#r, this.#w); + } else if (err instanceof Error) { + const e = new PartialReadError(); + e.partial = this.#buf.subarray(this.#r, this.#w); + e.stack = err.stack; + e.message = err.message; + e.cause = err.cause; + throw err; + } + throw err; + } + avail = this.#w - this.#r; + } + if (avail === 0 && this.#eof) { + return null; + } else if (avail < n && this.#eof) { + return this.#buf.subarray(this.#r, this.#r + avail); + } else if (avail < n) { + throw new BufferFullError(this.#buf.subarray(this.#r, this.#w)); + } + return this.#buf.subarray(this.#r, this.#r + n); + } +} +class AbstractBufBase { + buf; + usedBufferBytes = 0; + err = null; + constructor(buf){ + this.buf = buf; + } + /** Size returns the size of the underlying buffer in bytes. */ size() { + return this.buf.byteLength; + } + /** Returns how many bytes are unused in the buffer. */ available() { + return this.buf.byteLength - this.usedBufferBytes; + } + /** buffered returns the number of bytes that have been written into the + * current buffer. + */ buffered() { + return this.usedBufferBytes; + } +} +/** BufWriter implements buffering for an deno.Writer object. + * If an error occurs writing to a Writer, no more data will be + * accepted and all subsequent writes, and flush(), will return the error. + * After all data has been written, the client should call the + * flush() method to guarantee all data has been forwarded to + * the underlying deno.Writer. + */ export class BufWriter extends AbstractBufBase { + #writer; + /** return new BufWriter unless writer is BufWriter */ static create(writer, size = DEFAULT_BUF_SIZE) { + return writer instanceof BufWriter ? writer : new BufWriter(writer, size); + } + constructor(writer, size = DEFAULT_BUF_SIZE){ + super(new Uint8Array(size <= 0 ? DEFAULT_BUF_SIZE : size)); + this.#writer = writer; + } + /** Discards any unflushed buffered data, clears any error, and + * resets buffer to write its output to w. + */ reset(w) { + this.err = null; + this.usedBufferBytes = 0; + this.#writer = w; + } + /** Flush writes any buffered data to the underlying io.Writer. */ async flush() { + if (this.err !== null) throw this.err; + if (this.usedBufferBytes === 0) return; + try { + const p = this.buf.subarray(0, this.usedBufferBytes); + let nwritten = 0; + while(nwritten < p.length){ + nwritten += await this.#writer.write(p.subarray(nwritten)); + } + } catch (e) { + if (e instanceof Error) { + this.err = e; + } + throw e; + } + this.buf = new Uint8Array(this.buf.length); + this.usedBufferBytes = 0; + } + /** Writes the contents of `data` into the buffer. If the contents won't fully + * fit into the buffer, those bytes that can are copied into the buffer, the + * buffer is the flushed to the writer and the remaining bytes are copied into + * the now empty buffer. + * + * @return the number of bytes written to the buffer. + */ async write(data) { + if (this.err !== null) throw this.err; + if (data.length === 0) return 0; + let totalBytesWritten = 0; + let numBytesWritten = 0; + while(data.byteLength > this.available()){ + if (this.buffered() === 0) { + // Large write, empty buffer. + // Write directly from data to avoid copy. + try { + numBytesWritten = await this.#writer.write(data); + } catch (e) { + if (e instanceof Error) { + this.err = e; + } + throw e; + } + } else { + numBytesWritten = copy(data, this.buf, this.usedBufferBytes); + this.usedBufferBytes += numBytesWritten; + await this.flush(); + } + totalBytesWritten += numBytesWritten; + data = data.subarray(numBytesWritten); + } + numBytesWritten = copy(data, this.buf, this.usedBufferBytes); + this.usedBufferBytes += numBytesWritten; + totalBytesWritten += numBytesWritten; + return totalBytesWritten; + } +} +/** BufWriterSync implements buffering for a deno.WriterSync object. + * If an error occurs writing to a WriterSync, no more data will be + * accepted and all subsequent writes, and flush(), will return the error. + * After all data has been written, the client should call the + * flush() method to guarantee all data has been forwarded to + * the underlying deno.WriterSync. + */ export class BufWriterSync extends AbstractBufBase { + #writer; + /** return new BufWriterSync unless writer is BufWriterSync */ static create(writer, size = DEFAULT_BUF_SIZE) { + return writer instanceof BufWriterSync ? writer : new BufWriterSync(writer, size); + } + constructor(writer, size = DEFAULT_BUF_SIZE){ + super(new Uint8Array(size <= 0 ? DEFAULT_BUF_SIZE : size)); + this.#writer = writer; + } + /** Discards any unflushed buffered data, clears any error, and + * resets buffer to write its output to w. + */ reset(w) { + this.err = null; + this.usedBufferBytes = 0; + this.#writer = w; + } + /** Flush writes any buffered data to the underlying io.WriterSync. */ flush() { + if (this.err !== null) throw this.err; + if (this.usedBufferBytes === 0) return; + try { + const p = this.buf.subarray(0, this.usedBufferBytes); + let nwritten = 0; + while(nwritten < p.length){ + nwritten += this.#writer.writeSync(p.subarray(nwritten)); + } + } catch (e) { + if (e instanceof Error) { + this.err = e; + } + throw e; + } + this.buf = new Uint8Array(this.buf.length); + this.usedBufferBytes = 0; + } + /** Writes the contents of `data` into the buffer. If the contents won't fully + * fit into the buffer, those bytes that can are copied into the buffer, the + * buffer is the flushed to the writer and the remaining bytes are copied into + * the now empty buffer. + * + * @return the number of bytes written to the buffer. + */ writeSync(data) { + if (this.err !== null) throw this.err; + if (data.length === 0) return 0; + let totalBytesWritten = 0; + let numBytesWritten = 0; + while(data.byteLength > this.available()){ + if (this.buffered() === 0) { + // Large write, empty buffer. + // Write directly from data to avoid copy. + try { + numBytesWritten = this.#writer.writeSync(data); + } catch (e) { + if (e instanceof Error) { + this.err = e; + } + throw e; + } + } else { + numBytesWritten = copy(data, this.buf, this.usedBufferBytes); + this.usedBufferBytes += numBytesWritten; + this.flush(); + } + totalBytesWritten += numBytesWritten; + data = data.subarray(numBytesWritten); + } + numBytesWritten = copy(data, this.buf, this.usedBufferBytes); + this.usedBufferBytes += numBytesWritten; + totalBytesWritten += numBytesWritten; + return totalBytesWritten; + } +} +/** Generate longest proper prefix which is also suffix array. */ function createLPS(pat) { + const lps = new Uint8Array(pat.length); + lps[0] = 0; + let prefixEnd = 0; + let i = 1; + while(i < lps.length){ + if (pat[i] == pat[prefixEnd]) { + prefixEnd++; + lps[i] = prefixEnd; + i++; + } else if (prefixEnd === 0) { + lps[i] = 0; + i++; + } else { + prefixEnd = lps[prefixEnd - 1]; + } + } + return lps; +} +/** Read delimited bytes from a Reader. */ export async function* readDelim(reader, delim) { + // Avoid unicode problems + const delimLen = delim.length; + const delimLPS = createLPS(delim); + const chunks = new BytesList(); + const bufSize = Math.max(1024, delimLen + 1); + // Modified KMP + let inspectIndex = 0; + let matchIndex = 0; + while(true){ + const inspectArr = new Uint8Array(bufSize); + const result = await reader.read(inspectArr); + if (result === null) { + // Yield last chunk. + yield chunks.concat(); + return; + } else if (result < 0) { + // Discard all remaining and silently fail. + return; + } + chunks.add(inspectArr, 0, result); + let localIndex = 0; + while(inspectIndex < chunks.size()){ + if (inspectArr[localIndex] === delim[matchIndex]) { + inspectIndex++; + localIndex++; + matchIndex++; + if (matchIndex === delimLen) { + // Full match + const matchEnd = inspectIndex - delimLen; + const readyBytes = chunks.slice(0, matchEnd); + yield readyBytes; + // Reset match, different from KMP. + chunks.shift(inspectIndex); + inspectIndex = 0; + matchIndex = 0; + } + } else { + if (matchIndex === 0) { + inspectIndex++; + localIndex++; + } else { + matchIndex = delimLPS[matchIndex - 1]; + } + } + } + } +} +/** Read delimited strings from a Reader. */ export async function* readStringDelim(reader, delim, decoderOpts) { + const encoder = new TextEncoder(); + const decoder = new TextDecoder(decoderOpts?.encoding, decoderOpts); + for await (const chunk of readDelim(reader, encoder.encode(delim))){ + yield decoder.decode(chunk); + } +} +/** Read strings line-by-line from a Reader. */ export async function* readLines(reader, decoderOpts) { + const bufReader = new BufReader(reader); + let chunks = []; + const decoder = new TextDecoder(decoderOpts?.encoding, decoderOpts); + while(true){ + const res = await bufReader.readLine(); + if (!res) { + if (chunks.length > 0) { + yield decoder.decode(concat(...chunks)); + } + break; + } + chunks.push(res.line); + if (!res.more) { + yield decoder.decode(concat(...chunks)); + chunks = []; + } + } +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["https://deno.land/std@0.140.0/io/buffer.ts"],"sourcesContent":["// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.\nimport { assert } from \"../_util/assert.ts\";\nimport { BytesList } from \"../bytes/bytes_list.ts\";\nimport { concat, copy } from \"../bytes/mod.ts\";\nimport type { Reader, ReaderSync, Writer, WriterSync } from \"./types.d.ts\";\n\n// MIN_READ is the minimum ArrayBuffer size passed to a read call by\n// buffer.ReadFrom. As long as the Buffer has at least MIN_READ bytes beyond\n// what is required to hold the contents of r, readFrom() will not grow the\n// underlying buffer.\nconst MIN_READ = 32 * 1024;\nconst MAX_SIZE = 2 ** 32 - 2;\n\n/** A variable-sized buffer of bytes with `read()` and `write()` methods.\n *\n * Buffer is almost always used with some I/O like files and sockets. It allows\n * one to buffer up a download from a socket. Buffer grows and shrinks as\n * necessary.\n *\n * Buffer is NOT the same thing as Node's Buffer. Node's Buffer was created in\n * 2009 before JavaScript had the concept of ArrayBuffers. It's simply a\n * non-standard ArrayBuffer.\n *\n * ArrayBuffer is a fixed memory allocation. Buffer is implemented on top of\n * ArrayBuffer.\n *\n * Based on [Go Buffer](https://golang.org/pkg/bytes/#Buffer). */\n\nexport class Buffer {\n  #buf: Uint8Array; // contents are the bytes buf[off : len(buf)]\n  #off = 0; // read at buf[off], write at buf[buf.byteLength]\n\n  constructor(ab?: ArrayBufferLike | ArrayLike<number>) {\n    this.#buf = ab === undefined ? new Uint8Array(0) : new Uint8Array(ab);\n  }\n\n  /** Returns a slice holding the unread portion of the buffer.\n   *\n   * The slice is valid for use only until the next buffer modification (that\n   * is, only until the next call to a method like `read()`, `write()`,\n   * `reset()`, or `truncate()`). If `options.copy` is false the slice aliases the buffer content at\n   * least until the next buffer modification, so immediate changes to the\n   * slice will affect the result of future reads.\n   * @param options Defaults to `{ copy: true }`\n   */\n  bytes(options = { copy: true }): Uint8Array {\n    if (options.copy === false) return this.#buf.subarray(this.#off);\n    return this.#buf.slice(this.#off);\n  }\n\n  /** Returns whether the unread portion of the buffer is empty. */\n  empty(): boolean {\n    return this.#buf.byteLength <= this.#off;\n  }\n\n  /** A read only number of bytes of the unread portion of the buffer. */\n  get length(): number {\n    return this.#buf.byteLength - this.#off;\n  }\n\n  /** The read only capacity of the buffer's underlying byte slice, that is,\n   * the total space allocated for the buffer's data. */\n  get capacity(): number {\n    return this.#buf.buffer.byteLength;\n  }\n\n  /** Discards all but the first `n` unread bytes from the buffer but\n   * continues to use the same allocated storage. It throws if `n` is\n   * negative or greater than the length of the buffer. */\n  truncate(n: number): void {\n    if (n === 0) {\n      this.reset();\n      return;\n    }\n    if (n < 0 || n > this.length) {\n      throw Error(\"bytes.Buffer: truncation out of range\");\n    }\n    this.#reslice(this.#off + n);\n  }\n\n  reset(): void {\n    this.#reslice(0);\n    this.#off = 0;\n  }\n\n  #tryGrowByReslice(n: number) {\n    const l = this.#buf.byteLength;\n    if (n <= this.capacity - l) {\n      this.#reslice(l + n);\n      return l;\n    }\n    return -1;\n  }\n\n  #reslice(len: number) {\n    assert(len <= this.#buf.buffer.byteLength);\n    this.#buf = new Uint8Array(this.#buf.buffer, 0, len);\n  }\n\n  /** Reads the next `p.length` bytes from the buffer or until the buffer is\n   * drained. Returns the number of bytes read. If the buffer has no data to\n   * return, the return is EOF (`null`). */\n  readSync(p: Uint8Array): number | null {\n    if (this.empty()) {\n      // Buffer is empty, reset to recover space.\n      this.reset();\n      if (p.byteLength === 0) {\n        // this edge case is tested in 'bufferReadEmptyAtEOF' test\n        return 0;\n      }\n      return null;\n    }\n    const nread = copy(this.#buf.subarray(this.#off), p);\n    this.#off += nread;\n    return nread;\n  }\n\n  /** Reads the next `p.length` bytes from the buffer or until the buffer is\n   * drained. Resolves to the number of bytes read. If the buffer has no\n   * data to return, resolves to EOF (`null`).\n   *\n   * NOTE: This methods reads bytes synchronously; it's provided for\n   * compatibility with `Reader` interfaces.\n   */\n  read(p: Uint8Array): Promise<number | null> {\n    const rr = this.readSync(p);\n    return Promise.resolve(rr);\n  }\n\n  writeSync(p: Uint8Array): number {\n    const m = this.#grow(p.byteLength);\n    return copy(p, this.#buf, m);\n  }\n\n  /** NOTE: This methods writes bytes synchronously; it's provided for\n   * compatibility with `Writer` interface. */\n  write(p: Uint8Array): Promise<number> {\n    const n = this.writeSync(p);\n    return Promise.resolve(n);\n  }\n\n  #grow(n: number) {\n    const m = this.length;\n    // If buffer is empty, reset to recover space.\n    if (m === 0 && this.#off !== 0) {\n      this.reset();\n    }\n    // Fast: Try to grow by means of a reslice.\n    const i = this.#tryGrowByReslice(n);\n    if (i >= 0) {\n      return i;\n    }\n    const c = this.capacity;\n    if (n <= Math.floor(c / 2) - m) {\n      // We can slide things down instead of allocating a new\n      // ArrayBuffer. We only need m+n <= c to slide, but\n      // we instead let capacity get twice as large so we\n      // don't spend all our time copying.\n      copy(this.#buf.subarray(this.#off), this.#buf);\n    } else if (c + n > MAX_SIZE) {\n      throw new Error(\"The buffer cannot be grown beyond the maximum size.\");\n    } else {\n      // Not enough space anywhere, we need to allocate.\n      const buf = new Uint8Array(Math.min(2 * c + n, MAX_SIZE));\n      copy(this.#buf.subarray(this.#off), buf);\n      this.#buf = buf;\n    }\n    // Restore this.#off and len(this.#buf).\n    this.#off = 0;\n    this.#reslice(Math.min(m + n, MAX_SIZE));\n    return m;\n  }\n\n  /** Grows the buffer's capacity, if necessary, to guarantee space for\n   * another `n` bytes. After `.grow(n)`, at least `n` bytes can be written to\n   * the buffer without another allocation. If `n` is negative, `.grow()` will\n   * throw. If the buffer can't grow it will throw an error.\n   *\n   * Based on Go Lang's\n   * [Buffer.Grow](https://golang.org/pkg/bytes/#Buffer.Grow). */\n  grow(n: number): void {\n    if (n < 0) {\n      throw Error(\"Buffer.grow: negative count\");\n    }\n    const m = this.#grow(n);\n    this.#reslice(m);\n  }\n\n  /** Reads data from `r` until EOF (`null`) and appends it to the buffer,\n   * growing the buffer as needed. It resolves to the number of bytes read.\n   * If the buffer becomes too large, `.readFrom()` will reject with an error.\n   *\n   * Based on Go Lang's\n   * [Buffer.ReadFrom](https://golang.org/pkg/bytes/#Buffer.ReadFrom). */\n  async readFrom(r: Reader): Promise<number> {\n    let n = 0;\n    const tmp = new Uint8Array(MIN_READ);\n    while (true) {\n      const shouldGrow = this.capacity - this.length < MIN_READ;\n      // read into tmp buffer if there's not enough room\n      // otherwise read directly into the internal buffer\n      const buf = shouldGrow\n        ? tmp\n        : new Uint8Array(this.#buf.buffer, this.length);\n\n      const nread = await r.read(buf);\n      if (nread === null) {\n        return n;\n      }\n\n      // write will grow if needed\n      if (shouldGrow) this.writeSync(buf.subarray(0, nread));\n      else this.#reslice(this.length + nread);\n\n      n += nread;\n    }\n  }\n\n  /** Reads data from `r` until EOF (`null`) and appends it to the buffer,\n   * growing the buffer as needed. It returns the number of bytes read. If the\n   * buffer becomes too large, `.readFromSync()` will throw an error.\n   *\n   * Based on Go Lang's\n   * [Buffer.ReadFrom](https://golang.org/pkg/bytes/#Buffer.ReadFrom). */\n  readFromSync(r: ReaderSync): number {\n    let n = 0;\n    const tmp = new Uint8Array(MIN_READ);\n    while (true) {\n      const shouldGrow = this.capacity - this.length < MIN_READ;\n      // read into tmp buffer if there's not enough room\n      // otherwise read directly into the internal buffer\n      const buf = shouldGrow\n        ? tmp\n        : new Uint8Array(this.#buf.buffer, this.length);\n\n      const nread = r.readSync(buf);\n      if (nread === null) {\n        return n;\n      }\n\n      // write will grow if needed\n      if (shouldGrow) this.writeSync(buf.subarray(0, nread));\n      else this.#reslice(this.length + nread);\n\n      n += nread;\n    }\n  }\n}\n\nconst DEFAULT_BUF_SIZE = 4096;\nconst MIN_BUF_SIZE = 16;\nconst MAX_CONSECUTIVE_EMPTY_READS = 100;\nconst CR = \"\\r\".charCodeAt(0);\nconst LF = \"\\n\".charCodeAt(0);\n\nexport class BufferFullError extends Error {\n  override name = \"BufferFullError\";\n  constructor(public partial: Uint8Array) {\n    super(\"Buffer full\");\n  }\n}\n\nexport class PartialReadError extends Error {\n  override name = \"PartialReadError\";\n  partial?: Uint8Array;\n  constructor() {\n    super(\"Encountered UnexpectedEof, data only partially read\");\n  }\n}\n\n/** Result type returned by of BufReader.readLine(). */\nexport interface ReadLineResult {\n  line: Uint8Array;\n  more: boolean;\n}\n\n/** BufReader implements buffering for a Reader object. */\nexport class BufReader implements Reader {\n  #buf!: Uint8Array;\n  #rd!: Reader; // Reader provided by caller.\n  #r = 0; // buf read position.\n  #w = 0; // buf write position.\n  #eof = false;\n  // private lastByte: number;\n  // private lastCharSize: number;\n\n  /** return new BufReader unless r is BufReader */\n  static create(r: Reader, size: number = DEFAULT_BUF_SIZE): BufReader {\n    return r instanceof BufReader ? r : new BufReader(r, size);\n  }\n\n  constructor(rd: Reader, size: number = DEFAULT_BUF_SIZE) {\n    if (size < MIN_BUF_SIZE) {\n      size = MIN_BUF_SIZE;\n    }\n    this.#reset(new Uint8Array(size), rd);\n  }\n\n  /** Returns the size of the underlying buffer in bytes. */\n  size(): number {\n    return this.#buf.byteLength;\n  }\n\n  buffered(): number {\n    return this.#w - this.#r;\n  }\n\n  // Reads a new chunk into the buffer.\n  #fill = async () => {\n    // Slide existing data to beginning.\n    if (this.#r > 0) {\n      this.#buf.copyWithin(0, this.#r, this.#w);\n      this.#w -= this.#r;\n      this.#r = 0;\n    }\n\n    if (this.#w >= this.#buf.byteLength) {\n      throw Error(\"bufio: tried to fill full buffer\");\n    }\n\n    // Read new data: try a limited number of times.\n    for (let i = MAX_CONSECUTIVE_EMPTY_READS; i > 0; i--) {\n      const rr = await this.#rd.read(this.#buf.subarray(this.#w));\n      if (rr === null) {\n        this.#eof = true;\n        return;\n      }\n      assert(rr >= 0, \"negative read\");\n      this.#w += rr;\n      if (rr > 0) {\n        return;\n      }\n    }\n\n    throw new Error(\n      `No progress after ${MAX_CONSECUTIVE_EMPTY_READS} read() calls`,\n    );\n  };\n\n  /** Discards any buffered data, resets all state, and switches\n   * the buffered reader to read from r.\n   */\n  reset(r: Reader): void {\n    this.#reset(this.#buf, r);\n  }\n\n  #reset = (buf: Uint8Array, rd: Reader): void => {\n    this.#buf = buf;\n    this.#rd = rd;\n    this.#eof = false;\n    // this.lastByte = -1;\n    // this.lastCharSize = -1;\n  };\n\n  /** reads data into p.\n   * It returns the number of bytes read into p.\n   * The bytes are taken from at most one Read on the underlying Reader,\n   * hence n may be less than len(p).\n   * To read exactly len(p) bytes, use io.ReadFull(b, p).\n   */\n  async read(p: Uint8Array): Promise<number | null> {\n    let rr: number | null = p.byteLength;\n    if (p.byteLength === 0) return rr;\n\n    if (this.#r === this.#w) {\n      if (p.byteLength >= this.#buf.byteLength) {\n        // Large read, empty buffer.\n        // Read directly into p to avoid copy.\n        const rr = await this.#rd.read(p);\n        const nread = rr ?? 0;\n        assert(nread >= 0, \"negative read\");\n        // if (rr.nread > 0) {\n        //   this.lastByte = p[rr.nread - 1];\n        //   this.lastCharSize = -1;\n        // }\n        return rr;\n      }\n\n      // One read.\n      // Do not use this.fill, which will loop.\n      this.#r = 0;\n      this.#w = 0;\n      rr = await this.#rd.read(this.#buf);\n      if (rr === 0 || rr === null) return rr;\n      assert(rr >= 0, \"negative read\");\n      this.#w += rr;\n    }\n\n    // copy as much as we can\n    const copied = copy(this.#buf.subarray(this.#r, this.#w), p, 0);\n    this.#r += copied;\n    // this.lastByte = this.buf[this.r - 1];\n    // this.lastCharSize = -1;\n    return copied;\n  }\n\n  /** reads exactly `p.length` bytes into `p`.\n   *\n   * If successful, `p` is returned.\n   *\n   * If the end of the underlying stream has been reached, and there are no more\n   * bytes available in the buffer, `readFull()` returns `null` instead.\n   *\n   * An error is thrown if some bytes could be read, but not enough to fill `p`\n   * entirely before the underlying stream reported an error or EOF. Any error\n   * thrown will have a `partial` property that indicates the slice of the\n   * buffer that has been successfully filled with data.\n   *\n   * Ported from https://golang.org/pkg/io/#ReadFull\n   */\n  async readFull(p: Uint8Array): Promise<Uint8Array | null> {\n    let bytesRead = 0;\n    while (bytesRead < p.length) {\n      try {\n        const rr = await this.read(p.subarray(bytesRead));\n        if (rr === null) {\n          if (bytesRead === 0) {\n            return null;\n          } else {\n            throw new PartialReadError();\n          }\n        }\n        bytesRead += rr;\n      } catch (err) {\n        if (err instanceof PartialReadError) {\n          err.partial = p.subarray(0, bytesRead);\n        } else if (err instanceof Error) {\n          const e = new PartialReadError();\n          e.partial = p.subarray(0, bytesRead);\n          e.stack = err.stack;\n          e.message = err.message;\n          e.cause = err.cause;\n          throw err;\n        }\n        throw err;\n      }\n    }\n    return p;\n  }\n\n  /** Returns the next byte [0, 255] or `null`. */\n  async readByte(): Promise<number | null> {\n    while (this.#r === this.#w) {\n      if (this.#eof) return null;\n      await this.#fill(); // buffer is empty.\n    }\n    const c = this.#buf[this.#r];\n    this.#r++;\n    // this.lastByte = c;\n    return c;\n  }\n\n  /** readString() reads until the first occurrence of delim in the input,\n   * returning a string containing the data up to and including the delimiter.\n   * If ReadString encounters an error before finding a delimiter,\n   * it returns the data read before the error and the error itself\n   * (often `null`).\n   * ReadString returns err != nil if and only if the returned data does not end\n   * in delim.\n   * For simple uses, a Scanner may be more convenient.\n   */\n  async readString(delim: string): Promise<string | null> {\n    if (delim.length !== 1) {\n      throw new Error(\"Delimiter should be a single character\");\n    }\n    const buffer = await this.readSlice(delim.charCodeAt(0));\n    if (buffer === null) return null;\n    return new TextDecoder().decode(buffer);\n  }\n\n  /** `readLine()` is a low-level line-reading primitive. Most callers should\n   * use `readString('\\n')` instead or use a Scanner.\n   *\n   * `readLine()` tries to return a single line, not including the end-of-line\n   * bytes. If the line was too long for the buffer then `more` is set and the\n   * beginning of the line is returned. The rest of the line will be returned\n   * from future calls. `more` will be false when returning the last fragment\n   * of the line. The returned buffer is only valid until the next call to\n   * `readLine()`.\n   *\n   * The text returned from ReadLine does not include the line end (\"\\r\\n\" or\n   * \"\\n\").\n   *\n   * When the end of the underlying stream is reached, the final bytes in the\n   * stream are returned. No indication or error is given if the input ends\n   * without a final line end. When there are no more trailing bytes to read,\n   * `readLine()` returns `null`.\n   *\n   * Calling `unreadByte()` after `readLine()` will always unread the last byte\n   * read (possibly a character belonging to the line end) even if that byte is\n   * not part of the line returned by `readLine()`.\n   */\n  async readLine(): Promise<ReadLineResult | null> {\n    let line: Uint8Array | null = null;\n\n    try {\n      line = await this.readSlice(LF);\n    } catch (err) {\n      if (err instanceof Deno.errors.BadResource) {\n        throw err;\n      }\n      let partial;\n      if (err instanceof PartialReadError) {\n        partial = err.partial;\n        assert(\n          partial instanceof Uint8Array,\n          \"bufio: caught error from `readSlice()` without `partial` property\",\n        );\n      }\n\n      // Don't throw if `readSlice()` failed with `BufferFullError`, instead we\n      // just return whatever is available and set the `more` flag.\n      if (!(err instanceof BufferFullError)) {\n        throw err;\n      }\n\n      partial = err.partial;\n\n      // Handle the case where \"\\r\\n\" straddles the buffer.\n      if (\n        !this.#eof && partial &&\n        partial.byteLength > 0 &&\n        partial[partial.byteLength - 1] === CR\n      ) {\n        // Put the '\\r' back on buf and drop it from line.\n        // Let the next call to ReadLine check for \"\\r\\n\".\n        assert(this.#r > 0, \"bufio: tried to rewind past start of buffer\");\n        this.#r--;\n        partial = partial.subarray(0, partial.byteLength - 1);\n      }\n\n      if (partial) {\n        return { line: partial, more: !this.#eof };\n      }\n    }\n\n    if (line === null) {\n      return null;\n    }\n\n    if (line.byteLength === 0) {\n      return { line, more: false };\n    }\n\n    if (line[line.byteLength - 1] == LF) {\n      let drop = 1;\n      if (line.byteLength > 1 && line[line.byteLength - 2] === CR) {\n        drop = 2;\n      }\n      line = line.subarray(0, line.byteLength - drop);\n    }\n    return { line, more: false };\n  }\n\n  /** `readSlice()` reads until the first occurrence of `delim` in the input,\n   * returning a slice pointing at the bytes in the buffer. The bytes stop\n   * being valid at the next read.\n   *\n   * If `readSlice()` encounters an error before finding a delimiter, or the\n   * buffer fills without finding a delimiter, it throws an error with a\n   * `partial` property that contains the entire buffer.\n   *\n   * If `readSlice()` encounters the end of the underlying stream and there are\n   * any bytes left in the buffer, the rest of the buffer is returned. In other\n   * words, EOF is always treated as a delimiter. Once the buffer is empty,\n   * it returns `null`.\n   *\n   * Because the data returned from `readSlice()` will be overwritten by the\n   * next I/O operation, most clients should use `readString()` instead.\n   */\n  async readSlice(delim: number): Promise<Uint8Array | null> {\n    let s = 0; // search start index\n    let slice: Uint8Array | undefined;\n\n    while (true) {\n      // Search buffer.\n      let i = this.#buf.subarray(this.#r + s, this.#w).indexOf(delim);\n      if (i >= 0) {\n        i += s;\n        slice = this.#buf.subarray(this.#r, this.#r + i + 1);\n        this.#r += i + 1;\n        break;\n      }\n\n      // EOF?\n      if (this.#eof) {\n        if (this.#r === this.#w) {\n          return null;\n        }\n        slice = this.#buf.subarray(this.#r, this.#w);\n        this.#r = this.#w;\n        break;\n      }\n\n      // Buffer full?\n      if (this.buffered() >= this.#buf.byteLength) {\n        this.#r = this.#w;\n        // #4521 The internal buffer should not be reused across reads because it causes corruption of data.\n        const oldbuf = this.#buf;\n        const newbuf = this.#buf.slice(0);\n        this.#buf = newbuf;\n        throw new BufferFullError(oldbuf);\n      }\n\n      s = this.#w - this.#r; // do not rescan area we scanned before\n\n      // Buffer is not full.\n      try {\n        await this.#fill();\n      } catch (err) {\n        if (err instanceof PartialReadError) {\n          err.partial = slice;\n        } else if (err instanceof Error) {\n          const e = new PartialReadError();\n          e.partial = slice;\n          e.stack = err.stack;\n          e.message = err.message;\n          e.cause = err.cause;\n          throw err;\n        }\n        throw err;\n      }\n    }\n\n    // Handle last byte, if any.\n    // const i = slice.byteLength - 1;\n    // if (i >= 0) {\n    //   this.lastByte = slice[i];\n    //   this.lastCharSize = -1\n    // }\n\n    return slice;\n  }\n\n  /** `peek()` returns the next `n` bytes without advancing the reader. The\n   * bytes stop being valid at the next read call.\n   *\n   * When the end of the underlying stream is reached, but there are unread\n   * bytes left in the buffer, those bytes are returned. If there are no bytes\n   * left in the buffer, it returns `null`.\n   *\n   * If an error is encountered before `n` bytes are available, `peek()` throws\n   * an error with the `partial` property set to a slice of the buffer that\n   * contains the bytes that were available before the error occurred.\n   */\n  async peek(n: number): Promise<Uint8Array | null> {\n    if (n < 0) {\n      throw Error(\"negative count\");\n    }\n\n    let avail = this.#w - this.#r;\n    while (avail < n && avail < this.#buf.byteLength && !this.#eof) {\n      try {\n        await this.#fill();\n      } catch (err) {\n        if (err instanceof PartialReadError) {\n          err.partial = this.#buf.subarray(this.#r, this.#w);\n        } else if (err instanceof Error) {\n          const e = new PartialReadError();\n          e.partial = this.#buf.subarray(this.#r, this.#w);\n          e.stack = err.stack;\n          e.message = err.message;\n          e.cause = err.cause;\n          throw err;\n        }\n        throw err;\n      }\n      avail = this.#w - this.#r;\n    }\n\n    if (avail === 0 && this.#eof) {\n      return null;\n    } else if (avail < n && this.#eof) {\n      return this.#buf.subarray(this.#r, this.#r + avail);\n    } else if (avail < n) {\n      throw new BufferFullError(this.#buf.subarray(this.#r, this.#w));\n    }\n\n    return this.#buf.subarray(this.#r, this.#r + n);\n  }\n}\n\nabstract class AbstractBufBase {\n  buf: Uint8Array;\n  usedBufferBytes = 0;\n  err: Error | null = null;\n\n  constructor(buf: Uint8Array) {\n    this.buf = buf;\n  }\n\n  /** Size returns the size of the underlying buffer in bytes. */\n  size(): number {\n    return this.buf.byteLength;\n  }\n\n  /** Returns how many bytes are unused in the buffer. */\n  available(): number {\n    return this.buf.byteLength - this.usedBufferBytes;\n  }\n\n  /** buffered returns the number of bytes that have been written into the\n   * current buffer.\n   */\n  buffered(): number {\n    return this.usedBufferBytes;\n  }\n}\n\n/** BufWriter implements buffering for an deno.Writer object.\n * If an error occurs writing to a Writer, no more data will be\n * accepted and all subsequent writes, and flush(), will return the error.\n * After all data has been written, the client should call the\n * flush() method to guarantee all data has been forwarded to\n * the underlying deno.Writer.\n */\nexport class BufWriter extends AbstractBufBase implements Writer {\n  #writer: Writer;\n\n  /** return new BufWriter unless writer is BufWriter */\n  static create(writer: Writer, size: number = DEFAULT_BUF_SIZE): BufWriter {\n    return writer instanceof BufWriter ? writer : new BufWriter(writer, size);\n  }\n\n  constructor(writer: Writer, size: number = DEFAULT_BUF_SIZE) {\n    super(new Uint8Array(size <= 0 ? DEFAULT_BUF_SIZE : size));\n    this.#writer = writer;\n  }\n\n  /** Discards any unflushed buffered data, clears any error, and\n   * resets buffer to write its output to w.\n   */\n  reset(w: Writer): void {\n    this.err = null;\n    this.usedBufferBytes = 0;\n    this.#writer = w;\n  }\n\n  /** Flush writes any buffered data to the underlying io.Writer. */\n  async flush() {\n    if (this.err !== null) throw this.err;\n    if (this.usedBufferBytes === 0) return;\n\n    try {\n      const p = this.buf.subarray(0, this.usedBufferBytes);\n      let nwritten = 0;\n      while (nwritten < p.length) {\n        nwritten += await this.#writer.write(p.subarray(nwritten));\n      }\n    } catch (e) {\n      if (e instanceof Error) {\n        this.err = e;\n      }\n      throw e;\n    }\n\n    this.buf = new Uint8Array(this.buf.length);\n    this.usedBufferBytes = 0;\n  }\n\n  /** Writes the contents of `data` into the buffer.  If the contents won't fully\n   * fit into the buffer, those bytes that can are copied into the buffer, the\n   * buffer is the flushed to the writer and the remaining bytes are copied into\n   * the now empty buffer.\n   *\n   * @return the number of bytes written to the buffer.\n   */\n  async write(data: Uint8Array): Promise<number> {\n    if (this.err !== null) throw this.err;\n    if (data.length === 0) return 0;\n\n    let totalBytesWritten = 0;\n    let numBytesWritten = 0;\n    while (data.byteLength > this.available()) {\n      if (this.buffered() === 0) {\n        // Large write, empty buffer.\n        // Write directly from data to avoid copy.\n        try {\n          numBytesWritten = await this.#writer.write(data);\n        } catch (e) {\n          if (e instanceof Error) {\n            this.err = e;\n          }\n          throw e;\n        }\n      } else {\n        numBytesWritten = copy(data, this.buf, this.usedBufferBytes);\n        this.usedBufferBytes += numBytesWritten;\n        await this.flush();\n      }\n      totalBytesWritten += numBytesWritten;\n      data = data.subarray(numBytesWritten);\n    }\n\n    numBytesWritten = copy(data, this.buf, this.usedBufferBytes);\n    this.usedBufferBytes += numBytesWritten;\n    totalBytesWritten += numBytesWritten;\n    return totalBytesWritten;\n  }\n}\n\n/** BufWriterSync implements buffering for a deno.WriterSync object.\n * If an error occurs writing to a WriterSync, no more data will be\n * accepted and all subsequent writes, and flush(), will return the error.\n * After all data has been written, the client should call the\n * flush() method to guarantee all data has been forwarded to\n * the underlying deno.WriterSync.\n */\nexport class BufWriterSync extends AbstractBufBase implements WriterSync {\n  #writer: WriterSync;\n\n  /** return new BufWriterSync unless writer is BufWriterSync */\n  static create(\n    writer: WriterSync,\n    size: number = DEFAULT_BUF_SIZE,\n  ): BufWriterSync {\n    return writer instanceof BufWriterSync\n      ? writer\n      : new BufWriterSync(writer, size);\n  }\n\n  constructor(writer: WriterSync, size: number = DEFAULT_BUF_SIZE) {\n    super(new Uint8Array(size <= 0 ? DEFAULT_BUF_SIZE : size));\n    this.#writer = writer;\n  }\n\n  /** Discards any unflushed buffered data, clears any error, and\n   * resets buffer to write its output to w.\n   */\n  reset(w: WriterSync): void {\n    this.err = null;\n    this.usedBufferBytes = 0;\n    this.#writer = w;\n  }\n\n  /** Flush writes any buffered data to the underlying io.WriterSync. */\n  flush(): void {\n    if (this.err !== null) throw this.err;\n    if (this.usedBufferBytes === 0) return;\n\n    try {\n      const p = this.buf.subarray(0, this.usedBufferBytes);\n      let nwritten = 0;\n      while (nwritten < p.length) {\n        nwritten += this.#writer.writeSync(p.subarray(nwritten));\n      }\n    } catch (e) {\n      if (e instanceof Error) {\n        this.err = e;\n      }\n      throw e;\n    }\n\n    this.buf = new Uint8Array(this.buf.length);\n    this.usedBufferBytes = 0;\n  }\n\n  /** Writes the contents of `data` into the buffer.  If the contents won't fully\n   * fit into the buffer, those bytes that can are copied into the buffer, the\n   * buffer is the flushed to the writer and the remaining bytes are copied into\n   * the now empty buffer.\n   *\n   * @return the number of bytes written to the buffer.\n   */\n  writeSync(data: Uint8Array): number {\n    if (this.err !== null) throw this.err;\n    if (data.length === 0) return 0;\n\n    let totalBytesWritten = 0;\n    let numBytesWritten = 0;\n    while (data.byteLength > this.available()) {\n      if (this.buffered() === 0) {\n        // Large write, empty buffer.\n        // Write directly from data to avoid copy.\n        try {\n          numBytesWritten = this.#writer.writeSync(data);\n        } catch (e) {\n          if (e instanceof Error) {\n            this.err = e;\n          }\n          throw e;\n        }\n      } else {\n        numBytesWritten = copy(data, this.buf, this.usedBufferBytes);\n        this.usedBufferBytes += numBytesWritten;\n        this.flush();\n      }\n      totalBytesWritten += numBytesWritten;\n      data = data.subarray(numBytesWritten);\n    }\n\n    numBytesWritten = copy(data, this.buf, this.usedBufferBytes);\n    this.usedBufferBytes += numBytesWritten;\n    totalBytesWritten += numBytesWritten;\n    return totalBytesWritten;\n  }\n}\n\n/** Generate longest proper prefix which is also suffix array. */\nfunction createLPS(pat: Uint8Array): Uint8Array {\n  const lps = new Uint8Array(pat.length);\n  lps[0] = 0;\n  let prefixEnd = 0;\n  let i = 1;\n  while (i < lps.length) {\n    if (pat[i] == pat[prefixEnd]) {\n      prefixEnd++;\n      lps[i] = prefixEnd;\n      i++;\n    } else if (prefixEnd === 0) {\n      lps[i] = 0;\n      i++;\n    } else {\n      prefixEnd = lps[prefixEnd - 1];\n    }\n  }\n  return lps;\n}\n\n/** Read delimited bytes from a Reader. */\nexport async function* readDelim(\n  reader: Reader,\n  delim: Uint8Array,\n): AsyncIterableIterator<Uint8Array> {\n  // Avoid unicode problems\n  const delimLen = delim.length;\n  const delimLPS = createLPS(delim);\n  const chunks = new BytesList();\n  const bufSize = Math.max(1024, delimLen + 1);\n\n  // Modified KMP\n  let inspectIndex = 0;\n  let matchIndex = 0;\n  while (true) {\n    const inspectArr = new Uint8Array(bufSize);\n    const result = await reader.read(inspectArr);\n    if (result === null) {\n      // Yield last chunk.\n      yield chunks.concat();\n      return;\n    } else if (result < 0) {\n      // Discard all remaining and silently fail.\n      return;\n    }\n    chunks.add(inspectArr, 0, result);\n    let localIndex = 0;\n    while (inspectIndex < chunks.size()) {\n      if (inspectArr[localIndex] === delim[matchIndex]) {\n        inspectIndex++;\n        localIndex++;\n        matchIndex++;\n        if (matchIndex === delimLen) {\n          // Full match\n          const matchEnd = inspectIndex - delimLen;\n          const readyBytes = chunks.slice(0, matchEnd);\n          yield readyBytes;\n          // Reset match, different from KMP.\n          chunks.shift(inspectIndex);\n          inspectIndex = 0;\n          matchIndex = 0;\n        }\n      } else {\n        if (matchIndex === 0) {\n          inspectIndex++;\n          localIndex++;\n        } else {\n          matchIndex = delimLPS[matchIndex - 1];\n        }\n      }\n    }\n  }\n}\n\n/** Read delimited strings from a Reader. */\nexport async function* readStringDelim(\n  reader: Reader,\n  delim: string,\n  decoderOpts?: {\n    encoding?: string;\n    fatal?: boolean;\n    ignoreBOM?: boolean;\n  },\n): AsyncIterableIterator<string> {\n  const encoder = new TextEncoder();\n  const decoder = new TextDecoder(decoderOpts?.encoding, decoderOpts);\n  for await (const chunk of readDelim(reader, encoder.encode(delim))) {\n    yield decoder.decode(chunk);\n  }\n}\n\n/** Read strings line-by-line from a Reader. */\nexport async function* readLines(\n  reader: Reader,\n  decoderOpts?: {\n    encoding?: string;\n    fatal?: boolean;\n    ignoreBOM?: boolean;\n  },\n): AsyncIterableIterator<string> {\n  const bufReader = new BufReader(reader);\n  let chunks: Uint8Array[] = [];\n  const decoder = new TextDecoder(decoderOpts?.encoding, decoderOpts);\n  while (true) {\n    const res = await bufReader.readLine();\n    if (!res) {\n      if (chunks.length > 0) {\n        yield decoder.decode(concat(...chunks));\n      }\n      break;\n    }\n    chunks.push(res.line);\n    if (!res.more) {\n      yield decoder.decode(concat(...chunks));\n      chunks = [];\n    }\n  }\n}\n"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/tests/__snapshots__/transpile/url/modules/p5wE1hCF6dGYMZ41YnIQs2go2is.js b/tests/__snapshots__/transpile/url/modules/p5wE1hCF6dGYMZ41YnIQs2go2is.js new file mode 100644 index 0000000..d414e93 --- /dev/null +++ b/tests/__snapshots__/transpile/url/modules/p5wE1hCF6dGYMZ41YnIQs2go2is.js @@ -0,0 +1,140 @@ +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. +/** + * An abstraction of multiple Uint8Arrays + */ export class BytesList { + len = 0; + chunks = []; + constructor(){} + /** + * Total size of bytes + */ size() { + return this.len; + } + /** + * Push bytes with given offset infos + */ add(value, start = 0, end = value.byteLength) { + if (value.byteLength === 0 || end - start === 0) { + return; + } + checkRange(start, end, value.byteLength); + this.chunks.push({ + value, + end, + start, + offset: this.len + }); + this.len += end - start; + } + /** + * Drop head `n` bytes. + */ shift(n) { + if (n === 0) { + return; + } + if (this.len <= n) { + this.chunks = []; + this.len = 0; + return; + } + const idx = this.getChunkIndex(n); + this.chunks.splice(0, idx); + const [chunk] = this.chunks; + if (chunk) { + const diff = n - chunk.offset; + chunk.start += diff; + } + let offset = 0; + for (const chunk of this.chunks){ + chunk.offset = offset; + offset += chunk.end - chunk.start; + } + this.len = offset; + } + /** + * Find chunk index in which `pos` locates by binary-search + * returns -1 if out of range + */ getChunkIndex(pos) { + let max = this.chunks.length; + let min = 0; + while(true){ + const i = min + Math.floor((max - min) / 2); + if (i < 0 || this.chunks.length <= i) { + return -1; + } + const { offset , start , end } = this.chunks[i]; + const len = end - start; + if (offset <= pos && pos < offset + len) { + return i; + } else if (offset + len <= pos) { + min = i + 1; + } else { + max = i - 1; + } + } + } + /** + * Get indexed byte from chunks + */ get(i) { + if (i < 0 || this.len <= i) { + throw new Error("out of range"); + } + const idx = this.getChunkIndex(i); + const { value , offset , start } = this.chunks[idx]; + return value[start + i - offset]; + } + /** + * Iterator of bytes from given position + */ *iterator(start = 0) { + const startIdx = this.getChunkIndex(start); + if (startIdx < 0) return; + const first = this.chunks[startIdx]; + let firstOffset = start - first.offset; + for(let i = startIdx; i < this.chunks.length; i++){ + const chunk = this.chunks[i]; + for(let j = chunk.start + firstOffset; j < chunk.end; j++){ + yield chunk.value[j]; + } + firstOffset = 0; + } + } + /** + * Returns subset of bytes copied + */ slice(start, end = this.len) { + if (end === start) { + return new Uint8Array(); + } + checkRange(start, end, this.len); + const result = new Uint8Array(end - start); + const startIdx = this.getChunkIndex(start); + const endIdx = this.getChunkIndex(end - 1); + let written = 0; + for(let i = startIdx; i < endIdx; i++){ + const chunk = this.chunks[i]; + const len = chunk.end - chunk.start; + result.set(chunk.value.subarray(chunk.start, chunk.end), written); + written += len; + } + const last = this.chunks[endIdx]; + const rest = end - start - written; + result.set(last.value.subarray(last.start, last.start + rest), written); + return result; + } + /** + * Concatenate chunks into single Uint8Array copied. + */ concat() { + const result = new Uint8Array(this.len); + let sum = 0; + for (const { value , start , end } of this.chunks){ + result.set(value.subarray(start, end), sum); + sum += end - start; + } + return result; + } +} +function checkRange(start, end, len) { + if (start < 0 || len < start || end < 0 || len < end || end < start) { + throw new Error("invalid range"); + } +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["https://deno.land/std@0.140.0/bytes/bytes_list.ts"],"sourcesContent":["// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.\n// This module is browser compatible.\n\n/**\n * An abstraction of multiple Uint8Arrays\n */\nexport class BytesList {\n  private len = 0;\n  private chunks: {\n    value: Uint8Array;\n    start: number; // start offset from head of chunk\n    end: number; // end offset from head of chunk\n    offset: number; // offset of head in all bytes\n  }[] = [];\n  constructor() {}\n\n  /**\n   * Total size of bytes\n   */\n  size() {\n    return this.len;\n  }\n  /**\n   * Push bytes with given offset infos\n   */\n  add(value: Uint8Array, start = 0, end = value.byteLength) {\n    if (value.byteLength === 0 || end - start === 0) {\n      return;\n    }\n    checkRange(start, end, value.byteLength);\n    this.chunks.push({\n      value,\n      end,\n      start,\n      offset: this.len,\n    });\n    this.len += end - start;\n  }\n\n  /**\n   * Drop head `n` bytes.\n   */\n  shift(n: number) {\n    if (n === 0) {\n      return;\n    }\n    if (this.len <= n) {\n      this.chunks = [];\n      this.len = 0;\n      return;\n    }\n    const idx = this.getChunkIndex(n);\n    this.chunks.splice(0, idx);\n    const [chunk] = this.chunks;\n    if (chunk) {\n      const diff = n - chunk.offset;\n      chunk.start += diff;\n    }\n    let offset = 0;\n    for (const chunk of this.chunks) {\n      chunk.offset = offset;\n      offset += chunk.end - chunk.start;\n    }\n    this.len = offset;\n  }\n\n  /**\n   * Find chunk index in which `pos` locates by binary-search\n   * returns -1 if out of range\n   */\n  getChunkIndex(pos: number): number {\n    let max = this.chunks.length;\n    let min = 0;\n    while (true) {\n      const i = min + Math.floor((max - min) / 2);\n      if (i < 0 || this.chunks.length <= i) {\n        return -1;\n      }\n      const { offset, start, end } = this.chunks[i];\n      const len = end - start;\n      if (offset <= pos && pos < offset + len) {\n        return i;\n      } else if (offset + len <= pos) {\n        min = i + 1;\n      } else {\n        max = i - 1;\n      }\n    }\n  }\n\n  /**\n   * Get indexed byte from chunks\n   */\n  get(i: number): number {\n    if (i < 0 || this.len <= i) {\n      throw new Error(\"out of range\");\n    }\n    const idx = this.getChunkIndex(i);\n    const { value, offset, start } = this.chunks[idx];\n    return value[start + i - offset];\n  }\n\n  /**\n   * Iterator of bytes from given position\n   */\n  *iterator(start = 0): IterableIterator<number> {\n    const startIdx = this.getChunkIndex(start);\n    if (startIdx < 0) return;\n    const first = this.chunks[startIdx];\n    let firstOffset = start - first.offset;\n    for (let i = startIdx; i < this.chunks.length; i++) {\n      const chunk = this.chunks[i];\n      for (let j = chunk.start + firstOffset; j < chunk.end; j++) {\n        yield chunk.value[j];\n      }\n      firstOffset = 0;\n    }\n  }\n\n  /**\n   * Returns subset of bytes copied\n   */\n  slice(start: number, end: number = this.len): Uint8Array {\n    if (end === start) {\n      return new Uint8Array();\n    }\n    checkRange(start, end, this.len);\n    const result = new Uint8Array(end - start);\n    const startIdx = this.getChunkIndex(start);\n    const endIdx = this.getChunkIndex(end - 1);\n    let written = 0;\n    for (let i = startIdx; i < endIdx; i++) {\n      const chunk = this.chunks[i];\n      const len = chunk.end - chunk.start;\n      result.set(chunk.value.subarray(chunk.start, chunk.end), written);\n      written += len;\n    }\n    const last = this.chunks[endIdx];\n    const rest = end - start - written;\n    result.set(last.value.subarray(last.start, last.start + rest), written);\n    return result;\n  }\n  /**\n   * Concatenate chunks into single Uint8Array copied.\n   */\n  concat(): Uint8Array {\n    const result = new Uint8Array(this.len);\n    let sum = 0;\n    for (const { value, start, end } of this.chunks) {\n      result.set(value.subarray(start, end), sum);\n      sum += end - start;\n    }\n    return result;\n  }\n}\n\nfunction checkRange(start: number, end: number, len: number) {\n  if (start < 0 || len < start || end < 0 || len < end || end < start) {\n    throw new Error(\"invalid range\");\n  }\n}\n"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/tests/__snapshots__/transpile/url/modules/wme9EIsCB7sfOz5qC_CSLRYajRk.js b/tests/__snapshots__/transpile/url/modules/wme9EIsCB7sfOz5qC_CSLRYajRk.js new file mode 100644 index 0000000..e057dad --- /dev/null +++ b/tests/__snapshots__/transpile/url/modules/wme9EIsCB7sfOz5qC_CSLRYajRk.js @@ -0,0 +1,5 @@ +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +// This module is browser compatible. +/** + * A parsed path object generated by path.parse() or consumed by path.format(). + */ //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImh0dHBzOi8vZGVuby5sYW5kL3N0ZEAwLjE0MC4wL3BhdGgvX2ludGVyZmFjZS50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAxOC0yMDIyIHRoZSBEZW5vIGF1dGhvcnMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuIE1JVCBsaWNlbnNlLlxuLy8gVGhpcyBtb2R1bGUgaXMgYnJvd3NlciBjb21wYXRpYmxlLlxuXG4vKipcbiAqIEEgcGFyc2VkIHBhdGggb2JqZWN0IGdlbmVyYXRlZCBieSBwYXRoLnBhcnNlKCkgb3IgY29uc3VtZWQgYnkgcGF0aC5mb3JtYXQoKS5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBQYXJzZWRQYXRoIHtcbiAgLyoqXG4gICAqIFRoZSByb290IG9mIHRoZSBwYXRoIHN1Y2ggYXMgJy8nIG9yICdjOlxcJ1xuICAgKi9cbiAgcm9vdDogc3RyaW5nO1xuICAvKipcbiAgICogVGhlIGZ1bGwgZGlyZWN0b3J5IHBhdGggc3VjaCBhcyAnL2hvbWUvdXNlci9kaXInIG9yICdjOlxccGF0aFxcZGlyJ1xuICAgKi9cbiAgZGlyOiBzdHJpbmc7XG4gIC8qKlxuICAgKiBUaGUgZmlsZSBuYW1lIGluY2x1ZGluZyBleHRlbnNpb24gKGlmIGFueSkgc3VjaCBhcyAnaW5kZXguaHRtbCdcbiAgICovXG4gIGJhc2U6IHN0cmluZztcbiAgLyoqXG4gICAqIFRoZSBmaWxlIGV4dGVuc2lvbiAoaWYgYW55KSBzdWNoIGFzICcuaHRtbCdcbiAgICovXG4gIGV4dDogc3RyaW5nO1xuICAvKipcbiAgICogVGhlIGZpbGUgbmFtZSB3aXRob3V0IGV4dGVuc2lvbiAoaWYgYW55KSBzdWNoIGFzICdpbmRleCdcbiAgICovXG4gIG5hbWU6IHN0cmluZztcbn1cblxuZXhwb3J0IHR5cGUgRm9ybWF0SW5wdXRQYXRoT2JqZWN0ID0gUGFydGlhbDxQYXJzZWRQYXRoPjtcbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwwRUFBMEU7QUFDMUUscUNBQXFDO0FBRXJDOztDQUVDLEdBQ0QifQ== \ No newline at end of file diff --git a/tests/bundle_test.ts b/tests/bundle_test.ts new file mode 100644 index 0000000..00b2c38 --- /dev/null +++ b/tests/bundle_test.ts @@ -0,0 +1,55 @@ +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +import { assertStringIncludes } from "https://deno.land/std@0.182.0/testing/asserts.ts"; +import { resolveFixture, testBundle } from "./utils.ts"; + +// FIXME: This repeats the test below. Consider supporting URLs without wrapping +// in a URL object. +Deno.test({ + name: "remote", + fn: testBundle( + new URL("https://deno.land/std@0.140.0/examples/chat/server.ts"), + ), +}); + +Deno.test({ + name: "url", + fn: testBundle( + new URL("https://deno.land/std@0.140.0/examples/chat/server.ts"), + ), +}); + +Deno.test({ + name: "relative", + fn: testBundle("./testdata/mod.ts"), +}); + +Deno.test({ + name: "absolute", + fn: testBundle(resolveFixture("mod.ts")), +}); + +Deno.test({ + name: "source", + fn: testBundle(new URL("file:///src.ts"), { + async load(specifier) { + if (specifier !== "file:///src.ts") return undefined; + const content = await Deno.readTextFile(resolveFixture("mod.ts")); + return { kind: "module", specifier, content }; + }, + }), +}); + +Deno.test({ + name: "json escapes", + fn: testBundle(resolveFixture("escape.ts"), undefined, ({ result }) => { + // This is done on purpose, as `String.raw` still performs a string interpolation, + // and we want a literal value ${jsInterpolation" as is, without any modifications. + // We should not need to escape `$` nor `{` as they are both JSON-safe characters. + const jsInterpolation = "${jsInterpolation}"; + assertStringIncludes( + result.code, + String + .raw`const __default = JSON.parse("{\n \"key\": \"a value with newline\\n, \\\"double quotes\\\", 'single quotes', and ${jsInterpolation}\"\n}");`, + ); + }), +}); diff --git a/tests/transpile_test.ts b/tests/transpile_test.ts new file mode 100644 index 0000000..7a59ab4 --- /dev/null +++ b/tests/transpile_test.ts @@ -0,0 +1,39 @@ +// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license. +import { resolveFixture, testTranspile } from "./utils.ts"; + +// FIXME: This repeats the test below. Consider supporting URLs without wrapping +// in a URL object. +Deno.test({ + name: "remote", + fn: testTranspile( + new URL("https://deno.land/std@0.140.0/examples/chat/server.ts"), + ), +}); + +Deno.test({ + name: "url", + fn: testTranspile( + new URL("https://deno.land/std@0.140.0/examples/chat/server.ts"), + ), +}); + +Deno.test({ + name: "relative", + fn: testTranspile("./testdata/mod.ts"), +}); + +Deno.test({ + name: "absolute", + fn: testTranspile(resolveFixture("mod.ts")), +}); + +Deno.test({ + name: "source", + fn: testTranspile(new URL("file:///src.ts"), { + async load(specifier) { + if (specifier !== "file:///src.ts") return undefined; + const content = await Deno.readTextFile(resolveFixture("mod.ts")); + return { kind: "module", specifier, content }; + }, + }), +}); diff --git a/tests/utils.ts b/tests/utils.ts new file mode 100644 index 0000000..2162390 --- /dev/null +++ b/tests/utils.ts @@ -0,0 +1,379 @@ +import { + fromFileUrl, + parse, + relative, + resolve, + SEP, + toFileUrl, +} from "https://deno.land/std@0.182.0/path/mod.ts"; +import { + ensureFile, + existsSync, +} from "https://deno.land/std@0.182.0/fs/mod.ts"; +import { AssertionError } from "https://deno.land/std@0.182.0/testing/asserts.ts"; +import { + buildMessage, + diffstr, +} from "https://deno.land/std@0.182.0/testing/_diff.ts"; +import { bundle, type BundleOptions, emit, type EmitOptions } from "../mod.ts"; +import * as base64Url from "https://deno.land/std@0.182.0/encoding/base64url.ts"; +import * as base64 from "https://deno.land/std@0.182.0/encoding/base64.ts"; + +const textEncoder = new TextEncoder(); +const textDecoder = new TextDecoder(); + +const inlineSourceMapRegex = + /^\/\/# sourceMappingURL=data:application\/json;base64,([a-zA-Z0-9+/=]+)$/; + +// Tracks which snapshots are involved in order to identify conflicts. +const tracker: Set = new Set(); + +type TranspileResult = Awaited>; +interface TestTranspileOutput { + result: TranspileResult; + modulesPaths: Record; +} + +type BundleResult = Awaited>; +interface TestBundleOutput { + result: BundleResult; + bundlePath: string; + sourceMapPath?: string; +} + +/** + * Calls `emit` with the provided parameters and checks that the output is + * consistent with the snapshots. + * Each module in the record returned by `emit` is stored as its own file. + * In order to avoid special characters, the file name is a hash of the module's + * URL. The mapping between the hashes and the URLs is stored alongside the + * modules. + * + * @param root The root module specifier to use for the emitted modules. + * @param options Options to use when emitting. + * @param more An optional function to perform more assertions. + * @returns A function to pass to the test runner + */ +export function testTranspile( + root: string | URL, + options?: EmitOptions, + more?: ( + output: TestTranspileOutput, + t: Deno.TestContext, + ) => void | Promise, +) { + return async function (t: Deno.TestContext): Promise { + const result = fixTranspileResult(await emit(root, options)); + + const testDir = resolve(getSnapshotDir(t), getTestName(t)); + + const modules = await Promise.all( + Object.entries(result).map(async ([url, source]) => { + const hash = await hashShortSha1(url); + const fileName = `${hash}.js`; + return { fileName, url, source }; + }), + ); + const modulesSnapshotEntries: [string, string][] = modules.map(( + { fileName, source }, + ) => [fileName, source]); + // The keys need to be sorted in order to have consistency between runs. + const mapping: Record = Object.fromEntries( + modules.map(({ fileName, url }) => { + return [url, fileName]; + }).sort((a, b) => { + if (a[0] > b[0]) return 1; + if (a[0] < b[0]) return -1; + return 0; + }), + ); + + const snapshotMode = + existsSync(testDir, { isReadable: true, isDirectory: true }) + ? getMode() + : "update"; + + await assertSnapshot( + resolve(testDir, "mapping.json"), + JSON.stringify(mapping, null, 2) + "\n", + snapshotMode, + ); + await assertSnapshots( + resolve(testDir, "modules"), + modulesSnapshotEntries, + snapshotMode, + ); + + if (more) { + const output: TestTranspileOutput = { + result, + modulesPaths: Object.fromEntries( + Object.entries(mapping).map(([url, filename]) => { + const filepath = resolve(testDir, "modules", filename); + return [url, filepath]; + }), + ), + }; + await more(output, t); + } + }; +} + +/** + * Calls `bundle` with the provided parameters and checks that the output is + * consistent with the snapshots of the code, stored as a JavaScript file, + * and the snapshot of the sourcemap, when it exists. + * + * @param root The root module specifier to use for the bundle. + * @param options Options to use when bundling. + * @param more An optional function to perform more assertions. + * @returns A function to pass to the test runner + */ +export function testBundle( + root: string | URL, + options?: BundleOptions, + more?: ( + output: TestBundleOutput, + t: Deno.TestContext, + ) => void | Promise, +) { + return async function (t: Deno.TestContext): Promise { + const result = fixBundleResult(await bundle(root, options)); + + const testName = getTestName(t); + const snapshotDir = getSnapshotDir(t); + + const bundlePath = resolve(snapshotDir, `${testName}.js`); + const sourceMapPath = resolve(snapshotDir, `${testName}.js.map`); + + const snapshotMode = + existsSync(snapshotDir, { isReadable: true, isDirectory: true }) + ? getMode() + : "update"; + await assertSnapshot( + bundlePath, + result.code, + snapshotMode, + ); + await assertSnapshot( + sourceMapPath, + result.map, + snapshotMode, + ); + + if (more) { + const output: TestBundleOutput = { + result, + bundlePath, + sourceMapPath: result.map ? sourceMapPath : undefined, + }; + await more(output, t); + } + }; +} + +/** + * Provides the full path of a fixture file stored in "testdata". + * + * @param parts Path relative to the folder with the fixtures. + * @returns the full path of the fixture. + */ +export function resolveFixture(...parts: string[]): string { + return resolve(Deno.cwd(), "testdata", ...parts); +} + +async function assertSnapshot( + path: string, + actual: string | undefined, + mode: SnapshotMode, +): Promise { + let snapshot: string | undefined; + try { + snapshot = await Deno.readTextFile(path); + } catch (e: unknown) { + if (!(e instanceof Deno.errors.NotFound)) { + throw e; + } + } + + if (actual === snapshot) { + return; + } + + const relativePath = relative(Deno.cwd(), path); + + if (mode === "update") { + if (tracker.has(path)) { + throw new Error(`Snapshot already defined at ${relativePath}`); + } + await applyUpdate(path, actual); + } else { + const diffResult = diffstr( + actual ?? "", + snapshot ?? "", + ); + const diffMsg = buildMessage(diffResult); + throw new AssertionError( + `Snapshot at ${relativePath} does not match:\n${diffMsg}`, + ); + } +} + +async function assertSnapshots( + path: string, + files: Iterable<[fileName: string, actual: string | undefined]>, + mode: SnapshotMode, +): Promise { + const remainingFiles: Set = new Set(); + const dir = Deno.readDir(path); + try { + for await (const entry of dir) { + if (entry.isFile) { + remainingFiles.add(resolve(path, entry.name)); + } + } + } catch (e: unknown) { + if (!(e instanceof Deno.errors.NotFound)) { + throw e; + } + } + for (const [fileName, actual] of files) { + const filePath = resolve(path, fileName); + await assertSnapshot(filePath, actual, mode); + remainingFiles.delete(filePath); + } + for (const filePath of remainingFiles) { + await assertSnapshot(filePath, undefined, mode); + } +} + +type SnapshotMode = "assert" | "update"; + +let _mode: SnapshotMode; + +function getMode(): SnapshotMode { + if (_mode) { + return _mode; + } else { + _mode = Deno.args.some((arg) => arg === "--update" || arg === "-u") + ? "update" + : "assert"; + return _mode; + } +} + +// Note that there can be conflicts; different tests can output the same test +// name. It is not ideal but it shouldn't happen in normal circumstances, and +// assertSnapshot will throw if it ever causes snapshots to clash. +function getTestName( + context: Deno.TestContext, +): string { + // Avoiding special characters other than dash and underscore + let name = slugify(context.name); + if (context.parent) { + name = `${getTestName(context.parent)}__${name}`; + } + return name; +} + +function slugify(name: string): string { + return name + .replace(/\s/g, "_") + .replace(/[^a-zA-Z0-9_]/g, "") + .toLowerCase(); +} + +function getSnapshotDir(context: Deno.TestContext): string { + const { dir, name } = parse(fromFileUrl(context.origin)); + const snapshotDir = resolve( + dir, + "__snapshots__", + name.endsWith("_test") + ? name.substring(0, name.length - "_test".length) + : name, + ); + return snapshotDir; +} + +async function applyUpdate( + path: string, + actual: string | undefined, +): Promise { + if (actual === undefined) { + await Deno.remove(path); + return; + } + await ensureFile(path); + await Deno.writeTextFile(path, actual); +} + +// We don't want to litter the snapshots with absolute file paths, which +// depend on where the repository is located on the device. +function normalizeIfFileUrl(urlString: string): string { + const url = new URL(urlString); + if (url.protocol === "file:") { + const path = fromFileUrl(url); + // We prepend with the separator instead of using `resolve()` because, on + // Windows, this adds the device prefix (e.g. `C:`), which we don't want. + const normalizedPath = SEP + relative(Deno.cwd(), path); + return toFileUrl(normalizedPath).toString(); + } + return url.toString(); +} + +// We need to normalize the source map URLs because they are absolute paths. + +function fixTranspileResult(result: TranspileResult): TranspileResult { + return Object.fromEntries( + Object.entries(result).map(( + [url, source], + ) => { + source = fixInlineSourceMap(source); + url = normalizeIfFileUrl(url); + return [url, source]; + }), + ); +} + +function fixBundleResult(result: BundleResult): BundleResult { + const code = fixInlineSourceMap(result.code); + const map = result.map !== undefined ? fixSourceMap(result.map) : undefined; + return { code, map }; +} + +function fixSourceMap(sourceMapJsonString: string): string { + const sourceMap = JSON.parse(sourceMapJsonString); + sourceMap.sources = sourceMap.sources.map(normalizeIfFileUrl); + return JSON.stringify(sourceMap); +} + +function fixInlineSourceMap(code: string): string { + const lines = code.split("\n"); + + const indexOfLastLine = lines.findLastIndex((line) => line !== ""); + const match = lines[indexOfLastLine]?.match(inlineSourceMapRegex); + if (match == null) { + return code; + } + + const sourceMapBase64 = match[1]; + const sourceMap = textDecoder.decode(base64.decode(sourceMapBase64)); + const newSourceMap = fixSourceMap(sourceMap); + const newSourceMapBase64 = base64.encode(textEncoder.encode(newSourceMap)); + + lines[indexOfLastLine] = + `//# sourceMappingURL=data:application/json;base64,${newSourceMapBase64}`; + + return lines.join("\n"); +} + +async function hashShortSha1(input: string): Promise { + // Base64 makes the hash shorted; the URL variants avoids special characters + // other than dash and underscore. + return base64Url.encode( + await crypto.subtle.digest( + "SHA-1", + textEncoder.encode(input), + ), + ); +}