;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2014 John Darrington <jmd@gnu.org>
;;; Copyright © 2014 Mark H Weaver <mhw@netris.org>
;;; Copyright © 2015, 2016 Efraim Flashner <efraim@flashner.co.il>
;;; Copyright © 2016 Kei Kebreau <kkebreau@posteo.net>
;;; Copyright © 2017 Eric Bavier <bavier@member.fsf.org>
;;; Copyright © 2017, 2018 Nils Gillmann <ng0@ng0.is>
;;; Copyright © 2018, 2019 Tobias Geerinckx-Rice <me@tobias.gr>
;;; Copyright © 2018 Rutger Helling <rhelling@mykolab.com>
;;; Copyright © 2018 Timo Eisenmann <eisenmann@fn.de>
;;; Copyright © 2018 Pierre Neidhardt <mail@ambrevar.xyz>
;;; Copyright © 2019 Pierre Neidhardt <swedebugia@riseup.net>
;;;
;;; This file is part of GNU Guix.
;;;
;;; GNU Guix is free software; you can redistribute it and/or modify it
;;; under the terms of the GNU General Public License as published by
;;; the Free Software Foundation; either version 3 of the License, or (at
;;; your option) any later version.
;;;
;;; GNU Guix is distributed in the hope that it will be useful, but
;;; WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;;; GNU General Public License for more details.
;;;
;;; You should have received a copy of the GNU General Public License
;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.

(define-module (gnu packages web-browsers)
  #:use-module ((guix licenses) #:prefix license:)
  #:use-module (guix packages)
  #:use-module (gnu packages)
  #:use-module (gnu packages admin)
  #:use-module (gnu packages assembly)
  #:use-module (gnu packages autotools)
  #:use-module (gnu packages base)
  #:use-module (gnu packages bash)
  #:use-module (gnu packages compression)
  #:use-module (gnu packages cups)
  #:use-module (gnu packages databases)
  #:use-module (gnu packages documentation)
  #:use-module (gnu packages fltk)
  #:use-module (gnu packages fontutils)
  #:use-module (gnu packages gcc)
  #:use-module (gnu packages gl)
  #:use-module (gnu packages glib)
  #:use-module (gnu packages gnome)
  #:use-module (gnu packages gnupg)
  #:use-module (gnu packages gnuzilla)
  #:use-module (gnu packages gstreamer)
  #:use-module (gnu packages gtk)
  #:use-module (gnu packages icu4c)
  #:use-module (gnu packages image)
  #:use-module (gnu packages kerberos)
  #:use-module (gnu packages libcanberra)
  #:use-module (gnu packages libevent)
  #:use-module (gnu packages libffi)
  #:use-module (gnu packages libidn)
  #:use-module (gnu packages libreoffice)
  #:use-module (gnu packages linux)
  #:use-module (gnu packages lisp)
  #:use-module (gnu packages lua)
  #:use-module (gnu packages m4)
  #:use-module (gnu packages ncurses)
  #:use-module (gnu packages perl)
  #:use-module (gnu packages pkg-config)
  #:use-module (gnu packages pulseaudio)
  #:use-module (gnu packages python)
;  #:use-module (gnu packages python-web)
  #:use-module (gnu packages python-xyz)
  #:use-module (gnu packages qt)
  #:use-module (gnu packages shells)
  #:use-module (gnu packages sqlite)
  #:use-module (gnu packages tls)
  #:use-module (gnu packages video)
  #:use-module (gnu packages webkit)
  #:use-module (gnu packages xdisorg)
  #:use-module (gnu packages xorg)
  #:use-module (guix download)
  #:use-module (guix git-download)
  #:use-module (guix build-system gnu)
  #:use-module (guix build-system glib-or-gtk)
  #:use-module (guix build-system python)
  #:use-module (guix build-system asdf))

(define-public dillo
  (package
    (name "dillo")
    (version "3.0.5")
    (source (origin
              (method url-fetch)
              (uri (string-append "http://www.dillo.org/download/"
                                  name "-" version ".tar.bz2"))
              (sha256
               (base32
                "12ql8n1lypv3k5zqgwjxlw1md90ixz3ag6j1gghfnhjq3inf26yv"))))
    (build-system gnu-build-system)
    (arguments `(#:configure-flags '("--enable-ssl" "--enable-ipv6")))
    (native-inputs `(("pkg-config" ,pkg-config)))
    (inputs `(("fltk" ,fltk)
              ("fontconfig" ,fontconfig)
              ("libjpeg" ,libjpeg)
              ("libpng" ,libpng)
              ("libxcursor" ,libxcursor)
              ("libxft" ,libxft)
              ("libxi" ,libxi)
              ("libxinerama" ,libxinerama)
              ("openssl" ,openssl)
              ("perl" ,perl)
              ("zlib" ,zlib)))
    (synopsis "Very small and fast graphical web browser")
    (description "Dillo is a minimalistic web browser particularly intended for
older or slower computers and embedded systems.")
    (home-page "http://www.dillo.org")
    (license license:gpl3+)))

(define-public links
  (package
    (name "links")
    (version "2.18")
    (source (origin
              (method url-fetch)
              (uri (string-append "http://links.twibright.com/download/"
                                  name "-" version ".tar.bz2"))
                (sha256
               (base32
                "0mwhh61klicn2vwk39nc7y4cw4mygzdi2nljn4r0gjbw6jmw3337"))))
    (build-system gnu-build-system)
    (arguments
     `(#:phases
       (modify-phases %standard-phases
         (replace 'configure
           (lambda* (#:key outputs #:allow-other-keys)
             ;; The tarball uses a very old version of autconf. It doesn't
             ;; understand extra flags like `--enable-fast-install', so
             ;; we need to invoke it with just what it understands.
             (let ((out (assoc-ref outputs "out")))
               ;; 'configure' doesn't understand '--host'.
               ,@(if (%current-target-system)
                     `((setenv "CHOST" ,(%current-target-system)))
                     '())
               (setenv "CONFIG_SHELL" (which "bash"))
               (invoke "./configure"
                       (string-append "--prefix=" out)
                       "--enable-graphics")
               #t))))))
    (native-inputs `(("pkg-config" ,pkg-config)))
    (inputs `(("zlib" ,zlib)
              ("openssl" ,openssl)
              ("libjpeg" ,libjpeg)
              ("libtiff" ,libtiff)
              ("libevent" ,libevent)
              ("libpng" ,libpng)
              ("libxt" ,libxt)))
    (synopsis "Text and graphics mode web browser")
    (description "Links is a graphics and text mode web browser, with many
features including, tables, builtin image display, bookmarks, SSL and more.")
    (home-page "http://links.twibright.com")
    ;; The distribution contains a copy of GPLv2
    ;; However, the copyright notices simply say:
    ;; "This file is a part of the Links program, released under GPL."
    ;; Therefore, under the provisions of Section 9, we can choose
    ;; any version ever published by the FSF.
    ;; One file (https.c) contains an exception permitting
    ;; linking of the program with openssl.
    (license license:gpl1+)))

(define-public luakit
  (package
    (name "luakit")
    (version "2.1")
    (source (origin
              (method url-fetch)
              (uri (string-append "https://github.com/luakit/luakit/archive/" version
                                  ".tar.gz"))
              (sha256
               (base32
                "09kgsm2w2xa4xwylsi0bwjvdl9k6hkyjyyrq2i3l8bvi2qrs5gzc"))
              (file-name (string-append name "-" version ".tar.gz"))))
    (inputs
     `(("lua-5.1" ,lua-5.1)
       ("gtk+" ,gtk+)
       ("gsettings-desktop-schemas" ,gsettings-desktop-schemas)
       ("glib-networking" ,glib-networking)
       ("lua5.1-filesystem" ,lua5.1-filesystem)
       ("luajit" ,luajit)
       ("webkitgtk" ,webkitgtk)
       ("sqlite" ,sqlite)))
    (native-inputs
     `(("pkg-config" ,pkg-config)))
    (build-system glib-or-gtk-build-system)
    (arguments
     '(#:make-flags
       (let ((out (assoc-ref %outputs "out")))
         (list
          "CC=gcc"
          "LUA_BIN_NAME=lua"
          "DEVELOPMENT_PATHS=0"
          (string-append "PREFIX=" out)
          (string-append "XDGPREFIX=" out "/etc/xdg")))
       #:phases
       (modify-phases %standard-phases
         (add-before 'build 'lfs-workaround
           (lambda _
             (setenv "LUA_CPATH"
                     (string-append
                      (assoc-ref %build-inputs "lua5.1-filesystem")
                      "/lib/lua/5.1/?.so;;"))
             #t))
         (delete 'configure)
         (delete 'check)
         (add-after 'install 'wrap
           (lambda* (#:key inputs outputs #:allow-other-keys)
             (let* ((luakit (assoc-ref outputs "out"))
                    (lua5.1-filesystem (assoc-ref inputs "lua5.1-filesystem") )
                    (gtk (assoc-ref inputs "gtk+"))
                    (gtk-share (string-append gtk "/share")))
               (wrap-program (string-append luakit "/bin/luakit")
                 `("LUA_CPATH" prefix
                   (,(string-append lua5.1-filesystem
                                    "/lib/lua/5.1/?.so;;")))
                 `("XDG_CONFIG_DIRS" prefix
                   (,(string-append luakit "/etc/xdg/"))))
               #t))))))
    (synopsis "Fast, lightweight, and simple browser based on WebKit")
    (description "Luakit is a fast, lightweight, and simple to use
micro-browser framework extensible by Lua using the WebKit web content engine
and the GTK+ toolkit.")
    (home-page "https://luakit.github.io/")
    (license license:gpl3+)))

(define-public lynx
  (package
    (name "lynx")
    (version "2.8.9rel.1")
    (source (origin
              (method url-fetch)
              (uri (string-append
                    "http://invisible-mirror.net/archives/lynx/tarballs"
                    "/lynx" version ".tar.bz2"))
              (sha256
               (base32
                "15cmyyma2kz1hfaa6mwjgli8zwdzq3jv0q2cl6nwzycjfwyijzrq"))))
    (build-system gnu-build-system)
    (native-inputs `(("pkg-config" ,pkg-config)
                     ("perl" ,perl)))
    (inputs `(("ncurses" ,ncurses)
              ("libidn" ,libidn)
              ("gnutls" ,gnutls)
              ("libgcrypt" ,libgcrypt)
              ("unzip" ,unzip)
              ("zlib" ,zlib)
              ("gzip" ,gzip)
              ("bzip2" ,bzip2)))
    (arguments
     `(#:configure-flags
       (let ((gnutls (assoc-ref %build-inputs "gnutls")))
         `("--with-pkg-config"
           "--with-screen=ncurses"
           "--with-zlib"
           "--with-bzlib"
           ,(string-append "--with-gnutls=" gnutls)
           ;; "--with-socks5"    ; XXX TODO
           "--enable-widec"
           "--enable-ascii-ctypes"
           "--enable-local-docs"
           "--enable-htmlized-cfg"
           "--enable-gzip-help"
           "--enable-nls"
           "--enable-ipv6"))
       #:tests? #f  ; no check target
       #:phases
       (modify-phases %standard-phases
         (add-before 'configure 'set-makefile-shell
           (lambda _ (substitute* "po/makefile.inn"
                       (("/bin/sh") (which "sh")))
                     #t))
         (replace 'install
           (lambda* (#:key (make-flags '()) #:allow-other-keys)
             (apply invoke "make" "install-full" make-flags)
             #t)))))
    (synopsis "Text Web Browser")
    (description
     "Lynx is a fully-featured World Wide Web (WWW) client for users running
cursor-addressable, character-cell display devices.  It will display Hypertext
Markup Language (HTML) documents containing links to files on the local
system, as well as files on remote systems running http, gopher, ftp, wais,
nntp, finger, or cso/ph/qi servers.  Lynx can be used to access information on
the WWW, or to build information systems intended primarily for local
access.")
    (home-page "https://lynx.invisible-island.net/")
    (license license:gpl2)))

(define-public qutebrowser
  (package
    (name "qutebrowser")
    (version "0.11.0")
    (source
     (origin
       (method url-fetch)
       (uri (string-append "https://github.com/The-Compiler/"
                           "qutebrowser/releases/download/v" version "/"
                           "qutebrowser-" version ".tar.gz"))
       (sha256
        (base32
         "13ihx66jm1dd6vx8px7pm0kbzf2sf9x43hhivc1rp17kahnxxdyv"))))
    (build-system python-build-system)
    (native-inputs
     `(("asciidoc" ,asciidoc)))
    (inputs
     `(("python-colorama" ,python-colorama)
       ("python-cssutils" ,python-cssutils)
       ("python-jinja2" ,python-jinja2)
       ("python-markupsafe" ,python-markupsafe)
       ("python-pygments" ,python-pygments)
       ("python-pypeg2" ,python-pypeg2)
       ("python-pyyaml" ,python-pyyaml)
       ("python-pyqt" ,python-pyqt)
       ("qtwebkit" ,qtwebkit)))
    (arguments
     `(#:tests? #f                      ;no tests
       #:phases
       (modify-phases %standard-phases
         (add-after 'install 'install-more
           (lambda* (#:key outputs #:allow-other-keys)
             (let* ((out (assoc-ref outputs "out"))
                    (app (string-append out "/share/applications"))
                    (hicolor (string-append out "/share/icons/hicolor")))
               (invoke "a2x" "-f" "manpage" "doc/qutebrowser.1.asciidoc")
               (install-file "doc/qutebrowser.1"
                             (string-append out "/share/man/man1"))

               (for-each
                (lambda (i)
                  (let ((src  (format #f "icons/qutebrowser-~dx~d.png" i i))
                        (dest (format #f "~a/~dx~d/apps/qutebrowser.png"
                                      hicolor i i)))
                    (mkdir-p (dirname dest))
                    (copy-file src dest)))
                '(16 24 32 48 64 128 256 512))
               (install-file "icons/qutebrowser.svg"
                             (string-append hicolor "/scalable/apps"))
               
               (substitute* "qutebrowser.desktop"
                 (("Exec=qutebrowser")
                  (string-append "Exec=" out "/bin/qutebrowser")))
               (install-file "qutebrowser.desktop" app)
               #t))))))
    (home-page "https://qutebrowser.org/")
    (synopsis "Minimal, keyboard-focused, vim-like web browser")
    (description "qutebrowser is a keyboard-focused browser with a minimal
GUI.  It is based on PyQt5 and QtWebKit.")
    (license license:gpl3+)))

(define-public vimb
  (package
    (name "vimb")
    (version "3.3.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/fanglingsu/vimb/")
             (commit version)))
       (sha256
        (base32
         "1qg18z2gnsli9qgrqfhqfrsi6g9mcgr90w8yab28nxrq4aha6brf"))
       (file-name (git-file-name name version))))
    (build-system glib-or-gtk-build-system)
    (arguments
     '(#:tests? #f ; no tests
       #:make-flags (list "CC=gcc"
                          "DESTDIR="
                          (string-append "PREFIX=" %output))
       #:phases
       (modify-phases %standard-phases
         (delete 'configure))))
    (inputs
     `(("glib-networking" ,glib-networking)
       ("gsettings-desktop-schemas" ,gsettings-desktop-schemas)
       ("webkitgtk" ,webkitgtk)))
    (native-inputs
     `(("pkg-config" ,pkg-config)))
    (home-page "https://fanglingsu.github.io/vimb/")
    (synopsis "Fast and lightweight Vim-like web browser")
    (description "Vimb is a fast and lightweight vim like web browser based on
the webkit web browser engine and the GTK toolkit.  Vimb is modal like the great
vim editor and also easily configurable during runtime.  Vimb is mostly keyboard
driven and does not detract you from your daily work.")
    (license license:gpl3+)))

(define-public next-gtk-webkit
  (package
    (name "next-gtk-webkit")
    (version "1.2.0")
    (source
     (origin
       (method git-fetch)
       (uri (git-reference
             (url "https://source.atlas.engineer/public/next")
             (commit version)))
       (sha256
        (base32
         "0a066f56hnb9znbwnv1blm31j0ysv05n4wzlkli0zgw087c9047x"))
       (file-name (git-file-name "next" version))))
    (build-system glib-or-gtk-build-system)
    (arguments
     `(#:tests? #f                      ; no tests
       #:make-flags (list "gtk-webkit"
                          (string-append
                           "CC="
                           (assoc-ref %build-inputs "gcc-7")
                           "/bin/gcc")
                          (string-append "PREFIX=" %output))
       #:phases
       (modify-phases %standard-phases
         (delete 'configure)
         (replace 'install
           (lambda* (#:key (make-flags '()) #:allow-other-keys)
             (apply invoke "make" "install-gtk-webkit" make-flags))))))
    (inputs
     `(("glib-networking" ,glib-networking)
       ("gsettings-desktop-schemas" ,gsettings-desktop-schemas)
       ("webkitgtk" ,webkitgtk-2.22)))
    (native-inputs
     `(("gcc-7" ,gcc-7) ; needed because webkitgtk-2.22 is compiled with gcc-7
       ("pkg-config" ,pkg-config)))
    (home-page "https://next.atlas.engineer")
    (synopsis "Infinitely extensible web-browser (user interface only)")
    (description "Next is a keyboard-oriented, extensible web-browser
inspired by Emacs and designed for power users.  The application has familiar
key-bindings, is fully configurable and extensible in Lisp, and has powerful
features for productive professionals.")
    (license license:bsd-3)))

(define-public sbcl-next
  (package
    (inherit next-gtk-webkit)
    (name "sbcl-next")
    (build-system asdf-build-system/sbcl)
    (outputs '("out" "lib"))
    (arguments
     `(#:tests? #f                      ; no tests
       #:phases (modify-phases %standard-phases
                  (add-after 'unpack 'patch-platform-port-path
                    (lambda* (#:key inputs #:allow-other-keys)
                      (substitute* "source/ports/gtk-webkit.lisp"
                        (("\"next-gtk-webkit\"")
                         (string-append "\"" (assoc-ref inputs "next-gtk-webkit")
                                        "/bin/next-gtk-webkit\"")))))
                  (add-before 'cleanup 'move-bundle
                    (lambda* (#:key outputs #:allow-other-keys)
                      (define lib (assoc-ref outputs "lib"))
                      (define actual-fasl (string-append
                                           lib
                                           "/lib/sbcl/next.fasl"))
                      (define expected-fasl (string-append
                                             lib
                                             "/lib/sbcl/next--system.fasl"))
                      (copy-file actual-fasl expected-fasl)
                      #t))
                  (add-after 'create-symlinks 'build-program
                    (lambda* (#:key outputs #:allow-other-keys)
                      (build-program
                       (string-append (assoc-ref outputs "out") "/bin/next")
                       outputs
                       #:entry-program '((next:start-with-port) 0))))
                  (add-before 'build 'install-assets
                    ;; Since the ASDF build system generates a new .asd with a
                    ;; possibly suffixed and thus illegal version number, assets
                    ;; should not be installed after the 'build phase or else
                    ;; the illegal version will result in NIL in the .desktop
                    ;; file.
                    (lambda* (#:key outputs #:allow-other-keys)
                      (with-output-to-file "version"
                        (lambda _
                          (format #t "~a" ,(package-version next-gtk-webkit))))
                      (invoke "make" "install-assets"
                              (string-append "PREFIX="
                                             (assoc-ref outputs "out"))))))))
    (inputs
     `(("next-gtk-webkit" ,next-gtk-webkit)
       ;; Lisp libraries:
       ("trivial-features" ,sbcl-trivial-features)
       ("alexandria" ,sbcl-alexandria)
       ("cl-strings" ,sbcl-cl-strings)
       ("cl-string-match" ,sbcl-cl-string-match)
       ("puri" ,sbcl-puri)
       ("sqlite" ,sbcl-cl-sqlite)
       ("parenscript" ,sbcl-parenscript)
       ("cl-json" ,sbcl-cl-json)
       ("swank" ,sbcl-slime-swank)
       ("cl-markup" ,sbcl-cl-markup)
       ("cl-css" ,sbcl-cl-css)
       ("bordeaux-threads" ,sbcl-bordeaux-threads)
       ("s-xml-rpc" ,sbcl-s-xml-rpc)
       ("unix-opts" ,sbcl-unix-opts)
       ("trivial-clipboard" ,sbcl-trivial-clipboard)))
    (synopsis "Infinitely extensible web-browser (with Lisp development files)")))

(define-public newmoon
  (package
    (name "newmoon")
    (version "28.4.0")
    (source
     (origin
       ;; Only generated github tarball available.
       (method git-fetch)
       (uri (git-reference
             (url "https://github.com/MoonchildProductions/UXP")
             (commit (string-append "PM" version "_Release"))))
       (file-name (git-file-name name version))
       (sha256
        (base32
         "0wnn15y7qpmz1b31rrmdlf3w4qz6f6qqrl8f1lgafx8czqgg9lwx"))))
    (build-system gnu-build-system)
    (inputs
     `(
       ;; ("gst-plugins-base" ,gst-plugins-base)
       ;; ("gstreamer" ,gstreamer)
       ;; ("mozjs" ,mozjs)
       ;; ("nss" ,nss)
       ;; ("openssl" ,openssl)
       ("alsa-lib" ,alsa-lib)
       ("bzip2" ,bzip2)
       ("cairo" ,cairo)
       ("cups" ,cups)
       ("dbus" ,dbus)
       ("dbus-glib" ,dbus-glib)
       ("ffmpeg" ,ffmpeg)
       ("freetype" ,freetype)
       ("glib" ,glib)
       ("gobject-introspection" ,gobject-introspection)
       ("gtk+-2" ,gtk+-2)
       ("hunspell" ,hunspell)
       ("inetutils" ,inetutils) ; Native-input?
       ("libcanberra" ,libcanberra)
       ("libevent" ,libevent)
       ("libffi" ,libffi)
       ("libgnome" ,libgnome)
       ("libidl" ,libidl)
       ("libjpeg-turbo" ,libjpeg-turbo)
       ("libnotify" ,libnotify)
       ("libpng-apng" ,libpng-apng)
       ("libvpx" ,libvpx)
       ("libwebp" ,libwebp)
       ("libx11" ,libx11)
       ("libxcomposite" ,libxcomposite)
       ("libxext" ,libxext)
       ("libxft" ,libxft)
       ("libxi" ,libxi)
       ("libxrender" ,libxrender)
       ("libxscrnsaver" ,libxscrnsaver)
       ("libxt" ,libxt)
       ("libxt" ,libxt)
       ("mesa" ,mesa)
       ("mit-krb5" ,mit-krb5)
       ("nspr" ,nspr)
       ("pixman" ,pixman)
       ("pulseaudio" ,pulseaudio)
       ("python-2" ,python-2)
       ("python-ply" ,python-ply)
       ("sqlite" ,sqlite-3.26.0)
       ("startup-notification" ,startup-notification)
       ("tcsh" ,tcsh)
       ("unzip" ,unzip)
       ("xextproto" ,xextproto)
       ("yasm" ,yasm)
       ("zip" ,zip)))
    (native-inputs
     `(("autoconf-2.13" ,autoconf-2.13)
       ("fontconfig" ,fontconfig)
       ("perl" ,perl)
       ("pkg-config" ,pkg-config)
       ("m4" ,m4)
       ("which" ,which)
       ("bash" ,bash)))
    (arguments
     `(#:modules ((ice-9 ftw)
                  (ice-9 rdelim)
                  (ice-9 match)
                  ,@%gnu-build-system-modules)
       ;; #:validate-runpath? #f
       #:phases
       (modify-phases %standard-phases
         (replace 'configure
           ;; According to <https://forum.palemoon.org/viewtopic.php?f=19&t=4166>
           ;; the only way to set configure options is in the .mozconfig file
           ;; (or the file set by variable MOZCONFIG).  If you try to use
           ;; our configure-flags, the configuration will break in unexpected
           ;; ways.  This includes breaking the mach build system detection
           ;; of --host, --build, and --arch, and carrying flags recursively
           ;; on to parts used later in the build system.
           ;; The palemoon.org link describes an MS Windows build, but at
           ;; least for Gentoo it is done comparable:
           ;; <https://data.gpo.zugaina.org/palemoon/>.
           (lambda* (#:key outputs configure-flags #:allow-other-keys)
             (let* ((out (assoc-ref outputs "out"))
                    (bash (which "bash"))
                    (abs-srcdir (getcwd))
                    (srcdir (string-append "../" (basename abs-srcdir)))
                    (flags `(,(string-append "--prefix=" out)
                             ,@configure-flags))
                    (mozconfig (string-append (getcwd) "/.mozconfig")))
               (setenv "SHELL" bash)
               (setenv "AUTOCONF"
                       (string-append (assoc-ref %build-inputs
                                                 "autoconf-2.13")
                                      "/bin/autoconf"))
               (setenv "BUILD_OBJ_DIR" (string-append (getcwd) "/o"))
               (setenv "CONFIG_SHELL" bash)
               (setenv "QA_CONFIGURE_OPTIONS" ".*")
               (setenv "MOZBUILD_STATE_PATH"
                       (string-append (getcwd) "/mach_state"))
               (setenv "MOZCONFIG"
                       (string-append (getcwd) "/.mozconfig"))
               (setenv "MOZ_NOSPAM" "1")
               (mkdir-p (string-append (getcwd) "/builddir"))
               (with-output-to-file mozconfig
                 (lambda ()
                   ;; These procedures help us create the .mozbuild-file
                   (define (enable option)
                     (string-append "ac_add_options --enable-" option "\n"))
                   (define (disable option)
                     (string-append "ac_add_options --disable-" option "\n"))
                   (define (var env)
                     (string-append "mk_add_options " env "\n"))
                   (define (with option)
                     (string-append "ac_add_options --with-" option "\n"))
                   ;; The full list of options can be obtained by running:
                   ;;  $ ./configure --help
                   (display
                    (string-append
                     ;; Todo: dbus, safe-browsing, 
                     (enable "application=palemoon")
                     (enable "chrome-format=omni")
                     (enable "content-sandbox")
                     (enable "default-toolkit=\"cairo-gtk2\"")
                     (enable "devtools")
                     (enable "export-js")
                     (enable "ffmpeg")
                     (enable "jemalloc")
                     (enable "pulseaudio")
                     (enable "sandbox")
                     (enable "skia")
                     (enable "startup-notification")
                     (enable "strip")
                     (enable "system-cairo")
                     (enable "system-ffi")
                     (enable "system-hunspell")
                     (enable "system-pixman")
                     (enable "system-sqlite") ;Needs >= sqlite-3.26.0

                     (disable "accessibility") ;There is no such option?
                     (disable "alsa")
                     ;;(disable "codesighs")
                     (disable "debug-symbols")
                     (disable "debug")
                     (disable "gamepad")
                     (disable "install-strip")
                     (disable "necko-wifi")
                     (disable "official-branding") ; Trademarks apply for official branding
                     (disable "optimize")
                     (disable "parental-controls") ;Yes? No?
                     (disable "tests") ; TODO fix tests
                     (disable "updater")
                     (disable "valgrind")

                     (with "pthreads")
                     (with "system-bz2")
                     (with "system-icu")
                     (with "system-jpeg")
                     (with "system-libevent")
                     (with "system-libvpx")
                     (with "system-nspr")
                     (with "system-png")
                     (with "system-zlib")

                     (var "AUTOCONF=\"autoconf\"")
                     (var (string-append "MOZ_OBJDIR=" (getenv "BUILD_OBJ_DIR"))) ;new
                     (var "PYTHON=\"python2\"")
                     "ac_add_options --prefix=" out "\n"

                     ;;"ac_add_options --disable-installer\n" ; no such option.
                     ;;"ac_add_options --disable-logging\n"
                     ;;"ac_add_options --disable-websms-backend\n"
                     ;;"ac_add_options --with-intl-api\n"
                     ;;"ac_add_options --with-system-ply\n"
                     ;;"ac_add_options --with-system-webp\n"
		     ))))
               (display "mach configure, this is expected to \"crash\"\n")
               (zero? (system* "./mach" "configure"))
               (display "mach, and another round.\n")
               (zero? (system* "./mach")))
             #t))
         (add-after 'patch-source-shebangs 'setenvs
           (lambda _
             (substitute* (list "build/autoconf/config.guess"
                                "client.mk"
                                "js/src/configure.in"
                                "intl/icu/source/configure")
               (("/bin/sh") (which "sh")))
             #t))
         (add-before 'build 'patch-clientmk
           (lambda _
             (substitute* "client.mk"
               (("/bin/sh") (which "sh")))
             #t))
         (replace 'build
           (lambda _
             (chdir "build")
             (display "mach build, the real build now\n")
             (system* "../mach" "build")
             #t))
         (add-after
             'unpack 'arrange-to-link-libxul-with-libraries-it-might-dlopen
           (lambda _
             ;; libxul.so dynamically opens libraries, so here we explicitly
             ;; link them into libxul.so instead.
             ;;
             ;; TODO: It might be preferable to patch in absolute file names in
             ;; calls to dlopen or PR_LoadLibrary, but that didn't seem to
             ;; work.  More investigation is needed.
             (substitute* "toolkit/library/moz.build"
               (("^# This needs to be last")
                "OS_LIBS += [
    'GL', 'gnome-2', 'canberra', 'Xss', 'cups', 'gssapi_krb5',
    'gstreamer-1.0', 'gstapp-1.0', 'gstvideo-1.0', 'png' ]\n\n"))
             #t))
         (add-after 'unpack 'privacy-patch-branding
           (lambda _
             (substitute* "application/palemoon/branding/unofficial/pref/palemoon-branding.js"
               (("http://www.palemoon.org/unofficial.shtml")
                "https://gnu.org/s/guix"))
             (substitute* "application/palemoon/branding/shared/pref/preferences.inc"
               (("http://www.palemoon.org/firstrun.shtml")
                "https://gnu.org"))
             (substitute* "application/palemoon/branding/shared/locales/browserconfig.properties"
               (("http://start.palemoon.org/")
                "https://gnu.org/s/guix"))
             #t))
         (replace 'install
           (lambda* (#:key name outputs #:allow-other-keys)
             (let* ((out (assoc-ref outputs "out"))
                    (bin (string-append out "/bin"))
                    (lib (string-append out "/lib"))
                    (palemoon (string-append
                               out "/lib/palemoon/palemoon"))
                    ;; Use one objectdirectory for all architectures.
                    (objdir "o")
                    ;; (prefsfile (string-append objdir "/dist/bin/browser"
                    ;;                           "/defaults/profile"
                    ;;                           "/prefs.js"))
                    (tarfile (string-append objdir "/dist/palemoon-"
                                            ,version ".linux-x86_64"
                                            ".tar.bz2")))
               ;; We skip this for now.
               ;;                (substitute* prefsfile
               ;;                  (("# Mozilla User Preferences")
               ;;                   "# Mozilla User Preferences\n
               ;; pref(\"app.update.enabled\", false);\n
               ;; pref(\"browser.backspace_action\", 0);\n
               ;; pref(\"browser.ctrlTab.previews\", false);\n
               ;; pref(\"intl.locale.matchOS\", true);\n
               ;; pref(\"general.useragent.locale\", \"chrome://global/locale/intl.properties\");\n
               ;; pref(\"browser.display.use_system_colors\", true);"))
               ;; Create the package, unpack it, manually install
               ;; the files from there to not miss anything.
               (zero? (system* "../mach" "package"))
               (display (getcwd))
               (chdir (string-append "../" objdir "/dist"))
               (zero? (system* "tar" "xjpf"
                               "palemoon-" ,version ".linux-x86_64.tar.bz2"))
               (mkdir-p (string-append out "/lib/palemoon"))
               (copy-recursively "palemoon"
                                 (string-append out "/lib/palemoon"))
               (mkdir-p bin)
               (symlink (string-append out "/lib/palemoon/palemoon")
                        (string-append bin "/newmoon"))
               ;; Avoid duplicate binaries.
               ;; https://bugzilla.mozilla.org/show_bug.cgi?id=658850 for
               (delete-file (string-append out "/lib/palemoon/palemoon-bin")))))
         ;; swap check and install phases and set paths to installed binaries
         (add-before 'check 'set-path-for-check
           (lambda* (#:key outputs #:allow-other-keys)
             (let ((out (assoc-ref outputs "out")))
               (setenv "PATH" (string-append (getenv "PATH") ":" out "/bin")))
             #t))
         (add-after 'install 'check
           ;;(assoc-ref %standard-phases 'check))
           (lambda* (#:key outputs #:allow-other-keys)
             (let* ((out (assoc-ref outputs "out"))
                    (bin (string-append out "/bin/newmoon")))
               (invoke bin "--version"))))
         (delete 'check)
         (delete 'bootstrap)
         ;; (replace 'check
         ;;   (lambda* (#:key outputs #:allow-other-keys)
         ;;     (let* ((out (assoc-ref outputs "out"))
         ;;            (bin (string-append out "/bin/newmoon")))
         ;;       (invoke bin "--version"))))
         (add-after 'install 'install-icons
           (lambda* (#:key outputs #:allow-other-keys)
             (let* ((out (assoc-ref outputs "out")))
               (display (getcwd))
               (with-directory-excursion "../../browser/branding/unofficial"
                 (for-each
                  (lambda (file)
                    (let* ((size (string-filter char-numeric? file))
                           (icons (string-append out "/share/icons/hicolor/"
                                                 size "x" size "/apps")))
                      (mkdir-p icons)
                      (copy-file file (string-append icons "/newmoon.png"))))
                  '("default16.png" "default32.png" "default48.png"
                    "mozicon128.png"))))))
         (add-after 'install 'install-desktop-file
           (lambda* (#:key outputs #:allow-other-keys)
             (let* ((out (assoc-ref outputs "out"))
                    (apps (string-append out "/share/applications")))
               (display (getcwd))
               (with-directory-excursion "../../browser/branding/official"
                 (substitute* "palemoon.desktop"
                   (("Pale Moon")
                    "New Moon")
                   (("Exec=palemoon -new-tab https://start.palemoon.org")
                    "Exec=newmoon -new-tab https://gnu.org/s/guix")
                   (("Exec=palemoon -new-window")
                    "Exec=newmoon -new-window")
                   (("Exec=palemoon -private-window")
                    "Exec=newmoon -private-window")
                   (("palemoon")
                    "newmoon"))
                 (install-file "palemoon.desktop"
                               (string-append apps
                                              "/newmoon.desktop")))))))))

    (home-page "https://www.palemoon.org/")
    (synopsis "Web Browser compiled from Pale Moon sources")
    (description
     "New Moon is a web browser compiled from Pale Moon sourcecode.  New Moon
is an independent browser derived from Firefox.

Among its features are:
@itemize
@item It's fast (much codebloat has been removed since the fork from Firefox).
@item The developers adhere to defence-in-depth, increasing the security
step-by-step.
@item Builds upon the Unified XUL Platform 
@item Comes with the Goanna layout engine (forked from Gecko). 
@item Uses the pre-Australis Firefox user interface Continues add-on support
for XUL, XPCOM, and NPAPI plugins.
@item Supports extensions and themes exclusive to Pale Moon, such as Adblock
Latitude.
@item Defaults to DuckDuckGo as the search engine.
@item Uses the IP-API service instead of Google's for geolocation. 
@item Fully customizable user interface.
@item Newmoon is not a full featured (bloated) media player or recorder but
does support the HTML5 video standard.
@end itemize\n")
    (properties '((upstream-name . "Pale-Moon")))
    ;; The exception clause of the Palemoon license states that
    ;; New Moon builds can be redistributed freely.
    (license (list license:mpl2.0 ;and others, see toolkit/content/license.html
                   license:gpl2+
                   license:lgpl2.1))))