Move zstd to use long-form flags instead of short-form

* Initial changes

* added info error as well

* Format

* Unused package

* adding message field

* removed line

* Review comments

* review comment to add validation as errors handling

packages/artifact/RELEASES.md

@@ -85,4 +85,8 @@
 
 ### 1.0.2
 
-- Update to v2.0.1 of `@actions/http-client` [#1087](https://github.com/actions/toolkit/pull/1087)
+- Update to v2.0.1 of `@actions/http-client` [#1087](https://github.com/actions/toolkit/pull/1087)
+
+### 1.1.0
+
+- Add `x-actions-results-crc64` and `x-actions-results-md5` checksum headers on upload [#1063](https://github.com/actions/toolkit/pull/1063)

packages/artifact/package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@actions/artifact",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {

packages/artifact/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@actions/artifact",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "preview": true,
   "description": "Actions artifact lib",
   "keywords": [

packages/cache/RELEASES.md

@@ -61,4 +61,13 @@
 - Update to v2.0.0 of `@actions/http-client`
 
 ### 2.0.4
-- Update to v2.0.1 of `@actions/http-client` [#1087](https://github.com/actions/toolkit/pull/1087)
+- Update to v2.0.1 of `@actions/http-client` [#1087](https://github.com/actions/toolkit/pull/1087)
+
+### 2.0.5
+- Fix to avoid saving empty cache when no files are available for caching. ([issue](https://github.com/actions/cache/issues/624))
+
+### 2.0.6
+- Fix `Tar failed with error: The process '/usr/bin/tar' failed with exit code 1` issue when temp directory where tar is getting created is actually the subdirectory of the path mentioned by the user for caching. ([issue](https://github.com/actions/cache/issues/689))
+
+### 3.0.0
+- Updated actions/cache to suppress Actions cache server error and log warning for those error  [#1122](https://github.com/actions/toolkit/pull/1122)

packages/cache/__tests__/restoreCache.test.ts

@@ -73,13 +73,17 @@ test('restore with no cache found', async () => {
 test('restore with server error should fail', async () => {
   const paths = ['node_modules']
   const key = 'node-test'
+  const logWarningMock = jest.spyOn(core, 'warning')
 
   jest.spyOn(cacheHttpClient, 'getCacheEntry').mockImplementation(() => {
     throw new Error('HTTP Error Occurred')
   })
 
-  await expect(restoreCache(paths, key)).rejects.toThrowError(
+  const cacheKey = await restoreCache(paths, key)
-    'HTTP Error Occurred'
+  expect(cacheKey).toBe(undefined)
+  expect(logWarningMock).toHaveBeenCalledTimes(1)
+  expect(logWarningMock).toHaveBeenCalledWith(
+    'Failed to restore: HTTP Error Occurred'
   )
 })
 

packages/cache/__tests__/saveCache.test.ts

@@ -48,6 +48,7 @@ test('save with large cache outputs should fail', async () => {
   const cachePaths = [path.resolve(filePath)]
 
   const createTarMock = jest.spyOn(tar, 'createTar')
+  const logWarningMock = jest.spyOn(core, 'warning')
 
   const cacheSize = 11 * 1024 * 1024 * 1024 //~11GB, over the 10GB limit
   jest
@@ -58,8 +59,11 @@ test('save with large cache outputs should fail', async () => {
     .spyOn(cacheUtils, 'getCompressionMethod')
     .mockReturnValueOnce(Promise.resolve(compression))
 
-  await expect(saveCache([filePath], primaryKey)).rejects.toThrowError(
+  const cacheId = await saveCache([filePath], primaryKey)
-    'Cache size of ~11264 MB (11811160064 B) is over the 10GB limit, not saving cache.'
+  expect(cacheId).toBe(-1)
+  expect(logWarningMock).toHaveBeenCalledTimes(1)
+  expect(logWarningMock).toHaveBeenCalledWith(
+    'Failed to save: Cache size of ~11264 MB (11811160064 B) is over the 10GB limit, not saving cache.'
   )
 
   const archiveFolder = '/foo/bar'
@@ -79,6 +83,7 @@ test('save with large cache outputs should fail in GHES with error message', asy
   const cachePaths = [path.resolve(filePath)]
 
   const createTarMock = jest.spyOn(tar, 'createTar')
+  const logWarningMock = jest.spyOn(core, 'warning')
 
   const cacheSize = 11 * 1024 * 1024 * 1024 //~11GB, over the 10GB limit
   jest
@@ -106,8 +111,11 @@ test('save with large cache outputs should fail in GHES with error message', asy
       return response
     })
 
-  await expect(saveCache([filePath], primaryKey)).rejects.toThrowError(
+  const cacheId = await saveCache([filePath], primaryKey)
-    'The cache filesize must be between 0 and 1073741824 bytes'
+  expect(cacheId).toBe(-1)
+  expect(logWarningMock).toHaveBeenCalledTimes(1)
+  expect(logWarningMock).toHaveBeenCalledWith(
+    'Failed to save: The cache filesize must be between 0 and 1073741824 bytes'
   )
 
   const archiveFolder = '/foo/bar'
@@ -127,6 +135,7 @@ test('save with large cache outputs should fail in GHES without error message',
   const cachePaths = [path.resolve(filePath)]
 
   const createTarMock = jest.spyOn(tar, 'createTar')
+  const logWarningMock = jest.spyOn(core, 'warning')
 
   const cacheSize = 11 * 1024 * 1024 * 1024 //~11GB, over the 10GB limit
   jest
@@ -150,8 +159,11 @@ test('save with large cache outputs should fail in GHES without error message',
       return response
     })
 
-  await expect(saveCache([filePath], primaryKey)).rejects.toThrowError(
+  const cacheId = await saveCache([filePath], primaryKey)
-    'Cache size of ~11264 MB (11811160064 B) is over the data cap limit, not saving cache.'
+  expect(cacheId).toBe(-1)
+  expect(logWarningMock).toHaveBeenCalledTimes(1)
+  expect(logWarningMock).toHaveBeenCalledWith(
+    'Failed to save: Cache size of ~11264 MB (11811160064 B) is over the data cap limit, not saving cache.'
   )
 
   const archiveFolder = '/foo/bar'
@@ -168,6 +180,7 @@ test('save with large cache outputs should fail in GHES without error message',
 test('save with reserve cache failure should fail', async () => {
   const paths = ['node_modules']
   const primaryKey = 'Linux-node-bb828da54c148048dd17899ba9fda624811cfb43'
+  const logInfoMock = jest.spyOn(core, 'info')
 
   const reserveCacheMock = jest
     .spyOn(cacheHttpClient, 'reserveCache')
@@ -187,9 +200,13 @@ test('save with reserve cache failure should fail', async () => {
     .spyOn(cacheUtils, 'getCompressionMethod')
     .mockReturnValueOnce(Promise.resolve(compression))
 
-  await expect(saveCache(paths, primaryKey)).rejects.toThrowError(
+  const cacheId = await saveCache(paths, primaryKey)
-    `Unable to reserve cache with key ${primaryKey}, another job may be creating this cache.`
+  expect(cacheId).toBe(-1)
+  expect(logInfoMock).toHaveBeenCalledTimes(1)
+  expect(logInfoMock).toHaveBeenCalledWith(
+    `Failed to save: Unable to reserve cache with key ${primaryKey}, another job may be creating this cache. More details: undefined`
   )
+
   expect(reserveCacheMock).toHaveBeenCalledTimes(1)
   expect(reserveCacheMock).toHaveBeenCalledWith(primaryKey, paths, {
     compressionMethod: compression
@@ -203,7 +220,7 @@ test('save with server error should fail', async () => {
   const filePath = 'node_modules'
   const primaryKey = 'Linux-node-bb828da54c148048dd17899ba9fda624811cfb43'
   const cachePaths = [path.resolve(filePath)]
-
+  const logWarningMock = jest.spyOn(core, 'warning')
   const cacheId = 4
   const reserveCacheMock = jest
     .spyOn(cacheHttpClient, 'reserveCache')
@@ -228,9 +245,12 @@ test('save with server error should fail', async () => {
     .spyOn(cacheUtils, 'getCompressionMethod')
     .mockReturnValueOnce(Promise.resolve(compression))
 
-  await expect(saveCache([filePath], primaryKey)).rejects.toThrowError(
+  await saveCache([filePath], primaryKey)
-    'HTTP Error Occurred'
+  expect(logWarningMock).toHaveBeenCalledTimes(1)
+  expect(logWarningMock).toHaveBeenCalledWith(
+    'Failed to save: HTTP Error Occurred'
   )
+
   expect(reserveCacheMock).toHaveBeenCalledTimes(1)
   expect(reserveCacheMock).toHaveBeenCalledWith(primaryKey, [filePath], {
     compressionMethod: compression
@@ -290,3 +310,14 @@ test('save with valid inputs uploads a cache', async () => {
   expect(saveCacheMock).toHaveBeenCalledWith(cacheId, archiveFile, undefined)
   expect(getCompressionMock).toHaveBeenCalledTimes(1)
 })
+
+test('save with non existing path should not save cache', async () => {
+  const path = 'node_modules'
+  const primaryKey = 'Linux-node-bb828da54c148048dd17899ba9fda624811cfb43'
+  jest.spyOn(cacheUtils, 'resolvePaths').mockImplementation(async () => {
+    return []
+  })
+  await expect(saveCache([path], primaryKey)).rejects.toThrowError(
+    `Path Validation Error: Path(s) specified in the action for caching do(es) not exist, hence no cache is being saved.`
+  )
+})

packages/cache/__tests__/tar.test.ts

@@ -143,6 +143,8 @@ test('zstd create tar', async () => {
       'zstd -T0 --long=30',
       '-cf',
       IS_WINDOWS ? CacheFilename.Zstd.replace(/\\/g, '/') : CacheFilename.Zstd,
+      '--exclude',
+      IS_WINDOWS ? CacheFilename.Zstd.replace(/\\/g, '/') : CacheFilename.Zstd,
       '-P',
       '-C',
       IS_WINDOWS ? workspace?.replace(/\\/g, '/') : workspace,
@@ -180,6 +182,8 @@ test('gzip create tar', async () => {
       '-z',
       '-cf',
       IS_WINDOWS ? CacheFilename.Gzip.replace(/\\/g, '/') : CacheFilename.Gzip,
+      '--exclude',
+      IS_WINDOWS ? CacheFilename.Gzip.replace(/\\/g, '/') : CacheFilename.Gzip,
       '-P',
       '-C',
       IS_WINDOWS ? workspace?.replace(/\\/g, '/') : workspace,

packages/cache/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@actions/cache",
-  "version": "2.0.4",
+  "version": "3.0.0",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@actions/cache",
-      "version": "2.0.3",
+      "version": "3.0.0",
       "license": "MIT",
       "dependencies": {
         "@actions/core": "^1.2.6",

packages/cache/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@actions/cache",
-  "version": "2.0.4",
+  "version": "3.0.0",
   "preview": true,
   "description": "Actions cache lib",
   "keywords": [

packages/cache/src/cache.ts

@@ -86,23 +86,24 @@ export async function restoreCache(
   }
 
   const compressionMethod = await utils.getCompressionMethod()
-
+  let archivePath = ''
-  // path are needed to compute version
-  const cacheEntry = await cacheHttpClient.getCacheEntry(keys, paths, {
-    compressionMethod
-  })
-  if (!cacheEntry?.archiveLocation) {
-    // Cache not found
-    return undefined
-  }
-
-  const archivePath = path.join(
-    await utils.createTempDirectory(),
-    utils.getCacheFileName(compressionMethod)
-  )
-  core.debug(`Archive Path: ${archivePath}`)
-
   try {
+    // path are needed to compute version
+    const cacheEntry = await cacheHttpClient.getCacheEntry(keys, paths, {
+      compressionMethod
+    })
+
+    if (!cacheEntry?.archiveLocation) {
+      // Cache not found
+      return undefined
+    }
+
+    archivePath = path.join(
+      await utils.createTempDirectory(),
+      utils.getCacheFileName(compressionMethod)
+    )
+    core.debug(`Archive Path: ${archivePath}`)
+
     // Download the cache from the cache entry
     await cacheHttpClient.downloadCache(
       cacheEntry.archiveLocation,
@@ -123,6 +124,16 @@ export async function restoreCache(
 
     await extractTar(archivePath, compressionMethod)
     core.info('Cache restored successfully')
+
+    return cacheEntry.cacheKey
+  } catch (error) {
+    const typedError = error as Error
+    if (typedError.name === ValidationError.name) {
+      throw error
+    } else {
+      // Supress all non-validation cache related errors because caching should be optional
+      core.warning(`Failed to restore: ${(error as Error).message}`)
+    }
   } finally {
     // Try to delete the archive to save space
     try {
@@ -132,7 +143,7 @@ export async function restoreCache(
     }
   }
 
-  return cacheEntry.cacheKey
+  return undefined
 }
 
 /**
@@ -152,12 +163,18 @@ export async function saveCache(
   checkKey(key)
 
   const compressionMethod = await utils.getCompressionMethod()
-  let cacheId = null
+  let cacheId = -1
 
   const cachePaths = await utils.resolvePaths(paths)
   core.debug('Cache Paths:')
   core.debug(`${JSON.stringify(cachePaths)}`)
 
+  if (cachePaths.length === 0) {
+    throw new Error(
+      `Path Validation Error: Path(s) specified in the action for caching do(es) not exist, hence no cache is being saved.`
+    )
+  }
+
   const archiveFolder = await utils.createTempDirectory()
   const archivePath = path.join(
     archiveFolder,
@@ -211,6 +228,15 @@ export async function saveCache(
 
     core.debug(`Saving Cache (ID: ${cacheId})`)
     await cacheHttpClient.saveCache(cacheId, archivePath, options)
+  } catch (error) {
+    const typedError = error as Error
+    if (typedError.name === ValidationError.name) {
+      throw error
+    } else if (typedError.name === ReserveCacheError.name) {
+      core.info(`Failed to save: ${typedError.message}`)
+    } else {
+      core.warning(`Failed to save: ${typedError.message}`)
+    }
   } finally {
     // Try to delete the archive to save space
     try {

packages/cache/src/internal/tar.ts

@@ -61,15 +61,15 @@ export async function extractTar(
   // Create directory to extract tar into
   const workingDirectory = getWorkingDirectory()
   await io.mkdirP(workingDirectory)
-  // --d: Decompress.
+  // --decompress: Decompress.
   // --long=#: Enables long distance matching with # bits. Maximum is 30 (1GB) on 32-bit OS and 31 (2GB) on 64-bit.
   // Using 30 here because we also support 32-bit self-hosted runners.
   function getCompressionProgram(): string[] {
     switch (compressionMethod) {
       case CompressionMethod.Zstd:
-        return ['--use-compress-program', 'zstd -d --long=30']
+        return ['--use-compress-program', 'zstd --decompress --long=30']
       case CompressionMethod.ZstdWithoutLong:
-        return ['--use-compress-program', 'zstd -d']
+        return ['--use-compress-program', 'zstd --decompress']
       default:
         return ['-z']
     }
@@ -99,16 +99,16 @@ export async function createTar(
   )
   const workingDirectory = getWorkingDirectory()
 
-  // -T#: Compress using # working thread. If # is 0, attempt to detect and use the number of physical CPU cores.
+  // --threads=#: Compress using # working thread. If # is 0, attempt to detect and use the number of physical CPU cores.
   // --long=#: Enables long distance matching with # bits. Maximum is 30 (1GB) on 32-bit OS and 31 (2GB) on 64-bit.
   // Using 30 here because we also support 32-bit self-hosted runners.
   // Long range mode is added to zstd in v1.3.2 release, so we will not use --long in older version of zstd.
   function getCompressionProgram(): string[] {
     switch (compressionMethod) {
       case CompressionMethod.Zstd:
-        return ['--use-compress-program', 'zstd -T0 --long=30']
+        return ['--use-compress-program', 'zstd --threads=0 --long=30']
       case CompressionMethod.ZstdWithoutLong:
-        return ['--use-compress-program', 'zstd -T0']
+        return ['--use-compress-program', 'zstd --threads=0']
       default:
         return ['-z']
     }
@@ -118,6 +118,8 @@ export async function createTar(
     ...getCompressionProgram(),
     '-cf',
     cacheFileName.replace(new RegExp(`\\${path.sep}`, 'g'), '/'),
+    '--exclude',
+    cacheFileName.replace(new RegExp(`\\${path.sep}`, 'g'), '/'),
     '-P',
     '-C',
     workingDirectory.replace(new RegExp(`\\${path.sep}`, 'g'), '/'),
@@ -131,16 +133,15 @@ export async function listTar(
   archivePath: string,
   compressionMethod: CompressionMethod
 ): Promise<void> {
-  // --d: Decompress.
   // --long=#: Enables long distance matching with # bits.
   // Maximum is 30 (1GB) on 32-bit OS and 31 (2GB) on 64-bit.
   // Using 30 here because we also support 32-bit self-hosted runners.
   function getCompressionProgram(): string[] {
     switch (compressionMethod) {
       case CompressionMethod.Zstd:
-        return ['--use-compress-program', 'zstd -d --long=30']
+        return ['--use-compress-program', 'zstd --long=30']
       case CompressionMethod.ZstdWithoutLong:
-        return ['--use-compress-program', 'zstd -d']
+        return ['--use-compress-program', 'zstd']
       default:
         return ['-z']
     }

packages/core/README.md

@@ -309,4 +309,27 @@ outputs:
 runs:
   using: 'node12'
   main: 'dist/index.js'
-```
+```
+
+#### Filesystem path helpers
+
+You can use these methods to manipulate file paths across operating systems.
+
+The `toPosixPath` function converts input paths to Posix-style (Linux) paths.
+The `toWin32Path` function converts input paths to Windows-style paths. These
+functions work independently of the underlying runner operating system.
+
+```js
+toPosixPath('\\foo\\bar') // => /foo/bar
+toWin32Path('/foo/bar') // => \foo\bar
+```
+
+The `toPlatformPath` function converts input paths to the expected value on the runner's operating system.
+
+```js
+// On a Windows runner.
+toPlatformPath('/foo/bar') // => \foo\bar
+
+// On a Linux runner.
+toPlatformPath('\\foo\\bar') // => /foo/bar
+```

packages/core/RELEASES.md

@@ -1,5 +1,8 @@
 # @actions/core Releases
 
+### 1.9.0
+- Added `toPosixPath`, `toWin32Path` and `toPlatformPath` utilities [#1102](https://github.com/actions/toolkit/pull/1102)
+
 ### 1.8.2
 - Update to v2.0.1 of `@actions/http-client` [#1087](https://github.com/actions/toolkit/pull/1087)
 

packages/core/__tests__/path-utils.test.ts

@@ -0,0 +1,162 @@
+import * as path from 'path'
+
+import {toPlatformPath, toPosixPath, toWin32Path} from '../src/path-utils'
+
+describe('#toPosixPath', () => {
+  const cases: {
+    only?: boolean
+    name: string
+    input: string
+    expected: string
+  }[] = [
+    {
+      name: 'empty string',
+      input: '',
+      expected: ''
+    },
+    {
+      name: 'single value',
+      input: 'foo',
+      expected: 'foo'
+    },
+    {
+      name: 'with posix relative',
+      input: 'foo/bar/baz',
+      expected: 'foo/bar/baz'
+    },
+    {
+      name: 'with posix absolute',
+      input: '/foo/bar/baz',
+      expected: '/foo/bar/baz'
+    },
+    {
+      name: 'with win32 relative',
+      input: 'foo\\bar\\baz',
+      expected: 'foo/bar/baz'
+    },
+    {
+      name: 'with win32 absolute',
+      input: '\\foo\\bar\\baz',
+      expected: '/foo/bar/baz'
+    },
+    {
+      name: 'with a mix',
+      input: '\\foo/bar/baz',
+      expected: '/foo/bar/baz'
+    }
+  ]
+
+  for (const tc of cases) {
+    const fn = tc.only ? it.only : it
+    fn(tc.name, () => {
+      const result = toPosixPath(tc.input)
+      expect(result).toEqual(tc.expected)
+    })
+  }
+})
+
+describe('#toWin32Path', () => {
+  const cases: {
+    only?: boolean
+    name: string
+    input: string
+    expected: string
+  }[] = [
+    {
+      name: 'empty string',
+      input: '',
+      expected: ''
+    },
+    {
+      name: 'single value',
+      input: 'foo',
+      expected: 'foo'
+    },
+    {
+      name: 'with posix relative',
+      input: 'foo/bar/baz',
+      expected: 'foo\\bar\\baz'
+    },
+    {
+      name: 'with posix absolute',
+      input: '/foo/bar/baz',
+      expected: '\\foo\\bar\\baz'
+    },
+    {
+      name: 'with win32 relative',
+      input: 'foo\\bar\\baz',
+      expected: 'foo\\bar\\baz'
+    },
+    {
+      name: 'with win32 absolute',
+      input: '\\foo\\bar\\baz',
+      expected: '\\foo\\bar\\baz'
+    },
+    {
+      name: 'with a mix',
+      input: '\\foo/bar\\baz',
+      expected: '\\foo\\bar\\baz'
+    }
+  ]
+
+  for (const tc of cases) {
+    const fn = tc.only ? it.only : it
+    fn(tc.name, () => {
+      const result = toWin32Path(tc.input)
+      expect(result).toEqual(tc.expected)
+    })
+  }
+})
+
+describe('#toPlatformPath', () => {
+  const cases: {
+    only?: boolean
+    name: string
+    input: string
+    expected: string
+  }[] = [
+    {
+      name: 'empty string',
+      input: '',
+      expected: ''
+    },
+    {
+      name: 'single value',
+      input: 'foo',
+      expected: 'foo'
+    },
+    {
+      name: 'with posix relative',
+      input: 'foo/bar/baz',
+      expected: path.join('foo', 'bar', 'baz')
+    },
+    {
+      name: 'with posix absolute',
+      input: '/foo/bar/baz',
+      expected: path.join(path.sep, 'foo', 'bar', 'baz')
+    },
+    {
+      name: 'with win32 relative',
+      input: 'foo\\bar\\baz',
+      expected: path.join('foo', 'bar', 'baz')
+    },
+    {
+      name: 'with win32 absolute',
+      input: '\\foo\\bar\\baz',
+      expected: path.join(path.sep, 'foo', 'bar', 'baz')
+    },
+    {
+      name: 'with a mix',
+      input: '\\foo/bar\\baz',
+      expected: path.join(path.sep, 'foo', 'bar', 'baz')
+    }
+  ]
+
+  for (const tc of cases) {
+    const fn = tc.only ? it.only : it
+    fn(tc.name, () => {
+      const result = toPlatformPath(tc.input)
+      expect(result).toEqual(tc.expected)
+    })
+  }
+})

packages/core/package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@actions/core",
-  "version": "1.8.2",
+  "version": "1.9.0",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {

packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@actions/core",
-  "version": "1.8.2",
+  "version": "1.9.0",
   "description": "Actions core lib",
   "keywords": [
     "github",

packages/core/src/core.ts

@@ -369,3 +369,8 @@ export {summary} from './summary'
  * @deprecated use core.summary
  */
 export {markdownSummary} from './summary'
+
+/**
+ * Path exports
+ */
+export {toPosixPath, toWin32Path, toPlatformPath} from './path-utils'

packages/core/src/path-utils.ts

@@ -0,0 +1,35 @@
+import * as path from 'path'
+
+/**
+ * toPosixPath converts the given path to the posix form. On Windows, \\ will be
+ * replaced with /.
+ *
+ * @param pth. Path to transform.
+ * @return string Posix path.
+ */
+export function toPosixPath(pth: string): string {
+  return pth.replace(/[\\]/g, '/')
+}
+
+/**
+ * toWin32Path converts the given path to the win32 form. On Linux, / will be
+ * replaced with \\.
+ *
+ * @param pth. Path to transform.
+ * @return string Win32 path.
+ */
+export function toWin32Path(pth: string): string {
+  return pth.replace(/[/]/g, '\\')
+}
+
+/**
+ * toPlatformPath converts the given path to a platform-specific path. It does
+ * this by replacing instances of / and \ with the platform-specific path
+ * separator.
+ *
+ * @param pth The path to platformize.
+ * @return string The platform-specific path.
+ */
+export function toPlatformPath(pth: string): string {
+  return pth.replace(/[/\\]/g, path.sep)
+}