class WasiMemoryManager {
  constructor (memory, malloc, free) {
    this.memory = memory
    this.malloc = malloc
    this.free = free
  }

  // Convert a pointer from the wasm module to JavaScript string.
  convertToString (ptr, length) {
    try {
      // The pointer is a multi byte character array encoded with utf-8.
      const array = new Uint8Array(this.memory.buffer, ptr, length)
      const decoder = new TextDecoder()
      const string = decoder.decode(array)
      return string
    } finally {
      // Free the memory sent to use from the WebAssembly instance.
      this.free(ptr)
    }
  }

  // Convert a JavaScript string to a pointer to multi byte character array
  convertFromString(string) {
    // Encode the string in utf-8.
    const encoder = new TextEncoder()
    const bytes = encoder.encode(string)
    // Copy the string into memory allocated in the WebAssembly
    const ptr = this.malloc(bytes.byteLength)
    const buffer = new Uint8Array(this.memory.buffer, ptr, bytes.byteLength + 1)
    buffer.set(bytes)
    return buffer
  }
}

const res = await WebAssembly.instantiate(buf, {
  wasi_snapshot_preview1: wasi,
})

const WasiMemoryManager = require('./wasi-memory-manager')

// An implementation of WASI which supports the minimum
// required to use multi byte characters.
class Wasi {
  constructor (env) {
    this.env = env
    this.instance = null
    this.wasiMemoryManager = null
  }

  // Initialise the instance from the WebAssembly.
  init = (instance) => {
    this.instance = instance
    this.wasiMemoryManager = new WasiMemoryManager(
      instance.exports.memory,
      instance.exports.malloc,
      instance.exports.free
    )
  }

  static WASI_ESUCCESS = 0

  // Get the environment variables.
  environ_get = (environ, environBuf) => {
    const encoder = new TextEncoder()
    const view = new DataView(this.wasiMemoryManager.memory.buffer)

    Object.entries(this.env).map(
      ([key, value]) => `${key}=${value}`
    ).forEach(envVar => {
      view.setUint32(environ, environBuf, true)
      environ += 4

      const bytes = encoder.encode(envVar)
      const buf = new Uint8Array(this.wasiMemoryManager.memory.buffer, environBuf, bytes.length + 1)
      environBuf += buf.byteLength
    });
    return this.WASI_ESUCCESS;
  }
  
  // Get the size required to store the environment variables.
  environ_sizes_get = (environCount, environBufSize) => {
    const encoder = new TextEncoder()
    const view = new DataView(this.wasiMemoryManager.memory.buffer)

    const envVars = Object.entries(this.env).map(
      ([key, value]) => `${key}=${value}`
    )
    const size = envVars.reduce(
      (acc, envVar) => acc + encoder.encode(envVar).byteLength + 1,
      0
    )
    view.setUint32(environCount, envVars.length, true)
    view.setUint32(environBufSize, size, true)

    return this.WASI_ESUCCESS
  }

  // This gets called on exit to stop the running program.
  // We don't have anything to stop!
  proc_exit = (rval) => {
    return this.WASI_ESUCCESS
  }
}

module.exports = Wasi

const fs = require('fs')
const Wasi = require('./wasi')

async function setupWasi(fileName) {
  // Read the wasm file.
  const buf = fs.readFileSync(fileName)

  // Create the Wasi instance passing in some environment variables.
  const wasi = new Wasi({
    "LANG": "en_GB.UTF-8",
    "TERM": "xterm"
  })

  // Instantiate the wasm module.
  const res = await WebAssembly.instantiate(buf, {
    wasi_snapshot_preview1: wasi,
    env: {
      // This function is exported to the web assembly.
      consoleLog: function(ptr, length) {
        // This converts the pointer to a string and frees he memory.
        const string = wasi.wasiMemoryManager.convertToString(ptr, length)
        console.log(string)
      }
    }
  })

  // Initialise the wasi instance
  wasi.init(res.instance)

  return wasi
}

module.exports = setupWasi

const setupWasi = require('./setup-wasi')

async function main() {
  // Setup the WASI instance.
  const wasi = await setupWasi('./string-example.wasm')

  // Get the functions exported from the WebAssembly
  const {
    countLetters,
    sayHelloWorld,
    sayHelloWorldInMandarin
  } = wasi.instance.exports

  let buf1 = null
  try {
    const s1 = '犬 means dog'
    // Convert the JavaScript string into a pointer in the WebAssembly
    buf1 = wasi.wasiMemoryManager.convertFromString(s1)
    // The Chinese character will take up more than one byte.
    const l1 = countLetters(buf1.byteOffset)
    console.log(`expected length ${s1.length} got ${l1} byte length was ${buf1.byteLength}`)
  } finally {
    // Free the pointer we created in WebAssembly.
    wasi.wasiMemoryManager.free(buf1)
  }

  // Should log "Hello, World!" to the console
  sayHelloWorld()
  sayHelloWorldInMandarin()
}

main().then(() => console.log('Done'))

const s1 = new Series('height', [1.82, 1.73, 1.69, 1.92], 'double')

import arrayMethods from './array-methods'

export class Series {
  constructor (name, array, type) {
    this.name = name
    this.array = array
    this.type = type

    return new Proxy(this, {
      get: (obj, prop, receiver) => {
        if (prop in obj) {
          // This is a known property: i.e. name, array or type.
          return Reflect.get(obj, prop, receiver)
        } else if (arrayMethods.has(prop)) {
          // The property is an operator.
          return (...args) => new Series('', ...arrayMethods.get(prop)(obj, ...args))
        } else {
          // The property requested is passed to the array.
          return Reflect.get(obj.array, prop, receiver.array)
        }
      },
      set: (obj, prop, value, receiver) => {
        if (prop in obj) {
          return Reflect.set(obj, prop, value, receiver)
        } else {
          return Reflect.set(obj.array, prop, value, receiver.array)
        }
      },
      apply: (target, thisArgument, argumentList) => {
        return Reflect.apply(target, thisArgument, argumentList)
      },
      // construct: Reflect.construct,
      defineProperty: Reflect.defineProperty,
      getOwnPropertyDescriptor: Reflect.getOwnPropertyDescriptor,
      deleteProperty: Reflect.deleteProperty,
      getPrototypeOf: Reflect.getPrototypeOf,
      setPrototypeOf: Reflect.setPrototypeOf,
      isExtensible: Reflect.isExtensible,
      preventExtensions: Reflect.preventExtensions,
      has: Reflect.has,
      ownKeys: Reflect.ownKeys
    })
  }

  toString () {
    return `(${this.name};${this.type}): ${this.array.join(', ')}`
  }
}

import arrayMethods from './array-methods'

return new Proxy(this, {
  get: (obj, prop, receiver) => {
    if (prop in obj) {
      return Reflect.get(obj, prop, receiver)
    } else if (arrayMethods.has(prop)) {
      return (...args) => new Series('', ...arrayMethods.get(prop)(obj, ...args))
    } else {
      return Reflect.get(obj.array, prop, receiver.array)
    }
  },
  ...
}

import { Series } from './Series'

export class DataFrame {
  constructor (series) {
    this.series = {}
    for (const item of series) {
      this.series[item.name] = item
    }

    return new Proxy(this, {
      get: (obj, prop, receiver) => {
        return prop in obj ? Reflect.get(obj, prop, receiver) : Reflect.get(obj.series, prop, receiver.series)
      },
      set: (obj, prop, value, receiver) => {
        if (prop in obj) {
          Reflect.set(obj, prop, value, receiver)
        } else {
          value.name = prop
          return Reflect.set(obj.series, prop, value, receiver.series)
        }
      },
      apply: (target, thisArgument, argumentList) => {
        return target in thisArgument ? Reflect.apply(target, thisArgument, argumentList) : Reflect.apply(target, thisArgument.array, argumentList)
      },
      defineProperty: Reflect.defineProperty,
      getOwnPropertyDescriptor: Reflect.getOwnPropertyDescriptor,
      deleteProperty: Reflect.deleteProperty,
      getPrototypeOf: Reflect.getPrototypeOf,
      setPrototypeOf: Reflect.setPrototypeOf,
      isExtensible: Reflect.isExtensible,
      preventExtensions: Reflect.preventExtensions,
      has: Reflect.has,
      ownKeys: Reflect.ownKeys
    })
  }

  static fromObject (data, types) {
    const series = {}
    for (let i = 0; i < data.length; i++) {
      for (const column in data[i]) {
        if (!(column in series)) {
          series[column] = new Series(column, new Array(data.length), types[column])
        }
        series[column][i] = data[i][column]
      }
    }
    const seriesList = Object.values(series)
    return new DataFrame(seriesList)
  }

  toString () {
    const columns = Object.getOwnPropertyNames(this.series)
    let s = columns.join(', ') + '\n'
    const maxLength = Object.values(this.series)
      .map(x => x.length)
      .reduce((accumulator, currentValue) => Math.max(accumulator, currentValue), 0)
    for (let i = 0; i < maxLength; i++) {
      const row = []
      for (const column of columns) {
        if (i < this.series[column].length) {
          row.push(this.series[column][i])
        } else {
          row.push(null)
        }
      }
      s += row.join(', ') + '\n'
    }
    s += columns.map(column => this.series[column].type).join(', ') + '\n'
    return s
  }
}

const df = DataFrame.fromObject(
  [
    { col0: 'a', col1: 5, col2: 8.1 },
    { col0: 'b', col1: 6, col2: 3.2 }
  ],
  { col0: 'object', col1: 'int', col2: 'double'}
)

class ArrayMethods {
  constructor () {
    if (!ArrayMethods.instance) {
      this._methods = {}
      ArrayMethods.instance = this
    }

    return ArrayMethods.instance
  }

  set (name, method) {
    this._methods[name] = method
  }

  has (name) {
    return name in this._methods
  }

  get (name) {
    return this._methods[name]
  }
}

const instance = new ArrayMethods()
Object.freeze(instance)

export default instance

export class WasmFunctionManager {
  constructor (memory, allocateMemory, freeMemory) {
    this.memory = memory
    this.allocateMemory = allocateMemory
    this.freeMemory = freeMemory
  }

  createTypedArray (typedArrayType, length) {
    const typedArray = new typedArrayType(
      this.memory.buffer,
      this.allocateMemory(length * typedArrayType.BYTES_PER_ELEMENT),
      length)

    if (typedArray.byteOffset === 0) {
      throw new RangeError('Unable to allocate memory for typed array')
    }

    return typedArray
  }

  invokeUnaryFunction(func, array, typedArrayType) {
    let input = null
    let output = null

    try {
      input = this.createTypedArray(typedArrayType, array.length)
      input.set(array)

      output = new typedArrayType(
        this.memory.buffer,
        func(input.byteOffset, array.length),
        array.length
      )

      if (output.byteOffset === 0) {
        throw new RangeError('Failed to allocate memory')
      }

      const result = Array.from(output)

      return result
    } finally {
      // Ensure the memory gets freed.
      this.freeMemory(input.byteOffset)
      this.freeMemory(output.byteOffset)
    }
  }

  invokeBinaryFunction(func, lhs, rhs, typedArrayType) {
    if (lhs.length !== rhs.length) {
      throw new RangeError('Arrays must the the same length')
    }
    const length = lhs.length

    let input1 = null
    let input2 = null
    let output = null

    try {
      input1 = this.createTypedArray(typedArrayType, length)
      input2 = this.createTypedArray(typedArrayType, length)

      input1.set(lhs)
      input2.set(rhs)

      output = new typedArrayType(
        this.memory.buffer,
        func(input1.byteOffset, input2.byteOffset, length),
        length
      )

      if (output.byteOffset === 0) {
        throw new RangeError('Failed to allocate memory')
      }

      const result = Array.from(output)

      return result
    } finally {
      // Ensure the memory gets freed.
      this.freeMemory(input1.byteOffset)
      this.freeMemory(input2.byteOffset)
      this.freeMemory(output.byteOffset)
    }
  }
}

function chooseBestType(lhsType, rhsType) {
  if (lhsType === 'int' && rhsType == 'int') {
    return 'int'
  } else if (
    (lhsType === 'int' && rhsType === 'double') ||
    (lhsType === 'double' && rhsType === 'int')) {
    return 'double'
  } else {
    return 'object'
  }
}

function makeBinaryOperation(wasmFunctionManager, intFunc, doubleFunc, defaultFunc) {
  return (lhs, rhs) => {
    const bestType = chooseBestType(lhs.type, rhs.type)

    if (bestType === 'int') {
      const result =  wasmFunctionManager.invokeBinaryFunction(
        intFunc,
        lhs.array,
        rhs.array,
        Int32Array
      )
      return [result, bestType]
    } else if (bestType === 'double') {
      const result = wasmFunctionManager.invokeBinaryFunction(
        doubleFunc,
        lhs.array,
        rhs.array,
        Float64Array
      )
      return [result, bestType]
    } else {
      const result = defaultFunc(lhs, rhs)
      return [result, bestType]
    }
  }
}

export async function setupWasm () {
  // Read the wasm file.
  const buf = fs.readFileSync('./src-wasm/data-frame.wasm')

  // Instantiate the wasm module.
  const res = await WebAssembly.instantiate(buf, {})

  // Get the memory exports from the wasm instance.
  const {
    memory,
    allocateMemory,
    freeMemory,

    addInt32Arrays,
    addFloat64Arrays,
 
    // .. import the rest of the methods
  } = res.instance.exports

  const wasmFunctionManager = new WasmFunctionManager(memory, allocateMemory, freeMemory)

  // Register the add method.
  arrayMethods.set(
    Symbol.for('+'),
    makeBinaryOperation(
      wasmFunctionManager,
      addInt32Arrays,
      addFloat64Arrays,
      (lhs, rhs) => lhs.array.map((value, index) => value + rhs.array[index])
    )
  )

  // register the rest of the methods ...
}

import { DataFrame } from './DataFrame'
import { setupWasm } from './setup-wasm'

function example () {
  'operator-overloading enabled'

  const df = DataFrame.fromObject(
    [
      { col0: 'a', col1: 5, col2: 8.1 },
      { col0: 'b', col1: 6, col2: 3.2 }
    ],
    { col0: 'object', col1: 'int', col2: 'double'}
  )
  console.log(df.toString())
  df['col3'] = df['col1'] + df['col2']
  console.log(df.toString())
}

async function main () {
  await setupWasm()

  example()
}

// Run the async main function.
main().then(() => console.log('Done')).catch(error => console.error(error))

const df = DataFrame.fromObject(
  [
    { 'col0': 'a', 'col1': 5, 'col2': 8.1 },
    { 'col0': 'b', 'col1': 6, 'col2': 3.2 }
  ]
)

df['col3'] = df['col1'] + df['col2']

let s1 = new Series('height', [1.82, 1.76, 1.72, 1.89])

s1[0] === 1.82

let height = new Series('height', [1.82, 1.76, 1.72, 1.89])
let weight = new Series('weight', [81.3, 73.2, 68.9, 92.1])
let score = height / weight

let df = DataFrame([
  height,
  weight
])

export class Series {
  constructor (name, array) {
    this.name = name
    this.array = array

    return new Proxy(this, {
      get: (obj, prop, receiver) => {
        if (prop in obj) {
          return Reflect.get(obj, prop, receiver)
        } else {
          return Reflect.get(obj.array, prop, receiver.array)
        }
      },
      set: (obj, prop, value, receiver) => {
        if (prop in obj) {
          return Reflect.set(obj, prop, value, receiver)
        } else {
          return Reflect.set(obj.array, prop, value, receiver.array)
        }
      },
      apply: (target, thisArgument, argumentList) => {
        return Reflect.apply(target, thisArgument, argumentList)
      },
      defineProperty: Reflect.defineProperty,
      getOwnPropertyDescriptor: Reflect.getOwnPropertyDescriptor,
      deleteProperty: Reflect.deleteProperty,
      getPrototypeOf: Reflect.getPrototypeOf,
      setPrototypeOf: Reflect.setPrototypeOf,
      isExtensible: Reflect.isExtensible,
      preventExtensions: Reflect.preventExtensions,
      has: Reflect.has,
      ownKeys: Reflect.ownKeys
    })
  }

  [Symbol.for('+')] (other) {
    return new Series(
      `${this.name}+${other.name}`,
      this.array.map((value, index) => value + other.array[index])
    )
  }

  [Symbol.for('-')] (other) {
    return new Series(
      `${this.name}-${other.name}`,
      this.array.map((value, index) => value - other.array[index])
    )
  }

  [Symbol.for('*')] (other) {
    return new Series(
      `${this.name}*${other.name}`,
      this.array.map((value, index) => value * other.array[index])
    )
  }

  [Symbol.for('/')] (other) {
    return new Series(
      `${this.name}/${other.name}`,
      this.array.map((value, index) => value / other.array[index])
    )
  }

  toString () {
    return `(${this.name}): ${this.array.join(', ')}`
  }
}

import { Series } from './Series'

export class DataFrame {
  constructor (series) {
    this.series = {}
    for (const item of series) {
      this.series[item.name] = item
    }

    return new Proxy(this, {
      get: (obj, prop, receiver) => {
        return prop in obj ? Reflect.get(obj, prop, receiver) : Reflect.get(obj.series, prop, receiver.series)
      },
      set: (obj, prop, value, receiver) => {
        return prop in obj ? Reflect.set(obj, prop, value, receiver) : Reflect.set(obj.series, prop, value, receiver.series)
      },
      apply: (target, thisArgument, argumentList) => {
        return target in thisArgument ? Reflect.apply(target, thisArgument, argumentList) : Reflect.apply(target, thisArgument.array, argumentList)
      },
      defineProperty: Reflect.defineProperty,
      getOwnPropertyDescriptor: Reflect.getOwnPropertyDescriptor,
      deleteProperty: Reflect.deleteProperty,
      getPrototypeOf: Reflect.getPrototypeOf,
      setPrototypeOf: Reflect.setPrototypeOf,
      isExtensible: Reflect.isExtensible,
      preventExtensions: Reflect.preventExtensions,
      has: Reflect.has,
      ownKeys: Reflect.ownKeys
    })
  }

  static fromObject (data) {
    const series = {}
    for (let i = 0; i < data.length; i++) {
      for (const column in data[i]) {
        if (!(column in series)) {
          series[column] = new Series(column, new Array(data.length))
        }
        series[column][i] = data[i][column]
      }
    }
    const seriesList = Object.values(series)
    return new DataFrame(seriesList)
  }

  toString () {
    const columns = Object.getOwnPropertyNames(this.series)
    let s = columns.join(', ') + '\n'
    const maxLength = Object.values(this.series)
      .map(x => x.length)
      .reduce((accumulator, currentValue) => Math.max(accumulator, currentValue), 0)
    for (let i = 0; i < maxLength; i++) {
      const row = []
      for (const column of columns) {
        if (i < this.series[column].length) {
          row.push(this.series[column][i])
        } else {
          row.push(null)
        }
      }
      s += row.join(', ') + '\n'
    }
    return s
  }
}

'operator-overloading enabled'

import { Series } from './Series'

const height = new Series('height', [1.82, 1.72, 1.64, 1.88])
const weight = new Series('weight', [81.4, 72.3, 69.9, 79.5])
const ratio = weight / height
console.log(ratio.toString())

> (weight/height): 44.72527472527473, 42.03488372093023, 42.6219512195122, 42.287234042553195

import { Series } from './Series'

const s1 = new Series('numbers', [1, 2, 3, 4])
s1.push(5)
console.log(s1.toString())

> (numbers): 1, 2, 3, 4, 5

'operator-overloading enabled'

import { DataFrame } from './DataFrame'

const df = DataFrame.fromObject(
  [
    { col0: 'a', col1: 5, col2: 8.1 },
    { col0: 'b', col1: 6, col2: 3.2 }
  ]
)
console.log(df.toString())
> col0, col1, col2
> a, 5, 8.1
> b, 6, 3.2

df['col3'] = df['col1'] + df['col2']
console.log(df.toString())
> col0, col1, col2, col3
> a, 5, 8.1, 13.1
> b, 6, 3.2, 9.2

const fs = require('fs')

async function main() {
  // Read the wasm file.
  const buf = fs.readFileSync('./example1.wasm')

  // Create a WebAssembly instance from the wasm.
  const res = await WebAssembly.instantiate(buf, {})
  
  // Get the function to call.
  const { addTwoInts } = res.instance.exports
  
  // Call the function.
  const a = 38, b = 4
  const result = addTwoInts(a, b)
  console.log(`${a} + ${b} =  ${result}`)
}

main().then(() => console.log('Done'))

const fs = require('fs')

async function main() {
  // Load the wasm into a buffer.
  const buf = fs.readFileSync('./example2.wasm')

  // Instantiate the wasm.
  const res = await WebAssembly.instantiate(buf, {})
  
  // Get the function out of the exports.
  const { sumArrayInt32, memory } = res.instance.exports
  
  // Create an array that can be passed to the WebAssembly instance.
  const array = new Int32Array(memory.buffer, 0, 5)
  array.set([3, 15, 18, 4, 2])

  // Call the function and display the results.
  const result = sumArrayInt32(array.byteOffset, array.length)
  console.log(`sum([${array.join(',')}]) = ${result}`)

  // This does the same thing!
  if (result == sumArrayInt32(0, 5)) {
    console.log(`Memory is an integer array starting at 0`)
  }
}

main().then(() => console.log('Done'))

const array = new Int32Array(memory.buffer, 0, 5)
array.set([3, 15, 18, 4, 2])

const result = sumArrayInt32(array.byteOffset, array.length)

const fs = require('fs')

async function main() {
  // Load the wasm into a buffer.
  const buf = fs.readFileSync('./example3.wasm')

  // Make an instance.
  const res = await WebAssembly.instantiate(buf, {})
  
  // Get function.
  const { addArraysInt32, memory } = res.instance.exports
  
  // Create the arrays.
  const length = 5

  let offset = 0
  const array1 = new Int32Array(memory.buffer, offset, length)
  array1.set([1, 2, 3, 4, 5])

  offset += length * Int32Array.BYTES_PER_ELEMENT
  const array2 = new Int32Array(memory.buffer, offset, length)
  array2.set([6, 7, 8, 9, 10])

  offset += length * Int32Array.BYTES_PER_ELEMENT
  const result = new Int32Array(memory.buffer, offset, length)

  // Call the function.
  addArraysInt32(
    array1.byteOffset,
    array2.byteOffset,
    result.byteOffset,
    length)
  
  // Show the results.
  console.log(`[${array1.join(", ")}] + [${array2.join(", ")}] = [${result.join(", ")}]`)
}

main().then(() => console.log('Done'))

offset += length * Int32Array.BYTES_PER_ELEMENT
const array2 = new Int32Array(memory.buffer, offset, length)

addArraysInt32(array1.byteOffset, array2.byteOffset, result.byteOffset, length)

const fs = require('fs')

async function main() {
  // Load the wasm into a buffer.
  const buf = fs.readFileSync('./example4.wasm')

  // Make the instance, importing a function called someFunction which
  // logs its arguments to the console.
  const res = await WebAssembly.instantiate(buf, {
    env: {
      someFunction: function (i) {
        console.log(`someFunction called with ${i}`)
      }
    }
  })
  
  // Get the exported function callSomeFunction from the wasm instance.
  const { callSomeFunction } = res.instance.exports

  // Calling the function should call back into the function we imported.
  callSomeFunction(42)
}

main().then(() => console.log('Done'))

const fs = require('fs')

/*
 * A simple memory manager.
 */
class MemoryManager {
  // The WebAssembly.Memory object for the instance.
  memory = null

  // Return the buffer length in bytes.
  memoryBytesLength() {
    return this.memory.buffer.byteLength
  }

  // Grow the memory by the requested blocks, returning the new buffer length
  // in bytes.
  grow(blocks) {
    this.memory.grow(blocks)
    return this.memory.buffer.byteLength
  }
}

async function main() {
  // Read the wasm file.
  const buf = fs.readFileSync('./example5.wasm')

  // Create an object to manage the memory.
  const memoryManager = new MemoryManager()

  // Instantiate the wasm module.
  const res = await WebAssembly.instantiate(buf, {
    env: {
      // The wasm module calls this function to grow the memory
      grow: function(blocks) {
        memoryManager.grow(blocks)
      },
      // The wasm module calls this function to get the current memory size.
      memoryBytesLength: function() {
        memoryManager.memoryBytesLength()
      }
    }
  })

  // Get the memory exports from the wasm instance.
  const {
    memory,
    allocateMemory,
    freeMemory,
    reportFreeMemory
  } = res.instance.exports

  // Give the memory manager access to the instances memory.
  memoryManager.memory = memory

  // How many free bytes are there?
  const startFreeMemoryBytes = reportFreeMemory()
  console.log(`There are ${startFreeMemoryBytes} bytes of free memory`)

  // Get the exported array function.
  const {
    addArrays
  } = res.instance.exports

  // Make the arrays to pass into the wasm function using allocateMemory.
  const length = 5
  const bytesLength = length * Int32Array.BYTES_PER_ELEMENT

  const array1 = new Int32Array(memory.buffer, allocateMemory(bytesLength), length)
  array1.set([1, 2, 3, 4, 5])

  const array2 = new Int32Array(memory.buffer, allocateMemory(bytesLength), length)
  array2.set([6, 7, 8, 9, 10])

  // Add the arrays. The result is the memory pointer to the result array.
  result = new Int32Array(
    memory.buffer,
    addArrays(array1.byteOffset, array2.byteOffset, length),
    length)

  console.log(`[${array1.join(", ")}] + [${array2.join(", ")}] = [${result.join(", ")}]`)

  // Show that some memory has been used.
  pctFree = 100 * reportFreeMemory() / startFreeMemoryBytes
  console.log(`Free memory ${pctFree}%`)

  // Free the memory.
  freeMemory(array1.byteOffset)
  freeMemory(array2.byteOffset)
  freeMemory(result.byteOffset)

  // Show that all the memory has been released.
  pctFree = 100 * reportFreeMemory() / startFreeMemoryBytes
  console.log(`Free memory ${pctFree}%`)
}

main().then(() => console.log('Done'))