text: 'use strict';
  
  let call = module.exports = {
    safe: safeCall,
    once: callOnce,
  };
  
  /**
   * Calls a function with the given arguments, and ensures that the error-first callback is _always_
   * invoked exactly once, even if the function throws an error.
   *
   * @param {function} fn - The function to invoke
   * @param {...*} args - The arguments to pass to the function. The final argument must be a callback function.
   */
  function safeCall (fn, args) {
    // Get the function arguments as an array
    args = Array.prototype.slice.call(arguments, 1);
  
    // Replace the callback function with a wrapper that ensures it will only be called once
    let callback = call.once(args.pop());
    args.push(callback);
  
    try {
      fn.apply(null, args);
    }
    catch (err) {
      callback(err);
    }
  }
  
  /**
   * Returns a wrapper function that ensures the given callback function is only called once.
   * Subsequent calls are ignored, unless the first argument is an Error, in which case the
   * error is thrown.
   *
   * @param {function} fn - The function that should only be called once
   * @returns {function}
   */
  function callOnce (fn) {
    let fulfilled = false;
  
    return function onceWrapper (err) {
      if (!fulfilled) {
        fulfilled = true;
        return fn.apply(this, arguments);
      }
      else if (err) {
        // The callback has already been called, but now an error has occurred
        // (most likely inside the callback function). So re-throw the error,
        // so it gets handled further up the call stack
        throw err;
      }
    };
  }
  