upath vs path2 vs upath2
Cross-Platform Path Manipulation in JavaScript
Search packages..
upathpath2upath2Similar Packages:
Cross-Platform Path Manipulation in JavaScript

path2, upath, and upath2 are npm packages that extend or replace Node.js’s built-in path module to provide consistent cross-platform path handling, particularly for Windows-style paths in Unix environments or vice versa. They aim to normalize path separators, resolve paths reliably, and avoid common pitfalls when working with file systems across operating systems. While the native path module works well in most cases, these libraries offer additional utilities or stricter guarantees for specific use cases like tooling, bundlers, or cross-platform CLI applications.

Npm Package Weekly Downloads Trend
3 Years
Github Stars Ranking
Stat Detail
Package
Downloads
Stars
Size
Issues
Publish
License
upath17,765,684154-35 years agoMIT
path2759,11425-112 years agoMIT
upath288,246242.9 kB1a year agoISC

Cross-Platform Path Handling: path2 vs upath vs upath2

When writing JavaScript tools that manipulate file paths—like bundlers, linters, or CLI apps—you quickly run into issues with Windows backslashes (\) versus Unix forward slashes (/). Node.js’s built-in path module helps, but it preserves platform-specific separators, which can break string-based logic. The path2, upath, and upath2 packages aim to solve this—but not all are viable today. Let’s compare them honestly.

⚠️ Deprecation Status: Don’t Use path2

First things first: path2 is deprecated. Its npm page states it’s no longer maintained, and its GitHub repo is archived. It was an early attempt to improve path handling but has been superseded. Do not use it in new code. We’ll mention it only for completeness.

// ❌ Avoid — path2 is deprecated
import path2 from 'path2';
const p = path2.join('src', 'components'); // Works, but unmaintained

🔁 Core Philosophy: Normalizing to Forward Slashes

Both upath and upath2 share the same core idea: always return paths with / separators, even on Windows. This avoids bugs like:

// Native path on Windows:
const p = path.join('src', 'utils'); // "src\\utils"
if (p.startsWith('src/utils')) { /* fails on Windows! */ }

By forcing /, string operations become reliable everywhere.

upath: The Original Normalizer

upath wraps Node’s path methods and post-processes results to replace \ with /.

// ✅ upath — consistent forward slashes
import upath from 'upath';

const p1 = upath.join('src', 'components');        // "src/components"
const p2 = upath.resolve('./dist');                // "/absolute/path/to/dist" (with /)
const normalized = upath.normalize('a\\b/c');     // "a/b/c"

It also adds convenience methods like .toUnix() for arbitrary strings:

const clean = upath.toUnix('C:\\Users\\file.js'); // "C:/Users/file.js"

upath2: A Modern Repackaging

upath2 is a fork of upath that preserves the exact same API but ships as a pure ESM package with built-in TypeScript definitions. Functionally, it behaves identically.

// ✅ upath2 — same behavior, ESM + TS
import upath from 'upath2';

const p1 = upath.join('src', 'components');        // "src/components"
const p2 = upath.resolve('./dist');                // "/absolute/path/to/dist" (with /)
const normalized = upath.normalize('a\\b/c');     // "a/b/c"

There are no additional features or bug fixes in upath2—just packaging differences.

🧪 Feature Comparison: What Each Package Actually Does

All three claim to “fix” path handling, but their capabilities differ sharply.

Path Joining and Resolution

Packagejoin()resolve()Always uses /?
path2✅✅❌ (platform-dependent)
upath✅✅✅
upath2✅✅✅

Example showing the key difference:

// On Windows:
import path from 'path';
import upath from 'upath';
import upath2 from 'upath2';

console.log(path.join('a', 'b'));      // "a\\b"
console.log(upath.join('a', 'b'));     // "a/b"
console.log(upath2.join('a', 'b'));    // "a/b"

String Normalization Utilities

Only upath and upath2 offer .toUnix() for sanitizing arbitrary path strings:

// upath
import upath from 'upath';
const clean = upath.toUnix('folder\\sub/file.txt'); // "folder/sub/file.txt"

// upath2
import upath from 'upath2';
const clean = upath.toUnix('folder\\sub/file.txt'); // "folder/sub/file.txt"

// path2 — no such method

Relative Path Handling

All support .relative(), but again, only upath/upath2 guarantee /:

// upath
const rel = upath.relative('/project/src', '/project/src/utils'); // "utils"

// upath2
const rel = upath2.relative('/project/src', '/project/src/utils'); // "utils"

// path2 — may return backslashes on Windows

📦 Packaging and Ecosystem Fit

This is where upath and upath2 diverge meaningfully:

  • upath: Published as CommonJS. Works everywhere, including older Node versions and bundlers without ESM config. No built-in TypeScript types (you’d install @types/upath).

  • upath2: Pure ESM. Requires Node 12+ with ESM support or bundler configuration. Ships with .d.ts files, so no extra install needed for TypeScript.

If your project is still using CommonJS or targets older environments, upath is safer. If you’re all-in on ESM and TypeScript, upath2 reduces setup friction.

🛠️ Real-World Guidance

When to Use upath

  • You’re building a widely compatible tool (e.g., a Webpack plugin or ESLint rule).
  • You need maximum compatibility across Node versions.
  • You don’t mind installing @types/upath separately.
// Example: A cross-platform file resolver
import upath from 'upath';

function resolveModule(baseDir, moduleName) {
  const candidate = upath.join(baseDir, 'node_modules', moduleName);
  // Safe to use string.includes() because separator is always /
  if (candidate.includes('/node_modules/react/')) {
    return candidate;
  }
}

When to Use upath2

  • Your project is ESM-only (e.g., Vite-based tooling).
  • You want zero-config TypeScript support.
  • You’re already avoiding CommonJS dependencies.
// Example: An ESM-native build script
import upath from 'upath2';

const srcDir = upath.resolve('./src');
const outFile = upath.join(srcDir, 'bundle.js'); // Always ".../src/bundle.js"

Never Use path2

It hasn’t seen updates in years, lacks security patches, and offers no advantage over maintained alternatives. Migrate existing usage:

// Before (deprecated)
import path2 from 'path2';
const p = path2.join('a', 'b');

// After
import upath from 'upath';
const p = upath.join('a', 'b');

🆚 Summary: Key Differences

Aspectpath2upathupath2
Maintenance❌ Deprecated✅ Actively maintained✅ Actively maintained
Path SeparatorPlatform-nativeAlways /Always /
ESM SupportCommonJS onlyCommonJSPure ESM
TypeScriptNo typesRequires @types/upathBuilt-in types
Extra MethodsNone.toUnix().toUnix()
Use in New CodeNeverYes (CommonJS or mixed envs)Yes (ESM-only projects)

💡 Final Recommendation

For most frontend tooling projects, upath remains the pragmatic choice—it’s stable, widely used, and solves the core problem reliably. Only reach for upath2 if you’re committed to a modern ESM + TypeScript stack and want to avoid type declaration packages. And never start a new project with path2—it’s a legacy artifact with no place in contemporary codebases.

Remember: sometimes the best path is the one that just works everywhere — and that’s what upath delivers.

How to Choose: upath vs path2 vs upath2
  • upath:

    Choose upath if you need a lightweight, battle-tested wrapper around Node.js’s path module that normalizes all paths to use forward slashes (/) regardless of platform. It’s ideal for build tools, static site generators, or any scenario where consistent path formatting simplifies string operations or avoids Windows-specific bugs.

  • path2:

    path2 should not be used in new projects. It is deprecated and unmaintained, as confirmed by its npm registry entry and GitHub repository archive status. Existing usage should be migrated to alternatives like upath or the native Node.js path module.

  • upath2:

    Choose upath2 only if you require ESM-first support and TypeScript types out of the box, and you’re already familiar with upath’s API. It’s a modern fork of upath but offers no functional improvements—only packaging and type enhancements. For most projects, upath remains sufficient unless ESM compatibility is non-negotiable.

Similar Npm Packages to upath

upath is a utility library for handling file and directory paths in a cross-platform manner. It provides a consistent API for working with paths, making it easier to manipulate and resolve paths in both Node.js and browser environments. This is particularly useful for developers who want to ensure their applications work seamlessly across different platforms. While upath is a great choice for path manipulation, there are several alternatives available in the JavaScript ecosystem. Here are a few notable ones:

  • path is a built-in Node.js module that provides utilities for working with file and directory paths. It offers methods for resolving, normalizing, and joining paths, making it a robust choice for server-side applications. However, it is not designed for browser environments, which limits its use in universal applications. If you're developing a Node.js application and need a reliable path manipulation library, the built-in path module is a solid option.

  • path-browserify is a browser-compatible version of the Node.js path module. It replicates the functionality of the Node.js path module, allowing developers to work with paths in browser environments. This is particularly useful for applications that need to run in both Node.js and browser contexts. If you need a path manipulation library that works in the browser while maintaining a familiar API, path-browserify is an excellent choice.

  • path-to-regexp is a library used for matching paths against a pattern, often used in routing scenarios. It allows developers to create regular expressions from path strings, making it easier to extract parameters from URLs. While it is not a direct alternative for general path manipulation, it is valuable for applications that require path matching and parameter extraction, such as web routing libraries.

  • upath2 is a fork of the original upath library, providing similar functionality with some enhancements and additional features. It aims to maintain compatibility while offering improvements in performance and usability. If you are looking for an updated version of upath with additional capabilities, upath2 may be the right choice.

To see how upath compares with path, path-browserify, path-to-regexp, and upath2, check out the comparison: Comparing path vs path-browserify vs path-to-regexp vs upath vs upath2.

Similar Npm Packages to upath2

upath2 is a utility library that provides enhanced cross-platform path handling for Node.js applications. It builds upon the standard path module by offering additional safety, consistency, and convenience methods—particularly useful when dealing with Windows and Unix-style paths in the same codebase. While upath2 offers modernized and robust path manipulation features, there are alternative libraries that aim to solve similar problems. Here are a few alternatives:

  • path2 is an experimental or community-driven extension of Node.js’s built-in path module, often designed to offer more intuitive APIs or extra utilities not found in the core module. Depending on its implementation, it may include features like better Unicode support, chainable methods, or improved normalization. If you're looking for a drop-in replacement with extended capabilities beyond the native path, path2 might be worth exploring.
  • upath is a well-established library that normalizes file paths to always use Unix-style forward slashes (/), regardless of the operating system. This helps avoid common issues when writing cross-platform scripts or tools that process file paths. upath also adds helpful utility functions like toUnix(), normalizeSafe(), and others that prevent errors caused by backslashes on Windows. If your project requires consistent path formatting across environments without overhauling your existing path logic, upath remains a solid, battle-tested choice.

Check out comparison: Comparing path2 vs upath vs upath2.

README for upath

upath v2.0.1

Build Status Up to date Status

A drop-in replacement / proxy to nodejs's path that:

  • Replaces the windows \ with the unix / in all string params & results. This has significant positives - see below.

  • Adds filename extensions functions addExt, trimExt, removeExt, changeExt, and defaultExt.

  • Add a normalizeSafe function to preserve any meaningful leading ./ & a normalizeTrim which additionally trims any useless ending /.

  • Plus a helper toUnix that simply converts \ to / and consolidates duplicates.

Useful note: these docs are actually auto generated from specs, running on Linux.

Notes:

  • upath.sep is set to '/' for seamless replacement (as of 1.0.3).

  • upath has no runtime dependencies, except built-in path (as of 1.0.4)

  • travis-ci tested in node versions 8 to 14 (on linux)

  • Also tested on Windows / node@12.18.0 (without CI)

History brief:

Why ?

Normal path doesn't convert paths to a unified format (ie /) before calculating paths (normalize, join), which can lead to numerous problems. Also path joining, normalization etc on the two formats is not consistent, depending on where it runs. Running path on Windows yields different results than when it runs on Linux / Mac.

In general, if you code your paths logic while developing on Unix/Mac and it runs on Windows, you may run into problems when using path.

Note that using Unix / on Windows works perfectly inside nodejs (and other languages), so there's no reason to stick to the Windows legacy at all.

Examples / specs

Check out the different (improved) behavior to vanilla path:

`upath.normalize(path)`        --returns-->

      ✓ `'c:/windows/nodejs/path'`         --->      `'c:/windows/nodejs/path'`  // equal to `path.normalize()`
      ✓ `'c:/windows/../nodejs/path'`      --->              `'c:/nodejs/path'`  // equal to `path.normalize()`
      ✓ `'c:\\windows\\nodejs\\path'`      --->      `'c:/windows/nodejs/path'`  // `path.normalize()` gives `'c:\windows\nodejs\path'`
      ✓ `'c:\\windows\\..\\nodejs\\path'`  --->              `'c:/nodejs/path'`  // `path.normalize()` gives `'c:\windows\..\nodejs\path'`
      ✓ `'/windows\\unix/mixed'`           --->         `'/windows/unix/mixed'`  // `path.normalize()` gives `'/windows\unix/mixed'`
      ✓ `'\\windows//unix/mixed'`          --->         `'/windows/unix/mixed'`  // `path.normalize()` gives `'\windows/unix/mixed'`
      ✓ `'\\windows\\..\\unix/mixed/'`     --->                `'/unix/mixed/'`  // `path.normalize()` gives `'\windows\..\unix/mixed/'`

Joining paths can also be a problem:

`upath.join(paths...)`        --returns-->

      ✓ `'some/nodejs/deep', '../path'`       --->       `'some/nodejs/path'`  // equal to `path.join()`
      ✓ `'some/nodejs\\windows', '../path'`   --->       `'some/nodejs/path'`  // `path.join()` gives `'some/path'`
      ✓ `'some\\windows\\only', '..\\path'`   --->      `'some/windows/path'`  // `path.join()` gives `'some\windows\only/..\path'`

Parsing with path.parse() should also be consistent across OSes:

upath.parse(path) --returns-->

      ✓ `'c:\Windows\Directory\somefile.ext'`      ---> `{ root: '', dir: 'c:/Windows/Directory', base: 'somefile.ext', ext: '.ext', name: 'somefile'

} //path.parse()gives'{ root: '', dir: '', base: 'c:\Windows\Directory\somefile.ext', ext: '.ext', name: 'c:\Windows\Directory\somefile' }' ✓'/root/of/unix/somefile.ext' --->{ root: '/', dir: '/root/of/unix', base: 'somefile.ext', ext: '.ext', name: 'somefile' } // equal topath.parse()`

Added functions

upath.toUnix(path)

Just converts all `` to / and consolidates duplicates, without performing any normalization.

Examples / specs
`upath.toUnix(path)`        --returns-->

    ✓ `'.//windows\//unix//mixed////'`      --->         `'./windows/unix/mixed/'`
    ✓ `'..///windows\..\\unix/mixed'`       --->      `'../windows/../unix/mixed'`

upath.normalizeSafe(path)

Exactly like path.normalize(path), but it keeps the first meaningful ./ or //.

Note that the unix / is returned everywhere, so windows \ is always converted to unix /.

Examples / specs & how it differs from vanilla path
`upath.normalizeSafe(path)`        --returns-->

    ✓ `''`                               --->                              `'.'`  // equal to `path.normalize()`
    ✓ `'.'`                              --->                              `'.'`  // equal to `path.normalize()`
    ✓ `'./'`                             --->                             `'./'`  // equal to `path.normalize()`
    ✓ `'.//'`                            --->                             `'./'`  // equal to `path.normalize()`
    ✓ `'.\\'`                            --->                             `'./'`  // `path.normalize()` gives `'.\'`
    ✓ `'.\\//'`                          --->                             `'./'`  // `path.normalize()` gives `'.\/'`
    ✓ `'./..'`                           --->                             `'..'`  // equal to `path.normalize()`
    ✓ `'.//..'`                          --->                             `'..'`  // equal to `path.normalize()`
    ✓ `'./../'`                          --->                            `'../'`  // equal to `path.normalize()`
    ✓ `'.\\..\\'`                        --->                            `'../'`  // `path.normalize()` gives `'.\..\'`
    ✓ `'./../dep'`                       --->                         `'../dep'`  // equal to `path.normalize()`
    ✓ `'../dep'`                         --->                         `'../dep'`  // equal to `path.normalize()`
    ✓ `'../path/dep'`                    --->                    `'../path/dep'`  // equal to `path.normalize()`
    ✓ `'../path/../dep'`                 --->                         `'../dep'`  // equal to `path.normalize()`
    ✓ `'dep'`                            --->                            `'dep'`  // equal to `path.normalize()`
    ✓ `'path//dep'`                      --->                       `'path/dep'`  // equal to `path.normalize()`
    ✓ `'./dep'`                          --->                          `'./dep'`  // `path.normalize()` gives `'dep'`
    ✓ `'./path/dep'`                     --->                     `'./path/dep'`  // `path.normalize()` gives `'path/dep'`
    ✓ `'./path/../dep'`                  --->                          `'./dep'`  // `path.normalize()` gives `'dep'`
    ✓ `'.//windows\\unix/mixed/'`        --->          `'./windows/unix/mixed/'`  // `path.normalize()` gives `'windows\unix/mixed/'`
    ✓ `'..//windows\\unix/mixed'`        --->          `'../windows/unix/mixed'`  // `path.normalize()` gives `'../windows\unix/mixed'`
    ✓ `'windows\\unix/mixed/'`           --->            `'windows/unix/mixed/'`  // `path.normalize()` gives `'windows\unix/mixed/'`
    ✓ `'..//windows\\..\\unix/mixed'`    --->                  `'../unix/mixed'`  // `path.normalize()` gives `'../windows\..\unix/mixed'`
    ✓ `'\\\\server\\share\\file'`        --->            `'//server/share/file'`  // `path.normalize()` gives `'\\server\share\file'`
    ✓ `'//server/share/file'`            --->            `'//server/share/file'`  // `path.normalize()` gives `'/server/share/file'`
    ✓ `'\\\\?\\UNC\\server\\share\\file'` --->      `'//?/UNC/server/share/file'`  // `path.normalize()` gives `'\\?\UNC\server\share\file'`
    ✓ `'\\\\LOCALHOST\\c$\\temp\\file'`  --->       `'//LOCALHOST/c$/temp/file'`  // `path.normalize()` gives `'\\LOCALHOST\c$\temp\file'`
    ✓ `'\\\\?\\c:\\temp\\file'`          --->               `'//?/c:/temp/file'`  // `path.normalize()` gives `'\\?\c:\temp\file'`
    ✓ `'\\\\.\\c:\\temp\\file'`          --->               `'//./c:/temp/file'`  // `path.normalize()` gives `'\\.\c:\temp\file'`
    ✓ `'//./c:/temp/file'`               --->               `'//./c:/temp/file'`  // `path.normalize()` gives `'/c:/temp/file'`
    ✓ `'////\\.\\c:/temp\\//file'`       --->               `'//./c:/temp/file'`  // `path.normalize()` gives `'/\.\c:/temp\/file'`

upath.normalizeTrim(path)

Exactly like path.normalizeSafe(path), but it trims any useless ending /.

Examples / specs
`upath.normalizeTrim(path)`        --returns-->

    ✓ `'./'`                          --->                         `'.'`  // `upath.normalizeSafe()` gives `'./'`
    ✓ `'./../'`                       --->                        `'..'`  // `upath.normalizeSafe()` gives `'../'`
    ✓ `'./../dep/'`                   --->                    `'../dep'`  // `upath.normalizeSafe()` gives `'../dep/'`
    ✓ `'path//dep\\'`                 --->                  `'path/dep'`  // `upath.normalizeSafe()` gives `'path/dep/'`
    ✓ `'.//windows\\unix/mixed/'`     --->      `'./windows/unix/mixed'`  // `upath.normalizeSafe()` gives `'./windows/unix/mixed/'`

upath.joinSafe([path1][, path2][, ...])

Exactly like path.join(), but it keeps the first meaningful ./ or //.

Note that the unix / is returned everywhere, so windows \ is always converted to unix /.

Examples / specs & how it differs from vanilla path
`upath.joinSafe(path)`        --returns-->

    ✓ `'some/nodejs/deep', '../path'`                --->           `'some/nodejs/path'`  // equal to `path.join()`
    ✓ `'./some/local/unix/', '../path'`              --->          `'./some/local/path'`  // `path.join()` gives `'some/local/path'`
    ✓ `'./some\\current\\mixed', '..\\path'`         --->        `'./some/current/path'`  // `path.join()` gives `'some\current\mixed/..\path'`
    ✓ `'../some/relative/destination', '..\\path'`   --->      `'../some/relative/path'`  // `path.join()` gives `'../some/relative/destination/..\path'`
    ✓ `'\\\\server\\share\\file', '..\\path'`        --->        `'//server/share/path'`  // `path.join()` gives `'\\server\share\file/..\path'`
    ✓ `'\\\\.\\c:\\temp\\file', '..\\path'`          --->           `'//./c:/temp/path'`  // `path.join()` gives `'\\.\c:\temp\file/..\path'`
    ✓ `'//server/share/file', '../path'`             --->        `'//server/share/path'`  // `path.join()` gives `'/server/share/path'`
    ✓ `'//./c:/temp/file', '../path'`                --->           `'//./c:/temp/path'`  // `path.join()` gives `'/c:/temp/path'`

Added functions for filename extension manipulation.

Happy notes:

In all functions you can:

  • use both .ext & ext - the dot . on the extension is always adjusted correctly.

  • omit the ext param (pass null/undefined/empty string) and the common sense thing will happen.

  • ignore specific extensions from being considered as valid ones (eg .min, .dev .aLongExtIsNotAnExt etc), hence no trimming or replacement takes place on them.

upath.addExt(filename, [ext])

Adds .ext to filename, but only if it doesn't already have the exact extension.

Examples / specs
`upath.addExt(filename, 'js')`     --returns-->

    ✓ `'myfile/addExt'`           --->           `'myfile/addExt.js'`
    ✓ `'myfile/addExt.txt'`       --->       `'myfile/addExt.txt.js'`
    ✓ `'myfile/addExt.js'`        --->           `'myfile/addExt.js'`
    ✓ `'myfile/addExt.min.'`      --->      `'myfile/addExt.min..js'`

It adds nothing if no ext param is passed.

`upath.addExt(filename)`           --returns-->

      ✓ `'myfile/addExt'`           --->              `'myfile/addExt'`
      ✓ `'myfile/addExt.txt'`       --->          `'myfile/addExt.txt'`
      ✓ `'myfile/addExt.js'`        --->           `'myfile/addExt.js'`
      ✓ `'myfile/addExt.min.'`      --->         `'myfile/addExt.min.'`

upath.trimExt(filename, [ignoreExts], [maxSize=7])

Trims a filename's extension.

  • Extensions are considered to be up to maxSize chars long, counting the dot (defaults to 7).

  • An Array of ignoreExts (eg ['.min']) prevents these from being considered as extension, thus are not trimmed.

Examples / specs
`upath.trimExt(filename)`          --returns-->

    ✓ `'my/trimedExt.txt'`             --->                 `'my/trimedExt'`
    ✓ `'my/trimedExt'`                 --->                 `'my/trimedExt'`
    ✓ `'my/trimedExt.min'`             --->                 `'my/trimedExt'`
    ✓ `'my/trimedExt.min.js'`          --->             `'my/trimedExt.min'`
    ✓ `'../my/trimedExt.longExt'`      --->      `'../my/trimedExt.longExt'`

It is ignoring .min & .dev as extensions, and considers exts with up to 8 chars.

`upath.trimExt(filename, ['min', '.dev'], 8)`          --returns-->

      ✓ `'my/trimedExt.txt'`              --->                  `'my/trimedExt'`
      ✓ `'my/trimedExt.min'`              --->              `'my/trimedExt.min'`
      ✓ `'my/trimedExt.dev'`              --->              `'my/trimedExt.dev'`
      ✓ `'../my/trimedExt.longExt'`       --->               `'../my/trimedExt'`
      ✓ `'../my/trimedExt.longRExt'`      --->      `'../my/trimedExt.longRExt'`

upath.removeExt(filename, ext)

Removes the specific ext extension from filename, if it has it. Otherwise it leaves it as is. As in all upath functions, it be .ext or ext.

Examples / specs
`upath.removeExt(filename, '.js')`          --returns-->

    ✓ `'removedExt.js'`          --->          `'removedExt'`
    ✓ `'removedExt.txt.js'`      --->      `'removedExt.txt'`
    ✓ `'notRemoved.txt'`         --->      `'notRemoved.txt'`

It does not care about the length of exts.

`upath.removeExt(filename, '.longExt')`          --returns-->

    ✓ `'removedExt.longExt'`          --->          `'removedExt'`
    ✓ `'removedExt.txt.longExt'`      --->      `'removedExt.txt'`
    ✓ `'notRemoved.txt'`              --->      `'notRemoved.txt'`

upath.changeExt(filename, [ext], [ignoreExts], [maxSize=7])

Changes a filename's extension to ext. If it has no (valid) extension, it adds it.

  • Valid extensions are considered to be up to maxSize chars long, counting the dot (defaults to 7).

  • An Array of ignoreExts (eg ['.min']) prevents these from being considered as extension, thus are not changed - the new extension is added instead.

Examples / specs
`upath.changeExt(filename, '.js')`  --returns-->

    ✓ `'my/module.min'`            --->                `'my/module.js'`
    ✓ `'my/module.coffee'`         --->                `'my/module.js'`
    ✓ `'my/module'`                --->                `'my/module.js'`
    ✓ `'file/withDot.'`            --->             `'file/withDot.js'`
    ✓ `'file/change.longExt'`      --->      `'file/change.longExt.js'`

If no ext param is given, it trims the current extension (if any).

`upath.changeExt(filename)`        --returns-->

      ✓ `'my/module.min'`            --->                   `'my/module'`
      ✓ `'my/module.coffee'`         --->                   `'my/module'`
      ✓ `'my/module'`                --->                   `'my/module'`
      ✓ `'file/withDot.'`            --->                `'file/withDot'`
      ✓ `'file/change.longExt'`      --->         `'file/change.longExt'`

It is ignoring .min & .dev as extensions, and considers exts with up to 8 chars.

`upath.changeExt(filename, 'js', ['min', '.dev'], 8)`        --returns-->

      ✓ `'my/module.coffee'`          --->                 `'my/module.js'`
      ✓ `'file/notValidExt.min'`      --->      `'file/notValidExt.min.js'`
      ✓ `'file/notValidExt.dev'`      --->      `'file/notValidExt.dev.js'`
      ✓ `'file/change.longExt'`       --->               `'file/change.js'`
      ✓ `'file/change.longRExt'`      --->      `'file/change.longRExt.js'`

upath.defaultExt(filename, [ext], [ignoreExts], [maxSize=7])

Adds .ext to filename, only if it doesn't already have any old extension.

  • (Old) extensions are considered to be up to maxSize chars long, counting the dot (defaults to 7).

  • An Array of ignoreExts (eg ['.min']) will force adding default .ext even if one of these is present.

Examples / specs
`upath.defaultExt(filename, 'js')`   --returns-->

    ✓ `'fileWith/defaultExt'`              --->              `'fileWith/defaultExt.js'`
    ✓ `'fileWith/defaultExt.js'`           --->              `'fileWith/defaultExt.js'`
    ✓ `'fileWith/defaultExt.min'`          --->             `'fileWith/defaultExt.min'`
    ✓ `'fileWith/defaultExt.longExt'`      --->      `'fileWith/defaultExt.longExt.js'`

If no ext param is passed, it leaves filename intact.

`upath.defaultExt(filename)`       --returns-->

      ✓ `'fileWith/defaultExt'`              --->                 `'fileWith/defaultExt'`
      ✓ `'fileWith/defaultExt.js'`           --->              `'fileWith/defaultExt.js'`
      ✓ `'fileWith/defaultExt.min'`          --->             `'fileWith/defaultExt.min'`
      ✓ `'fileWith/defaultExt.longExt'`      --->         `'fileWith/defaultExt.longExt'`

It is ignoring .min & .dev as extensions, and considers exts with up to 8 chars.

`upath.defaultExt(filename, 'js', ['min', '.dev'], 8)` --returns-->

      ✓ `'fileWith/defaultExt'`               --->               `'fileWith/defaultExt.js'`
      ✓ `'fileWith/defaultExt.min'`           --->           `'fileWith/defaultExt.min.js'`
      ✓ `'fileWith/defaultExt.dev'`           --->           `'fileWith/defaultExt.dev.js'`
      ✓ `'fileWith/defaultExt.longExt'`       --->          `'fileWith/defaultExt.longExt'`
      ✓ `'fileWith/defaultExt.longRext'`      --->      `'fileWith/defaultExt.longRext.js'`

Copyright(c) 2014-2020 Angelos Pikoulas (agelos.pikoulas@gmail.com)

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

npm-compare.com is an independent website designed to help developers choose the most suitable npm packages. We are not affiliated with npm, Inc, the official website for the npm registry. Note that npm is a registered trademark of npm, Inc. Please share your feedback via our GitHub repository. For more details, please refer to our Terms & Privacy.