mirror of
https://github.com/denoland/std.git
synced 2024-11-22 04:59:05 +00:00
110 lines
3.2 KiB
TypeScript
110 lines
3.2 KiB
TypeScript
// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
|
|
// This module is browser compatible.
|
|
|
|
import { CHAR_COLON, CHAR_DOT } from "../_common/constants.ts";
|
|
import { assertPath } from "../_common/assert_path.ts";
|
|
import { isPathSeparator, isWindowsDeviceRoot } from "./_util.ts";
|
|
import { fromFileUrl } from "./from_file_url.ts";
|
|
|
|
/**
|
|
* Return the extension of the `path` with leading period.
|
|
*
|
|
* @example Usage
|
|
* ```ts
|
|
* import { extname } from "@std/path/windows/extname";
|
|
* import { assertEquals } from "@std/assert";
|
|
*
|
|
* const ext = extname("file.ts");
|
|
* assertEquals(ext, ".ts");
|
|
* ```
|
|
*
|
|
* @param path The path to get the extension from.
|
|
* @returns The extension of the `path`.
|
|
*/
|
|
export function extname(path: string): string;
|
|
/**
|
|
* Return the extension of the `path` with leading period.
|
|
*
|
|
* @experimental **UNSTABLE**: New API, yet to be vetted.
|
|
*
|
|
* @example Usage
|
|
* ```ts
|
|
* import { extname } from "@std/path/windows/extname";
|
|
* import { assertEquals } from "@std/assert";
|
|
*
|
|
* assertEquals(extname("file.ts"), ".ts");
|
|
* assertEquals(extname(new URL("file:///C:/foo/bar/baz.ext")), ".ext");
|
|
* ```
|
|
*
|
|
* @param path The path to get the extension from.
|
|
* @returns The extension of the `path`.
|
|
*/
|
|
export function extname(path: string | URL): string;
|
|
export function extname(path: string | URL): string {
|
|
if (path instanceof URL) {
|
|
path = fromFileUrl(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);
|
|
}
|