lambda-toolkit 1.1.1 → 2.0.0-dev.1

package/dist/index.mjs

@@ -0,0 +1,2254 @@
+import { AthenaClient as __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_athena_fac0b5e3_AthenaClient__, GetQueryExecutionCommand as __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_athena_fac0b5e3_GetQueryExecutionCommand__, GetQueryResultsCommand as __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_athena_fac0b5e3_GetQueryResultsCommand__, StartQueryExecutionCommand as __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_athena_fac0b5e3_StartQueryExecutionCommand__ } from "@aws-sdk/client-athena";
+import { createHash as __WEBPACK_EXTERNAL_MODULE_node_crypto_803ecaf5_createHash__, randomBytes as __WEBPACK_EXTERNAL_MODULE_node_crypto_803ecaf5_randomBytes__ } from "node:crypto";
+import { CloudWatchLogsClient as __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_cloudwatch_logs_2ca14d81_CloudWatchLogsClient__, GetQueryResultsCommand as __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_cloudwatch_logs_2ca14d81_GetQueryResultsCommand__, StartQueryCommand as __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_cloudwatch_logs_2ca14d81_StartQueryCommand__ } from "@aws-sdk/client-cloudwatch-logs";
+import { DynamoDBClient as __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_dynamodb_8ad5c6c3_DynamoDBClient__ } from "@aws-sdk/client-dynamodb";
+import { BatchWriteCommand as __WEBPACK_EXTERNAL_MODULE__aws_sdk_lib_dynamodb_4ad47c88_BatchWriteCommand__, DeleteCommand as __WEBPACK_EXTERNAL_MODULE__aws_sdk_lib_dynamodb_4ad47c88_DeleteCommand__, DynamoDBDocumentClient as __WEBPACK_EXTERNAL_MODULE__aws_sdk_lib_dynamodb_4ad47c88_DynamoDBDocumentClient__, GetCommand as __WEBPACK_EXTERNAL_MODULE__aws_sdk_lib_dynamodb_4ad47c88_GetCommand__, PutCommand as __WEBPACK_EXTERNAL_MODULE__aws_sdk_lib_dynamodb_4ad47c88_PutCommand__, QueryCommand as __WEBPACK_EXTERNAL_MODULE__aws_sdk_lib_dynamodb_4ad47c88_QueryCommand__, ScanCommand as __WEBPACK_EXTERNAL_MODULE__aws_sdk_lib_dynamodb_4ad47c88_ScanCommand__, TransactWriteCommand as __WEBPACK_EXTERNAL_MODULE__aws_sdk_lib_dynamodb_4ad47c88_TransactWriteCommand__, UpdateCommand as __WEBPACK_EXTERNAL_MODULE__aws_sdk_lib_dynamodb_4ad47c88_UpdateCommand__ } from "@aws-sdk/lib-dynamodb";
+import { InvokeCommand as __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_lambda_45e15e4c_InvokeCommand__, LambdaClient as __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_lambda_45e15e4c_LambdaClient__ } from "@aws-sdk/client-lambda";
+import { CopyObjectCommand as __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_s3_166f32a4_CopyObjectCommand__, GetObjectCommand as __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_s3_166f32a4_GetObjectCommand__, HeadObjectCommand as __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_s3_166f32a4_HeadObjectCommand__, PutObjectCommand as __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_s3_166f32a4_PutObjectCommand__, S3Client as __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_s3_166f32a4_S3Client__ } from "@aws-sdk/client-s3";
+import { getSignedUrl as __WEBPACK_EXTERNAL_MODULE__aws_sdk_s3_request_presigner_c7ff9288_getSignedUrl__ } from "@aws-sdk/s3-request-presigner";
+import { DeleteSuppressedDestinationCommand as __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_sesv2_6677e3b1_DeleteSuppressedDestinationCommand__, SESv2Client as __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_sesv2_6677e3b1_SESv2Client__, SendEmailCommand as __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_sesv2_6677e3b1_SendEmailCommand__ } from "@aws-sdk/client-sesv2";
+import { PublishBatchCommand as __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_sns_aa88aa43_PublishBatchCommand__, PublishCommand as __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_sns_aa88aa43_PublishCommand__, SNSClient as __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_sns_aa88aa43_SNSClient__ } from "@aws-sdk/client-sns";
+import { DeleteMessageCommand as __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_sqs_1f0ecae0_DeleteMessageCommand__, SQSClient as __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_sqs_1f0ecae0_SQSClient__, SendMessageBatchCommand as __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_sqs_1f0ecae0_SendMessageBatchCommand__, SendMessageCommand as __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_sqs_1f0ecae0_SendMessageCommand__ } from "@aws-sdk/client-sqs";
+import { GetParameterCommand as __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_ssm_6758df31_GetParameterCommand__, SSMClient as __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_ssm_6758df31_SSMClient__ } from "@aws-sdk/client-ssm";
+import { QueryCommand as __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_timestream_query_1be755b6_QueryCommand__, ScalarType as __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_timestream_query_1be755b6_ScalarType__, TimestreamQueryClient as __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_timestream_query_1be755b6_TimestreamQueryClient__ } from "@aws-sdk/client-timestream-query";
+import { Agent as __WEBPACK_EXTERNAL_MODULE_https_Agent__ } from "https";
+import { TimestreamWriteClient as __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_timestream_write_3c1b228d_TimestreamWriteClient__, WriteRecordsCommand as __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_timestream_write_3c1b228d_WriteRecordsCommand__ } from "@aws-sdk/client-timestream-write";
+import { unzipSync as __WEBPACK_EXTERNAL_MODULE_node_zlib_38f1fbfb_unzipSync__ } from "node:zlib";
+/******/ // 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__ = {};
+
+// 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
+
+
+
+const evaluate = ( condition, errorMessage ) => {
+  if ( !condition ) { throw new LambdaApiValidationError( errorMessage ); }
+};
+
+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 );
+
+;// ./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 );
+
+;// ./src/object/camelize.js
+
+
+
+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 camelize_camelize = ( obj, { keepAllCaps = false } = {} ) => change( obj, keepAllCaps );
+
+;// ./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 );
+
+;// ./src/object/snakelize.js
+
+
+
+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 snakelize_snakelize = ( obj, { keepAllCaps = false } = {} ) => snakelize_change( obj, keepAllCaps );
+
+;// ./src/lambda_api/api_response.js
+
+
+const charset = 'utf-8';
+
+const transformFns = {
+  camelcase: camelize_camelize,
+  snakecase: snakelize_snakelize
+};
+
+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
+    };
+  }
+};
+
+;// ./src/lambda_api/event.js
+
+
+const event_transformFns = {
+  camelcase: camelize_camelize,
+  snakecase: snakelize_snakelize
+};
+
+const parseJson = content => {
+  try {
+    return JSON.parse( content );
+  } catch {
+    return content;
+  }
+};
+
+class Event {
+  #transformFn;
+  authorizer;
+  body;
+  rawBody;
+  headers;
+  method;
+  params;
+  path;
+  queryString;
+  route;
+
+  context = {};
+
+  constructor( { transform = false } = {} ) {
+    this.#transformFn = event_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;
+  }
+};
+
+;// ./src/lambda_api/handler.js
+
+
+class Handler {
+  #method;
+  #fn;
+  #route;
+  #routeIncludes;
+  #routeNotIncludes;
+  #routeMatches;
+  #path;
+  #pathIncludes;
+  #pathNotIncludes;
+  #pathMatches;
+
+  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 );
+
+    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; }
+};
+
+;// ./src/lambda_api/hook.js
+
+
+class Hook {
+  #fn;
+
+  constructor( { fn } ) {
+    Validator.function( fn );
+    this.#fn = fn;
+  }
+
+  get fn() { return this.#fn; }
+};
+
+;// ./src/lambda_api/user_response.js
+
+
+
+
+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' ) {
+      Validator.statusCode( args );
+      this.values = [ args ];
+
+    } else if ( Array.isArray( args ) ) {
+      Validator.statusCode( args[0] );
+      this.values = args;
+
+    } else if ( args.statusCode ) {
+      Validator.statusCode( args.statusCode );
+      this.values = [ args.statusCode, args.body, args.headers, args.isBase64Encoded ];
+
+    } else if ( [ undefined, null ].includes( args ) ) {
+      this.values = [ 200 ];
+    } else {
+      throw new LambdaApiValidationError( Text.INVALID_USER_RESPONSE );
+    }
+  }
+};
+
+;// ./src/lambda_api/lambda_api.js
+
+
+
+
+
+
+
+
+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 } = {} ) {
+    Validator.transformRequest( transformRequest );
+    Validator.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 } = {} ) {
+    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 );
+
+    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();
+    }
+  }
+};
+
+;// ./src/lambda_api/index.js
+
+
+
+
+;// ./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();
+
+;// ./src/array/index.js
+
+
+
+
+
+
+;// external "@aws-sdk/client-athena"
+
+;// external "node:crypto"
+
+;// ./src/aws/core/cache_storage.js
+
+
+const cacheSym = Symbol.for( 'cache' );
+
+const hash = text => __WEBPACK_EXTERNAL_MODULE_node_crypto_803ecaf5_createHash__( 'md5' ).update( text ).digest( 'hex' );
+
+const propOpts = {
+  enumerable: false,
+  configurable: false,
+  writable: false
+};
+
+const CacheStorage = {
+  set: ( key, value ) => {
+    const keySym = Symbol.for( hash( key ) );
+
+    if ( !global[cacheSym] ) {
+      Object.defineProperty( global, cacheSym, { ...propOpts, value: {} } );
+    }
+
+    Object.defineProperty( global[cacheSym], keySym, { ...propOpts, value } );
+  },
+  get: key => {
+    return global[cacheSym]?.[Symbol.for( hash( key ) )];
+  }
+};
+
+;// ./src/aws/core/generic_client_provider.js
+
+
+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;
+  } )();
+};
+
+;// ./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;
+    }
+  }
+};
+
+;// ./src/aws/athena/lib/start_query.js
+
+
+
+/**
+ * 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 __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_athena_fac0b5e3_StartQueryExecutionCommand__( {
+    ClientRequestToken: __WEBPACK_EXTERNAL_MODULE_node_crypto_803ecaf5_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 ? [] : {} );
+
+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 :
+
+    return removeNullValues( JSON.parse( obj ) );
+  }
+  if ( 'json' === type ) {
+    return JSON.parse( v );
+  }
+  return v;
+};
+
+;// ./src/aws/athena/lib/parse_results.js
+
+
+const parseResults = 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 ) } ), {} );
+  } );
+};
+
+;// ./src/aws/athena/lib/polling_delay.js
+const pollingDelay = 500;
+
+;// ./src/aws/athena/lib/get_results.js
+
+
+
+
+const sleep = t => new Promise( r => setTimeout( () => r(), t ) );
+
+const getQueryResults = async ( { client, queryExecutionId, maxResults, token } ) => {
+  const { NextToken: nextToken, ResultSet } = await client.send( new __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_athena_fac0b5e3_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 } );
+
+  if ( nextToken ) {
+    return { items: items.concat( ( await getQueryResultsRecursive( { client, queryExecutionId, token: nextToken } ) ).items ) };
+  }
+  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 __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_athena_fac0b5e3_GetQueryExecutionCommand__( { QueryExecutionId: queryExecutionId } ) );
+
+  if ( status.State === 'FAILED' ) {
+    throw new Error( status.AthenaError?.ErrorMessage ?? status.StateChangeReason );
+  }
+
+  if ( status.State === 'SUCCEEDED' ) {
+    const fn = recursive ? getQueryResultsRecursive : getQueryResults;
+    return fn( { client, recursive, queryExecutionId, token, maxResults } );
+  }
+
+  // sleep an try again
+  await sleep( pollingDelay );
+  return getResults( { client, recursive, queryExecutionId, token, maxResults } );
+};
+
+;// ./src/aws/athena/query.js
+
+
+
+
+const getQueryExecutionId = async ( { client, nativeArgs, recursive, paginationToken } ) => {
+  if ( !recursive && paginationToken ) {
+    const { queryExecutionId, token } = Encoder.decode( paginationToken );
+    return { queryExecutionId, token };
+  }
+
+  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
+ */
+const query = async ( client, nativeArgs, options ) => {
+  const { recursive = false, paginationToken, maxResults } = options;
+
+  const { queryExecutionId, token } = await getQueryExecutionId( { client, nativeArgs, recursive, paginationToken } );
+
+  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 );
+
+  // 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;
+    }
+  } );
+};
+
+;// ./src/aws/athena/index.js
+
+
+
+
+
+const methods = {
+  query: query
+};
+
+const athena = createInstance( genericClientProvider.bind( null, __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_athena_fac0b5e3_AthenaClient__ ), methods );
+
+;// external "@aws-sdk/client-cloudwatch-logs"
+
+;// ./src/aws/cw_logs/query/start_query.js
+
+
+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;
+
+  const { queryId } = await client.send( new __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_cloudwatch_logs_2ca14d81_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 ) );
+
+;// ./src/aws/cw_logs/query/get_results.js
+
+
+
+
+const getResultsRecursive = async ( { client, command } ) => {
+  const { results, status } = await client.send( command );
+
+  if ( [ 'Cancelled', 'Failed', 'Timeout', 'Unknown' ].includes( status ) ) {
+    throw new Error( `Query status is "${status}"` );
+  }
+
+  if ( status === 'Complete' ) {
+    return results;
+  }
+
+  // Running, Scheduled
+  await sleep_sleep( polling_delay_pollingDelay );
+  return getResultsRecursive( { client, command } );
+};
+
+const get_results_getResults = async ( { client, queryId } ) => {
+  const command = new __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_cloudwatch_logs_2ca14d81_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;
+};
+
+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 */
+const parse_value_parseValue = value => {
+  if ( [ null, undefined ].includes( value ) ) {
+    return undefined;
+  }
+
+  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 );
+  }
+
+  // integer
+  if ( /^-?\d+$/.test( value ) ) {
+    return parseInteger( value );
+  }
+
+  // float
+  if ( /^-?(\d+\.|\.\d+|\d+\.\d+)$/.test( value ) ) {
+    return parseFloatingPoint( value );
+  }
+
+  // boolean
+  if ( /^true$/.test( value ) ) {
+    return true;
+  }
+
+  if ( /^false$/.test( value ) ) {
+    return false;
+  }
+
+  return value;
+};
+
+;// ./src/aws/cw_logs/query/parse_item.js
+
+
+const parseItem = item =>
+  item.reduce( ( row, { field, value } ) =>
+    Object.assign( row, {
+      [field]: parse_value_parseValue( value )
+    } ), {} );
+
+;// ./src/aws/cw_logs/query/parse_results.js
+
+
+const parse_results_parseResults = results => results.map( item => parseItem( item ) );
+
+;// ./src/aws/cw_logs/query/index.js
+
+
+
+
+/**
+ * @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 };
+};
+
+;// ./src/aws/cw_logs/index.js
+
+
+
+
+
+const cw_logs_methods = {
+  query: query_query
+};
+
+const cwLogs = createInstance( genericClientProvider.bind( null, __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_cloudwatch_logs_2ca14d81_CloudWatchLogsClient__ ), cw_logs_methods );
+
+;// external "@aws-sdk/client-dynamodb"
+
+;// external "@aws-sdk/lib-dynamodb"
+
+;// ./src/aws/dynamo/document_client_provider.js
+
+
+
+
+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 key = `Dynamodb(${JSON.stringify( nativeArgs )}).DocumentClient`;
+  return CacheStorage.get( key ) ?? ( () => {
+    const client = new __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_dynamodb_8ad5c6c3_DynamoDBClient__( nativeArgs );
+    const docClient = __WEBPACK_EXTERNAL_MODULE__aws_sdk_lib_dynamodb_4ad47c88_DynamoDBDocumentClient__.from( client, translateConfig );
+
+    CacheStorage.set( key, docClient );
+    return docClient;
+  } )();
+};
+
+;// ./src/aws/dynamo/get.js
+
+
+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 __WEBPACK_EXTERNAL_MODULE__aws_sdk_lib_dynamodb_4ad47c88_GetCommand__( parseArgs( args ) ) );
+  return response.Item;
+};
+
+;// ./src/aws/dynamo/put.js
+
+
+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'
+  };
+};
+
+/**
+ *
+ * @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 __WEBPACK_EXTERNAL_MODULE__aws_sdk_lib_dynamodb_4ad47c88_PutCommand__( nativeArgs ) );
+  return response.Attributes ?? nativeArgs.Item;
+};
+
+;// ./src/aws/dynamo/batch_write.js
+
+
+
+const batchSize = 25;
+
+const getMapper = method => method === 'put' ? v => ( { PutRequest: { Item: v } } ) : v => ( { DeleteRequest: { Key: v } } );
+
+const process = async ( { client, method, table, batches } ) => {
+  if ( batches.length === 0 ) { return true; }
+
+  const response = await client.send( new __WEBPACK_EXTERNAL_MODULE__aws_sdk_lib_dynamodb_4ad47c88_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
+
+
+const putBatch = async ( client, ...args ) => batchWrite( client, 'put', ...args );
+
+;// ./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 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
+  };
+
+  if ( !recursive ) {
+    return { items: result.items, count: result.count, ...( result.startKey && { nextToken: Encoder.encode( result.startKey ) } ) };
+  }
+
+  if ( result.startKey && ( isCount || ( hasLimit && result.items.length < args.Limit ) || ( !isCount && !hasLimit ) ) ) {
+    return select_query( { client, command, args, recursive, ...result } );
+  }
+
+  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' ? __WEBPACK_EXTERNAL_MODULE__aws_sdk_lib_dynamodb_4ad47c88_ScanCommand__ : __WEBPACK_EXTERNAL_MODULE__aws_sdk_lib_dynamodb_4ad47c88_QueryCommand__;
+
+  return select_query( { client, command, args, recursive: options.recursive, startKey: Encoder.decode( options.paginationToken ) } );
+};
+
+;// ./src/aws/dynamo/query.js
+
+
+const dynamo_query_query = async ( client, ...args ) => select_select( client, 'query', ...args );
+
+;// ./src/aws/dynamo/remove.js
+
+
+const remove = async ( client, tableName, key ) => {
+  const { Attributes: item } = await client.send( new __WEBPACK_EXTERNAL_MODULE__aws_sdk_lib_dynamodb_4ad47c88_DeleteCommand__( {
+    ReturnValues: 'ALL_OLD',
+    TableName: tableName,
+    Key: key
+  } ) );
+  return item;
+};
+
+;// ./src/aws/dynamo/remove_batch.js
+
+
+const removeBatch = async ( client, ...args ) => batchWrite( client, 'remove', ...args );
+
+;// ./src/aws/dynamo/scan.js
+
+
+const scan = async ( client, ...args ) => select_select( client, 'scan', ...args );
+
+;// ./src/aws/dynamo/smart_update.js
+
+
+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 } )
+    , {} );
+
+    Object.assign( args.names, expAttrNames );
+
+    if ( isRemoval ) {
+      args.removals.push( fullPath );
+    } else {
+      args.updates.push( fullPath + ' = ' + valueId );
+      Object.assign( args.values, { [valueId]: value } );
+    }
+
+    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; }
+
+  const expressions = [];
+  if ( updates.length ) {
+    expressions.push( 'SET ' + updates.join( ', ' ) );
+  } if ( removals.length ) {
+    expressions.push( 'REMOVE ' + removals.join( ', ' ) );
+  }
+
+  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;
+  }
+
+  try {
+    const response = await client.send( new __WEBPACK_EXTERNAL_MODULE__aws_sdk_lib_dynamodb_4ad47c88_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;
+  }
+};
+
+;// ./src/aws/dynamo/transact_write.js
+
+
+const transactWrite = async ( client, items ) => {
+  const response = await client.send( new __WEBPACK_EXTERNAL_MODULE__aws_sdk_lib_dynamodb_4ad47c88_TransactWriteCommand__( { TransactItems: items } ) );
+  return response;
+};
+
+;// ./src/aws/dynamo/update.js
+
+
+const update = async ( client, nativeArgs ) => {
+  const args = Object.assign( { ReturnValues: 'ALL_NEW' }, nativeArgs );
+  const response = await client.send( new __WEBPACK_EXTERNAL_MODULE__aws_sdk_lib_dynamodb_4ad47c88_UpdateCommand__( args ) );
+  return response.Attributes;
+};
+
+;// ./src/aws/dynamo/index.js
+
+
+
+
+
+
+
+
+
+
+
+
+
+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 dynamo = createInstance( documentClientProvider, dynamo_methods );
+
+;// external "@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 __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_lambda_45e15e4c_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, __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_lambda_45e15e4c_LambdaClient__ ), lambda_methods );
+
+;// external "@aws-sdk/client-s3"
+
+;// ./src/aws/s3/copy.js
+
+
+const copy = async ( client, bucket, key, source, nativeArgs ) => {
+  const response = await client.send( new __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_s3_166f32a4_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 __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_s3_166f32a4_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"
+
+;// ./src/aws/s3/get_signed_url.js
+
+
+
+const getSignedUrl = async ( client, bucket, key, expiration ) => {
+  const getObjectCmd = new __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_s3_166f32a4_GetObjectCommand__( { Bucket: bucket, Key: key } );
+  const url = await __WEBPACK_EXTERNAL_MODULE__aws_sdk_s3_request_presigner_c7ff9288_getSignedUrl__( client, getObjectCmd, { expiresIn: expiration } );
+  return url;
+};
+
+;// ./src/aws/s3/head.js
+
+
+const head = async ( client, bucket, key ) =>
+  client.send( new __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_s3_166f32a4_HeadObjectCommand__( { Bucket: bucket, Key: key } ) );
+
+;// ./src/aws/s3/upload.js
+
+
+const upload = ( client, bucket, key, body, nativeArgs ) =>
+  client.send( new __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_s3_166f32a4_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, __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_s3_166f32a4_S3Client__ ), s3_methods );
+
+;// external "@aws-sdk/client-sesv2"
+
+;// ./src/aws/ses/delete_suppressed_destination.js
+
+
+const deleteSuppressedDestination = ( client, address ) => client.send( new __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_sesv2_6677e3b1_DeleteSuppressedDestinationCommand__( { EmailAddress: address } ) );
+
+;// ./src/aws/ses/send_email.js
+
+
+const sendEmail = ( client, { to = [], from, html, subject }, args ) =>
+  client.send( new __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_sesv2_6677e3b1_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, __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_sesv2_6677e3b1_SESv2Client__ ), ses_methods );
+
+;// external "@aws-sdk/client-sns"
+
+;// ./src/aws/sns/publish.js
+
+
+const publish = async ( client, topic, message, args = {} ) => {
+  const response = await client.send( new __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_sns_aa88aa43_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 __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_sns_aa88aa43_PublishBatchCommand__( {
+    TopicArn: topic,
+    PublishBatchRequestEntries: messages.map( ( { body, id = null, nativeArgs }, index ) => ( {
+      Id: id ?? `message_${index}`,
+      Message: typeof body === 'string' ? body : JSON.stringify( body ),
+      ...nativeArgs
+    } ) )
+  } ) );
+
+  if ( response.Failed?.length > 0 ) {
+    const error = new Error( 'SNS.publishBatch Failed. See error details' );
+    error.details = response.Failed;
+    throw error;
+  }
+  return response;
+};
+
+;// ./src/aws/sns/index.js
+
+
+
+
+
+
+const sns_methods = {
+  publish: publish,
+  publishBatch: publishBatch
+};
+
+const sns = createInstance( genericClientProvider.bind( null, __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_sns_aa88aa43_SNSClient__ ), sns_methods );
+
+;// external "@aws-sdk/client-sqs"
+
+;// ./src/aws/sqs/delete_message.js
+
+
+const deleteMessage = async ( client, queue, receiptHandle ) =>
+  client.send( new __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_sqs_1f0ecae0_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
+*/
+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
+
+
+
+const sendMessage = async ( client, queue, body, args ) => {
+  const response = await client.send( new __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_sqs_1f0ecae0_SendMessageCommand__( {
+    ...args,
+    MessageBody: sanitizeSqs( typeof body === 'string' ? body : JSON.stringify( body ) ),
+    QueueUrl: queue
+  } ) );
+  return response.MessageId;
+};
+
+;// ./src/aws/sqs/send_message_batch.js
+
+
+
+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 __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_sqs_1f0ecae0_SendMessageBatchCommand__( {
+    QueueUrl: queue,
+    Entries: messages.map( ( { body, id = null, nativeArgs }, index ) => ( {
+      Id: id ?? `message_${index}`,
+      MessageBody: sanitizeSqs( typeof body === 'string' ? body : JSON.stringify( body ) ),
+      ...nativeArgs
+    } ) )
+  } ) );
+
+  if ( response.Failed?.length > 0 ) {
+    const error = new Error( 'SQS.sendMessageBatch Failed. See error details' );
+    error.details = response.Failed;
+    throw error;
+  }
+  return response;
+};
+
+;// ./src/aws/sqs/index.js
+
+
+
+
+
+
+
+const sqs_methods = {
+  deleteMessage: deleteMessage,
+  sendMessage: sendMessage,
+  sendMessageBatch: sendMessageBatch
+};
+
+const sqs = createInstance( genericClientProvider.bind( null, __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_sqs_1f0ecae0_SQSClient__ ), sqs_methods );
+
+;// external "@aws-sdk/client-ssm"
+
+;// ./src/aws/ssm/get.js
+
+
+
+const get_get = async ( client, name ) => {
+  const key = `SSM_${name}`;
+  const cacheValue = CacheStorage.get( key );
+  if ( cacheValue ) { return cacheValue; }
+
+  try {
+    const response = await client.send( new __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_ssm_6758df31_GetParameterCommand__( { Name: name, WithDecryption: true } ) );
+    const value = response?.Parameter?.Value;
+    CacheStorage.set( key, value );
+    return value;
+  } catch ( error ) {
+    if ( error.constructor.name === 'ParameterNotFound' ) {
+      return null;
+    }
+    throw error;
+  }
+};
+
+;// ./src/aws/ssm/index.js
+
+
+
+
+
+const ssm_methods = { get: get_get };
+
+const ssm = createInstance( genericClientProvider.bind( null, __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_ssm_6758df31_SSMClient__ ), ssm_methods );
+
+;// external "@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 parseBigInt = value => {
+  const asInt = parseInt( value, 10 );
+  return asInt <= Number.MAX_SAFE_INTEGER && asInt >= Number.MIN_SAFE_INTEGER ? asInt : value;
+};
+
+const parseScalarValue = ( type, value ) => {
+  switch ( type ) {
+    case __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_timestream_query_1be755b6_ScalarType__.BOOLEAN:
+      return value === 'true';
+    case __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_timestream_query_1be755b6_ScalarType__.DOUBLE:
+      return parseFloat( value );
+    case __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_timestream_query_1be755b6_ScalarType__.TIMESTAMP:
+      return new Date( `${value.replace( ' ', 'T' )}Z` );
+    case __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_timestream_query_1be755b6_ScalarType__.INTEGER:
+      return parseInt( value, 10 );
+    case __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_timestream_query_1be755b6_ScalarType__.UNKNOWN: // is NULL
+      return null;
+    case __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_timestream_query_1be755b6_ScalarType__.BIGINT:
+      return parseBigInt( value );
+    case __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_timestream_query_1be755b6_ScalarType__.VARCHAR:
+    case __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_timestream_query_1be755b6_ScalarType__.DATE:
+    case __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_timestream_query_1be755b6_ScalarType__.TIME:
+    case __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_timestream_query_1be755b6_ScalarType__.INTERVAL_DAY_TO_SECOND:
+    case __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_timestream_query_1be755b6_ScalarType__.INTERVAL_YEAR_TO_MONTH:
+    default:
+      return value;
+  }
+};
+
+const parse_items_parseValue = ( typeInfo, datum ) => {
+  // value might be null
+  if ( datum['NullValue'] === true ) {
+    return null;
+  }
+
+  // or a time series
+  if ( Object.hasOwn( typeInfo, 'TimeSeriesMeasureValueColumnInfo' ) ) {
+    return datum.TimeSeriesValue.map( v => ( {
+      time: new Date( v.Time ),
+      value: parse_items_parseValue( typeInfo.TimeSeriesMeasureValueColumnInfo.Type, v.Value )
+    } ) );
+  }
+
+  // maybe an array
+  if ( Object.hasOwn( typeInfo, 'ArrayColumnInfo' ) ) {
+    return datum.ArrayValue.map( v => parse_items_parseValue( typeInfo.ArrayColumnInfo.Type, v ) );
+  }
+
+  // or even a row
+  if ( Object.hasOwn( typeInfo, 'RowColumnInfo' ) ) {
+    const rowColumnInfo = typeInfo.RowColumnInfo;
+    return datum.RowValue.Data.reduce( ( object, value, index ) => {
+      const { Name: name, Type: typeInfo } = rowColumnInfo[index];
+      return Object.assign( object, { [name]: parse_items_parseValue( typeInfo, value ) } );
+    }, {} );
+  }
+
+  // if none, it is scalar
+  return parseScalarValue( typeInfo.ScalarType, datum['ScalarValue'] );
+};
+
+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]: parse_items_parseValue( typeInfo, value ) } );
+    }, { } )
+  );
+};
+
+;// ./src/aws/timestream_query/query.js
+
+
+
+
+const sendQuery = async ( client, queryString, { prevItems = [], recursive, paginationToken, maxRows, rawResponse } ) => {
+  const response = await client.send( new __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_timestream_query_1be755b6_QueryCommand__( { QueryString: queryString, NextToken: paginationToken, MaxRows: maxRows } ) );
+  if ( !recursive && rawResponse ) {
+    return response;
+  }
+
+  const nextToken = response.NextToken;
+  if ( nextToken && recursive ) {
+    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_camelize( response.QueryStatus ) };
+};
+
+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"
+
+;// ./src/aws/timestream_query/index.js
+
+
+
+
+
+
+const timestream_query_methods = { query: timestream_query_query_query };
+const defaultArgs = {
+  maxRetries: 10,
+  httpOptions: { timeout: 60000, agent: new __WEBPACK_EXTERNAL_MODULE_https_Agent__( { maxSockets: 5000 } ) }
+};
+
+const timestreamQuery =
+  createInstance( args => genericClientProvider( __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_timestream_query_1be755b6_TimestreamQueryClient__, [ Object.assign( {}, defaultArgs, args ) ] ), timestream_query_methods );
+
+;// external "@aws-sdk/client-timestream-write"
+
+;// ./src/aws/timestream_write/write_records.js
+
+
+const writeRecords = async ( client, { database, table, records, ignoreRejections = false } ) => {
+  try {
+    const response = await client.send( new __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_timestream_write_3c1b228d_WriteRecordsCommand__( {
+      DatabaseName: database,
+      TableName: table,
+      Records: records
+    } ) );
+    return { recordsIngested: response.RecordsIngested };
+  } catch ( error ) {
+    if ( ignoreRejections && error.name === 'RejectedRecordsException' ) {
+      return { rejectedRecords: error.RejectedRecords };
+    }
+    throw error;
+  }
+};
+
+;// ./src/aws/timestream_write/index.js
+
+
+
+
+
+
+const timestream_write_methods = { writeRecords: writeRecords };
+const timestream_write_defaultArgs = {
+  maxRetries: 10,
+  httpOptions: { timeout: 60000, agent: new __WEBPACK_EXTERNAL_MODULE_https_Agent__( { maxSockets: 5000 } ) }
+};
+
+const timestreamWrite =
+  createInstance( args => genericClientProvider( __WEBPACK_EXTERNAL_MODULE__aws_sdk_client_timestream_write_3c1b228d_TimestreamWriteClient__, [ Object.assign( {}, timestream_write_defaultArgs, args ) ] ), timestream_write_methods );
+
+;// ./src/aws/index.js
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+;// ./src/epoch/days.js
+const days = t => t * 24 * 60 * 60 * 1000;
+
+;// ./src/epoch/hours.js
+const hours = t => t * 60 * 60 * 1000;
+
+;// ./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 );
+
+;// ./src/epoch/round.js
+const round = ( time, interval ) => time - ( time % interval );
+
+;// ./src/epoch/seconds.js
+const seconds = t => t * 1000;
+
+;// ./src/epoch/index.js
+
+
+
+
+
+
+
+
+
+
+;// ./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;
+  const midIndex = Math.floor( values.length / 2 );
+  return evenArray ? ( sorted[midIndex - 1] + sorted[midIndex] ) / 2 : sorted[midIndex];
+};
+
+;// ./src/math/calc_median_abs_dev.js
+
+
+const calcMedianAbsDev = pop => {
+  const center = calcMedian( pop );
+  return calcMedian( pop.map( v => Math.abs( v - center ) ) );
+};
+
+;// ./src/math/calc_std_dev_population.js
+
+
+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
+
+
+const calcStdDevSample = values => {
+  if ( values.length < 2 ) { return NaN; }
+
+  const mean = calcMean( values );
+  const squareDiffs = values.map( value => Math.pow( value - mean, 2 ) );
+  const avgSquareDiff = squareDiffs.reduce( ( sum, v ) => sum + v, 0 ) / ( values.length - 1 );
+  return Math.sqrt( avgSquareDiff );
+};
+
+;// ./src/math/calc_z_score.js
+const calcZScore = ( sample, mean, stdDev ) => stdDev === 0 ? NaN : ( sample - mean ) / stdDev;
+
+;// ./src/math/round_gaussian.js
+const roundGaussian = ( n, d = 2 ) => {
+  if ( !isFinite( n ) || typeof n !== 'number' ) { return NaN; }
+
+  const m = Math.pow( 10, d );
+  const num = +( n * m ).toFixed( 8 ); // Avoid rounding errors
+  const i = Math.floor( num );
+  const f = num - i;
+  const e = 1e-8; // Allow for rounding errors in f
+  const r = ( f > 0.5 - e && f < 0.5 + e ) ? // eslint-disable-line no-nested-ternary
+    ( ( i % 2 === 0 ) ? i : i + 1 ) : Math.round( num );
+  return r / m;
+};
+
+;// ./src/math/round_standard.js
+const roundStandard = ( n, d = 2 ) => Math.round( n * ( 10 ** d ) ) / ( 10 ** d );
+
+;// ./src/math/index.js
+
+
+
+
+
+
+
+
+
+
+
+;// ./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 ) );
+
+;// ./src/object/index.js
+
+
+
+
+
+
+
+;// ./src/redis/create_client.js
+global.__redisInstances = {};
+
+/**
+ * Create a redis client instance
+ *
+ * @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
+ */
+const createClient = async ( { redis, address, protocol = 'rediss', port = 6379 } ) => {
+  if ( global.__redisInstances[address] ) {
+    try {
+      const r = await global.__redisInstances[address].ping();
+      if ( r === 'PONG' ) {
+        return global.__redisInstances[address];
+      } else {
+        delete global.__redisInstances[address];
+      }
+    } catch {
+      delete global.__redisInstances[address];
+    }
+  }
+
+  const client = redis.createClient( { url: `${protocol}://${address}:${port}`, socket: { keepAlive: 15000 } } );
+
+  await client.connect();
+
+  global.__redisInstances[address] = client;
+  return client;
+};
+
+;// ./src/redis/index.js
+
+
+
+
+;// ./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
+    .map( term => [ term, term.charAt( 0 ).toUpperCase() + term.slice( 1 ).toLowerCase() ] )
+    // Rebuild the string replacing the converter terms keeping the original delimiters
+    .reduce( ( result, [ term, repl ] ) => result.replace( term, repl ), input );
+
+;// ./src/string/index.js
+
+
+
+
+
+
+;// ./src/utils/retry_on_error.js
+
+
+const execWithRetry = async ( closure, { limit, delay, retryHook, execCount = 0 } ) => {
+  if ( !( closure instanceof Function ) ) {
+    throw new Error( 'Closure is not a function' );
+  }
+
+  try {
+    return await closure();
+  } catch ( error ) {
+    // exhausted
+    if ( execCount === limit ) { throw error; }
+
+    // async retry hook to check if it should retry or give up and throw
+    if ( retryHook instanceof Function ) {
+      try {
+        const retry = await retryHook( error, execCount );
+        if ( retry === false ) { return false; }
+
+      // Hook errors break the flow
+      } catch ( hookError ) {
+        console.debug( hookError );
+        throw hookError;
+      }
+    }
+
+    // if there is no hook back-off and retry
+    if ( delay > 0 ) {
+      await sleep_sleep( delay ** ( 1 + execCount ) );
+    }
+    return execWithRetry( closure, { limit, delay, retryHook, execCount: execCount + 1 } );
+  }
+};
+
+/**
+ *
+ * @param {Function} closure A self contained function that will be invoked
+ * @param {Object} config
+ * @param {Number} 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
+ */
+const retryOnError = async ( closure, { limit = 0, delay = 0, retryHook = null } = {} ) =>
+  execWithRetry( closure, { limit, delay, retryHook } );
+
+;// ./src/utils/timer.js
+class Timer {
+  #startedAt;
+  #stoppedAt = null;
+  #running = false;
+
+  get elapsed() {
+    if ( this.#running ) {
+      return Date.now() - this.#startedAt;
+    } else if ( !this.#startedAt ) {
+      return 0;
+    } else {
+      return this.#stoppedAt - this.#startedAt;
+    }
+  }
+
+  get running() {
+    return this.#running;
+  }
+
+  start() {
+    if ( !this.#running ) {
+      this.#startedAt = Date.now();
+      this.#running = true;
+    }
+    return this;
+  }
+
+  restart() {
+    this.#running = true;
+    this.#startedAt = Date.now();
+    return this;
+  }
+
+  stop() {
+    if ( this.#running ) {
+      this.#running = false;
+      this.#stoppedAt = Date.now();
+    }
+    return this.#stoppedAt - this.#startedAt;
+  }
+};
+
+;// external "node:zlib"
+
+;// ./src/utils/untar_json_gz.js
+
+
+const firstIndexOf = ( c, ...vars ) => Math.min( ...vars.map( v => c.indexOf( v ) ).filter( n => n > -1 ) );
+const lastIndexOf = ( c, ...vars ) => Math.max( ...vars.map( v => c.lastIndexOf( v ) ) );
+
+/**
+ * Decompress JSON
+ *
+ * Reads a gzipped tarball (.tar.gz)
+ * 1. Unzip it
+ * 2. Convert all to utf-8
+ * 3. Split files using the \0star separator
+ * 4. Trim files until JSON markup start/end ({})
+ * 5. JSON parse
+ *
+ * Enjoy this 100% native tarball decompression!
+ */
+const untarJsonGz = raw =>
+  __WEBPACK_EXTERNAL_MODULE_node_zlib_38f1fbfb_unzipSync__( raw )
+    .toString( 'utf-8' )
+    .split( '\0ustar' )
+    .slice( 1 )
+    .map( c =>
+      JSON.parse( c.substring( firstIndexOf( c, '{', '[' ), lastIndexOf( c, '}', ']' ) + 1 ) )
+    );
+
+;// ./src/utils/index.js
+
+
+
+
+
+
+
+;// ./src/index.mjs
+
+
+
+
+
+
+
+
+
+
+export { LambdaApi, array_namespaceObject as array, aws_namespaceObject as aws, epoch_namespaceObject as epoch, math_namespaceObject as math, object_namespaceObject as object, redis_namespaceObject as redis, string_namespaceObject as string, utils_namespaceObject as utils };