defmodule MyBench do
  def run do
    Benchee.run(
      %{
        "elixir" => fn -> Makeup.highlight(elixir_code(), language: "elixir") end,
        "javascript" => fn -> Makeup.highlight(javascript_code(), language: "javascript") end
      },
      time: 10,
      memory_time: 2
    )
  end

  defp elixir_code do
    ~S"""
    defmodule Phoenix.LiveView.AsyncResult do
      @moduledoc ~S'''
      Provides a data structure for tracking the state of an async assign.

      See the `Async Operations` section of the `Phoenix.LiveView` docs for more information.

      ## Fields

        * `:ok?` - When true, indicates the `:result` has been set successfully at least once.
        * `:loading` - The current loading state
        * `:failed` - The current failed state
        * `:result` - The successful result of the async task
      '''

      defstruct ok?: false,
                loading: nil,
                failed: nil,
                result: nil

      alias Phoenix.LiveView.AsyncResult

      @doc \"\"\"
      Creates an async result in loading state.

      ## Examples

          iex> result = AsyncResult.loading()
          iex> result.loading
          true
          iex> result.ok?
          false

      \"\"\"
      def loading do
        %AsyncResult{loading: true}
      end

      @doc \"\"\"
      Updates the loading state.

      When loading, the failed state will be reset to `nil`.

      ## Examples

          iex> result = AsyncResult.loading(%{my: :loading_state})
          iex> result.loading
          %{my: :loading_state}
          iex> result = AsyncResult.loading(result)
          iex> result.loading
          true

      \"\"\"
      def loading(%AsyncResult{} = result) do
        %{result | loading: true, failed: nil}
      end

      def loading(loading_state) do
        %AsyncResult{loading: loading_state, failed: nil}
      end
    end
    """
  end

  defp javascript_code do
    """
    const ARIA = {
      anyOf(instance, classes) {
        return classes.find((name) => instance instanceof name);
      },

      isFocusable(el, interactiveOnly) {
        return (
          (el instanceof HTMLAnchorElement && el.rel !== "ignore") ||
          (el instanceof HTMLAreaElement && el.href !== undefined) ||
          (!el.disabled &&
            this.anyOf(el, [
              HTMLInputElement,
              HTMLSelectElement,
              HTMLTextAreaElement,
              HTMLButtonElement,
            ])) ||
          el instanceof HTMLIFrameElement ||
          (el.tabIndex >= 0 && el.getAttribute("aria-hidden") !== "true") ||
          (!interactiveOnly &&
            el.getAttribute("tabindex") !== null &&
            el.getAttribute("aria-hidden") !== "true")
        );
      },

      attemptFocus(el, interactiveOnly) {
        if (this.isFocusable(el, interactiveOnly)) {
          try {
            el.focus();
          } catch {
            // that's fine
          }
        }
        return !!document.activeElement && document.activeElement.isSameNode(el);
      },

      focusFirstInteractive(el) {
        let child = el.firstElementChild;
        while (child) {
          if (this.attemptFocus(child, true) || this.focusFirstInteractive(child)) {
            return true;
          }
          child = child.nextElementSibling;
        }
      },

      focusFirst(el) {
        let child = el.firstElementChild;
        while (child) {
          if (this.attemptFocus(child) || this.focusFirst(child)) {
            return true;
          }
          child = child.nextElementSibling;
        }
      },

      focusLast(el) {
        let child = el.lastElementChild;
        while (child) {
          if (this.attemptFocus(child) || this.focusLast(child)) {
            return true;
          }
          child = child.previousElementSibling;
        }
      },
    };
    export default ARIA;
    """
  end
end