JS (também conhecido como SpiderMonkey) é o mecanismo JavaScript e WebAssembly da Mozilla, escrito em C++ e Rust. No BLFS, o código-fonte do JS é retirado a partir do Firefox.
Esse pacote é conhecido por construir e funcionar adequadamente usando uma plataforma LFS 11.3.
Transferência (HTTP): https://archive.mozilla.org/pub/firefox/releases/102.8.0esr/source/firefox-102.8.0esr.source.tar.xz
Soma de verificação MD5 da transferência: 2f65e84943e97f6d56d7b07aa1ded135
Tamanho da transferência: 457 MB
Espaço em disco estimado exigido: 3,3 GB (38 MB instalado depois de remover biblioteca estática de 34 MB)
Tempo de construção estimado: 1,8 UPC (com paralelismo=4)
ICU-72.1, rustc-1.67.1 e Which-2.21
LLVM-15.0.7 (com o Clang, exigido para sistemas de 32 bits sem recursos "SSE2")
Observações de Usuário(a): https://wiki.linuxfromscratch.org/blfs/wiki/js102
          
            Ao contrário da maioria dos outros pacotes no BLFS, as instruções
            abaixo exigem que você descompacte firefox-102.8.0esr.tar.xz e mude para a pasta
            firefox-102.8.0.
          
            Extrair o "tarball" reconfigurará as permissões do diretório
            atual para 0755, se você tiver permissão para fazer isso. Se você
            fizer isso em um diretório onde o bit "sticky" estiver
            configurado, tal como o /tmp,
            [então] ele terminará com mensagens de erro:
          
              tar: .: Não é possível utime: Operação não permitida
              tar: .: Não é possível mudar o modo para rwxr-xr-t: Operação não permitida
              tar: Saindo com status de falha devido a erros anteriores
            
            Isso termina com um status diferente de zero, porém NÃO significa que existe um problema
            real. Não descompacte como o(a) usuário(a) root em um diretório onde o bit "sticky"
            estiver configurado - isso irá desconfigurá-lo.
          
Instale JS executando os seguintes comandos:
          
            Se você estiver compilando esse pacote em chroot, você precisa
            fazer duas coisas. Primeiro, como o(a) usuário(a) root, certifique-se de que /dev/shm esteja montado. Se você não fizer
            isso, a configuração do Python
            falhará com um informe de rastreamento referenciando /usr/lib/pythonN.N/multiprocessing/synchronize.py.
            Execute:
          
mountpoint -q /dev/shm || mount -t tmpfs devshm /dev/shm
            Segundo, como o(a) usuário(a) root exporte a variável de ambiente
            $SHELL usando export SHELL=/bin/sh ou, então,
            preceda SHELL=/bin/sh ao executar o
            comando configure.
          
A compilação do código C++ respeita "$MAKEFLAGS" e o padrão é 'j1'; o código "Rust" usará todos os processadores.
Primeiro remova um sinalizador obsoleto no código "Python", que foi removido no "python-3.11":
grep -rl \"rU\" | xargs sed -i 's/"rU"/"r"/'
Em seguida execute:
mkdir obj &&
cd    obj &&
sh ../js/src/configure.in --prefix=/usr            \
                          --with-intl-api          \
                          --with-system-zlib       \
                          --with-system-icu        \
                          --disable-jemalloc       \
                          --disable-debug-symbols  \
                          --enable-readline        &&
make
        Para executar a suíte de teste do JS, emita: make -C js/src check-jstests JSESTS_EXTRA_ARGS="--timeout 300 --wpt=disabled". É recomendável redirecionar a saída gerada para um [arquivo de] registro. Como estamos construindo com o "ICU" do sistema, mais de cem testes (de um total de mais de 50.000) são conhecidos por falharem.
Para executar a suíte de teste do JIT, emita: make -C js/src check-jit-test JITTEST_EXTRA_ARGS="--timeout 300".
          Um problema no processo de instalação faz com que qualquer aplicativo em execução e que se vincule à biblioteca compartilhada "JS102" (por exemplo, GNOME Shell) quebre se a "JS102" for atualizada ou for reinstalada. Para contornar esse problema, remova a versão antiga da biblioteca compartilhada "JS102" antes da instalação:
rm -fv /usr/lib/libmozjs-102.so
          Agora, como o(a) usuário(a) root:
        
make install && rm -v /usr/lib/libjs_static.ajs && sed -i '/@NSPR_CFLAGS@/d' /usr/bin/js102-config
          sh
          ../js/src/configure.in: configure.in é na verdade um script de shell,
          porém o bit executável não está configurado no modo de permissão
          dele, de modo que é necessário executá-lo explicitamente com o
          sh.
        
          --with-intl-api: Isso
          habilita as funções de internacionalização exigidas pelo
          Gjs.
        
          --with-system-*: Esses
          parâmetros permitem que o sistema de construção use versões do
          sistema das bibliotecas acima. Essas são exigidas para a
          estabilidade.
        
          --enable-readline: Essa
          chave habilita o suporte a "Readline" no shell do "JS".
        
          --disable-jemalloc: Essa
          chave desabilita o alocador interno de memória usado no "JS102". o
          "jemalloc" destina-se somente ao ambiente do navegador Firefox.
          Para outros aplicativos que usam a "JS102", o aplicativo
          possivelmente quebre quando os itens alocados no alocador
          "jemalloc" forem liberados no alocador do sistema (glibc).
        
          --disable-debug-symbols:
          Não gere símbolos de depuração, pois eles são muito grandes e a
          maioria dos(as) usuários(as) não precisará deles. Remova-a se
          quiser depurar a "JS102".
        
rm -v /usr/lib/libjs_static.ajs: Remove uma grande biblioteca estática que não é usada por nenhum pacote do BLFS.
sed -i '/@NSPR_CFLAGS@/d' /usr/bin/js102-config: Evita que js102-config use "CFLAGS" defeituosos.
          : o BLFS costumava preferir usar gcc e g++ em
          vez dos padrões do(a) desenvolvedor(a) dos aplicativos clang. Com o lançamento do gcc-12, a
          construção toma mais tempo com gcc e g++, principalmente por causa
          de avisos extras, e é maior. Passe essas variáveis de ambiente para
          o script de configuração se desejar continuar a usar gcc, g++
          (exportando-as e desconfigurando-as depois da instalação ou
          simplesmente anexando-as antes do comando sh ../js/src/configure.in). Se
          você estiver construindo em um sistema de 32 bits, [então] também
          veja abaixo.
        CC=gcc
          CXX=g++
          : Use "SSE2" em vez de "387" para
          operações de ponto flutuante de precisão dupla. É necessário para o
          GCC satisfazer as expectativas dos(as) desenvolvedores(as)
          "upstream" (Mozilla) com aritmética de ponto flutuante. Use-o se
          estiver construindo esse pacote em um sistema de 32 bits com GCC
          (se o "Clang" não estiver instalado ou o GCC for explicitamente
          especificado). Observe que isso fará com que o "JS" quebre em um
          processador sem capacidade "SSE2". Se você estiver executando o
          sistema em um processador tão antigo, [então] o "Clang" é
          estritamente necessário. Essa configuração não é necessária em
          sistemas de 64 bits, pois todos os processadores x86 de 64 bits
          suportam "SSE2" e os compiladores de 64 bits (ambos "Clang" e GCC)
          usam "SSE2" por padrão.
        CXXFLAGS="-msse2
          -mfpmath=sse"