/* eslint-disable no-alert */
/* eslint-disable prefer-rest-params */

/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */

import * as wasm from './index_bg.wasm'

const LTextDecoder
  = typeof TextDecoder === 'undefined'
    ? (0, module.require)('util').TextDecoder
    : TextDecoder

const cachedTextDecoder = new LTextDecoder('utf-8', {
  fatal: true,
  ignoreBOM: true,
})

cachedTextDecoder.decode()

let cachedUint8Memory0 = new Uint8Array()

function getUint8Memory0() {
  if (cachedUint8Memory0.byteLength === 0) {
    cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer)
  }

  return cachedUint8Memory0
}

function getStringFromWasm0(ptr, len) {
  return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len))
}

function logError(f, args) {
  try {
    return f.apply(this, args)
  }
  catch (e) {
    const error = (function () {
      try {
        return e instanceof Error
          ? `${e.message}\n\nStack:\n${e.stack}`
          : e.toString()
      }
      catch {
        return '<failed to stringify thrown value>'
      }
    })()
    console.error(
      'wasm-bindgen: imported JS function that was not marked as `catch` threw an error:',
      error,
    )
    throw e
  }
}

let WASM_VECTOR_LEN = 0

const LTextEncoder
  = typeof TextEncoder === 'undefined'
    ? (0, module.require)('util').TextEncoder
    : TextEncoder

const cachedTextEncoder = new LTextEncoder('utf-8')

const encodeString
  = typeof cachedTextEncoder.encodeInto === 'function'
    ? function (arg, view) {
      return cachedTextEncoder.encodeInto(arg, view)
    }
    : function (arg, view) {
      const buf = cachedTextEncoder.encode(arg)
      view.set(buf)
      return {
        read: arg.length,
        written: buf.length,
      }
    }

function passStringToWasm0(arg, malloc, realloc) {
  if (typeof arg !== 'string') {
    throw new TypeError('expected a string argument')
  }

  if (realloc === undefined) {
    const buf = cachedTextEncoder.encode(arg)
    const ptr = malloc(buf.length)
    getUint8Memory0()
      .subarray(ptr, ptr + buf.length)
      .set(buf)
    WASM_VECTOR_LEN = buf.length
    return ptr
  }

  let len = arg.length
  let ptr = malloc(len)

  const mem = getUint8Memory0()

  let offset = 0

  for (; offset < len; offset++) {
    const code = arg.charCodeAt(offset)
    if (code > 0x7F) {
      break
    }
    mem[ptr + offset] = code
  }

  if (offset !== len) {
    if (offset !== 0) {
      arg = arg.slice(offset)
    }

    ptr = realloc(ptr, len, (len = offset + arg.length * 3))
    const view = getUint8Memory0().subarray(ptr + offset, ptr + len)
    const ret = encodeString(arg, view)
    if (ret.read !== arg.length) {
      throw new Error('failed to pass whole string')
    }
    offset += ret.written
  }

  WASM_VECTOR_LEN = offset
  return ptr
}
/**
 * @param {string} name
 */
export function greet(name) {
  const ptr0 = passStringToWasm0(
    name,
    wasm.__wbindgen_malloc,
    wasm.__wbindgen_realloc,
  )
  const len0 = WASM_VECTOR_LEN
  wasm.greet(ptr0, len0)
}

export function __wbg_alert_9ea5a791b0d4c7a3() {
  return logError((arg0, arg1) => {
    alert(getStringFromWasm0(arg0, arg1))
  }, arguments)
}

export function __wbindgen_throw(arg0, arg1) {
  throw new Error(getStringFromWasm0(arg0, arg1))
}
