#$@%#$%!

Ngiler SH3LL 360
: / lib / node_modules / npm / node_modules / genfun / lib /

Information Server
MySQL : OFF Perl : OFF CURL : ON WGET : OFF PKEXEC : OFF

Directive	Local Value
IP Address	162.0.209.101
System	Linux premium169.web-hosting.com 4.18.0-553.50.1.lve.el8.x86_64 #1 SMP Thu Apr 17 19:10:24 UTC 2025 x86_64
User	luxeelil
PHP Version	8.0.30
Software	LiteSpeed
Doc root	Writable

Edit File : genfun.js \| Size : 8.40 KB
'use strict' const Method = require('./method') const Role = require('./role') const util = require('./util') const kCache = Symbol('cache') const kDefaultMethod = Symbol('defaultMethod') const kMethods = Symbol('methods') const kNoNext = Symbol('noNext') module.exports = function genfun (opts) { function gf () { if (!gf[kMethods].length && gf[kDefaultMethod]) { return gf[kDefaultMethod].func.apply(this, arguments) } else { return gf.applyGenfun(this, arguments) } } Object.setPrototypeOf(gf, Genfun.prototype) gf[kMethods] = [] gf[kCache] = {key: [], methods: [], state: STATES.UNINITIALIZED} if (opts && typeof opts === 'function') { gf.add(opts) } else if (opts && opts.default) { gf.add(opts.default) } if (opts && opts.name) { Object.defineProperty(gf, 'name', { value: opts.name }) } if (opts && opts.noNextMethod) { gf[kNoNext] = true } return gf } class Genfun extends Function {} Genfun.prototype.isGenfun = true const STATES = { UNINITIALIZED: 0, MONOMORPHIC: 1, POLYMORPHIC: 2, MEGAMORPHIC: 3 } const MAX_CACHE_SIZE = 32 /** * Defines a method on a generic function. * * @function * @param {Array-like} selector - Selector array for dispatching the method. * @param {Function} methodFunction - Function to execute when the method * successfully dispatches. / Genfun.prototype.add = function addMethod (selector, func) { if (!func && typeof selector === 'function') { func = selector selector = [] } selector = [].slice.call(selector) for (var i = 0; i < selector.length; i++) { if (!selector.hasOwnProperty(i)) { selector[i] = Object.prototype } } this[kCache] = {key: [], methods: [], state: STATES.UNINITIALIZED} let method = new Method(this, selector, func) if (selector.length) { this[kMethods].push(method) } else { this[kDefaultMethod] = method } return this } /* * Removes a previously-defined method on `genfun` that matches * `selector` exactly. * * @function * @param {Genfun} genfun - Genfun to remove a method from. * @param {Array-like} selector - Objects to match on when finding a * method to remove. / Genfun.prototype.rm = function removeMethod () { throw new Error('not yet implemented') } /* * Returns true if there are methods that apply to the given arguments on * `genfun`. Additionally, makes sure the cache is warmed up for the given * arguments. * / Genfun.prototype.hasMethod = function hasMethod () { const methods = this.getApplicableMethods(arguments) return !!(methods && methods.length) } /* * This generic function is called when `genfun` has been called and no * applicable method was found. The default method throws an `Error`. * * @function * @param {Genfun} genfun - Generic function instance that was called. * @param {} newthis - value of `this` the genfun was called with. @param {Array} callArgs - Arguments the genfun was called with. / module.exports.noApplicableMethod = module.exports() module.exports.noApplicableMethod.add([], (gf, thisArg, args) => { let msg = 'No applicable method found when called with arguments of types: (' + [].map.call(args, (arg) => { return (/\[object ([a-zA-Z0-9]+)\]/) .exec(({}).toString.call(arg))[1] }).join(', ') + ')' let err = new Error(msg) err.genfun = gf err.thisArg = thisArg err.args = args throw err }) / * Internal / Genfun.prototype.applyGenfun = function applyGenfun (newThis, args) { let applicableMethods = this.getApplicableMethods(args) if (applicableMethods.length === 1 \|\| this[kNoNext]) { return applicableMethods[0].func.apply(newThis, args) } else if (applicableMethods.length > 1) { let idx = 0 const nextMethod = function nextMethod () { if (arguments.length) { // Replace args if passed in explicitly args = arguments Array.prototype.push.call(args, nextMethod) } const next = applicableMethods[idx++] if (idx >= applicableMethods.length) { Array.prototype.pop.call(args) } return next.func.apply(newThis, args) } Array.prototype.push.call(args, nextMethod) return nextMethod() } else { return module.exports.noApplicableMethod(this, newThis, args) } } Genfun.prototype.getApplicableMethods = function getApplicableMethods (args) { if (!args.length \|\| !this[kMethods].length) { return this[kDefaultMethod] ? [this[kDefaultMethod]] : [] } let applicableMethods let maybeMethods = cachedMethods(this, args) if (maybeMethods) { applicableMethods = maybeMethods } else { applicableMethods = computeApplicableMethods(this, args) cacheArgs(this, args, applicableMethods) } return applicableMethods } function cacheArgs (genfun, args, methods) { if (genfun[kCache].state === STATES.MEGAMORPHIC) { return } var key = [] var proto for (var i = 0; i < args.length; i++) { proto = cacheableProto(genfun, args[i]) if (proto) { key[i] = proto } else { return null } } genfun[kCache].key.unshift(key) genfun[kCache].methods.unshift(methods) if (genfun[kCache].key.length === 1) { genfun[kCache].state = STATES.MONOMORPHIC } else if (genfun[kCache].key.length < MAX_CACHE_SIZE) { genfun[kCache].state = STATES.POLYMORPHIC } else { genfun[kCache].state = STATES.MEGAMORPHIC } } function cacheableProto (genfun, arg) { var dispatchable = util.dispatchableObject(arg) if (Object.hasOwnProperty.call(dispatchable, Role.roleKeyName)) { for (var j = 0; j < dispatchable[Role.roleKeyName].length; j++) { var role = dispatchable[Role.roleKeyName][j] if (role.method.genfun === genfun) { return null } } } return Object.getPrototypeOf(dispatchable) } function cachedMethods (genfun, args) { if (genfun[kCache].state === STATES.UNINITIALIZED \|\| genfun[kCache].state === STATES.MEGAMORPHIC) { return null } var protos = [] var proto for (var i = 0; i < args.length; i++) { proto = cacheableProto(genfun, args[i]) if (proto) { protos[i] = proto } else { return } } for (i = 0; i < genfun[kCache].key.length; i++) { if (matchCachedMethods(genfun[kCache].key[i], protos)) { return genfun[kCache].methods[i] } } } function matchCachedMethods (key, protos) { if (key.length !== protos.length) { return false } for (var i = 0; i < key.length; i++) { if (key[i] !== protos[i]) { return false } } return true } function computeApplicableMethods (genfun, args) { args = [].slice.call(args) let discoveredMethods = [] function findAndRankRoles (object, hierarchyPosition, index) { var roles = Object.hasOwnProperty.call(object, Role.roleKeyName) ? object[Role.roleKeyName] : [] roles.forEach(role => { if (role.method.genfun === genfun && index === role.position) { if (discoveredMethods.indexOf(role.method) < 0) { Method.clearRank(role.method) discoveredMethods.push(role.method) } Method.setRankHierarchyPosition(role.method, index, hierarchyPosition) } }) // When a discovered method would receive more arguments than // were specialized, we pretend all extra arguments have a role // on Object.prototype. if (util.isObjectProto(object)) { discoveredMethods.forEach(method => { if (method.minimalSelector <= index) { Method.setRankHierarchyPosition(method, index, hierarchyPosition) } }) } } args.forEach((arg, index) => { getPrecedenceList(util.dispatchableObject(arg)) .forEach((obj, hierarchyPosition) => { findAndRankRoles(obj, hierarchyPosition, index) }) }) let applicableMethods = discoveredMethods.filter(method => { return (args.length === method._rank.length && Method.isFullySpecified(method)) }) applicableMethods.sort((a, b) => Method.score(a) - Method.score(b)) if (genfun[kDefaultMethod]) { applicableMethods.push(genfun[kDefaultMethod]) } return applicableMethods } / * Helper function for getting an array representing the entire * inheritance/precedence chain for an object by navigating its * prototype pointers. */ function getPrecedenceList (obj) { var precedenceList = [] var nextObj = obj while (nextObj) { precedenceList.push(nextObj) nextObj = Object.getPrototypeOf(nextObj) } return precedenceList } Back

Edit File : genfun.js | Size : 8.40 KB

'use strict'

const Method = require('./method')
const Role = require('./role')
const util = require('./util')

const kCache = Symbol('cache')
const kDefaultMethod = Symbol('defaultMethod')
const kMethods = Symbol('methods')
const kNoNext = Symbol('noNext')

module.exports = function genfun (opts) {
  function gf () {
    if (!gf[kMethods].length && gf[kDefaultMethod]) {
      return gf[kDefaultMethod].func.apply(this, arguments)
    } else {
      return gf.applyGenfun(this, arguments)
    }
  }
  Object.setPrototypeOf(gf, Genfun.prototype)
  gf[kMethods] = []
  gf[kCache] = {key: [], methods: [], state: STATES.UNINITIALIZED}
  if (opts && typeof opts === 'function') {
    gf.add(opts)
  } else if (opts && opts.default) {
    gf.add(opts.default)
  }
  if (opts && opts.name) {
    Object.defineProperty(gf, 'name', {
      value: opts.name
    })
  }
  if (opts && opts.noNextMethod) {
    gf[kNoNext] = true
  }
  return gf
}

class Genfun extends Function {}
Genfun.prototype.isGenfun = true

const STATES = {
  UNINITIALIZED: 0,
  MONOMORPHIC: 1,
  POLYMORPHIC: 2,
  MEGAMORPHIC: 3
}

const MAX_CACHE_SIZE = 32

/**
 * Defines a method on a generic function.
 *
 * @function
 * @param {Array-like} selector - Selector array for dispatching the method.
 * @param {Function} methodFunction - Function to execute when the method
 *                                    successfully dispatches.
 */
Genfun.prototype.add = function addMethod (selector, func) {
  if (!func && typeof selector === 'function') {
    func = selector
    selector = []
  }
  selector = [].slice.call(selector)
  for (var i = 0; i < selector.length; i++) {
    if (!selector.hasOwnProperty(i)) {
      selector[i] = Object.prototype
    }
  }
  this[kCache] = {key: [], methods: [], state: STATES.UNINITIALIZED}
  let method = new Method(this, selector, func)
  if (selector.length) {
    this[kMethods].push(method)
  } else {
    this[kDefaultMethod] = method
  }
  return this
}

/**
 * Removes a previously-defined method on `genfun` that matches
 * `selector` exactly.
 *
 * @function
 * @param {Genfun} genfun - Genfun to remove a method from.
 * @param {Array-like} selector - Objects to match on when finding a
 *                                    method to remove.
 */
Genfun.prototype.rm = function removeMethod () {
  throw new Error('not yet implemented')
}

/**
 * Returns true if there are methods that apply to the given arguments on
 * `genfun`. Additionally, makes sure the cache is warmed up for the given
 * arguments.
 *
 */
Genfun.prototype.hasMethod = function hasMethod () {
  const methods = this.getApplicableMethods(arguments)
  return !!(methods && methods.length)
}

/**
 * This generic function is called when `genfun` has been called and no
 * applicable method was found. The default method throws an `Error`.
 *
 * @function
 * @param {Genfun} genfun - Generic function instance that was called.
 * @param {*} newthis - value of `this` the genfun was called with.
 * @param {Array} callArgs - Arguments the genfun was called with.
 */
module.exports.noApplicableMethod = module.exports()
module.exports.noApplicableMethod.add([], (gf, thisArg, args) => {
  let msg =
        'No applicable method found when called with arguments of types: (' +
        [].map.call(args, (arg) => {
          return (/\[object ([a-zA-Z0-9]+)\]/)
            .exec(({}).toString.call(arg))[1]
        }).join(', ') + ')'
  let err = new Error(msg)
  err.genfun = gf
  err.thisArg = thisArg
  err.args = args
  throw err
})

/*
 * Internal
 */
Genfun.prototype.applyGenfun = function applyGenfun (newThis, args) {
  let applicableMethods = this.getApplicableMethods(args)
  if (applicableMethods.length === 1 || this[kNoNext]) {
    return applicableMethods[0].func.apply(newThis, args)
  } else if (applicableMethods.length > 1) {
    let idx = 0
    const nextMethod = function nextMethod () {
      if (arguments.length) {
        // Replace args if passed in explicitly
        args = arguments
        Array.prototype.push.call(args, nextMethod)
      }
      const next = applicableMethods[idx++]
      if (idx >= applicableMethods.length) {
        Array.prototype.pop.call(args)
      }
      return next.func.apply(newThis, args)
    }
    Array.prototype.push.call(args, nextMethod)
    return nextMethod()
  } else {
    return module.exports.noApplicableMethod(this, newThis, args)
  }
}

Genfun.prototype.getApplicableMethods = function getApplicableMethods (args) {
  if (!args.length || !this[kMethods].length) {
    return this[kDefaultMethod] ? [this[kDefaultMethod]] : []
  }
  let applicableMethods
  let maybeMethods = cachedMethods(this, args)
  if (maybeMethods) {
    applicableMethods = maybeMethods
  } else {
    applicableMethods = computeApplicableMethods(this, args)
    cacheArgs(this, args, applicableMethods)
  }
  return applicableMethods
}

function cacheArgs (genfun, args, methods) {
  if (genfun[kCache].state === STATES.MEGAMORPHIC) { return }
  var key = []
  var proto
  for (var i = 0; i < args.length; i++) {
    proto = cacheableProto(genfun, args[i])
    if (proto) {
      key[i] = proto
    } else {
      return null
    }
  }
  genfun[kCache].key.unshift(key)
  genfun[kCache].methods.unshift(methods)
  if (genfun[kCache].key.length === 1) {
    genfun[kCache].state = STATES.MONOMORPHIC
  } else if (genfun[kCache].key.length < MAX_CACHE_SIZE) {
    genfun[kCache].state = STATES.POLYMORPHIC
  } else {
    genfun[kCache].state = STATES.MEGAMORPHIC
  }
}

function cacheableProto (genfun, arg) {
  var dispatchable = util.dispatchableObject(arg)
  if (Object.hasOwnProperty.call(dispatchable, Role.roleKeyName)) {
    for (var j = 0; j < dispatchable[Role.roleKeyName].length; j++) {
      var role = dispatchable[Role.roleKeyName][j]
      if (role.method.genfun === genfun) {
        return null
      }
    }
  }
  return Object.getPrototypeOf(dispatchable)
}

function matchCachedMethods (key, protos) {
  if (key.length !== protos.length) { return false }
  for (var i = 0; i < key.length; i++) {
    if (key[i] !== protos[i]) {
      return false
    }
  }
  return true
}

function computeApplicableMethods (genfun, args) {
  args = [].slice.call(args)
  let discoveredMethods = []
  function findAndRankRoles (object, hierarchyPosition, index) {
    var roles = Object.hasOwnProperty.call(object, Role.roleKeyName)
    ? object[Role.roleKeyName]
    : []
    roles.forEach(role => {
      if (role.method.genfun === genfun && index === role.position) {
        if (discoveredMethods.indexOf(role.method) < 0) {
          Method.clearRank(role.method)
          discoveredMethods.push(role.method)
        }
        Method.setRankHierarchyPosition(role.method, index, hierarchyPosition)
      }
    })
    // When a discovered method would receive more arguments than
    // were specialized, we pretend all extra arguments have a role
    // on Object.prototype.
    if (util.isObjectProto(object)) {
      discoveredMethods.forEach(method => {
        if (method.minimalSelector <= index) {
          Method.setRankHierarchyPosition(method, index, hierarchyPosition)
        }
      })
    }
  }
  args.forEach((arg, index) => {
    getPrecedenceList(util.dispatchableObject(arg))
      .forEach((obj, hierarchyPosition) => {
        findAndRankRoles(obj, hierarchyPosition, index)
      })
  })
  let applicableMethods = discoveredMethods.filter(method => {
    return (args.length === method._rank.length &&
            Method.isFullySpecified(method))
  })
  applicableMethods.sort((a, b) => Method.score(a) - Method.score(b))
  if (genfun[kDefaultMethod]) {
    applicableMethods.push(genfun[kDefaultMethod])
  }
  return applicableMethods
}

/*
 * Helper function for getting an array representing the entire
 * inheritance/precedence chain for an object by navigating its
 * prototype pointers.
 */
function getPrecedenceList (obj) {
  var precedenceList = []
  var nextObj = obj
  while (nextObj) {
    precedenceList.push(nextObj)
    nextObj = Object.getPrototypeOf(nextObj)
  }
  return precedenceList
}

Back