@yanglaofish/fishtools 0.5.1 → 0.5.3

package/node_modules/@npmcli/arborist/lib/package-extensions.js

@@ -1,236 +0,0 @@
-// Root-owned `packageExtensions`: declarative repairs to third-party manifests applied before Arborist reads a candidate's dependency edges.
-// See RFC: https://github.com/npm/rfcs/pull/889
-// This module is pure: it parses and validates the root rule set, matches a candidate manifest by name and version, and returns an extended manifest copy plus minimal provenance.
-// It never mutates the input manifest or any shared cache object.
-const semver = require('semver')
-const ssri = require('ssri')
-const validateName = require('validate-npm-package-name')
-
-// The only manifest fields a package extension may add or correct, because they are the fields that affect dependency and peer resolution.
-const EXTENSION_FIELDS = [
-  'dependencies',
-  'optionalDependencies',
-  'peerDependencies',
-  'peerDependenciesMeta',
-]
-
-// The two normal dependency fields; a name may exist in only one of them.
-const NORMAL_DEP_FIELDS = ['dependencies', 'optionalDependencies']
-
-const err = (message, code, extra = {}) =>
-  Object.assign(new Error(message), { code, ...extra })
-
-// Parse a selector key into { name, range }, where range is null for a name-only key.
-// Selectors are a package name with an optional semver range; dist-tags, git, file, directory, url, and alias specs are rejected.
-const parseSelector = key => {
-  if (typeof key !== 'string' || !key) {
-    throw err(`Invalid packageExtensions selector: ${JSON.stringify(key)}`, 'EEXTENSIONSELECTOR')
-  }
-  // The separator @ is the first @ after a leading scope @.
-  const at = key.indexOf('@', key.startsWith('@') ? 1 : 0)
-  const name = at === -1 ? key : key.slice(0, at)
-  const range = at === -1 ? null : key.slice(at + 1)
-
-  const { validForOldPackages, validForNewPackages } = validateName(name)
-  if (!validForOldPackages && !validForNewPackages) {
-    throw err(`Invalid package name in packageExtensions selector: "${key}"`, 'EEXTENSIONSELECTOR', { selector: key })
-  }
-  // A blank range such as "foo@" is malformed; the name-only form "foo" is how you match every version.
-  if (range !== null && range.trim() === '') {
-    throw err(
-      `Invalid packageExtensions selector: "${key}". Use the name only to match every version.`,
-      'EEXTENSIONSELECTOR', { selector: key })
-  }
-  // A versioned selector must be a valid semver range, which rejects dist-tags, git, file, url, and alias specs.
-  if (range !== null && semver.validRange(range, { loose: true }) === null) {
-    throw err(
-      `Invalid version range in packageExtensions selector: "${key}". Selectors accept a package name with an optional semver range only.`,
-      'EEXTENSIONSELECTOR', { selector: key })
-  }
-  return { name, range }
-}
-
-// A selector matches a candidate manifest by its own name and version.
-// Name-only selectors match every version, including non-semver versions.
-// Versioned selectors only match versions that parse as semver and satisfy the range.
-const rangeMatches = (range, version) => {
-  if (range === null) {
-    return true
-  }
-  return semver.valid(version, { loose: true }) !== null &&
-    semver.satisfies(version, range, { loose: true })
-}
-
-// Validate a single selector's extension object before it is ever applied.
-const validateExtensionObject = (key, ext) => {
-  if (ext === null || typeof ext !== 'object' || Array.isArray(ext)) {
-    throw err(`packageExtensions["${key}"] must be an object`, 'EEXTENSIONVALUE', { selector: key })
-  }
-  for (const field of Object.keys(ext)) {
-    if (!EXTENSION_FIELDS.includes(field)) {
-      throw err(
-        `packageExtensions["${key}"] has unsupported field "${field}". Supported fields: ${EXTENSION_FIELDS.join(', ')}.`,
-        'EEXTENSIONFIELD', { selector: key, field })
-    }
-    const val = ext[field]
-    if (val === null || typeof val !== 'object' || Array.isArray(val)) {
-      throw err(`packageExtensions["${key}"].${field} must be an object`, 'EEXTENSIONVALUE', { selector: key, field })
-    }
-  }
-  // Deletion is not supported in v1, so a null, false, or "-" value is an error.
-  for (const field of [...NORMAL_DEP_FIELDS, 'peerDependencies']) {
-    for (const [name, spec] of Object.entries(ext[field] || {})) {
-      if (spec === null || spec === false || spec === '-') {
-        throw err(
-          `packageExtensions["${key}"].${field}.${name} attempts deletion, which is not supported.`,
-          'EEXTENSIONDELETE', { selector: key, field, name })
-      }
-    }
-  }
-  // Each peerDependenciesMeta entry must be a non-null metadata object, never a deletion sentinel or primitive.
-  for (const [name, meta] of Object.entries(ext.peerDependenciesMeta || {})) {
-    if (meta === null || typeof meta !== 'object' || Array.isArray(meta)) {
-      throw err(
-        `packageExtensions["${key}"].peerDependenciesMeta.${name} must be an object`,
-        'EEXTENSIONVALUE', { selector: key, field: 'peerDependenciesMeta', name })
-    }
-  }
-}
-
-// Apply a matched extension to a manifest, returning { pkg, applied } where pkg is a copy with extended fields and applied is minimal provenance.
-// The input manifest is never mutated.
-const applyExtension = (pkg, { key, ext }) => {
-  const applied = { selector: key }
-
-  // Clone only the fields we may touch; the rest of the manifest is shared by reference since it is never mutated.
-  const next = { ...pkg }
-  for (const field of EXTENSION_FIELDS) {
-    if (pkg[field] && typeof pkg[field] === 'object') {
-      next[field] = field === 'peerDependenciesMeta'
-        ? Object.fromEntries(Object.entries(pkg[field]).map(([n, m]) => [n, { ...m }]))
-        : { ...pkg[field] }
-    }
-  }
-
-  // dependencies and optionalDependencies add missing names only.
-  // A name already declared in either normal dependency field is an error, which also prevents moving a name between the fields.
-  for (const field of NORMAL_DEP_FIELDS) {
-    const adds = ext[field]
-    if (!adds) {
-      continue
-    }
-    for (const [name, spec] of Object.entries(adds)) {
-      for (const existingField of NORMAL_DEP_FIELDS) {
-        if (next[existingField] && name in next[existingField]) {
-          throw err(
-            `packageExtensions["${key}"].${field}.${name} conflicts with the package's existing ${existingField}.${name}. Use overrides to change a dependency version; packageExtensions only adds missing dependencies.`,
-            'EEXTENSIONDUPDEP', { selector: key, field, name, existingField })
-        }
-      }
-      next[field] = next[field] || {}
-      next[field][name] = spec
-      ;(applied[field] = applied[field] || []).push(name)
-    }
-  }
-
-  // peerDependencies shallow-merges by peer name, and the extension value replaces an existing range.
-  if (ext.peerDependencies) {
-    next.peerDependencies = next.peerDependencies || {}
-    for (const [name, spec] of Object.entries(ext.peerDependencies)) {
-      next.peerDependencies[name] = spec
-      ;(applied.peerDependencies = applied.peerDependencies || []).push(name)
-    }
-  }
-
-  // peerDependenciesMeta merges by peer name, then shallow-merges each meta object so an extension can add optional without dropping other meta keys.
-  if (ext.peerDependenciesMeta) {
-    next.peerDependenciesMeta = next.peerDependenciesMeta || {}
-    for (const [name, meta] of Object.entries(ext.peerDependenciesMeta)) {
-      next.peerDependenciesMeta[name] = { ...next.peerDependenciesMeta[name], ...meta }
-      ;(applied.peerDependenciesMeta = applied.peerDependenciesMeta || []).push(name)
-      // Every peerDependenciesMeta entry an extension adds must correspond to a peerDependencies entry present after extension application.
-      if (!next.peerDependencies || !(name in next.peerDependencies)) {
-        throw err(
-          `packageExtensions["${key}"].peerDependenciesMeta.${name} has no corresponding peerDependencies.${name} after extension application.`,
-          'EEXTENSIONORPHANMETA', { selector: key, name })
-      }
-    }
-  }
-
-  return { pkg: next, applied }
-}
-
-// Deterministic JSON for hashing: keys sorted lexicographically at every level, string and number values preserved exactly, no insignificant whitespace.
-const canonicalStringify = val => {
-  if (Array.isArray(val)) {
-    return `[${val.map(canonicalStringify).join(',')}]`
-  }
-  if (val && typeof val === 'object') {
-    return `{${Object.keys(val).sort()
-      .map(k => `${JSON.stringify(k)}:${canonicalStringify(val[k])}`)
-      .join(',')}}`
-  }
-  return JSON.stringify(val)
-}
-
-// Hash the canonical form of the root packageExtensions object using npm's existing lockfile digest encoding.
-const canonicalHash = packageExtensions =>
-  ssri.fromData(canonicalStringify(packageExtensions), { algorithms: ['sha512'] }).toString()
-
-class PackageExtensions {
-  constructor (raw) {
-    this.raw = raw
-    this.present = raw !== undefined
-    this.selectors = []
-    this.hash = null
-
-    if (!this.present) {
-      return
-    }
-    if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
-      throw err('packageExtensions must be an object', 'EEXTENSIONROOT')
-    }
-    for (const [key, ext] of Object.entries(raw)) {
-      const { name, range } = parseSelector(key)
-      validateExtensionObject(key, ext)
-      this.selectors.push({ key, name, range, ext })
-    }
-    this.hash = canonicalHash(raw)
-  }
-
-  // Non-throwing check used for warnings: whether any selector matches the candidate.
-  wouldMatch (name, version) {
-    return this.selectors.some(s => s.name === name && rangeMatches(s.range, version))
-  }
-
-  // Return the single selector matching a candidate manifest, or null.
-  // Throws EEXTENSIONCONFLICT when more than one selector matches the same candidate.
-  match (name, version) {
-    const matches = this.selectors.filter(s => s.name === name && rangeMatches(s.range, version))
-    if (matches.length > 1) {
-      const keys = matches.map(s => `"${s.key}"`).join(', ')
-      throw err(
-        `Multiple packageExtensions selectors match ${name}@${version}: ${keys}. Narrow or remove one of the overlapping rules.`,
-        'EEXTENSIONCONFLICT', { name, version, selectors: matches.map(s => s.key) })
-    }
-    return matches[0] || null
-  }
-
-  // Apply the matching extension to a manifest copy, returning { pkg, applied } or null when no selector matches.
-  // Throws on selector conflict or invalid merge.
-  apply (pkg) {
-    if (!this.present || !this.selectors.length || !pkg || !pkg.name) {
-      return null
-    }
-    const sel = this.match(pkg.name, pkg.version)
-    return sel ? applyExtension(pkg, sel) : null
-  }
-}
-
-module.exports = PackageExtensions
-module.exports.PackageExtensions = PackageExtensions
-module.exports.parseSelector = parseSelector
-module.exports.rangeMatches = rangeMatches
-module.exports.canonicalHash = canonicalHash
-module.exports.canonicalStringify = canonicalStringify
-module.exports.EXTENSION_FIELDS = EXTENSION_FIELDS

package/node_modules/@npmcli/arborist/lib/patch.js

@@ -1,111 +0,0 @@
-// Native dependency patching helpers shared across build-ideal-tree and reify.
-// Patches are plain unified diffs (git apply-compatible) applied with jsdiff using a fuzz factor of 0 so that any context drift fails loudly.
-const { applyPatch, parsePatch } = require('diff')
-const ssri = require('ssri')
-const fs = require('node:fs')
-const { promises: fsp } = fs
-const { resolve, relative, dirname, isAbsolute } = require('node:path')
-
-// Compute the SSRI integrity of a patch file's contents.
-// Accepts a string or Buffer and returns a sha512 SSRI string.
-const patchIntegrity = data =>
-  ssri.fromData(Buffer.isBuffer(data) ? data : Buffer.from(data, 'utf8'), {
-    algorithms: ['sha512'],
-  }).toString()
-
-// Strip a leading git-style "a/" or "b/" prefix from a diff path.
-const stripPrefix = file => file.replace(/^[ab]\//, '')
-
-// True when a diff path points at /dev/null, signalling a file add or delete.
-const isDevNull = file => !file || file === '/dev/null' || /(^|\/)\.dev\/null$/.test(file)
-
-const patchError = (message, code, file) =>
-  Object.assign(new Error(message), { code, file })
-
-// Resolve a diff path under cwd and refuse anything that escapes the package directory.
-const containedTarget = (cwd, file) => {
-  const target = resolve(cwd, file)
-  const rel = relative(cwd, target)
-  if (!rel || rel.startsWith('..') || isAbsolute(rel)) {
-    throw patchError(`patch path escapes the package directory: ${file}`, 'EPATCHUNSAFE', file)
-  }
-  return target
-}
-
-// Run a parsed file patch against a source string with fuzz 0.
-// Returns the patched text, or throws EPATCHFAILED on any context mismatch.
-const strictApply = (source, filePatch, file) => {
-  const patched = applyPatch(source, filePatch, { fuzzFactor: 0 })
-  if (patched === false) {
-    throw patchError(`patch could not be applied to ${file}`, 'EPATCHFAILED', file)
-  }
-  return patched
-}
-
-// Apply a single parsed file patch under cwd.
-// Handles modified, added (--- /dev/null) and deleted (+++ /dev/null) files.
-const applyFilePatch = async (filePatch, cwd) => {
-  const isAdd = isDevNull(filePatch.oldFileName)
-  const isDelete = isDevNull(filePatch.newFileName)
-
-  if (isDelete) {
-    const file = stripPrefix(filePatch.oldFileName)
-    const target = containedTarget(cwd, file)
-    // verify the file still matches the diff before removing it
-    const source = await fsp.readFile(target, 'utf8').catch(() => {
-      throw patchError(`patch target to delete is missing: ${file}`, 'EPATCHFAILED', file)
-    })
-    strictApply(source, filePatch, file)
-    await fsp.rm(target, { force: true })
-    return
-  }
-
-  const file = stripPrefix(filePatch.newFileName)
-  const target = containedTarget(cwd, file)
-
-  if (isAdd) {
-    // a new file must not already exist, otherwise the tarball drifted
-    if (fs.existsSync(target)) {
-      throw patchError(`patch adds a file that already exists: ${file}`, 'EPATCHFAILED', file)
-    }
-    const created = strictApply('', filePatch, file)
-    await fsp.mkdir(dirname(target), { recursive: true })
-    await fsp.writeFile(target, created)
-    return
-  }
-
-  const source = await fsp.readFile(target, 'utf8').catch(() => {
-    throw patchError(`patch target is missing: ${file}`, 'EPATCHFAILED', file)
-  })
-  const mode = (await fsp.stat(target)).mode
-  const patched = strictApply(source, filePatch, file)
-  await fsp.writeFile(target, patched)
-  await fsp.chmod(target, mode)
-}
-
-// Apply a unified diff to the package extracted at `cwd`.
-// `patch` is the raw diff contents (string or Buffer).
-// Throws with code EPATCHFAILED on any hunk or file that cannot be applied.
-const applyPatchToDir = async ({ patch, cwd }) => {
-  const filePatches = parsePatch(patch.toString('utf8'))
-  for (const filePatch of filePatches) {
-    // jsdiff emits an empty trailing patch for some inputs; skip those.
-    if (!filePatch.hunks.length && isDevNull(filePatch.oldFileName) && isDevNull(filePatch.newFileName)) {
-      continue
-    }
-    try {
-      await applyFilePatch(filePatch, cwd)
-    } catch (er) {
-      // re-code raw filesystem errors so a patch failure is never mistaken for an optional-install skip
-      if (typeof er?.code === 'string' && er.code.startsWith('EPATCH')) {
-        throw er
-      }
-      throw Object.assign(new Error(`failed to apply patch: ${er.message}`), { code: 'EPATCHFAILED', cause: er })
-    }
-  }
-}
-
-module.exports = {
-  applyPatchToDir,
-  patchIntegrity,
-}

package/node_modules/@npmcli/arborist/lib/patched-dependencies.js

@@ -1,168 +0,0 @@
-// Resolve the root patchedDependencies map against an ideal tree.
-// Attaches node.patched = { path, integrity } to each matched node.
-// Enforces the failure modes (workspace-member entry, missing file, unused patch, non-registry target, ambiguous selectors) as hard errors.
-const semver = require('semver')
-const npa = require('npm-package-arg')
-const { log } = require('proc-log')
-const { resolve, relative, isAbsolute } = require('node:path')
-const { readFile } = require('node:fs/promises')
-const { patchIntegrity } = require('./patch.js')
-
-// Split a selector key into { name, spec }. spec is null for a name-only key.
-const parseSelector = key => {
-  const at = key.indexOf('@', 1)
-  return at === -1
-    ? { name: key, spec: null }
-    : { name: key.slice(0, at), spec: key.slice(at + 1) }
-}
-
-const err = (message, code, extra = {}) =>
-  Object.assign(new Error(message), { code, ...extra })
-
-// Pick the most specific range among several that all match a version.
-// Returns the strict subset, or throws when ordering is ambiguous.
-// semver.subset is transitive, so the running minimum is a subset of every range it did not throw on.
-const pickRange = (ranges, name, version) => {
-  let best = ranges[0]
-  for (const r of ranges.slice(1)) {
-    if (semver.subset(r.spec, best.spec, { loose: true })) {
-      best = r
-    } else if (!semver.subset(best.spec, r.spec, { loose: true })) {
-      throw err(
-        `Ambiguous patch selectors for ${name}@${version}: ` +
-          `"${name}@${best.spec}" and "${name}@${r.spec}" overlap but neither ` +
-          `is a subset. Add an exact "${name}@${version}" entry to disambiguate.`,
-        'EPATCHAMBIGUOUS'
-      )
-    }
-  }
-  return best
-}
-
-// Choose the winning selector for a node: exact > range subset > name-only.
-const matchSelector = (selectors, node) => {
-  const { name, version } = node
-  const matches = selectors.filter(s => s.name === name)
-  if (!matches.length) {
-    return null
-  }
-
-  const exact = matches.find(s =>
-    s.spec && semver.valid(s.spec) && semver.eq(s.spec, version, { loose: true }))
-  if (exact) {
-    return exact
-  }
-
-  const ranges = matches.filter(s =>
-    s.spec && !semver.valid(s.spec) && semver.satisfies(version, s.spec, { loose: true }))
-  if (ranges.length) {
-    return pickRange(ranges, name, version)
-  }
-
-  return matches.find(s => s.spec === null) || null
-}
-
-const resolvePatchedDependencies = async (tree, { path, allowUnusedPatches, rm }) => {
-  const patchedDependencies = tree.package?.patchedDependencies || {}
-  const selectors = Object.entries(patchedDependencies)
-    .map(([key, patchPath]) => ({ ...parseSelector(key), key, patchPath }))
-
-  // cache patch file integrity by path so shared diffs are read once
-  const integrityCache = new Map()
-  const readPatch = async patchPath => {
-    if (integrityCache.has(patchPath)) {
-      return integrityCache.get(patchPath)
-    }
-    // patch files must live inside the project so the patch set stays auditable
-    const abs = resolve(path, patchPath)
-    const rel = relative(path, abs)
-    if (!rel || rel.startsWith('..') || isAbsolute(rel)) {
-      throw err(`patch path escapes the project: ${patchPath}`, 'EPATCHUNSAFE', { path: patchPath })
-    }
-    let contents
-    try {
-      contents = await readFile(abs)
-    } catch {
-      throw err(`patch file not found: ${patchPath}`, 'EPATCHNOTFOUND', { path: patchPath })
-    }
-    const integrity = patchIntegrity(contents)
-    integrityCache.set(patchPath, integrity)
-    return integrity
-  }
-
-  const usedKeys = new Set()
-  for (const node of tree.inventory.values()) {
-    // patchedDependencies is honoured only in the root manifest
-    if (node.isWorkspace) {
-      // Link.package already delegates to its target's package
-      const pkg = node.package
-      if (pkg?.patchedDependencies && Object.keys(pkg.patchedDependencies).length) {
-        throw err(
-          `patchedDependencies is only supported in the root package.json, ` +
-            `but was found in workspace "${node.name}". Move the entry to the root.`,
-          'EPATCHWORKSPACE',
-          { workspace: node.name }
-        )
-      }
-      continue
-    }
-    if (node.isProjectRoot) {
-      continue
-    }
-
-    const selector = matchSelector(selectors, node)
-    if (!selector) {
-      // a node that was patched but no longer matches a selector must be re-extracted to revert its files
-      if (node.patched) {
-        node.patchRemoved = true
-      }
-      node.patched = null
-      continue
-    }
-
-    // a non-registry consumer edge (file:, git:, http(s)) means there is no registry tarball to patch; npm: aliases stay registry.
-    // checking edges (not isRegistryDependency) avoids rejecting an edgeless node, which is still a registry dep.
-    if ([...node.edgesIn].some(e => e.spec && !npa(e.spec).registry)) {
-      throw err(
-        `Cannot patch non-registry dependency ${node.name}@${node.version} ` +
-          `(selector "${selector.key}"). Only registry dependencies can be patched.`,
-        'EPATCHNONREGISTRY',
-        { node: node.name }
-      )
-    }
-
-    const integrity = await readPatch(selector.patchPath)
-    node.patched = { path: selector.patchPath, integrity }
-    usedKeys.add(selector.key)
-  }
-
-  if (selectors.length) {
-    const unused = selectors.filter(s => !usedKeys.has(s.key))
-
-    // an explicit `npm uninstall <name>` orphans that package's patch entry, so drop it instead of failing
-    const removed = new Set(rm)
-    const dropped = unused.filter(s => removed.has(s.name))
-    if (dropped.length) {
-      const patched = { ...tree.package.patchedDependencies }
-      for (const s of dropped) {
-        delete patched[s.key]
-        log.notice('patch', `Removing patch entry "${s.key}" for uninstalled ${s.name}; left ${s.patchPath} in place.`)
-      }
-      // undefined drops the key entirely when reify writes package.json
-      tree.package.patchedDependencies = Object.keys(patched).length ? patched : undefined
-    }
-
-    const stillUnused = unused.filter(s => !removed.has(s.name))
-    if (stillUnused.length && !allowUnusedPatches) {
-      throw err(
-        `The following patches were registered but matched no installed ` +
-          `package:\n${stillUnused.map(s => `  ${s.key} -> ${s.patchPath}`).join('\n')}\n` +
-          `Use --allow-unused-patches to install anyway.`,
-        'EPATCHUNUSED',
-        { unused: stillUnused.map(s => s.key) }
-      )
-    }
-  }
-}
-
-module.exports = { resolvePatchedDependencies, matchSelector, parseSelector }

package/node_modules/cacache/lib/util/cache-dir.js

@@ -1,29 +0,0 @@
-'use strict'
-
-const fs = require('fs/promises')
-const path = require('path')
-
-const tagContent = `Signature: 8a477f597d28d172789f06886806bc55
-# This file is a cache directory tag created by cacache.
-# For information about cache directory tags, see https://bford.info/cachedir/
-`
-
-async function mkdir (cache) {
-  await fs.mkdir(cache, { recursive: true, owner: 'inherit' })
-  await writeTag(cache)
-}
-
-async function writeTag (cache) {
-  try {
-    await fs.writeFile(path.join(cache, 'CACHEDIR.TAG'), tagContent, { flag: 'wx' })
-  } catch (err) {
-    if (err.code !== 'EEXIST') {
-      throw err
-    }
-  }
-}
-
-module.exports = {
-  mkdir,
-  tagContent,
-}

package/node_modules/diff/CONTRIBUTING.md

@@ -1,28 +0,0 @@
-## Building and testing
-
-```
-yarn
-yarn test
-```
-
-To run tests in a *browser* (for instance to test compatibility with Firefox, with Safari, or with old browser versions), run `yarn karma start`, then open http://localhost:9876/ in the browser you want to test in. Results of the test run will appear in the terminal where `yarn karma start` is running.
-
-If you notice any problems, please report them to the GitHub issue tracker at
-[http://github.com/kpdecker/jsdiff/issues](http://github.com/kpdecker/jsdiff/issues).
-
-## Releasing
-
-Run a test in Firefox via the procedure above before releasing.
-
-A full release may be completed by first updating the `"version"` property in package.json, then running the following:
-
-```
-yarn clean
-yarn build
-yarn npm publish
-```
-
-After releasing, remember to:
-* commit the `package.json` change and push it to GitHub
-* create a new version tag on GitHub
-* update `diff.js` on the `gh-pages` branch to the latest built version from the `dist/` folder.

package/node_modules/diff/LICENSE

@@ -1,29 +0,0 @@
-BSD 3-Clause License
-
-Copyright (c) 2009-2015, Kevin Decker <kpdecker@gmail.com>
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, this
-   list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice,
-   this list of conditions and the following disclaimer in the documentation
-   and/or other materials provided with the distribution.
-
-3. Neither the name of the copyright holder nor the names of its
-   contributors may be used to endorse or promote products derived from
-   this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.