serverless-offline 11.6.0 → 12.0.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "dedicatedTo": "Blue, a great migrating bird.",
   "name": "serverless-offline",
-  "version": "11.6.0",
+  "version": "12.0.1",
   "description": "Emulate AWS λ and API Gateway locally when developing your Serverless project",
   "license": "MIT",
   "exports": {
@@ -82,15 +82,15 @@
     ]
   },
   "dependencies": {
-    "@aws-sdk/client-lambda": "^3.216.0",
+    "@aws-sdk/client-lambda": "^3.224.0",
     "@hapi/boom": "^10.0.0",
     "@hapi/h2o2": "^10.0.0",
-    "@hapi/hapi": "^21.0.0",
+    "@hapi/hapi": "^21.1.0",
     "@serverless/utils": "^6.8.2",
     "boxen": "^7.0.0",
     "chalk": "^5.1.2",
     "execa": "^6.1.0",
-    "fs-extra": "^10.1.0",
+    "fs-extra": "^11.1.0",
     "is-wsl": "^2.2.0",
     "java-invoke-local": "0.0.6",
     "jose": "^4.11.1",
@@ -98,7 +98,7 @@
     "jsonpath-plus": "^7.2.0",
     "jsonschema": "^1.4.1",
     "jszip": "^3.10.1",
-    "luxon": "^3.1.0",
+    "luxon": "^3.1.1",
     "node-fetch": "^3.3.0",
     "node-schedule": "^2.1.0",
     "object.hasown": "^1.1.2",
@@ -110,18 +110,18 @@
   "devDependencies": {
     "@istanbuljs/esm-loader-hook": "^0.2.0",
     "archiver": "^5.3.1",
-    "eslint": "^8.28.0",
+    "eslint": "^8.29.0",
     "eslint-config-airbnb-base": "^15.0.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-import": "^2.25.4",
     "eslint-plugin-prettier": "^4.2.1",
     "git-list-updated": "^1.2.1",
     "husky": "^8.0.2",
-    "lint-staged": "^13.0.3",
+    "lint-staged": "^13.1.0",
     "mocha": "^10.1.0",
     "nyc": "^15.1.0",
     "prettier": "^2.8.0",
-    "serverless": "^3.25.0",
+    "serverless": "^3.25.1",
     "standard-version": "^9.5.0"
   },
   "peerDependencies": {

package/src/ServerlessOffline.js

@@ -9,6 +9,8 @@ import {
 import { gray } from './config/colors.js'
 
 export default class ServerlessOffline {
+  #alb = null
+
   #cliOptions = null
 
   #http = null
@@ -62,6 +64,7 @@ export default class ServerlessOffline {
     this.#mergeOptions()
 
     const {
+      albEvents,
       httpEvents,
       httpApiEvents,
       lambdas,
@@ -75,6 +78,10 @@ export default class ServerlessOffline {
 
     const eventModules = []
 
+    if (albEvents.length > 0) {
+      eventModules.push(this.#createAlb(albEvents))
+    }
+
     if (httpApiEvents.length > 0 || httpEvents.length > 0) {
       eventModules.push(this.#createHttp([...httpApiEvents, ...httpEvents]))
     }
@@ -104,6 +111,10 @@ export default class ServerlessOffline {
       eventModules.push(this.#lambda.stop(SERVER_SHUTDOWN_TIMEOUT))
     }
 
+    if (this.#alb) {
+      eventModules.push(this.#alb.stop(SERVER_SHUTDOWN_TIMEOUT))
+    }
+
     if (this.#http) {
       eventModules.push(this.#http.stop(SERVER_SHUTDOWN_TIMEOUT))
     }
@@ -217,6 +228,20 @@ export default class ServerlessOffline {
     await this.#webSocket.start()
   }
 
+  async #createAlb(events, skipStart) {
+    const { default: Alb } = await import('./events/alb/index.js')
+
+    this.#alb = new Alb(this.#serverless, this.#options, this.#lambda)
+
+    await this.#alb.createServer()
+
+    this.#alb.create(events)
+
+    if (!skipStart) {
+      await this.#alb.start()
+    }
+  }
+
   #mergeOptions() {
     const {
       service: { custom = {}, provider },
@@ -263,6 +288,7 @@ export default class ServerlessOffline {
   #getEvents() {
     const { service } = this.#serverless
 
+    const albEvents = []
     const httpEvents = []
     const httpApiEvents = []
     const lambdas = []
@@ -274,12 +300,23 @@ export default class ServerlessOffline {
     functionKeys.forEach((functionKey) => {
       const functionDefinition = service.getFunction(functionKey)
 
-      lambdas.push({ functionDefinition, functionKey })
+      lambdas.push({
+        functionDefinition,
+        functionKey,
+      })
 
-      const events = service.getAllEventsInFunction(functionKey) || []
+      const events = service.getAllEventsInFunction(functionKey) ?? []
 
       events.forEach((event) => {
-        const { http, httpApi, schedule, websocket } = event
+        const { alb, http, httpApi, schedule, websocket } = event
+
+        if (alb) {
+          albEvents.push({
+            alb,
+            functionKey,
+            handler: functionDefinition.handler,
+          })
+        }
 
         if (http && functionDefinition.handler) {
           const httpEvent = {
@@ -369,6 +406,7 @@ export default class ServerlessOffline {
     })
 
     return {
+      albEvents,
       httpApiEvents,
       httpEvents,
       lambdas,

package/src/config/commandOptions.js

@@ -1,4 +1,8 @@
 export default {
+  albPort: {
+    type: 'string',
+    usage: 'ALB port to listen on. Default: 3003.',
+  },
   corsAllowHeaders: {
     type: 'string',
     usage:

package/src/config/defaultOptions.js

@@ -1,4 +1,5 @@
 export default {
+  albPort: 3003,
   corsAllowHeaders: 'accept,content-type,x-api-key,authorization',
   corsAllowOrigin: '*',
   corsDisallowCredentials: true,

package/src/events/alb/Alb.js

@@ -0,0 +1,56 @@
+import { log } from '@serverless/utils/log.js'
+import AlbEventDefinition from './AlbEventDefinition.js'
+import HttpServer from './HttpServer.js'
+
+export default class Alb {
+  #httpServer = null
+
+  #lambda = null
+
+  #options = null
+
+  #serverless = null
+
+  constructor(serverless, options, lambda) {
+    this.#lambda = lambda
+    this.#options = options
+    this.#serverless = serverless
+
+    log.warning(`
+Application Load Balancer (ALB) support in serverless-offline is experimental.
+Please file an issue for any bugs, missing features or other feedback: https://github.com/dherault/serverless-offline/issues
+    `)
+  }
+
+  start() {
+    return this.#httpServer.start()
+  }
+
+  stop(timeout) {
+    return this.#httpServer.stop(timeout)
+  }
+
+  async createServer() {
+    this.#httpServer = new HttpServer(
+      this.#serverless,
+      this.#options,
+      this.#lambda,
+    )
+
+    await this.#httpServer.createServer()
+  }
+
+  #createEvent(functionKey, rawAlbEventDefinition) {
+    const albEvent = new AlbEventDefinition(rawAlbEventDefinition)
+
+    this.#httpServer.createRoutes(functionKey, albEvent)
+  }
+
+  create(events) {
+    events.forEach(({ functionKey, alb }) => {
+      this.#createEvent(functionKey, alb)
+    })
+
+    this.#httpServer.writeRoutesTerminal()
+  }
+}

package/src/events/alb/AlbEventDefinition.js

@@ -0,0 +1,22 @@
+const { assign } = Object
+
+export default class AlbEventDefinition {
+  constructor(rawAlbEventDefinition) {
+    let listenerArn
+    let priority
+    let conditions
+    let rest
+
+    if (typeof rawAlbEventDefinition === 'string') {
+      ;[listenerArn, priority, conditions] = rawAlbEventDefinition.split(' ')
+    } else {
+      ;({ listenerArn, priority, conditions, ...rest } = rawAlbEventDefinition)
+    }
+
+    this.listenerArn = listenerArn
+    this.priority = priority
+    this.conditions = conditions
+
+    assign(this, rest)
+  }
+}

package/src/events/alb/HttpServer.js

@@ -0,0 +1,402 @@
+import { Buffer } from 'node:buffer'
+import { exit } from 'node:process'
+import { Server } from '@hapi/hapi'
+import { log } from '@serverless/utils/log.js'
+import {
+  detectEncoding,
+  generateAlbHapiPath,
+  getHttpApiCorsConfig,
+} from '../../utils/index.js'
+import LambdaAlbRequestEvent from './lambda-events/LambdaAlbRequestEvent.js'
+import logRoutes from '../../utils/logRoutes.js'
+
+const { stringify } = JSON
+const { entries } = Object
+
+export default class HttpServer {
+  #lambda = null
+
+  #options = null
+
+  #serverless = null
+
+  #server = null
+
+  #lastRequestOptions = null
+
+  #terminalInfo = []
+
+  constructor(serverless, options, lambda) {
+    this.#serverless = serverless
+    this.#options = options
+    this.#lambda = lambda
+  }
+
+  async createServer() {
+    const { host, albPort } = this.#options
+
+    const serverOptions = {
+      host,
+      port: albPort,
+      router: {
+        // allows for paths with trailing slashes to be the same as without
+        // e.g. : /my-path is the same as /my-path/
+        stripTrailingSlash: true,
+      },
+    }
+
+    this.#server = new Server(serverOptions)
+
+    this.#server.ext('onPreResponse', (request, h) => {
+      if (request.headers.origin) {
+        const response = request.response.isBoom
+          ? request.response.output
+          : request.response
+
+        const explicitlySetHeaders = {
+          ...response.headers,
+        }
+
+        if (
+          this.#serverless.service.provider.httpApi &&
+          this.#serverless.service.provider.httpApi.cors
+        ) {
+          const httpApiCors = getHttpApiCorsConfig(
+            this.#serverless.service.provider.httpApi.cors,
+            this,
+          )
+
+          if (request.method === 'options') {
+            response.statusCode = 204
+            const allowAllOrigins =
+              httpApiCors.allowedOrigins.length === 1 &&
+              httpApiCors.allowedOrigins[0] === '*'
+            if (
+              !allowAllOrigins &&
+              !httpApiCors.allowedOrigins.includes(request.headers.origin)
+            ) {
+              return h.continue
+            }
+          }
+
+          response.headers['access-control-allow-origin'] =
+            request.headers.origin
+          if (httpApiCors.allowCredentials) {
+            response.headers['access-control-allow-credentials'] = 'true'
+          }
+          if (httpApiCors.maxAge) {
+            response.headers['access-control-max-age'] = httpApiCors.maxAge
+          }
+          if (httpApiCors.exposedResponseHeaders) {
+            response.headers['access-control-expose-headers'] =
+              httpApiCors.exposedResponseHeaders.join(',')
+          }
+          if (httpApiCors.allowedMethods) {
+            response.headers['access-control-allow-methods'] =
+              httpApiCors.allowedMethods.join(',')
+          }
+          if (httpApiCors.allowedHeaders) {
+            response.headers['access-control-allow-headers'] =
+              httpApiCors.allowedHeaders.join(',')
+          }
+        } else {
+          response.headers['access-control-allow-origin'] =
+            request.headers.origin
+          response.headers['access-control-allow-credentials'] = 'true'
+
+          if (request.method === 'options') {
+            response.statusCode = 200
+
+            if (request.headers['access-control-expose-headers']) {
+              response.headers['access-control-expose-headers'] =
+                request.headers['access-control-expose-headers']
+            } else {
+              response.headers['access-control-expose-headers'] =
+                'content-type, content-length, etag'
+            }
+            response.headers['access-control-max-age'] = 60 * 10
+
+            if (request.headers['access-control-request-headers']) {
+              response.headers['access-control-allow-headers'] =
+                request.headers['access-control-request-headers']
+            }
+
+            if (request.headers['access-control-request-method']) {
+              response.headers['access-control-allow-methods'] =
+                request.headers['access-control-request-method']
+            }
+          }
+
+          // Override default headers with headers that have been explicitly set
+          entries(explicitlySetHeaders).forEach(([key, value]) => {
+            if (value) {
+              response.headers[key] = value
+            }
+          })
+        }
+      }
+      return h.continue
+    })
+  }
+
+  async start() {
+    const { host, albPort, httpsProtocol } = this.#options
+
+    try {
+      await this.#server.start()
+    } catch (err) {
+      log.error(
+        `Unexpected error while starting serverless-offline alb server on port ${albPort}:`,
+        err,
+      )
+      exit(1)
+    }
+
+    // TODO move the following block
+    const server = `${httpsProtocol ? 'https' : 'http'}://${host}:${albPort}`
+
+    log.notice(`ALB Server ready: ${server} 🚀`)
+  }
+
+  stop(timeout) {
+    return this.#server.stop({
+      timeout,
+    })
+  }
+
+  get server() {
+    return this.#server.listener
+  }
+
+  #createHapiHandler(params) {
+    const { functionKey, method, stage } = params
+
+    return async (request, h) => {
+      this.#lastRequestOptions = {
+        headers: request.headers,
+        method: request.method,
+        payload: request.payload,
+        url: request.url.href,
+      }
+
+      const requestPath = this.#options.noPrependStageInUrl
+        ? request.path
+        : request.path.substr(`/${stage}`.length)
+
+      // Payload processing
+      const encoding = detectEncoding(request)
+
+      request.payload = request.payload && request.payload.toString(encoding)
+      request.rawPayload = request.payload
+
+      // Incoming request message
+      log.notice()
+
+      log.notice()
+      log.notice(`${method} ${request.path} (λ: ${functionKey})`)
+
+      const response = h.response()
+
+      let event = {}
+      try {
+        event = new LambdaAlbRequestEvent(request, stage, requestPath).create()
+      } catch (err) {
+        return this.#reply502(response, ``, err)
+      }
+
+      log.debug('event:', event)
+
+      const lambdaFunction = this.#lambda.get(functionKey)
+
+      lambdaFunction.setEvent(event)
+
+      let result
+      let err
+
+      try {
+        result = await lambdaFunction.runHandler()
+      } catch (_err) {
+        err = _err
+      }
+
+      log.debug('_____ HANDLER RESOLVED _____')
+
+      // Failure handling
+      let errorStatusCode = '502'
+
+      if (err) {
+        const errorMessage = (err.message || err).toString()
+
+        const found = errorMessage.match(/\[(\d{3})]/)
+
+        if (found && found.length > 1) {
+          ;[, errorStatusCode] = found
+        } else {
+          errorStatusCode = '502'
+        }
+
+        // Mocks Lambda errors
+        result = {
+          errorMessage,
+          errorType: err.constructor.name,
+          stackTrace: this.#getArrayStackTrace(err.stack),
+        }
+
+        log.error(errorMessage)
+      }
+
+      let statusCode = 200
+
+      if (result && !result.errorType) {
+        statusCode = result.statusCode || 200
+      } else if (err) {
+        statusCode = errorStatusCode || 502
+      } else {
+        statusCode = 502
+      }
+
+      response.statusCode = statusCode
+
+      const headers = {}
+
+      if (result && result.headers) {
+        entries(result.headers).forEach(([headerKey, headerValue]) => {
+          headers[headerKey] = (headers[headerKey] || []).concat(headerValue)
+        })
+      }
+
+      if (result && result.multiValueHeaders) {
+        entries(result.multiValueHeaders).forEach(
+          ([headerKey, headerValue]) => {
+            headers[headerKey] = (headers[headerKey] || []).concat(headerValue)
+          },
+        )
+      }
+
+      log.debug('headers:', headers)
+
+      response.header('Content-Type', 'application/json', {
+        duplicate: false,
+        override: false,
+      })
+
+      if (typeof result === 'string') {
+        response.source = stringify(result)
+      } else if (result && result.body !== undefined) {
+        if (result.isBase64Encoded) {
+          response.encoding = 'binary'
+          response.source = Buffer.from(result.body, 'base64')
+          response.variety = 'buffer'
+        } else {
+          if (result && result.body && typeof result.body !== 'string') {
+            // FIXME TODO we should probably just write to console instead of returning a payload
+            return this.#reply502(
+              response,
+              'According to the API Gateway specs, the body content must be stringified. Check your Lambda response and make sure you are invoking JSON.stringify(YOUR_CONTENT) on your body object',
+              {},
+            )
+          }
+          response.source = result.body
+        }
+      }
+
+      return response
+    }
+  }
+
+  createRoutes(functionKey, albEvent) {
+    const method = albEvent.conditions.method[0].toUpperCase()
+    const path = albEvent.conditions.path[0]
+    const hapiPath = generateAlbHapiPath(path, this.#options, this.#serverless)
+
+    const stage = this.#options.stage || this.#serverless.service.provider.stage
+    const { host, albPort, httpsProtocol } = this.#options
+    const server = `${httpsProtocol ? 'https' : 'http'}://${host}:${albPort}`
+
+    this.#terminalInfo.push({
+      invokePath: `/2015-03-31/functions/${functionKey}/invocations`,
+      method,
+      path: hapiPath,
+      server,
+      stage: this.#options.noPrependStageInUrl ? null : stage,
+    })
+
+    const hapiMethod = method === 'ANY' ? '*' : method
+    const hapiOptions = {}
+
+    // skip HEAD routes as hapi will fail with 'Method name not allowed: HEAD ...'
+    // for more details, check https://github.com/dherault/serverless-offline/issues/204
+    if (hapiMethod === 'HEAD') {
+      log.notice(
+        'HEAD method event detected. Skipping HAPI server route mapping',
+      )
+
+      return
+    }
+
+    if (hapiMethod !== 'HEAD' && hapiMethod !== 'GET') {
+      // maxBytes: Increase request size from 1MB default limit to 10MB.
+      // Cf AWS API GW payload limits.
+      hapiOptions.payload = {
+        maxBytes: 1024 * 1024 * 10,
+        parse: false,
+      }
+    }
+
+    const hapiHandler = this.#createHapiHandler({
+      functionKey,
+      method,
+      stage,
+    })
+
+    this.#server.route({
+      handler: hapiHandler,
+      method: hapiMethod,
+      options: hapiOptions,
+      path: hapiPath,
+    })
+  }
+
+  #replyError(statusCode, response, message, error) {
+    log.notice(message)
+
+    log.error(error)
+
+    response.header('Content-Type', 'application/json')
+
+    response.statusCode = statusCode
+    response.source = {
+      errorMessage: message,
+      errorType: error.constructor.name,
+      offlineInfo:
+        'If you believe this is an issue with serverless-offline please submit it, thanks. https://github.com/dherault/serverless-offline/issues',
+      stackTrace: this.#getArrayStackTrace(error.stack),
+    }
+
+    return response
+  }
+
+  #reply502(response, message, error) {
+    // APIG replies 502 by default on failures;
+    return this.#replyError(502, response, message, error)
+  }
+
+  #getArrayStackTrace(stack) {
+    if (!stack) return null
+
+    const splittedStack = stack.split('\n')
+
+    return splittedStack
+      .slice(
+        0,
+        splittedStack.findIndex((item) =>
+          item.match(/server.route.handler.LambdaContext/),
+        ),
+      )
+      .map((line) => line.trim())
+  }
+
+  writeRoutesTerminal() {
+    logRoutes(this.#terminalInfo)
+  }
+}

package/src/events/alb/index.js

@@ -0,0 +1 @@
+export { default } from './Alb.js'

package/src/events/alb/lambda-events/LambdaAlbRequestEvent.js

@@ -0,0 +1,52 @@
+import {
+  parseMultiValueHeaders,
+  parseMultiValueQueryStringParameters,
+} from '../../../utils/index.js'
+
+const { fromEntries } = Object
+
+export default class LambdaAlbRequestEvent {
+  #path = null
+
+  #request = null
+
+  #stage = null
+
+  constructor(request, stage, path) {
+    this.#path = path
+    this.#request = request
+    this.#stage = stage
+  }
+
+  create() {
+    const { method } = this.#request
+    const { rawHeaders, url } = this.#request.raw.req
+    const httpMethod = method.toUpperCase()
+
+    const queryStringParameters = this.#request.url.search
+      ? fromEntries(Array.from(this.#request.url.searchParams))
+      : null
+
+    return {
+      body: this.#request.payload,
+      headers: this.#request.headers,
+      httpMethod,
+      isBase64Encoded: false,
+      multiValueHeaders: parseMultiValueHeaders(
+        // NOTE FIXME request.raw.req.rawHeaders can only be null for testing (hapi shot inject())
+        rawHeaders || [],
+      ),
+      multiValueQueryStringParameters:
+        parseMultiValueQueryStringParameters(url),
+      path: this.#path,
+      queryStringParameters,
+      requestContext: {
+        elb: {
+          targetGroupArn:
+            // TODO: probably replace this
+            'arn:aws:elasticloadbalancing:us-east-1:550213415212:targetgroup/5811b5d6aff964cd50efa8596604c4e0/b49d49c443aa999f',
+        },
+      },
+    }
+  }
+}

package/src/events/alb/lambda-events/index.js

@@ -0,0 +1 @@
+export { default } from './LambdaAlbRequestEvent.js'

package/src/events/http/HttpServer.js

@@ -828,6 +828,8 @@ export default class HttpServer {
 
         if (result && !result.errorType) {
           statusCode = result.statusCode || 200
+        } else if (err) {
+          statusCode = errorStatusCode || 502
         } else {
           statusCode = 502
         }

package/src/lambda/LambdaFunction.js

@@ -280,7 +280,7 @@ export default class LambdaFunction {
   async #timeoutAndTerminate() {
     await setTimeoutPromise(this.#timeout)
 
-    throw new LambdaTimeoutError('Lambda timeout.')
+    throw new LambdaTimeoutError('[504] - Lambda timeout.')
   }
 
   async runHandler() {

package/src/lambda/handler-runner/python-runner/PythonRunner.js

@@ -1,7 +1,7 @@
 import { spawn } from 'node:child_process'
 import { EOL, platform } from 'node:os'
 import { delimiter, dirname, join, relative, resolve } from 'node:path'
-import process, { cwd } from 'node:process'
+import process, { cwd, nextTick } from 'node:process'
 import { createInterface } from 'node:readline'
 import { fileURLToPath } from 'node:url'
 import { log } from '@serverless/utils/log.js'
@@ -99,7 +99,7 @@ export default class PythonRunner {
   // invoke.py, based on:
   // https://github.com/serverless/serverless/blob/v1.50.0/lib/plugins/aws/invokeLocal/invoke.py
   async run(event, context) {
-    return new Promise((accept, reject) => {
+    return new Promise((res, rej) => {
       const input = stringify({
         context,
         event,
@@ -117,18 +117,17 @@ export default class PythonRunner {
           if (parsed) {
             this.#handlerProcess.stdout.readline.removeListener('line', onLine)
             this.#handlerProcess.stderr.removeListener('data', onErr)
-            return accept(parsed)
+            res(parsed)
           }
-          return null
         } catch (err) {
-          return reject(err)
+          rej(err)
         }
       }
 
       this.#handlerProcess.stdout.readline.on('line', onLine)
       this.#handlerProcess.stderr.on('data', onErr)
 
-      process.nextTick(() => {
+      nextTick(() => {
         this.#handlerProcess.stdin.write(input)
         this.#handlerProcess.stdin.write('\n')
       })

package/src/utils/generateHapiPath.js

@@ -19,3 +19,32 @@ export default function generateHapiPath(path, options, serverless) {
 
   return hapiPath
 }
+
+export function generateAlbHapiPath(path, options, serverless) {
+  // path must start with '/'
+  let hapiPath = path.startsWith('/') ? path : `/${path}`
+
+  if (!options.noPrependStageInUrl) {
+    const stage = options.stage || serverless.service.provider.stage
+    // prepend the stage to path
+    hapiPath = `/${stage}${hapiPath}`
+  }
+
+  if (options.prefix) {
+    hapiPath = `/${options.prefix}${hapiPath}`
+  }
+
+  if (
+    hapiPath !== '/' &&
+    hapiPath.endsWith('/') &&
+    !options.noStripTrailingSlashInUrl
+  ) {
+    hapiPath = hapiPath.slice(0, -1)
+  }
+
+  for (let i = 0; hapiPath.includes('*'); i += 1) {
+    hapiPath = hapiPath.replace('*', `{${i}}`)
+  }
+
+  return hapiPath
+}

package/src/utils/index.js

@@ -16,7 +16,7 @@ export { default as parseMultiValueQueryStringParameters } from './parseMultiVal
 export { default as parseQueryStringParameters } from './parseQueryStringParameters.js'
 export { default as parseQueryStringParametersForPayloadV2 } from './parseQueryStringParametersForPayloadV2.js'
 export { default as splitHandlerPathAndName } from './splitHandlerPathAndName.js'
-
+export { generateAlbHapiPath } from './generateHapiPath.js'
 // export { default as baseImage } from './baseImage.js'
 
 const { isArray } = Array