SEC [ tranzendo.com ]

Linux premium117.web-hosting.com 4.18.0-553.54.1.lve.el8.x86_64 #1 SMP Wed Jun 4 13:01:13 UTC 2025 x86_64

LiteSpeed

162.0.229.114 | Your IP: 216.73.216.149

Cant read [ /etc/named.conf ]

[ drwxr-xr-x ]

/ opt / alt / alt-nodejs24 / root / usr / lib / node_modules / npm / node_modules.bundled / @npmcli / arborist / lib /

Home Upload Mass Deface Mass Delete Back Connect Info Server

Server Info

Operating System	:	Linux premium117.web-hosting.com 4.18.0-553.54.1.lve.el8.x86_64 #1 SMP Wed Jun 4 13:01:13 UTC 2025 x86_64
User / Group	:	539[sawaunyk] / 539[sawaunyk]
PHP Version	:	8.1.34
IP Server	:	162.0.229.114
Your IP	:	216.73.216.149
Storage	:	Total = 48.91 GB, Free = 31.66 GB [64%]
Domains	:	Cant read [ /etc/named.conf ]
Software	:	LiteSpeed
Disable Functions	:	All function is accessible
Useful Functions	:	gcc, lcc, cc, ld, make, php, perl, python, ruby, tar, gzip, bzip, bzialfa2, nc, locate, suidperl, git, docker, ssh
Downloader	:	wget, fetch, lynx, links, curl, get, lwp-mirror
CURL : ON \| SSH2 : OFF \| Magic Quotes : OFF \| MySQL : ON \| MSSQL : OFF \| PostgreSQL : ON \| Oracle : OFF
Safe Mode : OFF \| Open Basedir : NONE \| Safe Mode Exec Dir : NONE \| Safe Mode Include Dir : NONE

diff.js

// a tree representing the difference between two trees
// A Diff node's parent is not necessarily the parent of
// the node location it refers to, but rather the highest level
// node that needs to be either changed or removed.
// Thus, the root Diff node is the shallowest change required
// for a given branch of the tree being mutated.

const { depth } = require('treeverse')
const { existsSync } = require('node:fs')

const ssri = require('ssri')

class Diff {
  constructor ({ actual, ideal, filterSet, shrinkwrapInflated, omit }) {
    this.omit = omit
    this.filterSet = filterSet
    this.shrinkwrapInflated = shrinkwrapInflated
    this.children = []
    this.actual = actual
    this.ideal = ideal
    if (this.ideal) {
      this.resolved = this.ideal.resolved
      this.integrity = this.ideal.integrity
    }
    this.action = getAction(this)
    this.parent = null
    // the set of leaf nodes that we rake up to the top level
    this.leaves = []
    // the set of nodes that don't change in this branch of the tree
    this.unchanged = []
    // the set of nodes that will be removed in this branch of the tree
    this.removed = []
  }

static calculate ({
    actual,
    ideal,
    filterNodes = [],
    shrinkwrapInflated = new Set(),
    omit = new Set(),
  }) {
    // if there's a filterNode, then:
    // - get the path from the root to the filterNode.  The root or
    //   root.target should have an edge either to the filterNode or
    //   a link to the filterNode.  If not, abort.  Add the path to the
    //   filterSet.
    // - Add set of Nodes depended on by the filterNode to filterSet.
    // - Anything outside of that set should be ignored by getChildren
    const filterSet = new Set()
    const extraneous = new Set()
    for (const filterNode of filterNodes) {
      const { root } = filterNode
      if (root !== ideal && root !== actual) {
        throw new Error('invalid filterNode: outside idealTree/actualTree')
      }
      const rootTarget = root.target
      const edge = [...rootTarget.edgesOut.values()].filter(e => {
        return e.to && (e.to === filterNode || e.to.target === filterNode)
      })[0]
      filterSet.add(root)
      filterSet.add(rootTarget)
      filterSet.add(ideal)
      filterSet.add(actual)
      if (edge && edge.to) {
        filterSet.add(edge.to)
        filterSet.add(edge.to.target)
      }
      filterSet.add(filterNode)

depth({
        tree: filterNode,
        visit: node => filterSet.add(node),
        getChildren: node => {
          node = node.target
          const loc = node.location
          const idealNode = ideal.inventory.get(loc)
          const ideals = !idealNode ? []
            : [...idealNode.edgesOut.values()].filter(e => e.to).map(e => e.to)
          const actualNode = actual.inventory.get(loc)
          const actuals = !actualNode ? []
            : [...actualNode.edgesOut.values()].filter(e => e.to).map(e => e.to)
          if (actualNode) {
            for (const child of actualNode.children.values()) {
              if (child.extraneous) {
                extraneous.add(child)
              }
            }
          }

return ideals.concat(actuals)
        },
      })
    }
    for (const extra of extraneous) {
      filterSet.add(extra)
    }

return depth({
      tree: new Diff({ actual, ideal, filterSet, shrinkwrapInflated, omit }),
      getChildren,
      leave,
    })
  }
}

const getAction = ({ actual, ideal }) => {
  if (!ideal) {
    return 'REMOVE'
  }

// bundled meta-deps are copied over to the ideal tree when we visit it,
  // so they'll appear to be missing here.  There's no need to handle them
  // in the diff, though, because they'll be replaced at reify time anyway
  // Otherwise, add the missing node.
  if (!actual) {
    return ideal.inDepBundle ? null : 'ADD'
  }

// always ignore the root node
  if (ideal.isRoot && actual.isRoot) {
    return null
  }

// if the versions don't match, it's a change no matter what
  if (ideal.version !== actual.version) {
    return 'CHANGE'
  }

const binsExist = ideal.binPaths.every((path) => existsSync(path))

// top nodes, links, and git deps won't have integrity, but do have resolved
  // if neither node has integrity, the bins exist, and either (a) neither
  // node has a resolved value or (b) they both do and match, then we can
  // leave this one alone since we already know the versions match due to
  // the condition above.  The "neither has resolved" case (a) cannot be
  // treated as a 'mark CHANGE and refetch', because shrinkwraps, bundles,
  // and link deps may lack this information, and we don't want to try to
  // go to the registry for something that isn't there.
  const noIntegrity = !ideal.integrity && !actual.integrity
  const noResolved = !ideal.resolved && !actual.resolved
  const resolvedMatch = ideal.resolved && ideal.resolved === actual.resolved
  if (noIntegrity && binsExist && (resolvedMatch || noResolved)) {
    return null
  }

// otherwise, verify that it's the same bits
  // note that if ideal has integrity, and resolved doesn't, we treat
  // that as a 'change', so that it gets re-fetched and locked down.
  const integrityMismatch = !ideal.integrity || !actual.integrity ||
    !ssri.parse(ideal.integrity).match(actual.integrity)
  if (integrityMismatch || !binsExist) {
    return 'CHANGE'
  }

return null
}

const allChildren = node => {
  if (!node) {
    return new Map()
  }

// if the node is root, and also a link, then what we really
  // want is to traverse the target's children
  if (node.isRoot && node.isLink) {
    return allChildren(node.target)
  }

const kids = new Map()
  for (const n of [node, ...node.fsChildren]) {
    for (const kid of n.children.values()) {
      kids.set(kid.path, kid)
    }
  }
  return kids
}

// functions for the walk options when we traverse the trees
// to create the diff tree
const getChildren = diff => {
  const children = []
  const {
    actual,
    ideal,
    unchanged,
    removed,
    filterSet,
    shrinkwrapInflated,
    omit,
  } = diff

// Note: we DON'T diff fsChildren themselves, because they are either
  // included in the package contents, or part of some other project, and
  // will never appear in legacy shrinkwraps anyway.  but we _do_ include the
  // child nodes of fsChildren, because those are nodes that we are typically
  // responsible for installing.
  const actualKids = allChildren(actual)
  const idealKids = allChildren(ideal)

if (ideal && ideal.hasShrinkwrap && !shrinkwrapInflated.has(ideal)) {
    // Guaranteed to get a diff.leaves here, because we always
    // be called with a proper Diff object when ideal has a shrinkwrap
    // that has not been inflated.
    diff.leaves.push(diff)
    return children
  }

const paths = new Set([...actualKids.keys(), ...idealKids.keys()])
  for (const path of paths) {
    const actual = actualKids.get(path)
    const ideal = idealKids.get(path)
    diffNode({
      actual,
      ideal,
      children,
      unchanged,
      removed,
      filterSet,
      shrinkwrapInflated,
      omit,
    })
  }

if (diff.leaves && !children.length) {
    diff.leaves.push(diff)
  }

return children
}

const diffNode = ({
  actual,
  ideal,
  children,
  unchanged,
  removed,
  filterSet,
  shrinkwrapInflated,
  omit,
}) => {
  if (filterSet.size && !(filterSet.has(ideal) || filterSet.has(actual))) {
    return
  }

if (ideal?.shouldOmit?.(omit)) {
    ideal.inert = true
  }

// Treat inert nodes as undefined for the purposes of diffing.
  if (ideal?.inert) {
    ideal = undefined
  }
  if (!actual && !ideal) {
    return
  }

const action = getAction({ actual, ideal })

// if it's a match, then get its children
  // otherwise, this is the child diff node
  if (action || (!shrinkwrapInflated.has(ideal) && ideal.hasShrinkwrap)) {
    if (action === 'REMOVE') {
      removed.push(actual)
    }
    children.push(new Diff({ actual, ideal, filterSet, shrinkwrapInflated, omit }))
  } else {
    unchanged.push(ideal)
    // !*! Weird dirty hack warning !*!
    //
    // Bundled deps aren't loaded in the ideal tree, because we don't know
    // what they are going to be without unpacking.  Swap them over now if
    // the bundling node isn't changing, so we don't prune them later.
    //
    // It's a little bit dirty to be doing this here, since it means that
    // diffing trees can mutate them, but otherwise we have to walk over
    // all unchanging bundlers and correct the diff later, so it's more
    // efficient to just fix it while we're passing through already.
    //
    // Note that moving over a bundled dep will break the links to other
    // deps under this parent, which may have been transitively bundled.
    // Breaking those links means that we'll no longer see the transitive
    // dependency, meaning that it won't appear as bundled any longer!
    // In order to not end up dropping transitively bundled deps, we have
    // to get the list of nodes to move, then move them all at once, rather
    // than moving them one at a time in the first loop.
    const bd = ideal.package.bundleDependencies
    if (actual && bd && bd.length) {
      const bundledChildren = []
      for (const node of actual.children.values()) {
        if (node.inBundle) {
          bundledChildren.push(node)
        }
      }
      for (const node of bundledChildren) {
        node.parent = ideal
      }
    }
    children.push(...getChildren({
      actual,
      ideal,
      unchanged,
      removed,
      filterSet,
      shrinkwrapInflated,
      omit,
    }))
  }
}

// set the parentage in the leave step so that we aren't attaching
// child nodes only to remove them later.  also bubble up the unchanged
// nodes so that we can move them out of staging in the reification step.
const leave = (diff, children) => {
  children.forEach(kid => {
    kid.parent = diff
    diff.leaves.push(...kid.leaves)
    diff.unchanged.push(...kid.unchanged)
    diff.removed.push(...kid.removed)
  })
  diff.children = children
  return diff
}

module.exports = Diff

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	root/root	drwxr-xr-x	2026-03-14 08:32:09
..	dir	-	root/root	drwxr-xr-x	2026-03-14 08:32:09
arborist	dir	-	root/root	drwxr-xr-x	2026-03-14 08:32:09
add-rm-pkg-deps.js	text/plain	4.89 KB	root/root	-rw-r--r--	2026-02-23 07:38:42
audit-report.js	text/plain	9.34 KB	root/root	-rw-r--r--	2026-02-23 07:38:42
calc-dep-flags.js	text/plain	4.07 KB	root/root	-rw-r--r--	2026-02-23 07:38:42
can-place-dep.js	text/plain	13.94 KB	root/root	-rw-r--r--	2026-02-23 07:38:42
case-insensitive-map.js	text/plain	1.21 KB	root/root	-rw-r--r--	2026-02-23 07:38:42
consistent-resolve.js	text/plain	1.22 KB	root/root	-rw-r--r--	2026-02-23 07:38:42
debug.js	text/plain	1.25 KB	root/root	-rw-r--r--	2026-02-23 07:38:42
deepest-nesting-target.js	text/plain	691 B	root/root	-rw-r--r--	2026-02-23 07:38:42
dep-valid.js	text/plain	5 KB	root/root	-rw-r--r--	2026-02-23 07:38:42
diff.js	text/plain	9.89 KB	root/root	-rw-r--r--	2026-02-23 07:38:42
edge.js	text/plain	9.3 KB	root/root	-rw-r--r--	2026-02-23 07:38:42
from-path.js	text/plain	1.07 KB	root/root	-rw-r--r--	2026-02-23 07:38:42
gather-dep-set.js	text/plain	1.26 KB	root/root	-rw-r--r--	2026-02-23 07:38:42
index.js	text/plain	273 B	root/root	-rw-r--r--	2026-02-23 07:38:42
inventory.js	text/plain	3.25 KB	root/root	-rw-r--r--	2026-02-23 07:38:42
link.js	text/plain	3.04 KB	root/root	-rw-r--r--	2026-02-23 07:38:42
node.js	text/plain	48.39 KB	root/root	-rw-r--r--	2026-02-23 07:38:42
optional-set.js	text/plain	1.22 KB	root/root	-rw-r--r--	2026-02-23 07:38:42
override-resolves.js	text/plain	225 B	root/root	-rw-r--r--	2026-02-23 07:38:42
override-set.js	text/plain	4.95 KB	root/root	-rw-r--r--	2026-02-23 07:38:42
packument-cache.js	text/plain	2.5 KB	root/root	-rw-r--r--	2026-02-23 07:38:42
peer-entry-sets.js	text/plain	2.57 KB	root/root	-rw-r--r--	2026-02-23 07:38:42
place-dep.js	text/plain	19.78 KB	root/root	-rw-r--r--	2026-02-23 07:38:42
printable.js	text/plain	5.1 KB	root/root	-rw-r--r--	2026-02-23 07:38:42
query-selector-all.js	text/x-c++	28.85 KB	root/root	-rw-r--r--	2026-02-23 07:38:42
realpath.js	text/plain	2.59 KB	root/root	-rw-r--r--	2026-02-23 07:38:42
relpath.js	text/plain	136 B	root/root	-rw-r--r--	2026-02-23 07:38:42
reset-dep-flags.js	text/plain	638 B	root/root	-rw-r--r--	2026-02-23 07:38:42
retire-path.js	text/plain	501 B	root/root	-rw-r--r--	2026-02-23 07:38:42
shrinkwrap.js	text/plain	36.83 KB	root/root	-rw-r--r--	2026-02-23 07:38:42
signal-handling.js	text/plain	2.19 KB	root/root	-rw-r--r--	2026-02-23 07:38:42
signals.js	text/plain	1.35 KB	root/root	-rw-r--r--	2026-02-23 07:38:42
spec-from-lock.js	text/plain	874 B	root/root	-rw-r--r--	2026-02-23 07:38:42
tracker.js	text/plain	2.92 KB	root/root	-rw-r--r--	2026-02-23 07:38:42
tree-check.js	text/plain	4.04 KB	root/root	-rw-r--r--	2026-02-23 07:38:42
version-from-tgz.js	text/plain	1.45 KB	root/root	-rw-r--r--	2026-02-23 07:38:42
vuln.js	text/plain	5.82 KB	root/root	-rw-r--r--	2026-02-23 07:38:42
yarn-lock.js	text/plain	10.56 KB	root/root	-rw-r--r--	2026-02-23 07:38:42