lambda-toolkit 0.0.2-beta → 0.0.4-beta

package/dist/index.js

@@ -0,0 +1,2530 @@
+import { createRequire as __WEBPACK_EXTERNAL_createRequire } from "node:module";
+/******/ 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
+};
+
+
+/***/ }),
+
+/***/ 2836:
+/***/ ((module) => {
+
+module.exports = ( ...args ) => [ ...new Set( args.filter( Array.isArray ).flat() ) ];
+
+
+/***/ }),
+
+/***/ 536:
+/***/ ((module) => {
+
+module.exports = ( { key, items } ) => [
+  ...items.filter( Array.isArray ).flat().reduce( ( map, v ) => {
+    const k = key( v );
+    if ( !map.has( k ) ) {
+      map.set( k, v );
+    }
+    return map;
+  }, new Map() ).values()
+];
+
+
+/***/ }),
+
+/***/ 4821:
+/***/ ((module) => {
+
+module.exports = ( items, size ) => items.reduce( ( arrs, item ) =>
+  ( arrs[0] && arrs[0].length < size ) ?
+    [ [ ...arrs[0], item ] ].concat( arrs.slice( 1 ) ) :
+    [ [ item ] ].concat( arrs )
+, [] ).reverse();
+
+
+/***/ }),
+
+/***/ 228:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const { AthenaClient } = __webpack_require__( 3744 );
+const clientProvider = __webpack_require__( 9039 );
+const query = __webpack_require__( 140 );
+const createInstance = __webpack_require__( 5438 );
+
+const methods = {
+  query
+};
+
+module.exports = createInstance( clientProvider.bind( null, AthenaClient ), methods );
+
+
+/***/ }),
+
+/***/ 7337:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const { GetQueryExecutionCommand, GetQueryResultsCommand } = __webpack_require__( 3744 );
+const parseResults = __webpack_require__( 834 );
+const pollingDelay = __webpack_require__( 4127 );
+
+const sleep = t => new Promise( r => setTimeout( () => r(), t ) );
+
+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 } );
+
+  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 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 } );
+};
+
+module.exports = getResults;
+
+
+/***/ }),
+
+/***/ 834:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+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 ) } ), {} );
+  } );
+};
+
+
+/***/ }),
+
+/***/ 9129:
+/***/ ((module) => {
+
+/* 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 ? [] : {} );
+
+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();
+  }
+  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;
+};
+
+
+/***/ }),
+
+/***/ 4127:
+/***/ ((module) => {
+
+module.exports = 500;
+
+
+/***/ }),
+
+/***/ 5723:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const { randomBytes } = __webpack_require__( 6982 );
+const { StartQueryExecutionCommand } = __webpack_require__( 3744 );
+
+/**
+ * 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;
+};
+
+
+/***/ }),
+
+/***/ 140:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const { encode, decode } = __webpack_require__( 5744 );
+const startQuery = __webpack_require__( 5723 );
+const getResults = __webpack_require__( 7337 );
+
+const getQueryExecutionId = async ( { client, nativeArgs, recursive, paginationToken } ) => {
+  if ( !recursive && paginationToken ) {
+    const { queryExecutionId, token } = 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
+ */
+module.exports = 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 ? encode( { queryExecutionId, token: nextToken } ) : undefined, items };
+};
+
+
+/***/ }),
+
+/***/ 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: {} } );
+    }
+
+    Object.defineProperty( global[cacheSym], keySym, { ...propOpts, value } );
+  },
+  get: key => {
+    return global[cacheSym]?.[Symbol.for( hash( key ) )];
+  }
+};
+
+
+/***/ }),
+
+/***/ 5438:
+/***/ ((module) => {
+
+/**
+ * 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 ) } ), { } );
+  };
+
+  // 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;
+    }
+  } );
+};
+
+
+/***/ }),
+
+/***/ 5744:
+/***/ ((module) => {
+
+module.exports = {
+  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;
+    }
+  }
+};
+
+
+/***/ }),
+
+/***/ 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 );
+    // console.log( 'client', client );
+    // const client = new constructor( ...args );
+    cache.set( cacheKey, client );
+    return client;
+  } )();
+};
+
+
+/***/ }),
+
+/***/ 8593:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const { BatchWriteCommand } = __webpack_require__( 3489 );
+const splitBatches = __webpack_require__( 4821 );
+
+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 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 )
+  } );
+};
+
+module.exports = async ( client, method, table, items ) =>
+  process( { client, method, table, batches: splitBatches( items.map( getMapper( method ) ), batchSize ) } );
+
+
+/***/ }),
+
+/***/ 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 key = `Dynamodb(${JSON.stringify( nativeArgs )}).DocumentClient`;
+  return cache.get( key ) ?? ( () => {
+    const client = new DynamoDBClient( nativeArgs );
+    const docClient = DynamoDBDocumentClient.from( client, translateConfig );
+
+    cache.set( key, docClient );
+    return docClient;
+  } )();
+};
+
+
+/***/ }),
+
+/***/ 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];
+  }
+  // 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;
+};
+
+
+/***/ }),
+
+/***/ 1505:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+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 );
+
+const methods = {
+  get,
+  put,
+  putBatch,
+  query,
+  remove,
+  removeBatch,
+  scan,
+  smartUpdate,
+  transactWrite,
+  update
+};
+
+module.exports = createInstance( documentClientProvider, methods );
+
+
+/***/ }),
+
+/***/ 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];
+  }
+  // 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
+ */
+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__) => {
+
+const batchWrite = __webpack_require__( 8593 );
+
+module.exports = async ( client, ...args ) => batchWrite( client, 'put', ...args );
+
+
+/***/ }),
+
+/***/ 5265:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const select = __webpack_require__( 2157 );
+
+module.exports = async ( client, ...args ) => select( client, 'query', ...args );
+
+
+/***/ }),
+
+/***/ 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;
+};
+
+
+/***/ }),
+
+/***/ 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 );
+
+module.exports = async ( client, ...args ) => select( client, 'scan', ...args );
+
+
+/***/ }),
+
+/***/ 2157:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+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
+  };
+
+  if ( !recursive ) {
+    return { items: result.items, count: result.count, ...( result.startKey && { nextToken: encode( result.startKey ) } ) };
+  }
+
+  if ( result.startKey && ( isCount || ( hasLimit && result.items.length < args.Limit ) || ( !isCount && !hasLimit ) ) ) {
+    return 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 };
+};
+
+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 ) } );
+};
+
+
+/***/ }),
+
+/***/ 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 } );
+    }
+
+    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 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;
+  }
+};
+
+
+/***/ }),
+
+/***/ 1659:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const { TransactWriteCommand } = __webpack_require__( 3489 );
+
+module.exports = async ( client, items ) => {
+  const response = await client.send( new TransactWriteCommand( { TransactItems: items } ) );
+  return response;
+};
+
+
+/***/ }),
+
+/***/ 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;
+};
+
+
+/***/ }),
+
+/***/ 4870:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const athena = __webpack_require__( 228 );
+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,
+  dynamo,
+  lambda,
+  s3,
+  ses,
+  sns,
+  sqs,
+  ssm,
+  timestreamQuery,
+  timestreamWrite
+};
+
+
+/***/ }),
+
+/***/ 3544:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const invoke = __webpack_require__( 5894 );
+const { LambdaClient } = __webpack_require__( 5892 );
+const clientProvider = __webpack_require__( 9039 );
+const createInstance = __webpack_require__( 5438 );
+
+const methods = {
+  invoke
+};
+
+module.exports = createInstance( clientProvider.bind( null, LambdaClient ), methods );
+
+
+/***/ }),
+
+/***/ 5894:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const { InvokeCommand } = __webpack_require__( 5892 );
+const AWSLambdaError = __webpack_require__( 468 );
+
+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 ) )
+  } ) );
+
+  if ( response.FunctionError ) {
+    throw new AWSLambdaError( response );
+  }
+
+  if ( type !== 'RequestResponse' ) { return true; }
+
+  try {
+    return JSON.parse( Buffer.from( response.Payload ).toString() );
+  } catch {
+    return response.Payload;
+  }
+};
+
+
+/***/ }),
+
+/***/ 468:
+/***/ ((module) => {
+
+const parsePayload = payload => {
+  try {
+    return JSON.parse( Buffer.from( payload ).toString( 'utf-8' ) );
+  } catch {
+    return null;
+  }
+};
+
+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;
+  }
+};
+
+
+/***/ }),
+
+/***/ 3936:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const { CopyObjectCommand } = __webpack_require__( 5725 );
+
+module.exports = async ( client, bucket, key, source, nativeArgs ) => {
+  const response = await client.send( new CopyObjectCommand( {
+    ...nativeArgs,
+    Bucket: bucket,
+    Key: key,
+    CopySource: source
+  } ) );
+  return response;
+};
+
+
+/***/ }),
+
+/***/ 345:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const { GetObjectCommand } = __webpack_require__( 5725 );
+
+module.exports = async ( client, bucket, key, nativeArgs ) => {
+  const response = await client.send( new GetObjectCommand( {
+    ...nativeArgs,
+    Bucket: bucket,
+    Key: key
+  } ) );
+  const stream = response.Body;
+  return Buffer.concat( await stream.toArray() ).toString( 'utf-8' );
+};
+
+
+/***/ }),
+
+/***/ 3758:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const { getSignedUrl } = __webpack_require__( 4991 );
+const { GetObjectCommand } = __webpack_require__( 5725 );
+
+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;
+};
+
+
+/***/ }),
+
+/***/ 279:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const { HeadObjectCommand } = __webpack_require__( 5725 );
+
+module.exports = async ( client, bucket, key ) =>
+  client.send( new HeadObjectCommand( { Bucket: bucket, Key: key } ) );
+
+
+/***/ }),
+
+/***/ 645:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+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 );
+
+const methods = {
+  copy,
+  download,
+  getSignedUrl,
+  head,
+  upload
+};
+
+module.exports = createInstance( clientProvider.bind( null, S3Client ), methods );
+
+
+/***/ }),
+
+/***/ 9704:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const { PutObjectCommand } = __webpack_require__( 5725 );
+
+module.exports = ( client, bucket, key, body, nativeArgs ) =>
+  client.send( new PutObjectCommand( {
+    ...nativeArgs,
+    Bucket: bucket,
+    Key: key,
+    Body: typeof body === 'string' ? body : JSON.stringify( body )
+  } ) );
+
+
+/***/ }),
+
+/***/ 809:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const { DeleteSuppressedDestinationCommand } = __webpack_require__( 9556 );
+
+module.exports = ( client, address ) => client.send( new DeleteSuppressedDestinationCommand( { EmailAddress: address } ) );
+
+
+/***/ }),
+
+/***/ 5624:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+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 methods = {
+  deleteSuppressedDestination,
+  sendEmail
+};
+
+module.exports = createInstance( clientProvider.bind( null, SESv2Client ), methods );
+
+
+/***/ }),
+
+/***/ 1783:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+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
+  } ) );
+
+
+/***/ }),
+
+/***/ 3099:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const publish = __webpack_require__( 8080 );
+const { SNSClient } = __webpack_require__( 7651 );
+const clientProvider = __webpack_require__( 9039 );
+const createInstance = __webpack_require__( 5438 );
+
+const methods = {
+  publish
+};
+
+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;
+};
+
+
+/***/ }),
+
+/***/ 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
+};
+
+module.exports = createInstance( clientProvider.bind( null, SQSClient ), methods );
+
+
+/***/ }),
+
+/***/ 8175:
+/***/ ((module) => {
+
+/*
+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
+
+
+/***/ }),
+
+/***/ 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( {
+    ...args,
+    MessageBody: sanitizeSqs( typeof body === 'string' ? body : JSON.stringify( body ) ),
+    QueueUrl: queue
+  } ) );
+  return response.MessageId;
+};
+
+
+/***/ }),
+
+/***/ 3131:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const { SendMessageBatchCommand } = __webpack_require__( 1976 );
+const sanitizeSqs = __webpack_require__( 8175 );
+
+module.exports = async ( client, queue, messages ) => {
+  if ( messages.length > 10 ) {
+    throw new Error( 'SQS.sendMessageBatch only accepts up to then messages.' );
+  }
+  const response = await client.send( new SendMessageBatchCommand( {
+    QueueUrl: queue,
+    Entries: messages.map( ( { body, id = null, ...args }, index ) => ( {
+      ...args,
+      Id: id ?? `message_${index}`,
+      MessageBody: sanitizeSqs( typeof body === 'string' ? body : JSON.stringify( body ) )
+    } ) )
+  } ) );
+
+  if ( response.Failed?.length > 0 ) {
+    const error = new Error( 'SQS.sendMessageBatch Failed. See error details' );
+    error.details = response.Failed;
+    throw error;
+  }
+  return response;
+};
+
+
+/***/ }),
+
+/***/ 8660:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const cacheStorage = __webpack_require__( 4164 );
+const { GetParameterCommand } = __webpack_require__( 4348 );
+
+module.exports = async ( client, name ) => {
+  const key = `SSM_${name}`;
+  const cacheValue = cacheStorage.get( key );
+  if ( cacheValue ) { return cacheValue; }
+
+  try {
+    const response = await client.send( new 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;
+  }
+};
+
+
+/***/ }),
+
+/***/ 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__( 3649 );
+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 );
+
+
+/***/ }),
+
+/***/ 7261:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+// 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 parseScalarValue = ( type, value ) => {
+  switch ( type ) {
+  case ScalarType.BOOLEAN:
+    return value === 'true';
+  case ScalarType.DOUBLE:
+    return parseFloat( value );
+  case ScalarType.TIMESTAMP:
+    return new Date( `${value.replace( ' ', 'T' )}Z` );
+  case ScalarType.INTEGER:
+    return parseInt( value, 10 );
+  case ScalarType.UNKNOWN: // is NULL
+    return null;
+  case ScalarType.VARCHAR:
+  case ScalarType.BIGINT:
+  case ScalarType.DATE:
+  case ScalarType.TIME:
+  case ScalarType.INTERVAL_DAY_TO_SECOND:
+  case ScalarType.INTERVAL_YEAR_TO_MONTH:
+  default:
+    return value;
+  }
+};
+
+const 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: parseValue( typeInfo.TimeSeriesMeasureValueColumnInfo.Type, v.Value )
+    } ) );
+  }
+
+  // maybe an array
+  if ( Object.hasOwn( typeInfo, 'ArrayColumnInfo' ) ) {
+    return datum.ArrayValue.map( v => 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]: parseValue( typeInfo, value ) } );
+    }, {} );
+  }
+
+  // if none, it is scalar
+  return parseScalarValue( typeInfo.ScalarType, datum['ScalarValue'] );
+};
+
+module.exports = 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 ) } );
+    }, { } )
+  );
+};
+
+
+/***/ }),
+
+/***/ 3649:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const { QueryCommand } = __webpack_require__( 1671 );
+const { camelize } = __webpack_require__( 5762 );
+const parseItems = __webpack_require__( 7261 );
+
+module.exports = async ( client, queryString, { paginationToken = undefined, maxRows = undefined, rawResponse = false } = {} ) => {
+  const response = await client.send( new QueryCommand( { QueryString: queryString, NextToken: paginationToken, MaxRows: maxRows } ) );
+  return rawResponse ? response : {
+    nextToken: response.NextToken,
+    count: response.Rows.length,
+    items: parseItems( response ),
+    queryStatus: camelize( response.QueryStatus )
+  };
+};
+
+
+/***/ }),
+
+/***/ 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 defaultArgs = {
+  maxRetries: 10,
+  httpOptions: { timeout: 60000, agent: new Agent( { maxSockets: 5000 } ) }
+};
+
+module.exports = createInstance( args => clientProvider( TimestreamWriteClient, [ Object.assign( {}, defaultArgs, args ) ] ), methods );
+
+
+/***/ }),
+
+/***/ 8936:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const { WriteRecordsCommand } = __webpack_require__( 8248 );
+
+module.exports = async ( client, { database, table, records, ignoreRejections = false } ) => {
+  try {
+    const response = await client.send( new WriteRecordsCommand( {
+      DatabaseName: database,
+      TableName: table,
+      Records: records
+    } ) );
+    return { recordsIngested: response.RecordsIngested };
+  } 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 string = __webpack_require__( 268 );
+const utils = __webpack_require__( 6878 );
+
+module.exports = {
+  array,
+  aws,
+  epoch,
+  LambdaApi,
+  math,
+  object,
+  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;
+  #body = '';
+
+  constructor( { headers = {}, transform } = {} ) {
+    this.#transformFn = transformFns[transform] ?? ( v => v );
+    this.#headers = Object.assign( {
+      'Cache-Control': 'no-store',
+      'Access-Control-Allow-Origin': '*'
+    }, headers );
+  }
+
+  setContent( statusCode, body, headers = {} ) {
+    this.#statusCode = statusCode;
+    if ( body?.length === 0 || [ null, undefined ].includes( body ) ) {
+      this.#body = '';
+    } else if ( typeof body === 'object' ) {
+      this.#body = JSON.stringify( this.#transformFn( body ) );
+      this.#headers['Content-Type'] = `application/json; charset=${charset}`;
+    } else {
+      this.#body = String( body );
+      this.#headers['Content-Type'] = `text/plain; charset=${charset}`;
+    }
+    this.#headers['Content-Length'] = this.#body.length;
+    Object.assign( this.#headers, headers ?? {} );
+    return this;
+  }
+
+  toJSON() {
+    return {
+      statusCode: this.#statusCode,
+      body: this.#body,
+      headers: this.#headers
+    };
+  }
+};
+
+
+/***/ }),
+
+/***/ 329:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const { camelize, snakelize } = __webpack_require__( 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;
+  headers;
+  method;
+  params;
+  path;
+  queryString;
+  route;
+
+  context = {};
+
+  constructor( { transform = false } = {} ) {
+    this.#transformFn = transformFns[transform] ?? ( v => v );
+  }
+
+  parseFromAwsEvent( awsEvent ) {
+    this[`parseFromAwsEventV${awsEvent.version !== '1.0' ? 2 : 1}`]( awsEvent );
+  }
+
+  parseFromAwsEventV1( awsEvent ) {
+    const {
+      body,
+      path,
+      resource,
+      httpMethod,
+      requestContext,
+      pathParameters,
+      headers,
+      multiValueHeaders,
+      queryStringParameters,
+      multiValueQueryStringParameters: multiValueQueryString
+    } = awsEvent;
+
+    const unifiedHeaders = {
+      headers,
+      ...Object.fromEntries( Object.entries( multiValueHeaders ?? {} ).map( ( [ k, v ] ) => [ k, Array.isArray( v ) ? v.join( ',' ) : k ] ) )
+    };
+
+    const unifiedQueryString = {
+      queryStringParameters,
+      ...Object.fromEntries( Object.entries( multiValueQueryString ?? {} ).map( ( [ k, v ] ) => [ k, Array.isArray( v ) ? v.join( ',' ) : k ] ) )
+    };
+
+    this.authorizer = requestContext?.authorizer;
+    this.body = body ? this.#transformFn( parseJson( body ) ) : null;
+    this.headers = unifiedHeaders ?? {};
+    this.method = httpMethod;
+    this.params = this.#transformFn( pathParameters ) ?? {};
+    this.path = path;
+    this.queryString = this.#transformFn( unifiedQueryString ) ?? {};
+    this.route = resource;
+  }
+
+  parseFromAwsEventV2( awsEvent ) {
+    const {
+      body,
+      routeKey,
+      requestContext,
+      pathParameters,
+      headers,
+      queryStringParameters
+    } = awsEvent;
+
+    const { http: { method, path } } = requestContext;
+
+    this.authorizer = requestContext?.authorizer;
+    this.body = body ? this.#transformFn( parseJson( body ) ) : null;
+    this.headers = headers ?? {};
+    this.method = method;
+    this.params = this.#transformFn( pathParameters ) ?? {};
+    this.path = path;
+    this.queryString = this.#transformFn( queryStringParameters ) ?? {};
+    this.route = routeKey?.split( ' ' )[1].replace( /\/$/, '' );
+  }
+};
+
+
+/***/ }),
+
+/***/ 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 } );
+  }
+
+  /**
+   * 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();
+    }
+  }
+};
+
+
+/***/ }),
+
+/***/ 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;
+
+    } else if ( args.statusCode ) {
+      validators.statusCode( args.statusCode );
+      this.values = [ args.statusCode, args.body, args.headers ];
+
+    } else if ( [ undefined, null ].includes( args ) ) {
+      this.values = [ 200 ];
+    } else {
+      throw new LambdaApiValidationError( Text.INVALID_USER_RESPONSE );
+    }
+  }
+};
+
+
+/***/ }),
+
+/***/ 8994:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const Text = __webpack_require__( 9760 );
+const LambdaApiValidationError = __webpack_require__( 3446 );
+
+const evaluate = ( condition, errorMessage ) => {
+  if ( !condition ) { throw new LambdaApiValidationError( errorMessage ); }
+};
+
+const isConstructor = v => {
+  try {
+    return !!Reflect.construct( new Proxy( v, {} ), [] );
+  } catch {
+    return false;
+  }
+};
+
+module.exports = {
+  errorType: v => evaluate( isConstructor( v ), Text.INVALID_ERROR_TYPE ),
+  function: v => evaluate( typeof v === 'function', Text.INVALID_FN ),
+  httpMethod: v => evaluate( [ 'DELETE', 'GET', 'HEAD', 'PATCH', 'POST', 'PUT' ].includes( v ), Text.INVALID_METHOD ),
+  matcherPath: v => evaluate( v === undefined || ( typeof v === 'string' && v.length > 0 ), Text.INVALID_MATCHER_PATH ),
+  matcherPathIncludes: v => evaluate( v === undefined || ( typeof v === 'string' && v.length > 0 ), Text.INVALID_MATCHER_PATH_INCLUDES ),
+  matcherPathMatch: v => evaluate( v === undefined || v?.constructor?.name === RegExp.name, Text.INVALID_MATCHER_PATH_MATCH ),
+  matcherPathNotIncludes: v => evaluate( v === undefined || ( typeof v === 'string' && v.length > 0 ), Text.INVALID_MATCHER_PATH_NOT_INCLUDES ),
+  matcherRoute: v => evaluate( v === undefined || ( typeof v === 'string' && v.length > 0 ), Text.INVALID_MATCHER_ROUTE ),
+  matcherRouteIncludes: v => evaluate( v === undefined || ( typeof v === 'string' && v.length > 0 ), Text.INVALID_MATCHER_ROUTE_INCLUDES ),
+  matcherRouteMatch: v => evaluate( v === undefined || v?.constructor?.name === RegExp.name, Text.INVALID_MATCHER_ROUTE_MATCH ),
+  matcherRouteNotIncludes: v => evaluate( v === undefined || ( typeof v === 'string' && v.length > 0 ), Text.INVALID_MATCHER_ROUTE_NOT_INCLUDES ),
+  statusCode: v => evaluate( typeof v === 'number' && /^[1-5]\d\d$/.test( String( v ) ), Text.INVALID_STATUS_CODE ),
+  transformRequest: v => evaluate( [ 'camelcase', 'snakecase', null, false ].includes( v ), Text.INVALID_TRANSFORM_REQUEST ),
+  transformResponse: v => evaluate( [ 'camelcase', 'snakecase', null, false ].includes( v ), Text.INVALID_TRANSFORM_RESPONSE )
+};
+
+
+/***/ }),
+
+/***/ 4124:
+/***/ ((module) => {
+
+module.exports = values => values.reduce( ( sum, value ) => sum + value, 0 ) / values.length;
+
+
+/***/ }),
+
+/***/ 3187:
+/***/ ((module) => {
+
+module.exports = values => {
+  //Sort bug: https://www.tutorialrepublic.com/faq/how-to-sort-an-array-of-integers-correctly-in-javascript.php
+  const sorted = values.slice().sort( ( a, b ) => a - b );
+  const evenArray = values.length % 2 === 0;
+  const midIndex = Math.floor( values.length / 2 );
+  return evenArray ? ( sorted[midIndex - 1] + sorted[midIndex] ) / 2 : sorted[midIndex];
+};
+
+
+/***/ }),
+
+/***/ 4692:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const calcMedian = __webpack_require__( 3187 );
+
+module.exports = pop => {
+  const center = calcMedian( pop );
+  return calcMedian( pop.map( v => Math.abs( v - center ) ) );
+};
+
+
+/***/ }),
+
+/***/ 2736:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const calcMean = __webpack_require__( 4124 );
+
+module.exports = values => {
+  const mean = calcMean( values );
+  const squareDiffs = values.map( value => Math.pow( value - mean, 2 ) );
+  const avgSquareDiff = calcMean( squareDiffs );
+  return Math.sqrt( avgSquareDiff );
+};
+
+
+/***/ }),
+
+/***/ 6089:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const calcMean = __webpack_require__( 4124 );
+
+module.exports = values => {
+  if ( values.length < 2 ) { return NaN; }
+
+  const mean = calcMean( values );
+  const squareDiffs = values.map( value => Math.pow( value - mean, 2 ) );
+  const avgSquareDiff = squareDiffs.reduce( ( sum, v ) => sum + v, 0 ) / ( values.length - 1 );
+  return Math.sqrt( avgSquareDiff );
+};
+
+
+/***/ }),
+
+/***/ 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 ) => {
+  if ( !isFinite( n ) || typeof n !== 'number' ) { return NaN; }
+
+  const m = Math.pow( 10, d );
+  const num = +( n * m ).toFixed( 8 ); // Avoid rounding errors
+  const i = Math.floor( num );
+  const f = num - i;
+  const e = 1e-8; // Allow for rounding errors in f
+  const r = ( f > 0.5 - e && f < 0.5 + e ) ? // eslint-disable-line no-nested-ternary
+    ( ( i % 2 === 0 ) ? i : i + 1 ) : Math.round( num );
+  return r / m;
+};
+
+
+/***/ }),
+
+/***/ 115:
+/***/ ((module) => {
+
+module.exports = ( n, d = 2 ) => Math.round( n * ( 10 ** d ) ) / ( 10 ** d );
+
+
+/***/ }),
+
+/***/ 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 snakelize = __webpack_require__( 7572 );
+
+module.exports = {
+  camelize,
+  filterProps,
+  snakelize
+};
+
+
+/***/ }),
+
+/***/ 8864:
+/***/ ((module) => {
+
+module.exports = obj =>
+  typeof obj === 'object' &&
+  obj !== null &&
+  !( obj instanceof String ) &&
+  !( obj instanceof Number ) &&
+  !( obj instanceof Boolean ) &&
+  !( obj instanceof Date );
+
+
+/***/ }),
+
+/***/ 7572:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+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 );
+
+
+/***/ }),
+
+/***/ 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 );
+
+
+/***/ }),
+
+/***/ 3258:
+/***/ ((module) => {
+
+module.exports = input =>
+  // Break the string into sequences to rebuild later
+  !input ? input : input.split( /\s/ )
+    // ALL_CAPS terms are ignored
+    .map( term => [ term, term.charAt( 0 ).toUpperCase() + term.slice( 1 ).toLowerCase() ] )
+    // Rebuild the string replacing the converter terms keeping the original delimiters
+    .reduce( ( result, [ term, repl ] ) => result.replace( term, repl ), input );
+
+
+/***/ }),
+
+/***/ 268:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const camelize = __webpack_require__( 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__) => {
+
+const sleep = __webpack_require__( 2445 );
+
+const execWithRetry = async ( closure, { limit, delay, retryHook, execCount = 0 } ) => {
+  if ( !( closure instanceof Function ) ) {
+    throw new Error( 'Closure is not a function' );
+  }
+
+  try {
+    return await closure();
+  } catch ( error ) {
+    // exhausted
+    if ( execCount === limit ) { throw error; }
+
+    // async retry hook to check if it should retry or give up and throw
+    if ( retryHook instanceof Function ) {
+      try {
+        const retry = await retryHook( error, execCount );
+        if ( retry === false ) { return false; }
+
+      // Hook errors break the flow
+      } catch ( hookError ) {
+        console.debug( hookError );
+        throw hookError;
+      }
+    }
+
+    // if there is no hook back-off and retry
+    if ( delay > 0 ) {
+      await sleep( delay ** ( 1 + execCount ) );
+    }
+    return execWithRetry( closure, { limit, delay, retryHook, execCount: execCount + 1 } );
+  }
+};
+
+/**
+ *
+ * @param {Function} closure A self contained function that will be invoked
+ * @param {Object} config
+ * @param {Number} limit The max number of retries
+ * @param {Number} delay The delay between each retry (it will be multiplied by the number of retries, so, it is linear back-off)
+ * @param {Function} retryHook A function to be called every-time a retry is needed.
+ *                             If this functions returns false, the retry error is raised
+ *                             If this functions throws error, the thrown error is raised
+ * @returns {Any} The closure result
+ */
+module.exports = async ( closure, { limit = 0, delay = 0, retryHook = null } = {} ) =>
+  execWithRetry( closure, { limit, delay, retryHook } );
+
+
+/***/ }),
+
+/***/ 2445:
+/***/ ((module) => {
+
+module.exports = t => new Promise( r => setTimeout( r, t ) );
+
+
+/***/ }),
+
+/***/ 9651:
+/***/ ((module) => {
+
+module.exports = class Timer {
+  #startedAt;
+  #stoppedAt = null;
+  #running = false;
+
+  get elapsed() {
+    if ( this.#running ) {
+      return Date.now() - this.#startedAt;
+    } else if ( !this.#startedAt ) {
+      return 0;
+    } else {
+      return this.#stoppedAt - this.#startedAt;
+    }
+  }
+
+  get running() {
+    return this.#running;
+  }
+
+  start() {
+    if ( !this.#running ) {
+      this.#startedAt = Date.now();
+      this.#running = true;
+    }
+    return this;
+  }
+
+  restart() {
+    this.#running = true;
+    this.#startedAt = Date.now();
+    return this;
+  }
+
+  stop() {
+    if ( this.#running ) {
+      this.#running = false;
+      this.#stoppedAt = Date.now();
+    }
+    return this.#stoppedAt - this.#startedAt;
+  }
+};
+
+
+/***/ }),
+
+/***/ 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 ) ) );
+
+/**
+ * Decompress JSON
+ *
+ * Reads a gzipped tarball (.tar.gz)
+ * 1. Unzip it
+ * 2. Convert all to utf-8
+ * 3. Split files using the \0star separator
+ * 4. Trim files until JSON markup start/end ({})
+ * 5. JSON parse
+ *
+ * Enjoy this 100% native tarball decompression!
+ */
+module.exports = raw =>
+  unzipSync( raw )
+    .toString( 'utf-8' )
+    .split( '\0ustar' )
+    .slice( 1 )
+    .map( c =>
+      JSON.parse( c.substring( firstIndexOf( c, '{', '[' ), lastIndexOf( c, '}', ']' ) + 1 ) )
+    );
+
+
+/***/ }),
+
+/***/ 3744:
+/***/ ((module) => {
+
+module.exports = require("@aws-sdk/client-athena");
+
+/***/ }),
+
+/***/ 4671:
+/***/ ((module) => {
+
+module.exports = require("@aws-sdk/client-dynamodb");
+
+/***/ }),
+
+/***/ 5892:
+/***/ ((module) => {
+
+module.exports = require("@aws-sdk/client-lambda");
+
+/***/ }),
+
+/***/ 5725:
+/***/ ((module) => {
+
+module.exports = require("@aws-sdk/client-s3");
+
+/***/ }),
+
+/***/ 9556:
+/***/ ((module) => {
+
+module.exports = require("@aws-sdk/client-sesv2");
+
+/***/ }),
+
+/***/ 7651:
+/***/ ((module) => {
+
+module.exports = require("@aws-sdk/client-sns");
+
+/***/ }),
+
+/***/ 1976:
+/***/ ((module) => {
+
+module.exports = require("@aws-sdk/client-sqs");
+
+/***/ }),
+
+/***/ 4348:
+/***/ ((module) => {
+
+module.exports = require("@aws-sdk/client-ssm");
+
+/***/ }),
+
+/***/ 1671:
+/***/ ((module) => {
+
+module.exports = require("@aws-sdk/client-timestream-query");
+
+/***/ }),
+
+/***/ 8248:
+/***/ ((module) => {
+
+module.exports = require("@aws-sdk/client-timestream-write");
+
+/***/ }),
+
+/***/ 3489:
+/***/ ((module) => {
+
+module.exports = require("@aws-sdk/lib-dynamodb");
+
+/***/ }),
+
+/***/ 4991:
+/***/ ((module) => {
+
+module.exports = require("@aws-sdk/s3-request-presigner");
+
+/***/ }),
+
+/***/ 6982:
+/***/ ((module) => {
+
+module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("crypto");
+
+/***/ }),
+
+/***/ 5692:
+/***/ ((module) => {
+
+module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("https");
+
+/***/ }),
+
+/***/ 3106:
+/***/ ((module) => {
+
+module.exports = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("zlib");
+
+/***/ })
+
+/******/ });
+/************************************************************************/
+/******/ // The module cache
+/******/ var __webpack_module_cache__ = {};
+/******/ 
+/******/ // The require function
+/******/ function __webpack_require__(moduleId) {
+/******/ 	// Check if module is in cache
+/******/ 	var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 	if (cachedModule !== undefined) {
+/******/ 		return cachedModule.exports;
+/******/ 	}
+/******/ 	// Create a new module (and put it into the cache)
+/******/ 	var module = __webpack_module_cache__[moduleId] = {
+/******/ 		// no module.id needed
+/******/ 		// no module.loaded needed
+/******/ 		exports: {}
+/******/ 	};
+/******/ 
+/******/ 	// Execute the module function
+/******/ 	__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 
+/******/ 	// Return the exports of the module
+/******/ 	return module.exports;
+/******/ }
+/******/ 
+/************************************************************************/
+/******/ 
+/******/ // startup
+/******/ // Load entry module and return exports
+/******/ // This entry module is referenced by other modules so it can't be inlined
+/******/ var __webpack_exports__ = __webpack_require__(44);
+/******/ module.exports = __webpack_exports__;
+/******/