Zy Filemanager

📁 File Browser

Name	Size	Permissions	Actions
📝 create.js (2,395 bytes)	2.34 KB	0644	✍️ ⬇️ 🗑️
📝 extract.js (2,852 bytes)	2.79 KB	0644	✍️ ⬇️ 🗑️
📝 get-write-flag.js (921 bytes)	921 B	0644	✍️ ⬇️ 🗑️
📝 header.js (9,154 bytes)	8.94 KB	0644	✍️ ⬇️ 🗑️
📝 high-level-opt.js (760 bytes)	760 B	0644	✍️ ⬇️ 🗑️
📝 large-numbers.js (2,229 bytes)	2.18 KB	0644	✍️ ⬇️ 🗑️
📝 list.js (3,224 bytes)	3.15 KB	0644	✍️ ⬇️ 🗑️
📝 mkdir.js (5,485 bytes)	5.36 KB	0644	✍️ ⬇️ 🗑️
📝 mode-fix.js (649 bytes)	649 B	0644	✍️ ⬇️ 🗑️
📝 normalize-unicode.js (412 bytes)	412 B	0644	✍️ ⬇️ 🗑️
📝 normalize-windows-path.js (410 bytes)	410 B	0644	✍️ ⬇️ 🗑️
📝 pack.js (10,021 bytes)	9.79 KB	0644	✍️ ⬇️ 🗑️
📝 parse.js (16,322 bytes)	15.94 KB	0644	✍️ ⬇️ 🗑️
📝 path-reservations.js (4,410 bytes)	4.31 KB	0644	✍️ ⬇️ 🗑️
📝 pax.js (4,068 bytes)	3.97 KB	0644	✍️ ⬇️ 🗑️
📝 read-entry.js (2,842 bytes)	2.78 KB	0644	✍️ ⬇️ 🗑️
📝 replace.js (5,776 bytes)	5.64 KB	0644	✍️ ⬇️ 🗑️
📝 strip-absolute-path.js (917 bytes)	917 B	0644	✍️ ⬇️ 🗑️
📝 strip-trailing-slashes.js (394 bytes)	394 B	0644	✍️ ⬇️ 🗑️
📝 types.js (1,096 bytes)	1.07 KB	0644	✍️ ⬇️ 🗑️
📝 unpack.js (25,835 bytes)	25.23 KB	0644	✍️ ⬇️ 🗑️
📝 update.js (937 bytes)	937 B	0644	✍️ ⬇️ 🗑️
📝 warn-mixin.js (725 bytes)	725 B	0644	✍️ ⬇️ 🗑️
📝 winchars.js (535 bytes)	535 B	0644	✍️ ⬇️ 🗑️
📝 write-entry.js (15,300 bytes)	14.94 KB	0644	✍️ ⬇️ 🗑️

✍️ Editing: path-reservations.js

            File: /opt/alt/alt-nodejs20/root/usr/lib/node_modules/npm/node_modules.bundled/tar/lib/path-reservations.js

            Size: 4.31 KB | 
            Last Modified: 2026-04-09 19:16:14        

// A path exclusive reservation system
// reserve([list, of, paths], fn)
// When the fn is first in line for all its paths, it
// is called with a cb that clears the reservation.
//
// Used by async unpack to avoid clobbering paths in use,
// while still allowing maximal safe parallelization.

const assert = require('assert')
const normalize = require('./normalize-unicode.js')
const stripSlashes = require('./strip-trailing-slashes.js')
const { join } = require('path')

const platform = process.env.TESTING_TAR_FAKE_PLATFORM || process.platform
const isWindows = platform === 'win32'

module.exports = () => {
  // path => [function or Set]
  // A Set object means a directory reservation
  // A fn is a direct reservation on that path
  const queues = new Map()

// fn => {paths:[path,...], dirs:[path, ...]}
  const reservations = new Map()

// return a set of parent dirs for a given path
  // '/a/b/c/d' -> ['/', '/a', '/a/b', '/a/b/c', '/a/b/c/d']
  const getDirs = path => {
    const dirs = path.split('/').slice(0, -1).reduce((set, path) => {
      if (set.length) {
        path = join(set[set.length - 1], path)
      }
      set.push(path || '/')
      return set
    }, [])
    return dirs
  }

// functions currently running
  const running = new Set()

// return the queues for each path the function cares about
  // fn => {paths, dirs}
  const getQueues = fn => {
    const res = reservations.get(fn)
    /* istanbul ignore if - unpossible */
    if (!res) {
      throw new Error('function does not have any path reservations')
    }
    return {
      paths: res.paths.map(path => queues.get(path)),
      dirs: [...res.dirs].map(path => queues.get(path)),
    }
  }

// check if fn is first in line for all its paths, and is
  // included in the first set for all its dir queues
  const check = fn => {
    const { paths, dirs } = getQueues(fn)
    return paths.every(q => q[0] === fn) &&
      dirs.every(q => q[0] instanceof Set && q[0].has(fn))
  }

// run the function if it's first in line and not already running
  const run = fn => {
    if (running.has(fn) || !check(fn)) {
      return false
    }
    running.add(fn)
    fn(() => clear(fn))
    return true
  }

const clear = fn => {
    if (!running.has(fn)) {
      return false
    }

const { paths, dirs } = reservations.get(fn)
    const next = new Set()

paths.forEach(path => {
      const q = queues.get(path)
      assert.equal(q[0], fn)
      if (q.length === 1) {
        queues.delete(path)
      } else {
        q.shift()
        if (typeof q[0] === 'function') {
          next.add(q[0])
        } else {
          q[0].forEach(fn => next.add(fn))
        }
      }
    })

dirs.forEach(dir => {
      const q = queues.get(dir)
      assert(q[0] instanceof Set)
      if (q[0].size === 1 && q.length === 1) {
        queues.delete(dir)
      } else if (q[0].size === 1) {
        q.shift()

// must be a function or else the Set would've been reused
        next.add(q[0])
      } else {
        q[0].delete(fn)
      }
    })
    running.delete(fn)

next.forEach(fn => run(fn))
    return true
  }

const reserve = (paths, fn) => {
    // collide on matches across case and unicode normalization
    // On windows, thanks to the magic of 8.3 shortnames, it is fundamentally
    // impossible to determine whether two paths refer to the same thing on
    // disk, without asking the kernel for a shortname.
    // So, we just pretend that every path matches every other path here,
    // effectively removing all parallelization on windows.
    paths = isWindows ? ['win32 parallelization disabled'] : paths.map(p => {
      // don't need normPath, because we skip this entirely for windows
      return stripSlashes(join(normalize(p))).toLowerCase()
    })

const dirs = new Set(
      paths.map(path => getDirs(path)).reduce((a, b) => a.concat(b))
    )
    reservations.set(fn, { dirs, paths })
    paths.forEach(path => {
      const q = queues.get(path)
      if (!q) {
        queues.set(path, [fn])
      } else {
        q.push(fn)
      }
    })
    dirs.forEach(dir => {
      const q = queues.get(dir)
      if (!q) {
        queues.set(dir, [new Set([fn])])
      } else if (q[q.length - 1] instanceof Set) {
        q[q.length - 1].add(fn)
      } else {
        q.push(new Set([fn]))
      }
    })

return run(fn)
  }

return { check, reserve }
}

↩️ Back

Zy Filemanager

📁 File Browser

📤 Upload Files

Single File

Multiple Files

ZIP Extract

➕ Create New

New Folder

New File

✍️ Editing: path-reservations.js

Backup Management