lambda-toolkit 1.1.1 → 2.0.0-dev.1

package/dist/{index.js → index.cjs}

@@ -1,1243 +1,1630 @@
 /******/ (() => { // webpackBootstrap
-/******/ 	var __webpack_modules__ = ({
-
-/***/ 8278
-(module, __unused_webpack_exports, __webpack_require__) {
-
-const joinUnique = __webpack_require__( 2836 );
-const joinUniqueCustom = __webpack_require__( 536 );
-const splitBatches = __webpack_require__( 4821 );
-
-module.exports = {
-  joinUnique,
-  joinUniqueCustom,
-  splitBatches
+/******/ 	"use strict";
+/******/ 	// The require scope
+/******/ 	var __webpack_require__ = {};
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = (exports, definition) => {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	(() => {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = (exports) => {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  LambdaApi: () => (/* reexport */ LambdaApi),
+  array: () => (/* reexport */ array_namespaceObject),
+  aws: () => (/* reexport */ aws_namespaceObject),
+  epoch: () => (/* reexport */ epoch_namespaceObject),
+  math: () => (/* reexport */ math_namespaceObject),
+  object: () => (/* reexport */ object_namespaceObject),
+  redis: () => (/* reexport */ redis_namespaceObject),
+  string: () => (/* reexport */ string_namespaceObject),
+  utils: () => (/* reexport */ utils_namespaceObject)
+});
+
+// NAMESPACE OBJECT: ./src/array/index.js
+var array_namespaceObject = {};
+__webpack_require__.r(array_namespaceObject);
+__webpack_require__.d(array_namespaceObject, {
+  joinUnique: () => (joinUnique),
+  joinUniqueCustom: () => (joinUniqueCustom),
+  splitBatches: () => (splitBatches)
+});
+
+// NAMESPACE OBJECT: ./src/aws/index.js
+var aws_namespaceObject = {};
+__webpack_require__.r(aws_namespaceObject);
+__webpack_require__.d(aws_namespaceObject, {
+  athena: () => (athena),
+  cwLogs: () => (cwLogs),
+  dynamo: () => (dynamo),
+  lambda: () => (lambda),
+  s3: () => (s3),
+  ses: () => (ses),
+  sns: () => (sns),
+  sqs: () => (sqs),
+  ssm: () => (ssm),
+  timestreamQuery: () => (timestreamQuery),
+  timestreamWrite: () => (timestreamWrite)
+});
+
+// NAMESPACE OBJECT: ./src/epoch/index.js
+var epoch_namespaceObject = {};
+__webpack_require__.r(epoch_namespaceObject);
+__webpack_require__.d(epoch_namespaceObject, {
+  days: () => (days),
+  hours: () => (hours),
+  minutes: () => (minutes),
+  months: () => (months),
+  msToS: () => (msToS),
+  round: () => (round),
+  seconds: () => (seconds)
+});
+
+// NAMESPACE OBJECT: ./src/math/index.js
+var math_namespaceObject = {};
+__webpack_require__.r(math_namespaceObject);
+__webpack_require__.d(math_namespaceObject, {
+  calcMean: () => (calcMean),
+  calcMedian: () => (calcMedian),
+  calcMedianAbsDev: () => (calcMedianAbsDev),
+  calcStdDevPopulation: () => (calcStdDevPopulation),
+  calcStdDevSample: () => (calcStdDevSample),
+  calcZScore: () => (calcZScore),
+  roundGaussian: () => (roundGaussian),
+  roundStandard: () => (roundStandard)
+});
+
+// NAMESPACE OBJECT: ./src/object/index.js
+var object_namespaceObject = {};
+__webpack_require__.r(object_namespaceObject);
+__webpack_require__.d(object_namespaceObject, {
+  camelize: () => (camelize_camelize),
+  filterProps: () => (filterProps),
+  removeEmptyArrays: () => (removeEmptyArrays),
+  snakelize: () => (snakelize_snakelize)
+});
+
+// NAMESPACE OBJECT: ./src/redis/index.js
+var redis_namespaceObject = {};
+__webpack_require__.r(redis_namespaceObject);
+__webpack_require__.d(redis_namespaceObject, {
+  createClient: () => (createClient)
+});
+
+// NAMESPACE OBJECT: ./src/string/index.js
+var string_namespaceObject = {};
+__webpack_require__.r(string_namespaceObject);
+__webpack_require__.d(string_namespaceObject, {
+  camelize: () => (camelize),
+  capitalizeWords: () => (capitalizeWords),
+  snakelize: () => (snakelize)
+});
+
+// NAMESPACE OBJECT: ./src/utils/index.js
+var utils_namespaceObject = {};
+__webpack_require__.r(utils_namespaceObject);
+__webpack_require__.d(utils_namespaceObject, {
+  Timer: () => (Timer),
+  retryOnError: () => (retryOnError),
+  sleep: () => (sleep_sleep),
+  untarJsonGz: () => (untarJsonGz)
+});
+
+;// ./src/lambda_api/text_enum.js
+const Text = {
+  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)'
 };
 
+;// ./src/lambda_api/lambda_api_validation_error.js
+class LambdaApiValidationError extends Error {};
 
-/***/ },
+;// ./src/lambda_api/validator.js
 
-/***/ 2836
-(module) {
 
-module.exports = ( ...args ) => [ ...new Set( args.filter( Array.isArray ).flat() ) ];
 
+const evaluate = ( condition, errorMessage ) => {
+  if ( !condition ) { throw new LambdaApiValidationError( errorMessage ); }
+};
 
-/***/ },
-
-/***/ 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()
-];
+const isConstructor = v => {
+  try {
+    return !!Reflect.construct( new Proxy( v, {} ), [] );
+  } catch {
+    return false;
+  }
+};
 
+const Validator = {
+  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 )
+};
 
-/***/ },
+;// ./src/object/is_serializable.js
+const isSerializable = obj =>
+  typeof obj === 'object' &&
+  obj !== null &&
+  !( obj instanceof String ) &&
+  !( obj instanceof Number ) &&
+  !( obj instanceof Boolean ) &&
+  !( obj instanceof Date );
 
-/***/ 4821
-(module) {
+;// ./src/string/camelize.js
+// Convert a string to camelCase
+const camelize = ( 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 );
 
-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();
+;// ./src/object/camelize.js
 
 
-/***/ },
 
-/***/ 228
-(module, __unused_webpack_exports, __webpack_require__) {
+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 ) ? [] : {} );
 
-const { AthenaClient } = __webpack_require__( 3744 );
-const clientProvider = __webpack_require__( 9039 );
-const query = __webpack_require__( 140 );
-const createInstance = __webpack_require__( 5438 );
+const camelize_camelize = ( obj, { keepAllCaps = false } = {} ) => change( obj, keepAllCaps );
 
-const methods = {
-  query
-};
+;// ./src/string/snakelize.js
+// convert a string to snake_case
+const snakelize = ( 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 );
 
-module.exports = createInstance( clientProvider.bind( null, AthenaClient ), methods );
+;// ./src/object/snakelize.js
 
 
-/***/ },
 
-/***/ 7337
-(module, __unused_webpack_exports, __webpack_require__) {
+const snakelize_change = ( obj, keepAllCaps ) =>
+  !isSerializable( obj ) ? obj : Object.entries( obj ).reduce( ( transformed, [ key, value ] ) => {
+    delete transformed[key];
+    transformed[snakelize( key, { keepAllCaps } )] = typeof value === 'object' ? snakelize_change( value, keepAllCaps ) : value;
+    return transformed;
+  }, Array.isArray( obj ) ? [] : {} );
 
-const { GetQueryExecutionCommand, GetQueryResultsCommand } = __webpack_require__( 3744 );
-const parseResults = __webpack_require__( 834 );
-const pollingDelay = __webpack_require__( 4127 );
+const snakelize_snakelize = ( obj, { keepAllCaps = false } = {} ) => snakelize_change( obj, keepAllCaps );
 
-const sleep = t => new Promise( r => setTimeout( () => r(), t ) );
+;// ./src/lambda_api/api_response.js
 
-const getQueryResults = async ( { client, queryExecutionId, maxResults, token } ) => {
-  const { NextToken: nextToken, ResultSet } = await client.send( new GetQueryResultsCommand( {
-    ...{ QueryExecutionId: queryExecutionId },
-    ...( maxResults ? { MaxResults: maxResults } : {} ),
-    ...( token ? { NextToken: token } : {} )
-  } ) );
 
-  return { nextToken, items: parseResults( ResultSet ) };
-};
-const getQueryResultsRecursive = async ( { client, queryExecutionId, token } ) => {
-  const { nextToken, items } = await getQueryResults( { client, queryExecutionId, token } );
+const charset = 'utf-8';
 
-  if ( nextToken ) {
-    return { items: items.concat( ( await getQueryResultsRecursive( { client, queryExecutionId, token: nextToken } ) ).items ) };
-  }
-  return { items };
+const transformFns = {
+  camelcase: camelize_camelize,
+  snakecase: snakelize_snakelize
 };
 
-/**
- * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/athena/command/GetQueryResultsCommand/
- * { client, recursive, queryExecutionId, maxResults, paginationToken }
- */
-const getResults = async ( { client, recursive, queryExecutionId, token, maxResults } ) => {
-  const { QueryExecution: { Status: status } } = await client.send( new GetQueryExecutionCommand( { QueryExecutionId: queryExecutionId } ) );
+class ApiResponse {
+  #headers = null;
+  #statusCode = null;
+  #transformFn = false;
+  #isBase64Encoded = false;
+  #body = '';
 
-  if ( status.State === 'FAILED' ) {
-    throw new Error( status.AthenaError?.ErrorMessage ?? status.StateChangeReason );
+  constructor( { headers = {}, transform } = {} ) {
+    this.#transformFn = transformFns[transform] ?? ( v => v );
+    this.#headers = Object.assign( {
+      'Cache-Control': 'no-store',
+      'Access-Control-Allow-Origin': '*'
+    }, headers );
   }
 
-  if ( status.State === 'SUCCEEDED' ) {
-    const fn = recursive ? getQueryResultsRecursive : getQueryResults;
-    return fn( { client, recursive, queryExecutionId, token, maxResults } );
+  setContent( statusCode, body, headers = {}, isBase64Encoded = false ) {
+    this.#statusCode = statusCode;
+    this.#isBase64Encoded = isBase64Encoded;
+    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;
   }
 
-  // sleep an try again
-  await sleep( pollingDelay );
-  return getResults( { client, recursive, queryExecutionId, token, maxResults } );
+  toJSON() {
+    return {
+      isBase64Encoded: this.#isBase64Encoded,
+      statusCode: this.#statusCode,
+      body: this.#body,
+      headers: this.#headers
+    };
+  }
 };
 
-module.exports = getResults;
-
-
-/***/ },
-
-/***/ 834
-(module, __unused_webpack_exports, __webpack_require__) {
+;// ./src/lambda_api/event.js
 
-const parseValue = __webpack_require__( 9129 );
 
-module.exports = resultSet => {
-  const columns = resultSet.ResultSetMetadata.ColumnInfo
-    .map( col => ( { name: col.Name, type: col.Type } ) );
-
-  // first data row contains the table field names
-  return resultSet.Rows.slice( 1 ).map( row => {
-    const values = row.Data.map( d => d.VarCharValue );
-    return columns.reduce( ( obj, p, i ) => Object.assign( obj, { [p.name]: parseValue( values[i], p.type ) } ), {} );
-  } );
+const event_transformFns = {
+  camelcase: camelize_camelize,
+  snakecase: snakelize_snakelize
 };
 
+const parseJson = content => {
+  try {
+    return JSON.parse( content );
+  } catch {
+    return content;
+  }
+};
 
-/***/ },
-
-/***/ 9129
-(module) {
+class Event {
+  #transformFn;
+  authorizer;
+  body;
+  rawBody;
+  headers;
+  method;
+  params;
+  path;
+  queryString;
+  route;
 
-/* eslint consistent-return: 0 */
-const removeNullValues = ( o, isArray = Array.isArray( o ) ) =>
-  Object.entries( o ).reduce( ( newObj, [ k, v ] ) => {
-    if ( v === null && !isArray ) { return newObj; }
-    return Object.assign( newObj, { [k]: v?.constructor === Object ? removeNullValues( v ) : v } );
-  }, isArray ? [] : {} );
+  context = {};
 
-module.exports = ( v, type ) => {
-  if ( [ null, undefined ].includes( v ) ) {
-    return undefined;
-  }
-  if ( v === '' && type !== 'varchar' ) {
-    return undefined;
-  }
-  if ( type === 'boolean' ) {
-    return v === 'true';
-  }
-  if ( [ 'float', 'decimal', 'double' ].includes( type ) ) {
-    return parseFloat( v );
-  }
-  if ( [ 'tinyint', 'smallint', 'int', 'bigint' ].includes( type ) ) {
-    return parseInt( v );
-  }
-  if ( 'timestamp' === type ) {
-    return new Date( v ).getTime();
+  constructor( { transform = false } = {} ) {
+    this.#transformFn = event_transformFns[transform] ?? ( v => v );
   }
-  if ( [ 'row', 'array' ].includes( type ) ) {
-    const obj = v.replace( /(?<=(?:{|,\s)[\w-_]+)=/g, '@@DELIMITER@@' ) // replaces delimiter = with @@DELIMITER@@
-      .replace( /(?<={|,\s)([\w_-]+)(?=@@DELIMITER@@)/g, '"$1"' ) // wrap object keys
-      .replace( /(?<=@@DELIMITER@@)((?:(?!,\s|}|\[|{).)+)/g, '"$1"' ) // wrap object values
-      .replace( /(?<=\[|,\s)((?:(?!,\s|{|\]|").)+)/g, '"$1"' ) // wrap array values
-      .replace( /"null"/g, 'null' ) // convert "null" to null
-      .replace( /@@DELIMITER@@/g, ':' ); // replaces @@DELIMITER@@ for :
 
-    return removeNullValues( JSON.parse( obj ) );
-  }
-  if ( 'json' === type ) {
-    return JSON.parse( v );
+  parseFromAwsEvent( awsEvent ) {
+    this[`parseFromAwsEventV${awsEvent.version === '2.0' ? 2 : 1}`]( awsEvent );
   }
-  return v;
-};
 
+  parseFromAwsEventV1( awsEvent ) {
+    const {
+      body,
+      path,
+      resource,
+      httpMethod,
+      requestContext,
+      pathParameters,
+      headers,
+      multiValueHeaders,
+      queryStringParameters,
+      multiValueQueryStringParameters: multiValueQueryString,
+      isBase64Encoded
+    } = awsEvent;
 
-/***/ },
-
-/***/ 4127
-(module) {
-
-module.exports = 500;
+    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.rawBody = body ?? null;
+    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;
+    this.isBase64Encoded = isBase64Encoded ?? false;
+  }
 
-/***/ 5723
-(module, __unused_webpack_exports, __webpack_require__) {
+  parseFromAwsEventV2( awsEvent ) {
+    const {
+      body,
+      routeKey,
+      requestContext,
+      pathParameters,
+      headers,
+      queryStringParameters,
+      isBase64Encoded
+    } = awsEvent;
 
-const { randomBytes } = __webpack_require__( 6982 );
-const { StartQueryExecutionCommand } = __webpack_require__( 3744 );
+    const { http: { method, path } } = requestContext;
 
-/**
- * args : https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/athena/command/StartQueryExecutionCommand/
- * A ClientRequestToken is created automatically
- */
-module.exports = async ( { client, ...args } ) => {
-  const cmd = new StartQueryExecutionCommand( {
-    ClientRequestToken: randomBytes( 16 ).toString( 'hex' ),
-    ...args
-  } );
-  const { QueryExecutionId: queryId } = await client.send( cmd );
-  return queryId;
+    this.authorizer = requestContext?.authorizer;
+    this.rawBody = body ?? null;
+    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( /\/$/, '' );
+    this.isBase64Encoded = isBase64Encoded ?? false;
+  }
 };
 
+;// ./src/lambda_api/handler.js
 
-/***/ },
 
-/***/ 140
-(module, __unused_webpack_exports, __webpack_require__) {
+class Handler {
+  #method;
+  #fn;
+  #route;
+  #routeIncludes;
+  #routeNotIncludes;
+  #routeMatches;
+  #path;
+  #pathIncludes;
+  #pathNotIncludes;
+  #pathMatches;
 
-const { encode, decode } = __webpack_require__( 5744 );
-const startQuery = __webpack_require__( 5723 );
-const getResults = __webpack_require__( 7337 );
+  constructor( { method, fn, ...matchers } ) {
+    Validator.httpMethod( method );
+    Validator.function( fn );
+    Validator.matcherRoute( matchers.route );
+    Validator.matcherRouteIncludes( matchers.routeIncludes );
+    Validator.matcherRouteNotIncludes( matchers.routeNotIncludes );
+    Validator.matcherRouteMatch( matchers.routeMatch );
+    Validator.matcherPath( matchers.path );
+    Validator.matcherPathIncludes( matchers.pathIncludes );
+    Validator.matcherPathNotIncludes( matchers.pathNotIncludes );
+    Validator.matcherPathMatch( matchers.pathMatch );
 
-const getQueryExecutionId = async ( { client, nativeArgs, recursive, paginationToken } ) => {
-  if ( !recursive && paginationToken ) {
-    const { queryExecutionId, token } = decode( paginationToken );
-    return { queryExecutionId, token };
+    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;
   }
 
-  const queryExecutionId = await startQuery( { client, ...nativeArgs } );
-  return { queryExecutionId };
-};
-
-/**
- * @class Result
- * @type {Object}
- * @property {Object[]} items Each query result row, parsed to a camelized js object
- * @property {String} paginationToken The next pagination token, if recursive = false ans there are more results for the query
- */
-
-/**
- * Executes an Athena Query
- * @param {*} client The native client
- * @param {Object} nativeArgs The native args to start the Athena Query
- * @param {Object=} options Query configuration
- * @param {Boolean=} [options.recursive=false] If to recursive query all results or to return a paginationToken after each page
- * @param {String=} options.paginationToken The pagination token received in the previous call to resume the query (only used when recursive = false)
- * @param {Number=} options.maxResults The maximum number of results per page (only when using pagination token)
- * @returns {Result} The query result
- */
-module.exports = async ( client, nativeArgs, options ) => {
-  const { recursive = false, paginationToken, maxResults } = options;
-
-  const { queryExecutionId, token } = await getQueryExecutionId( { client, nativeArgs, recursive, paginationToken } );
+  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;
+  }
 
-  const { nextToken, items } = await getResults( { client, queryExecutionId, token, recursive, maxResults } );
-  return { paginationToken: nextToken ? encode( { queryExecutionId, token: nextToken } ) : undefined, items };
+  get fn() { return this.#fn; }
 };
 
+;// ./src/lambda_api/hook.js
 
-/***/ },
-
-/***/ 4164
-(module, __unused_webpack_exports, __webpack_require__) {
-
-const cacheSym = Symbol.for( 'cache' );
-const crypto = __webpack_require__( 6982 );
-
-const hash = text => crypto.createHash( 'md5' ).update( text ).digest( 'hex' );
-
-const propOpts = {
-  enumerable: false,
-  configurable: false,
-  writable: false
-};
-
-module.exports = {
-  set: ( key, value ) => {
-    const keySym = Symbol.for( hash( key ) );
 
-    if ( !global[cacheSym] ) {
-      Object.defineProperty( global, cacheSym, { ...propOpts, value: {} } );
-    }
+class Hook {
+  #fn;
 
-    Object.defineProperty( global[cacheSym], keySym, { ...propOpts, value } );
-  },
-  get: key => {
-    return global[cacheSym]?.[Symbol.for( hash( key ) )];
+  constructor( { fn } ) {
+    Validator.function( fn );
+    this.#fn = fn;
   }
-};
-
 
-/***/ },
-
-/***/ 5438
-(module) {
+  get fn() { return this.#fn; }
+};
 
-/**
- * This is base object each AWS abstraction will provide
- */
-module.exports = ( providerFn, methods ) => {
-  // This creates the "instance",
-  // so calling the method as a function returns a copy of its client instantiated with the given args
-  // every method called from it will use this instance
-  const factory = args => {
-    const client = providerFn( args );
-    // return self, so it is possible use the native client
-    methods.getClient = () => client;
-    return Object.entries( methods ).reduce( ( o, [ k, v ] ) => Object.assign( o, { [k]: v.bind( null, client ) } ), { } );
-  };
+;// ./src/lambda_api/user_response.js
 
-  // This is the singleton part;
-  // First add the static method to the factory;
-  Object.entries( methods ).forEach( ( [ key, value ] ) => factory[key] = value );
 
-  // Then add the special method "getClient", so it is possible use the native client
-  factory.getClient = client => client;
 
-  // Finally makes the proxy which will allow each singleton method to use the client provider of the AWS service+
-  return new Proxy( factory, {
-    get( target, key ) {
-      const t = target[key];
-      return ( typeof t === 'function' ) ? t.bind( null, providerFn() ) : t;
-    }
-  } );
-};
 
+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 ];
 
-/***/ 5744
-(module) {
+    } else if ( typeof args === 'number' ) {
+      Validator.statusCode( args );
+      this.values = [ args ];
 
-module.exports = {
-  encode: k => {
-    if ( k === null || k === undefined ) { return k; }
+    } else if ( Array.isArray( args ) ) {
+      Validator.statusCode( args[0] );
+      this.values = args;
 
-    return Buffer.from( JSON.stringify( k ) ).toString( 'base64' );
-  },
-  decode: k => {
-    if ( k === null || k === undefined ) { return k; }
+    } else if ( args.statusCode ) {
+      Validator.statusCode( args.statusCode );
+      this.values = [ args.statusCode, args.body, args.headers, args.isBase64Encoded ];
 
-    const result = Buffer.from( k, 'base64' ).toString( 'utf8' );
-    try {
-      return JSON.parse( result );
-    } catch {
-      return result;
+    } else if ( [ undefined, null ].includes( args ) ) {
+      this.values = [ 200 ];
+    } else {
+      throw new LambdaApiValidationError( Text.INVALID_USER_RESPONSE );
     }
   }
 };
 
+;// ./src/lambda_api/lambda_api.js
 
-/***/ },
-
-/***/ 9039
-(module, __unused_webpack_exports, __webpack_require__) {
-
-const cache = __webpack_require__( 4164 );
-
-module.exports = ( constructor, args = [] ) => {
-  const cacheKey = `${constructor.name}(${args.map( arg => JSON.stringify( arg ) ).join( ',' )})`;
-  return cache.get( cacheKey ) ?? ( () => {
-    const client = Reflect.construct( constructor, args );
-    cache.set( cacheKey, client );
-    return client;
-  } )();
-};
-
-
-/***/ },
 
-/***/ 2710
-(module, __unused_webpack_exports, __webpack_require__) {
 
-const { CloudWatchLogsClient } = __webpack_require__( 7493 );
-const clientProvider = __webpack_require__( 9039 );
-const query = __webpack_require__( 4338 );
-const createInstance = __webpack_require__( 5438 );
-
-const methods = {
-  query
-};
 
-module.exports = createInstance( clientProvider.bind( null, CloudWatchLogsClient ), methods );
 
 
-/***/ },
 
-/***/ 739
-(module, __unused_webpack_exports, __webpack_require__) {
 
-const { GetQueryResultsCommand } = __webpack_require__( 7493 );
-const pollingDelay = __webpack_require__( 2549 );
-const sleep = t => new Promise( r => setTimeout( () => r(), t ) );
+class LambdaApi {
+  #apiResponse = null;
+  #handlers = [];
+  #errorResponses = [];
+  #beforeHooks = [];
+  #afterHooks = [];
+  #transformRequest = [];
 
-const getResults = async ( { client, command } ) => {
-  const { results, status } = await client.send( command );
+  /**
+   * Creates a new Lambda Api
+   *
+   * @param {Object} headers Any headers you want to be included in all responses
+   */
+  constructor( { headers = {}, transformRequest = false, transformResponse = false } = {} ) {
+    Validator.transformRequest( transformRequest );
+    Validator.transformResponse( transformResponse );
 
-  if ( [ 'Cancelled', 'Failed', 'Timeout', 'Unknown' ].includes( status ) ) {
-    throw new Error( `Query status is "${status}"` );
+    this.#transformRequest = transformRequest;
+    this.#apiResponse = new ApiResponse( { headers, transform: transformResponse } );
   }
 
-  if ( status === 'Complete' ) {
-    return results;
+  /**
+   * 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 } ) );
   }
 
-  // Running, Scheduled
-  await sleep( pollingDelay );
-  return getResults( { client, command } );
-};
+  /**
+   * 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 } ) );
+  }
 
-module.exports = async ( { client, queryId } ) => {
-  const command = new GetQueryResultsCommand( { queryId } );
-  return getResults( { client, command } );
-};
+  /**
+   * 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 } = {} ) {
+    Validator.statusCode( code );
+    Validator.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 );
 
-/***/ 4338
-(module, __unused_webpack_exports, __webpack_require__) {
+    if ( event.method === 'HEAD' ) {
+      return this.#apiResponse.setContent( 204 ).toJSON();
+    }
 
-const startQuery = __webpack_require__( 3649 );
-const getResults = __webpack_require__( 739 );
-const parseResults = __webpack_require__( 9552 );
+    const handler = this.#handlers.find( h => h.match( event ) );
+    if ( !handler ) {
+      return this.#apiResponse.setContent( 405, Text.ERROR_405 ).toJSON();
+    }
 
-/**
- * @class Result
- * @type {Object}
- * @property {Object[]} items Each query result row, parsed to a camelized js object
- * @property {Number} count Total number of results
- */
+    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 )
+    ];
 
-/**
- * Executes an Athena Query
- * @param {*} client The native client
- * @param {Object} nativeArgs The native args to start the Cloudwatch Query
- * @param {Object=} options Extra options for this command
- * @param {Object=} options.range Since the nativeArgs "startTime" and "endTime" are second based epochs, the "range" argument accepts milliseconds based epochs for convenience, thus overwriting the "nativeArgs"
- * @param {Number} options.range.from The beginning of the time range to query, overwrites "startTime"
- * @param {Number} options.range.to The end of the time range to query, overwrites "endTime"
- * @returns {Result} The query result
- */
-module.exports = async ( client, nativeArgs, { range = {} } = {} ) => {
-  const queryId = await startQuery( { client, nativeArgs, range } );
-  const results = await getResults( { client, queryId } );
-  const items = parseResults( results );
-  return { items, count: items.length };
+    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();
+    }
+  }
 };
 
+;// ./src/lambda_api/index.js
 
-/***/ },
 
-/***/ 9179
-(module, __unused_webpack_exports, __webpack_require__) {
 
-const parseValue = __webpack_require__( 2847 );
 
-module.exports = item =>
-  item.reduce( ( row, { field, value } ) =>
-    Object.assign( row, {
-      [field]: parseValue( value )
-    } ), {} );
+;// ./src/array/join_unique.js
+const joinUnique = ( ...args ) => [ ...new Set( args.filter( Array.isArray ).flat() ) ];
 
+;// ./src/array/join_unique_custom.js
+const joinUniqueCustom = ( { 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()
+];
 
-/***/ },
+;// ./src/array/split_batches.js
+const splitBatches = ( items, size ) => items.reduce( ( arrs, item ) =>
+  ( arrs[0] && arrs[0].length < size ) ?
+    [ [ ...arrs[0], item ] ].concat( arrs.slice( 1 ) ) :
+    [ [ item ] ].concat( arrs )
+, [] ).reverse();
 
-/***/ 9552
-(module, __unused_webpack_exports, __webpack_require__) {
+;// ./src/array/index.js
 
-const parseItem = __webpack_require__( 9179 );
 
-module.exports = results => results.map( item => parseItem( item ) );
 
 
-/***/ },
 
-/***/ 2847
-(module) {
 
-const parseInteger = value => {
-  const number = parseInt( value, 10 );
-  return number <= Number.MAX_SAFE_INTEGER && number >= Number.MIN_SAFE_INTEGER ? number : value;
-};
+;// external "@aws-sdk/client-athena"
+const client_athena_namespaceObject = require("@aws-sdk/client-athena");
+;// external "node:crypto"
+const external_node_crypto_namespaceObject = require("node:crypto");
+;// ./src/aws/core/cache_storage.js
 
-const parseFloatingPoint = value => {
-  if ( value.replace( /[^\d]/g, '' ).length > 16 ) {
-    return value;
-  }
-  const number = parseFloat( value, 10 );
-  return number <= Number.MAX_SAFE_INTEGER && number >= Number.MIN_SAFE_INTEGER ? number : value;
-};
 
-/* eslint-disable consistent-return */
-module.exports = value => {
-  if ( [ null, undefined ].includes( value ) ) {
-    return undefined;
-  }
+const cacheSym = Symbol.for( 'cache' );
 
-  if ( /^\d{4}-\d\d-\d\d((T| )\d\d:\d\d:\d\d(.\d{3})?(Z|\+\d\d:?\d\d)?)?$/.test( value ) ) {
-    return new Date( value );
-  }
+const hash = text => (0,external_node_crypto_namespaceObject.createHash)( 'md5' ).update( text ).digest( 'hex' );
 
-  // integer
-  if ( /^-?\d+$/.test( value ) ) {
-    return parseInteger( value );
-  }
+const propOpts = {
+  enumerable: false,
+  configurable: false,
+  writable: false
+};
 
-  // float
-  if ( /^-?(\d+\.|\.\d+|\d+\.\d+)$/.test( value ) ) {
-    return parseFloatingPoint( value );
-  }
+const CacheStorage = {
+  set: ( key, value ) => {
+    const keySym = Symbol.for( hash( key ) );
 
-  // boolean
-  if ( /^true$/.test( value ) ) {
-    return true;
-  }
+    if ( !global[cacheSym] ) {
+      Object.defineProperty( global, cacheSym, { ...propOpts, value: {} } );
+    }
 
-  if ( /^false$/.test( value ) ) {
-    return false;
+    Object.defineProperty( global[cacheSym], keySym, { ...propOpts, value } );
+  },
+  get: key => {
+    return global[cacheSym]?.[Symbol.for( hash( key ) )];
   }
-
-  return value;
 };
 
+;// ./src/aws/core/generic_client_provider.js
 
-/***/ },
 
-/***/ 2549
-(module) {
+const genericClientProvider = ( constructor, args = [] ) => {
+  const cacheKey = `${constructor.name}(${args.map( arg => JSON.stringify( arg ) ).join( ',' )})`;
+  return CacheStorage.get( cacheKey ) ?? ( () => {
+    const client = Reflect.construct( constructor, args );
+    CacheStorage.set( cacheKey, client );
+    return client;
+  } )();
+};
 
-module.exports = 500;
+;// ./src/aws/core/encoder.js
+const Encoder = {
+  encode: k => {
+    if ( k === null || k === undefined ) { return k; }
 
+    return Buffer.from( JSON.stringify( k ) ).toString( 'base64' );
+  },
+  decode: k => {
+    if ( k === null || k === undefined ) { return k; }
 
-/***/ },
+    const result = Buffer.from( k, 'base64' ).toString( 'utf8' );
+    try {
+      return JSON.parse( result );
+    } catch {
+      return result;
+    }
+  }
+};
 
-/***/ 3649
-(module, __unused_webpack_exports, __webpack_require__) {
+;// ./src/aws/athena/lib/start_query.js
 
-const { StartQueryCommand } = __webpack_require__( 7493 );
 
-module.exports = async ( { client, nativeArgs, range } ) => {
-  const startTime = range?.from ? Math.trunc( range.from / 1000 ) : nativeArgs.startTime;
-  const endTime = range?.to ? Math.trunc( range.to / 1000 ) : nativeArgs.endTime;
 
-  const { queryId } = await client.send( new StartQueryCommand( { ...nativeArgs, startTime, endTime } ) );
+/**
+ * args : https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/athena/command/StartQueryExecutionCommand/
+ * A ClientRequestToken is created automatically
+ */
+const startQuery = async ( { client, ...args } ) => {
+  const cmd = new client_athena_namespaceObject.StartQueryExecutionCommand( {
+    ClientRequestToken: (0,external_node_crypto_namespaceObject.randomBytes)( 16 ).toString( 'hex' ),
+    ...args
+  } );
+  const { QueryExecutionId: queryId } = await client.send( cmd );
   return queryId;
 };
 
+;// ./src/aws/athena/lib/parse_value.js
+/* eslint consistent-return: 0 */
+const removeNullValues = ( o, isArray = Array.isArray( o ) ) =>
+  Object.entries( o ).reduce( ( newObj, [ k, v ] ) => {
+    if ( v === null && !isArray ) { return newObj; }
+    return Object.assign( newObj, { [k]: v?.constructor === Object ? removeNullValues( v ) : v } );
+  }, isArray ? [] : {} );
 
-/***/ },
-
-/***/ 8593
-(module, __unused_webpack_exports, __webpack_require__) {
-
-const { BatchWriteCommand } = __webpack_require__( 3489 );
-const splitBatches = __webpack_require__( 4821 );
+const parseValue = ( v, type ) => {
+  if ( [ null, undefined ].includes( v ) ) {
+    return undefined;
+  }
+  if ( v === '' && type !== 'varchar' ) {
+    return undefined;
+  }
+  if ( type === 'boolean' ) {
+    return v === 'true';
+  }
+  if ( [ 'float', 'decimal', 'double' ].includes( type ) ) {
+    return parseFloat( v );
+  }
+  if ( [ 'tinyint', 'smallint', 'int', 'bigint' ].includes( type ) ) {
+    return parseInt( v );
+  }
+  if ( 'timestamp' === type ) {
+    return new Date( v ).getTime();
+  }
+  if ( [ 'row', 'array' ].includes( type ) ) {
+    const obj = v.replace( /(?<=(?:{|,\s)[\w-_]+)=/g, '@@DELIMITER@@' ) // replaces delimiter = with @@DELIMITER@@
+      .replace( /(?<={|,\s)([\w_-]+)(?=@@DELIMITER@@)/g, '"$1"' ) // wrap object keys
+      .replace( /(?<=@@DELIMITER@@)((?:(?!,\s|}|\[|{).)+)/g, '"$1"' ) // wrap object values
+      .replace( /(?<=\[|,\s)((?:(?!,\s|{|\]|").)+)/g, '"$1"' ) // wrap array values
+      .replace( /"null"/g, 'null' ) // convert "null" to null
+      .replace( /@@DELIMITER@@/g, ':' ); // replaces @@DELIMITER@@ for :
 
-const batchSize = 25;
+    return removeNullValues( JSON.parse( obj ) );
+  }
+  if ( 'json' === type ) {
+    return JSON.parse( v );
+  }
+  return v;
+};
 
-const getMapper = method => method === 'put' ? v => ( { PutRequest: { Item: v } } ) : v => ( { DeleteRequest: { Key: v } } );
+;// ./src/aws/athena/lib/parse_results.js
 
-const process = async ( { client, method, table, batches } ) => {
-  if ( batches.length === 0 ) { return true; }
 
-  const response = await client.send( new BatchWriteCommand( { RequestItems: { [table]: batches[0] } } ) );
+const parseResults = resultSet => {
+  const columns = resultSet.ResultSetMetadata.ColumnInfo
+    .map( col => ( { name: col.Name, type: col.Type } ) );
 
-  const unprocessed = response.UnprocessedItems?.[table];
-  return process( {
-    client, method, table,
-    batches: unprocessed ? splitBatches( batches.slice( 1 ).flat().concat( unprocessed ), batchSize ) : batches.slice( 1 )
+  // first data row contains the table field names
+  return resultSet.Rows.slice( 1 ).map( row => {
+    const values = row.Data.map( d => d.VarCharValue );
+    return columns.reduce( ( obj, p, i ) => Object.assign( obj, { [p.name]: parseValue( values[i], p.type ) } ), {} );
   } );
 };
 
-module.exports = async ( client, method, table, items ) =>
-  process( { client, method, table, batches: splitBatches( items.map( getMapper( method ) ), batchSize ) } );
+;// ./src/aws/athena/lib/polling_delay.js
+const pollingDelay = 500;
 
+;// ./src/aws/athena/lib/get_results.js
 
-/***/ },
 
-/***/ 2966
-(module, __unused_webpack_exports, __webpack_require__) {
 
-const { DynamoDBClient } = __webpack_require__( 4671 );
-const { DynamoDBDocumentClient } = __webpack_require__( 3489 );
-const cache = __webpack_require__( 4164 );
 
-module.exports = nativeArgs => {
-  const translateConfig = {
-    // Yes I copied those from the docs, read more here:
-    // https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/modules/_aws_sdk_lib_dynamodb.html#dynamodbdocumentclientresolvedconfig-1
-    marshallOptions: {
-      // Whether to automatically convert empty strings, blobs, and sets to `null`.
-      convertEmptyValues: true, // false, by default.
-      // Whether to remove undefined values while marshalling.
-      removeUndefinedValues: true, // false, by default.
-      // Whether to convert typeof object to map attribute.
-      convertClassInstanceToMap: true // false, by default.
-    },
-    unmarshallOptions: {
-      // Whether to return numbers as a string instead of converting them to native JavaScript numbers.
-      wrapNumbers: false // false, by default.
-    }
-  };
+const sleep = t => new Promise( r => setTimeout( () => r(), t ) );
 
-  const key = `Dynamodb(${JSON.stringify( nativeArgs )}).DocumentClient`;
-  return cache.get( key ) ?? ( () => {
-    const client = new DynamoDBClient( nativeArgs );
-    const docClient = DynamoDBDocumentClient.from( client, translateConfig );
+const getQueryResults = async ( { client, queryExecutionId, maxResults, token } ) => {
+  const { NextToken: nextToken, ResultSet } = await client.send( new client_athena_namespaceObject.GetQueryResultsCommand( {
+    ...{ QueryExecutionId: queryExecutionId },
+    ...( maxResults ? { MaxResults: maxResults } : {} ),
+    ...( token ? { NextToken: token } : {} )
+  } ) );
 
-    cache.set( key, docClient );
-    return docClient;
-  } )();
+  return { nextToken, items: parseResults( ResultSet ) };
 };
+const getQueryResultsRecursive = async ( { client, queryExecutionId, token } ) => {
+  const { nextToken, items } = await getQueryResults( { client, queryExecutionId, token } );
 
-
-/***/ },
-
-/***/ 1417
-(module, __unused_webpack_exports, __webpack_require__) {
-
-const { GetCommand } = __webpack_require__( 3489 );
-
-const parseArgs = args => {
-  // native args mode
-  if ( args[0] instanceof Object ) {
-    return args[0];
+  if ( nextToken ) {
+    return { items: items.concat( ( await getQueryResultsRecursive( { client, queryExecutionId, token: nextToken } ) ).items ) };
   }
-  // sugar mode
-  return {
-    TableName: args[0],
-    Key: args[1]
-  };
-};
-
-module.exports = async ( client, ...args ) => {
-  const response = await client.send( new GetCommand( parseArgs( args ) ) );
-  return response.Item;
+  return { items };
 };
 
+/**
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/athena/command/GetQueryResultsCommand/
+ * { client, recursive, queryExecutionId, maxResults, paginationToken }
+ */
+const getResults = async ( { client, recursive, queryExecutionId, token, maxResults } ) => {
+  const { QueryExecution: { Status: status } } = await client.send( new client_athena_namespaceObject.GetQueryExecutionCommand( { QueryExecutionId: queryExecutionId } ) );
 
-/***/ },
-
-/***/ 1505
-(module, __unused_webpack_exports, __webpack_require__) {
+  if ( status.State === 'FAILED' ) {
+    throw new Error( status.AthenaError?.ErrorMessage ?? status.StateChangeReason );
+  }
 
-const documentClientProvider = __webpack_require__( 2966 );
-const get = __webpack_require__( 1417 );
-const put = __webpack_require__( 9628 );
-const putBatch = __webpack_require__( 5847 );
-const query = __webpack_require__( 5265 );
-const remove = __webpack_require__( 6777 );
-const removeBatch = __webpack_require__( 3862 );
-const scan = __webpack_require__( 748 );
-const smartUpdate = __webpack_require__( 2266 );
-const transactWrite = __webpack_require__( 1659 );
-const update = __webpack_require__( 4144 );
-const createInstance = __webpack_require__( 5438 );
+  if ( status.State === 'SUCCEEDED' ) {
+    const fn = recursive ? getQueryResultsRecursive : getQueryResults;
+    return fn( { client, recursive, queryExecutionId, token, maxResults } );
+  }
 
-const methods = {
-  get,
-  put,
-  putBatch,
-  query,
-  remove,
-  removeBatch,
-  scan,
-  smartUpdate,
-  transactWrite,
-  update
+  // sleep an try again
+  await sleep( pollingDelay );
+  return getResults( { client, recursive, queryExecutionId, token, maxResults } );
 };
 
-module.exports = createInstance( documentClientProvider, methods );
-
+;// ./src/aws/athena/query.js
 
-/***/ },
 
-/***/ 9628
-(module, __unused_webpack_exports, __webpack_require__) {
 
-const { PutCommand } = __webpack_require__( 3489 );
 
-const parseArgs = args => {
-  // native args mode
-  if ( args[0] instanceof Object ) {
-    return args[0];
+const getQueryExecutionId = async ( { client, nativeArgs, recursive, paginationToken } ) => {
+  if ( !recursive && paginationToken ) {
+    const { queryExecutionId, token } = Encoder.decode( paginationToken );
+    return { queryExecutionId, token };
   }
-  // sugar mode
-  return {
-    TableName: args[0],
-    Item: args[1],
-    ReturnValues: 'NONE',
-    ReturnConsumedCapacity: 'NONE'
-  };
+
+  const queryExecutionId = await startQuery( { client, ...nativeArgs } );
+  return { queryExecutionId };
 };
 
 /**
- *
- * @param {*} client
- * @param  {...any} args The args. either one object with the native args or two string args, tableName and item.
- * @returns
+ * @class Result
+ * @type {Object}
+ * @property {Object[]} items Each query result row, parsed to a camelized js object
+ * @property {String} paginationToken The next pagination token, if recursive = false ans there are more results for the query
  */
-module.exports = async ( client, ...args ) => {
-  const nativeArgs = parseArgs( args );
-  const response = await client.send( new PutCommand( nativeArgs ) );
-  return response.Attributes ?? nativeArgs.Item;
-};
-
 
-/***/ },
-
-/***/ 5847
-(module, __unused_webpack_exports, __webpack_require__) {
+/**
+ * Executes an Athena Query
+ * @param {*} client The native client
+ * @param {Object} nativeArgs The native args to start the Athena Query
+ * @param {Object=} options Query configuration
+ * @param {Boolean=} [options.recursive=false] If to recursive query all results or to return a paginationToken after each page
+ * @param {String=} options.paginationToken The pagination token received in the previous call to resume the query (only used when recursive = false)
+ * @param {Number=} options.maxResults The maximum number of results per page (only when using pagination token)
+ * @returns {Result} The query result
+ */
+const query = async ( client, nativeArgs, options ) => {
+  const { recursive = false, paginationToken, maxResults } = options;
 
-const batchWrite = __webpack_require__( 8593 );
+  const { queryExecutionId, token } = await getQueryExecutionId( { client, nativeArgs, recursive, paginationToken } );
 
-module.exports = async ( client, ...args ) => batchWrite( client, 'put', ...args );
+  const { nextToken, items } = await getResults( { client, queryExecutionId, token, recursive, maxResults } );
+  return { paginationToken: nextToken ? Encoder.encode( { queryExecutionId, token: nextToken } ) : undefined, items };
+};
 
+;// ./src/aws/core/create_instance.js
+/**
+ * This is base object each AWS abstraction will provide
+ */
+const createInstance = ( providerFn, methods ) => {
+  // This creates the "instance",
+  // so calling the method as a function returns a copy of its client instantiated with the given args
+  // every method called from it will use this instance
+  const factory = args => {
+    const client = providerFn( args );
+    // return self, so it is possible use the native client
+    methods.getClient = () => client;
+    return Object.entries( methods ).reduce( ( o, [ k, v ] ) => Object.assign( o, { [k]: v.bind( null, client ) } ), { } );
+  };
 
-/***/ },
+  // This is the singleton part;
+  // First add the static method to the factory;
+  Object.entries( methods ).forEach( ( [ key, value ] ) => factory[key] = value );
 
-/***/ 5265
-(module, __unused_webpack_exports, __webpack_require__) {
+  // Then add the special method "getClient", so it is possible use the native client
+  factory.getClient = client => client;
 
-const select = __webpack_require__( 2157 );
+  // Finally makes the proxy which will allow each singleton method to use the client provider of the AWS service+
+  return new Proxy( factory, {
+    get( target, key ) {
+      const t = target[key];
+      return ( typeof t === 'function' ) ? t.bind( null, providerFn() ) : t;
+    }
+  } );
+};
 
-module.exports = async ( client, ...args ) => select( client, 'query', ...args );
+;// ./src/aws/athena/index.js
 
 
-/***/ },
 
-/***/ 6777
-(module, __unused_webpack_exports, __webpack_require__) {
 
-const { DeleteCommand } = __webpack_require__( 3489 );
 
-module.exports = async ( client, tableName, key ) => {
-  const { Attributes: item } = await client.send( new DeleteCommand( {
-    ReturnValues: 'ALL_OLD',
-    TableName: tableName,
-    Key: key
-  } ) );
-  return item;
+const methods = {
+  query: query
 };
 
+const athena = createInstance( genericClientProvider.bind( null, client_athena_namespaceObject.AthenaClient ), methods );
 
-/***/ },
+;// external "@aws-sdk/client-cloudwatch-logs"
+const client_cloudwatch_logs_namespaceObject = require("@aws-sdk/client-cloudwatch-logs");
+;// ./src/aws/cw_logs/query/start_query.js
 
-/***/ 3862
-(module, __unused_webpack_exports, __webpack_require__) {
 
-const batchWrite = __webpack_require__( 8593 );
-
-module.exports = async ( client, ...args ) => batchWrite( client, 'remove', ...args );
-
-
-/***/ },
-
-/***/ 748
-(module, __unused_webpack_exports, __webpack_require__) {
-
-const select = __webpack_require__( 2157 );
+const start_query_startQuery = async ( { client, nativeArgs, range } ) => {
+  const startTime = range?.from ? Math.trunc( range.from / 1000 ) : nativeArgs.startTime;
+  const endTime = range?.to ? Math.trunc( range.to / 1000 ) : nativeArgs.endTime;
 
-module.exports = async ( client, ...args ) => select( client, 'scan', ...args );
+  const { queryId } = await client.send( new client_cloudwatch_logs_namespaceObject.StartQueryCommand( { ...nativeArgs, startTime, endTime } ) );
+  return queryId;
+};
 
+;// ./src/aws/cw_logs/query/polling_delay.js
+const polling_delay_pollingDelay = 500;
 
-/***/ },
+;// ./src/utils/sleep.js
+const sleep_sleep = t => new Promise( r => setTimeout( r, t ) );
 
-/***/ 2157
-(module, __unused_webpack_exports, __webpack_require__) {
+;// ./src/aws/cw_logs/query/get_results.js
 
-const { encode, decode } = __webpack_require__( 5744 );
-const { ScanCommand, QueryCommand } = __webpack_require__( 3489 );
 
-const query = async ( { client, command, args, recursive, startKey, items = [], count = 0 } ) => {
-  const response = await client.send( new command( {
-    ...args,
-    ...( startKey && { ExclusiveStartKey: startKey } )
-  } ) );
 
-  const isCount = args.Select === 'COUNT';
-  const hasLimit = Number.isFinite( args.Limit );
 
-  const result = {
-    items: isCount ? null : items.concat( response.Items ),
-    count: count + response.Count,
-    startKey: response.LastEvaluatedKey
-  };
+const getResultsRecursive = async ( { client, command } ) => {
+  const { results, status } = await client.send( command );
 
-  if ( !recursive ) {
-    return { items: result.items, count: result.count, ...( result.startKey && { nextToken: encode( result.startKey ) } ) };
+  if ( [ 'Cancelled', 'Failed', 'Timeout', 'Unknown' ].includes( status ) ) {
+    throw new Error( `Query status is "${status}"` );
   }
 
-  if ( result.startKey && ( isCount || ( hasLimit && result.items.length < args.Limit ) || ( !isCount && !hasLimit ) ) ) {
-    return query( { client, command, args, recursive, ...result } );
+  if ( status === 'Complete' ) {
+    return results;
   }
 
-  if ( isCount ) {
-    return { items: null, count: result.count };
-  }
-  const trimmedItems = result.items.slice( 0, args.Limit );
-  return { items: trimmedItems, count: trimmedItems.length };
+  // Running, Scheduled
+  await sleep_sleep( polling_delay_pollingDelay );
+  return getResultsRecursive( { client, command } );
 };
 
-module.exports = async ( client, method, args, options = { recursive: false, paginationToken: null } ) => {
-  const command = method === 'scan' ? ScanCommand : QueryCommand;
-
-  return query( { client, command, args, recursive: options.recursive, startKey: decode( options.paginationToken ) } );
+const get_results_getResults = async ( { client, queryId } ) => {
+  const command = new client_cloudwatch_logs_namespaceObject.GetQueryResultsCommand( { queryId } );
+  return getResultsRecursive( { client, command } );
 };
 
+;// ./src/aws/cw_logs/query/parse_value.js
+const parseInteger = value => {
+  const number = parseInt( value, 10 );
+  return number <= Number.MAX_SAFE_INTEGER && number >= Number.MIN_SAFE_INTEGER ? number : value;
+};
 
-/***/ },
-
-/***/ 2266
-(module, __unused_webpack_exports, __webpack_require__) {
-
-const { UpdateCommand } = __webpack_require__( 3489 );
-
-module.exports = async ( client, tableName, key, keyValues ) => {
-  const { updates, removals, names, values } = Object.entries( keyValues ).reduce( ( args, [ k, value ], index ) => {
-    const isRemoval = value === undefined;
-
-    const attrs = k.split( '.' ).map( ( attr, i ) => {
-      const arrayPosition = attr.match( /\[(\d+)\]$/ )?.[1];
-      return {
-        key: `#${attr.replace( /\[\d+\]$|[^a-zA-Z0-9_]/g, '' )}${i}`,
-        name: attr.replace( /\[\d+\]$/g, '' ),
-        arrayPosition
-      };
-    } );
-    const fullPath = attrs.map( attr => attr.key + ( attr.arrayPosition ? `[${attr.arrayPosition}]` : '' ) ).join( '.' );
-    const valueId = `:v${index}`;
-    const expAttrNames = attrs.reduce( ( obj, attr ) =>
-      Object.assign( {}, obj, { [attr.key]: attr.name } )
-    , {} );
-
-    Object.assign( args.names, expAttrNames );
-
-    if ( isRemoval ) {
-      args.removals.push( fullPath );
-    } else {
-      args.updates.push( fullPath + ' = ' + valueId );
-      Object.assign( args.values, { [valueId]: value } );
-    }
+const parseFloatingPoint = value => {
+  if ( value.replace( /[^\d]/g, '' ).length > 16 ) {
+    return value;
+  }
+  const number = parseFloat( value, 10 );
+  return number <= Number.MAX_SAFE_INTEGER && number >= Number.MIN_SAFE_INTEGER ? number : value;
+};
 
-    return args;
-  }, { removals: [], updates: [], names: {}, values: {} } );
+/* eslint-disable consistent-return */
+const parse_value_parseValue = value => {
+  if ( [ null, undefined ].includes( value ) ) {
+    return undefined;
+  }
 
-  const conditionalExpressions = [];
-  for ( const k of Object.keys( key ) ) {
-    Object.assign( names, { [`#key_${k}`]: k } );
-    conditionalExpressions.push( `attribute_exists(#key_${k})` );
+  if ( /^\d{4}-\d\d-\d\d((T| )\d\d:\d\d:\d\d(.\d{3})?(Z|\+\d\d:?\d\d)?)?$/.test( value ) ) {
+    return new Date( value );
   }
 
-  if ( updates.length + removals.length === 0 ) { return null; }
+  // integer
+  if ( /^-?\d+$/.test( value ) ) {
+    return parseInteger( value );
+  }
 
-  const expressions = [];
-  if ( updates.length ) {
-    expressions.push( 'SET ' + updates.join( ', ' ) );
-  } if ( removals.length ) {
-    expressions.push( 'REMOVE ' + removals.join( ', ' ) );
+  // float
+  if ( /^-?(\d+\.|\.\d+|\d+\.\d+)$/.test( value ) ) {
+    return parseFloatingPoint( value );
   }
 
-  const statement = {
-    TableName: tableName,
-    ReturnValues: 'ALL_NEW',
-    Key: key,
-    ConditionExpression: conditionalExpressions.join( ' AND ' ),
-    UpdateExpression: expressions.join( ' ' ),
-    ExpressionAttributeNames: names
-  };
-  if ( Object.keys( values ).length > 0 ) {
-    statement.ExpressionAttributeValues = values;
+  // boolean
+  if ( /^true$/.test( value ) ) {
+    return true;
   }
 
-  try {
-    const response = await client.send( new UpdateCommand( statement ) );
-    return response.Attributes;
-  } catch ( error ) {
-    if ( error.constructor.name === 'ConditionalCheckFailedException' ) {
-      console.info( 'Fail to update a record that was not found.' );
-      return null;
-    }
-    throw error;
+  if ( /^false$/.test( value ) ) {
+    return false;
   }
+
+  return value;
 };
 
+;// ./src/aws/cw_logs/query/parse_item.js
 
-/***/ },
 
-/***/ 1659
-(module, __unused_webpack_exports, __webpack_require__) {
+const parseItem = item =>
+  item.reduce( ( row, { field, value } ) =>
+    Object.assign( row, {
+      [field]: parse_value_parseValue( value )
+    } ), {} );
 
-const { TransactWriteCommand } = __webpack_require__( 3489 );
+;// ./src/aws/cw_logs/query/parse_results.js
 
-module.exports = async ( client, items ) => {
-  const response = await client.send( new TransactWriteCommand( { TransactItems: items } ) );
-  return response;
-};
 
+const parse_results_parseResults = results => results.map( item => parseItem( item ) );
 
-/***/ },
+;// ./src/aws/cw_logs/query/index.js
 
-/***/ 4144
-(module, __unused_webpack_exports, __webpack_require__) {
 
-const { UpdateCommand } = __webpack_require__( 3489 );
 
-module.exports = async ( client, nativeArgs ) => {
-  const args = Object.assign( { ReturnValues: 'ALL_NEW' }, nativeArgs );
-  const response = await client.send( new UpdateCommand( args ) );
-  return response.Attributes;
-};
 
+/**
+ * @class Result
+ * @type {Object}
+ * @property {Object[]} items Each query result row, parsed to a camelized js object
+ * @property {Number} count Total number of results
+ */
 
-/***/ },
+/**
+ * Executes an Athena Query
+ * @param {*} client The native client
+ * @param {Object} nativeArgs The native args to start the Cloudwatch Query
+ * @param {Object=} options Extra options for this command
+ * @param {Object=} options.range Since the nativeArgs "startTime" and "endTime" are second based epochs, the "range" argument accepts milliseconds based epochs for convenience, thus overwriting the "nativeArgs"
+ * @param {Number} options.range.from The beginning of the time range to query, overwrites "startTime"
+ * @param {Number} options.range.to The end of the time range to query, overwrites "endTime"
+ * @returns {Result} The query result
+ */
+const query_query = async ( client, nativeArgs, { range = {} } = {} ) => {
+  const queryId = await start_query_startQuery( { client, nativeArgs, range } );
+  const results = await get_results_getResults( { client, queryId } );
+  const items = parse_results_parseResults( results );
+  return { items, count: items.length };
+};
 
-/***/ 4870
-(module, __unused_webpack_exports, __webpack_require__) {
+;// ./src/aws/cw_logs/index.js
 
-const athena = __webpack_require__( 228 );
-const cwLogs = __webpack_require__( 2710 );
-const dynamo = __webpack_require__( 1505 );
-const lambda = __webpack_require__( 3544 );
-const s3 = __webpack_require__( 645 );
-const ses = __webpack_require__( 5624 );
-const sns = __webpack_require__( 3099 );
-const sqs = __webpack_require__( 3340 );
-const ssm = __webpack_require__( 5888 );
-const timestreamQuery = __webpack_require__( 4225 );
-const timestreamWrite = __webpack_require__( 2538 );
 
-module.exports = {
-  athena,
-  cwLogs,
-  dynamo,
-  lambda,
-  s3,
-  ses,
-  sns,
-  sqs,
-  ssm,
-  timestreamQuery,
-  timestreamWrite
-};
 
 
-/***/ },
 
-/***/ 3544
-(module, __unused_webpack_exports, __webpack_require__) {
+const cw_logs_methods = {
+  query: query_query
+};
 
-const invoke = __webpack_require__( 5894 );
-const { LambdaClient } = __webpack_require__( 5892 );
-const clientProvider = __webpack_require__( 9039 );
-const createInstance = __webpack_require__( 5438 );
+const cwLogs = createInstance( genericClientProvider.bind( null, client_cloudwatch_logs_namespaceObject.CloudWatchLogsClient ), cw_logs_methods );
 
-const methods = {
-  invoke
-};
+;// external "@aws-sdk/client-dynamodb"
+const client_dynamodb_namespaceObject = require("@aws-sdk/client-dynamodb");
+;// external "@aws-sdk/lib-dynamodb"
+const lib_dynamodb_namespaceObject = require("@aws-sdk/lib-dynamodb");
+;// ./src/aws/dynamo/document_client_provider.js
 
-module.exports = createInstance( clientProvider.bind( null, LambdaClient ), methods );
 
 
-/***/ },
 
-/***/ 5894
-(module, __unused_webpack_exports, __webpack_require__) {
+const documentClientProvider = nativeArgs => {
+  const translateConfig = {
+    // Yes I copied those from the docs, read more here:
+    // https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/modules/_aws_sdk_lib_dynamodb.html#dynamodbdocumentclientresolvedconfig-1
+    marshallOptions: {
+      // Whether to automatically convert empty strings, blobs, and sets to `null`.
+      convertEmptyValues: true, // false, by default.
+      // Whether to remove undefined values while marshalling.
+      removeUndefinedValues: true, // false, by default.
+      // Whether to convert typeof object to map attribute.
+      convertClassInstanceToMap: true // false, by default.
+    },
+    unmarshallOptions: {
+      // Whether to return numbers as a string instead of converting them to native JavaScript numbers.
+      wrapNumbers: false // false, by default.
+    }
+  };
 
-const { InvokeCommand } = __webpack_require__( 5892 );
-const AWSLambdaError = __webpack_require__( 468 );
+  const key = `Dynamodb(${JSON.stringify( nativeArgs )}).DocumentClient`;
+  return CacheStorage.get( key ) ?? ( () => {
+    const client = new client_dynamodb_namespaceObject.DynamoDBClient( nativeArgs );
+    const docClient = lib_dynamodb_namespaceObject.DynamoDBDocumentClient.from( client, translateConfig );
 
-module.exports = async ( client, name, payload = {}, type = 'RequestResponse' ) => {
-  const response = await client.send( new InvokeCommand( {
-    FunctionName: name,
-    InvocationType: type,
-    Payload: Buffer.from( JSON.stringify( payload ) )
-  } ) );
+    CacheStorage.set( key, docClient );
+    return docClient;
+  } )();
+};
 
-  if ( response.FunctionError ) {
-    throw new AWSLambdaError( response );
-  }
+;// ./src/aws/dynamo/get.js
 
-  if ( type !== 'RequestResponse' ) { return true; }
 
-  try {
-    return JSON.parse( Buffer.from( response.Payload ).toString() );
-  } catch {
-    return response.Payload;
+const parseArgs = args => {
+  // native args mode
+  if ( args[0] instanceof Object ) {
+    return args[0];
   }
+  // sugar mode
+  return {
+    TableName: args[0],
+    Key: args[1]
+  };
 };
 
+const get = async ( client, ...args ) => {
+  const response = await client.send( new lib_dynamodb_namespaceObject.GetCommand( parseArgs( args ) ) );
+  return response.Item;
+};
 
-/***/ },
+;// ./src/aws/dynamo/put.js
 
-/***/ 468
-(module) {
 
-const parsePayload = payload => {
-  try {
-    return JSON.parse( Buffer.from( payload ).toString( 'utf-8' ) );
-  } catch {
-    return null;
+const put_parseArgs = args => {
+  // native args mode
+  if ( args[0] instanceof Object ) {
+    return args[0];
   }
+  // sugar mode
+  return {
+    TableName: args[0],
+    Item: args[1],
+    ReturnValues: 'NONE',
+    ReturnConsumedCapacity: 'NONE'
+  };
 };
 
-module.exports = class LambdaError extends Error {
-  constructor( response ) {
-    const { StatusCode: statusCode, Payload: rawPayload } = response;
-    const payload = parsePayload( rawPayload );
-    const lambdaErrorType = payload?.errorType ?? Error.name;
-    const lambdaErrorMessage = payload?.errorMessage;
-    if ( statusCode === 200 ) {
-      super( `Invoked function threw "[${lambdaErrorType}]${lambdaErrorMessage ? ' ' + lambdaErrorMessage : ''}"` );
-    } else {
-      super( 'Error invoking the function' );
-    }
-    this.statusCode = statusCode;
-    this.lambdaErrorType = lambdaErrorType;
-    this.lambdaErrorMessage = lambdaErrorMessage;
-  }
+/**
+ *
+ * @param {*} client
+ * @param  {...any} args The args. either one object with the native args or two string args, tableName and item.
+ * @returns
+ */
+const put = async ( client, ...args ) => {
+  const nativeArgs = put_parseArgs( args );
+  const response = await client.send( new lib_dynamodb_namespaceObject.PutCommand( nativeArgs ) );
+  return response.Attributes ?? nativeArgs.Item;
 };
 
+;// ./src/aws/dynamo/batch_write.js
+
 
-/***/ },
 
-/***/ 3936
-(module, __unused_webpack_exports, __webpack_require__) {
+const batchSize = 25;
 
-const { CopyObjectCommand } = __webpack_require__( 5725 );
+const getMapper = method => method === 'put' ? v => ( { PutRequest: { Item: v } } ) : v => ( { DeleteRequest: { Key: v } } );
 
-module.exports = async ( client, bucket, key, source, nativeArgs ) => {
-  const response = await client.send( new CopyObjectCommand( {
-    ...nativeArgs,
-    Bucket: bucket,
-    Key: key,
-    CopySource: source
-  } ) );
-  return response;
+const process = async ( { client, method, table, batches } ) => {
+  if ( batches.length === 0 ) { return true; }
+
+  const response = await client.send( new lib_dynamodb_namespaceObject.BatchWriteCommand( { RequestItems: { [table]: batches[0] } } ) );
+
+  const unprocessed = response.UnprocessedItems?.[table];
+  return process( {
+    client, method, table,
+    batches: unprocessed ? splitBatches( batches.slice( 1 ).flat().concat( unprocessed ), batchSize ) : batches.slice( 1 )
+  } );
 };
 
+const batchWrite = async ( client, method, table, items ) =>
+  process( { client, method, table, batches: splitBatches( items.map( getMapper( method ) ), batchSize ) } );
 
-/***/ },
+;// ./src/aws/dynamo/put_batch.js
 
-/***/ 345
-(module, __unused_webpack_exports, __webpack_require__) {
 
-const { GetObjectCommand } = __webpack_require__( 5725 );
+const putBatch = async ( client, ...args ) => batchWrite( client, 'put', ...args );
 
-module.exports = async ( client, bucket, key, nativeArgs ) => {
-  const response = await client.send( new GetObjectCommand( {
-    ...nativeArgs,
-    Bucket: bucket,
-    Key: key
+;// ./src/aws/dynamo/select.js
+
+
+
+const select_query = async ( { client, command, args, recursive, startKey, items = [], count = 0 } ) => {
+  const response = await client.send( new command( {
+    ...args,
+    ...( startKey && { ExclusiveStartKey: startKey } )
   } ) );
-  const stream = response.Body;
-  return Buffer.concat( await stream.toArray() ).toString( 'utf-8' );
-};
 
+  const isCount = args.Select === 'COUNT';
+  const hasLimit = Number.isFinite( args.Limit );
 
-/***/ },
+  const result = {
+    items: isCount ? null : items.concat( response.Items ),
+    count: count + response.Count,
+    startKey: response.LastEvaluatedKey
+  };
 
-/***/ 3758
-(module, __unused_webpack_exports, __webpack_require__) {
+  if ( !recursive ) {
+    return { items: result.items, count: result.count, ...( result.startKey && { nextToken: Encoder.encode( result.startKey ) } ) };
+  }
 
-const { getSignedUrl } = __webpack_require__( 4991 );
-const { GetObjectCommand } = __webpack_require__( 5725 );
+  if ( result.startKey && ( isCount || ( hasLimit && result.items.length < args.Limit ) || ( !isCount && !hasLimit ) ) ) {
+    return select_query( { client, command, args, recursive, ...result } );
+  }
 
-module.exports = async ( client, bucket, key, expiration ) => {
-  const getObjectCmd = new GetObjectCommand( { Bucket: bucket, Key: key } );
-  const url = await getSignedUrl( client, getObjectCmd, { expiresIn: expiration } );
-  return url;
+  if ( isCount ) {
+    return { items: null, count: result.count };
+  }
+  const trimmedItems = result.items.slice( 0, args.Limit );
+  return { items: trimmedItems, count: trimmedItems.length };
 };
 
+const select_select = async ( client, method, args, options = { recursive: false, paginationToken: null } ) => {
+  const command = method === 'scan' ? lib_dynamodb_namespaceObject.ScanCommand : lib_dynamodb_namespaceObject.QueryCommand;
 
-/***/ },
+  return select_query( { client, command, args, recursive: options.recursive, startKey: Encoder.decode( options.paginationToken ) } );
+};
 
-/***/ 279
-(module, __unused_webpack_exports, __webpack_require__) {
+;// ./src/aws/dynamo/query.js
 
-const { HeadObjectCommand } = __webpack_require__( 5725 );
 
-module.exports = async ( client, bucket, key ) =>
-  client.send( new HeadObjectCommand( { Bucket: bucket, Key: key } ) );
+const dynamo_query_query = async ( client, ...args ) => select_select( client, 'query', ...args );
 
+;// ./src/aws/dynamo/remove.js
 
-/***/ },
 
-/***/ 645
-(module, __unused_webpack_exports, __webpack_require__) {
+const remove = async ( client, tableName, key ) => {
+  const { Attributes: item } = await client.send( new lib_dynamodb_namespaceObject.DeleteCommand( {
+    ReturnValues: 'ALL_OLD',
+    TableName: tableName,
+    Key: key
+  } ) );
+  return item;
+};
 
-const copy = __webpack_require__( 3936 );
-const download = __webpack_require__( 345 );
-const getSignedUrl = __webpack_require__( 3758 );
-const head = __webpack_require__( 279 );
-const upload = __webpack_require__( 9704 );
-const { S3Client } = __webpack_require__( 5725 );
-const clientProvider = __webpack_require__( 9039 );
-const createInstance = __webpack_require__( 5438 );
+;// ./src/aws/dynamo/remove_batch.js
 
-const methods = {
-  copy,
-  download,
-  getSignedUrl,
-  head,
-  upload
-};
 
-module.exports = createInstance( clientProvider.bind( null, S3Client ), methods );
+const removeBatch = async ( client, ...args ) => batchWrite( client, 'remove', ...args );
 
+;// ./src/aws/dynamo/scan.js
 
-/***/ },
 
-/***/ 9704
-(module, __unused_webpack_exports, __webpack_require__) {
+const scan = async ( client, ...args ) => select_select( client, 'scan', ...args );
 
-const { PutObjectCommand } = __webpack_require__( 5725 );
+;// ./src/aws/dynamo/smart_update.js
 
-module.exports = ( client, bucket, key, body, nativeArgs ) =>
-  client.send( new PutObjectCommand( {
-    ...nativeArgs,
-    Bucket: bucket,
-    Key: key,
-    Body: typeof body === 'string' || Buffer.isBuffer( body ) ? body : JSON.stringify( body )
-  } ) );
 
+const smartUpdate = async ( client, tableName, key, keyValues ) => {
+  const { updates, removals, names, values } = Object.entries( keyValues ).reduce( ( args, [ k, value ], index ) => {
+    const isRemoval = value === undefined;
 
-/***/ },
+    const attrs = k.split( '.' ).map( ( attr, i ) => {
+      const arrayPosition = attr.match( /\[(\d+)\]$/ )?.[1];
+      return {
+        key: `#${attr.replace( /\[\d+\]$|[^a-zA-Z0-9_]/g, '' )}${i}`,
+        name: attr.replace( /\[\d+\]$/g, '' ),
+        arrayPosition
+      };
+    } );
+    const fullPath = attrs.map( attr => attr.key + ( attr.arrayPosition ? `[${attr.arrayPosition}]` : '' ) ).join( '.' );
+    const valueId = `:v${index}`;
+    const expAttrNames = attrs.reduce( ( obj, attr ) =>
+      Object.assign( {}, obj, { [attr.key]: attr.name } )
+    , {} );
 
-/***/ 809
-(module, __unused_webpack_exports, __webpack_require__) {
+    Object.assign( args.names, expAttrNames );
 
-const { DeleteSuppressedDestinationCommand } = __webpack_require__( 9556 );
+    if ( isRemoval ) {
+      args.removals.push( fullPath );
+    } else {
+      args.updates.push( fullPath + ' = ' + valueId );
+      Object.assign( args.values, { [valueId]: value } );
+    }
 
-module.exports = ( client, address ) => client.send( new DeleteSuppressedDestinationCommand( { EmailAddress: address } ) );
+    return args;
+  }, { removals: [], updates: [], names: {}, values: {} } );
 
+  const conditionalExpressions = [];
+  for ( const k of Object.keys( key ) ) {
+    Object.assign( names, { [`#key_${k}`]: k } );
+    conditionalExpressions.push( `attribute_exists(#key_${k})` );
+  }
 
-/***/ },
+  if ( updates.length + removals.length === 0 ) { return null; }
 
-/***/ 5624
-(module, __unused_webpack_exports, __webpack_require__) {
+  const expressions = [];
+  if ( updates.length ) {
+    expressions.push( 'SET ' + updates.join( ', ' ) );
+  } if ( removals.length ) {
+    expressions.push( 'REMOVE ' + removals.join( ', ' ) );
+  }
 
-const deleteSuppressedDestination = __webpack_require__( 809 );
-const sendEmail = __webpack_require__( 1783 );
-const { SESv2Client } = __webpack_require__( 9556 );
-const clientProvider = __webpack_require__( 9039 );
-const createInstance = __webpack_require__( 5438 );
+  const statement = {
+    TableName: tableName,
+    ReturnValues: 'ALL_NEW',
+    Key: key,
+    ConditionExpression: conditionalExpressions.join( ' AND ' ),
+    UpdateExpression: expressions.join( ' ' ),
+    ExpressionAttributeNames: names
+  };
+  if ( Object.keys( values ).length > 0 ) {
+    statement.ExpressionAttributeValues = values;
+  }
 
-const methods = {
-  deleteSuppressedDestination,
-  sendEmail
+  try {
+    const response = await client.send( new lib_dynamodb_namespaceObject.UpdateCommand( statement ) );
+    return response.Attributes;
+  } catch ( error ) {
+    if ( error.constructor.name === 'ConditionalCheckFailedException' ) {
+      console.info( 'Fail to update a record that was not found.' );
+      return null;
+    }
+    throw error;
+  }
 };
 
-module.exports = createInstance( clientProvider.bind( null, SESv2Client ), methods );
+;// ./src/aws/dynamo/transact_write.js
 
 
-/***/ },
+const transactWrite = async ( client, items ) => {
+  const response = await client.send( new lib_dynamodb_namespaceObject.TransactWriteCommand( { TransactItems: items } ) );
+  return response;
+};
 
-/***/ 1783
-(module, __unused_webpack_exports, __webpack_require__) {
+;// ./src/aws/dynamo/update.js
 
-const { SendEmailCommand } = __webpack_require__( 9556 );
 
-module.exports = ( client, { to = [], from, html, subject }, args ) =>
-  client.send( new SendEmailCommand( {
-    Destination: {
-      ToAddresses: to
-    },
-    Content: {
-      Simple: {
-        Body: {
-          Html: {
-            Data: html,
-            Charset: 'utf-8'
-          }
-        },
-        Subject: {
-          Data: subject
-        }
-      }
-    },
-    FromEmailAddress: from,
-    ...args
-  } ) );
+const update = async ( client, nativeArgs ) => {
+  const args = Object.assign( { ReturnValues: 'ALL_NEW' }, nativeArgs );
+  const response = await client.send( new lib_dynamodb_namespaceObject.UpdateCommand( args ) );
+  return response.Attributes;
+};
 
+;// ./src/aws/dynamo/index.js
 
-/***/ },
 
-/***/ 3099
-(module, __unused_webpack_exports, __webpack_require__) {
 
-const publish = __webpack_require__( 8080 );
-const publishBatch = __webpack_require__( 3531 );
-const { SNSClient } = __webpack_require__( 7651 );
-const clientProvider = __webpack_require__( 9039 );
-const createInstance = __webpack_require__( 5438 );
 
-const methods = {
-  publish,
-  publishBatch
-};
 
-module.exports = createInstance( clientProvider.bind( null, SNSClient ), methods );
 
 
-/***/ },
 
-/***/ 8080
-(module, __unused_webpack_exports, __webpack_require__) {
 
-const { PublishCommand } = __webpack_require__( 7651 );
 
-module.exports = async ( client, topic, message, args = {} ) => {
-  const response = await client.send( new PublishCommand( {
-    ...args,
-    TopicArn: topic,
-    Message: typeof message === 'string' ? message : JSON.stringify( message )
-  } ) );
-  return response.MessageId;
-};
 
 
-/***/ },
 
-/***/ 3531
-(module, __unused_webpack_exports, __webpack_require__) {
+const dynamo_methods = {
+  get: get,
+  put: put,
+  putBatch: putBatch,
+  query: dynamo_query_query,
+  remove: remove,
+  removeBatch: removeBatch,
+  scan: scan,
+  smartUpdate: smartUpdate,
+  transactWrite: transactWrite,
+  update: update
+};
 
-const { PublishBatchCommand } = __webpack_require__( 7651 );
+const dynamo = createInstance( documentClientProvider, dynamo_methods );
 
-module.exports = async ( client, topic, messages ) => {
-  if ( messages.length > 10 ) {
+;// external "@aws-sdk/client-lambda"
+const client_lambda_namespaceObject = require("@aws-sdk/client-lambda");
+;// ./src/aws/lambda/lambda_error.js
+const parsePayload = payload => {
+  try {
+    return JSON.parse( Buffer.from( payload ).toString( 'utf-8' ) );
+  } catch {
+    return null;
+  }
+};
+
+class LambdaError extends Error {
+  constructor( response ) {
+    const { StatusCode: statusCode, Payload: rawPayload } = response;
+    const payload = parsePayload( rawPayload );
+    const lambdaErrorType = payload?.errorType ?? Error.name;
+    const lambdaErrorMessage = payload?.errorMessage;
+    if ( statusCode === 200 ) {
+      super( `Invoked function threw "[${lambdaErrorType}]${lambdaErrorMessage ? ' ' + lambdaErrorMessage : ''}"` );
+    } else {
+      super( 'Error invoking the function' );
+    }
+    this.statusCode = statusCode;
+    this.lambdaErrorType = lambdaErrorType;
+    this.lambdaErrorMessage = lambdaErrorMessage;
+  }
+};
+
+;// ./src/aws/lambda/invoke.js
+
+
+
+const invoke = async ( client, name, payload = {}, type = 'RequestResponse' ) => {
+  const response = await client.send( new client_lambda_namespaceObject.InvokeCommand( {
+    FunctionName: name,
+    InvocationType: type,
+    Payload: Buffer.from( JSON.stringify( payload ) )
+  } ) );
+
+  if ( response.FunctionError ) {
+    throw new LambdaError( response );
+  }
+
+  if ( type !== 'RequestResponse' ) { return true; }
+
+  try {
+    return JSON.parse( Buffer.from( response.Payload ).toString() );
+  } catch {
+    return response.Payload;
+  }
+};
+
+;// ./src/aws/lambda/index.js
+
+
+
+
+
+const lambda_methods = {
+  invoke: invoke
+};
+
+const lambda = createInstance( genericClientProvider.bind( null, client_lambda_namespaceObject.LambdaClient ), lambda_methods );
+
+;// external "@aws-sdk/client-s3"
+const client_s3_namespaceObject = require("@aws-sdk/client-s3");
+;// ./src/aws/s3/copy.js
+
+
+const copy = async ( client, bucket, key, source, nativeArgs ) => {
+  const response = await client.send( new client_s3_namespaceObject.CopyObjectCommand( {
+    ...nativeArgs,
+    Bucket: bucket,
+    Key: key,
+    CopySource: source
+  } ) );
+  return response;
+};
+
+;// ./src/aws/s3/download.js
+
+
+const download = async ( client, bucket, key, nativeArgs ) => {
+  const response = await client.send( new client_s3_namespaceObject.GetObjectCommand( {
+    ...nativeArgs,
+    Bucket: bucket,
+    Key: key
+  } ) );
+  const stream = response.Body;
+  return Buffer.concat( await stream.toArray() ).toString( 'utf-8' );
+};
+
+;// external "@aws-sdk/s3-request-presigner"
+const s3_request_presigner_namespaceObject = require("@aws-sdk/s3-request-presigner");
+;// ./src/aws/s3/get_signed_url.js
+
+
+
+const getSignedUrl = async ( client, bucket, key, expiration ) => {
+  const getObjectCmd = new client_s3_namespaceObject.GetObjectCommand( { Bucket: bucket, Key: key } );
+  const url = await (0,s3_request_presigner_namespaceObject.getSignedUrl)( client, getObjectCmd, { expiresIn: expiration } );
+  return url;
+};
+
+;// ./src/aws/s3/head.js
+
+
+const head = async ( client, bucket, key ) =>
+  client.send( new client_s3_namespaceObject.HeadObjectCommand( { Bucket: bucket, Key: key } ) );
+
+;// ./src/aws/s3/upload.js
+
+
+const upload = ( client, bucket, key, body, nativeArgs ) =>
+  client.send( new client_s3_namespaceObject.PutObjectCommand( {
+    ...nativeArgs,
+    Bucket: bucket,
+    Key: key,
+    Body: typeof body === 'string' || Buffer.isBuffer( body ) ? body : JSON.stringify( body )
+  } ) );
+
+;// ./src/aws/s3/index.js
+
+
+
+
+
+
+
+
+
+const s3_methods = {
+  copy: copy,
+  download: download,
+  getSignedUrl: getSignedUrl,
+  head: head,
+  upload: upload
+};
+
+const s3 = createInstance( genericClientProvider.bind( null, client_s3_namespaceObject.S3Client ), s3_methods );
+
+;// external "@aws-sdk/client-sesv2"
+const client_sesv2_namespaceObject = require("@aws-sdk/client-sesv2");
+;// ./src/aws/ses/delete_suppressed_destination.js
+
+
+const deleteSuppressedDestination = ( client, address ) => client.send( new client_sesv2_namespaceObject.DeleteSuppressedDestinationCommand( { EmailAddress: address } ) );
+
+;// ./src/aws/ses/send_email.js
+
+
+const sendEmail = ( client, { to = [], from, html, subject }, args ) =>
+  client.send( new client_sesv2_namespaceObject.SendEmailCommand( {
+    Destination: {
+      ToAddresses: to
+    },
+    Content: {
+      Simple: {
+        Body: {
+          Html: {
+            Data: html,
+            Charset: 'utf-8'
+          }
+        },
+        Subject: {
+          Data: subject
+        }
+      }
+    },
+    FromEmailAddress: from,
+    ...args
+  } ) );
+
+;// ./src/aws/ses/index.js
+
+
+
+
+
+
+const ses_methods = {
+  deleteSuppressedDestination: deleteSuppressedDestination,
+  sendEmail: sendEmail
+};
+
+const ses = createInstance( genericClientProvider.bind( null, client_sesv2_namespaceObject.SESv2Client ), ses_methods );
+
+;// external "@aws-sdk/client-sns"
+const client_sns_namespaceObject = require("@aws-sdk/client-sns");
+;// ./src/aws/sns/publish.js
+
+
+const publish = async ( client, topic, message, args = {} ) => {
+  const response = await client.send( new client_sns_namespaceObject.PublishCommand( {
+    ...args,
+    TopicArn: topic,
+    Message: typeof message === 'string' ? message : JSON.stringify( message )
+  } ) );
+  return response.MessageId;
+};
+
+;// ./src/aws/sns/publish_batch.js
+
+
+const publishBatch = async ( client, topic, messages ) => {
+  if ( messages.length > 10 ) {
     throw new Error( 'SNS.publishBatch only accepts up to 10 messages.' );
   }
-  const response = await client.send( new PublishBatchCommand( {
+  const response = await client.send( new client_sns_namespaceObject.PublishBatchCommand( {
     TopicArn: topic,
     PublishBatchRequestEntries: messages.map( ( { body, id = null, nativeArgs }, index ) => ( {
       Id: id ?? `message_${index}`,
@@ -1254,65 +1641,45 @@ module.exports = async ( client, topic, messages ) => {
   return response;
 };
 
+;// ./src/aws/sns/index.js
 
-/***/ },
-
-/***/ 5637
-(module, __unused_webpack_exports, __webpack_require__) {
-
-const { DeleteMessageCommand } = __webpack_require__( 1976 );
-
-module.exports = async ( client, queue, receiptHandle ) =>
-  client.send( new DeleteMessageCommand( {
-    QueueUrl: queue,
-    ReceiptHandle: receiptHandle
-  } ) );
 
 
-/***/ },
 
-/***/ 3340
-(module, __unused_webpack_exports, __webpack_require__) {
 
-const deleteMessage = __webpack_require__( 5637 );
-const sendMessage = __webpack_require__( 6720 );
-const sendMessageBatch = __webpack_require__( 3131 );
-const { SQSClient } = __webpack_require__( 1976 );
-const clientProvider = __webpack_require__( 9039 );
-const createInstance = __webpack_require__( 5438 );
 
-const methods = {
-  deleteMessage,
-  sendMessage,
-  sendMessageBatch
+const sns_methods = {
+  publish: publish,
+  publishBatch: publishBatch
 };
 
-module.exports = createInstance( clientProvider.bind( null, SQSClient ), methods );
+const sns = createInstance( genericClientProvider.bind( null, client_sns_namespaceObject.SNSClient ), sns_methods );
 
+;// external "@aws-sdk/client-sqs"
+const client_sqs_namespaceObject = require("@aws-sdk/client-sqs");
+;// ./src/aws/sqs/delete_message.js
 
-/***/ },
 
-/***/ 8175
-(module) {
+const deleteMessage = async ( client, queue, receiptHandle ) =>
+  client.send( new client_sqs_namespaceObject.DeleteMessageCommand( {
+    QueueUrl: queue,
+    ReceiptHandle: receiptHandle
+  } ) );
 
+;// ./src/aws/sqs/sanitize_sqs.js
 /*
 References:
 - https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html
 - https://stackoverflow.com/questions/58809098/remove-invalid-characters-from-message-sent-to-aws-amazon-sqs
 */
-module.exports = v => v?.replace( /[^\u0009\u000A\u000D\u0020-\uD7FF\uE000-\uFFFD\u{10000}-\u{10FFFF}]/ug, '' ) // eslint-disable-line
-
+const sanitizeSqs = v => v?.replace( /[^\u0009\u000A\u000D\u0020-\uD7FF\uE000-\uFFFD\u{10000}-\u{10FFFF}]/ug, '' ) // eslint-disable-line
 
-/***/ },
+;// ./src/aws/sqs/send_message.js
 
-/***/ 6720
-(module, __unused_webpack_exports, __webpack_require__) {
 
-const { SendMessageCommand } = __webpack_require__( 1976 );
-const sanitizeSqs = __webpack_require__( 8175 );
 
-module.exports = async ( client, queue, body, args ) => {
-  const response = await client.send( new SendMessageCommand( {
+const sendMessage = async ( client, queue, body, args ) => {
+  const response = await client.send( new client_sqs_namespaceObject.SendMessageCommand( {
     ...args,
     MessageBody: sanitizeSqs( typeof body === 'string' ? body : JSON.stringify( body ) ),
     QueueUrl: queue
@@ -1320,20 +1687,15 @@ module.exports = async ( client, queue, body, args ) => {
   return response.MessageId;
 };
 
+;// ./src/aws/sqs/send_message_batch.js
 
-/***/ },
 
-/***/ 3131
-(module, __unused_webpack_exports, __webpack_require__) {
 
-const { SendMessageBatchCommand } = __webpack_require__( 1976 );
-const sanitizeSqs = __webpack_require__( 8175 );
-
-module.exports = async ( client, queue, messages ) => {
+const sendMessageBatch = async ( client, queue, messages ) => {
   if ( messages.length > 10 ) {
     throw new Error( 'SQS.sendMessageBatch only accepts up to 10 messages.' );
   }
-  const response = await client.send( new SendMessageBatchCommand( {
+  const response = await client.send( new client_sqs_namespaceObject.SendMessageBatchCommand( {
     QueueUrl: queue,
     Entries: messages.map( ( { body, id = null, nativeArgs }, index ) => ( {
       Id: id ?? `message_${index}`,
@@ -1350,24 +1712,37 @@ module.exports = async ( client, queue, messages ) => {
   return response;
 };
 
+;// ./src/aws/sqs/index.js
+
+
+
+
+
+
+
+const sqs_methods = {
+  deleteMessage: deleteMessage,
+  sendMessage: sendMessage,
+  sendMessageBatch: sendMessageBatch
+};
+
+const sqs = createInstance( genericClientProvider.bind( null, client_sqs_namespaceObject.SQSClient ), sqs_methods );
 
-/***/ },
+;// external "@aws-sdk/client-ssm"
+const client_ssm_namespaceObject = require("@aws-sdk/client-ssm");
+;// ./src/aws/ssm/get.js
 
-/***/ 8660
-(module, __unused_webpack_exports, __webpack_require__) {
 
-const cacheStorage = __webpack_require__( 4164 );
-const { GetParameterCommand } = __webpack_require__( 4348 );
 
-module.exports = async ( client, name ) => {
+const get_get = async ( client, name ) => {
   const key = `SSM_${name}`;
-  const cacheValue = cacheStorage.get( key );
+  const cacheValue = CacheStorage.get( key );
   if ( cacheValue ) { return cacheValue; }
 
   try {
-    const response = await client.send( new GetParameterCommand( { Name: name, WithDecryption: true } ) );
+    const response = await client.send( new client_ssm_namespaceObject.GetParameterCommand( { Name: name, WithDecryption: true } ) );
     const value = response?.Parameter?.Value;
-    cacheStorage.set( key, value );
+    CacheStorage.set( key, value );
     return value;
   } catch ( error ) {
     if ( error.constructor.name === 'ParameterNotFound' ) {
@@ -1377,51 +1752,23 @@ module.exports = async ( client, name ) => {
   }
 };
 
+;// ./src/aws/ssm/index.js
 
-/***/ },
-
-/***/ 5888
-(module, __unused_webpack_exports, __webpack_require__) {
-
-const get = __webpack_require__( 8660 );
-const { SSMClient } = __webpack_require__( 4348 );
-const clientProvider = __webpack_require__( 9039 );
-const createInstance = __webpack_require__( 5438 );
-
-const methods = { get };
-
-module.exports = createInstance( clientProvider.bind( null, SSMClient ), methods );
-
-
-/***/ },
-
-/***/ 4225
-(module, __unused_webpack_exports, __webpack_require__) {
-
-const query = __webpack_require__( 6030 );
-const { TimestreamQueryClient } = __webpack_require__( 1671 );
-const { Agent } = __webpack_require__( 5692 );
-const clientProvider = __webpack_require__( 9039 );
-const createInstance = __webpack_require__( 5438 );
 
-const methods = { query };
-const defaultArgs = {
-  maxRetries: 10,
-  httpOptions: { timeout: 60000, agent: new Agent( { maxSockets: 5000 } ) }
-};
 
-module.exports = createInstance( args => clientProvider( TimestreamQueryClient, [ Object.assign( {}, defaultArgs, args ) ] ), methods );
 
 
-/***/ },
+const ssm_methods = { get: get_get };
 
-/***/ 7261
-(module, __unused_webpack_exports, __webpack_require__) {
+const ssm = createInstance( genericClientProvider.bind( null, client_ssm_namespaceObject.SSMClient ), ssm_methods );
 
+;// external "@aws-sdk/client-timestream-query"
+const client_timestream_query_namespaceObject = require("@aws-sdk/client-timestream-query");
+;// ./src/aws/timestream_query/parse_items.js
 // https://docs.aws.amazon.com/timestream/latest/developerguide/API_query_Type.html
 // https://docs.aws.amazon.com/timestream/latest/developerguide/supported-data-types.html
 
-const { ScalarType } = __webpack_require__( 1671 );
+
 
 const parseBigInt = value => {
   const asInt = parseInt( value, 10 );
@@ -1430,29 +1777,29 @@ const parseBigInt = value => {
 
 const parseScalarValue = ( type, value ) => {
   switch ( type ) {
-    case ScalarType.BOOLEAN:
+    case client_timestream_query_namespaceObject.ScalarType.BOOLEAN:
       return value === 'true';
-    case ScalarType.DOUBLE:
+    case client_timestream_query_namespaceObject.ScalarType.DOUBLE:
       return parseFloat( value );
-    case ScalarType.TIMESTAMP:
+    case client_timestream_query_namespaceObject.ScalarType.TIMESTAMP:
       return new Date( `${value.replace( ' ', 'T' )}Z` );
-    case ScalarType.INTEGER:
+    case client_timestream_query_namespaceObject.ScalarType.INTEGER:
       return parseInt( value, 10 );
-    case ScalarType.UNKNOWN: // is NULL
+    case client_timestream_query_namespaceObject.ScalarType.UNKNOWN: // is NULL
       return null;
-    case ScalarType.BIGINT:
+    case client_timestream_query_namespaceObject.ScalarType.BIGINT:
       return parseBigInt( value );
-    case ScalarType.VARCHAR:
-    case ScalarType.DATE:
-    case ScalarType.TIME:
-    case ScalarType.INTERVAL_DAY_TO_SECOND:
-    case ScalarType.INTERVAL_YEAR_TO_MONTH:
+    case client_timestream_query_namespaceObject.ScalarType.VARCHAR:
+    case client_timestream_query_namespaceObject.ScalarType.DATE:
+    case client_timestream_query_namespaceObject.ScalarType.TIME:
+    case client_timestream_query_namespaceObject.ScalarType.INTERVAL_DAY_TO_SECOND:
+    case client_timestream_query_namespaceObject.ScalarType.INTERVAL_YEAR_TO_MONTH:
     default:
       return value;
   }
 };
 
-const parseValue = ( typeInfo, datum ) => {
+const parse_items_parseValue = ( typeInfo, datum ) => {
   // value might be null
   if ( datum['NullValue'] === true ) {
     return null;
@@ -1462,13 +1809,13 @@ const parseValue = ( typeInfo, datum ) => {
   if ( Object.hasOwn( typeInfo, 'TimeSeriesMeasureValueColumnInfo' ) ) {
     return datum.TimeSeriesValue.map( v => ( {
       time: new Date( v.Time ),
-      value: parseValue( typeInfo.TimeSeriesMeasureValueColumnInfo.Type, v.Value )
+      value: parse_items_parseValue( typeInfo.TimeSeriesMeasureValueColumnInfo.Type, v.Value )
     } ) );
   }
 
   // maybe an array
   if ( Object.hasOwn( typeInfo, 'ArrayColumnInfo' ) ) {
-    return datum.ArrayValue.map( v => parseValue( typeInfo.ArrayColumnInfo.Type, v ) );
+    return datum.ArrayValue.map( v => parse_items_parseValue( typeInfo.ArrayColumnInfo.Type, v ) );
   }
 
   // or even a row
@@ -1476,7 +1823,7 @@ const parseValue = ( typeInfo, datum ) => {
     const rowColumnInfo = typeInfo.RowColumnInfo;
     return datum.RowValue.Data.reduce( ( object, value, index ) => {
       const { Name: name, Type: typeInfo } = rowColumnInfo[index];
-      return Object.assign( object, { [name]: parseValue( typeInfo, value ) } );
+      return Object.assign( object, { [name]: parse_items_parseValue( typeInfo, value ) } );
     }, {} );
   }
 
@@ -1484,75 +1831,66 @@ const parseValue = ( typeInfo, datum ) => {
   return parseScalarValue( typeInfo.ScalarType, datum['ScalarValue'] );
 };
 
-module.exports = response => {
+const parseItems = response => {
   const { ColumnInfo: colInfo, Rows: rows } = response;
   return rows.map( row =>
     row.Data.reduce( ( entry, value, index ) => {
       const { Name: name, Type: typeInfo } = colInfo[index];
-      return Object.assign( entry, { [name]: parseValue( typeInfo, value ) } );
+      return Object.assign( entry, { [name]: parse_items_parseValue( typeInfo, value ) } );
     }, { } )
   );
 };
 
+;// ./src/aws/timestream_query/query.js
 
-/***/ },
 
-/***/ 6030
-(module, __unused_webpack_exports, __webpack_require__) {
 
-const { QueryCommand } = __webpack_require__( 1671 );
-const { camelize } = __webpack_require__( 5762 );
-const parseItems = __webpack_require__( 7261 );
 
-const query = async ( client, queryString, { prevItems = [], recursive, paginationToken, maxRows, rawResponse } ) => {
-  const response = await client.send( new QueryCommand( { QueryString: queryString, NextToken: paginationToken, MaxRows: maxRows } ) );
+const sendQuery = async ( client, queryString, { prevItems = [], recursive, paginationToken, maxRows, rawResponse } ) => {
+  const response = await client.send( new client_timestream_query_namespaceObject.QueryCommand( { QueryString: queryString, NextToken: paginationToken, MaxRows: maxRows } ) );
   if ( !recursive && rawResponse ) {
     return response;
   }
 
   const nextToken = response.NextToken;
   if ( nextToken && recursive ) {
-    return query( client, queryString, { prevItems: parseItems( response ), recursive, paginationToken: nextToken, maxRows } );
+    return sendQuery( client, queryString, { prevItems: parseItems( response ), recursive, paginationToken: nextToken, maxRows } );
   }
 
   const items = prevItems.concat( parseItems( response ) );
-  return { nextToken, count: items.length, items, queryStatus: camelize( response.QueryStatus ) };
+  return { nextToken, count: items.length, items, queryStatus: camelize_camelize( response.QueryStatus ) };
 };
 
-module.exports = async ( client, queryString, { recursive = false, paginationToken = undefined, maxRows = undefined, rawResponse = false } = {} ) =>
-  query( client, queryString, { recursive, paginationToken, maxRows, rawResponse } );
+const timestream_query_query_query =
+  async ( client, queryString, { recursive = false, paginationToken = undefined, maxRows = undefined, rawResponse = false } = {} ) =>
+    sendQuery( client, queryString, { recursive, paginationToken, maxRows, rawResponse } );
 
+;// external "https"
+const external_https_namespaceObject = require("https");
+;// ./src/aws/timestream_query/index.js
 
-/***/ },
 
-/***/ 2538
-(module, __unused_webpack_exports, __webpack_require__) {
 
-const writeRecords = __webpack_require__( 8936 );
-const { TimestreamWriteClient } = __webpack_require__( 8248 );
-const { Agent } = __webpack_require__( 5692 );
-const clientProvider = __webpack_require__( 9039 );
-const createInstance = __webpack_require__( 5438 );
 
-const methods = { writeRecords };
+
+
+const timestream_query_methods = { query: timestream_query_query_query };
 const defaultArgs = {
   maxRetries: 10,
-  httpOptions: { timeout: 60000, agent: new Agent( { maxSockets: 5000 } ) }
+  httpOptions: { timeout: 60000, agent: new external_https_namespaceObject.Agent( { maxSockets: 5000 } ) }
 };
 
-module.exports = createInstance( args => clientProvider( TimestreamWriteClient, [ Object.assign( {}, defaultArgs, args ) ] ), methods );
-
-
-/***/ },
+const timestreamQuery =
+  createInstance( args => genericClientProvider( client_timestream_query_namespaceObject.TimestreamQueryClient, [ Object.assign( {}, defaultArgs, args ) ] ), timestream_query_methods );
 
-/***/ 8936
-(module, __unused_webpack_exports, __webpack_require__) {
+;// external "@aws-sdk/client-timestream-write"
+const client_timestream_write_namespaceObject = require("@aws-sdk/client-timestream-write");
+;// ./src/aws/timestream_write/write_records.js
 
-const { WriteRecordsCommand } = __webpack_require__( 8248 );
 
-module.exports = async ( client, { database, table, records, ignoreRejections = false } ) => {
+const writeRecords = async ( client, { database, table, records, ignoreRejections = false } ) => {
   try {
-    const response = await client.send( new WriteRecordsCommand( {
+    const response = await client.send( new client_timestream_write_namespaceObject.WriteRecordsCommand( {
       DatabaseName: database,
       TableName: table,
       Records: records
@@ -1561,651 +1899,79 @@ module.exports = async ( client, { database, table, records, ignoreRejections =
   } catch ( error ) {
     if ( ignoreRejections && error.name === 'RejectedRecordsException' ) {
       return { rejectedRecords: error.RejectedRecords };
-    }
-    throw error;
-  }
-};
-
-
-/***/ },
-
-/***/ 5263
-(module) {
-
-module.exports = t => t * 24 * 60 * 60 * 1000;
-
-
-/***/ },
-
-/***/ 6961
-(module) {
-
-module.exports = t => t * 60 * 60 * 1000;
-
-
-/***/ },
-
-/***/ 3830
-(module, __unused_webpack_exports, __webpack_require__) {
-
-const days = __webpack_require__( 5263 );
-const hours = __webpack_require__( 6961 );
-const minutes = __webpack_require__( 6635 );
-const months = __webpack_require__( 8119 );
-const msToS = __webpack_require__( 7416 );
-const round = __webpack_require__( 3990 );
-const seconds = __webpack_require__( 7051 );
-
-module.exports = {
-  days,
-  hours,
-  minutes,
-  months,
-  msToS,
-  round,
-  seconds
-};
-
-
-/***/ },
-
-/***/ 6635
-(module) {
-
-module.exports = t => t * 60 * 1000;
-
-
-/***/ },
-
-/***/ 8119
-(module) {
-
-module.exports = t => t * 30 * 24 * 60 * 60 * 1000;
-
-
-/***/ },
-
-/***/ 7416
-(module) {
-
-module.exports = v => Math.ceil( v / 1000 );
-
-
-/***/ },
-
-/***/ 3990
-(module) {
-
-module.exports = ( time, interval ) => time - ( time % interval );
-
-
-/***/ },
-
-/***/ 7051
-(module) {
-
-module.exports = t => t * 1000;
-
-
-/***/ },
-
-/***/ 44
-(module, __unused_webpack_exports, __webpack_require__) {
-
-const { LambdaApi } = __webpack_require__( 2705 );
-const array = __webpack_require__( 8278 );
-const aws = __webpack_require__( 4870 );
-const epoch = __webpack_require__( 3830 );
-const math = __webpack_require__( 943 );
-const object = __webpack_require__( 5762 );
-const redis = __webpack_require__( 4528 );
-const string = __webpack_require__( 268 );
-const utils = __webpack_require__( 6878 );
-
-module.exports = {
-  array,
-  aws,
-  epoch,
-  LambdaApi,
-  math,
-  object,
-  redis,
-  string,
-  utils
-};
-
-
-/***/ },
-
-/***/ 3119
-(module, __unused_webpack_exports, __webpack_require__) {
-
-const { snakelize, camelize } = __webpack_require__( 5762 );
-const charset = 'utf-8';
-
-const transformFns = {
-  camelcase: camelize,
-  snakecase: snakelize
-};
-
-module.exports = class ApiResponse {
-  #headers = null;
-  #statusCode = null;
-  #transformFn = false;
-  #isBase64Encoded = 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 = {}, isBase64Encoded = false ) {
-    this.#statusCode = statusCode;
-    this.#isBase64Encoded = isBase64Encoded;
-    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 {
-      isBase64Encoded: this.#isBase64Encoded,
-      statusCode: this.#statusCode,
-      body: this.#body,
-      headers: this.#headers
-    };
-  }
-};
-
-
-/***/ },
-
-/***/ 329
-(module, __unused_webpack_exports, __webpack_require__) {
-
-const { camelize, snakelize } = __webpack_require__( 5762 );
-
-const transformFns = {
-  camelcase: camelize,
-  snakecase: snakelize
-};
-
-const parseJson = content => {
-  try {
-    return JSON.parse( content );
-  } catch {
-    return content;
-  }
-};
-
-module.exports = class Event {
-  #transformFn;
-  authorizer;
-  body;
-  rawBody;
-  headers;
-  method;
-  params;
-  path;
-  queryString;
-  route;
-
-  context = {};
-
-  constructor( { transform = false } = {} ) {
-    this.#transformFn = transformFns[transform] ?? ( v => v );
-  }
-
-  parseFromAwsEvent( awsEvent ) {
-    this[`parseFromAwsEventV${awsEvent.version === '2.0' ? 2 : 1}`]( awsEvent );
-  }
-
-  parseFromAwsEventV1( awsEvent ) {
-    const {
-      body,
-      path,
-      resource,
-      httpMethod,
-      requestContext,
-      pathParameters,
-      headers,
-      multiValueHeaders,
-      queryStringParameters,
-      multiValueQueryStringParameters: multiValueQueryString,
-      isBase64Encoded
-    } = 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.rawBody = body ?? null;
-    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;
-    this.isBase64Encoded = isBase64Encoded ?? false;
-  }
-
-  parseFromAwsEventV2( awsEvent ) {
-    const {
-      body,
-      routeKey,
-      requestContext,
-      pathParameters,
-      headers,
-      queryStringParameters,
-      isBase64Encoded
-    } = awsEvent;
-
-    const { http: { method, path } } = requestContext;
-
-    this.authorizer = requestContext?.authorizer;
-    this.rawBody = body ?? null;
-    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( /\/$/, '' );
-    this.isBase64Encoded = isBase64Encoded ?? false;
-  }
-};
-
-
-/***/ },
-
-/***/ 3109
-(module, __unused_webpack_exports, __webpack_require__) {
-
-const validators = __webpack_require__( 8994 );
-
-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__( 8994 );
-
-module.exports = class Hook {
-  #fn;
-
-  constructor( { fn } ) {
-    validators.function( fn );
-    this.#fn = fn;
-  }
-
-  get fn() { return this.#fn; }
-};
-
-
-/***/ },
-
-/***/ 2705
-(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__( 8994 );
-const ApiResponse = __webpack_require__( 3119 );
-const Event = __webpack_require__( 329 );
-const Handler = __webpack_require__( 3109 );
-const Hook = __webpack_require__( 798 );
-const UserResponse = __webpack_require__( 8282 );
-const Text = __webpack_require__( 9760 );
-
-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 } );
+    }
+    throw error;
   }
+};
 
-  /**
-   * 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 );
+;// ./src/aws/timestream_write/index.js
 
-    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();
-    }
-  }
+const timestream_write_methods = { writeRecords: writeRecords };
+const timestream_write_defaultArgs = {
+  maxRetries: 10,
+  httpOptions: { timeout: 60000, agent: new external_https_namespaceObject.Agent( { maxSockets: 5000 } ) }
 };
 
+const timestreamWrite =
+  createInstance( args => genericClientProvider( client_timestream_write_namespaceObject.TimestreamWriteClient, [ Object.assign( {}, timestream_write_defaultArgs, args ) ] ), timestream_write_methods );
 
-/***/ },
+;// ./src/aws/index.js
 
-/***/ 3446
-(module) {
 
-module.exports = class LambdaApiValidationError extends Error {};
 
 
-/***/ },
 
-/***/ 9760
-(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)'
-};
 
 
-/***/ },
 
-/***/ 8282
-(module, __unused_webpack_exports, __webpack_require__) {
 
-const validators = __webpack_require__( 8994 );
-const LambdaApiValidationError = __webpack_require__( 3446 );
-const Text = __webpack_require__( 9760 );
 
-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;
+;// ./src/epoch/days.js
+const days = t => t * 24 * 60 * 60 * 1000;
 
-    } else if ( args.statusCode ) {
-      validators.statusCode( args.statusCode );
-      this.values = [ args.statusCode, args.body, args.headers, args.isBase64Encoded ];
+;// ./src/epoch/hours.js
+const hours = t => t * 60 * 60 * 1000;
 
-    } else if ( [ undefined, null ].includes( args ) ) {
-      this.values = [ 200 ];
-    } else {
-      throw new LambdaApiValidationError( Text.INVALID_USER_RESPONSE );
-    }
-  }
-};
+;// ./src/epoch/minutes.js
+const minutes = t => t * 60 * 1000;
 
+;// ./src/epoch/months.js
+const months = t => t * 30 * 24 * 60 * 60 * 1000;
 
-/***/ },
+;// ./src/epoch/ms_to_s.js
+const msToS = v => Math.ceil( v / 1000 );
 
-/***/ 8994
-(module, __unused_webpack_exports, __webpack_require__) {
+;// ./src/epoch/round.js
+const round = ( time, interval ) => time - ( time % interval );
 
-const Text = __webpack_require__( 9760 );
-const LambdaApiValidationError = __webpack_require__( 3446 );
+;// ./src/epoch/seconds.js
+const seconds = t => t * 1000;
 
-const evaluate = ( condition, errorMessage ) => {
-  if ( !condition ) { throw new LambdaApiValidationError( errorMessage ); }
-};
+;// ./src/epoch/index.js
 
-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 )
-};
 
 
-/***/ },
 
-/***/ 4124
-(module) {
 
-module.exports = values => values.reduce( ( sum, value ) => sum + value, 0 ) / values.length;
 
 
-/***/ },
 
-/***/ 3187
-(module) {
 
-module.exports = values => {
+;// ./src/math/calc_mean.js
+const calcMean = values => values.reduce( ( sum, value ) => sum + value, 0 ) / values.length;
+
+;// ./src/math/calc_median.js
+const calcMedian = 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;
@@ -2213,43 +1979,28 @@ module.exports = values => {
   return evenArray ? ( sorted[midIndex - 1] + sorted[midIndex] ) / 2 : sorted[midIndex];
 };
 
+;// ./src/math/calc_median_abs_dev.js
 
-/***/ },
-
-/***/ 4692
-(module, __unused_webpack_exports, __webpack_require__) {
 
-const calcMedian = __webpack_require__( 3187 );
-
-module.exports = pop => {
+const calcMedianAbsDev = pop => {
   const center = calcMedian( pop );
   return calcMedian( pop.map( v => Math.abs( v - center ) ) );
 };
 
+;// ./src/math/calc_std_dev_population.js
 
-/***/ },
-
-/***/ 2736
-(module, __unused_webpack_exports, __webpack_require__) {
 
-const calcMean = __webpack_require__( 4124 );
-
-module.exports = values => {
+const calcStdDevPopulation = values => {
   const mean = calcMean( values );
   const squareDiffs = values.map( value => Math.pow( value - mean, 2 ) );
   const avgSquareDiff = calcMean( squareDiffs );
   return Math.sqrt( avgSquareDiff );
 };
 
+;// ./src/math/calc_std_dev_sample.js
 
-/***/ },
-
-/***/ 6089
-(module, __unused_webpack_exports, __webpack_require__) {
 
-const calcMean = __webpack_require__( 4124 );
-
-module.exports = values => {
+const calcStdDevSample = values => {
   if ( values.length < 2 ) { return NaN; }
 
   const mean = calcMean( values );
@@ -2258,47 +2009,11 @@ module.exports = values => {
   return Math.sqrt( avgSquareDiff );
 };
 
+;// ./src/math/calc_z_score.js
+const calcZScore = ( sample, mean, stdDev ) => stdDev === 0 ? NaN : ( sample - mean ) / stdDev;
 
-/***/ },
-
-/***/ 4110
-(module) {
-
-module.exports = ( sample, mean, stdDev ) => stdDev === 0 ? NaN : ( sample - mean ) / stdDev;
-
-
-/***/ },
-
-/***/ 943
-(module, __unused_webpack_exports, __webpack_require__) {
-
-const calcMean = __webpack_require__( 4124 );
-const calcMedian = __webpack_require__( 3187 );
-const calcMedianAbsDev = __webpack_require__( 4692 );
-const calcStdDevPopulation = __webpack_require__( 2736 );
-const calcStdDevSample = __webpack_require__( 6089 );
-const calcZScore = __webpack_require__( 4110 );
-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 ) => {
+;// ./src/math/round_gaussian.js
+const roundGaussian = ( n, d = 2 ) => {
   if ( !isFinite( n ) || typeof n !== 'number' ) { return NaN; }
 
   const m = Math.pow( 10, d );
@@ -2311,113 +2026,49 @@ module.exports = ( n, d = 2 ) => {
   return r / m;
 };
 
+;// ./src/math/round_standard.js
+const roundStandard = ( n, d = 2 ) => Math.round( n * ( 10 ** d ) ) / ( 10 ** d );
 
-/***/ },
-
-/***/ 115
-(module) {
-
-module.exports = ( n, d = 2 ) => Math.round( n * ( 10 ** d ) ) / ( 10 ** d );
-
+;// ./src/math/index.js
 
-/***/ },
 
-/***/ 8256
-(module, __unused_webpack_exports, __webpack_require__) {
 
-const isSerializable = __webpack_require__( 8864 );
-const camelize = __webpack_require__( 3914 );
-
-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 );
-
-
-/***/ },
-
-/***/ 6451
-(module) {
-
-module.exports = ( obj, props ) => Object.fromEntries( Object.entries( obj ).filter( ( [ k ] ) => props.includes( k ) ) );
-
-
-/***/ },
-
-/***/ 5762
-(module, __unused_webpack_exports, __webpack_require__) {
-
-const camelize = __webpack_require__( 8256 );
-const filterProps = __webpack_require__( 6451 );
-const removeEmptyArrays = __webpack_require__( 2047 );
-const snakelize = __webpack_require__( 7572 );
-
-module.exports = {
-  camelize,
-  filterProps,
-  removeEmptyArrays,
-  snakelize
-};
 
 
-/***/ },
 
-/***/ 8864
-(module) {
-
-module.exports = obj =>
-  typeof obj === 'object' &&
-  obj !== null &&
-  !( obj instanceof String ) &&
-  !( obj instanceof Number ) &&
-  !( obj instanceof Boolean ) &&
-  !( obj instanceof Date );
 
 
-/***/ },
 
-/***/ 2047
-(module) {
 
-module.exports = o => Object.fromEntries( Object.entries( o ).filter( ( [ , v ] ) => !Array.isArray( v ) || v.length > 0 ) );
 
+;// ./src/object/filter_props.js
+const filterProps = ( obj, props ) => Object.fromEntries( Object.entries( obj ).filter( ( [ k ] ) => props.includes( k ) ) );
 
-/***/ },
+;// ./src/object/remove_empty_arrays.js
+const removeEmptyArrays = o => Object.fromEntries( Object.entries( o ).filter( ( [ , v ] ) => !Array.isArray( v ) || v.length > 0 ) );
 
-/***/ 7572
-(module, __unused_webpack_exports, __webpack_require__) {
+;// ./src/object/index.js
 
-const isSerializable = __webpack_require__( 8864 );
-const snakelize = __webpack_require__( 3402 );
 
-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 );
 
 
-/***/ },
 
-/***/ 5422
-(module) {
 
+;// ./src/redis/create_client.js
 global.__redisInstances = {};
 
 /**
  * Create a redis client instance
- * @param {Object} redis Redis npm dependency
- * @param {String} address Redis DB address (either RW or RO)
+ *
+ * @param {Object} args
+ * @param {Object} args.redis Redis npm dependency
+ * @param {String} args.address Redis DB address (either RW or RO)
+ * @param {String} [args.protocol=rediss] Redis connection protocol
+ * @param {String} [args.port=6379] Redis DB connection port
  * @returns redisClient A new redis client instance connected to the database
  */
-module.exports = async ( { redis, address, protocol = 'rediss', port = 6379 } ) => {
+const createClient = async ( { redis, address, protocol = 'rediss', port = 6379 } ) => {
   if ( global.__redisInstances[address] ) {
     try {
       const r = await global.__redisInstances[address].ping();
@@ -2439,47 +2090,13 @@ module.exports = async ( { redis, address, protocol = 'rediss', port = 6379 } )
   return client;
 };
 
-
-/***/ },
-
-/***/ 4528
-(module, __unused_webpack_exports, __webpack_require__) {
-
-const createClient = __webpack_require__( 5422 );
-
-module.exports = {
-  createClient
-};
-
-
-/***/ },
-
-/***/ 3914
-(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 );
+;// ./src/redis/index.js
 
 
-/***/ },
 
-/***/ 3258
-(module) {
 
-module.exports = input =>
+;// ./src/string/capitalize_words.js
+const capitalizeWords = input =>
   // Break the string into sequences to rebuild later
   !input ? input : input.split( /\s/ )
     // ALL_CAPS terms are ignored
@@ -2487,66 +2104,15 @@ module.exports = input =>
     // Rebuild the string replacing the converter terms keeping the original delimiters
     .reduce( ( result, [ term, repl ] ) => result.replace( term, repl ), input );
 
+;// ./src/string/index.js
 
-/***/ },
-
-/***/ 268
-(module, __unused_webpack_exports, __webpack_require__) {
-
-const camelize = __webpack_require__( 3914 );
-const capitalizeWords = __webpack_require__( 3258 );
-const snakelize = __webpack_require__( 3402 );
-
-module.exports = {
-  camelize,
-  capitalizeWords,
-  snakelize
-};
-
-
-/***/ },
-
-/***/ 3402
-(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 );
-
-
-/***/ },
-
-/***/ 6878
-(module, __unused_webpack_exports, __webpack_require__) {
 
-const retryOnError = __webpack_require__( 4243 );
-const sleep = __webpack_require__( 2445 );
-const Timer = __webpack_require__( 9651 );
-const untarJsonGz = __webpack_require__( 8233 );
 
-module.exports = {
-  retryOnError,
-  sleep,
-  Timer,
-  untarJsonGz
-};
 
 
-/***/ },
 
-/***/ 4243
-(module, __unused_webpack_exports, __webpack_require__) {
+;// ./src/utils/retry_on_error.js
 
-const sleep = __webpack_require__( 2445 );
 
 const execWithRetry = async ( closure, { limit, delay, retryHook, execCount = 0 } ) => {
   if ( !( closure instanceof Function ) ) {
@@ -2574,7 +2140,7 @@ const execWithRetry = async ( closure, { limit, delay, retryHook, execCount = 0
 
     // if there is no hook back-off and retry
     if ( delay > 0 ) {
-      await sleep( delay ** ( 1 + execCount ) );
+      await sleep_sleep( delay ** ( 1 + execCount ) );
     }
     return execWithRetry( closure, { limit, delay, retryHook, execCount: execCount + 1 } );
   }
@@ -2584,31 +2150,19 @@ const execWithRetry = async ( closure, { limit, delay, retryHook, execCount = 0
  *
  * @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
+ * @param {Number} config.limit The max number of retries
+ * @param {Number} config.delay The delay between each retry (it will be raised to the power of the number of retries, so it is exponential back-off)
+ * @param {Function} config.retryHook A function to be called every time a retry is needed.
+ *                             If this functions returns true, the retry flow continues until limit
+ *                             If this functions returns false, the retry flow is aborted, returning false
+ *                             If this functions throws an error, the retry flow is aborted with that error
  * @returns {Any} The closure result
  */
-module.exports = async ( closure, { limit = 0, delay = 0, retryHook = null } = {} ) =>
+const retryOnError = async ( closure, { limit = 0, delay = 0, retryHook = null } = {} ) =>
   execWithRetry( closure, { limit, delay, retryHook } );
 
-
-/***/ },
-
-/***/ 2445
-(module) {
-
-module.exports = t => new Promise( r => setTimeout( r, t ) );
-
-
-/***/ },
-
-/***/ 9651
-(module) {
-
-module.exports = class Timer {
+;// ./src/utils/timer.js
+class Timer {
   #startedAt;
   #stoppedAt = null;
   #running = false;
@@ -2650,13 +2204,10 @@ module.exports = class Timer {
   }
 };
 
+;// external "node:zlib"
+const external_node_zlib_namespaceObject = require("node:zlib");
+;// ./src/utils/untar_json_gz.js
 
-/***/ },
-
-/***/ 8233
-(module, __unused_webpack_exports, __webpack_require__) {
-
-const { unzipSync } = __webpack_require__( 3106 );
 
 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 ) ) );
@@ -2673,8 +2224,8 @@ const lastIndexOf = ( c, ...vars ) => Math.max( ...vars.map( v => c.lastIndexOf(
  *
  * Enjoy this 100% native tarball decompression!
  */
-module.exports = raw =>
-  unzipSync( raw )
+const untarJsonGz = raw =>
+  (0,external_node_zlib_namespaceObject.unzipSync)( raw )
     .toString( 'utf-8' )
     .split( '\0ustar' )
     .slice( 1 )
@@ -2682,170 +2233,25 @@ module.exports = raw =>
       JSON.parse( c.substring( firstIndexOf( c, '{', '[' ), lastIndexOf( c, '}', ']' ) + 1 ) )
     );
 
+;// ./src/utils/index.js
 
-/***/ },
-
-/***/ 3744
-(module) {
-
-"use strict";
-module.exports = require("@aws-sdk/client-athena");
-
-/***/ },
-
-/***/ 7493
-(module) {
-
-"use strict";
-module.exports = require("@aws-sdk/client-cloudwatch-logs");
-
-/***/ },
-
-/***/ 4671
-(module) {
-
-"use strict";
-module.exports = require("@aws-sdk/client-dynamodb");
-
-/***/ },
-
-/***/ 5892
-(module) {
 
-"use strict";
-module.exports = require("@aws-sdk/client-lambda");
 
-/***/ },
 
-/***/ 5725
-(module) {
 
-"use strict";
-module.exports = require("@aws-sdk/client-s3");
 
-/***/ },
 
-/***/ 9556
-(module) {
+;// ./src/index.mjs
 
-"use strict";
-module.exports = require("@aws-sdk/client-sesv2");
 
-/***/ },
 
-/***/ 7651
-(module) {
 
-"use strict";
-module.exports = require("@aws-sdk/client-sns");
 
-/***/ },
 
-/***/ 1976
-(module) {
 
-"use strict";
-module.exports = require("@aws-sdk/client-sqs");
 
-/***/ },
 
-/***/ 4348
-(module) {
 
-"use strict";
-module.exports = require("@aws-sdk/client-ssm");
-
-/***/ },
-
-/***/ 1671
-(module) {
-
-"use strict";
-module.exports = require("@aws-sdk/client-timestream-query");
-
-/***/ },
-
-/***/ 8248
-(module) {
-
-"use strict";
-module.exports = require("@aws-sdk/client-timestream-write");
-
-/***/ },
-
-/***/ 3489
-(module) {
-
-"use strict";
-module.exports = require("@aws-sdk/lib-dynamodb");
-
-/***/ },
-
-/***/ 4991
-(module) {
-
-"use strict";
-module.exports = require("@aws-sdk/s3-request-presigner");
-
-/***/ },
-
-/***/ 6982
-(module) {
-
-"use strict";
-module.exports = require("crypto");
-
-/***/ },
-
-/***/ 5692
-(module) {
-
-"use strict";
-module.exports = require("https");
-
-/***/ },
-
-/***/ 3106
-(module) {
-
-"use strict";
-module.exports = require("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);
-/******/ 	module.exports = __webpack_exports__;
-/******/ 	
+module.exports = __webpack_exports__;
 /******/ })()
 ;