possible implementation of prototypal method modifier [afterFinally].

Function.afterFinally.js

(function (Function) {

  const fctPrototype = Function.prototype;
  const FUNCTION_TYPE = (typeof Function);

  function isFunction(type) {
    return (
         (typeof type == FUNCTION_TYPE)
      && (typeof type.call == FUNCTION_TYPE)
      && (typeof type.apply == FUNCTION_TYPE)
    );
  }
  function getSanitizedTarget(target) {
    /* eslint-disable */
    /* jshint ignore:start */
    /* ignore jslint start */

    /* no-eq-null */
    return ((target != null) && target) || null;

    /* ignore jslint end */
    /* jshint ignore:end */
    /* eslint-enable */
  }

  function afterFinally/*Modifier*/(handler, target) {
    target = getSanitizedTarget(target);

    const proceed = this;
    return (

      isFunction(handler) &&
      isFunction(proceed) &&

      function () {
        const context = target || getSanitizedTarget(this);
        const args = arguments;

        let result, error;
        try {
          result = proceed.apply(context, args);

        } catch (exception) {

          error = exception;

        } // finally { ... }

        result = (error || result);
        handler.call(context, result, args);

        return result;
      }

    ) || proceed;
  }
  // afterFinally.toString = () => 'afterFinally() { [native code] }';

  Object.defineProperty(fctPrototype, 'afterFinally', {
    configurable: true,
    writable: true,
    value: afterFinally/*Modifier*/
  });

  // provide static implementation as well.

  function staticAfterFinally/*Modifier*/(proceed, handler, target) {
    return afterFinally.call(proceed, handler, target);
  }
  // staticAfterFinally.toString = () => 'afterFinally() { [native code] }';
  // staticAfterFinally.toString = () => 'staticAfterFinally() { [native code] }';

  Object.defineProperty(Function, 'afterFinally', {
    configurable: true,
    writable: true,
    value: staticAfterFinally/*Modifier*/
  });

}(Function));