lambda-toolkit 0.0.2-beta

package/dist/index.mjs

@@ -0,0 +1,1139 @@
+import { createRequire as __WEBPACK_EXTERNAL_createRequire } from "node:module";
+/******/ var __webpack_modules__ = ({
+
+/***/ 278:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const joinUnique = __webpack_require__( 836 );
+const joinUniqueCustom = __webpack_require__( 536 );
+const splitBatches = __webpack_require__( 821 );
+
+module.exports = {
+  joinUnique,
+  joinUniqueCustom,
+  splitBatches
+};
+
+
+/***/ }),
+
+/***/ 836:
+/***/ ((module) => {
+
+module.exports = ( ...args ) => [ ...new Set( args.filter( Array.isArray ).flat() ) ];
+
+
+/***/ }),
+
+/***/ 536:
+/***/ ((module) => {
+
+module.exports = ( { key, items } ) => [
+  ...items.filter( Array.isArray ).flat().reduce( ( map, v ) => {
+    const k = key( v );
+    if ( !map.has( k ) ) {
+      map.set( k, v );
+    }
+    return map;
+  }, new Map() ).values()
+];
+
+
+/***/ }),
+
+/***/ 821:
+/***/ ((module) => {
+
+module.exports = ( items, size ) => items.reduce( ( arrs, item ) =>
+  ( arrs[0] && arrs[0].length < size ) ?
+    [ [ ...arrs[0], item ] ].concat( arrs.slice( 1 ) ) :
+    [ [ item ] ].concat( arrs )
+, [] ).reverse();
+
+
+/***/ }),
+
+/***/ 263:
+/***/ ((module) => {
+
+module.exports = t => t * 24 * 60 * 60 * 1000;
+
+
+/***/ }),
+
+/***/ 961:
+/***/ ((module) => {
+
+module.exports = t => t * 60 * 60 * 1000;
+
+
+/***/ }),
+
+/***/ 830:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const days = __webpack_require__( 263 );
+const hours = __webpack_require__( 961 );
+const minutes = __webpack_require__( 635 );
+const months = __webpack_require__( 500 );
+const msToS = __webpack_require__( 416 );
+const round = __webpack_require__( 990 );
+const seconds = __webpack_require__( 51 );
+
+module.exports = {
+  days,
+  hours,
+  minutes,
+  months,
+  msToS,
+  round,
+  seconds
+};
+
+
+/***/ }),
+
+/***/ 635:
+/***/ ((module) => {
+
+module.exports = t => t * 60 * 1000;
+
+
+/***/ }),
+
+/***/ 500:
+/***/ ((module) => {
+
+module.exports = t => t * 30 * 24 * 60 * 60 * 1000;
+
+
+/***/ }),
+
+/***/ 416:
+/***/ ((module) => {
+
+module.exports = v => Math.ceil( v / 1000 );
+
+
+/***/ }),
+
+/***/ 990:
+/***/ ((module) => {
+
+module.exports = ( time, interval ) => time - ( time % interval );
+
+
+/***/ }),
+
+/***/ 51:
+/***/ ((module) => {
+
+module.exports = t => t * 1000;
+
+
+/***/ }),
+
+/***/ 44:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const { LambdaApi } = __webpack_require__( 705 );
+const array = __webpack_require__( 278 );
+const epoch = __webpack_require__( 830 );
+const math = __webpack_require__( 943 );
+const object = __webpack_require__( 762 );
+const string = __webpack_require__( 268 );
+const utils = __webpack_require__( 878 );
+
+module.exports = {
+  array,
+  epoch,
+  LambdaApi,
+  math,
+  object,
+  string,
+  utils
+};
+
+
+/***/ }),
+
+/***/ 119:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const { snakelize, camelize } = __webpack_require__( 762 );
+const charset = 'utf-8';
+
+const transformFns = {
+  camelcase: camelize,
+  snakecase: snakelize
+};
+
+module.exports = class ApiResponse {
+  #headers = null;
+  #statusCode = null;
+  #transformFn = false;
+  #body = '';
+
+  constructor( { headers = {}, transform } = {} ) {
+    this.#transformFn = transformFns[transform] ?? ( v => v );
+    this.#headers = Object.assign( {
+      'Cache-Control': 'no-store',
+      'Access-Control-Allow-Origin': '*'
+    }, headers );
+  }
+
+  setContent( statusCode, body, headers = {} ) {
+    this.#statusCode = statusCode;
+    if ( body?.length === 0 || [ null, undefined ].includes( body ) ) {
+      this.#body = '';
+    } else if ( typeof body === 'object' ) {
+      this.#body = JSON.stringify( this.#transformFn( body ) );
+      this.#headers['Content-Type'] = `application/json; charset=${charset}`;
+    } else {
+      this.#body = String( body );
+      this.#headers['Content-Type'] = `text/plain; charset=${charset}`;
+    }
+    this.#headers['Content-Length'] = this.#body.length;
+    Object.assign( this.#headers, headers ?? {} );
+    return this;
+  }
+
+  toJSON() {
+    return {
+      statusCode: this.#statusCode,
+      body: this.#body,
+      headers: this.#headers
+    };
+  }
+};
+
+
+/***/ }),
+
+/***/ 329:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const { camelize, snakelize } = __webpack_require__( 762 );
+
+const transformFns = {
+  camelcase: camelize,
+  snakecase: snakelize
+};
+
+const parseJson = content => {
+  try {
+    return JSON.parse( content );
+  } catch {
+    return content;
+  }
+};
+
+module.exports = class Event {
+  #transformFn;
+  authorizer;
+  body;
+  headers;
+  method;
+  params;
+  path;
+  queryString;
+  route;
+
+  context = {};
+
+  constructor( { transform = false } = {} ) {
+    this.#transformFn = transformFns[transform] ?? ( v => v );
+  }
+
+  parseFromAwsEvent( awsEvent ) {
+    this[`parseFromAwsEventV${awsEvent.version !== '1.0' ? 2 : 1}`]( awsEvent );
+  }
+
+  parseFromAwsEventV1( awsEvent ) {
+    const {
+      body,
+      path,
+      resource,
+      httpMethod,
+      requestContext,
+      pathParameters,
+      headers,
+      multiValueHeaders,
+      queryStringParameters,
+      multiValueQueryStringParameters: multiValueQueryString
+    } = awsEvent;
+
+    const unifiedHeaders = {
+      headers,
+      ...Object.fromEntries( Object.entries( multiValueHeaders ?? {} ).map( ( [ k, v ] ) => [ k, Array.isArray( v ) ? v.join( ',' ) : k ] ) )
+    };
+
+    const unifiedQueryString = {
+      queryStringParameters,
+      ...Object.fromEntries( Object.entries( multiValueQueryString ?? {} ).map( ( [ k, v ] ) => [ k, Array.isArray( v ) ? v.join( ',' ) : k ] ) )
+    };
+
+    this.authorizer = requestContext?.authorizer;
+    this.body = body ? this.#transformFn( parseJson( body ) ) : null;
+    this.headers = unifiedHeaders ?? {};
+    this.method = httpMethod;
+    this.params = this.#transformFn( pathParameters ) ?? {};
+    this.path = path;
+    this.queryString = this.#transformFn( unifiedQueryString ) ?? {};
+    this.route = resource;
+  }
+
+  parseFromAwsEventV2( awsEvent ) {
+    const {
+      body,
+      routeKey,
+      requestContext,
+      pathParameters,
+      headers,
+      queryStringParameters
+    } = awsEvent;
+
+    const { http: { method, path } } = requestContext;
+
+    this.authorizer = requestContext?.authorizer;
+    this.body = body ? this.#transformFn( parseJson( body ) ) : null;
+    this.headers = headers ?? {};
+    this.method = method;
+    this.params = this.#transformFn( pathParameters ) ?? {};
+    this.path = path;
+    this.queryString = this.#transformFn( queryStringParameters ) ?? {};
+    this.route = routeKey?.split( ' ' )[1].replace( /\/$/, '' );
+  }
+};
+
+
+/***/ }),
+
+/***/ 109:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const validators = __webpack_require__( 994 );
+
+module.exports = class Handler {
+  #method;
+  #fn;
+  #route;
+  #routeIncludes;
+  #routeNotIncludes;
+  #routeMatches;
+  #path;
+  #pathIncludes;
+  #pathNotIncludes;
+  #pathMatches;
+
+  constructor( { method, fn, ...matchers } ) {
+    validators.httpMethod( method );
+    validators.function( fn );
+    validators.matcherRoute( matchers.route );
+    validators.matcherRouteIncludes( matchers.routeIncludes );
+    validators.matcherRouteNotIncludes( matchers.routeNotIncludes );
+    validators.matcherRouteMatch( matchers.routeMatch );
+    validators.matcherPath( matchers.path );
+    validators.matcherPathIncludes( matchers.pathIncludes );
+    validators.matcherPathNotIncludes( matchers.pathNotIncludes );
+    validators.matcherPathMatch( matchers.pathMatch );
+
+    this.#method = method;
+    this.#fn = fn;
+    this.#route = matchers.route;
+    this.#routeIncludes = matchers.routeIncludes;
+    this.#routeNotIncludes = matchers.routeNotIncludes;
+    this.#routeMatches = matchers.routeMatches;
+    this.#path = matchers.path;
+    this.#pathIncludes = matchers.pathIncludes;
+    this.#pathNotIncludes = matchers.pathNotIncludes;
+    this.#pathMatches = matchers.pathMatches;
+  }
+
+  match( event ) {
+    if ( this.#method !== event.method ) {
+      return false;
+    }
+    if ( this.#route ) {
+      return this.#route === event.route;
+    }
+    if ( this.#path ) {
+      return this.#path === event.path;
+    }
+    if ( this.#routeIncludes && !event.route.includes( this.#routeIncludes ) ) {
+      return false;
+    }
+    if ( this.#routeNotIncludes && event.route.includes( this.#routeNotIncludes ) ) {
+      return false;
+    }
+    if ( this.#routeMatches && !this.#routeMatches.test( event.route ) ) {
+      return false;
+    }
+    if ( this.#pathIncludes && !event.path.includes( this.#pathIncludes ) ) {
+      return false;
+    }
+    if ( this.#pathNotIncludes && event.path.includes( this.#pathNotIncludes ) ) {
+      return false;
+    }
+    if ( this.#pathMatches && !this.#pathMatches.test( event.path ) ) {
+      return false;
+    }
+    return true;
+  }
+
+  get fn() { return this.#fn; }
+};
+
+
+/***/ }),
+
+/***/ 798:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const validators = __webpack_require__( 994 );
+
+module.exports = class Hook {
+  #fn;
+
+  constructor( { fn } ) {
+    validators.function( fn );
+    this.#fn = fn;
+  }
+
+  get fn() { return this.#fn; }
+};
+
+
+/***/ }),
+
+/***/ 705:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const LambdaApi = __webpack_require__( 321 );
+
+module.exports = { LambdaApi };
+
+
+/***/ }),
+
+/***/ 321:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const validators = __webpack_require__( 994 );
+const ApiResponse = __webpack_require__( 119 );
+const Event = __webpack_require__( 329 );
+const Handler = __webpack_require__( 109 );
+const Hook = __webpack_require__( 798 );
+const UserResponse = __webpack_require__( 282 );
+const Text = __webpack_require__( 760 );
+
+module.exports = class LambdaApi {
+  #apiResponse = null;
+  #handlers = [];
+  #errorResponses = [];
+  #beforeHooks = [];
+  #afterHooks = [];
+  #transformRequest = [];
+
+  /**
+   * Creates a new Lambda Api
+   *
+   * @param {Object} headers Any headers you want to be included in all responses
+   */
+  constructor( { headers = {}, transformRequest = false, transformResponse = false } = {} ) {
+    validators.transformRequest( transformRequest );
+    validators.transformResponse( transformResponse );
+
+    this.#transformRequest = transformRequest;
+    this.#apiResponse = new ApiResponse( { headers, transform: transformResponse } );
+  }
+
+  /**
+   * Register a function that will run before the matching route (only if matches)
+   *
+   * @param {Object} args
+   * @param {function} args.fn A function
+   */
+  addBeforeHook( { fn } = {} ) {
+    this.#beforeHooks.push( new Hook( { fn } ) );
+  }
+
+  /**
+   * Register a function that will run after the matching route (only if matches)
+   *
+   * @param {Object} args
+   * @param {function} args.fn A function
+   */
+  addAfterHook( { fn } = {} ) {
+    this.#afterHooks.push( new Hook( { fn } ) );
+  }
+
+  /**
+   * Register a handler for a given request method and optionally a path
+   *
+   * @param {Object} args
+   * @param {string} args.method The method to match this handler
+   * @param {function} args.fn The handler function
+   * @param {string} [args.route] A route to match this handler
+   * @param {string} [args.routeIncludes] A part of the route to match this handler
+   * @param {string} [args.routeNotIncludes] A part of the route to not match this handler
+   * @param {RegExp} [args.routeMatches] A RegExp to match the route
+   * @param {string} [args.path] A path to match this handler
+   * @param {string} [args.pathIncludes] A part of the path to match this handler
+   * @param {string} [args.pathNotIncludes] A part of the path to not match this handler
+   * @param {RegExp} [args.pathMatches] A RegExp to match the path
+   */
+  addHandler( { method, fn, ...matchers } = {} ) {
+    this.#handlers.push( new Handler( { method, fn, ...matchers } ) );
+  }
+
+  /**
+   * Register an automatic error code response for given error class (constructor name)
+   *
+   * @param {Object} args
+   * @param {string} args.code The HTTP status code to return
+   * @param {class} args.errorType The error class
+   * @param {string} [args.message=null] Optional message to return for the status code, if not present will default to Error.message
+   * @param {message} [args.errorType] And optional message to display
+   */
+  addErrorHandler( { errorType, code, message = null } = {} ) {
+    validators.statusCode( code );
+    validators.errorType( errorType );
+    this.#errorResponses.push( { errorType, code, message } );
+  }
+
+  /**
+   * Init the flow using a given AWS Lambda APIGateway event (v2 syntax)
+   *
+   * @param {Object} ApiGatewayPayload The raw API Gateway event
+   * @returns {Object} The http response with status, body and headers
+   */
+  async process( awsEvent ) {
+    const event = new Event( { transform: this.#transformRequest } );
+    event.parseFromAwsEvent( awsEvent );
+
+    if ( event.method === 'HEAD' ) {
+      return this.#apiResponse.setContent( 204 ).toJSON();
+    }
+
+    const handler = this.#handlers.find( h => h.match( event ) );
+    if ( !handler ) {
+      return this.#apiResponse.setContent( 405, Text.ERROR_405 ).toJSON();
+    }
+
+    const chain = [
+      ...this.#beforeHooks.map( b => b.fn ),
+      async ev => {
+        const result = await handler.fn( ev );
+        const response = new UserResponse( result );
+        this.#apiResponse.setContent( ...response.values ).toJSON();
+      },
+      ...this.#afterHooks.map( a => a.fn )
+    ];
+
+    try {
+      for ( const fn of chain ) {
+        await fn( event );
+      }
+      return this.#apiResponse.toJSON();
+
+    } catch ( error ) {
+      console.error( 'Lambda API Error', { error, event } );
+
+      const response = this.#errorResponses.find( e => error instanceof e.errorType );
+      if ( response ) {
+        return this.#apiResponse.setContent( response.code, response.message ?? error.message ).toJSON();
+      }
+      return this.#apiResponse.setContent( 500, Text.ERROR_500 ).toJSON();
+    }
+  }
+};
+
+
+/***/ }),
+
+/***/ 446:
+/***/ ((module) => {
+
+module.exports = class LambdaApiValidationError extends Error {};
+
+
+/***/ }),
+
+/***/ 760:
+/***/ ((module) => {
+
+module.exports = {
+  ERROR_500: 'Internal Server Error',
+  ERROR_405: 'Method Not Allowed',
+  INVALID_ERROR_TYPE: 'Argument "errorType" must be a constructor Function',
+  INVALID_FN: 'Argument "fn" must be of type function',
+  INVALID_METHOD: 'Argument "method" must be one of the default HTTP methods',
+  INVALID_STATUS_CODE: 'Argument "statusCode" must be valid HTTP Status Code',
+  INVALID_TRANSFORM_REQUEST: 'Argument "transformRequest" must be either "camelize", "snakelize", false or null',
+  INVALID_TRANSFORM_RESPONSE: 'Argument "transformResponse" must be either "camelize", "snakelize", false or null',
+  INVALID_MATCHER_ROUTE: 'Argument "route" must be either undefined or an string with length greater than 0',
+  INVALID_MATCHER_ROUTE_INCLUDES: 'Argument "routeIncludes" must be either undefined or an string with length greater than 0',
+  INVALID_MATCHER_ROUTE_NOT_INCLUDES: 'Argument "routeNotIncludes" must be either undefined or an string with length greater than 0',
+  INVALID_MATCHER_ROUTE_MATCH: 'Argument "routeMatch" must be either undefined or type RegExp',
+  INVALID_MATCHER_PATH: 'Argument "path" must be either undefined or an string with length greater than 0',
+  INVALID_MATCHER_PATH_INCLUDES: 'Argument "pathIncludes" must be either undefined or an string with length greater than 0',
+  INVALID_MATCHER_PATH_NOT_INCLUDES: 'Argument "pathNotIncludes" must be either undefined or an string with length greater than 0',
+  INVALID_MATCHER_PATH_MATCH: 'Argument "pathMatch" must be either undefined or type RegExp',
+  INVALID_USER_RESPONSE: 'Function return must be a number, a string, an array (where p=0 is a number) or an object (where .statusCode is a number)'
+};
+
+
+/***/ }),
+
+/***/ 282:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const validators = __webpack_require__( 994 );
+const LambdaApiValidationError = __webpack_require__( 446 );
+const Text = __webpack_require__( 760 );
+
+module.exports = class UserResponse {
+  constructor( args ) {
+    if ( args === undefined ) {
+      this.values = [ 204 ];
+    } else if ( typeof args === 'string' && args.length === 0 ) {
+      this.values = [ 204 ];
+
+    } else if ( typeof args === 'string' && args.length > 0 ) {
+      this.values = [ 200, args ];
+
+    } else if ( typeof args === 'number' ) {
+      validators.statusCode( args );
+      this.values = [ args ];
+
+    } else if ( Array.isArray( args ) ) {
+      validators.statusCode( args[0] );
+      this.values = args;
+
+    } else if ( args.statusCode ) {
+      validators.statusCode( args.statusCode );
+      this.values = [ args.statusCode, args.body, args.headers ];
+
+    } else if ( [ undefined, null ].includes( args ) ) {
+      this.values = [ 200 ];
+    } else {
+      throw new LambdaApiValidationError( Text.INVALID_USER_RESPONSE );
+    }
+  }
+};
+
+
+/***/ }),
+
+/***/ 994:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const Text = __webpack_require__( 760 );
+const LambdaApiValidationError = __webpack_require__( 446 );
+
+const evaluate = ( condition, errorMessage ) => {
+  if ( !condition ) { throw new LambdaApiValidationError( errorMessage ); }
+};
+
+const isConstructor = v => {
+  try {
+    return !!Reflect.construct( new Proxy( v, {} ), [] );
+  } catch {
+    return false;
+  }
+};
+
+module.exports = {
+  errorType: v => evaluate( isConstructor( v ), Text.INVALID_ERROR_TYPE ),
+  function: v => evaluate( typeof v === 'function', Text.INVALID_FN ),
+  httpMethod: v => evaluate( [ 'DELETE', 'GET', 'HEAD', 'PATCH', 'POST', 'PUT' ].includes( v ), Text.INVALID_METHOD ),
+  matcherPath: v => evaluate( v === undefined || ( typeof v === 'string' && v.length > 0 ), Text.INVALID_MATCHER_PATH ),
+  matcherPathIncludes: v => evaluate( v === undefined || ( typeof v === 'string' && v.length > 0 ), Text.INVALID_MATCHER_PATH_INCLUDES ),
+  matcherPathMatch: v => evaluate( v === undefined || v?.constructor?.name === RegExp.name, Text.INVALID_MATCHER_PATH_MATCH ),
+  matcherPathNotIncludes: v => evaluate( v === undefined || ( typeof v === 'string' && v.length > 0 ), Text.INVALID_MATCHER_PATH_NOT_INCLUDES ),
+  matcherRoute: v => evaluate( v === undefined || ( typeof v === 'string' && v.length > 0 ), Text.INVALID_MATCHER_ROUTE ),
+  matcherRouteIncludes: v => evaluate( v === undefined || ( typeof v === 'string' && v.length > 0 ), Text.INVALID_MATCHER_ROUTE_INCLUDES ),
+  matcherRouteMatch: v => evaluate( v === undefined || v?.constructor?.name === RegExp.name, Text.INVALID_MATCHER_ROUTE_MATCH ),
+  matcherRouteNotIncludes: v => evaluate( v === undefined || ( typeof v === 'string' && v.length > 0 ), Text.INVALID_MATCHER_ROUTE_NOT_INCLUDES ),
+  statusCode: v => evaluate( typeof v === 'number' && /^[1-5]\d\d$/.test( String( v ) ), Text.INVALID_STATUS_CODE ),
+  transformRequest: v => evaluate( [ 'camelcase', 'snakecase', null, false ].includes( v ), Text.INVALID_TRANSFORM_REQUEST ),
+  transformResponse: v => evaluate( [ 'camelcase', 'snakecase', null, false ].includes( v ), Text.INVALID_TRANSFORM_RESPONSE )
+};
+
+
+/***/ }),
+
+/***/ 124:
+/***/ ((module) => {
+
+module.exports = values => values.reduce( ( sum, value ) => sum + value, 0 ) / values.length;
+
+
+/***/ }),
+
+/***/ 187:
+/***/ ((module) => {
+
+module.exports = values => {
+  //Sort bug: https://www.tutorialrepublic.com/faq/how-to-sort-an-array-of-integers-correctly-in-javascript.php
+  const sorted = values.slice().sort( ( a, b ) => a - b );
+  const evenArray = values.length % 2 === 0;
+  const midIndex = Math.floor( values.length / 2 );
+  return evenArray ? ( sorted[midIndex - 1] + sorted[midIndex] ) / 2 : sorted[midIndex];
+};
+
+
+/***/ }),
+
+/***/ 692:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const calcMedian = __webpack_require__( 187 );
+
+module.exports = pop => {
+  const center = calcMedian( pop );
+  return calcMedian( pop.map( v => Math.abs( v - center ) ) );
+};
+
+
+/***/ }),
+
+/***/ 736:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const calcMean = __webpack_require__( 124 );
+
+module.exports = values => {
+  const mean = calcMean( values );
+  const squareDiffs = values.map( value => Math.pow( value - mean, 2 ) );
+  const avgSquareDiff = calcMean( squareDiffs );
+  return Math.sqrt( avgSquareDiff );
+};
+
+
+/***/ }),
+
+/***/ 89:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const calcMean = __webpack_require__( 124 );
+
+module.exports = values => {
+  if ( values.length < 2 ) { return NaN; }
+
+  const mean = calcMean( values );
+  const squareDiffs = values.map( value => Math.pow( value - mean, 2 ) );
+  const avgSquareDiff = squareDiffs.reduce( ( sum, v ) => sum + v, 0 ) / ( values.length - 1 );
+  return Math.sqrt( avgSquareDiff );
+};
+
+
+/***/ }),
+
+/***/ 110:
+/***/ ((module) => {
+
+module.exports = ( sample, mean, stdDev ) => stdDev === 0 ? NaN : ( sample - mean ) / stdDev;
+
+
+/***/ }),
+
+/***/ 943:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const calcMean = __webpack_require__( 124 );
+const calcMedian = __webpack_require__( 187 );
+const calcMedianAbsDev = __webpack_require__( 692 );
+const calcStdDevPopulation = __webpack_require__( 736 );
+const calcStdDevSample = __webpack_require__( 89 );
+const calcZScore = __webpack_require__( 110 );
+const roundGaussian = __webpack_require__( 637 );
+const roundStandard = __webpack_require__( 115 );
+
+module.exports = {
+  calcMean,
+  calcMedian,
+  calcMedianAbsDev,
+  calcStdDevPopulation,
+  calcStdDevSample,
+  calcZScore,
+  roundGaussian,
+  roundStandard
+};
+
+
+/***/ }),
+
+/***/ 637:
+/***/ ((module) => {
+
+module.exports = ( n, d = 2 ) => {
+  if ( !isFinite( n ) || typeof n !== 'number' ) { return NaN; }
+
+  const m = Math.pow( 10, d );
+  const num = +( n * m ).toFixed( 8 ); // Avoid rounding errors
+  const i = Math.floor( num );
+  const f = num - i;
+  const e = 1e-8; // Allow for rounding errors in f
+  const r = ( f > 0.5 - e && f < 0.5 + e ) ? // eslint-disable-line no-nested-ternary
+    ( ( i % 2 === 0 ) ? i : i + 1 ) : Math.round( num );
+  return r / m;
+};
+
+
+/***/ }),
+
+/***/ 115:
+/***/ ((module) => {
+
+module.exports = ( n, d = 2 ) => Math.round( n * ( 10 ** d ) ) / ( 10 ** d );
+
+
+/***/ }),
+
+/***/ 256:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const isSerializable = __webpack_require__( 864 );
+const camelize = __webpack_require__( 914 );
+
+const change = ( obj, keepAllCaps ) =>
+  !isSerializable( obj ) ? obj : Object.entries( obj ).reduce( ( transformed, [ key, value ] ) => {
+    delete transformed[key];
+    transformed[camelize( key, { keepAllCaps } )] = typeof value === 'object' ? change( value, keepAllCaps ) : value;
+    return transformed;
+  }, Array.isArray( obj ) ? [] : {} );
+
+module.exports = ( obj, { keepAllCaps = false } = {} ) => change( obj, keepAllCaps );
+
+
+/***/ }),
+
+/***/ 451:
+/***/ ((module) => {
+
+module.exports = ( obj, props ) => Object.fromEntries( Object.entries( obj ).filter( ( [ k ] ) => props.includes( k ) ) );
+
+
+/***/ }),
+
+/***/ 762:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const camelize = __webpack_require__( 256 );
+const filterProps = __webpack_require__( 451 );
+const snakelize = __webpack_require__( 572 );
+
+module.exports = {
+  camelize,
+  filterProps,
+  snakelize
+};
+
+
+/***/ }),
+
+/***/ 864:
+/***/ ((module) => {
+
+module.exports = obj =>
+  typeof obj === 'object' &&
+  obj !== null &&
+  !( obj instanceof String ) &&
+  !( obj instanceof Number ) &&
+  !( obj instanceof Boolean ) &&
+  !( obj instanceof Date );
+
+
+/***/ }),
+
+/***/ 572:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const isSerializable = __webpack_require__( 864 );
+const snakelize = __webpack_require__( 402 );
+
+const change = ( obj, keepAllCaps ) =>
+  !isSerializable( obj ) ? obj : Object.entries( obj ).reduce( ( transformed, [ key, value ] ) => {
+    delete transformed[key];
+    transformed[snakelize( key, { keepAllCaps } )] = typeof value === 'object' ? change( value, keepAllCaps ) : value;
+    return transformed;
+  }, Array.isArray( obj ) ? [] : {} );
+
+module.exports = ( obj, { keepAllCaps = false } = {} ) => change( obj, keepAllCaps );
+
+
+/***/ }),
+
+/***/ 914:
+/***/ ((module) => {
+
+// Convert a string to camelCase
+module.exports = ( input, { keepAllCaps = false } = {} ) =>
+  // Break the string into sequences to rebuild later
+  !input ? input : input.split( /\s/ )
+    // ALL_CAPS terms are ignored
+    .map( term => [ term, keepAllCaps && /^[A-Z_]+$/g.test( term ) ? term : term
+      // Matches the penultimate letter in a sequence of upper case followed by lower case and convert it to lower case
+      // Effectively creating a word break eg: BDay => bDay
+      .replace( /[A-Z](?=[A-Z][a-z])/g, c => `${c[0].toLowerCase()}` )
+      .replace( /([A-Z])([A-Z]+)/g, c => `${c[0]}${c.slice( 1 ).toLowerCase()}` ) // Sequences of upper case
+      .replace( /([-_]\w)/g, c => c[1].toUpperCase() ) // first letter after hyphen and underline
+      .replace( /^([A-Z])/g, c => c[0].toLowerCase() ) // first letter
+    ] )
+    // Rebuild the string replacing the converter terms keeping the original delimiters
+    .reduce( ( result, [ term, repl ] ) => result.replace( term, repl ), input );
+
+
+/***/ }),
+
+/***/ 258:
+/***/ ((module) => {
+
+module.exports = input =>
+  // Break the string into sequences to rebuild later
+  !input ? input : input.split( /\s/ )
+    // ALL_CAPS terms are ignored
+    .map( term => [ term, term.charAt( 0 ).toUpperCase() + term.slice( 1 ).toLowerCase() ] )
+    // Rebuild the string replacing the converter terms keeping the original delimiters
+    .reduce( ( result, [ term, repl ] ) => result.replace( term, repl ), input );
+
+
+/***/ }),
+
+/***/ 268:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const camelize = __webpack_require__( 914 );
+const capitalizeWords = __webpack_require__( 258 );
+const snakelize = __webpack_require__( 402 );
+
+module.exports = {
+  camelize,
+  capitalizeWords,
+  snakelize
+};
+
+
+/***/ }),
+
+/***/ 402:
+/***/ ((module) => {
+
+// convert a string to snake_case
+module.exports = ( input, { keepAllCaps = false } = {} ) =>
+  // Break the string into sequences to rebuild later
+  !input ? input : input.split( /\s/ )
+    // ALL_CAPS terms are ignored
+    .map( term => [ term, keepAllCaps && /^[A-Z_]+$/g.test( term ) ? term : term
+      .replace( /-/g, '_' ) // replaces hyphen
+      .replace( /([a-z\d])([A-Z])/g, '$1_$2' ) // add _ between lower and upper case letters
+      .replace( /([A-Z])([A-Z])(?=[a-z\d])/g, '$1_$2' ).toLowerCase() // add _ between uppercase char and next uppercase char follow by lowercase
+    ] )
+    // Rebuild the string replacing the converter terms keeping the original delimiters
+    .reduce( ( result, [ term, repl ] ) => result.replace( term, repl ), input );
+
+
+/***/ }),
+
+/***/ 878:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const retryOnError = __webpack_require__( 243 );
+const sleep = __webpack_require__( 445 );
+const Timer = __webpack_require__( 651 );
+const untarJsonGz = __webpack_require__( 233 );
+
+module.exports = {
+  retryOnError,
+  sleep,
+  Timer,
+  untarJsonGz
+};
+
+
+/***/ }),
+
+/***/ 243:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const sleep = __webpack_require__( 445 );
+
+const execWithRetry = async ( closure, { limit, delay, retryHook, execCount = 0 } ) => {
+  if ( !( closure instanceof Function ) ) {
+    throw new Error( 'Closure is not a function' );
+  }
+
+  try {
+    return await closure();
+  } catch ( error ) {
+    // exhausted
+    if ( execCount === limit ) { throw error; }
+
+    // async retry hook to check if it should retry or give up and throw
+    if ( retryHook instanceof Function ) {
+      try {
+        const retry = await retryHook( error, execCount );
+        if ( retry === false ) { return false; }
+
+      // Hook errors break the flow
+      } catch ( hookError ) {
+        console.debug( hookError );
+        throw hookError;
+      }
+    }
+
+    // if there is no hook back-off and retry
+    if ( delay > 0 ) {
+      await sleep( delay ** ( 1 + execCount ) );
+    }
+    return execWithRetry( closure, { limit, delay, retryHook, execCount: execCount + 1 } );
+  }
+};
+
+/**
+ *
+ * @param {Function} closure A self contained function that will be invoked
+ * @param {Object} config
+ * @param {Number} limit The max number of retries
+ * @param {Number} delay The delay between each retry (it will be multiplied by the number of retries, so, it is linear back-off)
+ * @param {Function} retryHook A function to be called every-time a retry is needed.
+ *                             If this functions returns false, the retry error is raised
+ *                             If this functions throws error, the thrown error is raised
+ * @returns {Any} The closure result
+ */
+module.exports = async ( closure, { limit = 0, delay = 0, retryHook = null } = {} ) =>
+  execWithRetry( closure, { limit, delay, retryHook } );
+
+
+/***/ }),
+
+/***/ 445:
+/***/ ((module) => {
+
+module.exports = t => new Promise( r => setTimeout( r, t ) );
+
+
+/***/ }),
+
+/***/ 651:
+/***/ ((module) => {
+
+module.exports = class Timer {
+  #startedAt;
+  #stoppedAt = null;
+  #running = false;
+
+  get elapsed() {
+    if ( this.#running ) {
+      return Date.now() - this.#startedAt;
+    } else if ( !this.#startedAt ) {
+      return 0;
+    } else {
+      return this.#stoppedAt - this.#startedAt;
+    }
+  }
+
+  get running() {
+    return this.#running;
+  }
+
+  start() {
+    if ( !this.#running ) {
+      this.#startedAt = Date.now();
+      this.#running = true;
+    }
+    return this;
+  }
+
+  restart() {
+    this.#running = true;
+    this.#startedAt = Date.now();
+    return this;
+  }
+
+  stop() {
+    if ( this.#running ) {
+      this.#running = false;
+      this.#stoppedAt = Date.now();
+    }
+    return this.#stoppedAt - this.#startedAt;
+  }
+};
+
+
+/***/ }),
+
+/***/ 233:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const { unzipSync } = __webpack_require__( 106 );
+
+const firstIndexOf = ( c, ...vars ) => Math.min( ...vars.map( v => c.indexOf( v ) ).filter( n => n > -1 ) );
+const lastIndexOf = ( c, ...vars ) => Math.max( ...vars.map( v => c.lastIndexOf( v ) ) );
+
+/**
+ * Decompress JSON
+ *
+ * Reads a gzipped tarball (.tar.gz)
+ * 1. Unzip it
+ * 2. Convert all to utf-8
+ * 3. Split files using the \0star separator
+ * 4. Trim files until JSON markup start/end ({})
+ * 5. JSON parse
+ *
+ * Enjoy this 100% native tarball decompression!
+ */
+module.exports = raw =>
+  unzipSync( raw )
+    .toString( 'utf-8' )
+    .split( '\0ustar' )
+    .slice( 1 )
+    .map( c =>
+      JSON.parse( c.substring( firstIndexOf( c, '{', '[' ), lastIndexOf( c, '}', ']' ) + 1 ) )
+    );
+
+
+/***/ }),
+
+/***/ 106:
+/***/ ((module) => {
+
+module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("zlib");
+
+/***/ })
+
+/******/ });
+/************************************************************************/
+/******/ // The module cache
+/******/ var __webpack_module_cache__ = {};
+/******/ 
+/******/ // The require function
+/******/ function __webpack_require__(moduleId) {
+/******/ 	// Check if module is in cache
+/******/ 	var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 	if (cachedModule !== undefined) {
+/******/ 		return cachedModule.exports;
+/******/ 	}
+/******/ 	// Create a new module (and put it into the cache)
+/******/ 	var module = __webpack_module_cache__[moduleId] = {
+/******/ 		// no module.id needed
+/******/ 		// no module.loaded needed
+/******/ 		exports: {}
+/******/ 	};
+/******/ 
+/******/ 	// Execute the module function
+/******/ 	__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 
+/******/ 	// Return the exports of the module
+/******/ 	return module.exports;
+/******/ }
+/******/ 
+/************************************************************************/
+/******/ 
+/******/ // startup
+/******/ // Load entry module and return exports
+/******/ // This entry module is referenced by other modules so it can't be inlined
+/******/ var __webpack_exports__ = __webpack_require__(44);
+/******/