Merge pull request #1337 from lightpanda-io/ci-check

ci: try to fix tag

.github/actions/install/action.yml

@@ -13,7 +13,7 @@ inputs:
   zig-v8:
     description: 'zig v8 version to install'
     required: false
-    default: 'v0.3.4'
+    default: 'v0.1.35'
   v8:
     description: 'v8 version to install'
     required: false
@@ -22,10 +22,6 @@ inputs:
     description: 'cache dir to use'
     required: false
     default: '~/.cache'
-  debug:
-    description: 'enable v8 pre-built debug version, only available for linux x86_64'
-    required: false
-    default: 'false'
 
 runs:
   using: "composite"
@@ -36,32 +32,55 @@ runs:
       shell: bash
       run: |
         sudo apt-get update
-        sudo apt-get install -y wget xz-utils ca-certificates clang make git
+        sudo apt-get install -y wget xz-utils python3 ca-certificates git pkg-config libglib2.0-dev gperf libexpat1-dev cmake clang
 
     # Zig version used from the `minimum_zig_version` field in build.zig.zon
     - uses: mlugg/setup-zig@v2
 
-    # Rust Toolchain for html5ever
-    - uses: dtolnay/rust-toolchain@stable
-
     - name: Cache v8
       id: cache-v8
-      uses: actions/cache@v5
+      uses: actions/cache@v4
       env:
         cache-name: cache-v8
       with:
         path: ${{ inputs.cache-dir }}/v8
-        key: libc_v8_${{ inputs.v8 }}_${{ inputs.os }}_${{ inputs.arch }}_${{ inputs.zig-v8 }}${{inputs.debug == 'true' && '_debug' || '' }}.a
+        key: libc_v8_${{ inputs.v8 }}_${{ inputs.os }}_${{ inputs.arch }}_${{ inputs.zig-v8 }}.a
 
     - if: ${{ steps.cache-v8.outputs.cache-hit != 'true' }}
       shell: bash
       run: |
         mkdir -p ${{ inputs.cache-dir }}/v8
 
-        wget -O ${{ inputs.cache-dir }}/v8/libc_v8.a https://github.com/lightpanda-io/zig-v8-fork/releases/download/${{ inputs.zig-v8 }}/libc_v8_${{ inputs.v8 }}_${{ inputs.os }}_${{ inputs.arch }}${{inputs.debug == 'true' && '_debug' || '' }}.a
+        wget -O ${{ inputs.cache-dir }}/v8/libc_v8.a https://github.com/lightpanda-io/zig-v8-fork/releases/download/${{ inputs.zig-v8 }}/libc_v8_${{ inputs.v8 }}_${{ inputs.os }}_${{ inputs.arch }}.a
 
     - name: install v8
       shell: bash
       run: |
         mkdir -p v8
-        ln -s ${{ inputs.cache-dir }}/v8/libc_v8.a v8/libc_v8${{inputs.debug == 'true' && '_debug' || '' }}.a
+        ln -s ${{ inputs.cache-dir }}/v8/libc_v8.a v8/libc_v8.a
+
+    - name: Cache libiconv
+      id: cache-libiconv
+      uses: actions/cache@v4
+      env:
+        cache-name: cache-libiconv
+      with:
+        path: ${{ inputs.cache-dir }}/libiconv
+        key: vendor/libiconv/libiconv-1.17
+
+    - name: download libiconv
+      if: ${{ steps.cache-libiconv.outputs.cache-hit != 'true' }}
+      shell: bash
+      run: make download-libiconv
+
+    - name: build libiconv
+      shell: bash
+      run: make build-libiconv
+
+    - name: build mimalloc
+      shell: bash
+      run: make install-mimalloc
+
+    - name: build netsurf
+      shell: bash
+      run: make install-netsurf

.github/workflows/build.yml

@@ -5,9 +5,7 @@ env:
   AWS_SECRET_ACCESS_KEY: ${{ secrets.NIGHTLY_BUILD_AWS_SECRET_ACCESS_KEY }}
   AWS_BUCKET: ${{ vars.NIGHTLY_BUILD_AWS_BUCKET }}
   AWS_REGION: ${{ vars.NIGHTLY_BUILD_AWS_REGION }}
-
   RELEASE: ${{ github.ref_type == 'tag' && github.ref_name || 'nightly' }}
-  GIT_VERSION_FLAG: ${{ github.ref_type == 'tag' && format('-Dgit_version={0}', github.ref_name) || '' }}
 
 on:
   push:
@@ -29,23 +27,21 @@ jobs:
       OS: linux
 
     runs-on: ubuntu-22.04
-    timeout-minutes: 20
+    timeout-minutes: 15
 
     steps:
       - uses: actions/checkout@v6
         with:
           fetch-depth: 0
+          submodules: recursive
 
       - uses: ./.github/actions/install
         with:
           os: ${{env.OS}}
           arch: ${{env.ARCH}}
 
-      - name: v8 snapshot
-        run: zig build -Dprebuilt_v8_path=v8/libc_v8.a -Doptimize=ReleaseFast snapshot_creator -- src/snapshot.bin
-
       - name: zig build
-        run: zig build -Dsnapshot_path=../../snapshot.bin -Dprebuilt_v8_path=v8/libc_v8.a -Doptimize=ReleaseFast -Dcpu=x86_64 -Dgit_commit=$(git rev-parse --short ${{ github.sha }}) ${{ env.GIT_VERSION_FLAG }}
+        run: zig build -Dprebuilt_v8_path=v8/libc_v8.a -Doptimize=ReleaseSafe -Dcpu=x86_64 -Dgit_commit=$(git rev-parse --short ${{ github.sha }})
 
       - name: Rename binary
         run: mv zig-out/bin/lightpanda lightpanda-${{ env.ARCH }}-${{ env.OS }}
@@ -61,7 +57,6 @@ jobs:
           allowUpdates: true
           artifacts: lightpanda-${{ env.ARCH }}-${{ env.OS }}
           tag: ${{ env.RELEASE }}
-          makeLatest: true
 
   build-linux-aarch64:
     env:
@@ -69,23 +64,22 @@ jobs:
       OS: linux
 
     runs-on: ubuntu-22.04-arm
-    timeout-minutes: 20
+    timeout-minutes: 15
 
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
+          # fetch submodules recusively, to get zig-js-runtime submodules also.
+          submodules: recursive
 
       - uses: ./.github/actions/install
         with:
           os: ${{env.OS}}
           arch: ${{env.ARCH}}
 
-      - name: v8 snapshot
-        run: zig build -Dprebuilt_v8_path=v8/libc_v8.a -Doptimize=ReleaseFast snapshot_creator -- src/snapshot.bin
-
       - name: zig build
-        run: zig build -Dsnapshot_path=../../snapshot.bin -Dprebuilt_v8_path=v8/libc_v8.a -Doptimize=ReleaseFast -Dcpu=generic -Dgit_commit=$(git rev-parse --short ${{ github.sha }}) ${{ env.GIT_VERSION_FLAG }}
+        run: zig build -Dprebuilt_v8_path=v8/libc_v8.a -Doptimize=ReleaseSafe -Dcpu=generic -Dgit_commit=$(git rev-parse --short ${{ github.sha }})
 
       - name: Rename binary
         run: mv zig-out/bin/lightpanda lightpanda-${{ env.ARCH }}-${{ env.OS }}
@@ -101,7 +95,6 @@ jobs:
           allowUpdates: true
           artifacts: lightpanda-${{ env.ARCH }}-${{ env.OS }}
           tag: ${{ env.RELEASE }}
-          makeLatest: true
 
   build-macos-aarch64:
     env:
@@ -111,23 +104,22 @@ jobs:
     # macos-14 runs on arm CPU. see
     # https://github.com/actions/runner-images?tab=readme-ov-file
     runs-on: macos-14
-    timeout-minutes: 20
+    timeout-minutes: 15
 
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
+          # fetch submodules recusively, to get zig-js-runtime submodules also.
+          submodules: recursive
 
       - uses: ./.github/actions/install
         with:
           os: ${{env.OS}}
           arch: ${{env.ARCH}}
 
-      - name: v8 snapshot
-        run: zig build -Dprebuilt_v8_path=v8/libc_v8.a -Doptimize=ReleaseFast snapshot_creator -- src/snapshot.bin
-
       - name: zig build
-        run: zig build -Dsnapshot_path=../../snapshot.bin -Dprebuilt_v8_path=v8/libc_v8.a -Doptimize=ReleaseFast -Dgit_commit=$(git rev-parse --short ${{ github.sha }}) ${{ env.GIT_VERSION_FLAG }}
+        run: zig build -Dprebuilt_v8_path=v8/libc_v8.a -Doptimize=ReleaseSafe -Dgit_commit=$(git rev-parse --short ${{ github.sha }})
 
       - name: Rename binary
         run: mv zig-out/bin/lightpanda lightpanda-${{ env.ARCH }}-${{ env.OS }}
@@ -143,7 +135,6 @@ jobs:
           allowUpdates: true
           artifacts: lightpanda-${{ env.ARCH }}-${{ env.OS }}
           tag: ${{ env.RELEASE }}
-          makeLatest: true
 
   build-macos-x86_64:
     env:
@@ -151,23 +142,22 @@ jobs:
       OS: macos
 
     runs-on: macos-14-large
-    timeout-minutes: 20
+    timeout-minutes: 15
 
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
+          # fetch submodules recusively, to get zig-js-runtime submodules also.
+          submodules: recursive
 
       - uses: ./.github/actions/install
         with:
           os: ${{env.OS}}
           arch: ${{env.ARCH}}
 
-      - name: v8 snapshot
-        run: zig build -Dprebuilt_v8_path=v8/libc_v8.a -Doptimize=ReleaseFast snapshot_creator -- src/snapshot.bin
-
       - name: zig build
-        run: zig build -Dsnapshot_path=../../snapshot.bin -Dprebuilt_v8_path=v8/libc_v8.a -Doptimize=ReleaseFast -Dgit_commit=$(git rev-parse --short ${{ github.sha }}) ${{ env.GIT_VERSION_FLAG }}
+        run: zig build -Dprebuilt_v8_path=v8/libc_v8.a -Doptimize=ReleaseSafe -Dgit_commit=$(git rev-parse --short ${{ github.sha }})
 
       - name: Rename binary
         run: mv zig-out/bin/lightpanda lightpanda-${{ env.ARCH }}-${{ env.OS }}
@@ -183,4 +173,3 @@ jobs:
           allowUpdates: true
           artifacts: lightpanda-${{ env.ARCH }}-${{ env.OS }}
           tag: ${{ env.RELEASE }}
-          makeLatest: true

.github/workflows/cla.yml

@@ -28,7 +28,7 @@ jobs:
           path-to-document: 'https://github.com/lightpanda-io/browser/blob/main/CLA.md'
           # branch should not be protected
           branch: 'main'
-          allowlist: krichprollsch,francisbouvier,katie-lpd,sjorsdonkers,bornlex
+          allowlist: krichprollsch,francisbouvier,katie-lpd
 
           remote-organization-name: lightpanda-io
           remote-repository-name: cla

.github/workflows/e2e-integration-test.yml

@@ -20,9 +20,11 @@ jobs:
     if: github.event.pull_request.draft == false
 
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
+          # fetch submodules recusively, to get zig-js-runtime submodules also.
+          submodules: recursive
 
       - uses: ./.github/actions/install
 
@@ -30,7 +32,7 @@ jobs:
         run: zig build -Dprebuilt_v8_path=v8/libc_v8.a -Doptimize=ReleaseFast -Dcpu=x86_64 -Dgit_commit=$(git rev-parse --short ${{ github.sha }})
 
       - name: upload artifact
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v4
         with:
           name: lightpanda-build-release
           path: |
@@ -45,7 +47,7 @@ jobs:
     timeout-minutes: 15
 
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
         with:
           repository: 'lightpanda-io/demo'
           fetch-depth: 0
@@ -53,7 +55,7 @@ jobs:
       - run: npm install
 
       - name: download artifact
-        uses: actions/download-artifact@v8
+        uses: actions/download-artifact@v4
         with:
           name: lightpanda-build-release
 
@@ -61,6 +63,6 @@ jobs:
 
       - name: run end to end integration tests
         run: |
-          ./lightpanda serve --log_level error & echo $! > LPD.pid
+          ./lightpanda serve & echo $! > LPD.pid
           go run integration/main.go
           kill `cat LPD.pid`

.github/workflows/e2e-test.yml

@@ -9,13 +9,15 @@ env:
 
 on:
   push:
-    branches: [main]
+    branches:
+      - main
     paths:
-      - ".github/**"
-      - "src/**"
       - "build.zig"
-      - "build.zig.zon"
-
+      - "src/**/*.zig"
+      - "src/*.zig"
+      - "vendor/zig-js-runtime"
+      - ".github/**"
+      - "vendor/**"
   pull_request:
 
     # By default GH trigger on types opened, synchronize and reopened.
@@ -27,10 +29,12 @@ on:
 
     paths:
       - ".github/**"
-      - "src/**"
       - "build.zig"
-      - "build.zig.zon"
-
+      - "src/**/*.zig"
+      - "src/*.zig"
+      - "vendor/**"
+      - ".github/**"
+      - "vendor/**"
   # Allows you to run this workflow manually from the Actions tab
   workflow_dispatch:
 
@@ -48,6 +52,7 @@ jobs:
       - uses: actions/checkout@v6
         with:
           fetch-depth: 0
+          submodules: recursive
 
       - uses: ./.github/actions/install
 
@@ -55,7 +60,7 @@ jobs:
         run: zig build -Dprebuilt_v8_path=v8/libc_v8.a -Doptimize=ReleaseFast -Dcpu=x86_64 -Dgit_commit=$(git rev-parse --short ${{ github.sha }})
 
       - name: upload artifact
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v4
         with:
           name: lightpanda-build-release
           path: |
@@ -70,7 +75,7 @@ jobs:
     timeout-minutes: 15
 
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
         with:
           repository: 'lightpanda-io/demo'
           fetch-depth: 0
@@ -78,7 +83,7 @@ jobs:
       - run: npm install
 
       - name: download artifact
-        uses: actions/download-artifact@v8
+        uses: actions/download-artifact@v4
         with:
           name: lightpanda-build-release
 
@@ -111,130 +116,21 @@ jobs:
           BASE_URL=https://demo-browser.lightpanda.io/ node playwright/proxy_auth.js
           kill `cat LPD.pid` `cat PROXY.id`
 
-  # e2e tests w/ web-bot-auth configuration on.
-  wba-demo-scripts:
-    name: wba-demo-scripts
-    needs: zig-build-release
-
-    runs-on: ubuntu-latest
-    timeout-minutes: 15
-
-    steps:
-      - uses: actions/checkout@v6
-        with:
-          repository: 'lightpanda-io/demo'
-          fetch-depth: 0
-
-      - run: npm install
-
-      - name: download artifact
-        uses: actions/download-artifact@v8
-        with:
-          name: lightpanda-build-release
-
-      - run: chmod a+x ./lightpanda
-
-      - run: echo "${{ secrets.WBA_PRIVATE_KEY_PEM }}" > private_key.pem
-
-      - name: run end to end tests
-        run: |
-          ./lightpanda serve \
-            --web_bot_auth_key_file private_key.pem \
-            --web_bot_auth_keyid ${{ vars.WBA_KEY_ID }} \
-            --web_bot_auth_domain ${{ vars.WBA_DOMAIN }} \
-            & echo $! > LPD.pid
-          go run runner/main.go
-          kill `cat LPD.pid`
-
-      - name: build proxy
-        run: |
-          cd proxy
-          go build
-
-      - name: run end to end tests through proxy
-        run: |
-          ./proxy/proxy & echo $! > PROXY.id
-          ./lightpanda serve \
-            --web_bot_auth_key_file private_key.pem \
-            --web_bot_auth_keyid ${{ vars.WBA_KEY_ID }} \
-            --web_bot_auth_domain ${{ vars.WBA_DOMAIN }} \
-            --http_proxy 'http://127.0.0.1:3000' \
-            & echo $! > LPD.pid
-          go run runner/main.go
-          kill `cat LPD.pid` `cat PROXY.id`
-
-      - name: run request interception through proxy
-        run: |
-          export PROXY_USERNAME=username PROXY_PASSWORD=password
-          ./proxy/proxy & echo $! > PROXY.id
-          ./lightpanda serve & echo $! > LPD.pid
-          URL=https://demo-browser.lightpanda.io/campfire-commerce/ node puppeteer/proxy_auth.js
-          BASE_URL=https://demo-browser.lightpanda.io/ node playwright/proxy_auth.js
-          kill `cat LPD.pid` `cat PROXY.id`
-
-  wba-test:
-    name: wba-test
-    needs: zig-build-release
-
-    runs-on: ubuntu-latest
-    timeout-minutes: 5
-
-    steps:
-      - uses: actions/checkout@v6
-        with:
-          repository: 'lightpanda-io/demo'
-          fetch-depth: 0
-
-      - name: download artifact
-        uses: actions/download-artifact@v8
-        with:
-          name: lightpanda-build-release
-
-      - run: chmod a+x ./lightpanda
-
-      # force a wakup of the auth server before requesting it w/ the test itself
-      - run: curl https://${{ vars.WBA_DOMAIN }}
-
-      - name: run wba test
-        shell: bash
-        run: |
-          node webbotauth/validator.js &
-          VALIDATOR_PID=$!
-          sleep 5
-
-          exec 3<<< "${{ secrets.WBA_PRIVATE_KEY_PEM }}"
-
-          ./lightpanda fetch --dump http://127.0.0.1:8989/ \
-            --web_bot_auth_key_file /proc/self/fd/3 \
-            --web_bot_auth_keyid ${{ vars.WBA_KEY_ID }} \
-            --web_bot_auth_domain ${{ vars.WBA_DOMAIN }}
-
-          wait $VALIDATOR_PID
-          exec 3>&-
-
   cdp-and-hyperfine-bench:
     name: cdp-and-hyperfine-bench
     needs: zig-build-release
 
     env:
-      MAX_VmHWM: 28000 # 28MB (KB)
-      MAX_CG_PEAK: 8000 # 8MB (KB)
-      MAX_AVG_DURATION: 17
-
-      # How to give cgroups access to the user actions-runner on the host:
-      # $ sudo apt install cgroup-tools
-      # $ sudo chmod o+w /sys/fs/cgroup/cgroup.procs
-      # $ sudo mkdir -p /sys/fs/cgroup/actions-runner
-      # $ sudo chown -R actions-runner:actions-runner /sys/fs/cgroup/actions-runner
-      CG_ROOT: /sys/fs/cgroup
-      CG: actions-runner/lpd_${{ github.run_id }}_${{ github.run_attempt }}
+      MAX_MEMORY: 28000
+      MAX_AVG_DURATION: 23
+      LIGHTPANDA_DISABLE_TELEMETRY: true
 
     # use a self host runner.
     runs-on: lpd-bench-hetzner
     timeout-minutes: 15
 
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
         with:
           repository: 'lightpanda-io/demo'
           fetch-depth: 0
@@ -242,7 +138,7 @@ jobs:
       - run: npm install
 
       - name: download artifact
-        uses: actions/download-artifact@v8
+        uses: actions/download-artifact@v4
         with:
           name: lightpanda-build-release
 
@@ -253,53 +149,22 @@ jobs:
           go run ws/main.go & echo $! > WS.pid
           sleep 2
 
-      - name: run lightpanda in cgroup
-        run: |
-          if [ ! -f /sys/fs/cgroup/cgroup.controllers ]; then
-            echo "cgroup v2 not available: /sys/fs/cgroup/cgroup.controllers missing"
-            exit 1
-          fi
-
-          mkdir -p $CG_ROOT/$CG
-          cgexec -g memory:$CG ./lightpanda serve & echo $! > LPD.pid
-
-          sleep 2
-
       - name: run puppeteer
         run: |
+          ./lightpanda serve & echo $! > LPD.pid
+          sleep 2
           RUNS=100 npm run bench-puppeteer-cdp > puppeteer.out || exit 1
           cat /proc/`cat LPD.pid`/status |grep VmHWM|grep -oP '\d+' > LPD.VmHWM
           kill `cat LPD.pid`
 
-          PID=$(cat LPD.pid)
-          while kill -0 $PID 2>/dev/null; do
-            sleep 1
-          done
-          if [ ! -f $CG_ROOT/$CG/memory.peak ]; then
-            echo "memory.peak not available in $CG"
-            exit 1
-          fi
-          cat $CG_ROOT/$CG/memory.peak > LPD.cg_mem_peak
-
       - name: puppeteer result
         run: cat puppeteer.out
 
-      - name: cgroup memory regression
-        run: |
-          PEAK_BYTES=$(cat LPD.cg_mem_peak)
-          PEAK_KB=$((PEAK_BYTES / 1024))
-          echo "memory.peak_bytes=$PEAK_BYTES"
-          echo "memory.peak_kb=$PEAK_KB"
-          test "$PEAK_KB" -le "$MAX_CG_PEAK"
-
-      - name: virtual memory regression
+      - name: memory regression
         run: |
           export LPD_VmHWM=`cat LPD.VmHWM`
           echo "Peak resident set size: $LPD_VmHWM"
-          test "$LPD_VmHWM" -le "$MAX_VmHWM"
-
-      - name: cleanup cgroup
-        run: rmdir $CG_ROOT/$CG
+          test "$LPD_VmHWM" -le "$MAX_MEMORY"
 
       - name: duration regression
         run: |
@@ -312,8 +177,7 @@ jobs:
           export AVG_DURATION=`cat puppeteer.out|grep 'avg run'|sed 's/avg run duration (ms) //'`
           export TOTAL_DURATION=`cat puppeteer.out|grep 'total duration'|sed 's/total duration (ms) //'`
           export LPD_VmHWM=`cat LPD.VmHWM`
-          export LPD_CG_PEAK_KB=$(( $(cat LPD.cg_mem_peak) / 1024 ))
-          echo "{\"duration_total\":${TOTAL_DURATION},\"duration_avg\":${AVG_DURATION},\"mem_peak\":${LPD_VmHWM},\"cg_mem_peak\":${LPD_CG_PEAK_KB}}" > bench.json
+          echo "{\"duration_total\":${TOTAL_DURATION},\"duration_avg\":${AVG_DURATION},\"mem_peak\":${LPD_VmHWM}}" > bench.json
           cat bench.json
 
       - name: run hyperfine
@@ -328,7 +192,7 @@ jobs:
           echo "${{github.sha}}" > commit.txt
 
       - name: upload artifact
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v4
         with:
           name: bench-results
           path: |
@@ -351,12 +215,12 @@ jobs:
     container:
       image: ghcr.io/lightpanda-io/perf-fmt:latest
       credentials:
-        username: ${{ github.actor }}
-        password: ${{ secrets.GITHUB_TOKEN }}
+       username: ${{ github.actor }}
+       password: ${{ secrets.GITHUB_TOKEN }}
 
     steps:
       - name: download artifact
-        uses: actions/download-artifact@v8
+        uses: actions/download-artifact@v4
         with:
           name: bench-results
 
@@ -365,19 +229,3 @@ jobs:
 
       - name: format and send json result
         run: /perf-fmt hyperfine ${{ github.sha }} hyperfine.json
-
-  browser-fetch:
-    name: browser fetch
-    needs: zig-build-release
-
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: download artifact
-        uses: actions/download-artifact@v8
-        with:
-          name: lightpanda-build-release
-
-      - run: chmod a+x ./lightpanda
-
-      - run: ./lightpanda fetch https://demo-browser.lightpanda.io/campfire-commerce/

.github/workflows/wpt.yml

@@ -5,126 +5,39 @@ env:
   AWS_SECRET_ACCESS_KEY: ${{ secrets.LPD_PERF_AWS_SECRET_ACCESS_KEY }}
   AWS_BUCKET: ${{ vars.LPD_PERF_AWS_BUCKET }}
   AWS_REGION: ${{ vars.LPD_PERF_AWS_REGION }}
-  AWS_CF_DISTRIBUTION: ${{ vars.AWS_CF_DISTRIBUTION }}
   LIGHTPANDA_DISABLE_TELEMETRY: true
 
 on:
   schedule:
-    - cron: "21 2 * * *"
+    - cron: "23 2 * * *"
 
   # Allows you to run this workflow manually from the Actions tab
   workflow_dispatch:
 
 jobs:
-  wpt-build-release:
-    name: zig build release
+  wpt:
+    name: web platform tests json output
 
-    env:
-      ARCH: aarch64
-      OS: linux
-
-    runs-on: ubuntu-24.04-arm
-    timeout-minutes: 20
+    runs-on: ubuntu-latest
+    timeout-minutes: 90
 
     steps:
       - uses: actions/checkout@v6
         with:
           fetch-depth: 0
+          submodules: recursive
 
       - uses: ./.github/actions/install
-        with:
-          os: ${{env.OS}}
-          arch: ${{env.ARCH}}
 
-      - name: v8 snapshot
-        run: zig build -Dprebuilt_v8_path=v8/libc_v8.a -Doptimize=ReleaseFast snapshot_creator -- src/snapshot.bin
-
-      - name: zig build release
-        run: zig build -Dsnapshot_path=../../snapshot.bin -Dprebuilt_v8_path=v8/libc_v8.a -Doptimize=ReleaseFast -Dcpu=generic -Dgit_commit=$(git rev-parse --short ${{ github.sha }})
-
-      - name: upload artifact
-        uses: actions/upload-artifact@v7
-        with:
-          name: lightpanda-build-release
-          path: |
-            zig-out/bin/lightpanda
-          retention-days: 1
-
-  wpt-build-runner:
-    name: build wpt runner
-
-    runs-on: ubuntu-24.04-arm
-    timeout-minutes: 15
-
-    steps:
-      - uses: actions/checkout@v6
-        with:
-          repository: 'lightpanda-io/demo'
-          fetch-depth: 0
-
-      - run: |
-          cd ./wptrunner
-          CGO_ENABLED=0 go build
-
-      - name: upload artifact
-        uses: actions/upload-artifact@v7
-        with:
-          name: wptrunner
-          path: |
-            wptrunner/wptrunner
-          retention-days: 1
-
-  run-wpt:
-    name: web platform tests json output
-    needs:
-      - wpt-build-release
-      - wpt-build-runner
-
-    # use a self host runner.
-    runs-on: lpd-wpt-aws
-    timeout-minutes: 600
-
-    steps:
-      - uses: actions/checkout@v6
-        with:
-          ref: fork
-          repository: 'lightpanda-io/wpt'
-          fetch-depth: 0
-
-      # The hosts are configured manually on the self host runner.
-      # - name: create custom hosts
-      #   run: ./wpt make-hosts-file | sudo tee -a /etc/hosts
-
-      - name: generate manifest
-        run: ./wpt manifest
-
-      - name: download lightpanda release
-        uses: actions/download-artifact@v8
-        with:
-          name: lightpanda-build-release
-
-      - run: chmod a+x ./lightpanda
-
-      - name: download wptrunner
-        uses: actions/download-artifact@v8
-        with:
-          name: wptrunner
-
-      - run: chmod a+x ./wptrunner
-
-      - name: run test with json output
-        run: |
-          ./wpt serve 2> /dev/null & echo $! > WPT.pid
-          sleep 20s
-          ./wptrunner -lpd-path ./lightpanda -json -concurrency 5 -pool 5 --mem-limit 400 > wpt.json
-          kill `cat WPT.pid`
+      - name: json output
+        run: zig build wpt -- --json > wpt.json
 
       - name: write commit
         run: |
           echo "${{github.sha}}" > commit.txt
 
       - name: upload artifact
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v4
         with:
           name: wpt-results
           path: |
@@ -134,7 +47,7 @@ jobs:
 
   perf-fmt:
     name: perf-fmt
-    needs: run-wpt
+    needs: wpt
 
     runs-on: ubuntu-latest
     timeout-minutes: 15
@@ -147,7 +60,7 @@ jobs:
 
     steps:
       - name: download artifact
-        uses: actions/download-artifact@v8
+        uses: actions/download-artifact@v4
         with:
           name: wpt-results
 

.github/workflows/zig-fmt.yml

@@ -0,0 +1,60 @@
+name: zig-fmt
+
+on:
+  pull_request:
+
+    # By default GH trigger on types opened, synchronize and reopened.
+    # see https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows#pull_request
+    # Since we skip the job when the PR is in draft state, we want to force CI
+    # running when the PR is marked ready_for_review w/o other change.
+    # see https://github.com/orgs/community/discussions/25722#discussioncomment-3248917
+    types: [opened, synchronize, reopened, ready_for_review]
+
+    paths:
+      - ".github/**"
+      - "build.zig"
+      - "src/**/*.zig"
+      - "src/*.zig"
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+jobs:
+  zig-fmt:
+    name: zig fmt
+
+    # Don't run the CI with draft PR.
+    if: github.event.pull_request.draft == false
+
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+
+      # Zig version used from the `minimum_zig_version` field in build.zig.zon
+      - uses: mlugg/setup-zig@v2
+
+      - name: Run zig fmt
+        id: fmt
+        run: |
+          zig fmt --check ./*.zig ./**/*.zig 2> zig-fmt.err > zig-fmt.err2 || echo "Failed"
+          delimiter="$(openssl rand -hex 8)"
+          echo "zig_fmt_errs<<${delimiter}" >> "${GITHUB_OUTPUT}"
+
+          if [ -s zig-fmt.err ]; then
+            echo "// The following errors occurred:" >> "${GITHUB_OUTPUT}"
+            cat zig-fmt.err >> "${GITHUB_OUTPUT}"
+          fi
+
+          if [ -s zig-fmt.err2 ]; then
+            echo "// The following files were not formatted:" >> "${GITHUB_OUTPUT}"
+            cat zig-fmt.err2 >> "${GITHUB_OUTPUT}"
+          fi
+
+          echo "${delimiter}" >> "${GITHUB_OUTPUT}"
+
+      - name: Fail the job
+        if: steps.fmt.outputs.zig_fmt_errs != ''
+        run: exit 1

.github/workflows/zig-test.yml

@@ -5,18 +5,20 @@ env:
   AWS_SECRET_ACCESS_KEY: ${{ secrets.LPD_PERF_AWS_SECRET_ACCESS_KEY }}
   AWS_BUCKET: ${{ vars.LPD_PERF_AWS_BUCKET }}
   AWS_REGION: ${{ vars.LPD_PERF_AWS_REGION }}
-  LIGHTPANDA_DISABLE_TELEMETRY: true
 
 on:
   push:
-    branches: [main]
+    branches:
+      - main
     paths:
-      - ".github/**"
-      - "src/**"
       - "build.zig"
-      - "build.zig.zon"
-
+      - "src/**/*.zig"
+      - "src/*.zig"
+      - "vendor/zig-js-runtime"
+      - ".github/**"
+      - "vendor/**"
   pull_request:
+
     # By default GH trigger on types opened, synchronize and reopened.
     # see https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows#pull_request
     # Since we skip the job when the PR is in draft state, we want to force CI
@@ -26,95 +28,89 @@ on:
 
     paths:
       - ".github/**"
-      - "src/**"
       - "build.zig"
-      - "build.zig.zon"
-
+      - "src/**/*.zig"
+      - "src/*.zig"
+      - "vendor/**"
+      - ".github/**"
+      - "vendor/**"
   # Allows you to run this workflow manually from the Actions tab
   workflow_dispatch:
 
 jobs:
-  zig-fmt:
-    name: zig fmt
-
-    runs-on: ubuntu-latest
-    timeout-minutes: 15
+  zig-build-dev:
+    name: zig build dev
 
+    # Don't run the CI with draft PR.
     if: github.event.pull_request.draft == false
 
-    steps:
-      - uses: actions/checkout@v6
-
-      # Zig version used from the `minimum_zig_version` field in build.zig.zon
-      - uses: mlugg/setup-zig@v2
-
-      - name: Run zig fmt
-        id: fmt
-        run: |
-          zig fmt --check ./*.zig ./**/*.zig 2> zig-fmt.err > zig-fmt.err2 || echo "Failed"
-          delimiter="$(openssl rand -hex 8)"
-          echo "zig_fmt_errs<<${delimiter}" >> "${GITHUB_OUTPUT}"
-
-          if [ -s zig-fmt.err ]; then
-            echo "// The following errors occurred:" >> "${GITHUB_OUTPUT}"
-            cat zig-fmt.err >> "${GITHUB_OUTPUT}"
-          fi
-
-          if [ -s zig-fmt.err2 ]; then
-            echo "// The following files were not formatted:" >> "${GITHUB_OUTPUT}"
-            cat zig-fmt.err2 >> "${GITHUB_OUTPUT}"
-          fi
-
-          echo "${delimiter}" >> "${GITHUB_OUTPUT}"
-
-      - name: Fail the job
-        if: steps.fmt.outputs.zig_fmt_errs != ''
-        run: exit 1
-
-  zig-test-debug:
-    name: zig test using v8 in debug mode
-
     runs-on: ubuntu-latest
-    timeout-minutes: 15
-
-    if: github.event.pull_request.draft == false
 
     steps:
       - uses: actions/checkout@v6
         with:
           fetch-depth: 0
+          submodules: recursive
 
       - uses: ./.github/actions/install
+
+      - name: zig build debug
+        run: zig build -Dprebuilt_v8_path=v8/libc_v8.a
+
+      - name: upload artifact
+        uses: actions/upload-artifact@v4
         with:
-          debug: true
+          name: lightpanda-build-dev
+          path: |
+            zig-out/bin/lightpanda
+          retention-days: 1
 
-      - name: zig build test
-        run: zig build -Dprebuilt_v8_path=v8/libc_v8_debug.a -Dtsan=true test
+  browser-fetch:
+    name: browser fetch
+    needs: zig-build-dev
 
-  zig-test-release:
+    # Don't run the CI with draft PR.
+    if: github.event.pull_request.draft == false
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: download artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: lightpanda-build-dev
+
+      - run: chmod a+x ./lightpanda
+
+      - run: ./lightpanda fetch https://httpbin.io/xhr/get
+
+  zig-test:
     name: zig test
-
-    runs-on: ubuntu-latest
     timeout-minutes: 15
 
+    # Don't run the CI with draft PR.
     if: github.event.pull_request.draft == false
 
+    runs-on: ubuntu-latest
+
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
+          # fetch submodules recusively, to get zig-js-runtime submodules also.
+          submodules: recursive
 
       - uses: ./.github/actions/install
 
       - name: zig build test
-        run: METRICS=true zig build -Dprebuilt_v8_path=v8/libc_v8.a test > bench.json
+        run: zig build  -Dprebuilt_v8_path=v8/libc_v8.a test -- --json > bench.json
 
       - name: write commit
         run: |
           echo "${{github.sha}}" > commit.txt
 
       - name: upload artifact
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v4
         with:
           name: bench-results
           path: |
@@ -124,22 +120,23 @@ jobs:
 
   bench-fmt:
     name: perf-fmt
-    needs: zig-test-release
+    needs: zig-test
+
+    # Don't execute on PR
+    if: github.event_name != 'pull_request'
 
     runs-on: ubuntu-latest
     timeout-minutes: 15
 
-    if: github.event_name != 'pull_request'
-
     container:
       image: ghcr.io/lightpanda-io/perf-fmt:latest
       credentials:
-        username: ${{ github.actor }}
-        password: ${{ secrets.GITHUB_TOKEN }}
+       username: ${{ github.actor }}
+       password: ${{ secrets.GITHUB_TOKEN }}
 
     steps:
       - name: download artifact
-        uses: actions/download-artifact@v8
+        uses: actions/download-artifact@v4
         with:
           name: bench-results
 

.gitignore

@@ -1,6 +1,8 @@
+zig-cache
 /.zig-cache/
 /.lp-cache/
 zig-out
+/vendor/netsurf/out
+/vendor/libiconv/
 lightpanda.id
-/src/html5ever/target/
-src/snapshot.bin
+/v8/

.gitmodules

@@ -0,0 +1,33 @@
+[submodule "vendor/netsurf/libwapcaplet"]
+	path = vendor/netsurf/libwapcaplet
+	url = https://github.com/lightpanda-io/libwapcaplet.git/
+[submodule "vendor/netsurf/libparserutils"]
+	path = vendor/netsurf/libparserutils
+	url = https://github.com/lightpanda-io/libparserutils.git/
+[submodule "vendor/netsurf/libdom"]
+	path = vendor/netsurf/libdom
+	url = https://github.com/lightpanda-io/libdom.git/
+[submodule "vendor/netsurf/share/netsurf-buildsystem"]
+	path = vendor/netsurf/share/netsurf-buildsystem
+	url = https://github.com/lightpanda-io/netsurf-buildsystem.git
+[submodule "vendor/netsurf/libhubbub"]
+	path = vendor/netsurf/libhubbub
+	url = https://github.com/lightpanda-io/libhubbub.git/
+[submodule "tests/wpt"]
+	path = tests/wpt
+	url = https://github.com/lightpanda-io/wpt
+[submodule "vendor/mimalloc"]
+	path = vendor/mimalloc
+	url = https://github.com/microsoft/mimalloc.git/
+[submodule "vendor/nghttp2"]
+	path = vendor/nghttp2
+	url = https://github.com/nghttp2/nghttp2.git
+[submodule "vendor/zlib"]
+	path = vendor/zlib
+	url = https://github.com/madler/zlib.git
+[submodule "vendor/curl"]
+	path = vendor/curl
+	url = https://github.com/curl/curl.git
+[submodule "vendor/brotli"]
+	path = vendor/brotli
+	url = https://github.com/google/brotli

Dockerfile

@@ -3,17 +3,16 @@ FROM debian:stable-slim
 ARG MINISIG=0.12
 ARG ZIG_MINISIG=RWSGOq2NVecA2UPNdBUZykf1CCb147pkmdtYxgb3Ti+JO/wCYvhbAb/U
 ARG V8=14.0.365.4
-ARG ZIG_V8=v0.3.4
+ARG ZIG_V8=v0.1.34
 ARG TARGETPLATFORM
 
 RUN apt-get update -yq && \
-    apt-get install -yq xz-utils ca-certificates \
+    apt-get install -yq xz-utils \
+        python3 ca-certificates git \
         pkg-config libglib2.0-dev \
-        clang make curl git
-
-# Get Rust
-RUN curl https://sh.rustup.rs -sSf | sh -s -- --profile minimal -y
-ENV PATH="/root/.cargo/bin:${PATH}"
+        gperf libexpat1-dev \
+        cmake clang \
+        curl git
 
 # install minisig
 RUN curl --fail -L -O https://github.com/jedisct1/minisign/releases/download/${MINISIG}/minisign-${MINISIG}-linux.tar.gz && \
@@ -36,6 +35,14 @@ RUN ZIG=$(grep '\.minimum_zig_version = "' "build.zig.zon" | cut -d'"' -f2) && \
     mv zig-${ARCH}-linux-${ZIG} /usr/local/lib && \
     ln -s /usr/local/lib/zig-${ARCH}-linux-${ZIG}/zig /usr/local/bin/zig
 
+# install deps
+RUN git submodule init && \
+    git submodule update --recursive
+
+RUN make install-libiconv && \
+    make install-netsurf && \
+    make install-mimalloc
+
 # download and install v8
 RUN case $TARGETPLATFORM in \
     "linux/arm64") ARCH="aarch64" ;; \
@@ -45,16 +52,8 @@ RUN case $TARGETPLATFORM in \
     mkdir -p v8/ && \
     mv libc_v8.a v8/libc_v8.a
 
-# build v8 snapshot
-RUN zig build -Doptimize=ReleaseFast \
-    -Dprebuilt_v8_path=v8/libc_v8.a \
-    snapshot_creator -- src/snapshot.bin
-
 # build release
-RUN zig build -Doptimize=ReleaseFast \
-    -Dsnapshot_path=../../snapshot.bin \
-    -Dprebuilt_v8_path=v8/libc_v8.a \
-    -Dgit_commit=$(git rev-parse --short HEAD)
+RUN zig build -Doptimize=ReleaseSafe -Dprebuilt_v8_path=v8/libc_v8.a -Dgit_commit=$$(git rev-parse --short HEAD)
 
 FROM debian:stable-slim
 

LICENSING.md

@@ -5,6 +5,14 @@ List](https://spdx.org/licenses/).
 
 The default license for this project is [AGPL-3.0-only](LICENSE).
 
+## MIT
+
+The following files are licensed under MIT:
+
+```
+src/polyfill/fetch.js
+```
+
 The following directories and their subdirectories are licensed under their
 original upstream licenses:
 

Makefile

@@ -47,18 +47,12 @@ help:
 
 # $(ZIG) commands
 # ------------
-.PHONY: build build-v8-snapshot build-dev run run-release test bench data end2end
+.PHONY: build build-dev run run-release shell test bench wpt data end2end
 
-## Build v8 snapshot
-build-v8-snapshot:
-	@printf "\033[36mBuilding v8 snapshot (release safe)...\033[0m\n"
-	@$(ZIG) build -Doptimize=ReleaseFast snapshot_creator -- src/snapshot.bin || (printf "\033[33mBuild ERROR\033[0m\n"; exit 1;)
-	@printf "\033[33mBuild OK\033[0m\n"
-
-## Build in release-fast mode
-build: build-v8-snapshot
-	@printf "\033[36mBuilding (release fast)...\033[0m\n"
-	@$(ZIG) build -Doptimize=ReleaseFast -Dsnapshot_path=../../snapshot.bin -Dgit_commit=$$(git rev-parse --short HEAD) || (printf "\033[33mBuild ERROR\033[0m\n"; exit 1;)
+## Build in release-safe mode
+build:
+	@printf "\033[36mBuilding (release safe)...\033[0m\n"
+	$(ZIG) build -Doptimize=ReleaseSafe -Dgit_commit=$$(git rev-parse --short HEAD) || (printf "\033[33mBuild ERROR\033[0m\n"; exit 1;)
 	@printf "\033[33mBuild OK\033[0m\n"
 
 ## Build in debug mode
@@ -77,14 +71,28 @@ run-debug: build-dev
 	@printf "\033[36mRunning...\033[0m\n"
 	@./zig-out/bin/lightpanda || (printf "\033[33mRun ERROR\033[0m\n"; exit 1;)
 
+## Run a JS shell in debug mode
+shell:
+	@printf "\033[36mBuilding shell...\033[0m\n"
+	@$(ZIG) build shell || (printf "\033[33mBuild ERROR\033[0m\n"; exit 1;)
+
+## Run WPT tests
+wpt:
+	@printf "\033[36mBuilding wpt...\033[0m\n"
+	@$(ZIG) build wpt -- $(filter-out $@,$(MAKECMDGOALS)) || (printf "\033[33mBuild ERROR\033[0m\n"; exit 1;)
+
+wpt-summary:
+	@printf "\033[36mBuilding wpt...\033[0m\n"
+	@$(ZIG) build wpt -- --summary $(filter-out $@,$(MAKECMDGOALS)) || (printf "\033[33mBuild ERROR\033[0m\n"; exit 1;)
+
 ## Test - `grep` is used to filter out the huge compile command on build
 ifeq ($(OS), macos)
 test:
-	@script -q /dev/null sh -c 'TEST_FILTER="${F}" $(ZIG) build test -freference-trace' 2>&1 \
+	@script -q /dev/null sh -c 'TEST_FILTER="${F}" $(ZIG) build test -freference-trace --summary all' 2>&1 \
 		| grep --line-buffered -v "^/.*zig test -freference-trace"
 else
 test:
-	@script -qec 'TEST_FILTER="${F}" $(ZIG) build test -freference-trace' /dev/null 2>&1 \
+	@script -qec 'TEST_FILTER="${F}" $(ZIG) build test -freference-trace --summary all' /dev/null 2>&1 \
 		| grep --line-buffered -v "^/.*zig test -freference-trace"
 endif
 
@@ -95,9 +103,129 @@ end2end:
 
 # Install and build required dependencies commands
 # ------------
-.PHONY: install
+.PHONY: install-submodule
+.PHONY: install-libiconv
+.PHONY: _install-netsurf install-netsurf clean-netsurf test-netsurf install-netsurf-dev
+.PHONY: install-mimalloc install-mimalloc-dev clean-mimalloc
+.PHONY: install-dev install
 
-install: build
+## Install and build dependencies for release
+install: install-submodule install-libiconv install-netsurf install-mimalloc
+
+## Install and build dependencies for dev
+install-dev: install-submodule install-libiconv install-netsurf-dev install-mimalloc-dev
+
+install-netsurf-dev: _install-netsurf
+install-netsurf-dev: OPTCFLAGS := -O0 -g -DNDEBUG
+
+install-netsurf: _install-netsurf
+install-netsurf: OPTCFLAGS := -DNDEBUG
+
+BC_NS := $(BC)vendor/netsurf/out/$(OS)-$(ARCH)
+ICONV := $(BC)vendor/libiconv/out/$(OS)-$(ARCH)
+# TODO: add Linux iconv path (I guess it depends on the distro)
+# TODO: this way of linking libiconv is not ideal. We should have a more generic way
+# and stick to a specif version. Maybe build from source. Anyway not now.
+_install-netsurf: clean-netsurf
+	@printf "\033[36mInstalling NetSurf...\033[0m\n" && \
+	ls $(ICONV)/lib/libiconv.a 1> /dev/null || (printf "\033[33mERROR: you need to execute 'make install-libiconv'\033[0m\n"; exit 1;) && \
+	mkdir -p $(BC_NS) && \
+	cp -R vendor/netsurf/share $(BC_NS) && \
+	export PREFIX=$(BC_NS) && \
+	export OPTLDFLAGS="-L$(ICONV)/lib" && \
+	export OPTCFLAGS="$(OPTCFLAGS) -I$(ICONV)/include" && \
+	printf "\033[33mInstalling libwapcaplet...\033[0m\n" && \
+	cd vendor/netsurf/libwapcaplet && \
+	BUILDDIR=$(BC_NS)/build/libwapcaplet make install && \
+	cd ../libparserutils && \
+	printf "\033[33mInstalling libparserutils...\033[0m\n" && \
+	BUILDDIR=$(BC_NS)/build/libparserutils make install && \
+	cd ../libhubbub && \
+	printf "\033[33mInstalling libhubbub...\033[0m\n" && \
+	BUILDDIR=$(BC_NS)/build/libhubbub make install && \
+	rm src/treebuilder/autogenerated-element-type.c && \
+	cd ../libdom && \
+	printf "\033[33mInstalling libdom...\033[0m\n" && \
+	BUILDDIR=$(BC_NS)/build/libdom make install && \
+	printf "\033[33mRunning libdom example...\033[0m\n" && \
+	cd examples && \
+	$(ZIG) cc \
+	-I$(ICONV)/include \
+	-I$(BC_NS)/include \
+	-L$(ICONV)/lib \
+	-L$(BC_NS)/lib \
+	-liconv \
+	-ldom \
+	-lhubbub \
+	-lparserutils \
+	-lwapcaplet \
+	-o a.out \
+	dom-structure-dump.c \
+	$(ICONV)/lib/libiconv.a && \
+	./a.out > /dev/null && \
+	rm a.out && \
+	printf "\033[36mDone NetSurf $(OS)\033[0m\n"
+
+clean-netsurf:
+	@printf "\033[36mCleaning NetSurf build...\033[0m\n" && \
+	rm -Rf $(BC_NS)
+
+test-netsurf:
+	@printf "\033[36mTesting NetSurf...\033[0m\n" && \
+	export PREFIX=$(BC_NS) && \
+	export LDFLAGS="-L$(ICONV)/lib -L$(BC_NS)/lib" && \
+	export CFLAGS="-I$(ICONV)/include -I$(BC_NS)/include" && \
+	cd vendor/netsurf/libdom && \
+	BUILDDIR=$(BC_NS)/build/libdom make test
+
+download-libiconv:
+ifeq ("$(wildcard vendor/libiconv/libiconv-1.17)","")
+	@mkdir -p vendor/libiconv
+	@cd vendor/libiconv && \
+	curl -L https://github.com/lightpanda-io/libiconv/releases/download/1.17/libiconv-1.17.tar.gz | tar -xvzf -
+endif
+
+build-libiconv: clean-libiconv
+	@cd vendor/libiconv/libiconv-1.17 && \
+	./configure --prefix=$(ICONV) --enable-static && \
+	make && make install
+
+install-libiconv: download-libiconv build-libiconv
+
+clean-libiconv:
+ifneq ("$(wildcard vendor/libiconv/libiconv-1.17/Makefile)","")
+	@cd vendor/libiconv/libiconv-1.17 && \
+	make clean
+endif
 
 data:
 	cd src/data && go run public_suffix_list_gen.go > public_suffix_list.zig
+
+.PHONY: _build_mimalloc
+
+MIMALLOC := $(BC)vendor/mimalloc/out/$(OS)-$(ARCH)
+_build_mimalloc: clean-mimalloc
+	@mkdir -p $(MIMALLOC)/build && \
+	cd $(MIMALLOC)/build && \
+	cmake -DMI_BUILD_SHARED=OFF -DMI_BUILD_OBJECT=OFF -DMI_BUILD_TESTS=OFF -DMI_OVERRIDE=OFF $(OPTS) ../../.. && \
+	make && \
+	mkdir -p $(MIMALLOC)/lib
+
+install-mimalloc-dev: _build_mimalloc
+install-mimalloc-dev: OPTS=-DCMAKE_BUILD_TYPE=Debug
+install-mimalloc-dev:
+	@cd $(MIMALLOC) && \
+	mv build/libmimalloc-debug.a lib/libmimalloc.a
+
+install-mimalloc: _build_mimalloc
+install-mimalloc:
+	@cd $(MIMALLOC) && \
+	mv build/libmimalloc.a lib/libmimalloc.a
+
+clean-mimalloc:
+	@rm -Rf $(MIMALLOC)/build
+
+## Init and update git submodule
+install-submodule:
+	@git submodule init && \
+	git submodule update

README.md

@@ -1,32 +1,18 @@
 <p align="center">
   <a href="https://lightpanda.io"><img src="https://cdn.lightpanda.io/assets/images/logo/lpd-logo.png" alt="Logo" height=170></a>
 </p>
-<h1 align="center">Lightpanda Browser</h1>
-<p align="center">
-<strong>The headless browser built from scratch for AI agents and automation.</strong><br>
-Not a Chromium fork. Not a WebKit patch. A new browser, written in Zig.
-</p>
 
-</div>
+<h1 align="center">Lightpanda Browser</h1>
+
+<p align="center"><a href="https://lightpanda.io/">lightpanda.io</a></p>
+
 <div align="center">
 
 [![License](https://img.shields.io/github/license/lightpanda-io/browser)](https://github.com/lightpanda-io/browser/blob/main/LICENSE)
 [![Twitter Follow](https://img.shields.io/twitter/follow/lightpanda_io)](https://twitter.com/lightpanda_io)
 [![GitHub stars](https://img.shields.io/github/stars/lightpanda-io/browser)](https://github.com/lightpanda-io/browser)
-[![Discord](https://img.shields.io/discord/1391984864894521354?style=flat-square&label=discord)](https://discord.gg/K63XeymfB5)
 
 </div>
-<div align="center">
-
-[<img width="350px" src="https://cdn.lightpanda.io/assets/images/github/execution-time.svg">
-](https://github.com/lightpanda-io/demo)
-&emsp;
-[<img width="350px" src="https://cdn.lightpanda.io/assets/images/github/memory-frame.svg">
-](https://github.com/lightpanda-io/demo)
-</div>
-
-_Puppeteer requesting 100 pages from a local website on a AWS EC2 m5.large instance.
-See [benchmark details](https://github.com/lightpanda-io/demo)._
 
 Lightpanda is the open-source browser made for headless usage:
 
@@ -40,6 +26,16 @@ Fast web automation for AI agents, LLM training, scraping and testing:
 - Exceptionally fast execution (11x faster than Chrome)
 - Instant startup
 
+[<img width="350px" src="https://cdn.lightpanda.io/assets/images/github/execution-time.svg">
+](https://github.com/lightpanda-io/demo)
+&emsp;
+[<img width="350px" src="https://cdn.lightpanda.io/assets/images/github/memory-frame.svg">
+](https://github.com/lightpanda-io/demo)
+</div>
+
+_Puppeteer requesting 100 pages from a local website on a AWS EC2 m5.large instance.
+See [benchmark details](https://github.com/lightpanda-io/demo)._
+
 [^1]: **Playwright support disclaimer:**
 Due to the nature of Playwright, a script that works with the current version of the browser may not function correctly with a future version. Playwright uses an intermediate JavaScript layer that selects an execution strategy based on the browser's available features. If Lightpanda adds a new [Web API](https://developer.mozilla.org/en-US/docs/Web/API), Playwright may choose to execute different code for the same script. This new code path could attempt to use features that are not yet implemented. Lightpanda makes an effort to add compatibility tests, but we can't cover all scenarios. If you encounter an issue, please create a [GitHub issue](https://github.com/lightpanda-io/browser/issues) and include the last known working version of the script.
 
@@ -82,49 +78,23 @@ docker run -d --name lightpanda -p 9222:9222 lightpanda/browser:nightly
 ### Dump a URL
 
 ```console
-./lightpanda fetch --obey_robots --log_format pretty  --log_level info https://demo-browser.lightpanda.io/campfire-commerce/
+./lightpanda fetch --dump https://lightpanda.io
 ```
 ```console
-INFO  telemetry : telemetry status . . . . . . . . . . . . .  [+0ms]
-      disabled = false
-
-INFO  page : navigate . . . . . . . . . . . . . . . . . . . . [+6ms]
-      url = https://demo-browser.lightpanda.io/campfire-commerce/
-      method = GET
-      reason = address_bar
-      body = false
-      req_id = 1
-
-INFO  browser : executing script . . . . . . . . . . . . . .  [+118ms]
-      src = https://demo-browser.lightpanda.io/campfire-commerce/script.js
-      kind = javascript
-      cacheable = true
-
-INFO  http : request complete . . . . . . . . . . . . . . . . [+140ms]
-      source = xhr
-      url = https://demo-browser.lightpanda.io/campfire-commerce/json/product.json
-      status = 200
-      len = 4770
-
-INFO  http : request complete . . . . . . . . . . . . . . . . [+141ms]
-      source = fetch
-      url = https://demo-browser.lightpanda.io/campfire-commerce/json/reviews.json
-      status = 200
-      len = 1615
+info(browser): GET https://lightpanda.io/ http.Status.ok
+info(browser): fetch script https://api.website.lightpanda.io/js/script.js: http.Status.ok
+info(browser): eval remote https://api.website.lightpanda.io/js/script.js: TypeError: Cannot read properties of undefined (reading 'pushState')
 <!DOCTYPE html>
 ```
 
 ### Start a CDP server
 
 ```console
-./lightpanda serve --obey_robots --log_format pretty  --log_level info --host 127.0.0.1 --port 9222
+./lightpanda serve --host 127.0.0.1 --port 9222
 ```
 ```console
-INFO  telemetry : telemetry status . . . . . . . . . . . . .  [+0ms]
-      disabled = false
-
-INFO  app : server running . . . . . . . . . . . . . . . . .  [+0ms]
-      address = 127.0.0.1:9222
+info(websocket): starting blocking worker to listen on 127.0.0.1:9222
+info(server): accepting new conn...
 ```
 
 Once the CDP server started, you can run a Puppeteer script by configuring the
@@ -145,7 +115,7 @@ const context = await browser.createBrowserContext();
 const page = await context.newPage();
 
 // Dump all the links from the page.
-await page.goto('https://demo-browser.lightpanda.io/amiibo/', {waitUntil: "networkidle0"});
+await page.goto('https://wikipedia.com/');
 
 const links = await page.evaluate(() => {
   return Array.from(document.querySelectorAll('a')).map(row => {
@@ -170,14 +140,13 @@ You may still encounter errors or crashes. Please open an issue with specifics i
 
 Here are the key features we have implemented:
 
-- [x] HTTP loader ([Libcurl](https://curl.se/libcurl/))
-- [x] HTML parser ([html5ever](https://github.com/servo/html5ever))
-- [x] DOM tree
-- [x] Javascript support ([v8](https://v8.dev/))
+- [x] HTTP loader (based on Libcurl)
+- [x] HTML parser and DOM tree (based on Netsurf libs)
+- [x] Javascript support (v8)
 - [x] DOM APIs
 - [x] Ajax
   - [x] XHR API
-  - [x] Fetch API
+  - [x] Fetch API (polyfill)
 - [x] DOM dump
 - [x] CDP/websockets server
 - [x] Click
@@ -186,7 +155,6 @@ Here are the key features we have implemented:
 - [x] Custom HTTP headers
 - [x] Proxy support
 - [x] Network interception
-- [x] Respect `robots.txt` with option `--obey_robots`
 
 NOTE: There are hundreds of Web APIs. Developing a browser (even just for headless mode) is a huge task. Coverage will increase over time.
 
@@ -198,53 +166,84 @@ Lightpanda is written with [Zig](https://ziglang.org/) `0.15.2`. You have to
 install it with the right version in order to build the project.
 
 Lightpanda also depends on
-[v8](https://chromium.googlesource.com/v8/v8.git),
-[Libcurl](https://curl.se/libcurl/) and [html5ever](https://github.com/servo/html5ever).
+[zig-v8-fork](https://github.com/lightpanda-io/zig-v8-fork/),
+[Libcurl](https://curl.se/libcurl/),
+[Brotli](https://github.com/google/brotli),
+[Netsurf libs](https://www.netsurf-browser.org/) and
+[Mimalloc](https://microsoft.github.io/mimalloc).
 
 To be able to build the v8 engine, you have to install some libs:
 
-For **Debian/Ubuntu based Linux**:
+For Debian/Ubuntu based Linux:
 
 ```
-sudo apt install xz-utils ca-certificates \
+sudo apt install xz-utils \
+    python3 ca-certificates git \
     pkg-config libglib2.0-dev \
-    clang make curl git
+    gperf libexpat1-dev unzip rsync \
+    cmake clang
 ```
-You also need to [install Rust](https://rust-lang.org/tools/install/).
 
-For systems with [**Nix**](https://nixos.org/download/), you can use the devShell:
+For systems with [Nix](https://nixos.org/download/), you can use the devShell:
 ```
 nix develop
 ```
 
-For **MacOS**, you need cmake and [Rust](https://rust-lang.org/tools/install/).
+For MacOS, you need [Xcode](https://developer.apple.com/xcode/) and the following pacakges from homebrew:
+
 ```
-brew install cmake
+brew install cmake pkgconf
 ```
 
-### Build and run
+### Install and build dependencies
 
-You an build the entire browser with `make build` or `make build-dev` for debug
-env.
+#### All in one build
 
-But you can directly use the zig command: `zig build run`.
+You can run `make install` to install deps all in one (or `make install-dev` if you need the development versions).
 
-#### Embed v8 snapshot
+Be aware that the build task is very long and cpu consuming, as you will build from sources all dependencies, including the v8 Javascript engine.
 
-Lighpanda uses v8 snapshot. By default, it is created on startup but you can
-embed it by using the following commands:
+#### Step by step build dependency
+
+The project uses git submodules for dependencies.
+
+To init or update the submodules in the `vendor/` directory:
 
-Generate the snapshot.
 ```
-zig build snapshot_creator -- src/snapshot.bin
+make install-submodule
 ```
 
-Build using the snapshot binary.
+**iconv**
+
+libiconv is an internationalization library used by Netsurf.
+
 ```
-zig build -Dsnapshot_path=../../snapshot.bin
+make install-libiconv
 ```
 
-See [#1279](https://github.com/lightpanda-io/browser/pull/1279) for more details.
+**Netsurf libs**
+
+Netsurf libs are used for HTML parsing and DOM tree generation.
+
+```
+make install-netsurf
+```
+
+For dev env, use `make install-netsurf-dev`.
+
+**Mimalloc**
+
+Mimalloc is used as a C memory allocator.
+
+```
+make install-mimalloc
+```
+
+For dev env, use `make install-mimalloc-dev`.
+
+Note: when Mimalloc is built in dev mode, you can dump memory stats with the
+env var `MIMALLOC_SHOW_STATS=1`. See
+[https://microsoft.github.io/mimalloc/environment.html](https://microsoft.github.io/mimalloc/environment.html).
 
 ## Test
 
@@ -271,75 +270,35 @@ make end2end
 Lightpanda is tested against the standardized [Web Platform
 Tests](https://web-platform-tests.org/).
 
-We use [a fork](https://github.com/lightpanda-io/wpt/tree/fork) including a custom
-[`testharnessreport.js`](https://github.com/lightpanda-io/wpt/commit/01a3115c076a3ad0c84849dbbf77a6e3d199c56f).
+The relevant tests cases are committed in a [dedicated repository](https://github.com/lightpanda-io/wpt) which is fetched by the `make install-submodule` command.
+
+All the tests cases executed are located in the `tests/wpt` sub-directory.
 
 For reference, you can easily execute a WPT test case with your browser via
 [wpt.live](https://wpt.live).
 
-#### Configure WPT HTTP server
-
-To run the test, you must clone the repository, configure the custom hosts and generate the
-`MANIFEST.json` file.
-
-Clone the repository with the `fork` branch.
-```
-git clone -b fork --depth=1 git@github.com:lightpanda-io/wpt.git
-```
-
-Enter into the `wpt/` dir.
-
-Install custom domains in your `/etc/hosts`
-```
-./wpt make-hosts-file | sudo tee -a /etc/hosts
-```
-
-Generate `MANIFEST.json`
-```
-./wpt manifest
-```
-Use the [WPT's setup
-guide](https://web-platform-tests.org/running-tests/from-local-system.html) for
-details.
-
 #### Run WPT test suite
 
-An external [Go](https://go.dev) runner is provided by
-[github.com/lightpanda-io/demo/](https://github.com/lightpanda-io/demo/)
-repository, located into `wptrunner/` dir.
-You need to clone the project first.
-
-First start the WPT's HTTP server from your `wpt/` clone dir.
-```
-./wpt serve
-```
-
-Run a Lightpanda browser
+To run all the tests:
 
 ```
-zig build run -- --insecure_disable_tls_host_verification
-```
-
-Then you can start the wptrunner from the Demo's clone dir:
-```
-cd wptrunner && go run .
+make wpt
 ```
 
 Or one specific test:
 
 ```
-cd wptrunner && go run . Node-childNodes.html
+make wpt Node-childNodes.html
 ```
 
-`wptrunner` command accepts `--summary` and `--json` options modifying output.
-Also `--concurrency` define the concurrency limit.
+#### Add a new WPT test case
 
-:warning: Running the whole test suite will take a long time. In this case,
-it's useful to build in `releaseFast` mode to make tests faster.
+We add new relevant tests cases files when we implemented changes in Lightpanda.
 
-```
-zig build -Doptimize=ReleaseFast run
-```
+To add a new test, copy the file you want from the [WPT
+repo](https://github.com/web-platform-tests/wpt) into the `tests/wpt` directory.
+
+:warning: Please keep the original directory tree structure of `tests/wpt`.
 
 ## Contributing
 

build.zig.zon

@@ -5,31 +5,18 @@
     .minimum_zig_version = "0.15.2",
     .dependencies = .{
         .v8 = .{
-            .url = "https://github.com/lightpanda-io/zig-v8-fork/archive/refs/tags/v0.3.4.tar.gz",
-            .hash = "v8-0.0.0-xddH6_F3BAAiFvKY6R1H-gkuQlk19BkDQ0--uZuTrSup",
+            .url = "https://github.com/lightpanda-io/zig-v8-fork/archive/e047d2a4d5af5783763f0f6a652fab8982a08603.tar.gz",
+            .hash = "v8-0.0.0-xddH65gMBACRBQMM7EwmVgfi94FJyyX-0jpe5KhXYhfv",
         },
         // .v8 = .{ .path = "../zig-v8-fork" },
-        .brotli = .{
-            // v1.2.0
-            .url = "https://github.com/google/brotli/archive/028fb5a23661f123017c060daa546b55cf4bde29.tar.gz",
-            .hash = "N-V-__8AAJudKgCQCuIiH6MJjAiIJHfg_tT_Ew-0vZwVkCo_",
-        },
-        .zlib = .{
-            .url = "https://github.com/madler/zlib/releases/download/v1.3.2/zlib-1.3.2.tar.gz",
-            .hash = "N-V-__8AAJ2cNgAgfBtAw33Bxfu1IWISDeKKSr3DAqoAysIJ",
-        },
-        .nghttp2 = .{
-            .url = "https://github.com/nghttp2/nghttp2/releases/download/v1.68.0/nghttp2-1.68.0.tar.gz",
-            .hash = "N-V-__8AAL15vQCI63ZL6Zaz5hJg6JTEgYXGbLnMFSnf7FT3",
+        .@"ada-singleheader" = .{
+            .url = "https://github.com/ada-url/ada/releases/download/v3.3.0/singleheader.zip",
+            .hash = "N-V-__8AAPmhFAAw64ALjlzd5YMtzpSrmZ6KymsT84BKfB4s",
         },
         .@"boringssl-zig" = .{
             .url = "git+https://github.com/Syndica/boringssl-zig.git#c53df00d06b02b755ad88bbf4d1202ed9687b096",
             .hash = "boringssl-0.1.0-VtJeWehMAAA4RNnwRnzEvKcS9rjsR1QVRw1uJrwXxmVK",
         },
-        .curl = .{
-            .url = "https://github.com/curl/curl/releases/download/curl-8_18_0/curl-8.18.0.tar.gz",
-            .hash = "N-V-__8AALp9QAGn6CCHZ6fK_FfMyGtG824LSHYHHasM3w-y",
-        },
     },
     .paths = .{""},
 }

flake.lock

@@ -1,26 +1,5 @@
 {
   "nodes": {
-    "fenix": {
-      "inputs": {
-        "nixpkgs": [
-          "nixpkgs"
-        ],
-        "rust-analyzer-src": "rust-analyzer-src"
-      },
-      "locked": {
-        "lastModified": 1770708269,
-        "narHash": "sha256-OnZW86app7hHJJoB5lC9GNXY5QBBIESJB+sIdwEyld0=",
-        "owner": "nix-community",
-        "repo": "fenix",
-        "rev": "6b5325a017a9a9fe7e6252ccac3680cc7181cd63",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-community",
-        "repo": "fenix",
-        "type": "github"
-      }
-    },
     "flake-compat": {
       "flake": false,
       "locked": {
@@ -96,11 +75,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1768649915,
-        "narHash": "sha256-jc21hKogFnxU7KXSVTRmxC7u5D4RHwm9BAvDf5/Z1Uo=",
+        "lastModified": 1760968520,
+        "narHash": "sha256-EjGslHDzCBKOVr+dnDB1CAD7wiQSHfUt3suOpFj9O1Q=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "3e3f3c7f9977dc123c23ee21e8085ed63daf8c37",
+        "rev": "e755547441a0413942a37692f7bf7fc6315bb7f6",
         "type": "github"
       },
       "original": {
@@ -112,30 +91,12 @@
     },
     "root": {
       "inputs": {
-        "fenix": "fenix",
         "flake-utils": "flake-utils",
         "nixpkgs": "nixpkgs",
         "zigPkgs": "zigPkgs",
         "zlsPkg": "zlsPkg"
       }
     },
-    "rust-analyzer-src": {
-      "flake": false,
-      "locked": {
-        "lastModified": 1770668050,
-        "narHash": "sha256-Q05yaIZtQrBKHpyWaPmyJmDRj0lojnVf8nUFE0vydcY=",
-        "owner": "rust-lang",
-        "repo": "rust-analyzer",
-        "rev": "9efc1f709f3c8134c3acac5d3592a8e4c184a0c6",
-        "type": "github"
-      },
-      "original": {
-        "owner": "rust-lang",
-        "ref": "nightly",
-        "repo": "rust-analyzer",
-        "type": "github"
-      }
-    },
     "systems": {
       "locked": {
         "lastModified": 1681028828,
@@ -175,11 +136,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1770598090,
-        "narHash": "sha256-k+82IDgTd9o5sxHIqGlvfwseKln3Ejx1edGtDltuPXo=",
+        "lastModified": 1760747435,
+        "narHash": "sha256-wNB/W3x+or4mdNxFPNOH5/WFckNpKgFRZk7OnOsLtm0=",
         "owner": "mitchellh",
         "repo": "zig-overlay",
-        "rev": "142495696982c88edddc8e17e4da90d8164acadf",
+        "rev": "d0f239b887b1ac736c0f3dde91bf5bf2ecf3a420",
         "type": "github"
       },
       "original": {

flake.nix

@@ -11,11 +11,6 @@
     zlsPkg.inputs.zig-overlay.follows = "zigPkgs";
     zlsPkg.inputs.nixpkgs.follows = "nixpkgs";
 
-    fenix = {
-      url = "github:nix-community/fenix";
-      inputs.nixpkgs.follows = "nixpkgs";
-    };
-
     flake-utils.url = "github:numtide/flake-utils";
   };
 
@@ -24,7 +19,6 @@
       nixpkgs,
       zigPkgs,
       zlsPkg,
-      fenix,
       flake-utils,
       ...
     }:
@@ -42,8 +36,6 @@
           inherit system overlays;
         };
 
-        rustToolchain = fenix.packages.${system}.stable.toolchain;
-
         # We need crtbeginS.o for building.
         crtFiles = pkgs.runCommand "crt-files" { } ''
           mkdir -p $out/lib
@@ -59,7 +51,6 @@
               # Build Tools
               zigpkgs."0.15.2"
               zls
-              rustToolchain
               python3
               pkg-config
               cmake
@@ -75,6 +66,7 @@
               glib.dev
               glibc.dev
               zlib
+              zlib.dev
             ];
         };
       in

src/App.zig

@@ -1,115 +0,0 @@
-// Copyright (C) 2023-2026  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program 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 Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-
-const Allocator = std.mem.Allocator;
-
-const log = @import("log.zig");
-const Config = @import("Config.zig");
-const Snapshot = @import("browser/js/Snapshot.zig");
-const Platform = @import("browser/js/Platform.zig");
-const Telemetry = @import("telemetry/telemetry.zig").Telemetry;
-
-const Network = @import("network/Runtime.zig");
-pub const ArenaPool = @import("ArenaPool.zig");
-
-const App = @This();
-
-network: Network,
-config: *const Config,
-platform: Platform,
-snapshot: Snapshot,
-telemetry: Telemetry,
-allocator: Allocator,
-arena_pool: ArenaPool,
-app_dir_path: ?[]const u8,
-
-pub fn init(allocator: Allocator, config: *const Config) !*App {
-    const app = try allocator.create(App);
-    errdefer allocator.destroy(app);
-
-    app.* = .{
-        .config = config,
-        .allocator = allocator,
-        .network = undefined,
-        .platform = undefined,
-        .snapshot = undefined,
-        .app_dir_path = undefined,
-        .telemetry = undefined,
-        .arena_pool = undefined,
-    };
-
-    app.network = try Network.init(allocator, app, config);
-    errdefer app.network.deinit();
-
-    app.platform = try Platform.init();
-    errdefer app.platform.deinit();
-
-    app.snapshot = try Snapshot.load();
-    errdefer app.snapshot.deinit();
-
-    app.app_dir_path = getAndMakeAppDir(allocator);
-
-    app.telemetry = try Telemetry.init(app, config.mode);
-    errdefer app.telemetry.deinit(allocator);
-
-    app.arena_pool = ArenaPool.init(allocator, 512, 1024 * 16);
-    errdefer app.arena_pool.deinit();
-
-    return app;
-}
-
-pub fn shutdown(self: *const App) bool {
-    return self.network.shutdown.load(.acquire);
-}
-
-pub fn deinit(self: *App) void {
-    const allocator = self.allocator;
-    if (self.app_dir_path) |app_dir_path| {
-        allocator.free(app_dir_path);
-        self.app_dir_path = null;
-    }
-    self.telemetry.deinit(allocator);
-    self.network.deinit();
-    self.snapshot.deinit();
-    self.platform.deinit();
-    self.arena_pool.deinit();
-
-    allocator.destroy(self);
-}
-
-fn getAndMakeAppDir(allocator: Allocator) ?[]const u8 {
-    if (@import("builtin").is_test) {
-        return allocator.dupe(u8, "/tmp") catch unreachable;
-    }
-    const app_dir_path = std.fs.getAppDataDir(allocator, "lightpanda") catch |err| {
-        log.warn(.app, "get data dir", .{ .err = err });
-        return null;
-    };
-
-    std.fs.cwd().makePath(app_dir_path) catch |err| switch (err) {
-        error.PathAlreadyExists => return app_dir_path,
-        else => {
-            allocator.free(app_dir_path);
-            log.warn(.app, "create data dir", .{ .err = err, .path = app_dir_path });
-            return null;
-        },
-    };
-    return app_dir_path;
-}

src/ArenaPool.zig

@@ -1,212 +0,0 @@
-// Copyright (C) 2023-2026  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program 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 Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-
-const Allocator = std.mem.Allocator;
-const ArenaAllocator = std.heap.ArenaAllocator;
-
-const ArenaPool = @This();
-
-allocator: Allocator,
-retain_bytes: usize,
-free_list_len: u16 = 0,
-free_list: ?*Entry = null,
-free_list_max: u16,
-entry_pool: std.heap.MemoryPool(Entry),
-mutex: std.Thread.Mutex = .{},
-
-const Entry = struct {
-    next: ?*Entry,
-    arena: ArenaAllocator,
-};
-
-pub fn init(allocator: Allocator, free_list_max: u16, retain_bytes: usize) ArenaPool {
-    return .{
-        .allocator = allocator,
-        .free_list_max = free_list_max,
-        .retain_bytes = retain_bytes,
-        .entry_pool = .init(allocator),
-    };
-}
-
-pub fn deinit(self: *ArenaPool) void {
-    var entry = self.free_list;
-    while (entry) |e| {
-        entry = e.next;
-        e.arena.deinit();
-    }
-    self.entry_pool.deinit();
-}
-
-pub fn acquire(self: *ArenaPool) !Allocator {
-    self.mutex.lock();
-    defer self.mutex.unlock();
-
-    if (self.free_list) |entry| {
-        self.free_list = entry.next;
-        self.free_list_len -= 1;
-        return entry.arena.allocator();
-    }
-
-    const entry = try self.entry_pool.create();
-    entry.* = .{
-        .next = null,
-        .arena = ArenaAllocator.init(self.allocator),
-    };
-
-    return entry.arena.allocator();
-}
-
-pub fn release(self: *ArenaPool, allocator: Allocator) void {
-    const arena: *std.heap.ArenaAllocator = @ptrCast(@alignCast(allocator.ptr));
-    const entry: *Entry = @fieldParentPtr("arena", arena);
-
-    // Reset the arena before acquiring the lock to minimize lock hold time
-    _ = arena.reset(.{ .retain_with_limit = self.retain_bytes });
-
-    self.mutex.lock();
-    defer self.mutex.unlock();
-
-    const free_list_len = self.free_list_len;
-    if (free_list_len == self.free_list_max) {
-        arena.deinit();
-        self.entry_pool.destroy(entry);
-        return;
-    }
-
-    entry.next = self.free_list;
-    self.free_list_len = free_list_len + 1;
-    self.free_list = entry;
-}
-
-pub fn reset(_: *const ArenaPool, allocator: Allocator, retain: usize) void {
-    const arena: *std.heap.ArenaAllocator = @ptrCast(@alignCast(allocator.ptr));
-    _ = arena.reset(.{ .retain_with_limit = retain });
-}
-
-const testing = std.testing;
-
-test "arena pool - basic acquire and use" {
-    var pool = ArenaPool.init(testing.allocator, 512, 1024 * 16);
-    defer pool.deinit();
-
-    const alloc = try pool.acquire();
-    const buf = try alloc.alloc(u8, 64);
-    @memset(buf, 0xAB);
-    try testing.expectEqual(@as(u8, 0xAB), buf[0]);
-
-    pool.release(alloc);
-}
-
-test "arena pool - reuse entry after release" {
-    var pool = ArenaPool.init(testing.allocator, 512, 1024 * 16);
-    defer pool.deinit();
-
-    const alloc1 = try pool.acquire();
-    try testing.expectEqual(@as(u16, 0), pool.free_list_len);
-
-    pool.release(alloc1);
-    try testing.expectEqual(@as(u16, 1), pool.free_list_len);
-
-    // The same entry should be returned from the free list.
-    const alloc2 = try pool.acquire();
-    try testing.expectEqual(@as(u16, 0), pool.free_list_len);
-    try testing.expectEqual(alloc1.ptr, alloc2.ptr);
-
-    pool.release(alloc2);
-}
-
-test "arena pool - multiple concurrent arenas" {
-    var pool = ArenaPool.init(testing.allocator, 512, 1024 * 16);
-    defer pool.deinit();
-
-    const a1 = try pool.acquire();
-    const a2 = try pool.acquire();
-    const a3 = try pool.acquire();
-
-    // All three must be distinct arenas.
-    try testing.expect(a1.ptr != a2.ptr);
-    try testing.expect(a2.ptr != a3.ptr);
-    try testing.expect(a1.ptr != a3.ptr);
-
-    _ = try a1.alloc(u8, 16);
-    _ = try a2.alloc(u8, 32);
-    _ = try a3.alloc(u8, 48);
-
-    pool.release(a1);
-    pool.release(a2);
-    pool.release(a3);
-
-    try testing.expectEqual(@as(u16, 3), pool.free_list_len);
-}
-
-test "arena pool - free list respects max limit" {
-    // Cap the free list at 1 so the second release discards its arena.
-    var pool = ArenaPool.init(testing.allocator, 1, 1024 * 16);
-    defer pool.deinit();
-
-    const a1 = try pool.acquire();
-    const a2 = try pool.acquire();
-
-    pool.release(a1);
-    try testing.expectEqual(@as(u16, 1), pool.free_list_len);
-
-    // The free list is full; a2's arena should be destroyed, not queued.
-    pool.release(a2);
-    try testing.expectEqual(@as(u16, 1), pool.free_list_len);
-}
-
-test "arena pool - reset clears memory without releasing" {
-    var pool = ArenaPool.init(testing.allocator, 512, 1024 * 16);
-    defer pool.deinit();
-
-    const alloc = try pool.acquire();
-
-    const buf = try alloc.alloc(u8, 128);
-    @memset(buf, 0xFF);
-
-    // reset() frees arena memory but keeps the allocator in-flight.
-    pool.reset(alloc, 0);
-
-    // The free list must stay empty; the allocator was not released.
-    try testing.expectEqual(@as(u16, 0), pool.free_list_len);
-
-    // Allocating again through the same arena must still work.
-    const buf2 = try alloc.alloc(u8, 64);
-    @memset(buf2, 0x00);
-    try testing.expectEqual(@as(u8, 0x00), buf2[0]);
-
-    pool.release(alloc);
-}
-
-test "arena pool - deinit with entries in free list" {
-    // Verifies that deinit properly cleans up free-listed arenas (no leaks
-    // detected by the test allocator).
-    var pool = ArenaPool.init(testing.allocator, 512, 1024 * 16);
-
-    const a1 = try pool.acquire();
-    const a2 = try pool.acquire();
-    _ = try a1.alloc(u8, 256);
-    _ = try a2.alloc(u8, 512);
-    pool.release(a1);
-    pool.release(a2);
-    try testing.expectEqual(@as(u16, 2), pool.free_list_len);
-
-    pool.deinit();
-}

src/Config.zig

@@ -1,928 +0,0 @@
-// Copyright (C) 2023-2026  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program 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 Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-const builtin = @import("builtin");
-const Allocator = std.mem.Allocator;
-
-const log = @import("log.zig");
-const dump = @import("browser/dump.zig");
-
-const WebBotAuthConfig = @import("network/WebBotAuth.zig").Config;
-
-pub const RunMode = enum {
-    help,
-    fetch,
-    serve,
-    version,
-    mcp,
-};
-
-pub const MAX_LISTENERS = 16;
-pub const CDP_MAX_HTTP_REQUEST_SIZE = 4096;
-
-// max message size
-// +14 for max websocket payload overhead
-// +140 for the max control packet that might be interleaved in a message
-pub const CDP_MAX_MESSAGE_SIZE = 512 * 1024 + 14 + 140;
-
-mode: Mode,
-exec_name: []const u8,
-http_headers: HttpHeaders,
-
-const Config = @This();
-
-pub fn init(allocator: Allocator, exec_name: []const u8, mode: Mode) !Config {
-    var config = Config{
-        .mode = mode,
-        .exec_name = exec_name,
-        .http_headers = undefined,
-    };
-    config.http_headers = try HttpHeaders.init(allocator, &config);
-    return config;
-}
-
-pub fn deinit(self: *const Config, allocator: Allocator) void {
-    self.http_headers.deinit(allocator);
-}
-
-pub fn tlsVerifyHost(self: *const Config) bool {
-    return switch (self.mode) {
-        inline .serve, .fetch, .mcp => |opts| opts.common.tls_verify_host,
-        else => unreachable,
-    };
-}
-
-pub fn obeyRobots(self: *const Config) bool {
-    return switch (self.mode) {
-        inline .serve, .fetch, .mcp => |opts| opts.common.obey_robots,
-        else => unreachable,
-    };
-}
-
-pub fn httpProxy(self: *const Config) ?[:0]const u8 {
-    return switch (self.mode) {
-        inline .serve, .fetch, .mcp => |opts| opts.common.http_proxy,
-        else => unreachable,
-    };
-}
-
-pub fn proxyBearerToken(self: *const Config) ?[:0]const u8 {
-    return switch (self.mode) {
-        inline .serve, .fetch, .mcp => |opts| opts.common.proxy_bearer_token,
-        .help, .version => null,
-    };
-}
-
-pub fn httpMaxConcurrent(self: *const Config) u8 {
-    return switch (self.mode) {
-        inline .serve, .fetch, .mcp => |opts| opts.common.http_max_concurrent orelse 10,
-        else => unreachable,
-    };
-}
-
-pub fn httpMaxHostOpen(self: *const Config) u8 {
-    return switch (self.mode) {
-        inline .serve, .fetch, .mcp => |opts| opts.common.http_max_host_open orelse 4,
-        else => unreachable,
-    };
-}
-
-pub fn httpConnectTimeout(self: *const Config) u31 {
-    return switch (self.mode) {
-        inline .serve, .fetch, .mcp => |opts| opts.common.http_connect_timeout orelse 0,
-        else => unreachable,
-    };
-}
-
-pub fn httpTimeout(self: *const Config) u31 {
-    return switch (self.mode) {
-        inline .serve, .fetch, .mcp => |opts| opts.common.http_timeout orelse 5000,
-        else => unreachable,
-    };
-}
-
-pub fn httpMaxRedirects(_: *const Config) u8 {
-    return 10;
-}
-
-pub fn httpMaxResponseSize(self: *const Config) ?usize {
-    return switch (self.mode) {
-        inline .serve, .fetch, .mcp => |opts| opts.common.http_max_response_size,
-        else => unreachable,
-    };
-}
-
-pub fn logLevel(self: *const Config) ?log.Level {
-    return switch (self.mode) {
-        inline .serve, .fetch, .mcp => |opts| opts.common.log_level,
-        else => unreachable,
-    };
-}
-
-pub fn logFormat(self: *const Config) ?log.Format {
-    return switch (self.mode) {
-        inline .serve, .fetch, .mcp => |opts| opts.common.log_format,
-        else => unreachable,
-    };
-}
-
-pub fn logFilterScopes(self: *const Config) ?[]const log.Scope {
-    return switch (self.mode) {
-        inline .serve, .fetch, .mcp => |opts| opts.common.log_filter_scopes,
-        else => unreachable,
-    };
-}
-
-pub fn userAgentSuffix(self: *const Config) ?[]const u8 {
-    return switch (self.mode) {
-        inline .serve, .fetch, .mcp => |opts| opts.common.user_agent_suffix,
-        .help, .version => null,
-    };
-}
-
-pub fn cacheDir(self: *const Config) ?[]const u8 {
-    return switch (self.mode) {
-        inline .serve, .fetch, .mcp => |opts| opts.common.cache_dir,
-        else => null,
-    };
-}
-
-pub fn cdpTimeout(self: *const Config) usize {
-    return switch (self.mode) {
-        .serve => |opts| if (opts.timeout > 604_800) 604_800_000 else @as(usize, opts.timeout) * 1000,
-        else => unreachable,
-    };
-}
-
-pub fn webBotAuth(self: *const Config) ?WebBotAuthConfig {
-    return switch (self.mode) {
-        inline .serve, .fetch, .mcp => |opts| WebBotAuthConfig{
-            .key_file = opts.common.web_bot_auth_key_file orelse return null,
-            .keyid = opts.common.web_bot_auth_keyid orelse return null,
-            .domain = opts.common.web_bot_auth_domain orelse return null,
-        },
-        .help, .version => null,
-    };
-}
-
-pub fn maxConnections(self: *const Config) u16 {
-    return switch (self.mode) {
-        .serve => |opts| opts.cdp_max_connections,
-        else => unreachable,
-    };
-}
-
-pub fn maxPendingConnections(self: *const Config) u31 {
-    return switch (self.mode) {
-        .serve => |opts| opts.cdp_max_pending_connections,
-        else => unreachable,
-    };
-}
-
-pub const Mode = union(RunMode) {
-    help: bool, // false when being printed because of an error
-    fetch: Fetch,
-    serve: Serve,
-    version: void,
-    mcp: Mcp,
-};
-
-pub const Serve = struct {
-    host: []const u8 = "127.0.0.1",
-    port: u16 = 9222,
-    timeout: u31 = 10,
-    cdp_max_connections: u16 = 16,
-    cdp_max_pending_connections: u16 = 128,
-    common: Common = .{},
-};
-
-pub const Mcp = struct {
-    common: Common = .{},
-};
-
-pub const DumpFormat = enum {
-    html,
-    markdown,
-    wpt,
-    semantic_tree,
-    semantic_tree_text,
-};
-
-pub const Fetch = struct {
-    url: [:0]const u8,
-    dump_mode: ?DumpFormat = null,
-    common: Common = .{},
-    with_base: bool = false,
-    with_frames: bool = false,
-    strip: dump.Opts.Strip = .{},
-};
-
-pub const Common = struct {
-    obey_robots: bool = false,
-    proxy_bearer_token: ?[:0]const u8 = null,
-    http_proxy: ?[:0]const u8 = null,
-    http_max_concurrent: ?u8 = null,
-    http_max_host_open: ?u8 = null,
-    http_timeout: ?u31 = null,
-    http_connect_timeout: ?u31 = null,
-    http_max_response_size: ?usize = null,
-    tls_verify_host: bool = true,
-    log_level: ?log.Level = null,
-    log_format: ?log.Format = null,
-    log_filter_scopes: ?[]log.Scope = null,
-    user_agent_suffix: ?[]const u8 = null,
-    cache_dir: ?[]const u8 = null,
-
-    web_bot_auth_key_file: ?[]const u8 = null,
-    web_bot_auth_keyid: ?[]const u8 = null,
-    web_bot_auth_domain: ?[]const u8 = null,
-};
-
-/// Pre-formatted HTTP headers for reuse across Http and Client.
-/// Must be initialized with an allocator that outlives all HTTP connections.
-pub const HttpHeaders = struct {
-    const user_agent_base: [:0]const u8 = "Lightpanda/1.0";
-
-    user_agent: [:0]const u8, // User agent value (e.g. "Lightpanda/1.0")
-    user_agent_header: [:0]const u8,
-
-    proxy_bearer_header: ?[:0]const u8,
-
-    pub fn init(allocator: Allocator, config: *const Config) !HttpHeaders {
-        const user_agent: [:0]const u8 = if (config.userAgentSuffix()) |suffix|
-            try std.fmt.allocPrintSentinel(allocator, "{s} {s}", .{ user_agent_base, suffix }, 0)
-        else
-            user_agent_base;
-        errdefer if (config.userAgentSuffix() != null) allocator.free(user_agent);
-
-        const user_agent_header = try std.fmt.allocPrintSentinel(allocator, "User-Agent: {s}", .{user_agent}, 0);
-        errdefer allocator.free(user_agent_header);
-
-        const proxy_bearer_header: ?[:0]const u8 = if (config.proxyBearerToken()) |token|
-            try std.fmt.allocPrintSentinel(allocator, "Proxy-Authorization: Bearer {s}", .{token}, 0)
-        else
-            null;
-
-        return .{
-            .user_agent = user_agent,
-            .user_agent_header = user_agent_header,
-            .proxy_bearer_header = proxy_bearer_header,
-        };
-    }
-
-    pub fn deinit(self: *const HttpHeaders, allocator: Allocator) void {
-        if (self.proxy_bearer_header) |hdr| {
-            allocator.free(hdr);
-        }
-        allocator.free(self.user_agent_header);
-        if (self.user_agent.ptr != user_agent_base.ptr) {
-            allocator.free(self.user_agent);
-        }
-    }
-};
-
-pub fn printUsageAndExit(self: *const Config, success: bool) void {
-    //                                                                     MAX_HELP_LEN|
-    const common_options =
-        \\
-        \\--insecure_disable_tls_host_verification
-        \\                Disables host verification on all HTTP requests. This is an
-        \\                advanced option which should only be set if you understand
-        \\                and accept the risk of disabling host verification.
-        \\
-        \\--obey_robots
-        \\                Fetches and obeys the robots.txt (if available) of the web pages
-        \\                we make requests towards.
-        \\                Defaults to false.
-        \\
-        \\--http_proxy    The HTTP proxy to use for all HTTP requests.
-        \\                A username:password can be included for basic authentication.
-        \\                Defaults to none.
-        \\
-        \\--proxy_bearer_token
-        \\                The <token> to send for bearer authentication with the proxy
-        \\                Proxy-Authorization: Bearer <token>
-        \\
-        \\--http_max_concurrent
-        \\                The maximum number of concurrent HTTP requests.
-        \\                Defaults to 10.
-        \\
-        \\--http_max_host_open
-        \\                The maximum number of open connection to a given host:port.
-        \\                Defaults to 4.
-        \\
-        \\--http_connect_timeout
-        \\                The time, in milliseconds, for establishing an HTTP connection
-        \\                before timing out. 0 means it never times out.
-        \\                Defaults to 0.
-        \\
-        \\--http_timeout
-        \\                The maximum time, in milliseconds, the transfer is allowed
-        \\                to complete. 0 means it never times out.
-        \\                Defaults to 10000.
-        \\
-        \\--http_max_response_size
-        \\                Limits the acceptable response size for any request
-        \\                (e.g. XHR, fetch, script loading, ...).
-        \\                Defaults to no limit.
-        \\
-        \\--log_level     The log level: debug, info, warn, error or fatal.
-        \\                Defaults to
-    ++ (if (builtin.mode == .Debug) " info." else "warn.") ++
-        \\
-        \\
-        \\--log_format    The log format: pretty or logfmt.
-        \\                Defaults to
-    ++ (if (builtin.mode == .Debug) " pretty." else " logfmt.") ++
-        \\
-        \\
-        \\--log_filter_scopes
-        \\                Filter out too verbose logs per scope:
-        \\                http, unknown_prop, event, ...
-        \\
-        \\--user_agent_suffix
-        \\                Suffix to append to the Lightpanda/X.Y User-Agent
-        \\
-        \\--web_bot_auth_key_file
-        \\                Path to the Ed25519 private key PEM file.
-        \\
-        \\--web_bot_auth_keyid
-        \\                The JWK thumbprint of your public key.
-        \\
-        \\--web_bot_auth_domain
-        \\                Your domain e.g. yourdomain.com
-    ;
-
-    //                                                                     MAX_HELP_LEN|
-    const usage =
-        \\usage: {s} command [options] [URL]
-        \\
-        \\Command can be either 'fetch', 'serve', 'mcp' or 'help'
-        \\
-        \\fetch command
-        \\Fetches the specified URL
-        \\Example: {s} fetch --dump html https://lightpanda.io/
-        \\
-        \\Options:
-        \\--dump          Dumps document to stdout.
-        \\                Argument must be 'html', 'markdown', 'semantic_tree', or 'semantic_tree_text'.
-        \\                Defaults to no dump.
-        \\
-        \\--strip_mode    Comma separated list of tag groups to remove from dump
-        \\                the dump. e.g. --strip_mode js,css
-        \\                  - "js" script and link[as=script, rel=preload]
-        \\                  - "ui" includes img, picture, video, css and svg
-        \\                  - "css" includes style and link[rel=stylesheet]
-        \\                  - "full" includes js, ui and css
-        \\
-        \\--with_base     Add a <base> tag in dump. Defaults to false.
-        \\
-        \\--with_frames   Includes the contents of iframes. Defaults to false.
-        \\
-    ++ common_options ++
-        \\
-        \\serve command
-        \\Starts a websocket CDP server
-        \\Example: {s} serve --host 127.0.0.1 --port 9222
-        \\
-        \\Options:
-        \\--host          Host of the CDP server
-        \\                Defaults to "127.0.0.1"
-        \\
-        \\--port          Port of the CDP server
-        \\                Defaults to 9222
-        \\
-        \\--timeout       Inactivity timeout in seconds before disconnecting clients
-        \\                Defaults to 10 (seconds). Limited to 604800 (1 week).
-        \\
-        \\--cdp_max_connections
-        \\                Maximum number of simultaneous CDP connections.
-        \\                Defaults to 16.
-        \\
-        \\--cdp_max_pending_connections
-        \\                Maximum pending connections in the accept queue.
-        \\                Defaults to 128.
-        \\
-    ++ common_options ++
-        \\
-        \\mcp command
-        \\Starts an MCP (Model Context Protocol) server over stdio
-        \\Example: {s} mcp
-        \\
-    ++ common_options ++
-        \\
-        \\version command
-        \\Displays the version of {s}
-        \\
-        \\help command
-        \\Displays this message
-        \\
-    ;
-    std.debug.print(usage, .{ self.exec_name, self.exec_name, self.exec_name, self.exec_name, self.exec_name });
-    if (success) {
-        return std.process.cleanExit();
-    }
-    std.process.exit(1);
-}
-
-pub fn parseArgs(allocator: Allocator) !Config {
-    var args = try std.process.argsWithAllocator(allocator);
-    defer args.deinit();
-
-    const exec_name = try allocator.dupe(u8, std.fs.path.basename(args.next().?));
-
-    const mode_string = args.next() orelse "";
-    const run_mode = std.meta.stringToEnum(RunMode, mode_string) orelse blk: {
-        const inferred_mode = inferMode(mode_string) orelse
-            return init(allocator, exec_name, .{ .help = false });
-        // "command" wasn't a command but an option. We can't reset args, but
-        // we can create a new one. Not great, but this fallback is temporary
-        // as we transition to this command mode approach.
-        args.deinit();
-
-        args = try std.process.argsWithAllocator(allocator);
-        // skip the exec_name
-        _ = args.skip();
-
-        break :blk inferred_mode;
-    };
-
-    const mode: Mode = switch (run_mode) {
-        .help => .{ .help = true },
-        .serve => .{ .serve = parseServeArgs(allocator, &args) catch
-            return init(allocator, exec_name, .{ .help = false }) },
-        .fetch => .{ .fetch = parseFetchArgs(allocator, &args) catch
-            return init(allocator, exec_name, .{ .help = false }) },
-        .mcp => .{ .mcp = parseMcpArgs(allocator, &args) catch
-            return init(allocator, exec_name, .{ .help = false }) },
-        .version => .{ .version = {} },
-    };
-    return init(allocator, exec_name, mode);
-}
-
-fn inferMode(opt: []const u8) ?RunMode {
-    if (opt.len == 0) {
-        return .serve;
-    }
-
-    if (std.mem.startsWith(u8, opt, "--") == false) {
-        return .fetch;
-    }
-
-    if (std.mem.eql(u8, opt, "--dump")) {
-        return .fetch;
-    }
-
-    if (std.mem.eql(u8, opt, "--noscript")) {
-        return .fetch;
-    }
-
-    if (std.mem.eql(u8, opt, "--strip_mode")) {
-        return .fetch;
-    }
-
-    if (std.mem.eql(u8, opt, "--with_base")) {
-        return .fetch;
-    }
-
-    if (std.mem.eql(u8, opt, "--with_frames")) {
-        return .fetch;
-    }
-
-    if (std.mem.eql(u8, opt, "--host")) {
-        return .serve;
-    }
-
-    if (std.mem.eql(u8, opt, "--port")) {
-        return .serve;
-    }
-
-    if (std.mem.eql(u8, opt, "--timeout")) {
-        return .serve;
-    }
-
-    return null;
-}
-
-fn parseServeArgs(
-    allocator: Allocator,
-    args: *std.process.ArgIterator,
-) !Serve {
-    var serve: Serve = .{};
-
-    while (args.next()) |opt| {
-        if (std.mem.eql(u8, "--host", opt)) {
-            const str = args.next() orelse {
-                log.fatal(.app, "missing argument value", .{ .arg = "--host" });
-                return error.InvalidArgument;
-            };
-            serve.host = try allocator.dupe(u8, str);
-            continue;
-        }
-
-        if (std.mem.eql(u8, "--port", opt)) {
-            const str = args.next() orelse {
-                log.fatal(.app, "missing argument value", .{ .arg = "--port" });
-                return error.InvalidArgument;
-            };
-
-            serve.port = std.fmt.parseInt(u16, str, 10) catch |err| {
-                log.fatal(.app, "invalid argument value", .{ .arg = "--port", .err = err });
-                return error.InvalidArgument;
-            };
-            continue;
-        }
-
-        if (std.mem.eql(u8, "--timeout", opt)) {
-            const str = args.next() orelse {
-                log.fatal(.app, "missing argument value", .{ .arg = "--timeout" });
-                return error.InvalidArgument;
-            };
-
-            serve.timeout = std.fmt.parseInt(u31, str, 10) catch |err| {
-                log.fatal(.app, "invalid argument value", .{ .arg = "--timeout", .err = err });
-                return error.InvalidArgument;
-            };
-            continue;
-        }
-
-        if (std.mem.eql(u8, "--cdp_max_connections", opt)) {
-            const str = args.next() orelse {
-                log.fatal(.app, "missing argument value", .{ .arg = "--cdp_max_connections" });
-                return error.InvalidArgument;
-            };
-
-            serve.cdp_max_connections = std.fmt.parseInt(u16, str, 10) catch |err| {
-                log.fatal(.app, "invalid argument value", .{ .arg = "--cdp_max_connections", .err = err });
-                return error.InvalidArgument;
-            };
-            continue;
-        }
-
-        if (std.mem.eql(u8, "--cdp_max_pending_connections", opt)) {
-            const str = args.next() orelse {
-                log.fatal(.app, "missing argument value", .{ .arg = "--cdp_max_pending_connections" });
-                return error.InvalidArgument;
-            };
-
-            serve.cdp_max_pending_connections = std.fmt.parseInt(u16, str, 10) catch |err| {
-                log.fatal(.app, "invalid argument value", .{ .arg = "--cdp_max_pending_connections", .err = err });
-                return error.InvalidArgument;
-            };
-            continue;
-        }
-
-        if (try parseCommonArg(allocator, opt, args, &serve.common)) {
-            continue;
-        }
-
-        log.fatal(.app, "unknown argument", .{ .mode = "serve", .arg = opt });
-        return error.UnkownOption;
-    }
-
-    return serve;
-}
-
-fn parseMcpArgs(
-    allocator: Allocator,
-    args: *std.process.ArgIterator,
-) !Mcp {
-    var mcp: Mcp = .{};
-
-    while (args.next()) |opt| {
-        if (try parseCommonArg(allocator, opt, args, &mcp.common)) {
-            continue;
-        }
-
-        log.fatal(.mcp, "unknown argument", .{ .mode = "mcp", .arg = opt });
-        return error.UnkownOption;
-    }
-
-    return mcp;
-}
-
-fn parseFetchArgs(
-    allocator: Allocator,
-    args: *std.process.ArgIterator,
-) !Fetch {
-    var dump_mode: ?DumpFormat = null;
-    var with_base: bool = false;
-    var with_frames: bool = false;
-    var url: ?[:0]const u8 = null;
-    var common: Common = .{};
-    var strip: dump.Opts.Strip = .{};
-
-    while (args.next()) |opt| {
-        if (std.mem.eql(u8, "--dump", opt)) {
-            var peek_args = args.*;
-            if (peek_args.next()) |next_arg| {
-                if (std.meta.stringToEnum(DumpFormat, next_arg)) |mode| {
-                    dump_mode = mode;
-                    _ = args.next();
-                } else {
-                    dump_mode = .html;
-                }
-            } else {
-                dump_mode = .html;
-            }
-            continue;
-        }
-
-        if (std.mem.eql(u8, "--noscript", opt)) {
-            log.warn(.app, "deprecation warning", .{
-                .feature = "--noscript argument",
-                .hint = "use '--strip_mode js' instead",
-            });
-            strip.js = true;
-            continue;
-        }
-
-        if (std.mem.eql(u8, "--with_base", opt)) {
-            with_base = true;
-            continue;
-        }
-
-        if (std.mem.eql(u8, "--with_frames", opt)) {
-            with_frames = true;
-            continue;
-        }
-
-        if (std.mem.eql(u8, "--strip_mode", opt)) {
-            const str = args.next() orelse {
-                log.fatal(.app, "missing argument value", .{ .arg = "--strip_mode" });
-                return error.InvalidArgument;
-            };
-
-            var it = std.mem.splitScalar(u8, str, ',');
-            while (it.next()) |part| {
-                const trimmed = std.mem.trim(u8, part, &std.ascii.whitespace);
-                if (std.mem.eql(u8, trimmed, "js")) {
-                    strip.js = true;
-                } else if (std.mem.eql(u8, trimmed, "ui")) {
-                    strip.ui = true;
-                } else if (std.mem.eql(u8, trimmed, "css")) {
-                    strip.css = true;
-                } else if (std.mem.eql(u8, trimmed, "full")) {
-                    strip.js = true;
-                    strip.ui = true;
-                    strip.css = true;
-                } else {
-                    log.fatal(.app, "invalid option choice", .{ .arg = "--strip_mode", .value = trimmed });
-                }
-            }
-            continue;
-        }
-
-        if (try parseCommonArg(allocator, opt, args, &common)) {
-            continue;
-        }
-
-        if (std.mem.startsWith(u8, opt, "--")) {
-            log.fatal(.app, "unknown argument", .{ .mode = "fetch", .arg = opt });
-            return error.UnkownOption;
-        }
-
-        if (url != null) {
-            log.fatal(.app, "duplicate fetch url", .{ .help = "only 1 URL can be specified" });
-            return error.TooManyURLs;
-        }
-        url = try allocator.dupeZ(u8, opt);
-    }
-
-    if (url == null) {
-        log.fatal(.app, "missing fetch url", .{ .help = "URL to fetch must be provided" });
-        return error.MissingURL;
-    }
-
-    return .{
-        .url = url.?,
-        .dump_mode = dump_mode,
-        .strip = strip,
-        .common = common,
-        .with_base = with_base,
-        .with_frames = with_frames,
-    };
-}
-
-fn parseCommonArg(
-    allocator: Allocator,
-    opt: []const u8,
-    args: *std.process.ArgIterator,
-    common: *Common,
-) !bool {
-    if (std.mem.eql(u8, "--insecure_disable_tls_host_verification", opt)) {
-        common.tls_verify_host = false;
-        return true;
-    }
-
-    if (std.mem.eql(u8, "--obey_robots", opt)) {
-        common.obey_robots = true;
-        return true;
-    }
-
-    if (std.mem.eql(u8, "--http_proxy", opt)) {
-        const str = args.next() orelse {
-            log.fatal(.app, "missing argument value", .{ .arg = "--http_proxy" });
-            return error.InvalidArgument;
-        };
-        common.http_proxy = try allocator.dupeZ(u8, str);
-        return true;
-    }
-
-    if (std.mem.eql(u8, "--proxy_bearer_token", opt)) {
-        const str = args.next() orelse {
-            log.fatal(.app, "missing argument value", .{ .arg = "--proxy_bearer_token" });
-            return error.InvalidArgument;
-        };
-        common.proxy_bearer_token = try allocator.dupeZ(u8, str);
-        return true;
-    }
-
-    if (std.mem.eql(u8, "--http_max_concurrent", opt)) {
-        const str = args.next() orelse {
-            log.fatal(.app, "missing argument value", .{ .arg = "--http_max_concurrent" });
-            return error.InvalidArgument;
-        };
-
-        common.http_max_concurrent = std.fmt.parseInt(u8, str, 10) catch |err| {
-            log.fatal(.app, "invalid argument value", .{ .arg = "--http_max_concurrent", .err = err });
-            return error.InvalidArgument;
-        };
-        return true;
-    }
-
-    if (std.mem.eql(u8, "--http_max_host_open", opt)) {
-        const str = args.next() orelse {
-            log.fatal(.app, "missing argument value", .{ .arg = "--http_max_host_open" });
-            return error.InvalidArgument;
-        };
-
-        common.http_max_host_open = std.fmt.parseInt(u8, str, 10) catch |err| {
-            log.fatal(.app, "invalid argument value", .{ .arg = "--http_max_host_open", .err = err });
-            return error.InvalidArgument;
-        };
-        return true;
-    }
-
-    if (std.mem.eql(u8, "--http_connect_timeout", opt)) {
-        const str = args.next() orelse {
-            log.fatal(.app, "missing argument value", .{ .arg = "--http_connect_timeout" });
-            return error.InvalidArgument;
-        };
-
-        common.http_connect_timeout = std.fmt.parseInt(u31, str, 10) catch |err| {
-            log.fatal(.app, "invalid argument value", .{ .arg = "--http_connect_timeout", .err = err });
-            return error.InvalidArgument;
-        };
-        return true;
-    }
-
-    if (std.mem.eql(u8, "--http_timeout", opt)) {
-        const str = args.next() orelse {
-            log.fatal(.app, "missing argument value", .{ .arg = "--http_timeout" });
-            return error.InvalidArgument;
-        };
-
-        common.http_timeout = std.fmt.parseInt(u31, str, 10) catch |err| {
-            log.fatal(.app, "invalid argument value", .{ .arg = "--http_timeout", .err = err });
-            return error.InvalidArgument;
-        };
-        return true;
-    }
-
-    if (std.mem.eql(u8, "--http_max_response_size", opt)) {
-        const str = args.next() orelse {
-            log.fatal(.app, "missing argument value", .{ .arg = "--http_max_response_size" });
-            return error.InvalidArgument;
-        };
-
-        common.http_max_response_size = std.fmt.parseInt(usize, str, 10) catch |err| {
-            log.fatal(.app, "invalid argument value", .{ .arg = "--http_max_response_size", .err = err });
-            return error.InvalidArgument;
-        };
-        return true;
-    }
-
-    if (std.mem.eql(u8, "--log_level", opt)) {
-        const str = args.next() orelse {
-            log.fatal(.app, "missing argument value", .{ .arg = "--log_level" });
-            return error.InvalidArgument;
-        };
-
-        common.log_level = std.meta.stringToEnum(log.Level, str) orelse blk: {
-            if (std.mem.eql(u8, str, "error")) {
-                break :blk .err;
-            }
-            log.fatal(.app, "invalid option choice", .{ .arg = "--log_level", .value = str });
-            return error.InvalidArgument;
-        };
-        return true;
-    }
-
-    if (std.mem.eql(u8, "--log_format", opt)) {
-        const str = args.next() orelse {
-            log.fatal(.app, "missing argument value", .{ .arg = "--log_format" });
-            return error.InvalidArgument;
-        };
-
-        common.log_format = std.meta.stringToEnum(log.Format, str) orelse {
-            log.fatal(.app, "invalid option choice", .{ .arg = "--log_format", .value = str });
-            return error.InvalidArgument;
-        };
-        return true;
-    }
-
-    if (std.mem.eql(u8, "--log_filter_scopes", opt)) {
-        if (builtin.mode != .Debug) {
-            log.fatal(.app, "experimental", .{ .help = "log scope filtering is only available in debug builds" });
-            return false;
-        }
-
-        const str = args.next() orelse {
-            // disables the default filters
-            common.log_filter_scopes = &.{};
-            return true;
-        };
-
-        var arr: std.ArrayList(log.Scope) = .empty;
-
-        var it = std.mem.splitScalar(u8, str, ',');
-        while (it.next()) |part| {
-            try arr.append(allocator, std.meta.stringToEnum(log.Scope, part) orelse {
-                log.fatal(.app, "invalid option choice", .{ .arg = "--log_filter_scopes", .value = part });
-                return false;
-            });
-        }
-        common.log_filter_scopes = arr.items;
-        return true;
-    }
-
-    if (std.mem.eql(u8, "--user_agent_suffix", opt)) {
-        const str = args.next() orelse {
-            log.fatal(.app, "missing argument value", .{ .arg = "--user_agent_suffix" });
-            return error.InvalidArgument;
-        };
-        for (str) |c| {
-            if (!std.ascii.isPrint(c)) {
-                log.fatal(.app, "not printable character", .{ .arg = "--user_agent_suffix" });
-                return error.InvalidArgument;
-            }
-        }
-        common.user_agent_suffix = try allocator.dupe(u8, str);
-        return true;
-    }
-
-    if (std.mem.eql(u8, "--web_bot_auth_key_file", opt)) {
-        const str = args.next() orelse {
-            log.fatal(.app, "missing argument value", .{ .arg = "--web_bot_auth_key_file" });
-            return error.InvalidArgument;
-        };
-        common.web_bot_auth_key_file = try allocator.dupe(u8, str);
-        return true;
-    }
-
-    if (std.mem.eql(u8, "--web_bot_auth_keyid", opt)) {
-        const str = args.next() orelse {
-            log.fatal(.app, "missing argument value", .{ .arg = "--web_bot_auth_keyid" });
-            return error.InvalidArgument;
-        };
-        common.web_bot_auth_keyid = try allocator.dupe(u8, str);
-        return true;
-    }
-
-    if (std.mem.eql(u8, "--web_bot_auth_domain", opt)) {
-        const str = args.next() orelse {
-            log.fatal(.app, "missing argument value", .{ .arg = "--web_bot_auth_domain" });
-            return error.InvalidArgument;
-        };
-        common.web_bot_auth_domain = try allocator.dupe(u8, str);
-        return true;
-    }
-
-    if (std.mem.eql(u8, "--cache_dir", opt)) {
-        const str = args.next() orelse {
-            log.fatal(.app, "missing argument value", .{ .arg = "--cache_dir" });
-            return error.InvalidArgument;
-        };
-        common.cache_dir = try allocator.dupe(u8, str);
-        return true;
-    }
-
-    return false;
-}

src/Notification.zig

@@ -1,419 +0,0 @@
-// Copyright (C) 2023-2025  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program 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 Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-const lp = @import("lightpanda");
-
-const log = @import("log.zig");
-const Page = @import("browser/Page.zig");
-const Transfer = @import("browser/HttpClient.zig").Transfer;
-
-const Allocator = std.mem.Allocator;
-
-const List = std.DoublyLinkedList;
-
-// Allows code to register for and emit events.
-// Keeps two lists
-// 1 - for a given event type, a linked list of all the listeners
-// 2 - for a given listener, a list of all it's registration
-// The 2nd one is so that a listener can unregister all of it's listeners
-// (there's currently no need for a listener to unregister only 1 or more
-// specific listener).
-//
-// Scoping is important. Imagine we created a global singleton registry, and our
-// CDP code registers for the "network_bytes_sent" event, because it needs to
-// send messages to the client when this happens. Our HTTP client could then
-// emit a "network_bytes_sent" message. It would be easy, and it would work.
-// That is, it would work until multiple CDP clients connect, and because
-// everything's just one big global, events from one CDP session would be sent
-// to all CDP clients.
-//
-// To avoid this, one way or another, we need scoping. We could still have
-// a global registry but every "register" and every "emit" has some type of
-// "scope". This would have a run-time cost and still require some coordination
-// between components to share a common scope.
-//
-// Instead, the approach that we take is to have a notification instance per
-// CDP connection (BrowserContext). Each CDP connection has its own notification
-// that is shared across all Sessions (tabs) within that connection. This ensures
-// proper isolation between different CDP clients while allowing a single client
-// to receive events from all its tabs.
-const Notification = @This();
-// Every event type (which are hard-coded), has a list of Listeners.
-// When the event happens, we dispatch to those listener.
-event_listeners: EventListeners,
-
-// list of listeners for a specified receiver
-// @intFromPtr(receiver) -> [listener1, listener2, ...]
-// Used when `unregisterAll` is called.
-listeners: std.AutoHashMapUnmanaged(usize, std.ArrayList(*Listener)),
-
-allocator: Allocator,
-mem_pool: std.heap.MemoryPool(Listener),
-
-const EventListeners = struct {
-    page_remove: List = .{},
-    page_created: List = .{},
-    page_navigate: List = .{},
-    page_navigated: List = .{},
-    page_network_idle: List = .{},
-    page_network_almost_idle: List = .{},
-    page_frame_created: List = .{},
-    http_request_fail: List = .{},
-    http_request_start: List = .{},
-    http_request_intercept: List = .{},
-    http_request_done: List = .{},
-    http_request_auth_required: List = .{},
-    http_response_data: List = .{},
-    http_response_header_done: List = .{},
-};
-
-const Events = union(enum) {
-    page_remove: PageRemove,
-    page_created: *Page,
-    page_navigate: *const PageNavigate,
-    page_navigated: *const PageNavigated,
-    page_network_idle: *const PageNetworkIdle,
-    page_network_almost_idle: *const PageNetworkAlmostIdle,
-    page_frame_created: *const PageFrameCreated,
-    http_request_fail: *const RequestFail,
-    http_request_start: *const RequestStart,
-    http_request_intercept: *const RequestIntercept,
-    http_request_auth_required: *const RequestAuthRequired,
-    http_request_done: *const RequestDone,
-    http_response_data: *const ResponseData,
-    http_response_header_done: *const ResponseHeaderDone,
-};
-const EventType = std.meta.FieldEnum(Events);
-
-pub const PageRemove = struct {};
-
-pub const PageNavigate = struct {
-    req_id: u32,
-    frame_id: u32,
-    timestamp: u64,
-    url: [:0]const u8,
-    opts: Page.NavigateOpts,
-};
-
-pub const PageNavigated = struct {
-    req_id: u32,
-    frame_id: u32,
-    timestamp: u64,
-    url: [:0]const u8,
-    opts: Page.NavigatedOpts,
-};
-
-pub const PageNetworkIdle = struct {
-    req_id: u32,
-    frame_id: u32,
-    timestamp: u64,
-};
-
-pub const PageNetworkAlmostIdle = struct {
-    req_id: u32,
-    frame_id: u32,
-    timestamp: u64,
-};
-
-pub const PageFrameCreated = struct {
-    frame_id: u32,
-    parent_id: u32,
-    timestamp: u64,
-};
-
-pub const RequestStart = struct {
-    transfer: *Transfer,
-};
-
-pub const RequestIntercept = struct {
-    transfer: *Transfer,
-    wait_for_interception: *bool,
-};
-
-pub const RequestAuthRequired = struct {
-    transfer: *Transfer,
-    wait_for_interception: *bool,
-};
-
-pub const ResponseData = struct {
-    data: []const u8,
-    transfer: *Transfer,
-};
-
-pub const ResponseHeaderDone = struct {
-    transfer: *Transfer,
-};
-
-pub const RequestDone = struct {
-    transfer: *Transfer,
-};
-
-pub const RequestFail = struct {
-    transfer: *Transfer,
-    err: anyerror,
-};
-
-pub fn init(allocator: Allocator) !*Notification {
-    const notification = try allocator.create(Notification);
-    errdefer allocator.destroy(notification);
-
-    notification.* = .{
-        .listeners = .{},
-        .event_listeners = .{},
-        .allocator = allocator,
-        .mem_pool = std.heap.MemoryPool(Listener).init(allocator),
-    };
-
-    return notification;
-}
-
-pub fn deinit(self: *Notification) void {
-    const allocator = self.allocator;
-
-    var it = self.listeners.valueIterator();
-    while (it.next()) |listener| {
-        listener.deinit(allocator);
-    }
-    self.listeners.deinit(allocator);
-    self.mem_pool.deinit();
-    allocator.destroy(self);
-}
-
-pub fn register(self: *Notification, comptime event: EventType, receiver: anytype, func: EventFunc(event)) !void {
-    var list = &@field(self.event_listeners, @tagName(event));
-
-    var listener = try self.mem_pool.create();
-    errdefer self.mem_pool.destroy(listener);
-
-    listener.* = .{
-        .node = .{},
-        .list = list,
-        .receiver = receiver,
-        .event = event,
-        .func = @ptrCast(func),
-        .struct_name = @typeName(@typeInfo(@TypeOf(receiver)).pointer.child),
-    };
-
-    const allocator = self.allocator;
-    const gop = try self.listeners.getOrPut(allocator, @intFromPtr(receiver));
-    if (gop.found_existing == false) {
-        gop.value_ptr.* = .{};
-    }
-    try gop.value_ptr.append(allocator, listener);
-
-    // we don't add this until we've successfully added the entry to
-    // self.listeners
-    list.append(&listener.node);
-}
-
-pub fn unregister(self: *Notification, comptime event: EventType, receiver: anytype) void {
-    var listeners = self.listeners.getPtr(@intFromPtr(receiver)) orelse return;
-
-    var i: usize = 0;
-    while (i < listeners.items.len) {
-        const listener = listeners.items[i];
-        if (listener.event != event) {
-            i += 1;
-            continue;
-        }
-        listener.list.remove(&listener.node);
-        self.mem_pool.destroy(listener);
-        _ = listeners.swapRemove(i);
-    }
-
-    if (listeners.items.len == 0) {
-        listeners.deinit(self.allocator);
-        const removed = self.listeners.remove(@intFromPtr(receiver));
-        lp.assert(removed == true, "Notification.unregister", .{ .type = event });
-    }
-}
-
-pub fn unregisterAll(self: *Notification, receiver: *anyopaque) void {
-    var kv = self.listeners.fetchRemove(@intFromPtr(receiver)) orelse return;
-    for (kv.value.items) |listener| {
-        listener.list.remove(&listener.node);
-        self.mem_pool.destroy(listener);
-    }
-    kv.value.deinit(self.allocator);
-}
-
-pub fn dispatch(self: *Notification, comptime event: EventType, data: ArgType(event)) void {
-    if (self.listeners.count() == 0) {
-        return;
-    }
-    const list = &@field(self.event_listeners, @tagName(event));
-
-    var node = list.first;
-    while (node) |n| {
-        const listener: *Listener = @fieldParentPtr("node", n);
-        const func: EventFunc(event) = @ptrCast(@alignCast(listener.func));
-        func(listener.receiver, data) catch |err| {
-            log.err(.app, "dispatch error", .{
-                .err = err,
-                .event = event,
-                .source = "notification",
-                .listener = listener.struct_name,
-            });
-        };
-        node = n.next;
-    }
-}
-
-// Given an event type enum, returns the type of arg the event emits
-fn ArgType(comptime event: Notification.EventType) type {
-    inline for (std.meta.fields(Notification.Events)) |f| {
-        if (std.mem.eql(u8, f.name, @tagName(event))) {
-            return f.type;
-        }
-    }
-    unreachable;
-}
-
-// Given an event type enum, returns the listening function type
-fn EventFunc(comptime event: Notification.EventType) type {
-    return *const fn (*anyopaque, ArgType(event)) anyerror!void;
-}
-
-// A listener. This is 1 receiver, with its function, and the linked list
-// node that goes in the appropriate EventListeners list.
-const Listener = struct {
-    // the receiver of the event, i.e. the self parameter to `func`
-    receiver: *anyopaque,
-
-    // the function to call
-    func: *const anyopaque,
-
-    // For logging slightly better error
-    struct_name: []const u8,
-
-    event: Notification.EventType,
-
-    // intrusive linked list node
-    node: List.Node,
-
-    // The event list this listener belongs to.
-    // We need this in order to be able to remove the node from the list
-    list: *List,
-};
-
-const testing = std.testing;
-test "Notification" {
-    var notifier = try Notification.init(testing.allocator);
-    defer notifier.deinit();
-
-    // noop
-    notifier.dispatch(.page_navigate, &.{
-        .frame_id = 0,
-        .req_id = 1,
-        .timestamp = 4,
-        .url = undefined,
-        .opts = .{},
-    });
-
-    var tc = TestClient{};
-
-    try notifier.register(.page_navigate, &tc, TestClient.pageNavigate);
-    notifier.dispatch(.page_navigate, &.{
-        .frame_id = 0,
-        .req_id = 1,
-        .timestamp = 4,
-        .url = undefined,
-        .opts = .{},
-    });
-    try testing.expectEqual(4, tc.page_navigate);
-
-    notifier.unregisterAll(&tc);
-    notifier.dispatch(.page_navigate, &.{
-        .frame_id = 0,
-        .req_id = 1,
-        .timestamp = 10,
-        .url = undefined,
-        .opts = .{},
-    });
-    try testing.expectEqual(4, tc.page_navigate);
-
-    try notifier.register(.page_navigate, &tc, TestClient.pageNavigate);
-    try notifier.register(.page_navigated, &tc, TestClient.pageNavigated);
-    notifier.dispatch(.page_navigate, &.{
-        .frame_id = 0,
-        .req_id = 1,
-        .timestamp = 10,
-        .url = undefined,
-        .opts = .{},
-    });
-    notifier.dispatch(.page_navigated, &.{ .frame_id = 0, .req_id = 1, .timestamp = 6, .url = undefined, .opts = .{} });
-    try testing.expectEqual(14, tc.page_navigate);
-    try testing.expectEqual(6, tc.page_navigated);
-
-    notifier.unregisterAll(&tc);
-    notifier.dispatch(.page_navigate, &.{
-        .frame_id = 0,
-        .req_id = 1,
-        .timestamp = 100,
-        .url = undefined,
-        .opts = .{},
-    });
-    notifier.dispatch(.page_navigated, &.{ .frame_id = 0, .req_id = 1, .timestamp = 100, .url = undefined, .opts = .{} });
-    try testing.expectEqual(14, tc.page_navigate);
-    try testing.expectEqual(6, tc.page_navigated);
-
-    {
-        // unregister
-        try notifier.register(.page_navigate, &tc, TestClient.pageNavigate);
-        try notifier.register(.page_navigated, &tc, TestClient.pageNavigated);
-        notifier.dispatch(.page_navigate, &.{ .frame_id = 0, .req_id = 1, .timestamp = 100, .url = undefined, .opts = .{} });
-        notifier.dispatch(.page_navigated, &.{ .frame_id = 0, .req_id = 1, .timestamp = 1000, .url = undefined, .opts = .{} });
-        try testing.expectEqual(114, tc.page_navigate);
-        try testing.expectEqual(1006, tc.page_navigated);
-
-        notifier.unregister(.page_navigate, &tc);
-        notifier.dispatch(.page_navigate, &.{ .frame_id = 0, .req_id = 1, .timestamp = 100, .url = undefined, .opts = .{} });
-        notifier.dispatch(.page_navigated, &.{ .frame_id = 0, .req_id = 1, .timestamp = 1000, .url = undefined, .opts = .{} });
-        try testing.expectEqual(114, tc.page_navigate);
-        try testing.expectEqual(2006, tc.page_navigated);
-
-        notifier.unregister(.page_navigated, &tc);
-        notifier.dispatch(.page_navigate, &.{ .frame_id = 0, .req_id = 1, .timestamp = 100, .url = undefined, .opts = .{} });
-        notifier.dispatch(.page_navigated, &.{ .frame_id = 0, .req_id = 1, .timestamp = 1000, .url = undefined, .opts = .{} });
-        try testing.expectEqual(114, tc.page_navigate);
-        try testing.expectEqual(2006, tc.page_navigated);
-
-        // already unregistered, try anyways
-        notifier.unregister(.page_navigated, &tc);
-        notifier.dispatch(.page_navigate, &.{ .frame_id = 0, .req_id = 1, .timestamp = 100, .url = undefined, .opts = .{} });
-        notifier.dispatch(.page_navigated, &.{ .frame_id = 0, .req_id = 1, .timestamp = 1000, .url = undefined, .opts = .{} });
-        try testing.expectEqual(114, tc.page_navigate);
-        try testing.expectEqual(2006, tc.page_navigated);
-    }
-}
-
-const TestClient = struct {
-    page_navigate: u64 = 0,
-    page_navigated: u64 = 0,
-
-    fn pageNavigate(ptr: *anyopaque, data: *const Notification.PageNavigate) !void {
-        const self: *TestClient = @ptrCast(@alignCast(ptr));
-        self.page_navigate += data.timestamp;
-    }
-
-    fn pageNavigated(ptr: *anyopaque, data: *const Notification.PageNavigated) !void {
-        const self: *TestClient = @ptrCast(@alignCast(ptr));
-        self.page_navigated += data.timestamp;
-    }
-};

src/SemanticTree.zig

@@ -1,532 +0,0 @@
-// Copyright (C) 2023-2026  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program 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 Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  See <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-
-const lp = @import("lightpanda");
-const log = @import("log.zig");
-const isAllWhitespace = @import("string.zig").isAllWhitespace;
-const Page = lp.Page;
-const interactive = @import("browser/interactive.zig");
-
-const CData = @import("browser/webapi/CData.zig");
-const Element = @import("browser/webapi/Element.zig");
-const Node = @import("browser/webapi/Node.zig");
-const AXNode = @import("cdp/AXNode.zig");
-const CDPNode = @import("cdp/Node.zig");
-
-const Self = @This();
-
-dom_node: *Node,
-registry: *CDPNode.Registry,
-page: *Page,
-arena: std.mem.Allocator,
-prune: bool = true,
-interactive_only: bool = false,
-max_depth: u32 = std.math.maxInt(u32) - 1,
-
-pub fn jsonStringify(self: @This(), jw: *std.json.Stringify) error{WriteFailed}!void {
-    var visitor = JsonVisitor{ .jw = jw, .tree = self };
-    var xpath_buffer: std.ArrayList(u8) = .{};
-    const listener_targets = interactive.buildListenerTargetMap(self.page, self.arena) catch |err| {
-        log.err(.app, "listener map failed", .{ .err = err });
-        return error.WriteFailed;
-    };
-    self.walk(self.dom_node, &xpath_buffer, null, &visitor, 1, listener_targets, 0) catch |err| {
-        log.err(.app, "semantic tree json dump failed", .{ .err = err });
-        return error.WriteFailed;
-    };
-}
-
-pub fn textStringify(self: @This(), writer: *std.Io.Writer) error{WriteFailed}!void {
-    var visitor = TextVisitor{ .writer = writer, .tree = self, .depth = 0 };
-    var xpath_buffer: std.ArrayList(u8) = .empty;
-    const listener_targets = interactive.buildListenerTargetMap(self.page, self.arena) catch |err| {
-        log.err(.app, "listener map failed", .{ .err = err });
-        return error.WriteFailed;
-    };
-    self.walk(self.dom_node, &xpath_buffer, null, &visitor, 1, listener_targets, 0) catch |err| {
-        log.err(.app, "semantic tree text dump failed", .{ .err = err });
-        return error.WriteFailed;
-    };
-}
-
-const OptionData = struct {
-    value: []const u8,
-    text: []const u8,
-    selected: bool,
-};
-
-const NodeData = struct {
-    id: CDPNode.Id,
-    axn: AXNode,
-    role: []const u8,
-    name: ?[]const u8,
-    value: ?[]const u8,
-    options: ?[]OptionData = null,
-    xpath: []const u8,
-    is_interactive: bool,
-    node_name: []const u8,
-};
-
-fn walk(self: @This(), node: *Node, xpath_buffer: *std.ArrayList(u8), parent_name: ?[]const u8, visitor: anytype, index: usize, listener_targets: interactive.ListenerTargetMap, current_depth: u32) !void {
-    if (current_depth > self.max_depth) return;
-
-    // 1. Skip non-content nodes
-    if (node.is(Element)) |el| {
-        const tag = el.getTag();
-        if (tag.isMetadata() or tag == .svg) return;
-
-        // We handle options/optgroups natively inside their parents, skip them in the general walk
-        if (tag == .datalist or tag == .option or tag == .optgroup) return;
-
-        // Check visibility using the engine's checkVisibility which handles CSS display: none
-        if (!el.checkVisibility(self.page)) {
-            return;
-        }
-
-        if (el.is(Element.Html)) |html_el| {
-            if (html_el.getHidden()) return;
-        }
-    } else if (node.is(CData.Text)) |text_node| {
-        const text = text_node.getWholeText();
-        if (isAllWhitespace(text)) {
-            return;
-        }
-    } else if (node._type != .document and node._type != .document_fragment) {
-        return;
-    }
-
-    const cdp_node = try self.registry.register(node);
-    const axn = AXNode.fromNode(node);
-    const role = try axn.getRole();
-
-    var is_interactive = false;
-    var value: ?[]const u8 = null;
-    var options: ?[]OptionData = null;
-    var node_name: []const u8 = "text";
-
-    if (node.is(Element)) |el| {
-        node_name = el.getTagNameLower();
-
-        if (el.is(Element.Html.Input)) |input| {
-            value = input.getValue();
-            if (el.getAttributeSafe(comptime lp.String.wrap("list"))) |list_id| {
-                options = try extractDataListOptions(list_id, self.page, self.arena);
-            }
-        } else if (el.is(Element.Html.TextArea)) |textarea| {
-            value = textarea.getValue();
-        } else if (el.is(Element.Html.Select)) |select| {
-            value = select.getValue(self.page);
-            options = try extractSelectOptions(el.asNode(), self.page, self.arena);
-        }
-
-        if (el.is(Element.Html)) |html_el| {
-            if (interactive.classifyInteractivity(el, html_el, listener_targets) != null) {
-                is_interactive = true;
-            }
-        }
-    } else if (node._type == .document or node._type == .document_fragment) {
-        node_name = "root";
-    }
-
-    const initial_xpath_len = xpath_buffer.items.len;
-    try appendXPathSegment(node, xpath_buffer.writer(self.arena), index);
-    const xpath = xpath_buffer.items;
-
-    var name = try axn.getName(self.page, self.arena);
-
-    const has_explicit_label = if (node.is(Element)) |el|
-        el.getAttributeSafe(.wrap("aria-label")) != null or el.getAttributeSafe(.wrap("title")) != null
-    else
-        false;
-
-    const structural = isStructuralRole(role);
-
-    // Filter out computed concatenated names for generic containers without explicit labels.
-    // This prevents token bloat and ensures their StaticText children aren't incorrectly pruned.
-    // We ignore interactivity because a generic wrapper with an event listener still shouldn't hoist all text.
-    if (name != null and structural and !has_explicit_label) {
-        name = null;
-    }
-
-    var data = NodeData{
-        .id = cdp_node.id,
-        .axn = axn,
-        .role = role,
-        .name = name,
-        .value = value,
-        .options = options,
-        .xpath = xpath,
-        .is_interactive = is_interactive,
-        .node_name = node_name,
-    };
-
-    var should_visit = true;
-    if (self.interactive_only) {
-        var keep = false;
-        if (interactive.isInteractiveRole(role)) {
-            keep = true;
-        } else if (interactive.isContentRole(role)) {
-            if (name != null and name.?.len > 0) {
-                keep = true;
-            }
-        } else if (std.mem.eql(u8, role, "RootWebArea")) {
-            keep = true;
-        } else if (is_interactive) {
-            keep = true;
-        }
-        if (!keep) {
-            should_visit = false;
-        }
-    } else if (self.prune) {
-        if (structural and !is_interactive and !has_explicit_label) {
-            should_visit = false;
-        }
-
-        if (std.mem.eql(u8, role, "StaticText") and node._parent != null) {
-            if (parent_name != null and name != null and std.mem.indexOf(u8, parent_name.?, name.?) != null) {
-                should_visit = false;
-            }
-        }
-    }
-
-    var did_visit = false;
-    var should_walk_children = true;
-    if (should_visit) {
-        should_walk_children = try visitor.visit(node, &data);
-        did_visit = true; // Always true if should_visit was true, because visit() executed and opened structures
-    } else {
-        // If we skip the node, we must NOT tell the visitor to close it later
-        did_visit = false;
-    }
-
-    if (should_walk_children) {
-        // If we are printing this node normally OR skipping it and unrolling its children,
-        // we walk the children iterator.
-        var it = node.childrenIterator();
-        var tag_counts = std.StringArrayHashMap(usize).init(self.arena);
-        while (it.next()) |child| {
-            var tag: []const u8 = "text()";
-            if (child.is(Element)) |el| {
-                tag = el.getTagNameLower();
-            }
-
-            const gop = try tag_counts.getOrPut(tag);
-            if (!gop.found_existing) {
-                gop.value_ptr.* = 0;
-            }
-            gop.value_ptr.* += 1;
-
-            try self.walk(child, xpath_buffer, name, visitor, gop.value_ptr.*, listener_targets, current_depth + 1);
-        }
-    }
-
-    if (did_visit) {
-        try visitor.leave();
-    }
-
-    xpath_buffer.shrinkRetainingCapacity(initial_xpath_len);
-}
-
-fn extractSelectOptions(node: *Node, page: *Page, arena: std.mem.Allocator) ![]OptionData {
-    var options = std.ArrayListUnmanaged(OptionData){};
-    var it = node.childrenIterator();
-    while (it.next()) |child| {
-        if (child.is(Element)) |el| {
-            if (el.getTag() == .option) {
-                if (el.is(Element.Html.Option)) |opt| {
-                    const text = opt.getText(page);
-                    const value = opt.getValue(page);
-                    const selected = opt.getSelected();
-                    try options.append(arena, .{ .text = text, .value = value, .selected = selected });
-                }
-            } else if (el.getTag() == .optgroup) {
-                var group_it = child.childrenIterator();
-                while (group_it.next()) |group_child| {
-                    if (group_child.is(Element.Html.Option)) |opt| {
-                        const text = opt.getText(page);
-                        const value = opt.getValue(page);
-                        const selected = opt.getSelected();
-                        try options.append(arena, .{ .text = text, .value = value, .selected = selected });
-                    }
-                }
-            }
-        }
-    }
-    return options.toOwnedSlice(arena);
-}
-
-fn extractDataListOptions(list_id: []const u8, page: *Page, arena: std.mem.Allocator) !?[]OptionData {
-    if (page.document.getElementById(list_id, page)) |referenced_el| {
-        if (referenced_el.getTag() == .datalist) {
-            return try extractSelectOptions(referenced_el.asNode(), page, arena);
-        }
-    }
-    return null;
-}
-
-fn appendXPathSegment(node: *Node, writer: anytype, index: usize) !void {
-    if (node.is(Element)) |el| {
-        const tag = el.getTagNameLower();
-        try std.fmt.format(writer, "/{s}[{d}]", .{ tag, index });
-    } else if (node.is(CData.Text)) |_| {
-        try std.fmt.format(writer, "/text()[{d}]", .{index});
-    }
-}
-
-const JsonVisitor = struct {
-    jw: *std.json.Stringify,
-    tree: Self,
-
-    pub fn visit(self: *JsonVisitor, node: *Node, data: *NodeData) !bool {
-        try self.jw.beginObject();
-
-        try self.jw.objectField("nodeId");
-        try self.jw.write(try std.fmt.allocPrint(self.tree.arena, "{d}", .{data.id}));
-
-        try self.jw.objectField("backendDOMNodeId");
-        try self.jw.write(data.id);
-
-        try self.jw.objectField("nodeName");
-        try self.jw.write(data.node_name);
-
-        try self.jw.objectField("xpath");
-        try self.jw.write(data.xpath);
-
-        if (node.is(Element)) |el| {
-            try self.jw.objectField("nodeType");
-            try self.jw.write(1);
-
-            try self.jw.objectField("isInteractive");
-            try self.jw.write(data.is_interactive);
-
-            try self.jw.objectField("role");
-            try self.jw.write(data.role);
-
-            if (data.name) |name| {
-                if (name.len > 0) {
-                    try self.jw.objectField("name");
-                    try self.jw.write(name);
-                }
-            }
-
-            if (data.value) |value| {
-                try self.jw.objectField("value");
-                try self.jw.write(value);
-            }
-
-            if (el._attributes) |attrs| {
-                try self.jw.objectField("attributes");
-                try self.jw.beginObject();
-                var iter = attrs.iterator();
-                while (iter.next()) |attr| {
-                    try self.jw.objectField(attr._name.str());
-                    try self.jw.write(attr._value.str());
-                }
-                try self.jw.endObject();
-            }
-
-            if (data.options) |options| {
-                try self.jw.objectField("options");
-                try self.jw.beginArray();
-                for (options) |opt| {
-                    try self.jw.beginObject();
-                    try self.jw.objectField("value");
-                    try self.jw.write(opt.value);
-                    try self.jw.objectField("text");
-                    try self.jw.write(opt.text);
-                    try self.jw.objectField("selected");
-                    try self.jw.write(opt.selected);
-                    try self.jw.endObject();
-                }
-                try self.jw.endArray();
-            }
-        } else if (node.is(CData.Text)) |text_node| {
-            try self.jw.objectField("nodeType");
-            try self.jw.write(3);
-            try self.jw.objectField("nodeValue");
-            try self.jw.write(text_node.getWholeText());
-        } else {
-            try self.jw.objectField("nodeType");
-            try self.jw.write(9);
-        }
-
-        try self.jw.objectField("children");
-        try self.jw.beginArray();
-
-        if (data.options != null) {
-            // Signal to not walk children, as we handled them natively
-            return false;
-        }
-
-        return true;
-    }
-
-    pub fn leave(self: *JsonVisitor) !void {
-        try self.jw.endArray();
-        try self.jw.endObject();
-    }
-};
-
-fn isStructuralRole(role: []const u8) bool {
-    const structural_roles = std.StaticStringMap(void).initComptime(.{
-        .{ "none", {} },
-        .{ "generic", {} },
-        .{ "InlineTextBox", {} },
-        .{ "banner", {} },
-        .{ "navigation", {} },
-        .{ "main", {} },
-        .{ "list", {} },
-        .{ "listitem", {} },
-        .{ "table", {} },
-        .{ "rowgroup", {} },
-        .{ "row", {} },
-        .{ "cell", {} },
-        .{ "region", {} },
-    });
-    return structural_roles.has(role);
-}
-
-const TextVisitor = struct {
-    writer: *std.Io.Writer,
-    tree: Self,
-    depth: usize,
-
-    pub fn visit(self: *TextVisitor, node: *Node, data: *NodeData) !bool {
-        for (0..self.depth) |_| {
-            try self.writer.writeByte(' ');
-        }
-
-        var name_to_print: ?[]const u8 = null;
-        if (data.name) |n| {
-            if (n.len > 0) {
-                name_to_print = n;
-            }
-        } else if (node.is(CData.Text)) |text_node| {
-            const trimmed = std.mem.trim(u8, text_node.getWholeText(), " \t\r\n");
-            if (trimmed.len > 0) {
-                name_to_print = trimmed;
-            }
-        }
-
-        const is_text_only = std.mem.eql(u8, data.role, "StaticText") or std.mem.eql(u8, data.role, "none") or std.mem.eql(u8, data.role, "generic");
-
-        try self.writer.print("{d}", .{data.id});
-        if (!is_text_only) {
-            try self.writer.print(" {s}", .{data.role});
-        }
-        if (name_to_print) |n| {
-            try self.writer.print(" '{s}'", .{n});
-        }
-
-        if (data.value) |v| {
-            if (v.len > 0) {
-                try self.writer.print(" value='{s}'", .{v});
-            }
-        }
-
-        if (data.options) |options| {
-            try self.writer.writeAll(" options=[");
-            for (options, 0..) |opt, i| {
-                if (i > 0) try self.writer.writeAll(",");
-                try self.writer.print("'{s}'", .{opt.value});
-                if (opt.selected) {
-                    try self.writer.writeAll("*");
-                }
-            }
-            try self.writer.writeAll("]\n");
-            self.depth += 1;
-            return false; // Native handling complete, do not walk children
-        }
-
-        try self.writer.writeByte('\n');
-        self.depth += 1;
-
-        // If this is a leaf-like semantic node and we already have a name,
-        // skip children to avoid redundant StaticText or noise.
-        const is_leaf_semantic = std.mem.eql(u8, data.role, "link") or
-            std.mem.eql(u8, data.role, "button") or
-            std.mem.eql(u8, data.role, "heading") or
-            std.mem.eql(u8, data.role, "code");
-        if (is_leaf_semantic and data.name != null and data.name.?.len > 0) {
-            return false;
-        }
-
-        return true;
-    }
-
-    pub fn leave(self: *TextVisitor) !void {
-        if (self.depth > 0) {
-            self.depth -= 1;
-        }
-    }
-};
-
-const testing = @import("testing.zig");
-
-test "SemanticTree backendDOMNodeId" {
-    var registry: CDPNode.Registry = .init(testing.allocator);
-    defer registry.deinit();
-
-    var page = try testing.pageTest("cdp/registry1.html");
-    defer testing.reset();
-    defer page._session.removePage();
-
-    const st: Self = .{
-        .dom_node = page.window._document.asNode(),
-        .registry = &registry,
-        .page = page,
-        .arena = testing.arena_allocator,
-        .prune = false,
-        .interactive_only = false,
-        .max_depth = std.math.maxInt(u32) - 1,
-    };
-
-    const json_str = try std.json.Stringify.valueAlloc(testing.allocator, st, .{});
-    defer testing.allocator.free(json_str);
-
-    try testing.expect(std.mem.indexOf(u8, json_str, "\"backendDOMNodeId\":") != null);
-}
-
-test "SemanticTree max_depth" {
-    var registry: CDPNode.Registry = .init(testing.allocator);
-    defer registry.deinit();
-
-    var page = try testing.pageTest("cdp/registry1.html");
-    defer testing.reset();
-    defer page._session.removePage();
-
-    const st: Self = .{
-        .dom_node = page.window._document.asNode(),
-        .registry = &registry,
-        .page = page,
-        .arena = testing.arena_allocator,
-        .prune = false,
-        .interactive_only = false,
-        .max_depth = 1,
-    };
-
-    var aw: std.Io.Writer.Allocating = .init(testing.allocator);
-    defer aw.deinit();
-
-    try st.textStringify(&aw.writer);
-    const text_str = aw.written();
-
-    try testing.expect(std.mem.indexOf(u8, text_str, "other") == null);
-}

src/Server.zig

@@ -1,935 +0,0 @@
-// Copyright (C) 2023-2025 Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program 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 Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-const lp = @import("lightpanda");
-const net = std.net;
-const posix = std.posix;
-
-const Allocator = std.mem.Allocator;
-const ArenaAllocator = std.heap.ArenaAllocator;
-
-const log = @import("log.zig");
-const App = @import("App.zig");
-const Config = @import("Config.zig");
-const CDP = @import("cdp/cdp.zig").CDP;
-const Net = @import("network/websocket.zig");
-const HttpClient = @import("browser/HttpClient.zig");
-
-const Server = @This();
-
-app: *App,
-allocator: Allocator,
-json_version_response: []const u8,
-
-// Thread management
-active_threads: std.atomic.Value(u32) = .init(0),
-clients: std.ArrayList(*Client) = .{},
-client_mutex: std.Thread.Mutex = .{},
-clients_pool: std.heap.MemoryPool(Client),
-
-pub fn init(app: *App, address: net.Address) !*Server {
-    const allocator = app.allocator;
-    const json_version_response = try buildJSONVersionResponse(allocator, address);
-    errdefer allocator.free(json_version_response);
-
-    const self = try allocator.create(Server);
-    errdefer allocator.destroy(self);
-
-    self.* = .{
-        .app = app,
-        .allocator = allocator,
-        .json_version_response = json_version_response,
-        .clients_pool = std.heap.MemoryPool(Client).init(allocator),
-    };
-
-    try self.app.network.bind(address, self, onAccept);
-    log.info(.app, "server running", .{ .address = address });
-
-    return self;
-}
-
-pub fn shutdown(self: *Server) void {
-    self.client_mutex.lock();
-    defer self.client_mutex.unlock();
-
-    for (self.clients.items) |client| {
-        client.stop();
-    }
-}
-
-pub fn deinit(self: *Server) void {
-    self.shutdown();
-    self.joinThreads();
-    self.clients.deinit(self.allocator);
-    self.clients_pool.deinit();
-    self.allocator.free(self.json_version_response);
-    self.allocator.destroy(self);
-}
-
-fn onAccept(ctx: *anyopaque, socket: posix.socket_t) void {
-    const self: *Server = @ptrCast(@alignCast(ctx));
-    const timeout_ms: u32 = @intCast(self.app.config.cdpTimeout());
-    self.spawnWorker(socket, timeout_ms) catch |err| {
-        log.err(.app, "CDP spawn", .{ .err = err });
-        posix.close(socket);
-    };
-}
-
-fn handleConnection(self: *Server, socket: posix.socket_t, timeout_ms: u32) void {
-    defer posix.close(socket);
-
-    // Client is HUGE (> 512KB) because it has a large read buffer.
-    // V8 crashes if this is on the stack (likely related to its size).
-    const client = self.getClient() catch |err| {
-        log.err(.app, "CDP client create", .{ .err = err });
-        return;
-    };
-    defer self.releaseClient(client);
-
-    client.* = Client.init(
-        socket,
-        self.allocator,
-        self.app,
-        self.json_version_response,
-        timeout_ms,
-    ) catch |err| {
-        log.err(.app, "CDP client init", .{ .err = err });
-        return;
-    };
-    defer client.deinit();
-
-    self.registerClient(client);
-    defer self.unregisterClient(client);
-
-    // Check shutdown after registering to avoid missing the stop signal.
-    // If deinit() already iterated over clients, this client won't receive stop()
-    // and would block joinThreads() indefinitely.
-    if (self.app.shutdown()) {
-        return;
-    }
-
-    client.start();
-}
-
-fn getClient(self: *Server) !*Client {
-    self.client_mutex.lock();
-    defer self.client_mutex.unlock();
-    return self.clients_pool.create();
-}
-
-fn releaseClient(self: *Server, client: *Client) void {
-    self.client_mutex.lock();
-    defer self.client_mutex.unlock();
-    self.clients_pool.destroy(client);
-}
-
-fn registerClient(self: *Server, client: *Client) void {
-    self.client_mutex.lock();
-    defer self.client_mutex.unlock();
-    self.clients.append(self.allocator, client) catch {};
-}
-
-fn unregisterClient(self: *Server, client: *Client) void {
-    self.client_mutex.lock();
-    defer self.client_mutex.unlock();
-    for (self.clients.items, 0..) |c, i| {
-        if (c == client) {
-            _ = self.clients.swapRemove(i);
-            break;
-        }
-    }
-}
-
-fn spawnWorker(self: *Server, socket: posix.socket_t, timeout_ms: u32) !void {
-    if (self.app.shutdown()) {
-        return error.ShuttingDown;
-    }
-
-    // Atomically increment active_threads only if below max_connections.
-    // Uses CAS loop to avoid race between checking the limit and incrementing.
-    //
-    // cmpxchgWeak may fail for two reasons:
-    // 1. Another thread changed the value (increment or decrement)
-    // 2. Spurious failure on some architectures (e.g. ARM)
-    //
-    // We use Weak instead of Strong because we need a retry loop anyway:
-    // if CAS fails because a thread finished (counter decreased), we should
-    // retry rather than return an error - there may now be room for a new connection.
-    //
-    // On failure, cmpxchgWeak returns the actual value, which we reuse to avoid
-    // an extra load on the next iteration.
-    const max_connections = self.app.config.maxConnections();
-    var current = self.active_threads.load(.monotonic);
-    while (current < max_connections) {
-        current = self.active_threads.cmpxchgWeak(current, current + 1, .monotonic, .monotonic) orelse break;
-    } else {
-        return error.MaxThreadsReached;
-    }
-    errdefer _ = self.active_threads.fetchSub(1, .monotonic);
-
-    const thread = try std.Thread.spawn(.{}, runWorker, .{ self, socket, timeout_ms });
-    thread.detach();
-}
-
-fn runWorker(self: *Server, socket: posix.socket_t, timeout_ms: u32) void {
-    defer _ = self.active_threads.fetchSub(1, .monotonic);
-    handleConnection(self, socket, timeout_ms);
-}
-
-fn joinThreads(self: *Server) void {
-    while (self.active_threads.load(.monotonic) > 0) {
-        std.Thread.sleep(10 * std.time.ns_per_ms);
-    }
-}
-
-// Handle exactly one TCP connection.
-pub const Client = struct {
-    // The client is initially serving HTTP requests but, under normal circumstances
-    // should eventually be upgraded to a websocket connections
-    mode: union(enum) {
-        http: void,
-        cdp: CDP,
-    },
-
-    allocator: Allocator,
-    app: *App,
-    http: *HttpClient,
-    ws: Net.WsConnection,
-
-    fn init(
-        socket: posix.socket_t,
-        allocator: Allocator,
-        app: *App,
-        json_version_response: []const u8,
-        timeout_ms: u32,
-    ) !Client {
-        var ws = try Net.WsConnection.init(socket, allocator, json_version_response, timeout_ms);
-        errdefer ws.deinit();
-
-        if (log.enabled(.app, .info)) {
-            const client_address = ws.getAddress() catch null;
-            log.info(.app, "client connected", .{ .ip = client_address });
-        }
-
-        const http = try HttpClient.init(allocator, &app.network);
-        errdefer http.deinit();
-
-        return .{
-            .allocator = allocator,
-            .app = app,
-            .http = http,
-            .ws = ws,
-            .mode = .{ .http = {} },
-        };
-    }
-
-    fn stop(self: *Client) void {
-        switch (self.mode) {
-            .http => {},
-            .cdp => |*cdp| {
-                cdp.browser.env.terminate();
-                self.ws.sendClose();
-            },
-        }
-        self.ws.shutdown();
-    }
-
-    fn deinit(self: *Client) void {
-        switch (self.mode) {
-            .cdp => |*cdp| cdp.deinit(),
-            .http => {},
-        }
-        self.ws.deinit();
-        self.http.deinit();
-    }
-
-    fn start(self: *Client) void {
-        const http = self.http;
-        http.cdp_client = .{
-            .socket = self.ws.socket,
-            .ctx = self,
-            .blocking_read_start = Client.blockingReadStart,
-            .blocking_read = Client.blockingRead,
-            .blocking_read_end = Client.blockingReadStop,
-        };
-        defer http.cdp_client = null;
-
-        self.httpLoop(http) catch |err| {
-            log.err(.app, "CDP client loop", .{ .err = err });
-        };
-    }
-
-    fn httpLoop(self: *Client, http: *HttpClient) !void {
-        lp.assert(self.mode == .http, "Client.httpLoop invalid mode", .{});
-
-        while (true) {
-            const status = http.tick(self.ws.timeout_ms) catch |err| {
-                log.err(.app, "http tick", .{ .err = err });
-                return;
-            };
-            if (status != .cdp_socket) {
-                log.info(.app, "CDP timeout", .{});
-                return;
-            }
-
-            if (self.readSocket() == false) {
-                return;
-            }
-
-            if (self.mode == .cdp) {
-                break;
-            }
-        }
-
-        var cdp = &self.mode.cdp;
-        var last_message = milliTimestamp(.monotonic);
-        var ms_remaining = self.ws.timeout_ms;
-
-        while (true) {
-            switch (cdp.pageWait(ms_remaining)) {
-                .cdp_socket => {
-                    if (self.readSocket() == false) {
-                        return;
-                    }
-                    last_message = milliTimestamp(.monotonic);
-                    ms_remaining = self.ws.timeout_ms;
-                },
-                .no_page => {
-                    const status = http.tick(ms_remaining) catch |err| {
-                        log.err(.app, "http tick", .{ .err = err });
-                        return;
-                    };
-                    if (status != .cdp_socket) {
-                        log.info(.app, "CDP timeout", .{});
-                        return;
-                    }
-                    if (self.readSocket() == false) {
-                        return;
-                    }
-                    last_message = milliTimestamp(.monotonic);
-                    ms_remaining = self.ws.timeout_ms;
-                },
-                .done => {
-                    const now = milliTimestamp(.monotonic);
-                    const elapsed = now - last_message;
-                    if (elapsed >= ms_remaining) {
-                        log.info(.app, "CDP timeout", .{});
-                        return;
-                    }
-                    ms_remaining -= @intCast(elapsed);
-                    last_message = now;
-                },
-            }
-        }
-    }
-
-    fn blockingReadStart(ctx: *anyopaque) bool {
-        const self: *Client = @ptrCast(@alignCast(ctx));
-        self.ws.setBlocking(true) catch |err| {
-            log.warn(.app, "CDP blockingReadStart", .{ .err = err });
-            return false;
-        };
-        return true;
-    }
-
-    fn blockingRead(ctx: *anyopaque) bool {
-        const self: *Client = @ptrCast(@alignCast(ctx));
-        return self.readSocket();
-    }
-
-    fn blockingReadStop(ctx: *anyopaque) bool {
-        const self: *Client = @ptrCast(@alignCast(ctx));
-        self.ws.setBlocking(false) catch |err| {
-            log.warn(.app, "CDP blockingReadStop", .{ .err = err });
-            return false;
-        };
-        return true;
-    }
-
-    fn readSocket(self: *Client) bool {
-        const n = self.ws.read() catch |err| {
-            log.warn(.app, "CDP read", .{ .err = err });
-            return false;
-        };
-
-        if (n == 0) {
-            log.info(.app, "CDP disconnect", .{});
-            return false;
-        }
-
-        return self.processData() catch false;
-    }
-
-    fn processData(self: *Client) !bool {
-        switch (self.mode) {
-            .cdp => |*cdp| return self.processWebsocketMessage(cdp),
-            .http => return self.processHTTPRequest(),
-        }
-    }
-
-    fn processHTTPRequest(self: *Client) !bool {
-        lp.assert(self.ws.reader.pos == 0, "Client.HTTP pos", .{ .pos = self.ws.reader.pos });
-        const request = self.ws.reader.buf[0..self.ws.reader.len];
-
-        if (request.len > Config.CDP_MAX_HTTP_REQUEST_SIZE) {
-            self.writeHTTPErrorResponse(413, "Request too large");
-            return error.RequestTooLarge;
-        }
-
-        // we're only expecting [body-less] GET requests.
-        if (std.mem.endsWith(u8, request, "\r\n\r\n") == false) {
-            // we need more data, put any more data here
-            return true;
-        }
-
-        // the next incoming data can go to the front of our buffer
-        defer self.ws.reader.len = 0;
-        return self.handleHTTPRequest(request) catch |err| {
-            switch (err) {
-                error.NotFound => self.writeHTTPErrorResponse(404, "Not found"),
-                error.InvalidRequest => self.writeHTTPErrorResponse(400, "Invalid request"),
-                error.InvalidProtocol => self.writeHTTPErrorResponse(400, "Invalid HTTP protocol"),
-                error.MissingHeaders => self.writeHTTPErrorResponse(400, "Missing required header"),
-                error.InvalidUpgradeHeader => self.writeHTTPErrorResponse(400, "Unsupported upgrade type"),
-                error.InvalidVersionHeader => self.writeHTTPErrorResponse(400, "Invalid websocket version"),
-                error.InvalidConnectionHeader => self.writeHTTPErrorResponse(400, "Invalid connection header"),
-                else => {
-                    log.err(.app, "server 500", .{ .err = err, .req = request[0..@min(100, request.len)] });
-                    self.writeHTTPErrorResponse(500, "Internal Server Error");
-                },
-            }
-            return err;
-        };
-    }
-
-    fn handleHTTPRequest(self: *Client, request: []u8) !bool {
-        if (request.len < 18) {
-            // 18 is [generously] the smallest acceptable HTTP request
-            return error.InvalidRequest;
-        }
-
-        if (std.mem.eql(u8, request[0..4], "GET ") == false) {
-            return error.NotFound;
-        }
-
-        const url_end = std.mem.indexOfScalarPos(u8, request, 4, ' ') orelse {
-            return error.InvalidRequest;
-        };
-
-        const url = request[4..url_end];
-
-        if (std.mem.eql(u8, url, "/")) {
-            try self.upgradeConnection(request);
-            return true;
-        }
-
-        if (std.mem.eql(u8, url, "/json/version") or std.mem.eql(u8, url, "/json/version/")) {
-            try self.ws.send(self.ws.json_version_response);
-            // Chromedp (a Go driver) does an http request to /json/version
-            // then to / (websocket upgrade) using a different connection.
-            // Since we only allow 1 connection at a time, the 2nd one (the
-            // websocket upgrade) blocks until the first one times out.
-            // We can avoid that by closing the connection. json_version_response
-            // has a Connection: Close header too.
-            self.ws.shutdown();
-            return false;
-        }
-
-        return error.NotFound;
-    }
-
-    fn upgradeConnection(self: *Client, request: []u8) !void {
-        try self.ws.upgrade(request);
-        self.mode = .{ .cdp = try CDP.init(self.app, self.http, self) };
-    }
-
-    fn writeHTTPErrorResponse(self: *Client, comptime status: u16, comptime body: []const u8) void {
-        self.ws.sendHttpError(status, body);
-    }
-
-    fn processWebsocketMessage(self: *Client, cdp: *CDP) !bool {
-        return self.ws.processMessages(cdp);
-    }
-
-    pub fn sendAllocator(self: *Client) Allocator {
-        return self.ws.send_arena.allocator();
-    }
-
-    pub fn sendJSON(self: *Client, message: anytype, opts: std.json.Stringify.Options) !void {
-        return self.ws.sendJSON(message, opts);
-    }
-
-    pub fn sendJSONRaw(self: *Client, buf: std.ArrayList(u8)) !void {
-        return self.ws.sendJSONRaw(buf);
-    }
-};
-
-// Utils
-// --------
-
-fn buildJSONVersionResponse(
-    allocator: Allocator,
-    address: net.Address,
-) ![]const u8 {
-    const body_format = "{{\"webSocketDebuggerUrl\": \"ws://{f}/\"}}";
-    const body_len = std.fmt.count(body_format, .{address});
-
-    // We send a Connection: Close (and actually close the connection)
-    // because chromedp (Go driver) sends a request to /json/version and then
-    // does an upgrade request, on a different connection. Since we only allow
-    // 1 connection at a time, the upgrade connection doesn't proceed until we
-    // timeout the /json/version. So, instead of waiting for that, we just
-    // always close HTTP requests.
-    const response_format =
-        "HTTP/1.1 200 OK\r\n" ++
-        "Content-Length: {d}\r\n" ++
-        "Connection: Close\r\n" ++
-        "Content-Type: application/json; charset=UTF-8\r\n\r\n" ++
-        body_format;
-    return try std.fmt.allocPrint(allocator, response_format, .{ body_len, address });
-}
-
-pub const timestamp = @import("datetime.zig").timestamp;
-pub const milliTimestamp = @import("datetime.zig").milliTimestamp;
-
-const testing = std.testing;
-test "server: buildJSONVersionResponse" {
-    const address = try net.Address.parseIp4("127.0.0.1", 9001);
-    const res = try buildJSONVersionResponse(testing.allocator, address);
-    defer testing.allocator.free(res);
-
-    try testing.expectEqualStrings("HTTP/1.1 200 OK\r\n" ++
-        "Content-Length: 48\r\n" ++
-        "Connection: Close\r\n" ++
-        "Content-Type: application/json; charset=UTF-8\r\n\r\n" ++
-        "{\"webSocketDebuggerUrl\": \"ws://127.0.0.1:9001/\"}", res);
-}
-
-test "Client: http invalid request" {
-    var c = try createTestClient();
-    defer c.deinit();
-
-    const res = try c.httpRequest("GET /over/9000 HTTP/1.1\r\n" ++ "Header: " ++ ("a" ** 4100) ++ "\r\n\r\n");
-    try testing.expectEqualStrings("HTTP/1.1 413 \r\n" ++
-        "Connection: Close\r\n" ++
-        "Content-Length: 17\r\n\r\n" ++
-        "Request too large", res);
-}
-
-test "Client: http invalid handshake" {
-    try assertHTTPError(
-        400,
-        "Invalid request",
-        "\r\n\r\n",
-    );
-
-    try assertHTTPError(
-        404,
-        "Not found",
-        "GET /over/9000 HTTP/1.1\r\n\r\n",
-    );
-
-    try assertHTTPError(
-        404,
-        "Not found",
-        "POST / HTTP/1.1\r\n\r\n",
-    );
-
-    try assertHTTPError(
-        400,
-        "Invalid HTTP protocol",
-        "GET / HTTP/1.0\r\n\r\n",
-    );
-
-    try assertHTTPError(
-        400,
-        "Missing required header",
-        "GET / HTTP/1.1\r\n\r\n",
-    );
-
-    try assertHTTPError(
-        400,
-        "Missing required header",
-        "GET / HTTP/1.1\r\nConnection:  upgrade\r\n\r\n",
-    );
-
-    try assertHTTPError(
-        400,
-        "Missing required header",
-        "GET / HTTP/1.1\r\nConnection: upgrade\r\nUpgrade: websocket\r\n\r\n",
-    );
-
-    try assertHTTPError(
-        400,
-        "Missing required header",
-        "GET / HTTP/1.1\r\nConnection: upgrade\r\nUpgrade: websocket\r\nsec-websocket-version:13\r\n\r\n",
-    );
-}
-
-test "Client: http valid handshake" {
-    var c = try createTestClient();
-    defer c.deinit();
-
-    const request =
-        "GET /   HTTP/1.1\r\n" ++
-        "Connection: upgrade\r\n" ++
-        "Upgrade: websocket\r\n" ++
-        "sec-websocket-version:13\r\n" ++
-        "sec-websocket-key: this is my key\r\n" ++
-        "Custom:  Header-Value\r\n\r\n";
-
-    const res = try c.httpRequest(request);
-    try testing.expectEqualStrings("HTTP/1.1 101 Switching Protocols\r\n" ++
-        "Upgrade: websocket\r\n" ++
-        "Connection: upgrade\r\n" ++
-        "Sec-Websocket-Accept: flzHu2DevQ2dSCSVqKSii5e9C2o=\r\n\r\n", res);
-}
-
-test "Client: read invalid websocket message" {
-    // 131 = 128 (fin) | 3  where 3 isn't a valid type
-    try assertWebSocketError(
-        1002,
-        &.{ 131, 128, 'm', 'a', 's', 'k' },
-    );
-
-    for ([_]u8{ 16, 32, 64 }) |rsv| {
-        // none of the reserve flags should be set
-        try assertWebSocketError(
-            1002,
-            &.{ rsv, 128, 'm', 'a', 's', 'k' },
-        );
-
-        // as a bitmask
-        try assertWebSocketError(
-            1002,
-            &.{ rsv + 4, 128, 'm', 'a', 's', 'k' },
-        );
-    }
-
-    // client->server messages must be masked
-    try assertWebSocketError(
-        1002,
-        &.{ 129, 1, 'a' },
-    );
-
-    // control types (ping/ping/close) can't be > 125 bytes
-    for ([_]u8{ 136, 137, 138 }) |op| {
-        try assertWebSocketError(
-            1002,
-            &.{ op, 254, 1, 1 },
-        );
-    }
-
-    // length of message is 0000 0810, i.e: 1024 * 512 + 265
-    try assertWebSocketError(1009, &.{ 129, 255, 0, 0, 0, 0, 0, 8, 1, 0, 'm', 'a', 's', 'k' });
-
-    // continuation type message must come after a normal message
-    // even when not a fin frame
-    try assertWebSocketError(
-        1002,
-        &.{ 0, 129, 'm', 'a', 's', 'k', 'd' },
-    );
-
-    // continuation type message must come after a normal message
-    // even as a fin frame
-    try assertWebSocketError(
-        1002,
-        &.{ 128, 129, 'm', 'a', 's', 'k', 'd' },
-    );
-
-    // text (non-fin) - text (non-fin)
-    try assertWebSocketError(
-        1002,
-        &.{ 1, 129, 'm', 'a', 's', 'k', 'd', 1, 128, 'k', 's', 'a', 'm' },
-    );
-
-    // text (non-fin) - text (fin) should always been continuation after non-fin
-    try assertWebSocketError(
-        1002,
-        &.{ 1, 129, 'm', 'a', 's', 'k', 'd', 129, 128, 'k', 's', 'a', 'm' },
-    );
-
-    // close must be fin
-    try assertWebSocketError(
-        1002,
-        &.{
-            8, 129, 'm', 'a', 's', 'k', 'd',
-        },
-    );
-
-    // ping must be fin
-    try assertWebSocketError(
-        1002,
-        &.{
-            9, 129, 'm', 'a', 's', 'k', 'd',
-        },
-    );
-
-    // pong must be fin
-    try assertWebSocketError(
-        1002,
-        &.{
-            10, 129, 'm', 'a', 's', 'k', 'd',
-        },
-    );
-}
-
-test "Client: ping reply" {
-    try assertWebSocketMessage(
-        // fin | pong, len
-        &.{ 138, 0 },
-
-        // fin | ping, masked | len, 4-byte mask
-        &.{ 137, 128, 0, 0, 0, 0 },
-    );
-
-    try assertWebSocketMessage(
-        // fin | pong, len, payload
-        &.{ 138, 5, 100, 96, 97, 109, 104 },
-
-        // fin | ping, masked | len, 4-byte mask, 5 byte payload
-        &.{ 137, 133, 0, 5, 7, 10, 100, 101, 102, 103, 104 },
-    );
-}
-
-test "Client: close message" {
-    try assertWebSocketMessage(
-        // fin | close, len, close code (normal)
-        &.{ 136, 2, 3, 232 },
-
-        // fin | close, masked | len, 4-byte mask
-        &.{ 136, 128, 0, 0, 0, 0 },
-    );
-}
-
-test "server: 404" {
-    var c = try createTestClient();
-    defer c.deinit();
-
-    const res = try c.httpRequest("GET /unknown HTTP/1.1\r\n\r\n");
-    try testing.expectEqualStrings("HTTP/1.1 404 \r\n" ++
-        "Connection: Close\r\n" ++
-        "Content-Length: 9\r\n\r\n" ++
-        "Not found", res);
-}
-
-test "server: get /json/version" {
-    const expected_response =
-        "HTTP/1.1 200 OK\r\n" ++
-        "Content-Length: 48\r\n" ++
-        "Connection: Close\r\n" ++
-        "Content-Type: application/json; charset=UTF-8\r\n\r\n" ++
-        "{\"webSocketDebuggerUrl\": \"ws://127.0.0.1:9583/\"}";
-
-    {
-        // twice on the same connection
-        var c = try createTestClient();
-        defer c.deinit();
-
-        const res1 = try c.httpRequest("GET /json/version HTTP/1.1\r\n\r\n");
-        try testing.expectEqualStrings(expected_response, res1);
-    }
-
-    {
-        // again on a new connection
-        var c = try createTestClient();
-        defer c.deinit();
-
-        const res1 = try c.httpRequest("GET /json/version HTTP/1.1\r\n\r\n");
-        try testing.expectEqualStrings(expected_response, res1);
-    }
-}
-
-fn assertHTTPError(
-    comptime expected_status: u16,
-    comptime expected_body: []const u8,
-    input: []const u8,
-) !void {
-    var c = try createTestClient();
-    defer c.deinit();
-
-    const res = try c.httpRequest(input);
-    const expected_response = std.fmt.comptimePrint(
-        "HTTP/1.1 {d} \r\nConnection: Close\r\nContent-Length: {d}\r\n\r\n{s}",
-        .{ expected_status, expected_body.len, expected_body },
-    );
-
-    try testing.expectEqualStrings(expected_response, res);
-}
-
-fn assertWebSocketError(close_code: u16, input: []const u8) !void {
-    var c = try createTestClient();
-    defer c.deinit();
-
-    try c.handshake();
-    try c.stream.writeAll(input);
-
-    const msg = try c.readWebsocketMessage() orelse return error.NoMessage;
-    defer if (msg.cleanup_fragment) {
-        c.reader.cleanup();
-    };
-
-    try testing.expectEqual(.close, msg.type);
-    try testing.expectEqual(2, msg.data.len);
-    try testing.expectEqual(close_code, std.mem.readInt(u16, msg.data[0..2], .big));
-}
-
-fn assertWebSocketMessage(expected: []const u8, input: []const u8) !void {
-    var c = try createTestClient();
-    defer c.deinit();
-
-    try c.handshake();
-    try c.stream.writeAll(input);
-
-    const msg = try c.readWebsocketMessage() orelse return error.NoMessage;
-    defer if (msg.cleanup_fragment) {
-        c.reader.cleanup();
-    };
-
-    const actual = c.reader.buf[0 .. msg.data.len + 2];
-    try testing.expectEqualSlices(u8, expected, actual);
-}
-
-const MockCDP = struct {
-    messages: std.ArrayList([]const u8) = .{},
-
-    allocator: Allocator = testing.allocator,
-
-    fn init(_: Allocator, client: anytype) MockCDP {
-        _ = client;
-        return .{};
-    }
-
-    fn deinit(self: *MockCDP) void {
-        const allocator = self.allocator;
-        for (self.messages.items) |msg| {
-            allocator.free(msg);
-        }
-        self.messages.deinit(allocator);
-    }
-
-    fn handleMessage(self: *MockCDP, message: []const u8) bool {
-        const owned = self.allocator.dupe(u8, message) catch unreachable;
-        self.messages.append(self.allocator, owned) catch unreachable;
-        return true;
-    }
-};
-
-fn createTestClient() !TestClient {
-    const address = std.net.Address.initIp4([_]u8{ 127, 0, 0, 1 }, 9583);
-    const stream = try std.net.tcpConnectToAddress(address);
-
-    const timeout = std.mem.toBytes(posix.timeval{
-        .sec = 2,
-        .usec = 0,
-    });
-    try posix.setsockopt(stream.handle, posix.SOL.SOCKET, posix.SO.RCVTIMEO, &timeout);
-    try posix.setsockopt(stream.handle, posix.SOL.SOCKET, posix.SO.SNDTIMEO, &timeout);
-    return .{
-        .stream = stream,
-        .reader = .{
-            .allocator = testing.allocator,
-            .buf = try testing.allocator.alloc(u8, 1024 * 16),
-        },
-    };
-}
-
-const TestClient = struct {
-    stream: std.net.Stream,
-    buf: [1024]u8 = undefined,
-    reader: Net.Reader(false),
-
-    fn deinit(self: *TestClient) void {
-        self.stream.close();
-        self.reader.deinit();
-    }
-
-    fn httpRequest(self: *TestClient, req: []const u8) ![]const u8 {
-        try self.stream.writeAll(req);
-
-        var pos: usize = 0;
-        var total_length: ?usize = null;
-        while (true) {
-            pos += try self.stream.read(self.buf[pos..]);
-            if (pos == 0) {
-                return error.NoMoreData;
-            }
-            const response = self.buf[0..pos];
-            if (total_length == null) {
-                const header_end = std.mem.indexOf(u8, response, "\r\n\r\n") orelse continue;
-                const header = response[0 .. header_end + 4];
-
-                const cl = blk: {
-                    const cl_header = "Content-Length: ";
-                    const start = (std.mem.indexOf(u8, header, cl_header) orelse {
-                        break :blk 0;
-                    }) + cl_header.len;
-
-                    const end = std.mem.indexOfScalarPos(u8, header, start, '\r') orelse {
-                        return error.InvalidContentLength;
-                    };
-
-                    break :blk std.fmt.parseInt(usize, header[start..end], 10) catch {
-                        return error.InvalidContentLength;
-                    };
-                };
-
-                total_length = cl + header.len;
-            }
-
-            if (total_length) |tl| {
-                if (pos == tl) {
-                    return response;
-                }
-                if (pos > tl) {
-                    return error.DataExceedsContentLength;
-                }
-            }
-        }
-    }
-
-    fn handshake(self: *TestClient) !void {
-        const request =
-            "GET /   HTTP/1.1\r\n" ++
-            "Connection: upgrade\r\n" ++
-            "Upgrade: websocket\r\n" ++
-            "sec-websocket-version:13\r\n" ++
-            "sec-websocket-key: this is my key\r\n" ++
-            "Custom:  Header-Value\r\n\r\n";
-
-        const res = try self.httpRequest(request);
-        try testing.expectEqualStrings("HTTP/1.1 101 Switching Protocols\r\n" ++
-            "Upgrade: websocket\r\n" ++
-            "Connection: upgrade\r\n" ++
-            "Sec-Websocket-Accept: flzHu2DevQ2dSCSVqKSii5e9C2o=\r\n\r\n", res);
-    }
-
-    fn readWebsocketMessage(self: *TestClient) !?Net.Message {
-        while (true) {
-            const n = try self.stream.read(self.reader.readBuf());
-            if (n == 0) {
-                return error.Closed;
-            }
-            self.reader.len += n;
-            if (try self.reader.next()) |msg| {
-                return msg;
-            }
-        }
-    }
-};

src/Sighandler.zig

@@ -1,107 +0,0 @@
-// Copyright (C) 2023-2025  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program 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 Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-//! This structure processes operating system signals (SIGINT, SIGTERM)
-//! and runs callbacks to clean up the system gracefully.
-//!
-//! The structure does not clear the memory allocated in the arena,
-//! clear the entire arena when exiting the program.
-const std = @import("std");
-const assert = std.debug.assert;
-const Allocator = std.mem.Allocator;
-const lp = @import("lightpanda");
-
-const log = lp.log;
-
-const SigHandler = @This();
-
-arena: Allocator,
-
-sigset: std.posix.sigset_t = undefined,
-handle_thread: ?std.Thread = null,
-
-attempt: u32 = 0,
-listeners: std.ArrayList(Listener) = .empty,
-
-pub const Listener = struct {
-    args: []const u8,
-    start: *const fn (context: *const anyopaque) void,
-};
-
-pub fn install(self: *SigHandler) !void {
-    // Block SIGINT and SIGTERM for the current thread and all created from it
-    self.sigset = std.posix.sigemptyset();
-    std.posix.sigaddset(&self.sigset, std.posix.SIG.INT);
-    std.posix.sigaddset(&self.sigset, std.posix.SIG.TERM);
-    std.posix.sigaddset(&self.sigset, std.posix.SIG.QUIT);
-    std.posix.sigprocmask(std.posix.SIG.BLOCK, &self.sigset, null);
-
-    self.handle_thread = try std.Thread.spawn(.{ .allocator = self.arena }, SigHandler.sighandle, .{self});
-    self.handle_thread.?.detach();
-}
-
-pub fn on(self: *SigHandler, func: anytype, args: std.meta.ArgsTuple(@TypeOf(func))) !void {
-    assert(@typeInfo(@TypeOf(func)).@"fn".return_type.? == void);
-
-    const Args = @TypeOf(args);
-    const TypeErased = struct {
-        fn start(context: *const anyopaque) void {
-            const args_casted: *const Args = @ptrCast(@alignCast(context));
-            @call(.auto, func, args_casted.*);
-        }
-    };
-
-    const buffer = try self.arena.alignedAlloc(u8, .of(Args), @sizeOf(Args));
-    errdefer self.arena.free(buffer);
-
-    const bytes: []const u8 = @ptrCast((&args)[0..1]);
-    @memcpy(buffer, bytes);
-
-    try self.listeners.append(self.arena, .{
-        .args = buffer,
-        .start = TypeErased.start,
-    });
-}
-
-fn sighandle(self: *SigHandler) noreturn {
-    while (true) {
-        var sig: c_int = 0;
-
-        const rc = std.c.sigwait(&self.sigset, &sig);
-        if (rc != 0) {
-            log.err(.app, "Unable to process signal {}", .{rc});
-            std.process.exit(1);
-        }
-
-        switch (sig) {
-            std.posix.SIG.INT, std.posix.SIG.TERM => {
-                if (self.attempt > 1) {
-                    std.process.exit(1);
-                }
-                self.attempt += 1;
-
-                log.info(.app, "Received termination signal...", .{});
-                for (self.listeners.items) |*item| {
-                    item.start(item.args.ptr);
-                }
-                continue;
-            },
-            else => continue,
-        }
-    }
-}

src/TestHTTPServer.zig

@@ -1,27 +1,8 @@
-// Copyright (C) 2023-2025  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program 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 Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
 const std = @import("std");
-const URL = @import("browser/URL.zig");
 
 const TestHTTPServer = @This();
 
-shutdown: std.atomic.Value(bool),
+shutdown: bool,
 listener: ?std.net.Server,
 handler: Handler,
 
@@ -29,23 +10,16 @@ const Handler = *const fn (req: *std.http.Server.Request) anyerror!void;
 
 pub fn init(handler: Handler) TestHTTPServer {
     return .{
-        .shutdown = .init(true),
+        .shutdown = true,
         .listener = null,
         .handler = handler,
     };
 }
 
 pub fn deinit(self: *TestHTTPServer) void {
-    self.listener = null;
-}
-
-pub fn stop(self: *TestHTTPServer) void {
-    self.shutdown.store(true, .release);
+    self.shutdown = true;
     if (self.listener) |*listener| {
-        switch (@import("builtin").target.os.tag) {
-            .linux => std.posix.shutdown(listener.stream.handle, .recv) catch {},
-            else => std.posix.close(listener.stream.handle),
-        }
+        listener.deinit();
     }
 }
 
@@ -54,13 +28,12 @@ pub fn run(self: *TestHTTPServer, wg: *std.Thread.WaitGroup) !void {
 
     self.listener = try address.listen(.{ .reuse_address = true });
     var listener = &self.listener.?;
-    self.shutdown.store(false, .release);
 
     wg.finish();
 
     while (true) {
         const conn = listener.accept() catch |err| {
-            if (self.shutdown.load(.acquire) or err == error.SocketNotListening) {
+            if (self.shutdown) {
                 return;
             }
             return err;
@@ -88,7 +61,6 @@ fn handleConnection(self: *TestHTTPServer, conn: std.net.Server.Connection) !voi
                 return err;
             },
         };
-
         self.handler(&req) catch |err| {
             std.debug.print("test http error '{s}': {}\n", .{ req.head.target, err });
             try req.respond("server error", .{ .status = .internal_server_error });
@@ -98,10 +70,7 @@ fn handleConnection(self: *TestHTTPServer, conn: std.net.Server.Connection) !voi
 }
 
 pub fn sendFile(req: *std.http.Server.Request, file_path: []const u8) !void {
-    var url_buf: [1024]u8 = undefined;
-    var fba = std.heap.FixedBufferAllocator.init(&url_buf);
-    const unescaped_file_path = try URL.unescape(fba.allocator(), file_path);
-    var file = std.fs.cwd().openFile(unescaped_file_path, .{}) catch |err| switch (err) {
+    var file = std.fs.cwd().openFile(file_path, .{}) catch |err| switch (err) {
         error.FileNotFound => return req.respond("server error", .{ .status = .not_found }),
         else => return err,
     };
@@ -131,6 +100,11 @@ fn getContentType(file_path: []const u8) []const u8 {
         return "application/json";
     }
 
+    if (std.mem.endsWith(u8, file_path, ".mjs")) {
+        // mjs are ECMAScript modules
+        return "application/json";
+    }
+
     if (std.mem.endsWith(u8, file_path, ".html")) {
         return "text/html";
     }
@@ -144,11 +118,6 @@ fn getContentType(file_path: []const u8) []const u8 {
         return "text/xml";
     }
 
-    if (std.mem.endsWith(u8, file_path, ".mjs")) {
-        // mjs are ECMAScript modules
-        return "application/json";
-    }
-
     std.debug.print("TestHTTPServer asked to serve an unknown file type: {s}\n", .{file_path});
     return "text/html";
 }

src/app.zig

@@ -0,0 +1,121 @@
+const std = @import("std");
+
+const Allocator = std.mem.Allocator;
+
+const log = @import("log.zig");
+const Http = @import("http/Http.zig");
+const Platform = @import("browser/js/Platform.zig");
+
+const Telemetry = @import("telemetry/telemetry.zig").Telemetry;
+const Notification = @import("notification.zig").Notification;
+
+// Container for global state / objects that various parts of the system
+// might need.
+pub const App = struct {
+    http: Http,
+    config: Config,
+    platform: Platform,
+    allocator: Allocator,
+    telemetry: Telemetry,
+    app_dir_path: ?[]const u8,
+    notification: *Notification,
+    shutdown: bool = false,
+
+    pub const RunMode = enum {
+        help,
+        fetch,
+        serve,
+        version,
+    };
+
+    pub const Config = struct {
+        run_mode: RunMode,
+        tls_verify_host: bool = true,
+        http_proxy: ?[:0]const u8 = null,
+        proxy_bearer_token: ?[:0]const u8 = null,
+        http_timeout_ms: ?u31 = null,
+        http_connect_timeout_ms: ?u31 = null,
+        http_max_host_open: ?u8 = null,
+        http_max_concurrent: ?u8 = null,
+        user_agent: [:0]const u8,
+    };
+
+    pub fn init(allocator: Allocator, config: Config) !*App {
+        const app = try allocator.create(App);
+        errdefer allocator.destroy(app);
+
+        const notification = try Notification.init(allocator, null);
+        errdefer notification.deinit();
+
+        var http = try Http.init(allocator, .{
+            .max_host_open = config.http_max_host_open orelse 4,
+            .max_concurrent = config.http_max_concurrent orelse 10,
+            .timeout_ms = config.http_timeout_ms orelse 5000,
+            .connect_timeout_ms = config.http_connect_timeout_ms orelse 0,
+            .http_proxy = config.http_proxy,
+            .tls_verify_host = config.tls_verify_host,
+            .proxy_bearer_token = config.proxy_bearer_token,
+            .user_agent = config.user_agent,
+        });
+        errdefer http.deinit();
+
+        const platform = try Platform.init();
+        errdefer platform.deinit();
+
+        const app_dir_path = getAndMakeAppDir(allocator);
+
+        app.* = .{
+            .http = http,
+            .allocator = allocator,
+            .telemetry = undefined,
+            .platform = platform,
+            .app_dir_path = app_dir_path,
+            .notification = notification,
+            .config = config,
+        };
+
+        app.telemetry = try Telemetry.init(app, config.run_mode);
+        errdefer app.telemetry.deinit();
+
+        try app.telemetry.register(app.notification);
+
+        return app;
+    }
+
+    pub fn deinit(self: *App) void {
+        if (@atomicRmw(bool, &self.shutdown, .Xchg, true, .monotonic)) {
+            return;
+        }
+
+        const allocator = self.allocator;
+        if (self.app_dir_path) |app_dir_path| {
+            allocator.free(app_dir_path);
+            self.app_dir_path = null;
+        }
+        self.telemetry.deinit();
+        self.notification.deinit();
+        self.http.deinit();
+        self.platform.deinit();
+        allocator.destroy(self);
+    }
+};
+
+fn getAndMakeAppDir(allocator: Allocator) ?[]const u8 {
+    if (@import("builtin").is_test) {
+        return allocator.dupe(u8, "/tmp") catch unreachable;
+    }
+    const app_dir_path = std.fs.getAppDataDir(allocator, "lightpanda") catch |err| {
+        log.warn(.app, "get data dir", .{ .err = err });
+        return null;
+    };
+
+    std.fs.cwd().makePath(app_dir_path) catch |err| switch (err) {
+        error.PathAlreadyExists => return app_dir_path,
+        else => {
+            allocator.free(app_dir_path);
+            log.warn(.app, "create data dir", .{ .err = err, .path = app_dir_path });
+            return null;
+        },
+    };
+    return app_dir_path;
+}

src/browser/Browser.zig

@@ -1,122 +0,0 @@
-// Copyright (C) 2023-2025  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program 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 Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-
-const Allocator = std.mem.Allocator;
-const ArenaAllocator = std.heap.ArenaAllocator;
-
-const js = @import("js/js.zig");
-const log = @import("../log.zig");
-const App = @import("../App.zig");
-const HttpClient = @import("HttpClient.zig");
-
-const ArenaPool = App.ArenaPool;
-
-const IS_DEBUG = @import("builtin").mode == .Debug;
-
-const Session = @import("Session.zig");
-const Notification = @import("../Notification.zig");
-
-// Browser is an instance of the browser.
-// You can create multiple browser instances.
-// A browser contains only one session.
-const Browser = @This();
-
-env: js.Env,
-app: *App,
-session: ?Session,
-allocator: Allocator,
-arena_pool: *ArenaPool,
-http_client: *HttpClient,
-
-const InitOpts = struct {
-    env: js.Env.InitOpts = .{},
-    http_client: *HttpClient,
-};
-
-pub fn init(app: *App, opts: InitOpts) !Browser {
-    const allocator = app.allocator;
-
-    var env = try js.Env.init(app, opts.env);
-    errdefer env.deinit();
-
-    return .{
-        .app = app,
-        .env = env,
-        .session = null,
-        .allocator = allocator,
-        .arena_pool = &app.arena_pool,
-        .http_client = opts.http_client,
-    };
-}
-
-pub fn deinit(self: *Browser) void {
-    self.closeSession();
-    self.env.deinit();
-}
-
-pub fn newSession(self: *Browser, notification: *Notification) !*Session {
-    self.closeSession();
-    self.session = @as(Session, undefined);
-    const session = &self.session.?;
-    try Session.init(session, self, notification);
-    return session;
-}
-
-pub fn closeSession(self: *Browser) void {
-    if (self.session) |*session| {
-        session.deinit();
-        self.session = null;
-        self.env.memoryPressureNotification(.critical);
-    }
-}
-
-pub fn runMicrotasks(self: *Browser) void {
-    self.env.runMicrotasks();
-}
-
-pub fn runMacrotasks(self: *Browser) !void {
-    const env = &self.env;
-
-    try self.env.runMacrotasks();
-    env.pumpMessageLoop();
-
-    // either of the above could have queued more microtasks
-    env.runMicrotasks();
-}
-
-pub fn hasBackgroundTasks(self: *Browser) bool {
-    return self.env.hasBackgroundTasks();
-}
-
-pub fn waitForBackgroundTasks(self: *Browser) void {
-    self.env.waitForBackgroundTasks();
-}
-
-pub fn msToNextMacrotask(self: *Browser) ?u64 {
-    return self.env.msToNextMacrotask();
-}
-
-pub fn msTo(self: *Browser) bool {
-    return self.env.hasBackgroundTasks();
-}
-
-pub fn runIdleTasks(self: *const Browser) void {
-    self.env.runIdleTasks();
-}

src/browser/DataURI.zig

@@ -0,0 +1,52 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+
+// Parses data:[<media-type>][;base64],<data>
+pub fn parse(allocator: Allocator, src: []const u8) !?[]const u8 {
+    if (!std.mem.startsWith(u8, src, "data:")) {
+        return null;
+    }
+
+    const uri = src[5..];
+    const data_starts = std.mem.indexOfScalar(u8, uri, ',') orelse return null;
+
+    var data = uri[data_starts + 1 ..];
+
+    // Extract the encoding.
+    const metadata = uri[0..data_starts];
+    if (std.mem.endsWith(u8, metadata, ";base64")) {
+        const decoder = std.base64.standard.Decoder;
+        const decoded_size = try decoder.calcSizeForSlice(data);
+
+        const buffer = try allocator.alloc(u8, decoded_size);
+        errdefer allocator.free(buffer);
+
+        try decoder.decode(buffer, data);
+        data = buffer;
+    }
+
+    return data;
+}
+
+const testing = @import("../testing.zig");
+test "DataURI: parse valid" {
+    try test_valid("data:text/javascript; charset=utf-8;base64,Zm9v", "foo");
+    try test_valid("data:text/javascript; charset=utf-8;,foo", "foo");
+    try test_valid("data:,foo", "foo");
+}
+
+test "DataURI: parse invalid" {
+    try test_cannot_parse("atad:,foo");
+    try test_cannot_parse("data:foo");
+    try test_cannot_parse("data:");
+}
+
+fn test_valid(uri: []const u8, expected: []const u8) !void {
+    defer testing.reset();
+    const data_uri = try parse(testing.arena_allocator, uri) orelse return error.TestFailed;
+    try testing.expectEqual(expected, data_uri);
+}
+
+fn test_cannot_parse(uri: []const u8) !void {
+    try testing.expectEqual(null, parse(undefined, uri));
+}

src/browser/EventManager.zig

@@ -1,943 +0,0 @@
-// Copyright (C) 2023-2025  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program 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 Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-const builtin = @import("builtin");
-
-const log = @import("../log.zig");
-const String = @import("../string.zig").String;
-
-const js = @import("js/js.zig");
-const Page = @import("Page.zig");
-
-const Node = @import("webapi/Node.zig");
-const Event = @import("webapi/Event.zig");
-const EventTarget = @import("webapi/EventTarget.zig");
-const Element = @import("webapi/Element.zig");
-
-const Allocator = std.mem.Allocator;
-
-const IS_DEBUG = builtin.mode == .Debug;
-
-const EventKey = struct {
-    event_target: usize,
-    type_string: String,
-};
-
-const EventKeyContext = struct {
-    pub fn hash(_: @This(), key: EventKey) u64 {
-        var hasher = std.hash.Wyhash.init(0);
-        hasher.update(std.mem.asBytes(&key.event_target));
-        hasher.update(key.type_string.str());
-        return hasher.final();
-    }
-
-    pub fn eql(_: @This(), a: EventKey, b: EventKey) bool {
-        return a.event_target == b.event_target and a.type_string.eql(b.type_string);
-    }
-};
-
-pub const EventManager = @This();
-
-page: *Page,
-arena: Allocator,
-// Used as an optimization in Page._documentIsComplete. If we know there are no
-// 'load' listeners in the document, we can skip dispatching the per-resource
-// 'load' event (e.g. amazon product page has no listener and ~350 resources)
-has_dom_load_listener: bool,
-listener_pool: std.heap.MemoryPool(Listener),
-ignore_list: std.ArrayList(*Listener),
-list_pool: std.heap.MemoryPool(std.DoublyLinkedList),
-lookup: std.HashMapUnmanaged(
-    EventKey,
-    *std.DoublyLinkedList,
-    EventKeyContext,
-    std.hash_map.default_max_load_percentage,
-),
-dispatch_depth: usize,
-deferred_removals: std.ArrayList(struct { list: *std.DoublyLinkedList, listener: *Listener }),
-
-pub fn init(arena: Allocator, page: *Page) EventManager {
-    return .{
-        .page = page,
-        .lookup = .{},
-        .arena = arena,
-        .ignore_list = .{},
-        .list_pool = .init(arena),
-        .listener_pool = .init(arena),
-        .dispatch_depth = 0,
-        .deferred_removals = .{},
-        .has_dom_load_listener = false,
-    };
-}
-
-pub const RegisterOptions = struct {
-    once: bool = false,
-    capture: bool = false,
-    passive: bool = false,
-    signal: ?*@import("webapi/AbortSignal.zig") = null,
-};
-
-pub const Callback = union(enum) {
-    function: js.Function,
-    object: js.Object,
-};
-
-pub fn register(self: *EventManager, target: *EventTarget, typ: []const u8, callback: Callback, opts: RegisterOptions) !void {
-    if (comptime IS_DEBUG) {
-        log.debug(.event, "eventManager.register", .{ .type = typ, .capture = opts.capture, .once = opts.once, .target = target.toString() });
-    }
-
-    // If a signal is provided and already aborted, don't register the listener
-    if (opts.signal) |signal| {
-        if (signal.getAborted()) {
-            return;
-        }
-    }
-
-    // Allocate the type string we'll use in both listener and key
-    const type_string = try String.init(self.arena, typ, .{});
-
-    if (type_string.eql(comptime .wrap("load")) and target._type == .node) {
-        self.has_dom_load_listener = true;
-    }
-
-    const gop = try self.lookup.getOrPut(self.arena, .{
-        .type_string = type_string,
-        .event_target = @intFromPtr(target),
-    });
-    if (gop.found_existing) {
-        // check for duplicate callbacks already registered
-        var node = gop.value_ptr.*.first;
-        while (node) |n| {
-            const listener: *Listener = @alignCast(@fieldParentPtr("node", n));
-            const is_duplicate = switch (callback) {
-                .object => |obj| listener.function.eqlObject(obj),
-                .function => |func| listener.function.eqlFunction(func),
-            };
-            if (is_duplicate and listener.capture == opts.capture) {
-                return;
-            }
-            node = n.next;
-        }
-    } else {
-        gop.value_ptr.* = try self.list_pool.create();
-        gop.value_ptr.*.* = .{};
-    }
-
-    const func = switch (callback) {
-        .function => |f| Function{ .value = try f.persist() },
-        .object => |o| Function{ .object = try o.persist() },
-    };
-
-    const listener = try self.listener_pool.create();
-    listener.* = .{
-        .node = .{},
-        .once = opts.once,
-        .capture = opts.capture,
-        .passive = opts.passive,
-        .function = func,
-        .signal = opts.signal,
-        .typ = type_string,
-    };
-    // append the listener to the list of listeners for this target
-    gop.value_ptr.*.append(&listener.node);
-
-    // Track load listeners for script execution ignore list
-    if (type_string.eql(comptime .wrap("load"))) {
-        try self.ignore_list.append(self.arena, listener);
-    }
-}
-
-pub fn remove(self: *EventManager, target: *EventTarget, typ: []const u8, callback: Callback, use_capture: bool) void {
-    const list = self.lookup.get(.{
-        .type_string = .wrap(typ),
-        .event_target = @intFromPtr(target),
-    }) orelse return;
-    if (findListener(list, callback, use_capture)) |listener| {
-        self.removeListener(list, listener);
-    }
-}
-
-pub fn clearIgnoreList(self: *EventManager) void {
-    self.ignore_list.clearRetainingCapacity();
-}
-
-// Dispatching can be recursive from the compiler's point of view, so we need to
-// give it an explicit error set so that other parts of the code can use and
-// inferred error.
-const DispatchError = error{
-    OutOfMemory,
-    StringTooLarge,
-    JSExecCallback,
-    CompilationError,
-    ExecutionError,
-    JsException,
-};
-
-pub const DispatchOpts = struct {
-    // A "load" event triggered by a script (in ScriptManager) should not trigger
-    // a "load" listener added within that script. Therefore, any "load" listener
-    // that we add go into an ignore list until after the script finishes executing.
-    // The ignore list is only checked when apply_ignore  == true, which is only
-    // set by the ScriptManager when raising the script's "load" event.
-    apply_ignore: bool = false,
-};
-
-pub fn dispatch(self: *EventManager, target: *EventTarget, event: *Event) DispatchError!void {
-    return self.dispatchOpts(target, event, .{});
-}
-
-pub fn dispatchOpts(self: *EventManager, target: *EventTarget, event: *Event, comptime opts: DispatchOpts) DispatchError!void {
-    event.acquireRef();
-    defer event.deinit(false, self.page._session);
-
-    if (comptime IS_DEBUG) {
-        log.debug(.event, "eventManager.dispatch", .{ .type = event._type_string.str(), .bubbles = event._bubbles });
-    }
-
-    switch (target._type) {
-        .node => |node| try self.dispatchNode(node, event, opts),
-        else => try self.dispatchDirect(target, event, null, .{ .context = "dispatch" }),
-    }
-}
-
-// There are a lot of events that can be attached via addEventListener or as
-// a property, like the XHR events, or window.onload. You might think that the
-// property is just a shortcut for calling addEventListener, but they are distinct.
-// An event set via property cannot be removed by removeEventListener. If you
-// set both the property and add a listener, they both execute.
-const DispatchDirectOptions = struct {
-    context: []const u8,
-    inject_target: bool = true,
-};
-
-// Direct dispatch for non-DOM targets (Window, XHR, AbortSignal) or DOM nodes with
-// property handlers. No propagation - just calls the handler and registered listeners.
-// Handler can be: null, ?js.Function.Global, ?js.Function.Temp, or js.Function
-pub fn dispatchDirect(self: *EventManager, target: *EventTarget, event: *Event, handler: anytype, comptime opts: DispatchDirectOptions) !void {
-    const page = self.page;
-
-    // Set window.event to the currently dispatching event (WHATWG spec)
-    const window = page.window;
-    const prev_event = window._current_event;
-    window._current_event = event;
-    defer window._current_event = prev_event;
-
-    event.acquireRef();
-    defer event.deinit(false, page._session);
-
-    if (comptime IS_DEBUG) {
-        log.debug(.event, "dispatchDirect", .{ .type = event._type_string, .context = opts.context });
-    }
-
-    if (comptime opts.inject_target) {
-        event._target = target;
-        event._dispatch_target = target; // Store original target for composedPath()
-    }
-
-    var was_dispatched = false;
-
-    var ls: js.Local.Scope = undefined;
-    page.js.localScope(&ls);
-    defer {
-        ls.local.runMicrotasks();
-        ls.deinit();
-    }
-
-    if (getFunction(handler, &ls.local)) |func| {
-        event._current_target = target;
-        if (func.callWithThis(void, target, .{event})) {
-            was_dispatched = true;
-        } else |err| {
-            // a non-JS error
-            log.warn(.event, opts.context, .{ .err = err });
-        }
-    }
-
-    // listeners reigstered via addEventListener
-    const list = self.lookup.get(.{
-        .event_target = @intFromPtr(target),
-        .type_string = event._type_string,
-    }) orelse return;
-
-    // This is a slightly simplified version of what you'll find in dispatchPhase
-    // It is simpler because, for direct dispatching, we know there's no ancestors
-    // and only the single target phase.
-
-    // Track dispatch depth for deferred removal
-    self.dispatch_depth += 1;
-    defer {
-        const dispatch_depth = self.dispatch_depth;
-        // Only destroy deferred listeners when we exit the outermost dispatch
-        if (dispatch_depth == 1) {
-            for (self.deferred_removals.items) |removal| {
-                removal.list.remove(&removal.listener.node);
-                self.listener_pool.destroy(removal.listener);
-            }
-            self.deferred_removals.clearRetainingCapacity();
-        } else {
-            self.dispatch_depth = dispatch_depth - 1;
-        }
-    }
-
-    // Use the last listener in the list as sentinel - listeners added during dispatch will be after it
-    const last_node = list.last orelse return;
-    const last_listener: *Listener = @alignCast(@fieldParentPtr("node", last_node));
-
-    // Iterate through the list, stopping after we've encountered the last_listener
-    var node = list.first;
-    var is_done = false;
-    while (node) |n| {
-        if (is_done) {
-            break;
-        }
-
-        const listener: *Listener = @alignCast(@fieldParentPtr("node", n));
-        is_done = (listener == last_listener);
-        node = n.next;
-
-        // Skip removed listeners
-        if (listener.removed) {
-            continue;
-        }
-
-        // If the listener has an aborted signal, remove it and skip
-        if (listener.signal) |signal| {
-            if (signal.getAborted()) {
-                self.removeListener(list, listener);
-                continue;
-            }
-        }
-
-        // Remove "once" listeners BEFORE calling them so nested dispatches don't see them
-        if (listener.once) {
-            self.removeListener(list, listener);
-        }
-
-        was_dispatched = true;
-        event._current_target = target;
-
-        switch (listener.function) {
-            .value => |value| try ls.toLocal(value).callWithThis(void, target, .{event}),
-            .string => |string| {
-                const str = try page.call_arena.dupeZ(u8, string.str());
-                try ls.local.eval(str, null);
-            },
-            .object => |obj_global| {
-                const obj = ls.toLocal(obj_global);
-                if (try obj.getFunction("handleEvent")) |handleEvent| {
-                    try handleEvent.callWithThis(void, obj, .{event});
-                }
-            },
-        }
-
-        if (event._stop_immediate_propagation) {
-            return;
-        }
-    }
-}
-
-fn getFunction(handler: anytype, local: *const js.Local) ?js.Function {
-    const T = @TypeOf(handler);
-    const ti = @typeInfo(T);
-
-    if (ti == .null) {
-        return null;
-    }
-    if (ti == .optional) {
-        return getFunction(handler orelse return null, local);
-    }
-    return switch (T) {
-        js.Function => handler,
-        js.Function.Temp => local.toLocal(handler),
-        js.Function.Global => local.toLocal(handler),
-        else => @compileError("handler must be null or \\??js.Function(\\.(Temp|Global))?"),
-    };
-}
-
-/// Check if there are any listeners for a direct dispatch (non-DOM target).
-/// Use this to avoid creating an event when there are no listeners.
-pub fn hasDirectListeners(self: *EventManager, target: *EventTarget, typ: []const u8, handler: anytype) bool {
-    if (hasHandler(handler)) {
-        return true;
-    }
-    return self.lookup.get(.{
-        .event_target = @intFromPtr(target),
-        .type_string = .wrap(typ),
-    }) != null;
-}
-
-fn hasHandler(handler: anytype) bool {
-    const ti = @typeInfo(@TypeOf(handler));
-    if (ti == .null) {
-        return false;
-    }
-    if (ti == .optional) {
-        return handler != null;
-    }
-    return true;
-}
-
-fn dispatchNode(self: *EventManager, target: *Node, event: *Event, comptime opts: DispatchOpts) !void {
-    const ShadowRoot = @import("webapi/ShadowRoot.zig");
-
-    {
-        const et = target.asEventTarget();
-        event._target = et;
-        event._dispatch_target = et; // Store original target for composedPath()
-    }
-
-    const page = self.page;
-
-    // Set window.event to the currently dispatching event (WHATWG spec)
-    const window = page.window;
-    const prev_event = window._current_event;
-    window._current_event = event;
-    defer window._current_event = prev_event;
-
-    var was_handled = false;
-
-    // Create a single scope for all event handlers in this dispatch.
-    // This ensures function handles passed to queueMicrotask remain valid
-    // throughout the entire dispatch, preventing crashes when microtasks run.
-    var ls: js.Local.Scope = undefined;
-    page.js.localScope(&ls);
-    defer {
-        if (was_handled) {
-            ls.local.runMicrotasks();
-        }
-        ls.deinit();
-    }
-
-    const activation_state = ActivationState.create(event, target, page);
-
-    // Defer runs even on early return - ensures event phase is reset
-    // and default actions execute (unless prevented)
-    defer {
-        event._event_phase = .none;
-        event._stop_propagation = false;
-        event._stop_immediate_propagation = false;
-        // Handle checkbox/radio activation rollback or commit
-        if (activation_state) |state| {
-            state.restore(event, page);
-        }
-
-        // Execute default action if not prevented
-        if (event._prevent_default) {
-            // can't return in a defer (╯°□°)╯︵ ┻━┻
-        } else if (event._type_string.eql(comptime .wrap("click"))) {
-            page.handleClick(target) catch |err| {
-                log.warn(.event, "page.click", .{ .err = err });
-            };
-        } else if (event._type_string.eql(comptime .wrap("keydown"))) {
-            page.handleKeydown(target, event) catch |err| {
-                log.warn(.event, "page.keydown", .{ .err = err });
-            };
-        }
-    }
-
-    var path_len: usize = 0;
-    var path_buffer: [128]*EventTarget = undefined;
-
-    var node: ?*Node = target;
-    while (node) |n| {
-        if (path_len >= path_buffer.len) break;
-        path_buffer[path_len] = n.asEventTarget();
-        path_len += 1;
-
-        // Check if this node is a shadow root
-        if (n.is(ShadowRoot)) |shadow| {
-            event._needs_retargeting = true;
-
-            // If event is not composed, stop at shadow boundary
-            if (!event._composed) {
-                break;
-            }
-
-            // Otherwise, jump to the shadow host and continue
-            node = shadow._host.asNode();
-            continue;
-        }
-
-        node = n._parent;
-    }
-
-    // Even though the window isn't part of the DOM, most events propagate
-    // through it in the capture phase (unless we stopped at a shadow boundary)
-    // The only explicit exception is "load"
-    if (event._type_string.eql(comptime .wrap("load")) == false) {
-        if (path_len < path_buffer.len) {
-            path_buffer[path_len] = page.window.asEventTarget();
-            path_len += 1;
-        }
-    }
-
-    const path = path_buffer[0..path_len];
-
-    // Phase 1: Capturing phase (root → target, excluding target)
-    // This happens for all events, regardless of bubbling
-    event._event_phase = .capturing_phase;
-    var i: usize = path_len;
-    while (i > 1) {
-        i -= 1;
-        if (event._stop_propagation) return;
-        const current_target = path[i];
-        if (self.lookup.get(.{
-            .event_target = @intFromPtr(current_target),
-            .type_string = event._type_string,
-        })) |list| {
-            try self.dispatchPhase(list, current_target, event, &was_handled, &ls.local, comptime .init(true, opts));
-        }
-    }
-
-    // Phase 2: At target
-    if (event._stop_propagation) return;
-    event._event_phase = .at_target;
-    const target_et = target.asEventTarget();
-
-    blk: {
-        // Get inline handler (e.g., onclick property) for this target
-        if (self.getInlineHandler(target_et, event)) |inline_handler| {
-            was_handled = true;
-            event._current_target = target_et;
-
-            try ls.toLocal(inline_handler).callWithThis(void, target_et, .{event});
-
-            if (event._stop_propagation) {
-                return;
-            }
-
-            if (event._stop_immediate_propagation) {
-                break :blk;
-            }
-        }
-
-        if (self.lookup.get(.{
-            .type_string = event._type_string,
-            .event_target = @intFromPtr(target_et),
-        })) |list| {
-            try self.dispatchPhase(list, target_et, event, &was_handled, &ls.local, comptime .init(null, opts));
-            if (event._stop_propagation) {
-                return;
-            }
-        }
-    }
-
-    // Phase 3: Bubbling phase (target → root, excluding target)
-    // This only happens if the event bubbles
-    if (event._bubbles) {
-        event._event_phase = .bubbling_phase;
-        for (path[1..]) |current_target| {
-            if (event._stop_propagation) break;
-            if (self.lookup.get(.{
-                .type_string = event._type_string,
-                .event_target = @intFromPtr(current_target),
-            })) |list| {
-                try self.dispatchPhase(list, current_target, event, &was_handled, &ls.local, comptime .init(false, opts));
-            }
-        }
-    }
-}
-
-const DispatchPhaseOpts = struct {
-    capture_only: ?bool = null,
-    apply_ignore: bool = false,
-
-    fn init(capture_only: ?bool, opts: DispatchOpts) DispatchPhaseOpts {
-        return .{
-            .capture_only = capture_only,
-            .apply_ignore = opts.apply_ignore,
-        };
-    }
-};
-
-fn dispatchPhase(self: *EventManager, list: *std.DoublyLinkedList, current_target: *EventTarget, event: *Event, was_handled: *bool, local: *const js.Local, comptime opts: DispatchPhaseOpts) !void {
-    const page = self.page;
-
-    // Track dispatch depth for deferred removal
-    self.dispatch_depth += 1;
-    defer {
-        const dispatch_depth = self.dispatch_depth;
-        // Only destroy deferred listeners when we exit the outermost dispatch
-        if (dispatch_depth == 1) {
-            for (self.deferred_removals.items) |removal| {
-                removal.list.remove(&removal.listener.node);
-                self.listener_pool.destroy(removal.listener);
-            }
-            self.deferred_removals.clearRetainingCapacity();
-        } else {
-            self.dispatch_depth = dispatch_depth - 1;
-        }
-    }
-
-    // Use the last listener in the list as sentinel - listeners added during dispatch will be after it
-    const last_node = list.last orelse return;
-    const last_listener: *Listener = @alignCast(@fieldParentPtr("node", last_node));
-
-    // Iterate through the list, stopping after we've encountered the last_listener
-    var node = list.first;
-    var is_done = false;
-    node_loop: while (node) |n| {
-        if (is_done) {
-            break;
-        }
-
-        const listener: *Listener = @alignCast(@fieldParentPtr("node", n));
-        is_done = (listener == last_listener);
-        node = n.next;
-
-        // Skip non-matching listeners
-        if (comptime opts.capture_only) |capture| {
-            if (listener.capture != capture) {
-                continue;
-            }
-        }
-
-        // Skip removed listeners
-        if (listener.removed) {
-            continue;
-        }
-
-        // If the listener has an aborted signal, remove it and skip
-        if (listener.signal) |signal| {
-            if (signal.getAborted()) {
-                self.removeListener(list, listener);
-                continue;
-            }
-        }
-
-        if (comptime opts.apply_ignore) {
-            for (self.ignore_list.items) |ignored| {
-                if (ignored == listener) {
-                    continue :node_loop;
-                }
-            }
-        }
-
-        // Remove "once" listeners BEFORE calling them so nested dispatches don't see them
-        if (listener.once) {
-            self.removeListener(list, listener);
-        }
-
-        was_handled.* = true;
-        event._current_target = current_target;
-
-        // Compute adjusted target for shadow DOM retargeting (only if needed)
-        const original_target = event._target;
-        if (event._needs_retargeting) {
-            event._target = getAdjustedTarget(original_target, current_target);
-        }
-
-        switch (listener.function) {
-            .value => |value| try local.toLocal(value).callWithThis(void, current_target, .{event}),
-            .string => |string| {
-                const str = try page.call_arena.dupeZ(u8, string.str());
-                try local.eval(str, null);
-            },
-            .object => |obj_global| {
-                const obj = local.toLocal(obj_global);
-                if (try obj.getFunction("handleEvent")) |handleEvent| {
-                    try handleEvent.callWithThis(void, obj, .{event});
-                }
-            },
-        }
-
-        // Restore original target (only if we changed it)
-        if (event._needs_retargeting) {
-            event._target = original_target;
-        }
-
-        if (event._stop_immediate_propagation) {
-            return;
-        }
-    }
-}
-
-fn getInlineHandler(self: *EventManager, target: *EventTarget, event: *Event) ?js.Function.Global {
-    const global_event_handlers = @import("webapi/global_event_handlers.zig");
-    const handler_type = global_event_handlers.fromEventType(event._type_string.str()) orelse return null;
-
-    // Look up the inline handler for this target
-    const html_element = switch (target._type) {
-        .node => |n| n.is(Element.Html) orelse return null,
-        else => return null,
-    };
-
-    return html_element.getAttributeFunction(handler_type, self.page) catch |err| {
-        log.warn(.event, "inline html callback", .{ .type = handler_type, .err = err });
-        return null;
-    };
-}
-
-fn removeListener(self: *EventManager, list: *std.DoublyLinkedList, listener: *Listener) void {
-    // If we're in a dispatch, defer removal to avoid invalidating iteration
-    if (self.dispatch_depth > 0) {
-        listener.removed = true;
-        self.deferred_removals.append(self.arena, .{ .list = list, .listener = listener }) catch unreachable;
-    } else {
-        // Outside dispatch, remove immediately
-        list.remove(&listener.node);
-        self.listener_pool.destroy(listener);
-    }
-}
-
-fn findListener(list: *const std.DoublyLinkedList, callback: Callback, capture: bool) ?*Listener {
-    var node = list.first;
-    while (node) |n| {
-        node = n.next;
-        const listener: *Listener = @alignCast(@fieldParentPtr("node", n));
-        const matches = switch (callback) {
-            .object => |obj| listener.function.eqlObject(obj),
-            .function => |func| listener.function.eqlFunction(func),
-        };
-        if (!matches) {
-            continue;
-        }
-        if (listener.capture != capture) {
-            continue;
-        }
-        return listener;
-    }
-    return null;
-}
-
-const Listener = struct {
-    typ: String,
-    once: bool,
-    capture: bool,
-    passive: bool,
-    function: Function,
-    signal: ?*@import("webapi/AbortSignal.zig") = null,
-    node: std.DoublyLinkedList.Node,
-    removed: bool = false,
-};
-
-const Function = union(enum) {
-    value: js.Function.Global,
-    string: String,
-    object: js.Object.Global,
-
-    fn eqlFunction(self: Function, func: js.Function) bool {
-        return switch (self) {
-            .value => |v| v.isEqual(func),
-            else => false,
-        };
-    }
-
-    fn eqlObject(self: Function, obj: js.Object) bool {
-        return switch (self) {
-            .object => |o| return o.isEqual(obj),
-            else => false,
-        };
-    }
-};
-
-// Computes the adjusted target for shadow DOM event retargeting
-// Returns the lowest shadow-including ancestor of original_target that is
-// also an ancestor-or-self of current_target
-fn getAdjustedTarget(original_target: ?*EventTarget, current_target: *EventTarget) ?*EventTarget {
-    const ShadowRoot = @import("webapi/ShadowRoot.zig");
-
-    const orig_node = switch ((original_target orelse return null)._type) {
-        .node => |n| n,
-        else => return original_target,
-    };
-    const curr_node = switch (current_target._type) {
-        .node => |n| n,
-        else => return original_target,
-    };
-
-    // Walk up from original target, checking if we can reach current target
-    var node: ?*Node = orig_node;
-    while (node) |n| {
-        // Check if current_target is an ancestor of n (or n itself)
-        if (isAncestorOrSelf(curr_node, n)) {
-            return n.asEventTarget();
-        }
-
-        // Cross shadow boundary if needed
-        if (n.is(ShadowRoot)) |shadow| {
-            node = shadow._host.asNode();
-            continue;
-        }
-
-        node = n._parent;
-    }
-
-    return original_target;
-}
-
-// Check if ancestor is an ancestor of (or the same as) node
-// WITHOUT crossing shadow boundaries (just regular DOM tree)
-fn isAncestorOrSelf(ancestor: *Node, node: *Node) bool {
-    if (ancestor == node) {
-        return true;
-    }
-
-    var current: ?*Node = node._parent;
-    while (current) |n| {
-        if (n == ancestor) {
-            return true;
-        }
-        current = n._parent;
-    }
-
-    return false;
-}
-
-// Handles the default action for clicking on input checked/radio. Maybe this
-// could be generalized if needed, but I'm not sure. This wasn't obvious to me
-// but when an input is clicked, it's important to think about both the intent
-// and the actual result. Imagine you have an unchecked checkbox. When clicked,
-// the checkbox immediately becomes checked, and event handlers see this "checked"
-// intent. But a listener can preventDefault() in which case the check we did at
-// the start will be undone.
-// This is a bit more complicated for radio buttons, as the checking/unchecking
-// and the rollback can impact a different radio input. So if you "check" a radio
-// the intent is that it becomes checked and whatever was checked before becomes
-// unchecked, so that if you have to rollback (because of a preventDefault())
-// then both inputs have to revert to their original values.
-const ActivationState = struct {
-    old_checked: bool,
-    input: *Element.Html.Input,
-    previously_checked_radio: ?*Input,
-
-    const Input = Element.Html.Input;
-
-    fn create(event: *const Event, target: *Node, page: *Page) ?ActivationState {
-        if (event._type_string.eql(comptime .wrap("click")) == false) {
-            return null;
-        }
-
-        const input = target.is(Element.Html.Input) orelse return null;
-        if (input._input_type != .checkbox and input._input_type != .radio) {
-            return null;
-        }
-
-        const old_checked = input._checked;
-        var previously_checked_radio: ?*Element.Html.Input = null;
-
-        // For radio buttons, find the currently checked radio in the group
-        if (input._input_type == .radio and !old_checked) {
-            previously_checked_radio = try findCheckedRadioInGroup(input, page);
-        }
-
-        // Toggle checkbox or check radio (which unchecks others in group)
-        const new_checked = if (input._input_type == .checkbox) !old_checked else true;
-        try input.setChecked(new_checked, page);
-
-        return .{
-            .input = input,
-            .old_checked = old_checked,
-            .previously_checked_radio = previously_checked_radio,
-        };
-    }
-
-    fn restore(self: *const ActivationState, event: *const Event, page: *Page) void {
-        const input = self.input;
-        if (event._prevent_default) {
-            // Rollback: restore previous state
-            input._checked = self.old_checked;
-            input._checked_dirty = true;
-            if (self.previously_checked_radio) |prev_radio| {
-                prev_radio._checked = true;
-                prev_radio._checked_dirty = true;
-            }
-            return;
-        }
-
-        // Commit: fire input and change events only if state actually changed
-        // and the element is connected to a document (detached elements don't fire).
-        // For checkboxes, state always changes. For radios, only if was unchecked.
-        const state_changed = (input._input_type == .checkbox) or !self.old_checked;
-        if (state_changed and input.asElement().asNode().isConnected()) {
-            fireEvent(page, input, "input") catch |err| {
-                log.warn(.event, "input event", .{ .err = err });
-            };
-            fireEvent(page, input, "change") catch |err| {
-                log.warn(.event, "change event", .{ .err = err });
-            };
-        }
-    }
-
-    fn findCheckedRadioInGroup(input: *Input, page: *Page) !?*Input {
-        const elem = input.asElement();
-
-        const name = elem.getAttributeSafe(comptime .wrap("name")) orelse return null;
-        if (name.len == 0) {
-            return null;
-        }
-
-        const form = input.getForm(page);
-
-        // Walk from the root of the tree containing this element
-        // This handles both document-attached and orphaned elements
-        const root = elem.asNode().getRootNode(null);
-
-        const TreeWalker = @import("webapi/TreeWalker.zig");
-        var walker = TreeWalker.Full.init(root, .{});
-
-        while (walker.next()) |node| {
-            const other_element = node.is(Element) orelse continue;
-            const other_input = other_element.is(Input) orelse continue;
-
-            if (other_input._input_type != .radio) {
-                continue;
-            }
-
-            // Skip the input we're checking from
-            if (other_input == input) {
-                continue;
-            }
-
-            const other_name = other_element.getAttributeSafe(comptime .wrap("name")) orelse continue;
-            if (!std.mem.eql(u8, name, other_name)) {
-                continue;
-            }
-
-            // Check if same form context
-            const other_form = other_input.getForm(page);
-            if (form) |f| {
-                const of = other_form orelse continue;
-                if (f != of) {
-                    continue; // Different forms
-                }
-            } else if (other_form != null) {
-                continue; // form is null but other has a form
-            }
-
-            if (other_input._checked) {
-                return other_input;
-            }
-        }
-
-        return null;
-    }
-
-    // Fire input or change event
-    fn fireEvent(page: *Page, input: *Input, comptime typ: []const u8) !void {
-        const event = try Event.initTrusted(comptime .wrap(typ), .{
-            .bubbles = true,
-            .cancelable = false,
-        }, page);
-
-        const target = input.asElement().asEventTarget();
-        try page._event_manager.dispatch(target, event);
-    }
-};

src/browser/Factory.zig

@@ -1,462 +0,0 @@
-// Copyright (C) 2023-2026  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program 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 Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-const builtin = @import("builtin");
-const reflect = @import("reflect.zig");
-
-const log = @import("../log.zig");
-const String = @import("../string.zig").String;
-
-const SlabAllocator = @import("../slab.zig").SlabAllocator;
-
-const Page = @import("Page.zig");
-const Node = @import("webapi/Node.zig");
-const Event = @import("webapi/Event.zig");
-const UIEvent = @import("webapi/event/UIEvent.zig");
-const MouseEvent = @import("webapi/event/MouseEvent.zig");
-const Element = @import("webapi/Element.zig");
-const Document = @import("webapi/Document.zig");
-const EventTarget = @import("webapi/EventTarget.zig");
-const XMLHttpRequestEventTarget = @import("webapi/net/XMLHttpRequestEventTarget.zig");
-const Blob = @import("webapi/Blob.zig");
-const AbstractRange = @import("webapi/AbstractRange.zig");
-
-const Allocator = std.mem.Allocator;
-
-const IS_DEBUG = builtin.mode == .Debug;
-const assert = std.debug.assert;
-
-// Shared across all frames of a Page.
-const Factory = @This();
-
-_arena: Allocator,
-_slab: SlabAllocator,
-
-pub fn init(arena: Allocator) Factory {
-    return .{
-        ._arena = arena,
-        ._slab = SlabAllocator.init(arena, 128),
-    };
-}
-
-// this is a root object
-pub fn eventTarget(self: *Factory, child: anytype) !*@TypeOf(child) {
-    return self.eventTargetWithAllocator(self._slab.allocator(), child);
-}
-
-pub fn eventTargetWithAllocator(_: *const Factory, allocator: Allocator, child: anytype) !*@TypeOf(child) {
-    const chain = try PrototypeChain(
-        &.{ EventTarget, @TypeOf(child) },
-    ).allocate(allocator);
-
-    const event_ptr = chain.get(0);
-    event_ptr.* = .{
-        ._type = unionInit(EventTarget.Type, chain.get(1)),
-    };
-    chain.setLeaf(1, child);
-
-    return chain.get(1);
-}
-
-pub fn standaloneEventTarget(self: *Factory, child: anytype) !*EventTarget {
-    const allocator = self._slab.allocator();
-    const et = try allocator.create(EventTarget);
-    et.* = .{ ._type = unionInit(EventTarget.Type, child) };
-    return et;
-}
-
-// this is a root object
-pub fn event(_: *const Factory, arena: Allocator, typ: String, child: anytype) !*@TypeOf(child) {
-    const chain = try PrototypeChain(
-        &.{ Event, @TypeOf(child) },
-    ).allocate(arena);
-
-    // Special case: Event has a _type_string field, so we need manual setup
-    const event_ptr = chain.get(0);
-    event_ptr.* = try eventInit(arena, typ, chain.get(1));
-    chain.setLeaf(1, child);
-
-    return chain.get(1);
-}
-
-pub fn uiEvent(_: *const Factory, arena: Allocator, typ: String, child: anytype) !*@TypeOf(child) {
-    const chain = try PrototypeChain(
-        &.{ Event, UIEvent, @TypeOf(child) },
-    ).allocate(arena);
-
-    // Special case: Event has a _type_string field, so we need manual setup
-    const event_ptr = chain.get(0);
-    event_ptr.* = try eventInit(arena, typ, chain.get(1));
-    chain.setMiddle(1, UIEvent.Type);
-    chain.setLeaf(2, child);
-
-    return chain.get(2);
-}
-
-pub fn mouseEvent(_: *const Factory, arena: Allocator, typ: String, mouse: MouseEvent, child: anytype) !*@TypeOf(child) {
-    const chain = try PrototypeChain(
-        &.{ Event, UIEvent, MouseEvent, @TypeOf(child) },
-    ).allocate(arena);
-
-    // Special case: Event has a _type_string field, so we need manual setup
-    const event_ptr = chain.get(0);
-    event_ptr.* = try eventInit(arena, typ, chain.get(1));
-    chain.setMiddle(1, UIEvent.Type);
-
-    // Set MouseEvent with all its fields
-    const mouse_ptr = chain.get(2);
-    mouse_ptr.* = mouse;
-    mouse_ptr._proto = chain.get(1);
-    mouse_ptr._type = unionInit(MouseEvent.Type, chain.get(3));
-
-    chain.setLeaf(3, child);
-
-    return chain.get(3);
-}
-
-fn PrototypeChain(comptime types: []const type) type {
-    return struct {
-        const Self = @This();
-        memory: []u8,
-
-        fn totalSize() usize {
-            var size: usize = 0;
-            for (types) |T| {
-                size = std.mem.alignForward(usize, size, @alignOf(T));
-                size += @sizeOf(T);
-            }
-            return size;
-        }
-
-        fn maxAlign() std.mem.Alignment {
-            var alignment: std.mem.Alignment = .@"1";
-
-            for (types) |T| {
-                alignment = std.mem.Alignment.max(alignment, std.mem.Alignment.of(T));
-            }
-
-            return alignment;
-        }
-
-        fn getType(comptime index: usize) type {
-            return types[index];
-        }
-
-        fn allocate(allocator: std.mem.Allocator) !Self {
-            const size = comptime Self.totalSize();
-            const alignment = comptime Self.maxAlign();
-
-            const memory = try allocator.alignedAlloc(u8, alignment, size);
-            return .{ .memory = memory };
-        }
-
-        fn get(self: *const Self, comptime index: usize) *getType(index) {
-            var offset: usize = 0;
-            inline for (types, 0..) |T, i| {
-                offset = std.mem.alignForward(usize, offset, @alignOf(T));
-
-                if (i == index) {
-                    return @as(*T, @ptrCast(@alignCast(self.memory.ptr + offset)));
-                }
-                offset += @sizeOf(T);
-            }
-            unreachable;
-        }
-
-        fn set(self: *const Self, comptime index: usize, value: getType(index)) void {
-            const ptr = self.get(index);
-            ptr.* = value;
-        }
-
-        fn setRoot(self: *const Self, comptime T: type) void {
-            const ptr = self.get(0);
-            ptr.* = .{ ._type = unionInit(T, self.get(1)) };
-        }
-
-        fn setMiddle(self: *const Self, comptime index: usize, comptime T: type) void {
-            assert(index >= 1);
-            assert(index < types.len);
-
-            const ptr = self.get(index);
-            ptr.* = .{ ._proto = self.get(index - 1), ._type = unionInit(T, self.get(index + 1)) };
-        }
-
-        fn setMiddleWithValue(self: *const Self, comptime index: usize, comptime T: type, value: anytype) void {
-            assert(index >= 1);
-
-            const ptr = self.get(index);
-            ptr.* = .{ ._proto = self.get(index - 1), ._type = unionInit(T, value) };
-        }
-
-        fn setLeaf(self: *const Self, comptime index: usize, value: anytype) void {
-            assert(index >= 1);
-
-            const ptr = self.get(index);
-            ptr.* = value;
-            ptr._proto = self.get(index - 1);
-        }
-    };
-}
-
-fn AutoPrototypeChain(comptime types: []const type) type {
-    return struct {
-        fn create(allocator: std.mem.Allocator, leaf_value: anytype) !*@TypeOf(leaf_value) {
-            const chain = try PrototypeChain(types).allocate(allocator);
-
-            const RootType = types[0];
-            chain.setRoot(RootType.Type);
-
-            inline for (1..types.len - 1) |i| {
-                const MiddleType = types[i];
-                chain.setMiddle(i, MiddleType.Type);
-            }
-
-            chain.setLeaf(types.len - 1, leaf_value);
-            return chain.get(types.len - 1);
-        }
-    };
-}
-
-fn eventInit(arena: Allocator, typ: String, value: anytype) !Event {
-    // Round to 2ms for privacy (browsers do this)
-    const raw_timestamp = @import("../datetime.zig").milliTimestamp(.monotonic);
-    const time_stamp = (raw_timestamp / 2) * 2;
-
-    return .{
-        ._rc = 0,
-        ._arena = arena,
-        ._type = unionInit(Event.Type, value),
-        ._type_string = typ,
-        ._time_stamp = time_stamp,
-    };
-}
-
-pub fn blob(_: *const Factory, arena: Allocator, child: anytype) !*@TypeOf(child) {
-    // Special case: Blob has slice and mime fields, so we need manual setup
-    const chain = try PrototypeChain(
-        &.{ Blob, @TypeOf(child) },
-    ).allocate(arena);
-
-    const blob_ptr = chain.get(0);
-    blob_ptr.* = .{
-        ._arena = arena,
-        ._type = unionInit(Blob.Type, chain.get(1)),
-        ._slice = "",
-        ._mime = "",
-    };
-    chain.setLeaf(1, child);
-
-    return chain.get(1);
-}
-
-pub fn abstractRange(_: *const Factory, arena: Allocator, child: anytype, page: *Page) !*@TypeOf(child) {
-    const chain = try PrototypeChain(&.{ AbstractRange, @TypeOf(child) }).allocate(arena);
-
-    const doc = page.document.asNode();
-    const abstract_range = chain.get(0);
-    abstract_range.* = AbstractRange{
-        ._rc = 0,
-        ._arena = arena,
-        ._page_id = page.id,
-        ._type = unionInit(AbstractRange.Type, chain.get(1)),
-        ._end_offset = 0,
-        ._start_offset = 0,
-        ._end_container = doc,
-        ._start_container = doc,
-    };
-    chain.setLeaf(1, child);
-    page._live_ranges.append(&abstract_range._range_link);
-    return chain.get(1);
-}
-
-pub fn node(self: *Factory, child: anytype) !*@TypeOf(child) {
-    const allocator = self._slab.allocator();
-    return try AutoPrototypeChain(
-        &.{ EventTarget, Node, @TypeOf(child) },
-    ).create(allocator, child);
-}
-
-pub fn document(self: *Factory, child: anytype) !*@TypeOf(child) {
-    const allocator = self._slab.allocator();
-    return try AutoPrototypeChain(
-        &.{ EventTarget, Node, Document, @TypeOf(child) },
-    ).create(allocator, child);
-}
-
-pub fn documentFragment(self: *Factory, child: anytype) !*@TypeOf(child) {
-    const allocator = self._slab.allocator();
-    return try AutoPrototypeChain(
-        &.{ EventTarget, Node, Node.DocumentFragment, @TypeOf(child) },
-    ).create(allocator, child);
-}
-
-pub fn element(self: *Factory, child: anytype) !*@TypeOf(child) {
-    const allocator = self._slab.allocator();
-    return try AutoPrototypeChain(
-        &.{ EventTarget, Node, Element, @TypeOf(child) },
-    ).create(allocator, child);
-}
-
-pub fn htmlElement(self: *Factory, child: anytype) !*@TypeOf(child) {
-    const allocator = self._slab.allocator();
-    return try AutoPrototypeChain(
-        &.{ EventTarget, Node, Element, Element.Html, @TypeOf(child) },
-    ).create(allocator, child);
-}
-
-pub fn htmlMediaElement(self: *Factory, child: anytype) !*@TypeOf(child) {
-    const allocator = self._slab.allocator();
-    return try AutoPrototypeChain(
-        &.{ EventTarget, Node, Element, Element.Html, Element.Html.Media, @TypeOf(child) },
-    ).create(allocator, child);
-}
-
-pub fn svgElement(self: *Factory, tag_name: []const u8, child: anytype) !*@TypeOf(child) {
-    const allocator = self._slab.allocator();
-    const ChildT = @TypeOf(child);
-
-    if (ChildT == Element.Svg) {
-        return self.element(child);
-    }
-
-    const chain = try PrototypeChain(
-        &.{ EventTarget, Node, Element, Element.Svg, ChildT },
-    ).allocate(allocator);
-
-    chain.setRoot(EventTarget.Type);
-    chain.setMiddle(1, Node.Type);
-    chain.setMiddle(2, Element.Type);
-
-    // will never allocate, can't fail
-    const tag_name_str = String.init(self._arena, tag_name, .{}) catch unreachable;
-
-    // Manually set Element.Svg with the tag_name
-    chain.set(3, .{
-        ._proto = chain.get(2),
-        ._tag_name = tag_name_str,
-        ._type = unionInit(Element.Svg.Type, chain.get(4)),
-    });
-
-    chain.setLeaf(4, child);
-    return chain.get(4);
-}
-
-pub fn xhrEventTarget(_: *const Factory, allocator: Allocator, child: anytype) !*@TypeOf(child) {
-    return try AutoPrototypeChain(
-        &.{ EventTarget, XMLHttpRequestEventTarget, @TypeOf(child) },
-    ).create(allocator, child);
-}
-
-pub fn textTrackCue(self: *Factory, child: anytype) !*@TypeOf(child) {
-    const allocator = self._slab.allocator();
-    const TextTrackCue = @import("webapi/media/TextTrackCue.zig");
-
-    return try AutoPrototypeChain(
-        &.{ EventTarget, TextTrackCue, @TypeOf(child) },
-    ).create(allocator, child);
-}
-
-pub fn destroy(self: *Factory, value: anytype) void {
-    const S = reflect.Struct(@TypeOf(value));
-
-    if (comptime IS_DEBUG) {
-        // We should always destroy from the leaf down.
-        if (@hasDecl(S, "_prototype_root")) {
-            // A Event{._type == .generic} (or any other similar types)
-            // _should_ be destoyed directly. The _type = .generic is a pseudo
-            // child
-            if (S != Event or value._type != .generic) {
-                log.fatal(.bug, "factory.destroy.event", .{ .type = @typeName(S) });
-                unreachable;
-            }
-        }
-    }
-
-    if (comptime @hasField(S, "_proto")) {
-        self.destroyChain(value, 0, std.mem.Alignment.@"1");
-    } else {
-        self.destroyStandalone(value);
-    }
-}
-
-pub fn destroyStandalone(self: *Factory, value: anytype) void {
-    const allocator = self._slab.allocator();
-    allocator.destroy(value);
-}
-
-fn destroyChain(
-    self: *Factory,
-    value: anytype,
-    old_size: usize,
-    old_align: std.mem.Alignment,
-) void {
-    const S = reflect.Struct(@TypeOf(value));
-    const allocator = self._slab.allocator();
-
-    // aligns the old size to the alignment of this element
-    const current_size = std.mem.alignForward(usize, old_size, @alignOf(S));
-    const new_size = current_size + @sizeOf(S);
-    const new_align = std.mem.Alignment.max(old_align, std.mem.Alignment.of(S));
-
-    if (@hasField(S, "_proto")) {
-        self.destroyChain(value._proto, new_size, new_align);
-    } else {
-        // no proto so this is the head of the chain.
-        // we use this as the ptr to the start of the chain.
-        // and we have summed up the length.
-        assert(@hasDecl(S, "_prototype_root"));
-
-        const memory_ptr: [*]u8 = @ptrCast(@constCast(value));
-        const len = std.mem.alignForward(usize, new_size, new_align.toByteUnits());
-        allocator.rawFree(memory_ptr[0..len], new_align, @returnAddress());
-    }
-}
-
-pub fn createT(self: *Factory, comptime T: type) !*T {
-    const allocator = self._slab.allocator();
-    return try allocator.create(T);
-}
-
-pub fn create(self: *Factory, value: anytype) !*@TypeOf(value) {
-    const ptr = try self.createT(@TypeOf(value));
-    ptr.* = value;
-    return ptr;
-}
-
-fn unionInit(comptime T: type, value: anytype) T {
-    const V = @TypeOf(value);
-    const field_name = comptime unionFieldName(T, V);
-    return @unionInit(T, field_name, value);
-}
-
-// There can be friction between comptime and runtime. Comptime has to
-// account for all possible types, even if some runtime flow makes certain
-// cases impossible. At runtime, we always call `unionFieldName` with the
-// correct struct or pointer type. But at comptime time, `unionFieldName`
-// is called with both variants (S and *S). So we use reflect.Struct().
-// This only works because we never have a union with a field S and another
-// field *S.
-fn unionFieldName(comptime T: type, comptime V: type) []const u8 {
-    inline for (@typeInfo(T).@"union".fields) |field| {
-        if (reflect.Struct(field.type) == reflect.Struct(V)) {
-            return field.name;
-        }
-    }
-    @compileError(@typeName(V) ++ " is not a valid type for " ++ @typeName(T) ++ ".type");
-}

src/browser/Mime.zig

@@ -1,795 +0,0 @@
-// Copyright (C) 2023-2025  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program 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 Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-
-const Mime = @This();
-content_type: ContentType,
-params: []const u8 = "",
-// IANA defines max. charset value length as 40.
-// We keep 41 for null-termination since HTML parser expects in this format.
-charset: [41]u8 = default_charset,
-charset_len: usize = default_charset_len,
-is_default_charset: bool = true,
-
-type_buf: [127]u8 = @splat(0),
-sub_type_buf: [127]u8 = @splat(0),
-
-/// String "UTF-8" continued by null characters.
-const default_charset = .{ 'U', 'T', 'F', '-', '8' } ++ .{0} ** 36;
-const default_charset_len = 5;
-
-/// Mime with unknown Content-Type, empty params and empty charset.
-pub const unknown = Mime{ .content_type = .{ .unknown = {} } };
-
-pub const ContentTypeEnum = enum {
-    text_xml,
-    text_html,
-    text_javascript,
-    text_plain,
-    text_css,
-    image_jpeg,
-    image_gif,
-    image_png,
-    image_webp,
-    application_json,
-    unknown,
-    other,
-};
-
-pub const ContentType = union(ContentTypeEnum) {
-    text_xml: void,
-    text_html: void,
-    text_javascript: void,
-    text_plain: void,
-    text_css: void,
-    image_jpeg: void,
-    image_gif: void,
-    image_png: void,
-    image_webp: void,
-    application_json: void,
-    unknown: void,
-    other: struct {
-        type: []const u8,
-        sub_type: []const u8,
-    },
-};
-
-pub fn contentTypeString(mime: *const Mime) []const u8 {
-    return switch (mime.content_type) {
-        .text_xml => "text/xml",
-        .text_html => "text/html",
-        .text_javascript => "application/javascript",
-        .text_plain => "text/plain",
-        .text_css => "text/css",
-        .image_jpeg => "image/jpeg",
-        .image_png => "image/png",
-        .image_gif => "image/gif",
-        .image_webp => "image/webp",
-        .application_json => "application/json",
-        else => "",
-    };
-}
-
-/// Returns the null-terminated charset value.
-pub fn charsetStringZ(mime: *const Mime) [:0]const u8 {
-    return mime.charset[0..mime.charset_len :0];
-}
-
-pub fn charsetString(mime: *const Mime) []const u8 {
-    return mime.charset[0..mime.charset_len];
-}
-
-/// Removes quotes of value if quotes are given.
-///
-/// Currently we don't validate the charset.
-/// See section 2.3 Naming Requirements:
-/// https://datatracker.ietf.org/doc/rfc2978/
-fn parseCharset(value: []const u8) error{ CharsetTooBig, Invalid }![]const u8 {
-    // Cannot be larger than 40.
-    // https://datatracker.ietf.org/doc/rfc2978/
-    if (value.len > 40) return error.CharsetTooBig;
-
-    // If the first char is a quote, look for a pair.
-    if (value[0] == '"') {
-        if (value.len < 3 or value[value.len - 1] != '"') {
-            return error.Invalid;
-        }
-
-        return value[1 .. value.len - 1];
-    }
-
-    // No quotes.
-    return value;
-}
-
-pub fn parse(input: []const u8) !Mime {
-    if (input.len > 255) {
-        return error.TooBig;
-    }
-
-    var buf: [255]u8 = undefined;
-    const normalized = std.ascii.lowerString(&buf, std.mem.trim(u8, input, &std.ascii.whitespace));
-    _ = std.ascii.lowerString(normalized, normalized);
-
-    var mime = Mime{ .content_type = undefined };
-
-    const content_type, const type_len = try parseContentType(normalized, &mime.type_buf, &mime.sub_type_buf);
-    if (type_len >= normalized.len) {
-        return .{ .content_type = content_type };
-    }
-
-    const params = trimLeft(normalized[type_len..]);
-
-    var charset: [41]u8 = default_charset;
-    var charset_len: usize = default_charset_len;
-    var has_explicit_charset = false;
-
-    var it = std.mem.splitScalar(u8, params, ';');
-    while (it.next()) |attr| {
-        const i = std.mem.indexOfScalarPos(u8, attr, 0, '=') orelse continue;
-        const name = trimLeft(attr[0..i]);
-
-        const value = trimRight(attr[i + 1 ..]);
-        if (value.len == 0) {
-            continue;
-        }
-
-        const attribute_name = std.meta.stringToEnum(enum {
-            charset,
-        }, name) orelse continue;
-
-        switch (attribute_name) {
-            .charset => {
-                if (value.len == 0) {
-                    break;
-                }
-
-                const attribute_value = parseCharset(value) catch continue;
-                @memcpy(charset[0..attribute_value.len], attribute_value);
-                // Null-terminate right after attribute value.
-                charset[attribute_value.len] = 0;
-                charset_len = attribute_value.len;
-                has_explicit_charset = true;
-            },
-        }
-    }
-
-    mime.params = params;
-    mime.charset = charset;
-    mime.charset_len = charset_len;
-    mime.content_type = content_type;
-    mime.is_default_charset = !has_explicit_charset;
-    return mime;
-}
-
-/// Prescan the first 1024 bytes of an HTML document for a charset declaration.
-/// Looks for `<meta charset="X">` and `<meta http-equiv="Content-Type" content="...;charset=X">`.
-/// Returns the charset value or null if none found.
-/// See: https://www.w3.org/International/questions/qa-html-encoding-declarations
-pub fn prescanCharset(html: []const u8) ?[]const u8 {
-    const limit = @min(html.len, 1024);
-    const data = html[0..limit];
-
-    // Scan for <meta tags
-    var pos: usize = 0;
-    while (pos < data.len) {
-        // Find next '<'
-        pos = std.mem.indexOfScalarPos(u8, data, pos, '<') orelse return null;
-        pos += 1;
-        if (pos >= data.len) return null;
-
-        // Check for "meta" (case-insensitive)
-        if (pos + 4 >= data.len) return null;
-        var tag_buf: [4]u8 = undefined;
-        _ = std.ascii.lowerString(&tag_buf, data[pos..][0..4]);
-        if (!std.mem.eql(u8, &tag_buf, "meta")) {
-            continue;
-        }
-        pos += 4;
-
-        // Must be followed by whitespace or end of tag
-        if (pos >= data.len) return null;
-        if (data[pos] != ' ' and data[pos] != '\t' and data[pos] != '\n' and
-            data[pos] != '\r' and data[pos] != '/')
-        {
-            continue;
-        }
-
-        // Scan attributes within this meta tag
-        const tag_end = std.mem.indexOfScalarPos(u8, data, pos, '>') orelse return null;
-        const attrs = data[pos..tag_end];
-
-        // Look for charset= attribute directly
-        if (findAttrValue(attrs, "charset")) |charset| {
-            if (charset.len > 0 and charset.len <= 40) return charset;
-        }
-
-        // Look for http-equiv="content-type" with content="...;charset=X"
-        if (findAttrValue(attrs, "http-equiv")) |he| {
-            if (std.ascii.eqlIgnoreCase(he, "content-type")) {
-                if (findAttrValue(attrs, "content")) |content| {
-                    if (extractCharsetFromContentType(content)) |charset| {
-                        return charset;
-                    }
-                }
-            }
-        }
-
-        pos = tag_end + 1;
-    }
-    return null;
-}
-
-fn findAttrValue(attrs: []const u8, name: []const u8) ?[]const u8 {
-    var pos: usize = 0;
-    while (pos < attrs.len) {
-        // Skip whitespace
-        while (pos < attrs.len and (attrs[pos] == ' ' or attrs[pos] == '\t' or
-            attrs[pos] == '\n' or attrs[pos] == '\r'))
-        {
-            pos += 1;
-        }
-        if (pos >= attrs.len) return null;
-
-        // Read attribute name
-        const attr_start = pos;
-        while (pos < attrs.len and attrs[pos] != '=' and attrs[pos] != ' ' and
-            attrs[pos] != '\t' and attrs[pos] != '>' and attrs[pos] != '/')
-        {
-            pos += 1;
-        }
-        const attr_name = attrs[attr_start..pos];
-
-        // Skip whitespace around =
-        while (pos < attrs.len and (attrs[pos] == ' ' or attrs[pos] == '\t')) pos += 1;
-        if (pos >= attrs.len or attrs[pos] != '=') {
-            // No '=' found - skip this token. Advance at least one byte to avoid infinite loop.
-            if (pos == attr_start) pos += 1;
-            continue;
-        }
-        pos += 1; // skip '='
-        while (pos < attrs.len and (attrs[pos] == ' ' or attrs[pos] == '\t')) pos += 1;
-        if (pos >= attrs.len) return null;
-
-        // Read attribute value
-        const value = blk: {
-            if (attrs[pos] == '"' or attrs[pos] == '\'') {
-                const quote = attrs[pos];
-                pos += 1;
-                const val_start = pos;
-                while (pos < attrs.len and attrs[pos] != quote) pos += 1;
-                const val = attrs[val_start..pos];
-                if (pos < attrs.len) pos += 1; // skip closing quote
-                break :blk val;
-            } else {
-                const val_start = pos;
-                while (pos < attrs.len and attrs[pos] != ' ' and attrs[pos] != '\t' and
-                    attrs[pos] != '>' and attrs[pos] != '/')
-                {
-                    pos += 1;
-                }
-                break :blk attrs[val_start..pos];
-            }
-        };
-
-        if (std.ascii.eqlIgnoreCase(attr_name, name)) return value;
-    }
-    return null;
-}
-
-fn extractCharsetFromContentType(content: []const u8) ?[]const u8 {
-    var it = std.mem.splitScalar(u8, content, ';');
-    while (it.next()) |part| {
-        const trimmed = std.mem.trimLeft(u8, part, &.{ ' ', '\t' });
-        if (trimmed.len > 8 and std.ascii.eqlIgnoreCase(trimmed[0..8], "charset=")) {
-            const val = std.mem.trim(u8, trimmed[8..], &.{ ' ', '\t', '"', '\'' });
-            if (val.len > 0 and val.len <= 40) return val;
-        }
-    }
-    return null;
-}
-
-pub fn sniff(body: []const u8) ?Mime {
-    // 0x0C is form feed
-    const content = std.mem.trimLeft(u8, body, &.{ ' ', '\t', '\n', '\r', 0x0C });
-    if (content.len == 0) {
-        return null;
-    }
-
-    if (content[0] != '<') {
-        if (std.mem.startsWith(u8, content, &.{ 0xEF, 0xBB, 0xBF })) {
-            // UTF-8 BOM
-            return .{
-                .content_type = .{ .text_plain = {} },
-                .charset = default_charset,
-                .charset_len = default_charset_len,
-                .is_default_charset = false,
-            };
-        }
-        if (std.mem.startsWith(u8, content, &.{ 0xFE, 0xFF })) {
-            // UTF-16 big-endian BOM
-            return .{
-                .content_type = .{ .text_plain = {} },
-                .charset = .{ 'U', 'T', 'F', '-', '1', '6', 'B', 'E' } ++ .{0} ** 33,
-                .charset_len = 8,
-                .is_default_charset = false,
-            };
-        }
-        if (std.mem.startsWith(u8, content, &.{ 0xFF, 0xFE })) {
-            // UTF-16 little-endian BOM
-            return .{
-                .content_type = .{ .text_plain = {} },
-                .charset = .{ 'U', 'T', 'F', '-', '1', '6', 'L', 'E' } ++ .{0} ** 33,
-                .charset_len = 8,
-                .is_default_charset = false,
-            };
-        }
-        return null;
-    }
-
-    // The longest prefix we have is "<!DOCTYPE HTML ", 15 bytes. If we're
-    // here, we already know content[0] == '<', so we can skip that. So 14
-    // bytes.
-
-    // +1 because we don't need the leading '<'
-    var buf: [14]u8 = undefined;
-
-    const stripped = content[1..];
-    const prefix_len = @min(stripped.len, buf.len);
-    const prefix = std.ascii.lowerString(&buf, stripped[0..prefix_len]);
-
-    // we already know it starts with a <
-    const known_prefixes = [_]struct { []const u8, ContentType }{
-        .{ "!doctype html", .{ .text_html = {} } },
-        .{ "html", .{ .text_html = {} } },
-        .{ "script", .{ .text_html = {} } },
-        .{ "iframe", .{ .text_html = {} } },
-        .{ "h1", .{ .text_html = {} } },
-        .{ "div", .{ .text_html = {} } },
-        .{ "font", .{ .text_html = {} } },
-        .{ "table", .{ .text_html = {} } },
-        .{ "a", .{ .text_html = {} } },
-        .{ "style", .{ .text_html = {} } },
-        .{ "title", .{ .text_html = {} } },
-        .{ "b", .{ .text_html = {} } },
-        .{ "body", .{ .text_html = {} } },
-        .{ "br", .{ .text_html = {} } },
-        .{ "p", .{ .text_html = {} } },
-        .{ "!--", .{ .text_html = {} } },
-        .{ "xml", .{ .text_xml = {} } },
-    };
-    inline for (known_prefixes) |kp| {
-        const known_prefix = kp.@"0";
-        if (std.mem.startsWith(u8, prefix, known_prefix) and prefix.len > known_prefix.len) {
-            const next = prefix[known_prefix.len];
-            // a "tag-terminating-byte"
-            if (next == ' ' or next == '>') {
-                return .{ .content_type = kp.@"1" };
-            }
-        }
-    }
-
-    return null;
-}
-
-pub fn isHTML(self: *const Mime) bool {
-    return self.content_type == .text_html;
-}
-
-// we expect value to be lowercase
-fn parseContentType(value: []const u8, type_buf: []u8, sub_type_buf: []u8) !struct { ContentType, usize } {
-    const end = std.mem.indexOfScalarPos(u8, value, 0, ';') orelse value.len;
-    const type_name = trimRight(value[0..end]);
-    const attribute_start = end + 1;
-
-    if (std.meta.stringToEnum(enum {
-        @"text/xml",
-        @"text/html",
-        @"text/css",
-        @"text/plain",
-
-        @"text/javascript",
-        @"application/javascript",
-        @"application/x-javascript",
-
-        @"image/jpeg",
-        @"image/png",
-        @"image/gif",
-        @"image/webp",
-
-        @"application/json",
-    }, type_name)) |known_type| {
-        const ct: ContentType = switch (known_type) {
-            .@"text/xml" => .{ .text_xml = {} },
-            .@"text/html" => .{ .text_html = {} },
-            .@"text/javascript", .@"application/javascript", .@"application/x-javascript" => .{ .text_javascript = {} },
-            .@"text/plain" => .{ .text_plain = {} },
-            .@"text/css" => .{ .text_css = {} },
-            .@"image/jpeg" => .{ .image_jpeg = {} },
-            .@"image/png" => .{ .image_png = {} },
-            .@"image/gif" => .{ .image_gif = {} },
-            .@"image/webp" => .{ .image_webp = {} },
-            .@"application/json" => .{ .application_json = {} },
-        };
-        return .{ ct, attribute_start };
-    }
-
-    const separator = std.mem.indexOfScalarPos(u8, type_name, 0, '/') orelse return error.Invalid;
-
-    const main_type = value[0..separator];
-    const sub_type = trimRight(value[separator + 1 .. end]);
-
-    if (main_type.len == 0 or validType(main_type) == false) {
-        return error.Invalid;
-    }
-    if (sub_type.len == 0 or validType(sub_type) == false) {
-        return error.Invalid;
-    }
-
-    @memcpy(type_buf[0..main_type.len], main_type);
-    @memcpy(sub_type_buf[0..sub_type.len], sub_type);
-
-    return .{
-        .{
-            .other = .{
-                .type = type_buf[0..main_type.len],
-                .sub_type = sub_type_buf[0..sub_type.len],
-            },
-        },
-        attribute_start,
-    };
-}
-
-const VALID_CODEPOINTS = blk: {
-    var v: [256]bool = undefined;
-    for (0..256) |i| {
-        v[i] = std.ascii.isAlphanumeric(i);
-    }
-    for ("!#$%&\\*+-.^'_`|~") |b| {
-        v[b] = true;
-    }
-    break :blk v;
-};
-
-pub fn typeString(self: *const Mime) []const u8 {
-    return switch (self.content_type) {
-        .other => |o| o.type[0..o.type_len],
-        else => "",
-    };
-}
-
-fn validType(value: []const u8) bool {
-    for (value) |b| {
-        if (VALID_CODEPOINTS[b] == false) {
-            return false;
-        }
-    }
-    return true;
-}
-
-fn trimLeft(s: []const u8) []const u8 {
-    return std.mem.trimLeft(u8, s, &std.ascii.whitespace);
-}
-
-fn trimRight(s: []const u8) []const u8 {
-    return std.mem.trimRight(u8, s, &std.ascii.whitespace);
-}
-
-const testing = @import("../testing.zig");
-test "Mime: invalid" {
-    defer testing.reset();
-
-    const invalids = [_][]const u8{
-        "",
-        "text",
-        "text /html",
-        "text/ html",
-        "text / html",
-        "text/html other",
-    };
-
-    for (invalids) |invalid| {
-        const mutable_input = try testing.arena_allocator.dupe(u8, invalid);
-        try testing.expectError(error.Invalid, Mime.parse(mutable_input));
-    }
-}
-
-test "Mime: malformed parameters are ignored" {
-    defer testing.reset();
-
-    // These should all parse successfully as text/html with malformed params ignored
-    const valid_with_malformed_params = [_][]const u8{
-        "text/html; x",
-        "text/html; x=",
-        "text/html; x=  ",
-        "text/html; = ",
-        "text/html;=",
-        "text/html; charset=\"\"",
-        "text/html; charset=\"",
-        "text/html; charset=\"\\",
-        "text/html;\"",
-    };
-
-    for (valid_with_malformed_params) |input| {
-        const mutable_input = try testing.arena_allocator.dupe(u8, input);
-        const mime = try Mime.parse(mutable_input);
-        try testing.expectEqual(.text_html, std.meta.activeTag(mime.content_type));
-    }
-}
-
-test "Mime: parse common" {
-    defer testing.reset();
-
-    try expect(.{ .content_type = .{ .text_xml = {} } }, "text/xml");
-    try expect(.{ .content_type = .{ .text_html = {} } }, "text/html");
-    try expect(.{ .content_type = .{ .text_plain = {} } }, "text/plain");
-
-    try expect(.{ .content_type = .{ .text_xml = {} } }, "text/xml;");
-    try expect(.{ .content_type = .{ .text_html = {} } }, "text/html;");
-    try expect(.{ .content_type = .{ .text_plain = {} } }, "text/plain;");
-
-    try expect(.{ .content_type = .{ .text_xml = {} } }, "  \ttext/xml");
-    try expect(.{ .content_type = .{ .text_html = {} } }, "text/html   ");
-    try expect(.{ .content_type = .{ .text_plain = {} } }, "text/plain \t\t");
-
-    try expect(.{ .content_type = .{ .text_xml = {} } }, "TEXT/xml");
-    try expect(.{ .content_type = .{ .text_html = {} } }, "text/Html");
-    try expect(.{ .content_type = .{ .text_plain = {} } }, "TEXT/PLAIN");
-
-    try expect(.{ .content_type = .{ .text_xml = {} } }, " TeXT/xml");
-    try expect(.{ .content_type = .{ .text_html = {} } }, "teXt/HtML  ;");
-    try expect(.{ .content_type = .{ .text_plain = {} } }, "tExT/PlAiN;");
-
-    try expect(.{ .content_type = .{ .text_javascript = {} } }, "text/javascript");
-    try expect(.{ .content_type = .{ .text_javascript = {} } }, "Application/JavaScript");
-    try expect(.{ .content_type = .{ .text_javascript = {} } }, "application/x-javascript");
-
-    try expect(.{ .content_type = .{ .application_json = {} } }, "application/json");
-    try expect(.{ .content_type = .{ .text_css = {} } }, "text/css");
-
-    try expect(.{ .content_type = .{ .image_jpeg = {} } }, "image/jpeg");
-    try expect(.{ .content_type = .{ .image_png = {} } }, "image/png");
-    try expect(.{ .content_type = .{ .image_gif = {} } }, "image/gif");
-    try expect(.{ .content_type = .{ .image_webp = {} } }, "image/webp");
-}
-
-test "Mime: parse uncommon" {
-    defer testing.reset();
-
-    const text_csv = Expectation{
-        .content_type = .{ .other = .{ .type = "text", .sub_type = "csv" } },
-    };
-    try expect(text_csv, "text/csv");
-    try expect(text_csv, "text/csv;");
-    try expect(text_csv, "  text/csv\t  ");
-    try expect(text_csv, "  text/csv\t  ;");
-
-    try expect(
-        .{ .content_type = .{ .other = .{ .type = "text", .sub_type = "csv" } } },
-        "Text/CSV",
-    );
-}
-
-test "Mime: parse charset" {
-    defer testing.reset();
-
-    try expect(.{
-        .content_type = .{ .text_xml = {} },
-        .charset = "utf-8",
-        .params = "charset=utf-8",
-    }, "text/xml; charset=utf-8");
-
-    try expect(.{
-        .content_type = .{ .text_xml = {} },
-        .charset = "utf-8",
-        .params = "charset=\"utf-8\"",
-    }, "text/xml;charset=\"UTF-8\"");
-
-    try expect(.{
-        .content_type = .{ .text_html = {} },
-        .charset = "iso-8859-1",
-        .params = "charset=\"iso-8859-1\"",
-    }, "text/html; charset=\"iso-8859-1\"");
-
-    try expect(.{
-        .content_type = .{ .text_html = {} },
-        .charset = "iso-8859-1",
-        .params = "charset=\"iso-8859-1\"",
-    }, "text/html; charset=\"ISO-8859-1\"");
-
-    try expect(.{
-        .content_type = .{ .text_xml = {} },
-        .charset = "custom-non-standard-charset-value",
-        .params = "charset=\"custom-non-standard-charset-value\"",
-    }, "text/xml;charset=\"custom-non-standard-charset-value\"");
-
-    try expect(.{
-        .content_type = .{ .text_html = {} },
-        .charset = "UTF-8",
-        .params = "x=\"",
-    }, "text/html;x=\"");
-}
-
-test "Mime: isHTML" {
-    defer testing.reset();
-
-    const assert = struct {
-        fn assert(expected: bool, input: []const u8) !void {
-            const mutable_input = try testing.arena_allocator.dupe(u8, input);
-            var mime = try Mime.parse(mutable_input);
-            try testing.expectEqual(expected, mime.isHTML());
-        }
-    }.assert;
-    try assert(true, "text/html");
-    try assert(true, "text/html;");
-    try assert(true, "text/html; charset=utf-8");
-    try assert(false, "text/htm"); // htm not html
-    try assert(false, "text/plain");
-    try assert(false, "over/9000");
-}
-
-test "Mime: sniff" {
-    try testing.expectEqual(null, Mime.sniff(""));
-    try testing.expectEqual(null, Mime.sniff("<htm"));
-    try testing.expectEqual(null, Mime.sniff("<html!"));
-    try testing.expectEqual(null, Mime.sniff("<a_"));
-    try testing.expectEqual(null, Mime.sniff("<!doctype html"));
-    try testing.expectEqual(null, Mime.sniff("<!doctype  html>"));
-    try testing.expectEqual(null, Mime.sniff("\n  <!doctype  html>"));
-    try testing.expectEqual(null, Mime.sniff("\n \t <font/>"));
-
-    const expectHTML = struct {
-        fn expect(input: []const u8) !void {
-            try testing.expectEqual(.text_html, std.meta.activeTag(Mime.sniff(input).?.content_type));
-        }
-    }.expect;
-
-    try expectHTML("<!doctype html ");
-    try expectHTML("\n  \t    <!DOCTYPE HTML ");
-
-    try expectHTML("<html ");
-    try expectHTML("\n  \t    <HtmL> even more stufff");
-
-    try expectHTML("<script>");
-    try expectHTML("\n  \t    <SCRIpt >alert(document.cookies)</script>");
-
-    try expectHTML("<iframe>");
-    try expectHTML(" \t    <ifRAME >");
-
-    try expectHTML("<h1>");
-    try expectHTML("  <H1>");
-
-    try expectHTML("<div>");
-    try expectHTML("\n\r\r  <DiV>");
-
-    try expectHTML("<font>");
-    try expectHTML("  <fonT>");
-
-    try expectHTML("<table>");
-    try expectHTML("\t\t<TAblE>");
-
-    try expectHTML("<a>");
-    try expectHTML("\n\n<A>");
-
-    try expectHTML("<style>");
-    try expectHTML("    \n\t <STyLE>");
-
-    try expectHTML("<title>");
-    try expectHTML("    \n\t <TITLE>");
-
-    try expectHTML("<b>");
-    try expectHTML("    \n\t <B>");
-
-    try expectHTML("<body>");
-    try expectHTML("    \n\t <BODY>");
-
-    try expectHTML("<br>");
-    try expectHTML("    \n\t <BR>");
-
-    try expectHTML("<p>");
-    try expectHTML("    \n\t <P>");
-
-    try expectHTML("<!-->");
-    try expectHTML("    \n\t <!-->");
-
-    {
-        const mime = Mime.sniff(&.{ 0xEF, 0xBB, 0xBF }).?;
-        try testing.expectEqual(.text_plain, std.meta.activeTag(mime.content_type));
-        try testing.expectEqual("UTF-8", mime.charsetString());
-    }
-
-    {
-        const mime = Mime.sniff(&.{ 0xFE, 0xFF }).?;
-        try testing.expectEqual(.text_plain, std.meta.activeTag(mime.content_type));
-        try testing.expectEqual("UTF-16BE", mime.charsetString());
-    }
-
-    {
-        const mime = Mime.sniff(&.{ 0xFF, 0xFE }).?;
-        try testing.expectEqual(.text_plain, std.meta.activeTag(mime.content_type));
-        try testing.expectEqual("UTF-16LE", mime.charsetString());
-    }
-}
-
-const Expectation = struct {
-    content_type: Mime.ContentType,
-    params: []const u8 = "",
-    charset: ?[]const u8 = null,
-};
-
-fn expect(expected: Expectation, input: []const u8) !void {
-    const mutable_input = try testing.arena_allocator.dupe(u8, input);
-
-    const actual = try Mime.parse(mutable_input);
-    try testing.expectEqual(
-        std.meta.activeTag(expected.content_type),
-        std.meta.activeTag(actual.content_type),
-    );
-
-    switch (expected.content_type) {
-        .other => |e| {
-            const a = actual.content_type.other;
-            try testing.expectEqual(e.type, a.type);
-            try testing.expectEqual(e.sub_type, a.sub_type);
-        },
-        else => {}, // already asserted above
-    }
-
-    try testing.expectEqual(expected.params, actual.params);
-
-    if (expected.charset) |ec| {
-        // We remove the null characters for testing purposes here.
-        try testing.expectEqual(ec, actual.charsetString());
-    } else {
-        const m: Mime = .unknown;
-        try testing.expectEqual(m.charsetStringZ(), actual.charsetStringZ());
-    }
-}
-
-test "Mime: prescanCharset" {
-    // <meta charset="X">
-    try testing.expectEqual("utf-8", Mime.prescanCharset("<html><head><meta charset=\"utf-8\">").?);
-    try testing.expectEqual("iso-8859-1", Mime.prescanCharset("<html><head><meta charset=\"iso-8859-1\">").?);
-    try testing.expectEqual("shift_jis", Mime.prescanCharset("<meta charset='shift_jis'>").?);
-
-    // Case-insensitive tag matching
-    try testing.expectEqual("utf-8", Mime.prescanCharset("<META charset=\"utf-8\">").?);
-    try testing.expectEqual("utf-8", Mime.prescanCharset("<Meta charset=\"utf-8\">").?);
-
-    // <meta http-equiv="Content-Type" content="text/html; charset=X">
-    try testing.expectEqual(
-        "iso-8859-1",
-        Mime.prescanCharset("<meta http-equiv=\"Content-Type\" content=\"text/html; charset=iso-8859-1\">").?,
-    );
-
-    // No charset found
-    try testing.expectEqual(null, Mime.prescanCharset("<html><head><title>Test</title>"));
-    try testing.expectEqual(null, Mime.prescanCharset(""));
-    try testing.expectEqual(null, Mime.prescanCharset("no html here"));
-
-    // Self-closing meta without charset must not loop forever
-    try testing.expectEqual(null, Mime.prescanCharset("<meta foo=\"bar\"/>"));
-
-    // Charset after 1024 bytes should not be found
-    var long_html: [1100]u8 = undefined;
-    @memset(&long_html, ' ');
-    const suffix = "<meta charset=\"windows-1252\">";
-    @memcpy(long_html[1050 .. 1050 + suffix.len], suffix);
-    try testing.expectEqual(null, Mime.prescanCharset(&long_html));
-}

src/browser/Scheduler.zig

@@ -0,0 +1,163 @@
+// Copyright (C) 2023-2025  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+
+const Scheduler = @This();
+
+high_priority: Queue,
+
+// For repeating tasks. We only want to run these if there are other things to
+// do. We don't, for example, want a window.setInterval or the page.runMicrotasks
+// to block the page.wait.
+low_priority: Queue,
+
+// we expect allocator to be the page arena, hence we never call high_priority.deinit
+pub fn init(allocator: Allocator) Scheduler {
+    return .{
+        .high_priority = Queue.init(allocator, {}),
+        .low_priority = Queue.init(allocator, {}),
+    };
+}
+
+pub fn reset(self: *Scheduler) void {
+    // Our allocator is the page arena, it's been reset. We cannot use
+    // clearAndRetainCapacity, since that space is no longer ours
+    self.high_priority.clearAndFree();
+    self.low_priority.clearAndFree();
+}
+
+const AddOpts = struct {
+    name: []const u8 = "",
+    low_priority: bool = false,
+};
+pub fn add(self: *Scheduler, ctx: *anyopaque, func: Task.Func, ms: u32, opts: AddOpts) !void {
+    var low_priority = opts.low_priority;
+    if (ms > 5_000) {
+        // we don't want tasks in the far future to block page.wait from
+        // completing. However, if page.wait is called multiple times (maybe
+        // a CDP driver is wait for something to happen), then we do want
+        // to [eventually] run these when their time is up.
+        low_priority = true;
+    }
+
+    var q = if (low_priority) &self.low_priority else &self.high_priority;
+    return q.add(.{
+        .ms = std.time.milliTimestamp() + ms,
+        .ctx = ctx,
+        .func = func,
+        .name = opts.name,
+    });
+}
+
+pub fn run(self: *Scheduler) !?i32 {
+    _ = try self.runQueue(&self.low_priority);
+    return self.runQueue(&self.high_priority);
+}
+
+fn runQueue(self: *Scheduler, queue: *Queue) !?i32 {
+    // this is O(1)
+    if (queue.count() == 0) {
+        return null;
+    }
+
+    const now = std.time.milliTimestamp();
+
+    var next = queue.peek();
+    while (next) |task| {
+        const time_to_next = task.ms - now;
+        if (time_to_next > 0) {
+            // @intCast is petty safe since we limit tasks to just 5 seconds
+            // in the future
+            return @intCast(time_to_next);
+        }
+
+        if (task.func(task.ctx)) |repeat_delay| {
+            // if we do (now + 0) then our WHILE loop will run endlessly.
+            // no task should ever return 0
+            std.debug.assert(repeat_delay != 0);
+
+            var copy = task;
+            copy.ms = now + repeat_delay;
+            try self.low_priority.add(copy);
+        }
+        _ = queue.remove();
+        next = queue.peek();
+    }
+    return null;
+}
+
+const Task = struct {
+    ms: i64,
+    func: Func,
+    ctx: *anyopaque,
+    name: []const u8,
+
+    const Func = *const fn (ctx: *anyopaque) ?u32;
+};
+
+const Queue = std.PriorityQueue(Task, void, struct {
+    fn compare(_: void, a: Task, b: Task) std.math.Order {
+        return std.math.order(a.ms, b.ms);
+    }
+}.compare);
+
+const testing = @import("../testing.zig");
+test "Scheduler" {
+    defer testing.reset();
+
+    var task = TestTask{ .allocator = testing.arena_allocator };
+
+    var s = Scheduler.init(testing.arena_allocator);
+    try testing.expectEqual(null, s.run());
+    try testing.expectEqual(0, task.calls.items.len);
+
+    try s.add(&task, TestTask.run1, 3, .{});
+
+    try testing.expectDelta(3, try s.run(), 1);
+    try testing.expectEqual(0, task.calls.items.len);
+
+    std.Thread.sleep(std.time.ns_per_ms * 5);
+    try testing.expectEqual(null, s.run());
+    try testing.expectEqualSlices(u32, &.{1}, task.calls.items);
+
+    try s.add(&task, TestTask.run2, 3, .{});
+    try s.add(&task, TestTask.run1, 2, .{});
+
+    std.Thread.sleep(std.time.ns_per_ms * 5);
+    try testing.expectDelta(null, try s.run(), 1);
+    try testing.expectEqualSlices(u32, &.{ 1, 1, 2 }, task.calls.items);
+}
+
+const TestTask = struct {
+    allocator: Allocator,
+    calls: std.ArrayListUnmanaged(u32) = .{},
+
+    fn run1(ctx: *anyopaque) ?u32 {
+        var self: *TestTask = @ptrCast(@alignCast(ctx));
+        self.calls.append(self.allocator, 1) catch unreachable;
+        return null;
+    }
+
+    fn run2(ctx: *anyopaque) ?u32 {
+        var self: *TestTask = @ptrCast(@alignCast(ctx));
+        self.calls.append(self.allocator, 2) catch unreachable;
+        return 2;
+    }
+};

src/browser/Session.zig

@@ -1,674 +0,0 @@
-// Copyright (C) 2023-2025  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program 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 Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-const lp = @import("lightpanda");
-const builtin = @import("builtin");
-
-const log = @import("../log.zig");
-const App = @import("../App.zig");
-
-const js = @import("js/js.zig");
-const storage = @import("webapi/storage/storage.zig");
-const Navigation = @import("webapi/navigation/Navigation.zig");
-const History = @import("webapi/History.zig");
-
-const Page = @import("Page.zig");
-const Browser = @import("Browser.zig");
-const Factory = @import("Factory.zig");
-const Notification = @import("../Notification.zig");
-const QueuedNavigation = Page.QueuedNavigation;
-
-const Allocator = std.mem.Allocator;
-const ArenaPool = App.ArenaPool;
-const IS_DEBUG = builtin.mode == .Debug;
-
-// You can create successively multiple pages for a session, but you must
-// deinit a page before running another one. It manages two distinct lifetimes.
-//
-// The first is the lifetime of the Session itself, where pages are created and
-// removed, but share the same cookie jar and navigation history (etc...)
-//
-// The second is as a container the data needed by the full page hierarchy, i.e. \
-// the root page and all of its frames (and all of their frames.)
-const Session = @This();
-
-// These are the fields that remain intact for the duration of the Session
-browser: *Browser,
-arena: Allocator,
-history: History,
-navigation: Navigation,
-storage_shed: storage.Shed,
-notification: *Notification,
-cookie_jar: storage.Cookie.Jar,
-
-// These are the fields that get reset whenever the Session's page (the root) is reset.
-factory: Factory,
-
-page_arena: Allocator,
-
-// Origin map for same-origin context sharing. Scoped to the root page lifetime.
-origins: std.StringHashMapUnmanaged(*js.Origin) = .empty,
-
-// Shared resources for all pages in this session.
-// These live for the duration of the page tree (root + frames).
-arena_pool: *ArenaPool,
-
-// In Debug, we use this to see if anything fails to release an arena back to
-// the pool.
-_arena_pool_leak_track: if (IS_DEBUG) std.AutoHashMapUnmanaged(usize, struct {
-    owner: []const u8,
-    count: usize,
-}) else void = if (IS_DEBUG) .empty else {},
-
-page: ?Page,
-
-queued_navigation: std.ArrayList(*Page),
-// Temporary buffer for about:blank navigations during processing.
-// We process async navigations first (safe from re-entrance), then sync
-// about:blank navigations (which may add to queued_navigation).
-queued_queued_navigation: std.ArrayList(*Page),
-
-page_id_gen: u32,
-frame_id_gen: u32,
-
-pub fn init(self: *Session, browser: *Browser, notification: *Notification) !void {
-    const allocator = browser.app.allocator;
-    const arena_pool = browser.arena_pool;
-
-    const arena = try arena_pool.acquire();
-    errdefer arena_pool.release(arena);
-
-    const page_arena = try arena_pool.acquire();
-    errdefer arena_pool.release(page_arena);
-
-    self.* = .{
-        .page = null,
-        .arena = arena,
-        .arena_pool = arena_pool,
-        .page_arena = page_arena,
-        .factory = Factory.init(page_arena),
-        .history = .{},
-        .page_id_gen = 0,
-        .frame_id_gen = 0,
-        // The prototype (EventTarget) for Navigation is created when a Page is created.
-        .navigation = .{ ._proto = undefined },
-        .storage_shed = .{},
-        .browser = browser,
-        .queued_navigation = .{},
-        .queued_queued_navigation = .{},
-        .notification = notification,
-        .cookie_jar = storage.Cookie.Jar.init(allocator),
-    };
-}
-
-pub fn deinit(self: *Session) void {
-    if (self.page != null) {
-        self.removePage();
-    }
-    self.cookie_jar.deinit();
-
-    self.storage_shed.deinit(self.browser.app.allocator);
-    self.arena_pool.release(self.page_arena);
-    self.arena_pool.release(self.arena);
-}
-
-// NOTE: the caller is not the owner of the returned value,
-// the pointer on Page is just returned as a convenience
-pub fn createPage(self: *Session) !*Page {
-    lp.assert(self.page == null, "Session.createPage - page not null", .{});
-
-    self.page = @as(Page, undefined);
-    const page = &self.page.?;
-    try Page.init(page, self.nextFrameId(), self, null);
-
-    // Creates a new NavigationEventTarget for this page.
-    try self.navigation.onNewPage(page);
-
-    if (comptime IS_DEBUG) {
-        log.debug(.browser, "create page", .{});
-    }
-    // start JS env
-    // Inform CDP the main page has been created such that additional context for other Worlds can be created as well
-    self.notification.dispatch(.page_created, page);
-
-    return page;
-}
-
-pub fn removePage(self: *Session) void {
-    // Inform CDP the page is going to be removed, allowing other worlds to remove themselves before the main one
-    self.notification.dispatch(.page_remove, .{});
-    lp.assert(self.page != null, "Session.removePage - page is null", .{});
-
-    self.page.?.deinit(false);
-    self.page = null;
-
-    self.navigation.onRemovePage();
-    self.resetPageResources();
-
-    if (comptime IS_DEBUG) {
-        log.debug(.browser, "remove page", .{});
-    }
-}
-
-pub const GetArenaOpts = struct {
-    debug: []const u8,
-};
-
-pub fn getArena(self: *Session, opts: GetArenaOpts) !Allocator {
-    const allocator = try self.arena_pool.acquire();
-    if (comptime IS_DEBUG) {
-        // Use session's arena (not page_arena) since page_arena gets reset between pages
-        const gop = try self._arena_pool_leak_track.getOrPut(self.arena, @intFromPtr(allocator.ptr));
-        if (gop.found_existing and gop.value_ptr.count != 0) {
-            log.err(.bug, "ArenaPool Double Use", .{ .owner = gop.value_ptr.*.owner });
-            @panic("ArenaPool Double Use");
-        }
-        gop.value_ptr.* = .{ .owner = opts.debug, .count = 1 };
-    }
-    return allocator;
-}
-
-pub fn releaseArena(self: *Session, allocator: Allocator) void {
-    if (comptime IS_DEBUG) {
-        const found = self._arena_pool_leak_track.getPtr(@intFromPtr(allocator.ptr)).?;
-        if (found.count != 1) {
-            log.err(.bug, "ArenaPool Double Free", .{ .owner = found.owner, .count = found.count });
-            if (comptime builtin.is_test) {
-                @panic("ArenaPool Double Free");
-            }
-            return;
-        }
-        found.count = 0;
-    }
-    return self.arena_pool.release(allocator);
-}
-
-pub fn getOrCreateOrigin(self: *Session, key_: ?[]const u8) !*js.Origin {
-    const key = key_ orelse {
-        var opaque_origin: [36]u8 = undefined;
-        @import("../id.zig").uuidv4(&opaque_origin);
-        // Origin.init will dupe opaque_origin. It's fine that this doesn't
-        // get added to self.origins. In fact, it further isolates it. When the
-        // context is freed, it'll call session.releaseOrigin which will free it.
-        return js.Origin.init(self.browser.app, self.browser.env.isolate, &opaque_origin);
-    };
-
-    const gop = try self.origins.getOrPut(self.arena, key);
-    if (gop.found_existing) {
-        const origin = gop.value_ptr.*;
-        origin.rc += 1;
-        return origin;
-    }
-
-    errdefer _ = self.origins.remove(key);
-
-    const origin = try js.Origin.init(self.browser.app, self.browser.env.isolate, key);
-    gop.key_ptr.* = origin.key;
-    gop.value_ptr.* = origin;
-    return origin;
-}
-
-pub fn releaseOrigin(self: *Session, origin: *js.Origin) void {
-    const rc = origin.rc;
-    if (rc == 1) {
-        _ = self.origins.remove(origin.key);
-        origin.deinit(self.browser.app);
-    } else {
-        origin.rc = rc - 1;
-    }
-}
-
-/// Reset page_arena and factory for a clean slate.
-/// Called when root page is removed.
-fn resetPageResources(self: *Session) void {
-    // Check for arena leaks before releasing
-    if (comptime IS_DEBUG) {
-        var it = self._arena_pool_leak_track.valueIterator();
-        while (it.next()) |value_ptr| {
-            if (value_ptr.count > 0) {
-                log.err(.bug, "ArenaPool Leak", .{ .owner = value_ptr.owner });
-            }
-        }
-        self._arena_pool_leak_track.clearRetainingCapacity();
-    }
-
-    // All origins should have been released when contexts were destroyed
-    if (comptime IS_DEBUG) {
-        std.debug.assert(self.origins.count() == 0);
-    }
-    // Defensive cleanup in case origins leaked
-    {
-        const app = self.browser.app;
-        var it = self.origins.valueIterator();
-        while (it.next()) |value| {
-            value.*.deinit(app);
-        }
-        self.origins.clearRetainingCapacity();
-    }
-
-    // Release old page_arena and acquire fresh one
-    self.frame_id_gen = 0;
-    self.arena_pool.reset(self.page_arena, 64 * 1024);
-    self.factory = Factory.init(self.page_arena);
-}
-
-pub fn replacePage(self: *Session) !*Page {
-    if (comptime IS_DEBUG) {
-        log.debug(.browser, "replace page", .{});
-    }
-
-    lp.assert(self.page != null, "Session.replacePage null page", .{});
-    lp.assert(self.page.?.parent == null, "Session.replacePage with parent", .{});
-
-    var current = self.page.?;
-    const frame_id = current._frame_id;
-    current.deinit(true);
-
-    self.resetPageResources();
-    self.browser.env.memoryPressureNotification(.moderate);
-
-    self.page = @as(Page, undefined);
-    const page = &self.page.?;
-    try Page.init(page, frame_id, self, null);
-    return page;
-}
-
-pub fn currentPage(self: *Session) ?*Page {
-    return &(self.page orelse return null);
-}
-
-pub const WaitResult = enum {
-    done,
-    no_page,
-    cdp_socket,
-};
-
-pub fn findPageByFrameId(self: *Session, frame_id: u32) ?*Page {
-    const page = self.currentPage() orelse return null;
-    return findPageBy(page, "_frame_id", frame_id);
-}
-
-pub fn findPageById(self: *Session, id: u32) ?*Page {
-    const page = self.currentPage() orelse return null;
-    return findPageBy(page, "id", id);
-}
-
-fn findPageBy(page: *Page, comptime field: []const u8, id: u32) ?*Page {
-    if (@field(page, field) == id) return page;
-    for (page.frames.items) |f| {
-        if (findPageBy(f, field, id)) |found| {
-            return found;
-        }
-    }
-    return null;
-}
-
-pub fn wait(self: *Session, wait_ms: u32) WaitResult {
-    var page = &(self.page orelse return .no_page);
-    while (true) {
-        const wait_result = self._wait(page, wait_ms) catch |err| {
-            switch (err) {
-                error.JsError => {}, // already logged (with hopefully more context)
-                else => log.err(.browser, "session wait", .{
-                    .err = err,
-                    .url = page.url,
-                }),
-            }
-            return .done;
-        };
-
-        switch (wait_result) {
-            .done => {
-                if (self.queued_navigation.items.len == 0) {
-                    return .done;
-                }
-                self.processQueuedNavigation() catch return .done;
-                page = &self.page.?; // might have changed
-            },
-            else => |result| return result,
-        }
-    }
-}
-
-fn _wait(self: *Session, page: *Page, wait_ms: u32) !WaitResult {
-    var timer = try std.time.Timer.start();
-    var ms_remaining = wait_ms;
-
-    const browser = self.browser;
-    var http_client = browser.http_client;
-
-    // I'd like the page to know NOTHING about cdp_socket / CDP, but the
-    // fact is that the behavior of wait changes depending on whether or
-    // not we're using CDP.
-    // If we aren't using CDP, as soon as we think there's nothing left
-    // to do, we can exit - we'de done.
-    // But if we are using CDP, we should wait for the whole `wait_ms`
-    // because the http_click.tick() also monitors the CDP socket. And while
-    // we could let CDP poll http (like it does for HTTP requests), the fact
-    // is that we know more about the timing of stuff (e.g. how long to
-    // poll/sleep) in the page.
-    const exit_when_done = http_client.cdp_client == null;
-
-    while (true) {
-        switch (page._parse_state) {
-            .pre, .raw, .text, .image => {
-                // The main page hasn't started/finished navigating.
-                // There's no JS to run, and no reason to run the scheduler.
-                if (http_client.active == 0 and exit_when_done) {
-                    // haven't started navigating, I guess.
-                    return .done;
-                }
-                // Either we have active http connections, or we're in CDP
-                // mode with an extra socket. Either way, we're waiting
-                // for http traffic
-                if (try http_client.tick(@intCast(ms_remaining)) == .cdp_socket) {
-                    // exit_when_done is explicitly set when there isn't
-                    // an extra socket, so it should not be possibl to
-                    // get an cdp_socket message when exit_when_done
-                    // is true.
-                    if (IS_DEBUG) {
-                        std.debug.assert(exit_when_done == false);
-                    }
-
-                    // data on a socket we aren't handling, return to caller
-                    return .cdp_socket;
-                }
-            },
-            .html, .complete => {
-                if (self.queued_navigation.items.len != 0) {
-                    return .done;
-                }
-
-                // The HTML page was parsed. We now either have JS scripts to
-                // download, or scheduled tasks to execute, or both.
-
-                // scheduler.run could trigger new http transfers, so do not
-                // store http_client.active BEFORE this call and then use
-                // it AFTER.
-                try browser.runMacrotasks();
-
-                // Each call to this runs scheduled load events.
-                try page.dispatchLoad();
-
-                const http_active = http_client.active;
-                const total_network_activity = http_active + http_client.intercepted;
-                if (page._notified_network_almost_idle.check(total_network_activity <= 2)) {
-                    page.notifyNetworkAlmostIdle();
-                }
-                if (page._notified_network_idle.check(total_network_activity == 0)) {
-                    page.notifyNetworkIdle();
-                }
-
-                if (http_active == 0 and exit_when_done) {
-                    // we don't need to consider http_client.intercepted here
-                    // because exit_when_done is true, and that can only be
-                    // the case when interception isn't possible.
-                    if (comptime IS_DEBUG) {
-                        std.debug.assert(http_client.intercepted == 0);
-                    }
-
-                    var ms = blk: {
-                        // if (wait_ms - ms_remaining < 100) {
-                        //     if (comptime builtin.is_test) {
-                        //         return .done;
-                        //     }
-                        //     // Look, we want to exit ASAP, but we don't want
-                        //     // to exit so fast that we've run none of the
-                        //     // background jobs.
-                        //     break :blk 50;
-                        // }
-
-                        if (browser.hasBackgroundTasks()) {
-                            // _we_ have nothing to run, but v8 is working on
-                            // background tasks. We'll wait for them.
-                            browser.waitForBackgroundTasks();
-                            break :blk 20;
-                        }
-
-                        break :blk browser.msToNextMacrotask() orelse return .done;
-                    };
-
-                    if (ms > ms_remaining) {
-                        // Same as above, except we have a scheduled task,
-                        // it just happens to be too far into the future
-                        // compared to how long we were told to wait.
-                        if (!browser.hasBackgroundTasks()) {
-                            return .done;
-                        }
-                        // _we_ have nothing to run, but v8 is working on
-                        // background tasks. We'll wait for them.
-                        browser.waitForBackgroundTasks();
-                        ms = 20;
-                    }
-
-                    // We have a task to run in the not-so-distant future.
-                    // You might think we can just sleep until that task is
-                    // ready, but we should continue to run lowPriority tasks
-                    // in the meantime, and that could unblock things. So
-                    // we'll just sleep for a bit, and then restart our wait
-                    // loop to see if anything new can be processed.
-                    std.Thread.sleep(std.time.ns_per_ms * @as(u64, @intCast(@min(ms, 20))));
-                } else {
-                    // We're here because we either have active HTTP
-                    // connections, or exit_when_done == false (aka, there's
-                    // an cdp_socket registered with the http client).
-                    // We should continue to run tasks, so we minimize how long
-                    // we'll poll for network I/O.
-                    var ms_to_wait = @min(200, browser.msToNextMacrotask() orelse 200);
-                    if (ms_to_wait > 10 and browser.hasBackgroundTasks()) {
-                        // if we have background tasks, we don't want to wait too
-                        // long for a message from the client. We want to go back
-                        // to the top of the loop and run macrotasks.
-                        ms_to_wait = 10;
-                    }
-                    if (try http_client.tick(@min(ms_remaining, ms_to_wait)) == .cdp_socket) {
-                        // data on a socket we aren't handling, return to caller
-                        return .cdp_socket;
-                    }
-                }
-            },
-            .err => |err| {
-                page._parse_state = .{ .raw_done = @errorName(err) };
-                return err;
-            },
-            .raw_done => {
-                if (exit_when_done) {
-                    return .done;
-                }
-                // we _could_ http_client.tick(ms_to_wait), but this has
-                // the same result, and I feel is more correct.
-                return .no_page;
-            },
-        }
-
-        const ms_elapsed = timer.lap() / 1_000_000;
-        if (ms_elapsed >= ms_remaining) {
-            return .done;
-        }
-        ms_remaining -= @intCast(ms_elapsed);
-    }
-}
-
-pub fn scheduleNavigation(self: *Session, page: *Page) !void {
-    const list = &self.queued_navigation;
-
-    // Check if page is already queued
-    for (list.items) |existing| {
-        if (existing == page) {
-            // Already queued
-            return;
-        }
-    }
-
-    return list.append(self.arena, page);
-}
-
-fn processQueuedNavigation(self: *Session) !void {
-    const navigations = &self.queued_navigation;
-
-    if (self.page.?._queued_navigation != null) {
-        // This is both an optimization and a simplification of sorts. If the
-        // root page is navigating, then we don't need to process any other
-        // navigation. Also, the navigation for the root page and for a frame
-        // is different enough that have two distinct code blocks is, imo,
-        // better. Yes, there will be duplication.
-        navigations.clearRetainingCapacity();
-        return self.processRootQueuedNavigation();
-    }
-
-    const about_blank_queue = &self.queued_queued_navigation;
-    defer about_blank_queue.clearRetainingCapacity();
-
-    // First pass: process async navigations (non-about:blank)
-    // These cannot cause re-entrant navigation scheduling
-    for (navigations.items) |page| {
-        const qn = page._queued_navigation.?;
-
-        if (qn.is_about_blank) {
-            // Defer about:blank to second pass
-            try about_blank_queue.append(self.arena, page);
-            continue;
-        }
-
-        self.processFrameNavigation(page, qn) catch |err| {
-            log.warn(.page, "frame navigation", .{ .url = qn.url, .err = err });
-        };
-    }
-
-    // Clear the queue after first pass
-    navigations.clearRetainingCapacity();
-
-    // Second pass: process synchronous navigations (about:blank)
-    // These may trigger new navigations which go into queued_navigation
-    for (about_blank_queue.items) |page| {
-        const qn = page._queued_navigation.?;
-        try self.processFrameNavigation(page, qn);
-    }
-
-    // Safety: Remove any about:blank navigations that were queued during the
-    // second pass to prevent infinite loops
-    var i: usize = 0;
-    while (i < navigations.items.len) {
-        const page = navigations.items[i];
-        if (page._queued_navigation) |qn| {
-            if (qn.is_about_blank) {
-                log.warn(.page, "recursive about    blank", .{});
-                _ = navigations.swapRemove(i);
-                continue;
-            }
-        }
-        i += 1;
-    }
-}
-
-fn processFrameNavigation(self: *Session, page: *Page, qn: *QueuedNavigation) !void {
-    lp.assert(page.parent != null, "root queued navigation", .{});
-
-    const iframe = page.iframe.?;
-    const parent = page.parent.?;
-
-    page._queued_navigation = null;
-    defer self.releaseArena(qn.arena);
-
-    errdefer iframe._window = null;
-
-    const parent_notified = page._parent_notified;
-    if (parent_notified) {
-        // we already notified the parent that we had loaded
-        parent._pending_loads += 1;
-    }
-
-    const frame_id = page._frame_id;
-    page.deinit(true);
-    page.* = undefined;
-
-    try Page.init(page, frame_id, self, parent);
-    errdefer {
-        for (parent.frames.items, 0..) |frame, i| {
-            if (frame == page) {
-                parent.frames_sorted = false;
-                _ = parent.frames.swapRemove(i);
-                break;
-            }
-        }
-        if (parent_notified) {
-            parent._pending_loads -= 1;
-        }
-        page.deinit(true);
-    }
-
-    page.iframe = iframe;
-    iframe._window = page.window;
-
-    page.navigate(qn.url, qn.opts) catch |err| {
-        log.err(.browser, "queued frame navigation error", .{ .err = err });
-        return err;
-    };
-}
-
-fn processRootQueuedNavigation(self: *Session) !void {
-    const current_page = &self.page.?;
-    const frame_id = current_page._frame_id;
-
-    // create a copy before the page is cleared
-    const qn = current_page._queued_navigation.?;
-    current_page._queued_navigation = null;
-
-    defer self.arena_pool.release(qn.arena);
-
-    // HACK
-    // Mark as released in tracking BEFORE removePage clears the map.
-    // We can't call releaseArena() because that would also return the arena
-    // to the pool, making the memory invalid before we use qn.url/qn.opts.
-    if (comptime IS_DEBUG) {
-        if (self._arena_pool_leak_track.getPtr(@intFromPtr(qn.arena.ptr))) |found| {
-            found.count = 0;
-        }
-    }
-
-    self.removePage();
-
-    self.page = @as(Page, undefined);
-    const new_page = &self.page.?;
-    try Page.init(new_page, frame_id, self, null);
-
-    // Creates a new NavigationEventTarget for this page.
-    try self.navigation.onNewPage(new_page);
-
-    // start JS env
-    // Inform CDP the main page has been created such that additional context for other Worlds can be created as well
-    self.notification.dispatch(.page_created, new_page);
-
-    new_page.navigate(qn.url, qn.opts) catch |err| {
-        log.err(.browser, "queued navigation error", .{ .err = err });
-        return err;
-    };
-}
-
-pub fn nextFrameId(self: *Session) u32 {
-    const id = self.frame_id_gen +% 1;
-    self.frame_id_gen = id;
-    return id;
-}
-
-pub fn nextPageId(self: *Session) u32 {
-    const id = self.page_id_gen +% 1;
-    self.page_id_gen = id;
-    return id;
-}

src/browser/SlotChangeMonitor.zig

@@ -0,0 +1,189 @@
+const std = @import("std");
+
+const log = @import("../log.zig");
+const parser = @import("netsurf.zig");
+const collection = @import("dom/html_collection.zig");
+
+const Page = @import("page.zig").Page;
+
+const SlotChangeMonitor = @This();
+
+page: *Page,
+event_node: parser.EventNode,
+slots_changed: std.ArrayList(*parser.Slot),
+
+// Monitors the document in order to trigger slotchange events.
+pub fn init(page: *Page) !*SlotChangeMonitor {
+    // on the heap, we need a stable address for event_node
+    const self = try page.arena.create(SlotChangeMonitor);
+    self.* = .{
+        .page = page,
+        .slots_changed = .empty,
+        .event_node = .{ .func = mutationCallback },
+    };
+    const root = parser.documentToNode(parser.documentHTMLToDocument(page.window.document));
+
+    _ = try parser.eventTargetAddEventListener(
+        parser.toEventTarget(parser.Node, root),
+        "DOMNodeInserted",
+        &self.event_node,
+        false,
+    );
+
+    _ = try parser.eventTargetAddEventListener(
+        parser.toEventTarget(parser.Node, root),
+        "DOMNodeRemoved",
+        &self.event_node,
+        false,
+    );
+
+    _ = try parser.eventTargetAddEventListener(
+        parser.toEventTarget(parser.Node, root),
+        "DOMAttrModified",
+        &self.event_node,
+        false,
+    );
+
+    return self;
+}
+
+// Given a element, finds its slot, if any.
+pub fn findSlot(element: *parser.Element, page: *const Page) !?*parser.Slot {
+    const target_name = (try parser.elementGetAttribute(element, "slot")) orelse return null;
+    return findNamedSlot(element, target_name, page);
+}
+
+// Given an element and a name, find the slo, if any. This is only useful for
+// MutationEvents where findSlot is unreliable because parser.elementGetAttribute(element, "slot")
+// could return the new or old value.
+fn findNamedSlot(element: *parser.Element, target_name: []const u8, page: *const Page) !?*parser.Slot {
+    // I believe elements need to be added as direct descendents of the host,
+    // so we don't need to go find the host, we just grab the parent.
+    const host = parser.nodeParentNode(@ptrCast(element)) orelse return null;
+    const state = page.getNodeState(host) orelse return null;
+    const shadow_root = state.shadow_root orelse return null;
+
+    // if we're here, we found a host, now find the slot
+    var nodes = collection.HTMLCollectionByTagName(
+        @ptrCast(@alignCast(shadow_root.proto)),
+        "slot",
+        .{ .include_root = false },
+    );
+    for (0..1000) |i| {
+        const n = (try nodes.item(@intCast(i))) orelse return null;
+        const slot_name = (try parser.elementGetAttribute(@ptrCast(n), "name")) orelse "";
+        if (std.mem.eql(u8, target_name, slot_name)) {
+            return @ptrCast(n);
+        }
+    }
+    return null;
+}
+
+// Event callback from the mutation event, signaling either the addition of
+// a node, removal of a node, or a change in attribute
+fn mutationCallback(en: *parser.EventNode, event: *parser.Event) void {
+    const mutation_event = parser.eventToMutationEvent(event);
+    const self: *SlotChangeMonitor = @fieldParentPtr("event_node", en);
+    self._mutationCallback(mutation_event) catch |err| {
+        log.err(.web_api, "slot change callback", .{ .err = err });
+    };
+}
+
+fn _mutationCallback(self: *SlotChangeMonitor, event: *parser.MutationEvent) !void {
+    const event_type = parser.eventType(@ptrCast(event));
+    if (std.mem.eql(u8, event_type, "DOMNodeInserted")) {
+        const event_target = parser.eventTarget(@ptrCast(event)) orelse return;
+        return self.nodeAddedOrRemoved(@ptrCast(event_target));
+    }
+
+    if (std.mem.eql(u8, event_type, "DOMNodeRemoved")) {
+        const event_target = parser.eventTarget(@ptrCast(event)) orelse return;
+        return self.nodeAddedOrRemoved(@ptrCast(event_target));
+    }
+
+    if (std.mem.eql(u8, event_type, "DOMAttrModified")) {
+        const attribute_name = try parser.mutationEventAttributeName(event);
+        if (std.mem.eql(u8, attribute_name, "slot") == false) {
+            return;
+        }
+
+        const new_value = parser.mutationEventNewValue(event);
+        const prev_value = parser.mutationEventPrevValue(event);
+        const event_target = parser.eventTarget(@ptrCast(event)) orelse return;
+        return self.nodeAttributeChanged(@ptrCast(event_target), new_value, prev_value);
+    }
+}
+
+// A node was removed or added. If it's an element, and if it has a slot attribute
+// then we'll dispatch a slotchange event.
+fn nodeAddedOrRemoved(self: *SlotChangeMonitor, node: *parser.Node) !void {
+    if (parser.nodeType(node) != .element) {
+        return;
+    }
+    const el: *parser.Element = @ptrCast(node);
+    if (try findSlot(el, self.page)) |slot| {
+        return self.scheduleSlotChange(slot);
+    }
+}
+
+// An attribute was modified. If the attribute is "slot", then we'll trigger 1
+// slotchange for the old slot (if there was one) and 1 slotchange for the new
+// one (if there is one)
+fn nodeAttributeChanged(self: *SlotChangeMonitor, node: *parser.Node, new_value: ?[]const u8, prev_value: ?[]const u8) !void {
+    if (parser.nodeType(node) != .element) {
+        return;
+    }
+
+    const el: *parser.Element = @ptrCast(node);
+    if (try findNamedSlot(el, prev_value orelse "", self.page)) |slot| {
+        try self.scheduleSlotChange(slot);
+    }
+
+    if (try findNamedSlot(el, new_value orelse "", self.page)) |slot| {
+        try self.scheduleSlotChange(slot);
+    }
+}
+
+// OK. Our MutationEvent is not a MutationObserver - it's an older, deprecated
+// API. It gets dispatched in the middle of the change. While I'm sure it has
+// some rules, from our point of view, it fires too early. DOMAttrModified fires
+// before the attribute is actually updated and DOMNodeRemoved before the node
+// is actually removed. This is a problem if the callback will call
+// `slot.assignedNodes`, since that won't return the new state.
+// So, we use the page schedule to schedule the dispatching of the slotchange
+// event.
+fn scheduleSlotChange(self: *SlotChangeMonitor, slot: *parser.Slot) !void {
+    for (self.slots_changed.items) |changed| {
+        if (slot == changed) {
+            return;
+        }
+    }
+
+    try self.slots_changed.append(self.page.arena, slot);
+    if (self.slots_changed.items.len == 1) {
+        // first item added, schedule the callback
+        try self.page.scheduler.add(self, scheduleCallback, 0, .{ .name = "slot change" });
+    }
+}
+
+// Callback from the schedule. Time to dispatch the slotchange event
+fn scheduleCallback(ctx: *anyopaque) ?u32 {
+    var self: *SlotChangeMonitor = @ptrCast(@alignCast(ctx));
+    self._scheduleCallback() catch |err| {
+        log.err(.app, "slot change schedule", .{ .err = err });
+    };
+    return null;
+}
+
+fn _scheduleCallback(self: *SlotChangeMonitor) !void {
+    for (self.slots_changed.items) |slot| {
+        const event = try parser.eventCreate();
+        defer parser.eventDestroy(event);
+        try parser.eventInit(event, "slotchange", .{});
+        _ = try parser.eventTargetDispatchEvent(
+            parser.toEventTarget(parser.Element, @ptrCast(@alignCast(slot))),
+            event,
+        );
+    }
+    self.slots_changed.clearRetainingCapacity();
+}

src/browser/State.zig

@@ -0,0 +1,77 @@
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+// Sometimes we need to extend libdom. For example, its HTMLDocument doesn't
+// have a readyState. We have a couple different options, such as making the
+// correction in libdom directly. Another option stems from the fact that every
+// libdom node has an opaque embedder_data field. This is the struct that we
+// lazily load into that field.
+//
+// It didn't originally start off as a collection of every single extension, but
+// this quickly proved necessary, since different fields are needed on the same
+// data at different levels of the prototype chain. This isn't memory efficient.
+
+const js = @import("js/js.zig");
+const parser = @import("netsurf.zig");
+const DataSet = @import("html/DataSet.zig");
+const ShadowRoot = @import("dom/shadow_root.zig").ShadowRoot;
+const StyleSheet = @import("cssom/StyleSheet.zig");
+const CSSStyleDeclaration = @import("cssom/CSSStyleDeclaration.zig");
+
+// for HTMLScript (but probably needs to be added to more)
+onload: ?js.Function = null,
+onerror: ?js.Function = null,
+
+// for HTMLElement
+style: CSSStyleDeclaration = .empty,
+dataset: ?DataSet = null,
+template_content: ?*parser.DocumentFragment = null,
+
+// For dom/element
+shadow_root: ?*ShadowRoot = null,
+
+// for html/document
+ready_state: ReadyState = .loading,
+
+// for html/HTMLStyleElement
+style_sheet: ?*StyleSheet = null,
+
+// for dom/document
+active_element: ?*parser.Element = null,
+adopted_style_sheets: ?js.Object = null,
+
+// for HTMLSelectElement
+// By default, if no option is explicitly selected, the first option should
+// be selected. However, libdom doesn't do this, and it sets the
+// selectedIndex to -1, which is a valid value for "nothing selected".
+// Therefore, when libdom says the selectedIndex == -1, we don't know if
+// it means that nothing is selected, or if the first option is selected by
+// default.
+// There are cases where this won't work, but when selectedIndex is
+// explicitly set, we set this boolean flag. Then, when we're getting then
+// selectedIndex, if this flag is == false, which is to say that if
+// selectedIndex hasn't been explicitly set AND if we have at least 1 option
+// AND if it isn't a multi select, we can make the 1st item selected by
+// default (by returning selectedIndex == 0).
+explicit_index_set: bool = false,
+
+const ReadyState = enum {
+    loading,
+    interactive,
+    complete,
+};

src/browser/actions.zig

@@ -1,104 +0,0 @@
-// Copyright (C) 2023-2026  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program 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 Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-const lp = @import("../lightpanda.zig");
-const DOMNode = @import("webapi/Node.zig");
-const Element = @import("webapi/Element.zig");
-const Event = @import("webapi/Event.zig");
-const MouseEvent = @import("webapi/event/MouseEvent.zig");
-const Page = @import("Page.zig");
-
-pub fn click(node: *DOMNode, page: *Page) !void {
-    const el = node.is(Element) orelse return error.InvalidNodeType;
-
-    const mouse_event: *MouseEvent = try .initTrusted(comptime .wrap("click"), .{
-        .bubbles = true,
-        .cancelable = true,
-        .composed = true,
-        .clientX = 0,
-        .clientY = 0,
-    }, page);
-
-    page._event_manager.dispatch(el.asEventTarget(), mouse_event.asEvent()) catch |err| {
-        lp.log.err(.app, "click failed", .{ .err = err });
-        return error.ActionFailed;
-    };
-}
-
-pub fn fill(node: *DOMNode, text: []const u8, page: *Page) !void {
-    const el = node.is(Element) orelse return error.InvalidNodeType;
-
-    if (el.is(Element.Html.Input)) |input| {
-        input.setValue(text, page) catch |err| {
-            lp.log.err(.app, "fill input failed", .{ .err = err });
-            return error.ActionFailed;
-        };
-    } else if (el.is(Element.Html.TextArea)) |textarea| {
-        textarea.setValue(text, page) catch |err| {
-            lp.log.err(.app, "fill textarea failed", .{ .err = err });
-            return error.ActionFailed;
-        };
-    } else if (el.is(Element.Html.Select)) |select| {
-        select.setValue(text, page) catch |err| {
-            lp.log.err(.app, "fill select failed", .{ .err = err });
-            return error.ActionFailed;
-        };
-    } else {
-        return error.InvalidNodeType;
-    }
-
-    const input_evt: *Event = try .initTrusted(comptime .wrap("input"), .{ .bubbles = true }, page);
-    page._event_manager.dispatch(el.asEventTarget(), input_evt) catch |err| {
-        lp.log.err(.app, "dispatch input event failed", .{ .err = err });
-    };
-
-    const change_evt: *Event = try .initTrusted(comptime .wrap("change"), .{ .bubbles = true }, page);
-    page._event_manager.dispatch(el.asEventTarget(), change_evt) catch |err| {
-        lp.log.err(.app, "dispatch change event failed", .{ .err = err });
-    };
-}
-
-pub fn scroll(node: ?*DOMNode, x: ?i32, y: ?i32, page: *Page) !void {
-    if (node) |n| {
-        const el = n.is(Element) orelse return error.InvalidNodeType;
-
-        if (x) |val| {
-            el.setScrollLeft(val, page) catch |err| {
-                lp.log.err(.app, "setScrollLeft failed", .{ .err = err });
-                return error.ActionFailed;
-            };
-        }
-        if (y) |val| {
-            el.setScrollTop(val, page) catch |err| {
-                lp.log.err(.app, "setScrollTop failed", .{ .err = err });
-                return error.ActionFailed;
-            };
-        }
-
-        const scroll_evt: *Event = try .initTrusted(comptime .wrap("scroll"), .{ .bubbles = true }, page);
-        page._event_manager.dispatch(el.asEventTarget(), scroll_evt) catch |err| {
-            lp.log.err(.app, "dispatch scroll event failed", .{ .err = err });
-        };
-    } else {
-        page.window.scrollTo(.{ .x = x orelse 0 }, y, page) catch |err| {
-            lp.log.err(.app, "scroll failed", .{ .err = err });
-            return error.ActionFailed;
-        };
-    }
-}

src/browser/browser.zig

@@ -0,0 +1,119 @@
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const std = @import("std");
+
+const Allocator = std.mem.Allocator;
+const ArenaAllocator = std.heap.ArenaAllocator;
+
+const js = @import("js/js.zig");
+const State = @import("State.zig");
+const App = @import("../app.zig").App;
+const Session = @import("session.zig").Session;
+const Notification = @import("../notification.zig").Notification;
+
+const log = @import("../log.zig");
+const HttpClient = @import("../http/Client.zig");
+
+// Browser is an instance of the browser.
+// You can create multiple browser instances.
+// A browser contains only one session.
+pub const Browser = struct {
+    env: *js.Env,
+    app: *App,
+    session: ?Session,
+    allocator: Allocator,
+    http_client: *HttpClient,
+    call_arena: ArenaAllocator,
+    page_arena: ArenaAllocator,
+    session_arena: ArenaAllocator,
+    transfer_arena: ArenaAllocator,
+    notification: *Notification,
+    state_pool: std.heap.MemoryPool(State),
+
+    pub fn init(app: *App) !Browser {
+        const allocator = app.allocator;
+
+        const env = try js.Env.init(allocator, &app.platform, .{});
+        errdefer env.deinit();
+
+        const notification = try Notification.init(allocator, app.notification);
+        app.http.client.notification = notification;
+        app.http.client.next_request_id = 0; // Should we track ids in CDP only?
+        errdefer notification.deinit();
+
+        return .{
+            .app = app,
+            .env = env,
+            .session = null,
+            .allocator = allocator,
+            .notification = notification,
+            .http_client = app.http.client,
+            .call_arena = ArenaAllocator.init(allocator),
+            .page_arena = ArenaAllocator.init(allocator),
+            .session_arena = ArenaAllocator.init(allocator),
+            .transfer_arena = ArenaAllocator.init(allocator),
+            .state_pool = std.heap.MemoryPool(State).init(allocator),
+        };
+    }
+
+    pub fn deinit(self: *Browser) void {
+        self.closeSession();
+        self.env.deinit();
+        self.call_arena.deinit();
+        self.page_arena.deinit();
+        self.session_arena.deinit();
+        self.transfer_arena.deinit();
+        self.http_client.notification = null;
+        self.notification.deinit();
+        self.state_pool.deinit();
+    }
+
+    pub fn newSession(self: *Browser) !*Session {
+        self.closeSession();
+        self.session = @as(Session, undefined);
+        const session = &self.session.?;
+        try Session.init(session, self);
+        return session;
+    }
+
+    pub fn closeSession(self: *Browser) void {
+        if (self.session) |*session| {
+            session.deinit();
+            self.session = null;
+            _ = self.session_arena.reset(.{ .retain_with_limit = 1 * 1024 * 1024 });
+            self.env.lowMemoryNotification();
+        }
+    }
+
+    pub fn runMicrotasks(self: *const Browser) void {
+        self.env.runMicrotasks();
+    }
+
+    pub fn runMessageLoop(self: *const Browser) void {
+        while (self.env.pumpMessageLoop()) {
+            log.debug(.browser, "pumpMessageLoop", .{});
+        }
+        self.env.runIdleTasks();
+    }
+};
+
+const testing = @import("../testing.zig");
+test "Browser" {
+    try testing.htmlRunner("browser.html");
+}

src/browser/canvas/CanvasRenderingContext2D.zig

@@ -0,0 +1,58 @@
+// Copyright (C) 2023-2025  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const std = @import("std");
+
+const color = @import("../cssom/color.zig");
+const Page = @import("../page.zig").Page;
+
+/// This class doesn't implement a `constructor`.
+/// It can be obtained with a call to `HTMLCanvasElement#getContext`.
+/// https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D
+const CanvasRenderingContext2D = @This();
+/// Fill color.
+/// TODO: Add support for `CanvasGradient` and `CanvasPattern`.
+fill_style: color.RGBA = color.RGBA.Named.black,
+
+pub fn _fillRect(
+    self: *const CanvasRenderingContext2D,
+    x: f64,
+    y: f64,
+    width: f64,
+    height: f64,
+) void {
+    _ = self;
+    _ = x;
+    _ = y;
+    _ = width;
+    _ = height;
+}
+
+pub fn get_fillStyle(self: *const CanvasRenderingContext2D, page: *Page) ![]const u8 {
+    var w = std.Io.Writer.Allocating.init(page.call_arena);
+    try self.fill_style.format(&w.writer);
+    return w.written();
+}
+
+pub fn set_fillStyle(
+    self: *CanvasRenderingContext2D,
+    value: []const u8,
+) !void {
+    // Prefer the same fill_style if fails.
+    self.fill_style = color.RGBA.parse(value) catch self.fill_style;
+}

src/browser/canvas/WebGLRenderingContext.zig

@@ -18,20 +18,8 @@
 
 const std = @import("std");
 
-const js = @import("../../js/js.zig");
-const Page = @import("../../Page.zig");
-
-pub fn registerTypes() []const type {
-    return &.{
-        WebGLRenderingContext,
-        // Extension types should be runtime generated. We might want
-        // to revisit this.
-        Extension.Type.WEBGL_debug_renderer_info,
-        Extension.Type.WEBGL_lose_context,
-    };
-}
-
 const WebGLRenderingContext = @This();
+_: u8 = 0,
 
 /// On Chrome and Safari, a call to `getSupportedExtensions` returns total of 39.
 /// The reference for it lists lesser number of extensions:
@@ -69,11 +57,11 @@ pub const Extension = union(enum) {
     WEBGL_compressed_texture_pvrtc: void,
     WEBGL_compressed_texture_s3tc: void,
     WEBGL_compressed_texture_s3tc_srgb: void,
-    WEBGL_debug_renderer_info: *Type.WEBGL_debug_renderer_info,
+    WEBGL_debug_renderer_info: Type.WEBGL_debug_renderer_info,
     WEBGL_debug_shaders: void,
     WEBGL_depth_texture: void,
     WEBGL_draw_buffers: void,
-    WEBGL_lose_context: *Type.WEBGL_lose_context,
+    WEBGL_lose_context: Type.WEBGL_lose_context,
     WEBGL_multi_draw: void,
     WEBGL_polygon_mode: void,
 
@@ -118,93 +106,40 @@ pub const Extension = union(enum) {
     /// Extension types.
     pub const Type = struct {
         pub const WEBGL_debug_renderer_info = struct {
-            _: u8 = 0,
             pub const UNMASKED_VENDOR_WEBGL: u64 = 0x9245;
             pub const UNMASKED_RENDERER_WEBGL: u64 = 0x9246;
 
-            pub const JsApi = struct {
-                pub const bridge = js.Bridge(WEBGL_debug_renderer_info);
+            pub fn get_UNMASKED_VENDOR_WEBGL() u64 {
+                return UNMASKED_VENDOR_WEBGL;
+            }
 
-                pub const Meta = struct {
-                    pub const name = "WEBGL_debug_renderer_info";
-
-                    pub const prototype_chain = bridge.prototypeChain();
-                    pub var class_id: bridge.ClassId = undefined;
-                };
-
-                pub const UNMASKED_VENDOR_WEBGL = bridge.property(WEBGL_debug_renderer_info.UNMASKED_VENDOR_WEBGL, .{ .template = false, .readonly = true });
-                pub const UNMASKED_RENDERER_WEBGL = bridge.property(WEBGL_debug_renderer_info.UNMASKED_RENDERER_WEBGL, .{ .template = false, .readonly = true });
-            };
+            pub fn get_UNMASKED_RENDERER_WEBGL() u64 {
+                return UNMASKED_RENDERER_WEBGL;
+            }
         };
 
         pub const WEBGL_lose_context = struct {
             _: u8 = 0,
-            pub fn loseContext(_: *const WEBGL_lose_context) void {}
-            pub fn restoreContext(_: *const WEBGL_lose_context) void {}
-
-            pub const JsApi = struct {
-                pub const bridge = js.Bridge(WEBGL_lose_context);
-
-                pub const Meta = struct {
-                    pub const name = "WEBGL_lose_context";
-
-                    pub const prototype_chain = bridge.prototypeChain();
-                    pub var class_id: bridge.ClassId = undefined;
-                };
-
-                pub const loseContext = bridge.function(WEBGL_lose_context.loseContext, .{ .noop = true });
-                pub const restoreContext = bridge.function(WEBGL_lose_context.restoreContext, .{ .noop = true });
-            };
+            pub fn _loseContext(_: *const WEBGL_lose_context) void {}
+            pub fn _restoreContext(_: *const WEBGL_lose_context) void {}
         };
     };
 };
 
-/// This actually takes "GLenum" which, in fact, is a fancy way to say number.
-/// Return value also depends on what's being passed as `pname`; we don't really
-/// support any though.
-pub fn getParameter(_: *const WebGLRenderingContext, pname: u32) []const u8 {
-    _ = pname;
-    return "";
-}
-
 /// Enables a WebGL extension.
-pub fn getExtension(_: *const WebGLRenderingContext, name: []const u8, page: *Page) !?Extension {
+pub fn _getExtension(self: *const WebGLRenderingContext, name: []const u8) ?Extension {
+    _ = self;
+
     const tag = Extension.find(name) orelse return null;
 
     return switch (tag) {
-        .WEBGL_debug_renderer_info => {
-            const info = try page._factory.create(Extension.Type.WEBGL_debug_renderer_info{});
-            return .{ .WEBGL_debug_renderer_info = info };
-        },
-        .WEBGL_lose_context => {
-            const ctx = try page._factory.create(Extension.Type.WEBGL_lose_context{});
-            return .{ .WEBGL_lose_context = ctx };
-        },
+        .WEBGL_debug_renderer_info => @unionInit(Extension, "WEBGL_debug_renderer_info", .{}),
+        .WEBGL_lose_context => @unionInit(Extension, "WEBGL_lose_context", .{}),
         inline else => |comptime_enum| @unionInit(Extension, @tagName(comptime_enum), {}),
     };
 }
 
 /// Returns a list of all the supported WebGL extensions.
-pub fn getSupportedExtensions(_: *const WebGLRenderingContext) []const []const u8 {
+pub fn _getSupportedExtensions(_: *const WebGLRenderingContext) []const []const u8 {
     return std.meta.fieldNames(Extension.Kind);
 }
-
-pub const JsApi = struct {
-    pub const bridge = js.Bridge(WebGLRenderingContext);
-
-    pub const Meta = struct {
-        pub const name = "WebGLRenderingContext";
-
-        pub const prototype_chain = bridge.prototypeChain();
-        pub var class_id: bridge.ClassId = undefined;
-    };
-
-    pub const getParameter = bridge.function(WebGLRenderingContext.getParameter, .{});
-    pub const getExtension = bridge.function(WebGLRenderingContext.getExtension, .{});
-    pub const getSupportedExtensions = bridge.function(WebGLRenderingContext.getSupportedExtensions, .{});
-};
-
-const testing = @import("../../../testing.zig");
-test "WebApi: WebGLRenderingContext" {
-    try testing.htmlRunner("canvas/webgl_rendering_context.html", .{});
-}

src/browser/canvas/root.zig

@@ -0,0 +1,13 @@
+//! Canvas API.
+//! https://developer.mozilla.org/en-US/docs/Web/API/Canvas_API
+
+const CanvasRenderingContext2D = @import("CanvasRenderingContext2D.zig");
+const WebGLRenderingContext = @import("WebGLRenderingContext.zig");
+const Extension = WebGLRenderingContext.Extension;
+
+pub const Interfaces = .{
+    CanvasRenderingContext2D,
+    WebGLRenderingContext,
+    Extension.Type.WEBGL_debug_renderer_info,
+    Extension.Type.WEBGL_lose_context,
+};

src/browser/console/console.zig

@@ -0,0 +1,177 @@
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const std = @import("std");
+const builtin = @import("builtin");
+const log = @import("../../log.zig");
+
+const js = @import("../js/js.zig");
+const Page = @import("../page.zig").Page;
+
+pub const Console = struct {
+    // TODO: configurable writer
+    timers: std.StringHashMapUnmanaged(u32) = .{},
+    counts: std.StringHashMapUnmanaged(u32) = .{},
+
+    pub fn _lp(values: []js.Object, page: *Page) !void {
+        if (values.len == 0) {
+            return;
+        }
+        log.fatal(.console, "lightpanda", .{ .args = try serializeValues(values, page) });
+    }
+
+    pub fn _log(values: []js.Object, page: *Page) !void {
+        if (values.len == 0) {
+            return;
+        }
+        log.info(.console, "info", .{ .args = try serializeValues(values, page) });
+    }
+
+    pub fn _info(values: []js.Object, page: *Page) !void {
+        return _log(values, page);
+    }
+
+    pub fn _debug(values: []js.Object, page: *Page) !void {
+        if (values.len == 0) {
+            return;
+        }
+        log.debug(.console, "debug", .{ .args = try serializeValues(values, page) });
+    }
+
+    pub fn _warn(values: []js.Object, page: *Page) !void {
+        if (values.len == 0) {
+            return;
+        }
+        log.warn(.console, "warn", .{ .args = try serializeValues(values, page) });
+    }
+
+    pub fn _error(values: []js.Object, page: *Page) !void {
+        if (values.len == 0) {
+            return;
+        }
+
+        log.warn(.console, "error", .{
+            .args = try serializeValues(values, page),
+            .stack = page.stackTrace() catch "???",
+        });
+    }
+
+    pub fn _trace(values: []js.Object, page: *Page) !void {
+        if (values.len == 0) {
+            return;
+        }
+        log.debug(.console, "debug", .{
+            .stack = page.js.stackTrace() catch "???",
+            .args = try serializeValues(values, page),
+        });
+    }
+
+    pub fn _clear() void {}
+
+    pub fn _count(self: *Console, label_: ?[]const u8, page: *Page) !void {
+        const label = label_ orelse "default";
+        const gop = try self.counts.getOrPut(page.arena, label);
+
+        var current: u32 = 0;
+        if (gop.found_existing) {
+            current = gop.value_ptr.*;
+        } else {
+            gop.key_ptr.* = try page.arena.dupe(u8, label);
+        }
+
+        const count = current + 1;
+        gop.value_ptr.* = count;
+
+        log.info(.console, "count", .{ .label = label, .count = count });
+    }
+
+    pub fn _countReset(self: *Console, label_: ?[]const u8) !void {
+        const label = label_ orelse "default";
+        const kv = self.counts.fetchRemove(label) orelse {
+            log.info(.console, "invalid counter", .{ .label = label });
+            return;
+        };
+        log.info(.console, "count reset", .{ .label = label, .count = kv.value });
+    }
+
+    pub fn _time(self: *Console, label_: ?[]const u8, page: *Page) !void {
+        const label = label_ orelse "default";
+        const gop = try self.timers.getOrPut(page.arena, label);
+
+        if (gop.found_existing) {
+            log.info(.console, "duplicate timer", .{ .label = label });
+            return;
+        }
+        gop.key_ptr.* = try page.arena.dupe(u8, label);
+        gop.value_ptr.* = timestamp();
+    }
+
+    pub fn _timeLog(self: *Console, label_: ?[]const u8) void {
+        const elapsed = timestamp();
+        const label = label_ orelse "default";
+        const start = self.timers.get(label) orelse {
+            log.info(.console, "invalid timer", .{ .label = label });
+            return;
+        };
+        log.info(.console, "timer", .{ .label = label, .elapsed = elapsed - start });
+    }
+
+    pub fn _timeStop(self: *Console, label_: ?[]const u8) void {
+        const elapsed = timestamp();
+        const label = label_ orelse "default";
+        const kv = self.timers.fetchRemove(label) orelse {
+            log.info(.console, "invalid timer", .{ .label = label });
+            return;
+        };
+
+        log.warn(.console, "timer stop", .{ .label = label, .elapsed = elapsed - kv.value });
+    }
+
+    pub fn _assert(assertion: js.Object, values: []js.Object, page: *Page) !void {
+        if (assertion.isTruthy()) {
+            return;
+        }
+        var serialized_values: []const u8 = "";
+        if (values.len > 0) {
+            serialized_values = try serializeValues(values, page);
+        }
+        log.info(.console, "assertion failed", .{ .values = serialized_values });
+    }
+
+    fn serializeValues(values: []js.Object, page: *Page) ![]const u8 {
+        if (values.len == 0) {
+            return "";
+        }
+
+        const arena = page.call_arena;
+        const separator = log.separator();
+        var arr: std.ArrayListUnmanaged(u8) = .{};
+
+        for (values, 1..) |value, i| {
+            try arr.appendSlice(arena, separator);
+            try arr.writer(arena).print("{d}: ", .{i});
+            const serialized = if (builtin.mode == .Debug) value.toDetailString() else value.toString();
+            try arr.appendSlice(arena, try serialized);
+        }
+        return arr.items;
+    }
+};
+
+fn timestamp() u32 {
+    return @import("../../datetime.zig").timestamp();
+}

src/browser/crypto/crypto.zig

@@ -1,4 +1,4 @@
-// Copyright (C) 2023-2025  Lightpanda (Selecy SAS)
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
 //
 // Francis Bouvier <francis@lightpanda.io>
 // Pierre Tachoire <pierre@lightpanda.io>
@@ -18,35 +18,28 @@
 
 const std = @import("std");
 const js = @import("../js/js.zig");
+const uuidv4 = @import("../../id.zig").uuidv4;
 
-const SubtleCrypto = @import("SubtleCrypto.zig");
+// https://w3c.github.io/webcrypto/#crypto-interface
+pub const Crypto = struct {
+    _not_empty: bool = true,
 
-const Crypto = @This();
-_subtle: SubtleCrypto = .{},
-
-pub const init: Crypto = .{};
-
-// We take a js.Value, because we want to return the same instance, not a new
-// TypedArray
-pub fn getRandomValues(_: *const Crypto, js_obj: js.Object) !js.Object {
-    var into = try js_obj.toZig(RandomValues);
-    const buf = into.asBuffer();
-    if (buf.len > 65_536) {
-        return error.QuotaExceeded;
+    pub fn _getRandomValues(_: *const Crypto, js_obj: js.Object) !js.Object {
+        var into = try js_obj.toZig(Crypto, "getRandomValues", RandomValues);
+        const buf = into.asBuffer();
+        if (buf.len > 65_536) {
+            return error.QuotaExceededError;
+        }
+        std.crypto.random.bytes(buf);
+        return js_obj;
     }
-    std.crypto.random.bytes(buf);
-    return js_obj;
-}
 
-pub fn randomUUID(_: *const Crypto) ![36]u8 {
-    var hex: [36]u8 = undefined;
-    @import("../../id.zig").uuidv4(&hex);
-    return hex;
-}
-
-pub fn getSubtle(self: *Crypto) *SubtleCrypto {
-    return &self._subtle;
-}
+    pub fn _randomUUID(_: *const Crypto) [36]u8 {
+        var hex: [36]u8 = undefined;
+        uuidv4(&hex);
+        return hex;
+    }
+};
 
 const RandomValues = union(enum) {
     int8: []i8,
@@ -72,22 +65,7 @@ const RandomValues = union(enum) {
     }
 };
 
-pub const JsApi = struct {
-    pub const bridge = js.Bridge(Crypto);
-
-    pub const Meta = struct {
-        pub const name = "Crypto";
-        pub const prototype_chain = bridge.prototypeChain();
-        pub var class_id: bridge.ClassId = undefined;
-        pub const empty_with_no_proto = true;
-    };
-
-    pub const getRandomValues = bridge.function(Crypto.getRandomValues, .{ .dom_exception = true });
-    pub const randomUUID = bridge.function(Crypto.randomUUID, .{});
-    pub const subtle = bridge.accessor(Crypto.getSubtle, null, .{});
-};
-
 const testing = @import("../../testing.zig");
-test "WebApi: Crypto" {
-    try testing.htmlRunner("crypto.html", .{});
+test "Browser: Crypto" {
+    try testing.htmlRunner("crypto.html");
 }

src/browser/css/Parser.zig

@@ -1,295 +0,0 @@
-// Copyright (C) 2023-2025  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program 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 Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-const std = @import("std");
-const Tokenizer = @import("Tokenizer.zig");
-
-pub const Declaration = struct {
-    name: []const u8,
-    value: []const u8,
-    important: bool,
-};
-
-const TokenSpan = struct {
-    token: Tokenizer.Token,
-    start: usize,
-    end: usize,
-};
-
-const TokenStream = struct {
-    tokenizer: Tokenizer,
-    peeked: ?TokenSpan = null,
-
-    fn init(input: []const u8) TokenStream {
-        return .{ .tokenizer = .{ .input = input } };
-    }
-
-    fn nextRaw(self: *TokenStream) ?TokenSpan {
-        const start = self.tokenizer.position;
-        const token = self.tokenizer.next() orelse return null;
-        const end = self.tokenizer.position;
-        return .{ .token = token, .start = start, .end = end };
-    }
-
-    fn next(self: *TokenStream) ?TokenSpan {
-        if (self.peeked) |token| {
-            self.peeked = null;
-            return token;
-        }
-        return self.nextRaw();
-    }
-
-    fn peek(self: *TokenStream) ?TokenSpan {
-        if (self.peeked == null) {
-            self.peeked = self.nextRaw();
-        }
-        return self.peeked;
-    }
-};
-
-pub fn parseDeclarationsList(input: []const u8) DeclarationsIterator {
-    return DeclarationsIterator.init(input);
-}
-
-pub const DeclarationsIterator = struct {
-    input: []const u8,
-    stream: TokenStream,
-
-    pub fn init(input: []const u8) DeclarationsIterator {
-        return .{
-            .input = input,
-            .stream = TokenStream.init(input),
-        };
-    }
-
-    pub fn next(self: *DeclarationsIterator) ?Declaration {
-        while (true) {
-            self.skipTriviaAndSemicolons();
-            const peeked = self.stream.peek() orelse return null;
-
-            switch (peeked.token) {
-                .at_keyword => {
-                    _ = self.stream.next();
-                    self.skipAtRule();
-                },
-                .ident => |name| {
-                    _ = self.stream.next();
-                    if (self.consumeDeclaration(name)) |declaration| {
-                        return declaration;
-                    }
-                },
-                else => {
-                    _ = self.stream.next();
-                    self.skipInvalidDeclaration();
-                },
-            }
-        }
-
-        return null;
-    }
-
-    fn consumeDeclaration(self: *DeclarationsIterator, name: []const u8) ?Declaration {
-        self.skipTrivia();
-
-        const colon = self.stream.next() orelse return null;
-        if (!isColon(colon.token)) {
-            self.skipInvalidDeclaration();
-            return null;
-        }
-
-        const value = self.consumeValue() orelse return null;
-        return .{
-            .name = name,
-            .value = value.value,
-            .important = value.important,
-        };
-    }
-
-    const ValueResult = struct {
-        value: []const u8,
-        important: bool,
-    };
-
-    fn consumeValue(self: *DeclarationsIterator) ?ValueResult {
-        self.skipTrivia();
-
-        var depth: usize = 0;
-        var start: ?usize = null;
-        var last_sig: ?TokenSpan = null;
-        var prev_sig: ?TokenSpan = null;
-
-        while (true) {
-            const peeked = self.stream.peek() orelse break;
-            if (isSemicolon(peeked.token) and depth == 0) {
-                _ = self.stream.next();
-                break;
-            }
-
-            const span = self.stream.next() orelse break;
-            if (isWhitespaceOrComment(span.token)) {
-                continue;
-            }
-
-            if (start == null) start = span.start;
-            prev_sig = last_sig;
-            last_sig = span;
-            updateDepth(span.token, &depth);
-        }
-
-        const value_start = start orelse return null;
-        const last = last_sig orelse return null;
-
-        var important = false;
-        var end_pos = last.end;
-
-        if (isImportantPair(prev_sig, last)) {
-            important = true;
-            const bang = prev_sig orelse return null;
-            if (value_start >= bang.start) return null;
-            end_pos = bang.start;
-        }
-
-        var value_slice = self.input[value_start..end_pos];
-        value_slice = std.mem.trim(u8, value_slice, &std.ascii.whitespace);
-        if (value_slice.len == 0) return null;
-
-        return .{ .value = value_slice, .important = important };
-    }
-
-    fn skipTrivia(self: *DeclarationsIterator) void {
-        while (self.stream.peek()) |peeked| {
-            if (!isWhitespaceOrComment(peeked.token)) break;
-            _ = self.stream.next();
-        }
-    }
-
-    fn skipTriviaAndSemicolons(self: *DeclarationsIterator) void {
-        while (self.stream.peek()) |peeked| {
-            if (isWhitespaceOrComment(peeked.token) or isSemicolon(peeked.token)) {
-                _ = self.stream.next();
-            } else {
-                break;
-            }
-        }
-    }
-
-    fn skipAtRule(self: *DeclarationsIterator) void {
-        var depth: usize = 0;
-        var saw_block = false;
-
-        while (true) {
-            const peeked = self.stream.peek() orelse return;
-            if (!saw_block and isSemicolon(peeked.token) and depth == 0) {
-                _ = self.stream.next();
-                return;
-            }
-
-            const span = self.stream.next() orelse return;
-            if (isWhitespaceOrComment(span.token)) continue;
-
-            if (isBlockStart(span.token)) {
-                depth += 1;
-                saw_block = true;
-            } else if (isBlockEnd(span.token)) {
-                if (depth > 0) depth -= 1;
-                if (saw_block and depth == 0) return;
-            }
-        }
-    }
-
-    fn skipInvalidDeclaration(self: *DeclarationsIterator) void {
-        var depth: usize = 0;
-
-        while (self.stream.peek()) |peeked| {
-            if (isSemicolon(peeked.token) and depth == 0) {
-                _ = self.stream.next();
-                return;
-            }
-
-            const span = self.stream.next() orelse return;
-            if (isWhitespaceOrComment(span.token)) continue;
-            updateDepth(span.token, &depth);
-        }
-    }
-};
-
-fn isWhitespaceOrComment(token: Tokenizer.Token) bool {
-    return switch (token) {
-        .white_space, .comment => true,
-        else => false,
-    };
-}
-
-fn isSemicolon(token: Tokenizer.Token) bool {
-    return switch (token) {
-        .semicolon => true,
-        else => false,
-    };
-}
-
-fn isColon(token: Tokenizer.Token) bool {
-    return switch (token) {
-        .colon => true,
-        else => false,
-    };
-}
-
-fn isBlockStart(token: Tokenizer.Token) bool {
-    return switch (token) {
-        .curly_bracket_block, .square_bracket_block, .parenthesis_block, .function => true,
-        else => false,
-    };
-}
-
-fn isBlockEnd(token: Tokenizer.Token) bool {
-    return switch (token) {
-        .close_curly_bracket, .close_parenthesis, .close_square_bracket => true,
-        else => false,
-    };
-}
-
-fn updateDepth(token: Tokenizer.Token, depth: *usize) void {
-    if (isBlockStart(token)) {
-        depth.* += 1;
-        return;
-    }
-
-    if (isBlockEnd(token)) {
-        if (depth.* > 0) depth.* -= 1;
-    }
-}
-
-fn isImportantPair(prev_sig: ?TokenSpan, last_sig: TokenSpan) bool {
-    if (!isIdentImportant(last_sig.token)) return false;
-    const prev = prev_sig orelse return false;
-    return isBang(prev.token);
-}
-
-fn isIdentImportant(token: Tokenizer.Token) bool {
-    return switch (token) {
-        .ident => |name| std.ascii.eqlIgnoreCase(name, "important"),
-        else => false,
-    };
-}
-
-fn isBang(token: Tokenizer.Token) bool {
-    return switch (token) {
-        .delim => |c| c == '!',
-        else => false,
-    };
-}

src/browser/css/README.md

@@ -0,0 +1,218 @@
+# css
+
+Lightpanda css implements CSS selectors parsing and matching in Zig.
+This package is a port of the Go lib [andybalholm/cascadia](https://github.com/andybalholm/cascadia).
+
+## Usage
+
+### Query parser
+
+```zig
+const css = @import("css.zig");
+
+const selector = try css.parse(alloc, "h1", .{});
+defer selector.deinit(alloc);
+```
+
+### DOM tree match
+
+The lib expects a `Node` interface implementation to match your DOM tree.
+
+```zig
+pub const Node = struct {
+    pub fn firstChild(_: Node) !?Node {
+        return error.TODO;
+    }
+
+    pub fn lastChild(_: Node) !?Node {
+        return error.TODO;
+    }
+
+    pub fn nextSibling(_: Node) !?Node {
+        return error.TODO;
+    }
+
+    pub fn prevSibling(_: Node) !?Node {
+        return error.TODO;
+    }
+
+    pub fn parent(_: Node) !?Node {
+        return error.TODO;
+    }
+
+    pub fn isElement(_: Node) bool {
+        return false;
+    }
+
+    pub fn isDocument(_: Node) bool {
+        return false;
+    }
+
+    pub fn isComment(_: Node) bool {
+        return false;
+    }
+
+    pub fn isText(_: Node) bool {
+        return false;
+    }
+
+    pub fn isEmptyText(_: Node) !bool {
+        return error.TODO;
+    }
+
+    pub fn tag(_: Node) ![]const u8 {
+        return error.TODO;
+    }
+
+    pub fn attr(_: Node, _: []const u8) !?[]const u8 {
+        return error.TODO;
+    }
+
+    pub fn eql(_: Node, _: Node) bool {
+        return false;
+    }
+};
+```
+
+You also need do define a `Matcher` implementing a `match` function to
+accumulate the results.
+
+```zig
+const Matcher = struct {
+    const Nodes = std.ArrayList(Node);
+
+    nodes: Nodes,
+
+    fn init(alloc: std.mem.Allocator) Matcher {
+        return .{ .nodes = Nodes.init(alloc) };
+    }
+
+    fn deinit(m: *Matcher) void {
+        m.nodes.deinit();
+    }
+
+    pub fn match(m: *Matcher, n: Node) !void {
+        try m.nodes.append(n);
+    }
+};
+```
+
+Then you can use the lib itself.
+
+```zig
+var matcher = Matcher.init(alloc);
+defer matcher.deinit();
+
+try css.matchAll(selector, node, &matcher);
+_ = try css.matchFirst(selector, node, &matcher); // returns true if a node matched.
+```
+
+## Features
+
+* [x] parse query selector
+* [x] `matchAll`
+* [x] `matchFirst`
+* [ ] specificity
+
+### Selectors implemented
+
+#### Selectors
+
+* [x] Class selectors
+* [x] Id selectors
+* [x] Type selectors
+* [x] Universal selectors
+* [ ] Nesting selectors
+
+#### Combinators
+
+* [x] Child combinator
+* [ ] Column combinator
+* [x] Descendant combinator
+* [ ] Namespace combinator
+* [x] Next-sibling combinator
+* [x] Selector list combinator
+* [x] Subsequent-sibling combinator
+
+#### Attribute
+
+* [x] `[attr]`
+* [x] `[attr=value]`
+* [x] `[attr|=value]`
+* [x] `[attr^=value]`
+* [x] `[attr$=value]`
+* [ ] `[attr*=value]`
+* [x] `[attr operator value i]`
+* [ ] `[attr operator value s]`
+
+#### Pseudo classes
+
+* [ ] `:active`
+* [ ] `:any-link`
+* [ ] `:autofill`
+* [ ] `:blank Experimental`
+* [x] `:checked`
+* [ ] `:current Experimental`
+* [ ] `:default`
+* [ ] `:defined`
+* [ ] `:dir() Experimental`
+* [x] `:disabled`
+* [x] `:empty`
+* [x] `:enabled`
+* [ ] `:first`
+* [x] `:first-child`
+* [x] `:first-of-type`
+* [ ] `:focus`
+* [ ] `:focus-visible`
+* [ ] `:focus-within`
+* [ ] `:fullscreen`
+* [ ] `:future Experimental`
+* [x] `:has() Experimental`
+* [ ] `:host`
+* [ ] `:host()`
+* [ ] `:host-context() Experimental`
+* [ ] `:hover`
+* [ ] `:indeterminate`
+* [ ] `:in-range`
+* [ ] `:invalid`
+* [ ] `:is()`
+* [x] `:lang()`
+* [x] `:last-child`
+* [x] `:last-of-type`
+* [ ] `:left`
+* [x] `:link`
+* [ ] `:local-link Experimental`
+* [ ] `:modal`
+* [x] `:not()`
+* [x] `:nth-child()`
+* [x] `:nth-last-child()`
+* [x] `:nth-last-of-type()`
+* [x] `:nth-of-type()`
+* [x] `:only-child`
+* [x] `:only-of-type`
+* [ ] `:optional`
+* [ ] `:out-of-range`
+* [ ] `:past Experimental`
+* [ ] `:paused`
+* [ ] `:picture-in-picture`
+* [ ] `:placeholder-shown`
+* [ ] `:playing`
+* [ ] `:read-only`
+* [ ] `:read-write`
+* [ ] `:required`
+* [ ] `:right`
+* [x] `:root`
+* [ ] `:scope`
+* [ ] `:state() Experimental`
+* [ ] `:target`
+* [ ] `:target-within Experimental`
+* [ ] `:user-invalid Experimental`
+* [ ] `:valid`
+* [ ] `:visited`
+* [ ] `:where()`
+* [ ] `:contains()`
+* [ ] `:containsown()`
+* [ ] `:matched()`
+* [ ] `:matchesown()`
+* [x] `:root`
+

src/browser/css/Tokenizer.zig

@@ -1,825 +0,0 @@
-// Copyright (C) 2023-2025  Lightpanda (Selecy SAS)
-//
-// Francis Bouvier <francis@lightpanda.io>
-// Pierre Tachoire <pierre@lightpanda.io>
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Affero General Public License as
-// published by the Free Software Foundation, either version 3 of the
-// License, or (at your option) any later version.
-//
-// This program 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 Affero General Public License for more details.
-//
-// You should have received a copy of the GNU Affero General Public License
-// along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-//! This file implements the tokenization step defined in the CSS Syntax Module Level 3 specification.
-//!
-//! The algorithm accepts a valid UTF-8 string and returns a stream of tokens.
-//! The tokenization step never fails, even for complete gibberish.
-//! Validity must then be checked by the parser.
-//!
-//! NOTE: The tokenizer is not thread-safe and does not own any memory, and does not check the validity of utf8.
-//!
-//! See spec for more info: https://drafts.csswg.org/css-syntax/#tokenization
-
-const std = @import("std");
-const builtin = @import("builtin");
-const assert = std.debug.assert;
-
-const Tokenizer = @This();
-
-pub const Token = union(enum) {
-    /// A `<ident-token>`
-    ident: []const u8,
-
-    /// A `<function-token>`
-    ///
-    /// The value (name) does not include the `(` marker.
-    function: []const u8,
-
-    /// A `<at-keyword-token>`
-    ///
-    /// The value does not include the `@` marker.
-    at_keyword: []const u8,
-
-    /// A `<hash-token>` with the type flag set to "id"
-    ///
-    /// The value does not include the `#` marker.
-    id_hash: []const u8, // Hash that is a valid ID selector.
-
-    /// A `<hash-token>` with the type flag set to "unrestricted"
-    ///
-    /// The value does not include the `#` marker.
-    unrestricted_hash: []const u8,
-
-    /// A `<string-token>`
-    ///
-    /// The value does not include the quotes.
-    string: []const u8,
-
-    /// A `<bad-string-token>`
-    ///
-    /// This token always indicates a parse error.
-    bad_string: []const u8,
-
-    /// A `<url-token>`
-    ///
-    /// The value does not include the `url(` `)` markers.  Note that `url( <string-token> )` is represented by a
-    /// `Function` token.
-    url: []const u8,
-
-    /// A `<bad-url-token>`
-    ///
-    /// This token always indicates a parse error.
-    bad_url: []const u8,
-
-    /// A `<delim-token>`
-    delim: u8,
-
-    /// A `<number-token>`
-    number: struct {
-        /// Whether the number had a `+` or `-` sign.
-        ///
-        /// This is used is some cases like the <An+B> micro syntax. (See the `parse_nth` function.)
-        has_sign: bool,
-
-        /// If the origin source did not include a fractional part, the value as an integer.
-        int_value: ?i32,
-
-        /// The value as a float
-        value: f32,
-    },
-
-    /// A `<percentage-token>`
-    percentage: struct {
-        /// Whether the number had a `+` or `-` sign.
-        has_sign: bool,
-
-        /// If the origin source did not include a fractional part, the value as an integer.
-        /// It is **not** divided by 100.
-        int_value: ?i32,
-
-        /// The value as a float, divided by 100 so that the nominal range is 0.0 to 1.0.
-        unit_value: f32,
-    },
-
-    /// A `<dimension-token>`
-    dimension: struct {
-        /// Whether the number had a `+` or `-` sign.
-        ///
-        /// This is used is some cases like the <An+B> micro syntax. (See the `parse_nth` function.)
-        has_sign: bool,
-
-        /// If the origin source did not include a fractional part, the value as an integer.
-        int_value: ?i32,
-
-        /// The value as a float
-        value: f32,
-
-        /// The unit, e.g. "px" in `12px`
-        unit: []const u8,
-    },
-
-    /// A `<unicode-range-token>`
-    unicode_range: struct { bgn: u32, end: i32 },
-
-    /// A `<whitespace-token>`
-    white_space: []const u8,
-
-    /// A `<!--` `<CDO-token>`
-    cdo,
-
-    /// A `-->` `<CDC-token>`
-    cdc,
-
-    /// A `:` `<colon-token>`
-    colon, // :
-
-    /// A `;` `<semicolon-token>`
-    semicolon, // ;
-
-    /// A `,` `<comma-token>`
-    comma, // ,
-
-    /// A `<[-token>`
-    square_bracket_block,
-
-    /// A `<]-token>`
-    ///
-    /// When obtained from one of the `Parser::next*` methods,
-    /// this token is always unmatched and indicates a parse error.
-    close_square_bracket,
-
-    /// A `<(-token>`
-    parenthesis_block,
-
-    /// A `<)-token>`
-    ///
-    /// When obtained from one of the `Parser::next*` methods,
-    /// this token is always unmatched and indicates a parse error.
-    close_parenthesis,
-
-    /// A `<{-token>`
-    curly_bracket_block,
-
-    /// A `<}-token>`
-    ///
-    /// When obtained from one of the `Parser::next*` methods,
-    /// this token is always unmatched and indicates a parse error.
-    close_curly_bracket,
-
-    /// A comment.
-    ///
-    /// The CSS Syntax spec does not generate tokens for comments,
-    /// But we do for simplicity of the interface.
-    ///
-    /// The value does not include the `/*` `*/` markers.
-    comment: []const u8,
-};
-
-input: []const u8,
-
-/// Counted in bytes, not code points. From 0.
-position: usize = 0,
-
-// If true, the input has at least `n` bytes left *after* the current one.
-// That is, `Lexer.byteAt(n)` will not panic.
-fn hasAtLeast(self: *const Tokenizer, n: usize) bool {
-    return self.position + n < self.input.len;
-}
-
-fn isEof(self: *const Tokenizer) bool {
-    return !self.hasAtLeast(0);
-}
-
-fn byteAt(self: *const Tokenizer, offset: usize) u8 {
-    return self.input[self.position + offset];
-}
-
-// Assumes non-EOF
-fn nextByteUnchecked(self: *const Tokenizer) u8 {
-    return self.byteAt(0);
-}
-
-fn nextByte(self: *const Tokenizer) ?u8 {
-    return if (self.isEof())
-        null
-    else
-        self.input[self.position];
-}
-
-fn startsWith(self: *const Tokenizer, needle: []const u8) bool {
-    return std.mem.startsWith(u8, self.input[self.position..], needle);
-}
-
-fn slice(self: *const Tokenizer, start: usize, end: usize) []const u8 {
-    return self.input[start..end];
-}
-
-fn sliceFrom(self: *const Tokenizer, start_pos: usize) []const u8 {
-    return self.slice(start_pos, self.position);
-}
-
-// Advance over N bytes in the input.  This function can advance
-// over ASCII bytes (excluding newlines), or UTF-8 sequence
-// leaders (excluding leaders for 4-byte sequences).
-fn advance(self: *Tokenizer, n: usize) void {
-    if (builtin.mode == .Debug) {
-        // Each byte must either be an ASCII byte or a sequence leader,
-        // but not a 4-byte leader; also newlines are rejected.
-        for (0..n) |i| {
-            const b = self.byteAt(i);
-            assert(b != '\r' and b != '\n' and b != '\x0C');
-            assert(b <= 0x7F or (b & 0xF0 != 0xF0 and b & 0xC0 != 0x80));
-        }
-    }
-    self.position += n;
-}
-
-fn hasNewlineAt(self: *const Tokenizer, offset: usize) bool {
-    if (!self.hasAtLeast(offset)) return false;
-
-    return switch (self.byteAt(offset)) {
-        '\n', '\r', '\x0C' => true,
-        else => false,
-    };
-}
-
-fn hasNonAsciiAt(self: *const Tokenizer, offset: usize) bool {
-    if (!self.hasAtLeast(offset)) return false;
-
-    const byte = self.byteAt(offset);
-    const len_utf8 = std.unicode.utf8ByteSequenceLength(byte) catch return false;
-
-    if (!self.hasAtLeast(offset + len_utf8 - 1)) return false;
-
-    const start = self.position + offset;
-    const bytes = self.slice(start, start + len_utf8);
-
-    const codepoint = std.unicode.utf8Decode(bytes) catch return false;
-
-    // https://drafts.csswg.org/css-syntax/#non-ascii-ident-code-point
-    return switch (codepoint) {
-        '\u{00B7}', '\u{200C}', '\u{200D}', '\u{203F}', '\u{2040}' => true,
-        '\u{00C0}'...'\u{00D6}' => true,
-        '\u{00D8}'...'\u{00F6}' => true,
-        '\u{00F8}'...'\u{037D}' => true,
-        '\u{037F}'...'\u{1FFF}' => true,
-        '\u{2070}'...'\u{218F}' => true,
-        '\u{2C00}'...'\u{2FEF}' => true,
-        '\u{3001}'...'\u{D7FF}' => true,
-        '\u{F900}'...'\u{FDCF}' => true,
-        '\u{FDF0}'...'\u{FFFD}' => true,
-        else => codepoint >= '\u{10000}',
-    };
-}
-
-fn isIdentStart(self: *Tokenizer) bool {
-    if (self.isEof()) return false;
-
-    var b = self.nextByteUnchecked();
-    if (b == '-') {
-        b = if (self.hasAtLeast(1)) self.byteAt(1) else return false;
-    }
-
-    return switch (b) {
-        'a'...'z', 'A'...'Z', '_', 0x0 => true,
-        '\\' => !self.hasNewlineAt(1),
-        else => b > 0x7F, // not is ascii
-    };
-}
-
-fn consumeChar(self: *Tokenizer) void {
-    const byte = self.nextByteUnchecked();
-    const len_utf8 = std.unicode.utf8ByteSequenceLength(byte) catch 1;
-    self.position += len_utf8;
-}
-
-// Given that a newline has been seen, advance over the newline
-// and update the state.
-fn consumeNewline(self: *Tokenizer) void {
-    const byte = self.nextByteUnchecked();
-    assert(byte == '\r' or byte == '\n' or byte == '\x0C');
-
-    self.position += 1;
-    if (byte == '\r' and self.nextByte() == '\n') {
-        self.position += 1;
-    }
-}
-
-fn consumeWhiteSpace(self: *Tokenizer, newline: bool) Token {
-    const start_position = self.position;
-    if (newline) {
-        self.consumeNewline();
-    } else {
-        self.advance(1);
-    }
-    while (!self.isEof()) {
-        const b = self.nextByteUnchecked();
-        switch (b) {
-            ' ', '\t' => {
-                self.advance(1);
-            },
-            '\n', '\x0C', '\r' => {
-                self.consumeNewline();
-            },
-            else => break,
-        }
-    }
-    return .{ .white_space = self.sliceFrom(start_position) };
-}
-
-fn consumeComment(self: *Tokenizer) []const u8 {
-    self.advance(2); // consume "/*"
-    const start_position = self.position;
-    while (!self.isEof()) {
-        switch (self.nextByteUnchecked()) {
-            '*' => {
-                const end_position = self.position;
-                self.advance(1);
-                if (self.nextByte() == '/') {
-                    self.advance(1);
-                    return self.slice(start_position, end_position);
-                }
-            },
-            '\n', '\x0C', '\r' => {
-                self.consumeNewline();
-            },
-            0x0 => self.advance(1),
-            else => self.consumeChar(),
-        }
-    }
-    return self.sliceFrom(start_position);
-}
-
-fn byteToHexDigit(b: u8) ?u32 {
-    return switch (b) {
-        '0'...'9' => b - '0',
-        'a'...'f' => b - 'a' + 10,
-        'A'...'F' => b - 'A' + 10,
-        else => null,
-    };
-}
-
-fn byteToDecimalDigit(b: u8) ?u32 {
-    return if (std.ascii.isDigit(b)) b - '0' else null;
-}
-
-// (value, number of digits up to 6)
-fn consumeHexDigits(self: *Tokenizer) void {
-    var value: u32 = 0;
-    var digits: u32 = 0;
-
-    while (digits < 6 and !self.isEof()) {
-        if (byteToHexDigit(self.nextByteUnchecked())) |digit| {
-            value = value * 16 + digit;
-            digits += 1;
-            self.advance(1);
-        } else {
-            break;
-        }
-    }
-
-    _ = &value;
-}
-
-// Assumes that the U+005C REVERSE SOLIDUS (\) has already been consumed
-// and that the next input character has already been verified
-// to not be a newline.
-fn consumeEscape(self: *Tokenizer) void {
-    if (self.isEof())
-        return; // Escaped EOF
-
-    switch (self.nextByteUnchecked()) {
-        '0'...'9', 'A'...'F', 'a'...'f' => {
-            consumeHexDigits(self);
-
-            if (!self.isEof()) {
-                switch (self.nextByteUnchecked()) {
-                    ' ', '\t' => {
-                        self.advance(1);
-                    },
-                    '\n', '\x0C', '\r' => {
-                        self.consumeNewline();
-                    },
-                    else => {},
-                }
-            }
-        },
-        else => self.consumeChar(),
-    }
-}
-
-/// https://drafts.csswg.org/css-syntax/#consume-string-token
-fn consumeString(self: *Tokenizer, single_quote: bool) Token {
-    self.advance(1); // Skip the initial quote
-
-    // start_pos is at code point boundary, after " or '
-    const start_pos = self.position;
-
-    while (!self.isEof()) {
-        switch (self.nextByteUnchecked()) {
-            '"' => {
-                if (!single_quote) {
-                    const value = self.sliceFrom(start_pos);
-                    self.advance(1);
-                    return .{ .string = value };
-                }
-                self.advance(1);
-            },
-            '\'' => {
-                if (single_quote) {
-                    const value = self.sliceFrom(start_pos);
-                    self.advance(1);
-                    return .{ .string = value };
-                }
-                self.advance(1);
-            },
-            '\n', '\r', '\x0C' => {
-                return .{ .bad_string = self.sliceFrom(start_pos) };
-            },
-            '\\' => {
-                self.advance(1);
-                if (self.isEof())
-                    continue; // escaped EOF, do nothing.
-
-                switch (self.nextByteUnchecked()) {
-                    // Escaped newline
-                    '\n', '\x0C', '\r' => self.consumeNewline(),
-
-                    // Spec calls for replacing escape sequences with characters,
-                    // but this would require allocating a new string.
-                    // Therefore, we leave it as is and let the parser handle the escaping.
-                    else => self.consumeEscape(),
-                }
-            },
-            else => self.consumeChar(),
-        }
-    }
-
-    return .{ .string = self.sliceFrom(start_pos) };
-}
-
-fn consumeName(self: *Tokenizer) []const u8 {
-    // start_pos is the end of the previous token, therefore at a code point boundary
-    const start_pos = self.position;
-
-    while (!self.isEof()) {
-        switch (self.nextByteUnchecked()) {
-            'a'...'z', 'A'...'Z', '0'...'9', '_', '-' => self.advance(1),
-            '\\' => {
-                if (self.hasNewlineAt(1)) {
-                    break;
-                }
-
-                self.advance(1);
-                self.consumeEscape();
-            },
-            0x0 => self.advance(1),
-            '\x80'...'\xFF' => {
-                // Non-ASCII: advance over the complete UTF-8 code point in one step.
-                // Using consumeChar() instead of advance(1) ensures we never land on
-                // a continuation byte, which advance() asserts against.
-                self.consumeChar();
-            },
-            else => {
-                if (self.hasNonAsciiAt(0)) {
-                    self.consumeChar();
-                } else {
-                    break; // ASCII
-                }
-            },
-        }
-    }
-
-    return self.sliceFrom(start_pos);
-}
-
-fn consumeMark(self: *Tokenizer) Token {
-    const byte = self.nextByteUnchecked();
-    self.advance(1);
-    return switch (byte) {
-        ',' => .comma,
-        ':' => .colon,
-        ';' => .semicolon,
-        '(' => .parenthesis_block,
-        ')' => .close_parenthesis,
-        '{' => .curly_bracket_block,
-        '}' => .close_curly_bracket,
-        '[' => .square_bracket_block,
-        ']' => .close_square_bracket,
-        else => unreachable,
-    };
-}
-
-fn consumeNumeric(self: *Tokenizer) Token {
-    // Parse [+-]?\d*(\.\d+)?([eE][+-]?\d+)?
-    // But this is always called so that there is at least one digit in \d*(\.\d+)?
-
-    // Do all the math in f64 so that large numbers overflow to +/-inf
-    // and i32::{MIN, MAX} are within range.
-
-    var sign: f64 = 1.0;
-    var has_sign = false;
-    switch (self.nextByteUnchecked()) {
-        '+' => {
-            has_sign = true;
-        },
-        '-' => {
-            has_sign = true;
-            sign = -1.0;
-        },
-        else => {},
-    }
-    if (has_sign) {
-        self.advance(1);
-    }
-
-    var is_integer = true;
-    var integral_part: f64 = 0.0;
-    var fractional_part: f64 = 0.0;
-
-    while (!self.isEof()) {
-        if (byteToDecimalDigit(self.nextByteUnchecked())) |digit| {
-            integral_part = integral_part * 10.0 + @as(f64, @floatFromInt(digit));
-            self.advance(1);
-        } else {
-            break;
-        }
-    }
-
-    if (self.hasAtLeast(1) and self.nextByteUnchecked() == '.' and std.ascii.isDigit(self.byteAt(1))) {
-        is_integer = false;
-        self.advance(1); // Consume '.'
-
-        var factor: f64 = 0.1;
-        while (!self.isEof()) {
-            if (byteToDecimalDigit(self.nextByteUnchecked())) |digit| {
-                fractional_part += @as(f64, @floatFromInt(digit)) * factor;
-                factor *= 0.1;
-                self.advance(1);
-            } else {
-                break;
-            }
-        }
-    }
-
-    var value = sign * (integral_part + fractional_part);
-
-    blk: {
-        const e = self.nextByte() orelse break :blk;
-        if (e != 'e' and e != 'E') break :blk;
-
-        var mul: f64 = 1.0;
-
-        if (self.hasAtLeast(2) and (self.byteAt(1) == '+' or self.byteAt(1) == '-') and std.ascii.isDigit(self.byteAt(2))) {
-            mul = switch (self.byteAt(1)) {
-                '-' => -1.0,
-                '+' => 1.0,
-                else => unreachable,
-            };
-
-            self.advance(2);
-        } else if (self.hasAtLeast(2) and std.ascii.isDigit(self.byteAt(2))) {
-            self.advance(1);
-        } else {
-            break :blk;
-        }
-
-        is_integer = false;
-
-        var exponent: f64 = 0.0;
-        while (!self.isEof()) {
-            if (byteToDecimalDigit(self.nextByteUnchecked())) |digit| {
-                exponent = exponent * 10.0 + @as(f64, @floatFromInt(digit));
-                self.advance(1);
-            } else {
-                break;
-            }
-        }
-        value *= std.math.pow(f64, 10.0, mul * exponent);
-    }
-
-    const int_value: ?i32 = if (is_integer) blk: {
-        if (value >= std.math.maxInt(i32)) {
-            break :blk std.math.maxInt(i32);
-        }
-
-        if (value <= std.math.minInt(i32)) {
-            break :blk std.math.minInt(i32);
-        }
-
-        break :blk @as(i32, @intFromFloat(value));
-    } else null;
-
-    if (!self.isEof() and self.nextByteUnchecked() == '%') {
-        self.advance(1);
-
-        return .{ .percentage = .{
-            .has_sign = has_sign,
-            .int_value = int_value,
-            .unit_value = @as(f32, @floatCast(value / 100.0)),
-        } };
-    }
-
-    if (isIdentStart(self)) {
-        return .{ .dimension = .{
-            .has_sign = has_sign,
-            .int_value = int_value,
-            .value = @as(f32, @floatCast(value)),
-            .unit = consumeName(self),
-        } };
-    }
-
-    return .{ .number = .{
-        .has_sign = has_sign,
-        .int_value = int_value,
-        .value = @as(f32, @floatCast(value)),
-    } };
-}
-
-fn consumeUnquotedUrl(self: *Tokenizer) ?Token {
-    // TODO: true url parser
-    if (self.nextByte()) |it| {
-        return self.consumeString(it == '\'');
-    }
-
-    return null;
-}
-
-fn consumeIdentLike(self: *Tokenizer) Token {
-    const value = self.consumeName();
-
-    if (!self.isEof() and self.nextByteUnchecked() == '(') {
-        self.advance(1);
-
-        if (std.ascii.eqlIgnoreCase(value, "url")) {
-            if (self.consumeUnquotedUrl()) |result| {
-                return result;
-            }
-        }
-
-        return .{ .function = value };
-    }
-
-    return .{ .ident = value };
-}
-
-pub fn next(self: *Tokenizer) ?Token {
-    if (self.isEof()) {
-        return null;
-    }
-
-    const b = self.nextByteUnchecked();
-    return switch (b) {
-        // Consume comments
-        '/' => {
-            if (self.startsWith("/*")) {
-                return .{ .comment = self.consumeComment() };
-            } else {
-                self.advance(1);
-                return .{ .delim = '/' };
-            }
-        },
-
-        // Consume marks
-        '(', ')', '{', '}', '[', ']', ',', ':', ';' => {
-            return self.consumeMark();
-        },
-
-        // Consume as much whitespace as possible. Return a <whitespace-token>.
-        ' ', '\t' => self.consumeWhiteSpace(false),
-        '\n', '\x0C', '\r' => self.consumeWhiteSpace(true),
-
-        // Consume a string token and return it.
-        '"' => self.consumeString(false),
-        '\'' => self.consumeString(true),
-
-        '0'...'9' => self.consumeNumeric(),
-        'a'...'z', 'A'...'Z', '_', 0x0 => self.consumeIdentLike(),
-
-        '+' => {
-            if ((self.hasAtLeast(1) and std.ascii.isDigit(self.byteAt(1))) or
-                (self.hasAtLeast(2) and self.byteAt(1) == '.' and std.ascii.isDigit(self.byteAt(2))))
-            {
-                return self.consumeNumeric();
-            }
-            self.advance(1);
-            return .{ .delim = '+' };
-        },
-        '-' => {
-            if ((self.hasAtLeast(1) and std.ascii.isDigit(self.byteAt(1))) or
-                (self.hasAtLeast(2) and self.byteAt(1) == '.' and std.ascii.isDigit(self.byteAt(2))))
-            {
-                return self.consumeNumeric();
-            }
-
-            if (self.startsWith("-->")) {
-                self.advance(3);
-                return .cdc;
-            }
-
-            if (isIdentStart(self)) {
-                return self.consumeIdentLike();
-            }
-
-            self.advance(1);
-            return .{ .delim = '-' };
-        },
-        '.' => {
-            if (self.hasAtLeast(1) and std.ascii.isDigit(self.byteAt(1))) {
-                return self.consumeNumeric();
-            }
-            self.advance(1);
-            return .{ .delim = '.' };
-        },
-
-        // Consume hash token
-        '#' => {
-            self.advance(1);
-            if (self.isIdentStart()) {
-                return .{ .id_hash = self.consumeName() };
-            }
-            if (self.nextByte()) |it| {
-                switch (it) {
-                    // Any other valid case here already resulted in IDHash.
-                    '0'...'9', '-' => return .{ .unrestricted_hash = self.consumeName() },
-                    else => {},
-                }
-            }
-            return .{ .delim = '#' };
-        },
-
-        // Consume at-rules
-        '@' => {
-            self.advance(1);
-            return if (isIdentStart(self))
-                .{ .at_keyword = consumeName(self) }
-            else
-                .{ .delim = '@' };
-        },
-
-        '<' => {
-            if (self.startsWith("<!--")) {
-                self.advance(4);
-                return .cdo;
-            } else {
-                self.advance(1);
-                return .{ .delim = '<' };
-            }
-        },
-
-        '\\' => {
-            if (!self.hasNewlineAt(1)) {
-                return self.consumeIdentLike();
-            }
-
-            self.advance(1);
-            return .{ .delim = '\\' };
-        },
-
-        else => {
-            if (b > 0x7F) { // not is ascii
-                return self.consumeIdentLike();
-            }
-
-            self.advance(1);
-            return .{ .delim = b };
-        },
-    };
-}
-
-const testing = std.testing;
-
-fn expectTokensEqual(input: []const u8, tokens: []const Token) !void {
-    var lexer = Tokenizer{ .input = input };
-
-    var i: usize = 0;
-    while (lexer.next()) |token| : (i += 1) {
-        assert(i < tokens.len);
-        try testing.expectEqualDeep(tokens[i], token);
-    }
-
-    try testing.expectEqual(i, tokens.len);
-    try testing.expectEqualDeep(null, lexer.next());
-}
-
-test "smoke" {
-    try expectTokensEqual(
-        \\.lightpanda  {color:red;}
-    , &.{
-        .{ .delim = '.' },
-        .{ .ident = "lightpanda" },
-        .{ .white_space = "  " },
-        .curly_bracket_block,
-        .{ .ident = "color" },
-        .colon,
-        .{ .ident = "red" },
-        .semicolon,
-        .close_curly_bracket,
-    });
-}

src/browser/css/css.zig

@@ -0,0 +1,191 @@
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+// CSS Selector parser and query
+// This package is a rewrite in Zig of Cascadia CSS Selector parser.
+// see https://github.com/andybalholm/cascadia
+const std = @import("std");
+const Selector = @import("selector.zig").Selector;
+const parser = @import("parser.zig");
+
+pub const Interfaces = .{
+    Css,
+};
+
+// https://developer.mozilla.org/en-US/docs/Web/API/CSS
+pub const Css = struct {
+    _not_empty: bool = true,
+
+    pub fn _supports(_: *Css, _: []const u8, _: ?[]const u8) bool {
+        // TODO: Actually respond with which CSS features we support.
+        return true;
+    }
+};
+
+// parse parse a selector string and returns the parsed result or an error.
+pub fn parse(alloc: std.mem.Allocator, s: []const u8, opts: parser.ParseOptions) parser.ParseError!Selector {
+    var p = parser.Parser{ .s = s, .i = 0, .opts = opts };
+    return p.parse(alloc);
+}
+
+// matchFirst call m.match with the first node that matches the selector s, from the
+// descendants of n and returns true. If none matches, it returns false.
+pub fn matchFirst(s: *const Selector, node: anytype, m: anytype) !bool {
+    var child = node.firstChild();
+    while (child) |c| {
+        if (try s.match(c)) {
+            try m.match(c);
+            return true;
+        }
+
+        if (try matchFirst(s, c, m)) return true;
+        child = c.nextSibling();
+    }
+    return false;
+}
+
+// matchAll call m.match with the all the nodes that matches the selector s, from the
+// descendants of n.
+pub fn matchAll(s: *const Selector, node: anytype, m: anytype) !void {
+    var child = node.firstChild();
+    while (child) |c| {
+        if (try s.match(c)) try m.match(c);
+        try matchAll(s, c, m);
+        child = c.nextSibling();
+    }
+}
+
+test "parse" {
+    const alloc = std.testing.allocator;
+
+    const testcases = [_][]const u8{
+        "address",
+        "*",
+        "#foo",
+        "li#t1",
+        "*#t4",
+        ".t1",
+        "p.t1",
+        "div.teST",
+        ".t1.fail",
+        "p.t1.t2",
+        "p.--t1",
+        "p.--t1.--t2",
+        "p[title]",
+        "div[class=\"red\" i]",
+        "address[title=\"foo\"]",
+        "address[title=\"FoOIgnoRECaSe\" i]",
+        "address[title!=\"foo\"]",
+        "address[title!=\"foo\" i]",
+        "p[title!=\"FooBarUFoo\" i]",
+        "[  \t title        ~=       foo    ]",
+        "p[title~=\"FOO\" i]",
+        "p[title~=toofoo i]",
+        "[title~=\"hello world\"]",
+        "[title~=\"hello\" i]",
+        "[title~=\"hello\"          I]",
+        "[lang|=\"en\"]",
+        "[lang|=\"EN\" i]",
+        "[lang|=\"EN\"     i]",
+        "[title^=\"foo\"]",
+        "[title^=\"foo\" i]",
+        "[title$=\"bar\"]",
+        "[title$=\"BAR\" i]",
+        "[title*=\"bar\"]",
+        "[title*=\"BaRu\" i]",
+        "[title*=\"BaRu\" I]",
+        "p[class$=\" \"]",
+        "p[class$=\"\"]",
+        "p[class^=\" \"]",
+        "p[class^=\"\"]",
+        "p[class*=\" \"]",
+        "p[class*=\"\"]",
+        "input[name=Sex][value=F]",
+        "table[border=\"0\"][cellpadding=\"0\"][cellspacing=\"0\"]",
+        ".t1:not(.t2)",
+        "div:not(.t1)",
+        "div:not([class=\"t2\"])",
+        "li:nth-child(odd)",
+        "li:nth-child(even)",
+        "li:nth-child(-n+2)",
+        "li:nth-child(3n+1)",
+        "li:nth-last-child(odd)",
+        "li:nth-last-child(even)",
+        "li:nth-last-child(-n+2)",
+        "li:nth-last-child(3n+1)",
+        "span:first-child",
+        "span:last-child",
+        "p:nth-of-type(2)",
+        "p:nth-last-of-type(2)",
+        "p:last-of-type",
+        "p:first-of-type",
+        "p:only-child",
+        "p:only-of-type",
+        ":empty",
+        "div p",
+        "div table p",
+        "div > p",
+        "p ~ p",
+        "p + p",
+        "li, p",
+        "p +/*This is a comment*/ p",
+        "p:contains(\"that wraps\")",
+        "p:containsOwn(\"that wraps\")",
+        ":containsOwn(\"inner\")",
+        "p:containsOwn(\"block\")",
+        "div:has(#p1)",
+        "div:has(:containsOwn(\"2\"))",
+        "body :has(:containsOwn(\"2\"))",
+        "body :haschild(:containsOwn(\"2\"))",
+        "p:matches([\\d])",
+        "p:matches([a-z])",
+        "p:matches([a-zA-Z])",
+        "p:matches([^\\d])",
+        "p:matches(^(0|a))",
+        "p:matches(^\\d+$)",
+        "p:not(:matches(^\\d+$))",
+        "div :matchesOwn(^\\d+$)",
+        "[href#=(fina)]:not([href#=(\\/\\/[^\\/]+untrusted)])",
+        "[href#=(^https:\\/\\/[^\\/]*\\/?news)]",
+        ":input",
+        ":root",
+        "*:root",
+        "html:nth-child(1)",
+        "*:root:first-child",
+        "*:root:nth-child(1)",
+        "a:not(:root)",
+        "body > *:nth-child(3n+2)",
+        "input:disabled",
+        ":disabled",
+        ":enabled",
+        "div.class1, div.class2",
+    };
+
+    for (testcases) |tc| {
+        const s = parse(alloc, tc, .{}) catch |e| {
+            std.debug.print("query {s}", .{tc});
+            return e;
+        };
+        defer s.deinit(alloc);
+    }
+}
+
+const testing = @import("../../testing.zig");
+test "Browser: CSS" {
+    try testing.htmlRunner("css.html");
+}

src/browser/css/libdom.zig

@@ -0,0 +1,423 @@
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const std = @import("std");
+
+const parser = @import("../netsurf.zig");
+const css = @import("css.zig");
+const Allocator = std.mem.Allocator;
+
+// Node implementation with Netsurf Libdom C lib.
+pub const Node = struct {
+    node: *parser.Node,
+
+    pub fn firstChild(n: Node) ?Node {
+        const c = parser.nodeFirstChild(n.node);
+        if (c) |cc| return .{ .node = cc };
+
+        return null;
+    }
+
+    pub fn lastChild(n: Node) ?Node {
+        const c = parser.nodeLastChild(n.node);
+        if (c) |cc| return .{ .node = cc };
+
+        return null;
+    }
+
+    pub fn nextSibling(n: Node) ?Node {
+        const c = parser.nodeNextSibling(n.node);
+        if (c) |cc| return .{ .node = cc };
+
+        return null;
+    }
+
+    pub fn prevSibling(n: Node) ?Node {
+        const c = parser.nodePreviousSibling(n.node);
+        if (c) |cc| return .{ .node = cc };
+
+        return null;
+    }
+
+    pub fn parent(n: Node) ?Node {
+        const c = parser.nodeParentNode(n.node);
+        if (c) |cc| return .{ .node = cc };
+
+        return null;
+    }
+
+    pub fn isElement(n: Node) bool {
+        return parser.nodeType(n.node) == .element;
+    }
+
+    pub fn isDocument(n: Node) bool {
+        return parser.nodeType(n.node) == .document;
+    }
+
+    pub fn isComment(n: Node) bool {
+        return parser.nodeType(n.node) == .comment;
+    }
+
+    pub fn isText(n: Node) bool {
+        return parser.nodeType(n.node) == .text;
+    }
+
+    pub fn text(n: Node) ?[]const u8 {
+        const data = parser.nodeTextContent(n.node);
+        if (data == null) return null;
+        if (data.?.len == 0) return null;
+
+        return std.mem.trim(u8, data.?, &std.ascii.whitespace);
+    }
+
+    pub fn isEmptyText(n: Node) bool {
+        const data = parser.nodeTextContent(n.node);
+        if (data == null) return true;
+        if (data.?.len == 0) return true;
+
+        return std.mem.trim(u8, data.?, &std.ascii.whitespace).len == 0;
+    }
+
+    pub fn tag(n: Node) ![]const u8 {
+        return parser.nodeName(n.node);
+    }
+
+    pub fn attr(n: Node, key: []const u8) !?[]const u8 {
+        if (!n.isElement()) return null;
+        return try parser.elementGetAttribute(parser.nodeToElement(n.node), key);
+    }
+
+    pub fn eql(a: Node, b: Node) bool {
+        return a.node == b.node;
+    }
+};
+
+const MatcherTest = struct {
+    const Nodes = std.ArrayListUnmanaged(Node);
+
+    nodes: Nodes,
+    allocator: Allocator,
+
+    fn init(allocator: Allocator) MatcherTest {
+        return .{
+            .nodes = .empty,
+            .allocator = allocator,
+        };
+    }
+
+    fn deinit(m: *MatcherTest) void {
+        m.nodes.deinit(m.allocator);
+    }
+
+    fn reset(m: *MatcherTest) void {
+        m.nodes.clearRetainingCapacity();
+    }
+
+    pub fn match(m: *MatcherTest, n: Node) !void {
+        try m.nodes.append(m.allocator, n);
+    }
+};
+
+test "Browser.CSS.Libdom: matchFirst" {
+    const alloc = std.testing.allocator;
+
+    parser.init();
+    defer parser.deinit();
+
+    var matcher = MatcherTest.init(alloc);
+    defer matcher.deinit();
+
+    const testcases = [_]struct {
+        q: []const u8,
+        html: []const u8,
+        exp: usize,
+    }{
+        .{ .q = "address", .html = "<body><address>This address...</address></body>", .exp = 1 },
+        .{ .q = "*", .html = "<!-- comment --><html><head></head><body>text</body></html>", .exp = 1 },
+        .{ .q = "*", .html = "<html><head></head><body></body></html>", .exp = 1 },
+        .{ .q = "#foo", .html = "<p id=\"foo\"><p id=\"bar\">", .exp = 1 },
+        .{ .q = "li#t1", .html = "<ul><li id=\"t1\"><p id=\"t1\">", .exp = 1 },
+        .{ .q = ".t3", .html = "<ul><li class=\"t1\"><li class=\"t2 t3\">", .exp = 1 },
+        .{ .q = "*#t4", .html = "<ol><li id=\"t4\"><li id=\"t44\">", .exp = 1 },
+        .{ .q = ".t1", .html = "<ul><li class=\"t1\"><li class=\"t2\">", .exp = 1 },
+        .{ .q = "p.t1", .html = "<p class=\"t1 t2\">", .exp = 1 },
+        .{ .q = "div.teST", .html = "<div class=\"test\">", .exp = 0 },
+        .{ .q = ".t1.fail", .html = "<p class=\"t1 t2\">", .exp = 0 },
+        .{ .q = "p.t1.t2", .html = "<p class=\"t1 t2\">", .exp = 1 },
+        .{ .q = "p.--t1", .html = "<p class=\"--t1 --t2\">", .exp = 1 },
+        .{ .q = "p.--t1.--t2", .html = "<p class=\"--t1 --t2\">", .exp = 1 },
+        .{ .q = "p[title]", .html = "<p><p title=\"title\">", .exp = 1 },
+        .{ .q = "div[class=\"red\" i]", .html = "<div><div class=\"Red\">", .exp = 1 },
+        .{ .q = "address[title=\"foo\"]", .html = "<address><address title=\"foo\"><address title=\"bar\">", .exp = 1 },
+        .{ .q = "address[title=\"FoOIgnoRECaSe\" i]", .html = "<address><address title=\"fooIgnoreCase\"><address title=\"bar\">", .exp = 1 },
+        .{ .q = "address[title!=\"foo\"]", .html = "<address><address title=\"foo\"><address title=\"bar\">", .exp = 1 },
+        .{ .q = "address[title!=\"foo\" i]", .html = "<address><address title=\"FOO\"><address title=\"bar\">", .exp = 1 },
+        .{ .q = "p[title!=\"FooBarUFoo\" i]", .html = "<p title=\"fooBARuFOO\"><p title=\"varfoo\">", .exp = 1 },
+        .{ .q = "[   title        ~=       foo    ]", .html = "<p title=\"tot foo bar\">", .exp = 1 },
+        .{ .q = "p[title~=\"FOO\" i]", .html = "<p title=\"tot foo bar\">", .exp = 1 },
+        .{ .q = "p[title~=toofoo i]", .html = "<p title=\"tot foo bar\">", .exp = 0 },
+        .{ .q = "[title~=\"hello world\"]", .html = "<p title=\"hello world\">", .exp = 0 },
+        .{ .q = "[title~=\"hello\" i]", .html = "<p title=\"HELLO world\">", .exp = 1 },
+        .{ .q = "[title~=\"hello\"          I]", .html = "<p title=\"HELLO world\">", .exp = 1 },
+        .{ .q = "[lang|=\"en\"]", .html = "<p lang=\"en\"><p lang=\"en-gb\"><p lang=\"enough\"><p lang=\"fr-en\">", .exp = 1 },
+        .{ .q = "[lang|=\"EN\" i]", .html = "<p lang=\"en\"><p lang=\"En-gb\"><p lang=\"enough\"><p lang=\"fr-en\">", .exp = 1 },
+        .{ .q = "[lang|=\"EN\"     i]", .html = "<p lang=\"en\"><p lang=\"En-gb\"><p lang=\"enough\"><p lang=\"fr-en\">", .exp = 1 },
+        .{ .q = "[title^=\"foo\"]", .html = "<p title=\"foobar\"><p title=\"barfoo\">", .exp = 1 },
+        .{ .q = "[title^=\"foo\" i]", .html = "<p title=\"FooBAR\"><p title=\"barfoo\">", .exp = 1 },
+        .{ .q = "[title$=\"bar\"]", .html = "<p title=\"foobar\"><p title=\"barfoo\">", .exp = 1 },
+        .{ .q = "[title$=\"BAR\" i]", .html = "<p title=\"foobar\"><p title=\"barfoo\">", .exp = 1 },
+        .{ .q = "[title*=\"bar\"]", .html = "<p title=\"foobarufoo\">", .exp = 1 },
+        .{ .q = "[title*=\"BaRu\" i]", .html = "<p title=\"foobarufoo\">", .exp = 1 },
+        .{ .q = "[title*=\"BaRu\" I]", .html = "<p title=\"foobarufoo\">", .exp = 1 },
+        .{ .q = "p[class$=\" \"]", .html = "<p class=\" \">This text should be green.</p><p>This text should be green.</p>", .exp = 0 },
+        .{ .q = "p[class$=\"\"]", .html = "<p class=\"\">This text should be green.</p><p>This text should be green.</p>", .exp = 0 },
+        .{ .q = "p[class^=\" \"]", .html = "<p class=\" \">This text should be green.</p><p>This text should be green.</p>", .exp = 0 },
+        .{ .q = "p[class^=\"\"]", .html = "<p class=\"\">This text should be green.</p><p>This text should be green.</p>", .exp = 0 },
+        .{ .q = "p[class*=\" \"]", .html = "<p class=\" \">This text should be green.</p><p>This text should be green.</p>", .exp = 0 },
+        .{ .q = "p[class*=\"\"]", .html = "<p class=\"\">This text should be green.</p><p>This text should be green.</p>", .exp = 0 },
+        .{ .q = "input[name=Sex][value=F]", .html = "<input type=\"radio\" name=\"Sex\" value=\"F\"/>", .exp = 1 },
+        .{ .q = "table[border=\"0\"][cellpadding=\"0\"][cellspacing=\"0\"]", .html = "<table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" style=\"table-layout: fixed; width: 100%; border: 0 dashed; border-color: #FFFFFF\"><tr style=\"height:64px\">aaa</tr></table>", .exp = 1 },
+        .{ .q = ".t1:not(.t2)", .html = "<p class=\"t1 t2\">", .exp = 0 },
+        .{ .q = "div:not(.t1)", .html = "<div class=\"t3\">", .exp = 1 },
+        .{ .q = "div:not([class=\"t2\"])", .html = "<div><div class=\"t2\"><div class=\"t3\">", .exp = 1 },
+        .{ .q = "li:nth-child(odd)", .html = "<ol><li id=1><li id=2><li id=3></ol>", .exp = 1 },
+        .{ .q = "li:nth-child(even)", .html = "<ol><li id=1><li id=2><li id=3></ol>", .exp = 1 },
+        .{ .q = "li:nth-child(-n+2)", .html = "<ol><li id=1><li id=2><li id=3></ol>", .exp = 1 },
+        .{ .q = "li:nth-child(3n+1)", .html = "<ol><li id=1><li id=2><li id=3></ol>", .exp = 1 },
+        .{ .q = "li:nth-last-child(odd)", .html = "<ol><li id=1><li id=2><li id=3><li id=4></ol>", .exp = 1 },
+        .{ .q = "li:nth-last-child(even)", .html = "<ol><li id=1><li id=2><li id=3><li id=4></ol>", .exp = 1 },
+        .{ .q = "li:nth-last-child(-n+2)", .html = "<ol><li id=1><li id=2><li id=3><li id=4></ol>", .exp = 1 },
+        .{ .q = "li:nth-last-child(3n+1)", .html = "<ol><li id=1><li id=2><li id=3><li id=4></ol>", .exp = 1 },
+        .{ .q = "span:first-child", .html = "<p>some text <span id=\"1\">and a span</span><span id=\"2\"> and another</span></p>", .exp = 1 },
+        .{ .q = "span:last-child", .html = "<span>a span</span> and some text", .exp = 1 },
+        .{ .q = "p:nth-of-type(2)", .html = "<address></address><p id=1><p id=2>", .exp = 1 },
+        .{ .q = "p:nth-last-of-type(2)", .html = "<address></address><p id=1><p id=2></p><a>", .exp = 1 },
+        .{ .q = "p:last-of-type", .html = "<address></address><p id=1><p id=2></p><a>", .exp = 1 },
+        .{ .q = "p:first-of-type", .html = "<address></address><p id=1><p id=2></p><a>", .exp = 1 },
+        .{ .q = "p:only-child", .html = "<div><p id=\"1\"></p><a></a></div><div><p id=\"2\"></p></div>", .exp = 1 },
+        .{ .q = "p:only-of-type", .html = "<div><p id=\"1\"></p><a></a></div><div><p id=\"2\"></p><p id=\"3\"></p></div>", .exp = 1 },
+        .{ .q = ":empty", .html = "<p id=\"1\"><!-- --><p id=\"2\">Hello<p id=\"3\"><span>", .exp = 1 },
+        .{ .q = "div p", .html = "<div><p id=\"1\"><table><tr><td><p id=\"2\"></table></div><p id=\"3\">", .exp = 1 },
+        .{ .q = "div table p", .html = "<div><p id=\"1\"><table><tr><td><p id=\"2\"></table></div><p id=\"3\">", .exp = 1 },
+        .{ .q = "div > p", .html = "<div><p id=\"1\"><div><p id=\"2\"></div><table><tr><td><p id=\"3\"></table></div>", .exp = 1 },
+        .{ .q = "p ~ p", .html = "<p id=\"1\"><p id=\"2\"></p><address></address><p id=\"3\">", .exp = 1 },
+        .{ .q = "p + p", .html = "<p id=\"1\"></p> <!--comment--> <p id=\"2\"></p><address></address><p id=\"3\">", .exp = 1 },
+        .{ .q = "li, p", .html = "<ul><li></li><li></li></ul><p>", .exp = 1 },
+        .{ .q = "p +/*This is a comment*/ p", .html = "<p id=\"1\"><p id=\"2\"></p><address></address><p id=\"3\">", .exp = 1 },
+        // .{ .q = "p:contains(\"that wraps\")", .html = "<p>Text block that <span>wraps inner text</span> and continues</p>", .exp = 1 },
+        .{ .q = "p:containsOwn(\"that wraps\")", .html = "<p>Text block that <span>wraps inner text</span> and continues</p>", .exp = 0 },
+        .{ .q = ":containsOwn(\"inner\")", .html = "<p>Text block that <span>wraps inner text</span> and continues</p>", .exp = 1 },
+        .{ .q = ":containsOwn(\"Inner\")", .html = "<p>Text block that <span>wraps inner text</span> and continues</p>", .exp = 0 },
+        .{ .q = "p:containsOwn(\"block\")", .html = "<p>Text block that <span>wraps inner text</span> and continues</p>", .exp = 1 },
+        // .{ .q = "div:has(#p1)", .html = "<div id=\"d1\"><p id=\"p1\"><span>text content</span></p></div><div id=\"d2\"/>", .exp = 1 },
+        .{ .q = "div:has(:containsOwn(\"2\"))", .html = "<div id=\"d1\"><p id=\"p1\"><span>contents 1</span></p></div> <div id=\"d2\"><p>contents <em>2</em></p></div>", .exp = 1 },
+        .{ .q = "body :has(:containsOwn(\"2\"))", .html = "<body><div id=\"d1\"><p id=\"p1\"><span>contents 1</span></p></div> <div id=\"d2\"><p id=\"p2\">contents <em>2</em></p></div></body>", .exp = 1 },
+        .{ .q = "body :haschild(:containsOwn(\"2\"))", .html = "<body><div id=\"d1\"><p id=\"p1\"><span>contents 1</span></p></div> <div id=\"d2\"><p id=\"p2\">contents <em>2</em></p></div></body>", .exp = 1 },
+        // .{ .q = "p:matches([\\d])", .html = "<p id=\"p1\">0123456789</p><p id=\"p2\">abcdef</p><p id=\"p3\">0123ABCD</p>", .exp = 1 },
+        // .{ .q = "p:matches([a-z])", .html = "<p id=\"p1\">0123456789</p><p id=\"p2\">abcdef</p><p id=\"p3\">0123ABCD</p>", .exp = 1 },
+        // .{ .q = "p:matches([a-zA-Z])", .html = "<p id=\"p1\">0123456789</p><p id=\"p2\">abcdef</p><p id=\"p3\">0123ABCD</p>", .exp = 1 },
+        // .{ .q = "p:matches([^\\d])", .html = "<p id=\"p1\">0123456789</p><p id=\"p2\">abcdef</p><p id=\"p3\">0123ABCD</p>", .exp = 1 },
+        // .{ .q = "p:matches(^(0|a))", .html = "<p id=\"p1\">0123456789</p><p id=\"p2\">abcdef</p><p id=\"p3\">0123ABCD</p>", .exp = 1 },
+        // .{ .q = "p:matches(^\\d+$)", .html = "<p id=\"p1\">0123456789</p><p id=\"p2\">abcdef</p><p id=\"p3\">0123ABCD</p>", .exp = 1 },
+        // .{ .q = "p:not(:matches(^\\d+$))", .html = "<p id=\"p1\">0123456789</p><p id=\"p2\">abcdef</p><p id=\"p3\">0123ABCD</p>", .exp = 1 },
+        // .{ .q = "div :matchesOwn(^\\d+$)", .html = "<div><p id=\"p1\">01234<em>567</em>89</p><div>", .exp = 1 },
+        // .{ .q = "[href#=(fina)]:not([href#=(\\/\\/[^\\/]+untrusted)])", .html = "<ul> <li><a id=\"a1\" href=\"http://www.google.com/finance\"></a> <li><a id=\"a2\" href=\"http://finance.yahoo.com/\"></a> <li><a id=\"a2\" href=\"http://finance.untrusted.com/\"/> <li><a id=\"a3\" href=\"https://www.google.com/news\"/> <li><a id=\"a4\" href=\"http://news.yahoo.com\"/> </ul>", .exp = 1 },
+        // .{ .q = "[href#=(^https:\\/\\/[^\\/]*\\/?news)]", .html = "<ul> <li><a id=\"a1\" href=\"http://www.google.com/finance\"/> <li><a id=\"a2\" href=\"http://finance.yahoo.com/\"/> <li><a id=\"a3\" href=\"https://www.google.com/news\"></a> <li><a id=\"a4\" href=\"http://news.yahoo.com\"/> </ul>", .exp = 1 },
+        .{ .q = ":input", .html = "<form> <label>Username <input type=\"text\" name=\"username\" /></label> <label>Password <input type=\"password\" name=\"password\" /></label> <label>Country <select name=\"country\"> <option value=\"ca\">Canada</option> <option value=\"us\">United States</option> </select> </label> <label>Bio <textarea name=\"bio\"></textarea></label> <button>Sign up</button> </form>", .exp = 1 },
+        .{ .q = ":root", .html = "<html><head></head><body></body></html>", .exp = 1 },
+        .{ .q = "*:root", .html = "<html><head></head><body></body></html>", .exp = 1 },
+        .{ .q = "html:nth-child(1)", .html = "<html><head></head><body></body></html>", .exp = 1 },
+        .{ .q = "*:root:first-child", .html = "<html><head></head><body></body></html>", .exp = 1 },
+        .{ .q = "*:root:nth-child(1)", .html = "<html><head></head><body></body></html>", .exp = 1 },
+        .{ .q = "a:not(:root)", .html = "<html><head></head><body><a href=\"http://www.foo.com\"></a></body></html>", .exp = 1 },
+        .{ .q = "body > *:nth-child(3n+2)", .html = "<html><head></head><body><p></p><div></div><span></span><a></a><form></form></body></html>", .exp = 1 },
+        .{ .q = "input:disabled", .html = "<html><head></head><body><fieldset disabled><legend id=\"1\"><input id=\"i1\"/></legend><legend id=\"2\"><input id=\"i2\"/></legend></fieldset></body></html>", .exp = 1 },
+        .{ .q = ":disabled", .html = "<html><head></head><body><fieldset disabled></fieldset></body></html>", .exp = 1 },
+        .{ .q = ":enabled", .html = "<html><head></head><body><fieldset></fieldset></body></html>", .exp = 1 },
+        .{ .q = "div.class1, div.class2", .html = "<div class=class1></div><div class=class2></div><div class=class3></div>", .exp = 1 },
+    };
+
+    for (testcases) |tc| {
+        matcher.reset();
+
+        const doc = try parser.documentHTMLParseFromStr(tc.html);
+        defer parser.documentHTMLClose(doc) catch {};
+
+        const s = css.parse(alloc, tc.q, .{}) catch |e| {
+            std.debug.print("parse, query: {s}\n", .{tc.q});
+            return e;
+        };
+
+        defer s.deinit(alloc);
+
+        const node = Node{ .node = parser.documentHTMLToNode(doc) };
+
+        _ = css.matchFirst(&s, node, &matcher) catch |e| {
+            std.debug.print("match, query: {s}\n", .{tc.q});
+            return e;
+        };
+        std.testing.expectEqual(tc.exp, matcher.nodes.items.len) catch |e| {
+            std.debug.print("expectation, query: {s}\n", .{tc.q});
+            return e;
+        };
+    }
+}
+
+test "Browser.CSS.Libdom: matchAll" {
+    const alloc = std.testing.allocator;
+
+    parser.init();
+    defer parser.deinit();
+
+    var matcher = MatcherTest.init(alloc);
+    defer matcher.deinit();
+
+    const testcases = [_]struct {
+        q: []const u8,
+        html: []const u8,
+        exp: usize,
+    }{
+        .{ .q = "address", .html = "<body><address>This address...</address></body>", .exp = 1 },
+        .{ .q = "*", .html = "<!-- comment --><html><head></head><body>text</body></html>", .exp = 3 },
+        .{ .q = "*", .html = "<html><head></head><body></body></html>", .exp = 3 },
+        .{ .q = "#foo", .html = "<p id=\"foo\"><p id=\"bar\">", .exp = 1 },
+        .{ .q = "li#t1", .html = "<ul><li id=\"t1\"><p id=\"t1\">", .exp = 1 },
+        .{ .q = ".t3", .html = "<ul><li class=\"t1\"><li class=\"t2 t3\">", .exp = 1 },
+        .{ .q = "*#t4", .html = "<ol><li id=\"t4\"><li id=\"t44\">", .exp = 1 },
+        .{ .q = ".t1", .html = "<ul><li class=\"t1\"><li class=\"t2\">", .exp = 1 },
+        .{ .q = "p.t1", .html = "<p class=\"t1 t2\">", .exp = 1 },
+        .{ .q = "div.teST", .html = "<div class=\"test\">", .exp = 0 },
+        .{ .q = ".t1.fail", .html = "<p class=\"t1 t2\">", .exp = 0 },
+        .{ .q = "p.t1.t2", .html = "<p class=\"t1 t2\">", .exp = 1 },
+        .{ .q = "p.--t1", .html = "<p class=\"--t1 --t2\">", .exp = 1 },
+        .{ .q = "p.--t1.--t2", .html = "<p class=\"--t1 --t2\">", .exp = 1 },
+        .{ .q = "p[title]", .html = "<p><p title=\"title\">", .exp = 1 },
+        .{ .q = "div[class=\"red\" i]", .html = "<div><div class=\"Red\">", .exp = 1 },
+        .{ .q = "address[title=\"foo\"]", .html = "<address><address title=\"foo\"><address title=\"bar\">", .exp = 1 },
+        .{ .q = "address[title=\"FoOIgnoRECaSe\" i]", .html = "<address><address title=\"fooIgnoreCase\"><address title=\"bar\">", .exp = 1 },
+        .{ .q = "address[title!=\"foo\"]", .html = "<address><address title=\"foo\"><address title=\"bar\">", .exp = 2 },
+        .{ .q = "address[title!=\"foo\" i]", .html = "<address><address title=\"FOO\"><address title=\"bar\">", .exp = 2 },
+        .{ .q = "p[title!=\"FooBarUFoo\" i]", .html = "<p title=\"fooBARuFOO\"><p title=\"varfoo\">", .exp = 1 },
+        .{ .q = "[   title        ~=       foo    ]", .html = "<p title=\"tot foo bar\">", .exp = 1 },
+        .{ .q = "p[title~=\"FOO\" i]", .html = "<p title=\"tot foo bar\">", .exp = 1 },
+        .{ .q = "p[title~=toofoo i]", .html = "<p title=\"tot foo bar\">", .exp = 0 },
+        .{ .q = "[title~=\"hello world\"]", .html = "<p title=\"hello world\">", .exp = 0 },
+        .{ .q = "[title~=\"hello\" i]", .html = "<p title=\"HELLO world\">", .exp = 1 },
+        .{ .q = "[title~=\"hello\"          I]", .html = "<p title=\"HELLO world\">", .exp = 1 },
+        .{ .q = "[lang|=\"en\"]", .html = "<p lang=\"en\"><p lang=\"en-gb\"><p lang=\"enough\"><p lang=\"fr-en\">", .exp = 2 },
+        .{ .q = "[lang|=\"EN\" i]", .html = "<p lang=\"en\"><p lang=\"En-gb\"><p lang=\"enough\"><p lang=\"fr-en\">", .exp = 2 },
+        .{ .q = "[lang|=\"EN\"     i]", .html = "<p lang=\"en\"><p lang=\"En-gb\"><p lang=\"enough\"><p lang=\"fr-en\">", .exp = 2 },
+        .{ .q = "[title^=\"foo\"]", .html = "<p title=\"foobar\"><p title=\"barfoo\">", .exp = 1 },
+        .{ .q = "[title^=\"foo\" i]", .html = "<p title=\"FooBAR\"><p title=\"barfoo\">", .exp = 1 },
+        .{ .q = "[title$=\"bar\"]", .html = "<p title=\"foobar\"><p title=\"barfoo\">", .exp = 1 },
+        .{ .q = "[title$=\"BAR\" i]", .html = "<p title=\"foobar\"><p title=\"barfoo\">", .exp = 1 },
+        .{ .q = "[title*=\"bar\"]", .html = "<p title=\"foobarufoo\">", .exp = 1 },
+        .{ .q = "[title*=\"BaRu\" i]", .html = "<p title=\"foobarufoo\">", .exp = 1 },
+        .{ .q = "[title*=\"BaRu\" I]", .html = "<p title=\"foobarufoo\">", .exp = 1 },
+        .{ .q = "p[class$=\" \"]", .html = "<p class=\" \">This text should be green.</p><p>This text should be green.</p>", .exp = 0 },
+        .{ .q = "p[class$=\"\"]", .html = "<p class=\"\">This text should be green.</p><p>This text should be green.</p>", .exp = 0 },
+        .{ .q = "p[class^=\" \"]", .html = "<p class=\" \">This text should be green.</p><p>This text should be green.</p>", .exp = 0 },
+        .{ .q = "p[class^=\"\"]", .html = "<p class=\"\">This text should be green.</p><p>This text should be green.</p>", .exp = 0 },
+        .{ .q = "p[class*=\" \"]", .html = "<p class=\" \">This text should be green.</p><p>This text should be green.</p>", .exp = 0 },
+        .{ .q = "p[class*=\"\"]", .html = "<p class=\"\">This text should be green.</p><p>This text should be green.</p>", .exp = 0 },
+        .{ .q = "input[name=Sex][value=F]", .html = "<input type=\"radio\" name=\"Sex\" value=\"F\"/>", .exp = 1 },
+        .{ .q = "table[border=\"0\"][cellpadding=\"0\"][cellspacing=\"0\"]", .html = "<table border=\"0\" cellpadding=\"0\" cellspacing=\"0\" style=\"table-layout: fixed; width: 100%; border: 0 dashed; border-color: #FFFFFF\"><tr style=\"height:64px\">aaa</tr></table>", .exp = 1 },
+        .{ .q = ".t1:not(.t2)", .html = "<p class=\"t1 t2\">", .exp = 0 },
+        .{ .q = "div:not(.t1)", .html = "<div class=\"t3\">", .exp = 1 },
+        .{ .q = "div:not([class=\"t2\"])", .html = "<div><div class=\"t2\"><div class=\"t3\">", .exp = 2 },
+        .{ .q = "li:nth-child(odd)", .html = "<ol><li id=1><li id=2><li id=3></ol>", .exp = 2 },
+        .{ .q = "li:nth-child(even)", .html = "<ol><li id=1><li id=2><li id=3></ol>", .exp = 1 },
+        .{ .q = "li:nth-child(-n+2)", .html = "<ol><li id=1><li id=2><li id=3></ol>", .exp = 2 },
+        .{ .q = "li:nth-child(3n+1)", .html = "<ol><li id=1><li id=2><li id=3></ol>", .exp = 1 },
+        .{ .q = "li:nth-last-child(odd)", .html = "<ol><li id=1><li id=2><li id=3><li id=4></ol>", .exp = 2 },
+        .{ .q = "li:nth-last-child(even)", .html = "<ol><li id=1><li id=2><li id=3><li id=4></ol>", .exp = 2 },
+        .{ .q = "li:nth-last-child(-n+2)", .html = "<ol><li id=1><li id=2><li id=3><li id=4></ol>", .exp = 2 },
+        .{ .q = "li:nth-last-child(3n+1)", .html = "<ol><li id=1><li id=2><li id=3><li id=4></ol>", .exp = 2 },
+        .{ .q = "span:first-child", .html = "<p>some text <span id=\"1\">and a span</span><span id=\"2\"> and another</span></p>", .exp = 1 },
+        .{ .q = "span:last-child", .html = "<span>a span</span> and some text", .exp = 1 },
+        .{ .q = "p:nth-of-type(2)", .html = "<address></address><p id=1><p id=2>", .exp = 1 },
+        .{ .q = "p:nth-last-of-type(2)", .html = "<address></address><p id=1><p id=2></p><a>", .exp = 1 },
+        .{ .q = "p:last-of-type", .html = "<address></address><p id=1><p id=2></p><a>", .exp = 1 },
+        .{ .q = "p:first-of-type", .html = "<address></address><p id=1><p id=2></p><a>", .exp = 1 },
+        .{ .q = "p:only-child", .html = "<div><p id=\"1\"></p><a></a></div><div><p id=\"2\"></p></div>", .exp = 1 },
+        .{ .q = "p:only-of-type", .html = "<div><p id=\"1\"></p><a></a></div><div><p id=\"2\"></p><p id=\"3\"></p></div>", .exp = 1 },
+        .{ .q = ":empty", .html = "<p id=\"1\"><!-- --><p id=\"2\">Hello<p id=\"3\"><span>", .exp = 3 },
+        .{ .q = "div p", .html = "<div><p id=\"1\"><table><tr><td><p id=\"2\"></table></div><p id=\"3\">", .exp = 2 },
+        .{ .q = "div table p", .html = "<div><p id=\"1\"><table><tr><td><p id=\"2\"></table></div><p id=\"3\">", .exp = 1 },
+        .{ .q = "div > p", .html = "<div><p id=\"1\"><div><p id=\"2\"></div><table><tr><td><p id=\"3\"></table></div>", .exp = 2 },
+        .{ .q = "p ~ p", .html = "<p id=\"1\"><p id=\"2\"></p><address></address><p id=\"3\">", .exp = 2 },
+        .{ .q = "p + p", .html = "<p id=\"1\"></p> <!--comment--> <p id=\"2\"></p><address></address><p id=\"3\">", .exp = 1 },
+        .{ .q = "li, p", .html = "<ul><li></li><li></li></ul><p>", .exp = 3 },
+        .{ .q = "p +/*This is a comment*/ p", .html = "<p id=\"1\"><p id=\"2\"></p><address></address><p id=\"3\">", .exp = 1 },
+        // .{ .q = "p:contains(\"that wraps\")", .html = "<p>Text block that <span>wraps inner text</span> and continues</p>", .exp = 1 },
+        .{ .q = "p:containsOwn(\"that wraps\")", .html = "<p>Text block that <span>wraps inner text</span> and continues</p>", .exp = 0 },
+        .{ .q = ":containsOwn(\"inner\")", .html = "<p>Text block that <span>wraps inner text</span> and continues</p>", .exp = 1 },
+        .{ .q = ":containsOwn(\"Inner\")", .html = "<p>Text block that <span>wraps inner text</span> and continues</p>", .exp = 0 },
+        .{ .q = "p:containsOwn(\"block\")", .html = "<p>Text block that <span>wraps inner text</span> and continues</p>", .exp = 1 },
+        .{ .q = "div:has(#p1)", .html = "<div id=\"d1\"><p id=\"p1\"><span>text content</span></p></div><div id=\"d2\"/>", .exp = 1 },
+        .{ .q = "div:has(:containsOwn(\"2\"))", .html = "<div id=\"d1\"><p id=\"p1\"><span>contents 1</span></p></div> <div id=\"d2\"><p>contents <em>2</em></p></div>", .exp = 1 },
+        .{ .q = "body :has(:containsOwn(\"2\"))", .html = "<body><div id=\"d1\"><p id=\"p1\"><span>contents 1</span></p></div> <div id=\"d2\"><p id=\"p2\">contents <em>2</em></p></div></body>", .exp = 2 },
+        .{ .q = "body :haschild(:containsOwn(\"2\"))", .html = "<body><div id=\"d1\"><p id=\"p1\"><span>contents 1</span></p></div> <div id=\"d2\"><p id=\"p2\">contents <em>2</em></p></div></body>", .exp = 1 },
+        // .{ .q = "p:matches([\\d])", .html = "<p id=\"p1\">0123456789</p><p id=\"p2\">abcdef</p><p id=\"p3\">0123ABCD</p>", .exp = 2 },
+        // .{ .q = "p:matches([a-z])", .html = "<p id=\"p1\">0123456789</p><p id=\"p2\">abcdef</p><p id=\"p3\">0123ABCD</p>", .exp = 1 },
+        // .{ .q = "p:matches([a-zA-Z])", .html = "<p id=\"p1\">0123456789</p><p id=\"p2\">abcdef</p><p id=\"p3\">0123ABCD</p>", .exp = 2 },
+        // .{ .q = "p:matches([^\\d])", .html = "<p id=\"p1\">0123456789</p><p id=\"p2\">abcdef</p><p id=\"p3\">0123ABCD</p>", .exp = 2 },
+        // .{ .q = "p:matches(^(0|a))", .html = "<p id=\"p1\">0123456789</p><p id=\"p2\">abcdef</p><p id=\"p3\">0123ABCD</p>", .exp = 3 },
+        // .{ .q = "p:matches(^\\d+$)", .html = "<p id=\"p1\">0123456789</p><p id=\"p2\">abcdef</p><p id=\"p3\">0123ABCD</p>", .exp = 1 },
+        // .{ .q = "p:not(:matches(^\\d+$))", .html = "<p id=\"p1\">0123456789</p><p id=\"p2\">abcdef</p><p id=\"p3\">0123ABCD</p>", .exp = 2 },
+        // .{ .q = "div :matchesOwn(^\\d+$)", .html = "<div><p id=\"p1\">01234<em>567</em>89</p><div>", .exp = 2 },
+        // .{ .q = "[href#=(fina)]:not([href#=(\\/\\/[^\\/]+untrusted)])", .html = "<ul> <li><a id=\"a1\" href=\"http://www.google.com/finance\"></a> <li><a id=\"a2\" href=\"http://finance.yahoo.com/\"></a> <li><a id=\"a2\" href=\"http://finance.untrusted.com/\"/> <li><a id=\"a3\" href=\"https://www.google.com/news\"/> <li><a id=\"a4\" href=\"http://news.yahoo.com\"/> </ul>", .exp = 2 },
+        // .{ .q = "[href#=(^https:\\/\\/[^\\/]*\\/?news)]", .html = "<ul> <li><a id=\"a1\" href=\"http://www.google.com/finance\"/> <li><a id=\"a2\" href=\"http://finance.yahoo.com/\"/> <li><a id=\"a3\" href=\"https://www.google.com/news\"></a> <li><a id=\"a4\" href=\"http://news.yahoo.com\"/> </ul>", .exp = 1 },
+        .{ .q = ":input", .html = "<form> <label>Username <input type=\"text\" name=\"username\" /></label> <label>Password <input type=\"password\" name=\"password\" /></label> <label>Country <select name=\"country\"> <option value=\"ca\">Canada</option> <option value=\"us\">United States</option> </select> </label> <label>Bio <textarea name=\"bio\"></textarea></label> <button>Sign up</button> </form>", .exp = 5 },
+        .{ .q = ":root", .html = "<html><head></head><body></body></html>", .exp = 1 },
+        .{ .q = "*:root", .html = "<html><head></head><body></body></html>", .exp = 1 },
+        .{ .q = "html:nth-child(1)", .html = "<html><head></head><body></body></html>", .exp = 1 },
+        .{ .q = "*:root:first-child", .html = "<html><head></head><body></body></html>", .exp = 1 },
+        .{ .q = "*:root:nth-child(1)", .html = "<html><head></head><body></body></html>", .exp = 1 },
+        .{ .q = "a:not(:root)", .html = "<html><head></head><body><a href=\"http://www.foo.com\"></a></body></html>", .exp = 1 },
+        .{ .q = "body > *:nth-child(3n+2)", .html = "<html><head></head><body><p></p><div></div><span></span><a></a><form></form></body></html>", .exp = 2 },
+        .{ .q = "input:disabled", .html = "<html><head></head><body><fieldset disabled><legend id=\"1\"><input id=\"i1\"/></legend><legend id=\"2\"><input id=\"i2\"/></legend></fieldset></body></html>", .exp = 1 },
+        .{ .q = ":disabled", .html = "<html><head></head><body><fieldset disabled></fieldset></body></html>", .exp = 1 },
+        .{ .q = ":enabled", .html = "<html><head></head><body><fieldset></fieldset></body></html>", .exp = 1 },
+        .{ .q = "div.class1, div.class2", .html = "<div class=class1></div><div class=class2></div><div class=class3></div>", .exp = 2 },
+    };
+
+    for (testcases) |tc| {
+        matcher.reset();
+
+        const doc = try parser.documentHTMLParseFromStr(tc.html);
+        defer parser.documentHTMLClose(doc) catch {};
+
+        const s = css.parse(alloc, tc.q, .{}) catch |e| {
+            std.debug.print("parse, query: {s}\n", .{tc.q});
+            return e;
+        };
+        defer s.deinit(alloc);
+
+        const node = Node{ .node = parser.documentHTMLToNode(doc) };
+
+        _ = css.matchAll(&s, node, &matcher) catch |e| {
+            std.debug.print("match, query: {s}\n", .{tc.q});
+            return e;
+        };
+        std.testing.expectEqual(tc.exp, matcher.nodes.items.len) catch |e| {
+            std.debug.print("expectation, query: {s}\n", .{tc.q});
+            return e;
+        };
+    }
+}

src/browser/css/parser.zig

@@ -0,0 +1,996 @@
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+// CSS Selector parser
+// This file is a rewrite in Zig of Cascadia CSS Selector parser.
+// see https://github.com/andybalholm/cascadia
+// see https://github.com/andybalholm/cascadia/blob/master/parser.go
+const std = @import("std");
+const ascii = std.ascii;
+const Allocator = std.mem.Allocator;
+
+const selector = @import("selector.zig");
+const Selector = selector.Selector;
+const PseudoClass = selector.PseudoClass;
+const AttributeOP = selector.AttributeOP;
+const Combinator = selector.Combinator;
+
+const REPLACEMENT_CHARACTER = &.{ 239, 191, 189 };
+
+pub const ParseError = error{
+    ExpectedSelector,
+    ExpectedIdentifier,
+    ExpectedName,
+    ExpectedIDSelector,
+    ExpectedClassSelector,
+    ExpectedAttributeSelector,
+    ExpectedString,
+    ExpectedRegexp,
+    ExpectedPseudoClassSelector,
+    ExpectedParenthesis,
+    ExpectedParenthesisClose,
+    ExpectedNthExpression,
+    ExpectedInteger,
+    InvalidEscape,
+    EscapeLineEndingOutsideString,
+    InvalidUnicode,
+    UnicodeIsNotHandled,
+    WriteError,
+    PseudoElementNotAtSelectorEnd,
+    PseudoElementNotUnique,
+    PseudoElementDisabled,
+    InvalidAttributeOperator,
+    InvalidAttributeSelector,
+    InvalidString,
+    InvalidRegexp,
+    InvalidPseudoClassSelector,
+    EmptyPseudoClassSelector,
+    InvalidPseudoClass,
+    InvalidPseudoElement,
+    UnmatchParenthesis,
+    NotHandled,
+    UnknownPseudoSelector,
+    InvalidNthExpression,
+} || PseudoClass.Error || Combinator.Error || std.mem.Allocator.Error;
+
+pub const ParseOptions = struct {
+    accept_pseudo_elts: bool = true,
+};
+
+pub const Parser = struct {
+    s: []const u8, // string to parse
+    i: usize = 0, // current position
+
+    opts: ParseOptions,
+
+    pub fn parse(p: *Parser, allocator: Allocator) ParseError!Selector {
+        return p.parseSelectorGroup(allocator);
+    }
+
+    // skipWhitespace consumes whitespace characters and comments.
+    // It returns true if there was actually anything to skip.
+    fn skipWhitespace(p: *Parser) bool {
+        var i = p.i;
+        while (i < p.s.len) {
+            const c = p.s[i];
+            // Whitespaces.
+            if (ascii.isWhitespace(c)) {
+                i += 1;
+                continue;
+            }
+
+            // Comments.
+            if (c == '/') {
+                if (std.mem.startsWith(u8, p.s[i..], "/*")) {
+                    if (std.mem.indexOf(u8, p.s[i..], "*/")) |end| {
+                        i += end + "*/".len;
+                        continue;
+                    }
+                }
+            }
+            break;
+        }
+
+        if (i > p.i) {
+            p.i = i;
+            return true;
+        }
+
+        return false;
+    }
+
+    // parseSimpleSelectorSequence parses a selector sequence that applies to
+    // a single element.
+    fn parseSimpleSelectorSequence(p: *Parser, allocator: Allocator) ParseError!Selector {
+        if (p.i >= p.s.len) {
+            return ParseError.ExpectedSelector;
+        }
+
+        var buf: std.ArrayListUnmanaged(Selector) = .empty;
+        defer buf.deinit(allocator);
+
+        switch (p.s[p.i]) {
+            '*' => {
+                // It's the universal selector. Just skip over it, since it
+                // doesn't affect the meaning.
+                p.i += 1;
+
+                // other version of universal selector
+                if (p.i + 2 < p.s.len and std.mem.eql(u8, "|*", p.s[p.i .. p.i + 2])) {
+                    p.i += 2;
+                }
+            },
+            '#', '.', '[', ':' => {
+                // There's no type selector. Wait to process the other till the
+                // main loop.
+            },
+            else => try buf.append(allocator, try p.parseTypeSelector(allocator)),
+        }
+
+        var pseudo_elt: ?PseudoClass = null;
+
+        loop: while (p.i < p.s.len) {
+            var ns: Selector = switch (p.s[p.i]) {
+                '#' => try p.parseIDSelector(allocator),
+                '.' => try p.parseClassSelector(allocator),
+                '[' => try p.parseAttributeSelector(allocator),
+                ':' => try p.parsePseudoclassSelector(allocator),
+                else => break :loop,
+            };
+            errdefer ns.deinit(allocator);
+
+            // From https://drafts.csswg.org/selectors-3/#pseudo-elements :
+            // "Only one pseudo-element may appear per selector, and if present
+            // it must appear after the sequence of simple selectors that
+            // represents the subjects of the selector.""
+            switch (ns) {
+                .pseudo_element => |e| {
+                    //  We found a pseudo-element.
+                    //  Only one pseudo-element is accepted per selector.
+                    if (pseudo_elt != null) return ParseError.PseudoElementNotUnique;
+                    if (!p.opts.accept_pseudo_elts) return ParseError.PseudoElementDisabled;
+
+                    pseudo_elt = e;
+                    ns.deinit(allocator);
+                },
+                else => {
+                    if (pseudo_elt != null) return ParseError.PseudoElementNotAtSelectorEnd;
+                    try buf.append(allocator, ns);
+                },
+            }
+        }
+
+        // no need wrap the selectors in compoundSelector
+        if (buf.items.len == 1 and pseudo_elt == null) {
+            return buf.items[0];
+        }
+
+        return .{
+            .compound = .{ .selectors = try buf.toOwnedSlice(allocator), .pseudo_elt = pseudo_elt },
+        };
+    }
+
+    // parseTypeSelector parses a type selector (one that matches by tag name).
+    fn parseTypeSelector(p: *Parser, allocator: Allocator) ParseError!Selector {
+        var buf: std.ArrayListUnmanaged(u8) = .empty;
+        defer buf.deinit(allocator);
+        try p.parseIdentifier(buf.writer(allocator));
+
+        return .{ .tag = try buf.toOwnedSlice(allocator) };
+    }
+
+    // parseIdentifier parses an identifier.
+    fn parseIdentifier(p: *Parser, w: anytype) ParseError!void {
+        const prefix = '-';
+        var numPrefix: usize = 0;
+
+        while (p.s.len > p.i and p.s[p.i] == prefix) {
+            p.i += 1;
+            numPrefix += 1;
+        }
+
+        if (p.s.len <= p.i) {
+            return ParseError.ExpectedSelector;
+        }
+
+        const c = p.s[p.i];
+        if (!(nameStart(c) or c == '\\')) {
+            return ParseError.ExpectedSelector;
+        }
+
+        var ii: usize = 0;
+        while (ii < numPrefix) {
+            w.writeByte(prefix) catch return ParseError.WriteError;
+            ii += 1;
+        }
+        try parseName(p, w);
+    }
+
+    // parseName parses a name (which is like an identifier, but doesn't have
+    // extra restrictions on the first character).
+    fn parseName(p: *Parser, w: anytype) ParseError!void {
+        const sel = p.s;
+        const sel_len = sel.len;
+
+        var i = p.i;
+        var ok = false;
+
+        while (i < sel_len) {
+            const c = sel[i];
+
+            if (nameChar(c)) {
+                const start = i;
+                while (i < sel_len and nameChar(sel[i])) i += 1;
+                w.writeAll(sel[start..i]) catch return ParseError.WriteError;
+                ok = true;
+            } else if (c == '\\') {
+                p.i = i;
+                try p.parseEscape(w);
+                i = p.i;
+                ok = true;
+            } else if (c == 0) {
+                w.writeAll(REPLACEMENT_CHARACTER) catch return ParseError.WriteError;
+                i += 1;
+                if (i == sel_len) {
+                    ok = true;
+                }
+            } else {
+                // default:
+                break;
+            }
+        }
+
+        if (!ok) return ParseError.ExpectedName;
+        p.i = i;
+    }
+
+    // parseEscape parses a backslash escape.
+    // The returned string is owned by the caller.
+    fn parseEscape(p: *Parser, w: anytype) ParseError!void {
+        const sel = p.s;
+        const sel_len = sel.len;
+
+        if (sel_len < p.i + 2 or sel[p.i] != '\\') {
+            p.i += 1;
+            w.writeAll(REPLACEMENT_CHARACTER) catch return ParseError.WriteError;
+            return;
+        }
+
+        const start = p.i + 1;
+        const c = sel[start];
+
+        // unicode escape (hex)
+        if (ascii.isHex(c)) {
+            var i: usize = start;
+            while (i < start + 6 and i < sel_len and ascii.isHex(sel[i])) {
+                i += 1;
+            }
+
+            const v = std.fmt.parseUnsigned(u21, sel[start..i], 16) catch {
+                p.i = i;
+                w.writeAll(REPLACEMENT_CHARACTER) catch return ParseError.WriteError;
+                return;
+            };
+
+            if (sel_len >= i) {
+                if (sel_len > i) {
+                    switch (sel[i]) {
+                        '\r' => {
+                            i += 1;
+                            if (sel_len > i and sel[i] == '\n') i += 1;
+                        },
+                        ' ', '\t', '\n', std.ascii.control_code.ff => i += 1,
+                        else => {},
+                    }
+                }
+                p.i = i;
+                if (v == 0) {
+                    w.writeAll(REPLACEMENT_CHARACTER) catch return ParseError.WriteError;
+                    return;
+                }
+                var buf: [4]u8 = undefined;
+                const ln = std.unicode.utf8Encode(v, &buf) catch {
+                    w.writeAll(REPLACEMENT_CHARACTER) catch return ParseError.WriteError;
+                    return;
+                };
+                w.writeAll(buf[0..ln]) catch return ParseError.WriteError;
+                return;
+            }
+        }
+
+        // Return the literal character after the backslash.
+        p.i += 2;
+        w.writeByte(sel[start]) catch return ParseError.WriteError;
+    }
+
+    // parseIDSelector parses a selector that matches by id attribute.
+    fn parseIDSelector(p: *Parser, allocator: Allocator) ParseError!Selector {
+        if (p.i >= p.s.len) return ParseError.ExpectedIDSelector;
+        if (p.s[p.i] != '#') return ParseError.ExpectedIDSelector;
+
+        p.i += 1;
+
+        var buf: std.ArrayListUnmanaged(u8) = .empty;
+        defer buf.deinit(allocator);
+
+        try p.parseName(buf.writer(allocator));
+        return .{ .id = try buf.toOwnedSlice(allocator) };
+    }
+
+    // parseClassSelector parses a selector that matches by class attribute.
+    fn parseClassSelector(p: *Parser, allocator: Allocator) ParseError!Selector {
+        if (p.i >= p.s.len) return ParseError.ExpectedClassSelector;
+        if (p.s[p.i] != '.') return ParseError.ExpectedClassSelector;
+
+        p.i += 1;
+
+        var buf: std.ArrayListUnmanaged(u8) = .empty;
+        defer buf.deinit(allocator);
+
+        try p.parseIdentifier(buf.writer(allocator));
+        return .{ .class = try buf.toOwnedSlice(allocator) };
+    }
+
+    // parseAttributeSelector parses a selector that matches by attribute value.
+    fn parseAttributeSelector(p: *Parser, allocator: Allocator) ParseError!Selector {
+        if (p.i >= p.s.len) return ParseError.ExpectedAttributeSelector;
+        if (p.s[p.i] != '[') return ParseError.ExpectedAttributeSelector;
+
+        p.i += 1;
+        _ = p.skipWhitespace();
+
+        var buf: std.ArrayListUnmanaged(u8) = .empty;
+        defer buf.deinit(allocator);
+
+        try p.parseIdentifier(buf.writer(allocator));
+        const key = try buf.toOwnedSlice(allocator);
+        errdefer allocator.free(key);
+
+        lowerstr(key);
+
+        _ = p.skipWhitespace();
+        if (p.i >= p.s.len) return ParseError.ExpectedAttributeSelector;
+        if (p.s[p.i] == ']') {
+            p.i += 1;
+            return .{ .attribute = .{ .key = key } };
+        }
+
+        if (p.i + 2 >= p.s.len) return ParseError.ExpectedAttributeSelector;
+
+        const op = try parseAttributeOP(p.s[p.i .. p.i + 2]);
+        p.i += op.len();
+
+        _ = p.skipWhitespace();
+        if (p.i >= p.s.len) return ParseError.ExpectedAttributeSelector;
+
+        buf.clearRetainingCapacity();
+        var is_val: bool = undefined;
+        if (op == .regexp) {
+            is_val = false;
+            try p.parseRegex(buf.writer(allocator));
+        } else {
+            is_val = true;
+            switch (p.s[p.i]) {
+                '\'', '"' => try p.parseString(buf.writer(allocator)),
+                else => try p.parseIdentifier(buf.writer(allocator)),
+            }
+        }
+
+        _ = p.skipWhitespace();
+        if (p.i >= p.s.len) return ParseError.ExpectedAttributeSelector;
+
+        // check if the attribute contains an ignore case flag
+        var ci = false;
+        if (p.s[p.i] == 'i' or p.s[p.i] == 'I') {
+            ci = true;
+            p.i += 1;
+        }
+
+        _ = p.skipWhitespace();
+        if (p.i >= p.s.len) return ParseError.ExpectedAttributeSelector;
+
+        if (p.s[p.i] != ']') return ParseError.InvalidAttributeSelector;
+        p.i += 1;
+
+        return .{ .attribute = .{
+            .key = key,
+            .val = if (is_val) try buf.toOwnedSlice(allocator) else null,
+            .regexp = if (!is_val) try buf.toOwnedSlice(allocator) else null,
+            .op = op,
+            .ci = ci,
+        } };
+    }
+
+    // parseString parses a single- or double-quoted string.
+    fn parseString(p: *Parser, writer: anytype) ParseError!void {
+        const sel = p.s;
+        const sel_len = sel.len;
+
+        var i = p.i;
+        if (sel_len < i + 2) return ParseError.ExpectedString;
+
+        const quote = sel[i];
+        i += 1;
+
+        loop: while (i < sel_len) {
+            switch (sel[i]) {
+                '\\' => {
+                    if (sel_len > i + 1) {
+                        const c = sel[i + 1];
+                        switch (c) {
+                            '\r' => {
+                                if (sel_len > i + 2 and sel[i + 2] == '\n') {
+                                    i += 3;
+                                    continue :loop;
+                                }
+                                i += 2;
+                                continue :loop;
+                            },
+                            '\n', std.ascii.control_code.ff => {
+                                i += 2;
+                                continue :loop;
+                            },
+                            else => {},
+                        }
+                    }
+                    p.i = i;
+                    try p.parseEscape(writer);
+                    i = p.i;
+                },
+                '\r', '\n', std.ascii.control_code.ff => return ParseError.InvalidString,
+                else => |c| {
+                    if (c == quote) break :loop;
+                    const start = i;
+                    while (i < sel_len) {
+                        const cc = sel[i];
+                        if (cc == quote or cc == '\\' or c == '\r' or c == '\n' or c == std.ascii.control_code.ff) break;
+                        i += 1;
+                    }
+                    writer.writeAll(sel[start..i]) catch return ParseError.WriteError;
+                },
+            }
+        }
+
+        if (i >= sel_len) return ParseError.InvalidString;
+
+        // Consume the final quote.
+        i += 1;
+        p.i = i;
+    }
+
+    // parseRegex parses a regular expression; the end is defined by encountering an
+    // unmatched closing ')' or ']' which is not consumed
+    fn parseRegex(p: *Parser, writer: anytype) ParseError!void {
+        var i = p.i;
+        if (p.s.len < i + 2) return ParseError.ExpectedRegexp;
+
+        // number of open parens or brackets;
+        // when it becomes negative, finished parsing regex
+        var open: isize = 0;
+
+        loop: while (i < p.s.len) {
+            switch (p.s[i]) {
+                '(', '[' => open += 1,
+                ')', ']' => {
+                    open -= 1;
+                    if (open < 0) break :loop;
+                },
+                else => {},
+            }
+            i += 1;
+        }
+
+        if (i >= p.s.len) return ParseError.InvalidRegexp;
+        writer.writeAll(p.s[p.i..i]) catch return ParseError.WriteError;
+        p.i = i;
+    }
+
+    // parsePseudoclassSelector parses a pseudoclass selector like :not(p) or a pseudo-element
+    // For backwards compatibility, both ':' and '::' prefix are allowed for pseudo-elements.
+    // https://drafts.csswg.org/selectors-3/#pseudo-elements
+    fn parsePseudoclassSelector(p: *Parser, allocator: Allocator) ParseError!Selector {
+        if (p.i >= p.s.len) return ParseError.ExpectedPseudoClassSelector;
+        if (p.s[p.i] != ':') return ParseError.ExpectedPseudoClassSelector;
+
+        p.i += 1;
+
+        var must_pseudo_elt: bool = false;
+        if (p.i >= p.s.len) return ParseError.EmptyPseudoClassSelector;
+        if (p.s[p.i] == ':') { // we found a pseudo-element
+            must_pseudo_elt = true;
+            p.i += 1;
+        }
+
+        var buf: std.ArrayListUnmanaged(u8) = .empty;
+        defer buf.deinit(allocator);
+
+        try p.parseIdentifier(buf.writer(allocator));
+
+        const pseudo_class = try PseudoClass.parse(buf.items);
+
+        // reset the buffer to reuse it.
+        buf.clearRetainingCapacity();
+
+        if (must_pseudo_elt and !pseudo_class.isPseudoElement()) return ParseError.InvalidPseudoElement;
+
+        switch (pseudo_class) {
+            .not, .has, .haschild => {
+                if (!p.consumeParenthesis()) return ParseError.ExpectedParenthesis;
+
+                const sel = try p.parseSelectorGroup(allocator);
+                if (!p.consumeClosingParenthesis()) return ParseError.ExpectedParenthesisClose;
+
+                const s = try allocator.create(Selector);
+                errdefer allocator.destroy(s);
+                s.* = sel;
+
+                return .{ .pseudo_class_relative = .{ .pseudo_class = pseudo_class, .match = s } };
+            },
+            .contains, .containsown => {
+                if (!p.consumeParenthesis()) return ParseError.ExpectedParenthesis;
+                if (p.i == p.s.len) return ParseError.UnmatchParenthesis;
+
+                switch (p.s[p.i]) {
+                    '\'', '"' => try p.parseString(buf.writer(allocator)),
+                    else => try p.parseString(buf.writer(allocator)),
+                }
+
+                _ = p.skipWhitespace();
+                if (p.i >= p.s.len) return ParseError.InvalidPseudoClass;
+                if (!p.consumeClosingParenthesis()) return ParseError.ExpectedParenthesisClose;
+
+                const val = try buf.toOwnedSlice(allocator);
+                errdefer allocator.free(val);
+
+                return .{ .pseudo_class_contains = .{ .own = pseudo_class == .containsown, .val = val } };
+            },
+            .matches, .matchesown => {
+                if (!p.consumeParenthesis()) return ParseError.ExpectedParenthesis;
+
+                try p.parseRegex(buf.writer(allocator));
+                if (p.i >= p.s.len) return ParseError.InvalidPseudoClassSelector;
+                if (!p.consumeClosingParenthesis()) return ParseError.ExpectedParenthesisClose;
+
+                return .{ .pseudo_class_regexp = .{ .own = pseudo_class == .matchesown, .regexp = try buf.toOwnedSlice(allocator) } };
+            },
+            .nth_child, .nth_last_child, .nth_of_type, .nth_last_of_type => {
+                if (!p.consumeParenthesis()) return ParseError.ExpectedParenthesis;
+                const nth = try p.parseNth(allocator);
+                if (!p.consumeClosingParenthesis()) return ParseError.ExpectedParenthesisClose;
+
+                const last = pseudo_class == .nth_last_child or pseudo_class == .nth_last_of_type;
+                const of_type = pseudo_class == .nth_of_type or pseudo_class == .nth_last_of_type;
+                return .{ .pseudo_class_nth = .{ .a = nth[0], .b = nth[1], .of_type = of_type, .last = last } };
+            },
+            .first_child => return .{ .pseudo_class_nth = .{ .a = 0, .b = 1, .of_type = false, .last = false } },
+            .last_child => return .{ .pseudo_class_nth = .{ .a = 0, .b = 1, .of_type = false, .last = true } },
+            .first_of_type => return .{ .pseudo_class_nth = .{ .a = 0, .b = 1, .of_type = true, .last = false } },
+            .last_of_type => return .{ .pseudo_class_nth = .{ .a = 0, .b = 1, .of_type = true, .last = true } },
+            .only_child => return .{ .pseudo_class_only_child = false },
+            .only_of_type => return .{ .pseudo_class_only_child = true },
+            .input, .empty, .root, .link => return .{ .pseudo_class = pseudo_class },
+            .enabled, .disabled, .checked => return .{ .pseudo_class = pseudo_class },
+            .visible => return .{ .pseudo_class = pseudo_class },
+            .lang => {
+                if (!p.consumeParenthesis()) return ParseError.ExpectedParenthesis;
+                if (p.i == p.s.len) return ParseError.UnmatchParenthesis;
+
+                try p.parseIdentifier(buf.writer(allocator));
+
+                _ = p.skipWhitespace();
+                if (p.i >= p.s.len) return ParseError.InvalidPseudoClass;
+                if (!p.consumeClosingParenthesis()) return ParseError.ExpectedParenthesisClose;
+
+                const val = try buf.toOwnedSlice(allocator);
+                errdefer allocator.free(val);
+                lowerstr(val);
+
+                return .{ .pseudo_class_lang = val };
+            },
+            .visited, .hover, .active, .focus, .target => {
+                // Not applicable in a static context: never match.
+                return .{ .never_match = pseudo_class };
+            },
+            .after, .backdrop, .before, .cue, .first_letter => return .{ .pseudo_element = pseudo_class },
+            .first_line, .grammar_error, .marker, .placeholder => return .{ .pseudo_element = pseudo_class },
+            .selection, .spelling_error => return .{ .pseudo_element = pseudo_class },
+            .modal, .popover_open => return .{ .pseudo_element = pseudo_class },
+        }
+    }
+
+    // consumeParenthesis consumes an opening parenthesis and any following
+    // whitespace. It returns true if there was actually a parenthesis to skip.
+    fn consumeParenthesis(p: *Parser) bool {
+        if (p.i < p.s.len and p.s[p.i] == '(') {
+            p.i += 1;
+            _ = p.skipWhitespace();
+            return true;
+        }
+        return false;
+    }
+
+    // parseSelectorGroup parses a group of selectors, separated by commas.
+    fn parseSelectorGroup(p: *Parser, allocator: Allocator) ParseError!Selector {
+        const s = try p.parseSelector(allocator);
+
+        var buf: std.ArrayListUnmanaged(Selector) = .empty;
+        defer buf.deinit(allocator);
+
+        try buf.append(allocator, s);
+
+        while (p.i < p.s.len) {
+            if (p.s[p.i] != ',') break;
+            p.i += 1;
+            const ss = try p.parseSelector(allocator);
+            try buf.append(allocator, ss);
+        }
+
+        if (buf.items.len == 1) {
+            return buf.items[0];
+        }
+
+        return .{ .group = try buf.toOwnedSlice(allocator) };
+    }
+
+    // parseSelector parses a selector that may include combinators.
+    fn parseSelector(p: *Parser, allocator: Allocator) ParseError!Selector {
+        _ = p.skipWhitespace();
+        var s = try p.parseSimpleSelectorSequence(allocator);
+
+        while (true) {
+            var combinator: Combinator = .empty;
+            if (p.skipWhitespace()) {
+                combinator = .descendant;
+            }
+            if (p.i >= p.s.len) {
+                return s;
+            }
+
+            switch (p.s[p.i]) {
+                '+', '>', '~' => {
+                    combinator = try Combinator.parse(p.s[p.i]);
+                    p.i += 1;
+                    _ = p.skipWhitespace();
+                },
+                // These characters can't begin a selector, but they can legally occur after one.
+                ',', ')' => {
+                    return s;
+                },
+                else => {},
+            }
+
+            if (combinator == .empty) {
+                return s;
+            }
+
+            const c = try p.parseSimpleSelectorSequence(allocator);
+
+            const first = try allocator.create(Selector);
+            errdefer allocator.destroy(first);
+            first.* = s;
+
+            const second = try allocator.create(Selector);
+            errdefer allocator.destroy(second);
+            second.* = c;
+
+            s = Selector{ .combined = .{
+                .first = first,
+                .second = second,
+                .combinator = combinator,
+            } };
+        }
+
+        return s;
+    }
+
+    // consumeClosingParenthesis consumes a closing parenthesis and any preceding
+    // whitespace. It returns true if there was actually a parenthesis to skip.
+    fn consumeClosingParenthesis(p: *Parser) bool {
+        const i = p.i;
+        _ = p.skipWhitespace();
+        if (p.i < p.s.len and p.s[p.i] == ')') {
+            p.i += 1;
+            return true;
+        }
+        p.i = i;
+        return false;
+    }
+
+    // parseInteger parses a  decimal integer.
+    fn parseInteger(p: *Parser) ParseError!isize {
+        var i = p.i;
+        const start = i;
+        while (i < p.s.len and '0' <= p.s[i] and p.s[i] <= '9') i += 1;
+        if (i == start) return ParseError.ExpectedInteger;
+        p.i = i;
+
+        return std.fmt.parseUnsigned(isize, p.s[start..i], 10) catch ParseError.ExpectedInteger;
+    }
+
+    fn parseNthReadN(p: *Parser, a: isize) ParseError![2]isize {
+        _ = p.skipWhitespace();
+        if (p.i >= p.s.len) return ParseError.ExpectedNthExpression;
+
+        return switch (p.s[p.i]) {
+            '+' => {
+                p.i += 1;
+                _ = p.skipWhitespace();
+                const b = try p.parseInteger();
+                return .{ a, b };
+            },
+            '-' => {
+                p.i += 1;
+                _ = p.skipWhitespace();
+                const b = try p.parseInteger();
+                return .{ a, -b };
+            },
+            else => .{ a, 0 },
+        };
+    }
+
+    fn parseNthReadA(p: *Parser, a: isize) ParseError![2]isize {
+        if (p.i >= p.s.len) return ParseError.ExpectedNthExpression;
+        return switch (p.s[p.i]) {
+            'n', 'N' => {
+                p.i += 1;
+                return p.parseNthReadN(a);
+            },
+            else => .{ 0, a },
+        };
+    }
+
+    fn parseNthNegativeA(p: *Parser) ParseError![2]isize {
+        if (p.i >= p.s.len) return ParseError.ExpectedNthExpression;
+        const c = p.s[p.i];
+        if (std.ascii.isDigit(c)) {
+            const a = try p.parseInteger() * -1;
+            return p.parseNthReadA(a);
+        }
+        if (c == 'n' or c == 'N') {
+            p.i += 1;
+            return p.parseNthReadN(-1);
+        }
+
+        return ParseError.InvalidNthExpression;
+    }
+
+    fn parseNthPositiveA(p: *Parser) ParseError![2]isize {
+        if (p.i >= p.s.len) return ParseError.ExpectedNthExpression;
+        const c = p.s[p.i];
+        if (std.ascii.isDigit(c)) {
+            const a = try p.parseInteger();
+            return p.parseNthReadA(a);
+        }
+        if (c == 'n' or c == 'N') {
+            p.i += 1;
+            return p.parseNthReadN(1);
+        }
+
+        return ParseError.InvalidNthExpression;
+    }
+
+    // parseNth parses the argument for :nth-child (normally of the form an+b).
+    fn parseNth(p: *Parser, allocator: Allocator) ParseError![2]isize {
+        // initial state
+        if (p.i >= p.s.len) return ParseError.ExpectedNthExpression;
+        return switch (p.s[p.i]) {
+            '-' => {
+                p.i += 1;
+                return p.parseNthNegativeA();
+            },
+            '+' => {
+                p.i += 1;
+                return p.parseNthPositiveA();
+            },
+            '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' => p.parseNthPositiveA(),
+            'n', 'N' => {
+                p.i += 1;
+                return p.parseNthReadN(1);
+            },
+            'o', 'O', 'e', 'E' => {
+                var buf: std.ArrayListUnmanaged(u8) = .empty;
+                defer buf.deinit(allocator);
+
+                try p.parseName(buf.writer(allocator));
+
+                if (std.ascii.eqlIgnoreCase("odd", buf.items)) return .{ 2, 1 };
+                if (std.ascii.eqlIgnoreCase("even", buf.items)) return .{ 2, 0 };
+
+                return ParseError.InvalidNthExpression;
+            },
+            else => ParseError.InvalidNthExpression,
+        };
+    }
+};
+
+// nameStart returns whether c can be the first character of an identifier
+// (not counting an initial hyphen, or an escape sequence).
+fn nameStart(c: u8) bool {
+    return 'a' <= c and c <= 'z' or 'A' <= c and c <= 'Z' or c == '_' or c > 127 or
+        '0' <= c and c <= '9';
+}
+
+// nameChar returns whether c can be a character within an identifier
+// (not counting an escape sequence).
+fn nameChar(c: u8) bool {
+    return 'a' <= c and c <= 'z' or 'A' <= c and c <= 'Z' or c == '_' or c > 127 or
+        c == '-' or '0' <= c and c <= '9';
+}
+
+fn lowerstr(str: []u8) void {
+    for (str, 0..) |c, i| {
+        str[i] = std.ascii.toLower(c);
+    }
+}
+
+// parseAttributeOP parses an AttributeOP from a string of 1 or 2 bytes.
+fn parseAttributeOP(s: []const u8) ParseError!AttributeOP {
+    if (s.len < 1 or s.len > 2) return ParseError.InvalidAttributeOperator;
+
+    // if the first sign is equal, we don't check anything else.
+    if (s[0] == '=') return .eql;
+
+    if (s.len != 2 or s[1] != '=') return ParseError.InvalidAttributeOperator;
+
+    return switch (s[0]) {
+        '=' => .eql,
+        '!' => .not_eql,
+        '~' => .one_of,
+        '|' => .prefix_hyphen,
+        '^' => .prefix,
+        '$' => .suffix,
+        '*' => .contains,
+        '#' => .regexp,
+        else => ParseError.InvalidAttributeOperator,
+    };
+}
+
+test "parser.skipWhitespace" {
+    const testcases = [_]struct {
+        s: []const u8,
+        i: usize,
+        r: bool,
+    }{
+        .{ .s = "", .i = 0, .r = false },
+        .{ .s = "foo", .i = 0, .r = false },
+        .{ .s = " ", .i = 1, .r = true },
+        .{ .s = " foo", .i = 1, .r = true },
+        .{ .s = "/* foo */ bar", .i = 10, .r = true },
+        .{ .s = "/* foo", .i = 0, .r = false },
+    };
+
+    for (testcases) |tc| {
+        var p = Parser{ .s = tc.s, .opts = .{} };
+        const res = p.skipWhitespace();
+        try std.testing.expectEqual(tc.r, res);
+        try std.testing.expectEqual(tc.i, p.i);
+    }
+}
+
+test "parser.parseIdentifier" {
+    const allocator = std.testing.allocator;
+
+    const testcases = [_]struct {
+        s: []const u8, // given value
+        exp: []const u8, // expected value
+        err: bool = false,
+    }{
+        .{ .s = "x", .exp = "x" },
+        .{ .s = "96", .exp = "96", .err = false },
+        .{ .s = "-x", .exp = "-x" },
+        .{ .s = "r\\e9 sumé", .exp = "résumé" },
+        .{ .s = "r\\0000e9 sumé", .exp = "résumé" },
+        .{ .s = "r\\0000e9sumé", .exp = "résumé" },
+        .{ .s = "a\\\"b", .exp = "a\"b" },
+    };
+
+    var buf: std.ArrayListUnmanaged(u8) = .empty;
+    defer buf.deinit(allocator);
+
+    for (testcases) |tc| {
+        buf.clearRetainingCapacity();
+
+        var p = Parser{ .s = tc.s, .opts = .{} };
+        p.parseIdentifier(buf.writer(allocator)) catch |e| {
+            // if error was expected, continue.
+            if (tc.err) continue;
+
+            std.debug.print("test case {s}\n", .{tc.s});
+            return e;
+        };
+        std.testing.expectEqualDeep(tc.exp, buf.items) catch |e| {
+            std.debug.print("test case {s} : {s}\n", .{ tc.s, buf.items });
+            return e;
+        };
+    }
+}
+
+test "parser.parseString" {
+    const allocator = std.testing.allocator;
+
+    const testcases = [_]struct {
+        s: []const u8, // given value
+        exp: []const u8, // expected value
+        err: bool = false,
+    }{
+        .{ .s = "\"x\"", .exp = "x" },
+        .{ .s = "'x'", .exp = "x" },
+        .{ .s = "'x", .exp = "", .err = true },
+        .{ .s = "'x\\\r\nx'", .exp = "xx" },
+        .{ .s = "\"r\\e9 sumé\"", .exp = "résumé" },
+        .{ .s = "\"r\\0000e9 sumé\"", .exp = "résumé" },
+        .{ .s = "\"r\\0000e9sumé\"", .exp = "résumé" },
+        .{ .s = "\"a\\\"b\"", .exp = "a\"b" },
+        .{ .s = "\"\\\n\"", .exp = "" },
+        .{ .s = "\"hello world\"", .exp = "hello world" },
+    };
+
+    var buf: std.ArrayListUnmanaged(u8) = .empty;
+    defer buf.deinit(allocator);
+
+    for (testcases) |tc| {
+        buf.clearRetainingCapacity();
+
+        var p = Parser{ .s = tc.s, .opts = .{} };
+        p.parseString(buf.writer(allocator)) catch |e| {
+            // if error was expected, continue.
+            if (tc.err) continue;
+
+            std.debug.print("test case {s}\n", .{tc.s});
+            return e;
+        };
+        std.testing.expectEqualDeep(tc.exp, buf.items) catch |e| {
+            std.debug.print("test case {s} : {s}\n", .{ tc.s, buf.items });
+            return e;
+        };
+    }
+}
+
+test "parser.parse" {
+    var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
+    defer arena.deinit();
+    const allocator = arena.allocator();
+
+    const testcases = [_]struct {
+        s: []const u8, // given value
+        exp: Selector, // expected value
+        err: bool = false,
+    }{
+        .{ .s = "root", .exp = .{ .tag = "root" } },
+        .{ .s = ".root", .exp = .{ .class = "root" } },
+        .{ .s = ":root", .exp = .{ .pseudo_class = .root } },
+        .{ .s = ".\\:bar", .exp = .{ .class = ":bar" } },
+        .{ .s = ".foo\\:bar", .exp = .{ .class = "foo:bar" } },
+        .{ .s = "[class=75c0fa18a94b9e3a6b8e14d6cbe688a27f5da10a]", .exp = .{ .attribute = .{ .key = "class", .val = "75c0fa18a94b9e3a6b8e14d6cbe688a27f5da10a", .op = .eql } } },
+    };
+
+    for (testcases) |tc| {
+        var p = Parser{ .s = tc.s, .opts = .{} };
+        const sel = p.parse(allocator) catch |e| {
+            // if error was expected, continue.
+            if (tc.err) continue;
+
+            std.debug.print("test case {s}\n", .{tc.s});
+            return e;
+        };
+        std.testing.expectEqualDeep(tc.exp, sel) catch |e| {
+            std.debug.print("test case {s} : {}\n", .{ tc.s, sel });
+            return e;
+        };
+    }
+}

src/browser/cssom/CSSParser.zig

@@ -0,0 +1,289 @@
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+
+const CSSConstants = struct {
+    const IMPORTANT = "!important";
+    const URL_PREFIX = "url(";
+};
+
+const CSSParserState = enum {
+    seek_name,
+    in_name,
+    seek_colon,
+    seek_value,
+    in_value,
+    in_quoted_value,
+    in_single_quoted_value,
+    in_url,
+    in_important,
+};
+
+const CSSDeclaration = struct {
+    name: []const u8,
+    value: []const u8,
+    is_important: bool,
+};
+
+const CSSParser = @This();
+state: CSSParserState,
+name_start: usize,
+name_end: usize,
+value_start: usize,
+position: usize,
+paren_depth: usize,
+escape_next: bool,
+
+pub fn init() CSSParser {
+    return .{
+        .state = .seek_name,
+        .name_start = 0,
+        .name_end = 0,
+        .value_start = 0,
+        .position = 0,
+        .paren_depth = 0,
+        .escape_next = false,
+    };
+}
+
+pub fn parseDeclarations(arena: Allocator, text: []const u8) ![]CSSDeclaration {
+    var parser = init();
+    var declarations: std.ArrayListUnmanaged(CSSDeclaration) = .empty;
+
+    while (parser.position < text.len) {
+        const c = text[parser.position];
+
+        switch (parser.state) {
+            .seek_name => {
+                if (!std.ascii.isWhitespace(c)) {
+                    parser.name_start = parser.position;
+                    parser.state = .in_name;
+                    continue;
+                }
+            },
+            .in_name => {
+                if (c == ':') {
+                    parser.name_end = parser.position;
+                    parser.state = .seek_value;
+                } else if (std.ascii.isWhitespace(c)) {
+                    parser.name_end = parser.position;
+                    parser.state = .seek_colon;
+                }
+            },
+            .seek_colon => {
+                if (c == ':') {
+                    parser.state = .seek_value;
+                } else if (!std.ascii.isWhitespace(c)) {
+                    parser.state = .seek_name;
+                    continue;
+                }
+            },
+            .seek_value => {
+                if (!std.ascii.isWhitespace(c)) {
+                    parser.value_start = parser.position;
+                    if (c == '"') {
+                        parser.state = .in_quoted_value;
+                    } else if (c == '\'') {
+                        parser.state = .in_single_quoted_value;
+                    } else if (c == 'u' and parser.position + CSSConstants.URL_PREFIX.len <= text.len and std.mem.startsWith(u8, text[parser.position..], CSSConstants.URL_PREFIX)) {
+                        parser.state = .in_url;
+                        parser.paren_depth = 1;
+                        parser.position += 3;
+                    } else {
+                        parser.state = .in_value;
+                        continue;
+                    }
+                }
+            },
+            .in_value => {
+                if (parser.escape_next) {
+                    parser.escape_next = false;
+                } else if (c == '\\') {
+                    parser.escape_next = true;
+                } else if (c == '(') {
+                    parser.paren_depth += 1;
+                } else if (c == ')' and parser.paren_depth > 0) {
+                    parser.paren_depth -= 1;
+                } else if (c == ';' and parser.paren_depth == 0) {
+                    try parser.finishDeclaration(arena, &declarations, text);
+                    parser.state = .seek_name;
+                }
+            },
+            .in_quoted_value => {
+                if (parser.escape_next) {
+                    parser.escape_next = false;
+                } else if (c == '\\') {
+                    parser.escape_next = true;
+                } else if (c == '"') {
+                    parser.state = .in_value;
+                }
+            },
+            .in_single_quoted_value => {
+                if (parser.escape_next) {
+                    parser.escape_next = false;
+                } else if (c == '\\') {
+                    parser.escape_next = true;
+                } else if (c == '\'') {
+                    parser.state = .in_value;
+                }
+            },
+            .in_url => {
+                if (parser.escape_next) {
+                    parser.escape_next = false;
+                } else if (c == '\\') {
+                    parser.escape_next = true;
+                } else if (c == '(') {
+                    parser.paren_depth += 1;
+                } else if (c == ')') {
+                    parser.paren_depth -= 1;
+                    if (parser.paren_depth == 0) {
+                        parser.state = .in_value;
+                    }
+                }
+            },
+            .in_important => {},
+        }
+
+        parser.position += 1;
+    }
+
+    try parser.finalize(arena, &declarations, text);
+
+    return declarations.items;
+}
+
+fn finishDeclaration(self: *CSSParser, arena: Allocator, declarations: *std.ArrayListUnmanaged(CSSDeclaration), text: []const u8) !void {
+    const name = std.mem.trim(u8, text[self.name_start..self.name_end], &std.ascii.whitespace);
+    if (name.len == 0) return;
+
+    const raw_value = text[self.value_start..self.position];
+    const value = std.mem.trim(u8, raw_value, &std.ascii.whitespace);
+
+    var final_value = value;
+    var is_important = false;
+
+    if (std.mem.endsWith(u8, value, CSSConstants.IMPORTANT)) {
+        is_important = true;
+        final_value = std.mem.trimRight(u8, value[0 .. value.len - CSSConstants.IMPORTANT.len], &std.ascii.whitespace);
+    }
+
+    try declarations.append(arena, .{
+        .name = name,
+        .value = final_value,
+        .is_important = is_important,
+    });
+}
+
+fn finalize(self: *CSSParser, arena: Allocator, declarations: *std.ArrayListUnmanaged(CSSDeclaration), text: []const u8) !void {
+    if (self.state != .in_value) {
+        return;
+    }
+    return self.finishDeclaration(arena, declarations, text);
+}
+
+const testing = @import("../../testing.zig");
+test "Browser: CSS.Parser - Simple property" {
+    defer testing.reset();
+
+    const text = "color: red;";
+    const allocator = testing.arena_allocator;
+
+    const declarations = try CSSParser.parseDeclarations(allocator, text);
+
+    try testing.expectEqual(1, declarations.len);
+    try testing.expectEqual("color", declarations[0].name);
+    try testing.expectEqual("red", declarations[0].value);
+    try testing.expectEqual(false, declarations[0].is_important);
+}
+
+test "Browser: CSS.Parser - Property with !important" {
+    defer testing.reset();
+    const text = "margin: 10px !important;";
+    const allocator = testing.arena_allocator;
+
+    const declarations = try CSSParser.parseDeclarations(allocator, text);
+
+    try testing.expectEqual(1, declarations.len);
+    try testing.expectEqual("margin", declarations[0].name);
+    try testing.expectEqual("10px", declarations[0].value);
+    try testing.expectEqual(true, declarations[0].is_important);
+}
+
+test "Browser: CSS.Parser - Multiple properties" {
+    defer testing.reset();
+    const text = "color: red; font-size: 12px; margin: 5px !important;";
+    const allocator = testing.arena_allocator;
+
+    const declarations = try CSSParser.parseDeclarations(allocator, text);
+
+    try testing.expect(declarations.len == 3);
+
+    try testing.expectEqual("color", declarations[0].name);
+    try testing.expectEqual("red", declarations[0].value);
+    try testing.expectEqual(false, declarations[0].is_important);
+
+    try testing.expectEqual("font-size", declarations[1].name);
+    try testing.expectEqual("12px", declarations[1].value);
+    try testing.expectEqual(false, declarations[1].is_important);
+
+    try testing.expectEqual("margin", declarations[2].name);
+    try testing.expectEqual("5px", declarations[2].value);
+    try testing.expectEqual(true, declarations[2].is_important);
+}
+
+test "Browser: CSS.Parser - Quoted value with semicolon" {
+    defer testing.reset();
+    const text = "content: \"Hello; world!\";";
+    const allocator = testing.arena_allocator;
+
+    const declarations = try CSSParser.parseDeclarations(allocator, text);
+
+    try testing.expectEqual(1, declarations.len);
+    try testing.expectEqual("content", declarations[0].name);
+    try testing.expectEqual("\"Hello; world!\"", declarations[0].value);
+    try testing.expectEqual(false, declarations[0].is_important);
+}
+
+test "Browser: CSS.Parser - URL value" {
+    defer testing.reset();
+    const text = "background-image: url(\"test.png\");";
+    const allocator = testing.arena_allocator;
+
+    const declarations = try CSSParser.parseDeclarations(allocator, text);
+
+    try testing.expectEqual(1, declarations.len);
+    try testing.expectEqual("background-image", declarations[0].name);
+    try testing.expectEqual("url(\"test.png\")", declarations[0].value);
+    try testing.expectEqual(false, declarations[0].is_important);
+}
+
+test "Browser: CSS.Parser - Whitespace handling" {
+    defer testing.reset();
+    const text = "  color  :  purple  ;  margin  :  10px  ;  ";
+    const allocator = testing.arena_allocator;
+
+    const declarations = try CSSParser.parseDeclarations(allocator, text);
+
+    try testing.expectEqual(2, declarations.len);
+    try testing.expectEqual("color", declarations[0].name);
+    try testing.expectEqual("purple", declarations[0].value);
+    try testing.expectEqual("margin", declarations[1].name);
+    try testing.expectEqual("10px", declarations[1].value);
+}

src/browser/cssom/CSSRule.zig

@@ -0,0 +1,41 @@
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const std = @import("std");
+
+const CSSStyleSheet = @import("CSSStyleSheet.zig");
+
+pub const Interfaces = .{
+    CSSRule,
+    CSSImportRule,
+};
+
+// https://developer.mozilla.org/en-US/docs/Web/API/CSSRule
+const CSSRule = @This();
+css_text: []const u8,
+parent_rule: ?*CSSRule = null,
+parent_stylesheet: ?*CSSStyleSheet = null,
+
+pub const CSSImportRule = struct {
+    pub const prototype = *CSSRule;
+    href: []const u8,
+    layer_name: ?[]const u8,
+    media: void,
+    style_sheet: CSSStyleSheet,
+    supports_text: ?[]const u8,
+};

src/browser/cssom/CSSRuleList.zig

@@ -1,4 +1,4 @@
-// Copyright (C) 2023-2025  Lightpanda (Selecy SAS)
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
 //
 // Francis Bouvier <francis@lightpanda.io>
 // Pierre Tachoire <pierre@lightpanda.io>
@@ -17,31 +17,35 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 const std = @import("std");
-const lp = @import("lightpanda");
 
-pub fn main() !void {
-    const allocator = std.heap.c_allocator;
+const CSSRule = @import("CSSRule.zig");
 
-    var platform = try lp.js.Platform.init();
-    defer platform.deinit();
+const CSSImportRule = CSSRule.CSSImportRule;
 
-    const snapshot = try lp.js.Snapshot.create();
-    defer snapshot.deinit();
+const CSSRuleList = @This();
+list: std.ArrayListUnmanaged([]const u8),
 
-    var is_stdout = true;
-    var file = std.fs.File.stdout();
-    var args = try std.process.argsWithAllocator(allocator);
-    _ = args.next(); // executable name
-    if (args.next()) |n| {
-        is_stdout = false;
-        file = try std.fs.cwd().createFile(n, .{});
-    }
-    defer if (!is_stdout) {
-        file.close();
-    };
-
-    var buffer: [4096]u8 = undefined;
-    var writer = file.writer(&buffer);
-    try snapshot.write(&writer.interface);
-    try writer.end();
+pub fn constructor() CSSRuleList {
+    return .{ .list = .empty };
+}
+
+pub fn _item(self: *CSSRuleList, _index: u32) ?CSSRule {
+    const index: usize = @intCast(_index);
+
+    if (index > self.list.items.len) {
+        return null;
+    }
+
+    // todo: for now, just return null.
+    // this depends on properly parsing CSSRule
+    return null;
+}
+
+pub fn get_length(self: *CSSRuleList) u32 {
+    return @intCast(self.list.items.len);
+}
+
+const testing = @import("../../testing.zig");
+test "Browser: CSS.CSSRuleList" {
+    try testing.htmlRunner("cssom/css_rule_list.html");
 }

src/browser/cssom/CSSStyleDeclaration.zig

@@ -0,0 +1,958 @@
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const std = @import("std");
+
+const Page = @import("../page.zig").Page;
+const CSSRule = @import("CSSRule.zig");
+const CSSParser = @import("CSSParser.zig");
+
+const Property = struct {
+    value: []const u8,
+    priority: bool,
+};
+
+const CSSStyleDeclaration = @This();
+
+properties: std.StringArrayHashMapUnmanaged(Property),
+
+pub const empty: CSSStyleDeclaration = .{
+    .properties = .empty,
+};
+
+pub fn get_cssFloat(self: *const CSSStyleDeclaration) []const u8 {
+    return self._getPropertyValue("float");
+}
+
+pub fn set_cssFloat(self: *CSSStyleDeclaration, value: ?[]const u8, page: *Page) !void {
+    const final_value = value orelse "";
+    return self._setProperty("float", final_value, null, page);
+}
+
+pub fn get_cssText(self: *const CSSStyleDeclaration, page: *Page) ![]const u8 {
+    var buffer: std.ArrayListUnmanaged(u8) = .empty;
+    const writer = buffer.writer(page.call_arena);
+    var it = self.properties.iterator();
+    while (it.next()) |entry| {
+        const name = entry.key_ptr.*;
+        const property = entry.value_ptr;
+        const escaped = try escapeCSSValue(page.call_arena, property.value);
+        try writer.print("{s}: {s}", .{ name, escaped });
+        if (property.priority) {
+            try writer.writeAll(" !important; ");
+        } else {
+            try writer.writeAll("; ");
+        }
+    }
+    return buffer.items;
+}
+
+// TODO Propagate also upward to parent node
+pub fn set_cssText(self: *CSSStyleDeclaration, text: []const u8, page: *Page) !void {
+    self.properties.clearRetainingCapacity();
+
+    // call_arena is safe here, because _setProperty will dupe the name
+    // using the page's longer-living arena.
+    const declarations = try CSSParser.parseDeclarations(page.call_arena, text);
+
+    for (declarations) |decl| {
+        if (!isValidPropertyName(decl.name)) {
+            continue;
+        }
+        const priority: ?[]const u8 = if (decl.is_important) "important" else null;
+        try self._setProperty(decl.name, decl.value, priority, page);
+    }
+}
+
+pub fn get_length(self: *const CSSStyleDeclaration) usize {
+    return self.properties.count();
+}
+
+pub fn get_parentRule(_: *const CSSStyleDeclaration) ?CSSRule {
+    return null;
+}
+
+pub fn _getPropertyPriority(self: *const CSSStyleDeclaration, name: []const u8) []const u8 {
+    const property = self.properties.getPtr(name) orelse return "";
+    return if (property.priority) "important" else "";
+}
+
+// TODO should handle properly shorthand properties and canonical forms
+pub fn _getPropertyValue(self: *const CSSStyleDeclaration, name: []const u8) []const u8 {
+    if (self.properties.getPtr(name)) |property| {
+        return property.value;
+    }
+
+    // default to everything being visible (unless it's been explicitly set)
+    if (std.mem.eql(u8, name, "visibility")) {
+        return "visible";
+    }
+
+    return "";
+}
+
+pub fn _item(self: *const CSSStyleDeclaration, index: usize) []const u8 {
+    const values = self.properties.entries.items(.key);
+    if (index >= values.len) {
+        return "";
+    }
+    return values[index];
+}
+
+pub fn _removeProperty(self: *CSSStyleDeclaration, name: []const u8) ![]const u8 {
+    const property = self.properties.fetchOrderedRemove(name) orelse return "";
+    return property.value.value;
+}
+
+pub fn _setProperty(self: *CSSStyleDeclaration, name: []const u8, value: []const u8, priority: ?[]const u8, page: *Page) !void {
+    const gop = try self.properties.getOrPut(page.arena, name);
+    if (!gop.found_existing) {
+        const owned_name = try page.arena.dupe(u8, name);
+        gop.key_ptr.* = owned_name;
+    }
+
+    const owned_value = try page.arena.dupe(u8, value);
+    const is_important = priority != null and std.ascii.eqlIgnoreCase(priority.?, "important");
+    gop.value_ptr.* = .{ .value = owned_value, .priority = is_important };
+}
+
+pub fn named_get(self: *const CSSStyleDeclaration, name: []const u8, _: *bool) []const u8 {
+    return self._getPropertyValue(name);
+}
+
+pub fn named_set(self: *CSSStyleDeclaration, name: []const u8, value: []const u8, _: *bool, page: *Page) !void {
+    return self._setProperty(name, value, null, page);
+}
+
+fn isNumericWithUnit(value: []const u8) bool {
+    if (value.len == 0) {
+        return false;
+    }
+
+    const first = value[0];
+
+    if (!std.ascii.isDigit(first) and first != '+' and first != '-' and first != '.') {
+        return false;
+    }
+
+    var i: usize = 0;
+    var has_digit = false;
+    var decimal_point = false;
+
+    while (i < value.len) : (i += 1) {
+        const c = value[i];
+        if (std.ascii.isDigit(c)) {
+            has_digit = true;
+        } else if (c == '.' and !decimal_point) {
+            decimal_point = true;
+        } else if ((c == 'e' or c == 'E') and has_digit) {
+            if (i + 1 >= value.len) return false;
+            if (value[i + 1] != '+' and value[i + 1] != '-' and !std.ascii.isDigit(value[i + 1])) break;
+            i += 1;
+            if (value[i] == '+' or value[i] == '-') {
+                i += 1;
+            }
+            var has_exp_digits = false;
+            while (i < value.len and std.ascii.isDigit(value[i])) : (i += 1) {
+                has_exp_digits = true;
+            }
+            if (!has_exp_digits) return false;
+            break;
+        } else if (c != '-' and c != '+') {
+            break;
+        }
+    }
+
+    if (!has_digit) {
+        return false;
+    }
+
+    if (i == value.len) {
+        return true;
+    }
+
+    const unit = value[i..];
+    return CSSKeywords.isValidUnit(unit);
+}
+
+pub fn isHexColor(value: []const u8) bool {
+    if (value.len == 0) {
+        return false;
+    }
+    if (value[0] != '#') {
+        return false;
+    }
+
+    const hex_part = value[1..];
+    if (hex_part.len != 3 and hex_part.len != 4 and hex_part.len != 6 and hex_part.len != 8) {
+        return false;
+    }
+
+    for (hex_part) |c| {
+        if (!std.ascii.isHex(c)) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+fn isMultiValueProperty(value: []const u8) bool {
+    var parts = std.mem.splitAny(u8, value, " ");
+    var multi_value_parts: usize = 0;
+    var all_parts_valid = true;
+
+    while (parts.next()) |part| {
+        if (part.len == 0) continue;
+        multi_value_parts += 1;
+
+        if (isNumericWithUnit(part)) {
+            continue;
+        }
+        if (isHexColor(part)) {
+            continue;
+        }
+        if (CSSKeywords.isKnownKeyword(part)) {
+            continue;
+        }
+        if (CSSKeywords.startsWithFunction(part)) {
+            continue;
+        }
+
+        all_parts_valid = false;
+        break;
+    }
+
+    return multi_value_parts >= 2 and all_parts_valid;
+}
+
+fn isAlreadyQuoted(value: []const u8) bool {
+    return value.len >= 2 and ((value[0] == '"' and value[value.len - 1] == '"') or
+        (value[0] == '\'' and value[value.len - 1] == '\''));
+}
+
+fn isValidPropertyName(name: []const u8) bool {
+    if (name.len == 0) return false;
+
+    if (std.mem.startsWith(u8, name, "--")) {
+        if (name.len == 2) return false;
+        for (name[2..]) |c| {
+            if (!std.ascii.isAlphanumeric(c) and c != '-' and c != '_') {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    const first_char = name[0];
+    if (!std.ascii.isAlphabetic(first_char) and first_char != '-') {
+        return false;
+    }
+
+    if (first_char == '-') {
+        if (name.len < 2) return false;
+
+        if (!std.ascii.isAlphabetic(name[1])) {
+            return false;
+        }
+
+        for (name[2..]) |c| {
+            if (!std.ascii.isAlphanumeric(c) and c != '-') {
+                return false;
+            }
+        }
+    } else {
+        for (name[1..]) |c| {
+            if (!std.ascii.isAlphanumeric(c) and c != '-') {
+                return false;
+            }
+        }
+    }
+
+    return true;
+}
+
+fn extractImportant(value: []const u8) struct { value: []const u8, is_important: bool } {
+    const trimmed = std.mem.trim(u8, value, &std.ascii.whitespace);
+
+    if (std.mem.endsWith(u8, trimmed, "!important")) {
+        const clean_value = std.mem.trimRight(u8, trimmed[0 .. trimmed.len - 10], &std.ascii.whitespace);
+        return .{ .value = clean_value, .is_important = true };
+    }
+
+    return .{ .value = trimmed, .is_important = false };
+}
+
+fn needsQuotes(value: []const u8) bool {
+    if (value.len == 0) return true;
+    if (isAlreadyQuoted(value)) return false;
+
+    if (CSSKeywords.containsSpecialChar(value)) {
+        return true;
+    }
+
+    if (std.mem.indexOfScalar(u8, value, ' ') == null) {
+        return false;
+    }
+
+    const is_url = std.mem.startsWith(u8, value, "url(");
+    const is_function = CSSKeywords.startsWithFunction(value);
+
+    return !isMultiValueProperty(value) and
+        !is_url and
+        !is_function;
+}
+
+fn escapeCSSValue(arena: std.mem.Allocator, value: []const u8) ![]const u8 {
+    if (!needsQuotes(value)) {
+        return value;
+    }
+    var out: std.ArrayListUnmanaged(u8) = .empty;
+
+    // We'll need at least this much space, +2 for the quotes
+    try out.ensureTotalCapacity(arena, value.len + 2);
+    const writer = out.writer(arena);
+
+    try writer.writeByte('"');
+
+    for (value, 0..) |c, i| {
+        switch (c) {
+            '"' => try writer.writeAll("\\\""),
+            '\\' => try writer.writeAll("\\\\"),
+            '\n' => try writer.writeAll("\\A "),
+            '\r' => try writer.writeAll("\\D "),
+            '\t' => try writer.writeAll("\\9 "),
+            0...8, 11, 12, 14...31, 127 => {
+                try writer.print("\\{x}", .{c});
+                if (i + 1 < value.len and std.ascii.isHex(value[i + 1])) {
+                    try writer.writeByte(' ');
+                }
+            },
+            else => try writer.writeByte(c),
+        }
+    }
+
+    try writer.writeByte('"');
+    return out.items;
+}
+
+fn isKnownKeyword(value: []const u8) bool {
+    return CSSKeywords.isKnownKeyword(value);
+}
+
+fn containsSpecialChar(value: []const u8) bool {
+    return CSSKeywords.containsSpecialChar(value);
+}
+
+const CSSKeywords = struct {
+    const BORDER_STYLES = [_][]const u8{
+        "none", "solid", "dotted", "dashed", "double", "groove", "ridge", "inset", "outset",
+    };
+
+    const COLOR_NAMES = [_][]const u8{
+        "black",        "white",   "red", "green", "blue", "yellow", "purple", "gray", "transparent",
+        "currentColor", "inherit",
+    };
+
+    const POSITION_KEYWORDS = [_][]const u8{
+        "auto", "center", "left", "right", "top", "bottom",
+    };
+
+    const BACKGROUND_REPEAT = [_][]const u8{
+        "repeat", "no-repeat", "repeat-x", "repeat-y", "space", "round",
+    };
+
+    const FONT_STYLES = [_][]const u8{
+        "normal", "italic", "oblique", "bold", "bolder", "lighter",
+    };
+
+    const FONT_SIZES = [_][]const u8{
+        "xx-small", "x-small", "small", "medium", "large", "x-large", "xx-large",
+        "smaller",  "larger",
+    };
+
+    const FONT_FAMILIES = [_][]const u8{
+        "serif", "sans-serif", "monospace", "cursive", "fantasy", "system-ui",
+    };
+
+    const CSS_GLOBAL = [_][]const u8{
+        "initial", "inherit", "unset", "revert",
+    };
+
+    const DISPLAY_VALUES = [_][]const u8{
+        "block", "inline", "inline-block", "flex", "grid", "none",
+    };
+
+    const UNITS = [_][]const u8{
+        // LENGTH
+        "px",   "em", "rem", "vw",  "vh",  "vmin", "vmax", "%", "pt", "pc", "in",  "cm",  "mm",
+        "ex",   "ch", "fr",
+
+        // ANGLE
+         "deg", "rad", "grad", "turn",
+
+        // TIME
+        "s", "ms",
+
+        // FREQUENCY
+        "hz", "khz",
+
+        // RESOLUTION
+        "dpi", "dpcm",
+        "dppx",
+    };
+
+    const SPECIAL_CHARS = [_]u8{
+        '"', '\'', ';', '{', '}', '\\', '<', '>', '/', '\n', '\t', '\r', '\x00', '\x7F',
+    };
+
+    const FUNCTIONS = [_][]const u8{
+        "rgb(",             "rgba(",            "hsl(",            "hsla(",      "url(",    "calc(",  "var(",  "attr(",
+        "linear-gradient(", "radial-gradient(", "conic-gradient(", "translate(", "rotate(", "scale(", "skew(", "matrix(",
+    };
+
+    const KEYWORDS = BORDER_STYLES ++ COLOR_NAMES ++ POSITION_KEYWORDS ++
+        BACKGROUND_REPEAT ++ FONT_STYLES ++ FONT_SIZES ++ FONT_FAMILIES ++
+        CSS_GLOBAL ++ DISPLAY_VALUES;
+
+    const MAX_KEYWORD_LEN = lengthOfLongestValue(&KEYWORDS);
+
+    pub fn isKnownKeyword(value: []const u8) bool {
+        if (value.len > MAX_KEYWORD_LEN) {
+            return false;
+        }
+        var buf: [MAX_KEYWORD_LEN]u8 = undefined;
+        const normalized = std.ascii.lowerString(&buf, value);
+
+        for (KEYWORDS) |keyword| {
+            if (std.ascii.eqlIgnoreCase(normalized, keyword)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    pub fn containsSpecialChar(value: []const u8) bool {
+        return std.mem.indexOfAny(u8, value, &SPECIAL_CHARS) != null;
+    }
+
+    const MAX_UNIT_LEN = lengthOfLongestValue(&UNITS);
+
+    pub fn isValidUnit(unit: []const u8) bool {
+        if (unit.len > MAX_UNIT_LEN) {
+            return false;
+        }
+        var buf: [MAX_UNIT_LEN]u8 = undefined;
+        const normalized = std.ascii.lowerString(&buf, unit);
+
+        for (UNITS) |u| {
+            if (std.mem.eql(u8, normalized, u)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    pub fn startsWithFunction(value: []const u8) bool {
+        const pos = std.mem.indexOfScalar(u8, value, '(') orelse return false;
+        if (pos == 0) return false;
+
+        if (std.mem.indexOfScalarPos(u8, value, pos, ')') == null) {
+            return false;
+        }
+        const function_name = value[0..pos];
+        return isValidFunctionName(function_name);
+    }
+
+    fn isValidFunctionName(name: []const u8) bool {
+        if (name.len == 0) return false;
+
+        const first = name[0];
+        if (!std.ascii.isAlphabetic(first) and first != '_' and first != '-') {
+            return false;
+        }
+
+        for (name[1..]) |c| {
+            if (!std.ascii.isAlphanumeric(c) and c != '_' and c != '-') {
+                return false;
+            }
+        }
+
+        return true;
+    }
+};
+
+fn lengthOfLongestValue(values: []const []const u8) usize {
+    var max: usize = 0;
+    for (values) |v| {
+        max = @max(v.len, max);
+    }
+    return max;
+}
+
+const testing = @import("../../testing.zig");
+test "Browser: CSS.StyleDeclaration" {
+    try testing.htmlRunner("cssom/css_style_declaration.html");
+}
+
+test "Browser: CSS.StyleDeclaration: isNumericWithUnit - valid numbers with units" {
+    try testing.expect(isNumericWithUnit("10px"));
+    try testing.expect(isNumericWithUnit("3.14em"));
+    try testing.expect(isNumericWithUnit("-5rem"));
+    try testing.expect(isNumericWithUnit("+12.5%"));
+    try testing.expect(isNumericWithUnit("0vh"));
+    try testing.expect(isNumericWithUnit(".5vw"));
+}
+
+test "Browser: CSS.StyleDeclaration: isNumericWithUnit - scientific notation" {
+    try testing.expect(isNumericWithUnit("1e5px"));
+    try testing.expect(isNumericWithUnit("2.5E-3em"));
+    try testing.expect(isNumericWithUnit("1e+2rem"));
+    try testing.expect(isNumericWithUnit("-3.14e10px"));
+}
+
+test "Browser: CSS.StyleDeclaration: isNumericWithUnit - edge cases and invalid inputs" {
+    try testing.expect(!isNumericWithUnit(""));
+
+    try testing.expect(!isNumericWithUnit("px"));
+    try testing.expect(!isNumericWithUnit("--px"));
+    try testing.expect(!isNumericWithUnit(".px"));
+
+    try testing.expect(!isNumericWithUnit("1e"));
+    try testing.expect(!isNumericWithUnit("1epx"));
+    try testing.expect(!isNumericWithUnit("1e+"));
+    try testing.expect(!isNumericWithUnit("1e+px"));
+
+    try testing.expect(!isNumericWithUnit("1.2.3px"));
+
+    try testing.expect(!isNumericWithUnit("10xyz"));
+    try testing.expect(!isNumericWithUnit("5invalid"));
+
+    try testing.expect(isNumericWithUnit("10"));
+    try testing.expect(isNumericWithUnit("3.14"));
+    try testing.expect(isNumericWithUnit("-5"));
+}
+
+test "Browser: CSS.StyleDeclaration: isHexColor - valid hex colors" {
+    try testing.expect(isHexColor("#000"));
+    try testing.expect(isHexColor("#0000"));
+    try testing.expect(isHexColor("#fff"));
+    try testing.expect(isHexColor("#123456"));
+    try testing.expect(isHexColor("#abcdef"));
+    try testing.expect(isHexColor("#ABCDEF"));
+    try testing.expect(isHexColor("#12345678"));
+}
+
+test "Browser: CSS.StyleDeclaration: isHexColor - invalid hex colors" {
+    try testing.expect(!isHexColor(""));
+    try testing.expect(!isHexColor("#"));
+    try testing.expect(!isHexColor("000"));
+    try testing.expect(!isHexColor("#00"));
+    try testing.expect(!isHexColor("#00000"));
+    try testing.expect(!isHexColor("#0000000"));
+    try testing.expect(!isHexColor("#000000000"));
+    try testing.expect(!isHexColor("#gggggg"));
+    try testing.expect(!isHexColor("#123xyz"));
+}
+
+test "Browser: CSS.StyleDeclaration: isMultiValueProperty - valid multi-value properties" {
+    try testing.expect(isMultiValueProperty("10px 20px"));
+    try testing.expect(isMultiValueProperty("solid red"));
+    try testing.expect(isMultiValueProperty("#fff black"));
+    try testing.expect(isMultiValueProperty("1em 2em 3em 4em"));
+    try testing.expect(isMultiValueProperty("rgb(255,0,0) solid"));
+}
+
+test "Browser: CSS.StyleDeclaration: isMultiValueProperty - invalid multi-value properties" {
+    try testing.expect(!isMultiValueProperty(""));
+    try testing.expect(!isMultiValueProperty("10px"));
+    try testing.expect(!isMultiValueProperty("invalid unknown"));
+    try testing.expect(!isMultiValueProperty("10px invalid"));
+    try testing.expect(!isMultiValueProperty("   "));
+}
+
+test "Browser: CSS.StyleDeclaration: isAlreadyQuoted - various quoting scenarios" {
+    try testing.expect(isAlreadyQuoted("\"hello\""));
+    try testing.expect(isAlreadyQuoted("'world'"));
+    try testing.expect(isAlreadyQuoted("\"\""));
+    try testing.expect(isAlreadyQuoted("''"));
+
+    try testing.expect(!isAlreadyQuoted(""));
+    try testing.expect(!isAlreadyQuoted("hello"));
+    try testing.expect(!isAlreadyQuoted("\""));
+    try testing.expect(!isAlreadyQuoted("'"));
+    try testing.expect(!isAlreadyQuoted("\"hello'"));
+    try testing.expect(!isAlreadyQuoted("'hello\""));
+    try testing.expect(!isAlreadyQuoted("\"hello"));
+    try testing.expect(!isAlreadyQuoted("hello\""));
+}
+
+test "Browser: CSS.StyleDeclaration: isValidPropertyName - valid property names" {
+    try testing.expect(isValidPropertyName("color"));
+    try testing.expect(isValidPropertyName("background-color"));
+    try testing.expect(isValidPropertyName("-webkit-transform"));
+    try testing.expect(isValidPropertyName("font-size"));
+    try testing.expect(isValidPropertyName("margin-top"));
+    try testing.expect(isValidPropertyName("z-index"));
+    try testing.expect(isValidPropertyName("line-height"));
+}
+
+test "Browser: CSS.StyleDeclaration: isValidPropertyName - invalid property names" {
+    try testing.expect(!isValidPropertyName(""));
+    try testing.expect(!isValidPropertyName("123color"));
+    try testing.expect(!isValidPropertyName("color!"));
+    try testing.expect(!isValidPropertyName("color space"));
+    try testing.expect(!isValidPropertyName("@color"));
+    try testing.expect(!isValidPropertyName("color.test"));
+    try testing.expect(!isValidPropertyName("color_test"));
+}
+
+test "Browser: CSS.StyleDeclaration: extractImportant - with and without !important" {
+    var result = extractImportant("red !important");
+    try testing.expect(result.is_important);
+    try testing.expectEqual("red", result.value);
+
+    result = extractImportant("blue");
+    try testing.expect(!result.is_important);
+    try testing.expectEqual("blue", result.value);
+
+    result = extractImportant("  green  !important  ");
+    try testing.expect(result.is_important);
+    try testing.expectEqual("green", result.value);
+
+    result = extractImportant("!important");
+    try testing.expect(result.is_important);
+    try testing.expectEqual("", result.value);
+
+    result = extractImportant("important");
+    try testing.expect(!result.is_important);
+    try testing.expectEqual("important", result.value);
+}
+
+test "Browser: CSS.StyleDeclaration: needsQuotes - various scenarios" {
+    try testing.expect(needsQuotes(""));
+    try testing.expect(needsQuotes("hello world"));
+    try testing.expect(needsQuotes("test;"));
+    try testing.expect(needsQuotes("a{b}"));
+    try testing.expect(needsQuotes("test\"quote"));
+
+    try testing.expect(!needsQuotes("\"already quoted\""));
+    try testing.expect(!needsQuotes("'already quoted'"));
+    try testing.expect(!needsQuotes("url(image.png)"));
+    try testing.expect(!needsQuotes("rgb(255, 0, 0)"));
+    try testing.expect(!needsQuotes("10px 20px"));
+    try testing.expect(!needsQuotes("simple"));
+}
+
+test "Browser: CSS.StyleDeclaration: escapeCSSValue - escaping various characters" {
+    const allocator = testing.arena_allocator;
+
+    var result = try escapeCSSValue(allocator, "simple");
+    try testing.expectEqual("simple", result);
+
+    result = try escapeCSSValue(allocator, "\"already quoted\"");
+    try testing.expectEqual("\"already quoted\"", result);
+
+    result = try escapeCSSValue(allocator, "test\"quote");
+    try testing.expectEqual("\"test\\\"quote\"", result);
+
+    result = try escapeCSSValue(allocator, "test\nline");
+    try testing.expectEqual("\"test\\A line\"", result);
+
+    result = try escapeCSSValue(allocator, "test\\back");
+    try testing.expectEqual("\"test\\\\back\"", result);
+}
+
+test "Browser: CSS.StyleDeclaration: CSSKeywords.isKnownKeyword - case sensitivity" {
+    try testing.expect(CSSKeywords.isKnownKeyword("red"));
+    try testing.expect(CSSKeywords.isKnownKeyword("solid"));
+    try testing.expect(CSSKeywords.isKnownKeyword("center"));
+    try testing.expect(CSSKeywords.isKnownKeyword("inherit"));
+
+    try testing.expect(CSSKeywords.isKnownKeyword("RED"));
+    try testing.expect(CSSKeywords.isKnownKeyword("Red"));
+    try testing.expect(CSSKeywords.isKnownKeyword("SOLID"));
+    try testing.expect(CSSKeywords.isKnownKeyword("Center"));
+
+    try testing.expect(!CSSKeywords.isKnownKeyword("invalid"));
+    try testing.expect(!CSSKeywords.isKnownKeyword("unknown"));
+    try testing.expect(!CSSKeywords.isKnownKeyword(""));
+}
+
+test "Browser: CSS.StyleDeclaration: CSSKeywords.containsSpecialChar - various special characters" {
+    try testing.expect(CSSKeywords.containsSpecialChar("test\"quote"));
+    try testing.expect(CSSKeywords.containsSpecialChar("test'quote"));
+    try testing.expect(CSSKeywords.containsSpecialChar("test;end"));
+    try testing.expect(CSSKeywords.containsSpecialChar("test{brace"));
+    try testing.expect(CSSKeywords.containsSpecialChar("test}brace"));
+    try testing.expect(CSSKeywords.containsSpecialChar("test\\back"));
+    try testing.expect(CSSKeywords.containsSpecialChar("test<angle"));
+    try testing.expect(CSSKeywords.containsSpecialChar("test>angle"));
+    try testing.expect(CSSKeywords.containsSpecialChar("test/slash"));
+
+    try testing.expect(!CSSKeywords.containsSpecialChar("normal-text"));
+    try testing.expect(!CSSKeywords.containsSpecialChar("text123"));
+    try testing.expect(!CSSKeywords.containsSpecialChar(""));
+}
+
+test "Browser: CSS.StyleDeclaration: CSSKeywords.isValidUnit - various units" {
+    try testing.expect(CSSKeywords.isValidUnit("px"));
+    try testing.expect(CSSKeywords.isValidUnit("em"));
+    try testing.expect(CSSKeywords.isValidUnit("rem"));
+    try testing.expect(CSSKeywords.isValidUnit("%"));
+
+    try testing.expect(CSSKeywords.isValidUnit("deg"));
+    try testing.expect(CSSKeywords.isValidUnit("rad"));
+
+    try testing.expect(CSSKeywords.isValidUnit("s"));
+    try testing.expect(CSSKeywords.isValidUnit("ms"));
+
+    try testing.expect(CSSKeywords.isValidUnit("PX"));
+
+    try testing.expect(!CSSKeywords.isValidUnit("invalid"));
+    try testing.expect(!CSSKeywords.isValidUnit(""));
+}
+
+test "Browser: CSS.StyleDeclaration: CSSKeywords.startsWithFunction - function detection" {
+    try testing.expect(CSSKeywords.startsWithFunction("rgb(255, 0, 0)"));
+    try testing.expect(CSSKeywords.startsWithFunction("rgba(255, 0, 0, 0.5)"));
+    try testing.expect(CSSKeywords.startsWithFunction("url(image.png)"));
+    try testing.expect(CSSKeywords.startsWithFunction("calc(100% - 20px)"));
+    try testing.expect(CSSKeywords.startsWithFunction("var(--custom-property)"));
+    try testing.expect(CSSKeywords.startsWithFunction("linear-gradient(to right, red, blue)"));
+
+    try testing.expect(CSSKeywords.startsWithFunction("custom-function(args)"));
+    try testing.expect(CSSKeywords.startsWithFunction("unknown(test)"));
+
+    try testing.expect(!CSSKeywords.startsWithFunction("not-a-function"));
+    try testing.expect(!CSSKeywords.startsWithFunction("missing-paren)"));
+    try testing.expect(!CSSKeywords.startsWithFunction("missing-close("));
+    try testing.expect(!CSSKeywords.startsWithFunction(""));
+    try testing.expect(!CSSKeywords.startsWithFunction("rgb"));
+}
+
+test "Browser: CSS.StyleDeclaration: isNumericWithUnit - whitespace handling" {
+    try testing.expect(!isNumericWithUnit(" 10px"));
+    try testing.expect(!isNumericWithUnit("10 px"));
+    try testing.expect(!isNumericWithUnit("10px "));
+    try testing.expect(!isNumericWithUnit(" 10 px "));
+}
+
+test "Browser: CSS.StyleDeclaration: extractImportant - whitespace edge cases" {
+    var result = extractImportant("   ");
+    try testing.expect(!result.is_important);
+    try testing.expectEqual("", result.value);
+
+    result = extractImportant("\t\n\r !important\t\n");
+    try testing.expect(result.is_important);
+    try testing.expectEqual("", result.value);
+
+    result = extractImportant("red\t!important");
+    try testing.expect(result.is_important);
+    try testing.expectEqual("red", result.value);
+}
+
+test "Browser: CSS.StyleDeclaration: isHexColor - mixed case handling" {
+    try testing.expect(isHexColor("#AbC"));
+    try testing.expect(isHexColor("#123aBc"));
+    try testing.expect(isHexColor("#FFffFF"));
+    try testing.expect(isHexColor("#000FFF"));
+}
+
+test "Browser: CSS.StyleDeclaration: edge case - very long inputs" {
+    const long_valid = "a" ** 1000 ++ "px";
+    try testing.expect(!isNumericWithUnit(long_valid)); // not numeric
+
+    const long_property = "a-" ** 100 ++ "property";
+    try testing.expect(isValidPropertyName(long_property));
+
+    const long_hex = "#" ++ "a" ** 20;
+    try testing.expect(!isHexColor(long_hex));
+}
+
+test "Browser: CSS.StyleDeclaration: boundary conditions - numeric parsing" {
+    try testing.expect(isNumericWithUnit("0px"));
+    try testing.expect(isNumericWithUnit("0.0px"));
+    try testing.expect(isNumericWithUnit(".0px"));
+    try testing.expect(isNumericWithUnit("0.px"));
+
+    try testing.expect(isNumericWithUnit("999999999px"));
+    try testing.expect(isNumericWithUnit("1.7976931348623157e+308px"));
+
+    try testing.expect(isNumericWithUnit("0.000000001px"));
+    try testing.expect(isNumericWithUnit("1e-100px"));
+}
+
+test "Browser: CSS.StyleDeclaration: extractImportant - malformed important declarations" {
+    var result = extractImportant("red ! important");
+    try testing.expect(!result.is_important);
+    try testing.expectEqual("red ! important", result.value);
+
+    result = extractImportant("red !Important");
+    try testing.expect(!result.is_important);
+    try testing.expectEqual("red !Important", result.value);
+
+    result = extractImportant("red !IMPORTANT");
+    try testing.expect(!result.is_important);
+    try testing.expectEqual("red !IMPORTANT", result.value);
+
+    result = extractImportant("!importantred");
+    try testing.expect(!result.is_important);
+    try testing.expectEqual("!importantred", result.value);
+
+    result = extractImportant("red !important !important");
+    try testing.expect(result.is_important);
+    try testing.expectEqual("red !important", result.value);
+}
+
+test "Browser: CSS.StyleDeclaration: isMultiValueProperty - complex spacing scenarios" {
+    try testing.expect(isMultiValueProperty("10px    20px"));
+    try testing.expect(isMultiValueProperty("solid     red"));
+
+    try testing.expect(isMultiValueProperty("  10px 20px  "));
+
+    try testing.expect(!isMultiValueProperty("10px\t20px"));
+    try testing.expect(!isMultiValueProperty("10px\n20px"));
+
+    try testing.expect(isMultiValueProperty("10px   20px   30px"));
+}
+
+test "Browser: CSS.StyleDeclaration: isAlreadyQuoted - edge cases with quotes" {
+    try testing.expect(isAlreadyQuoted("\"'hello'\""));
+    try testing.expect(isAlreadyQuoted("'\"hello\"'"));
+
+    try testing.expect(isAlreadyQuoted("\"hello\\\"world\""));
+    try testing.expect(isAlreadyQuoted("'hello\\'world'"));
+
+    try testing.expect(!isAlreadyQuoted("\"hello"));
+    try testing.expect(!isAlreadyQuoted("hello\""));
+    try testing.expect(!isAlreadyQuoted("'hello"));
+    try testing.expect(!isAlreadyQuoted("hello'"));
+
+    try testing.expect(isAlreadyQuoted("\"a\""));
+    try testing.expect(isAlreadyQuoted("'b'"));
+}
+
+test "Browser: CSS.StyleDeclaration: needsQuotes - function and URL edge cases" {
+    try testing.expect(!needsQuotes("rgb(255, 0, 0)"));
+    try testing.expect(!needsQuotes("calc(100% - 20px)"));
+
+    try testing.expect(!needsQuotes("url(path with spaces.jpg)"));
+
+    try testing.expect(!needsQuotes("linear-gradient(to right, red, blue)"));
+
+    try testing.expect(needsQuotes("rgb(255, 0, 0"));
+}
+
+test "Browser: CSS.StyleDeclaration: escapeCSSValue - control characters and Unicode" {
+    const allocator = testing.arena_allocator;
+
+    var result = try escapeCSSValue(allocator, "test\ttab");
+    try testing.expectEqual("\"test\\9 tab\"", result);
+
+    result = try escapeCSSValue(allocator, "test\rreturn");
+    try testing.expectEqual("\"test\\D return\"", result);
+
+    result = try escapeCSSValue(allocator, "test\x00null");
+    try testing.expectEqual("\"test\\0null\"", result);
+
+    result = try escapeCSSValue(allocator, "test\x7Fdel");
+    try testing.expectEqual("\"test\\7f del\"", result);
+
+    result = try escapeCSSValue(allocator, "test\"quote\nline\\back");
+    try testing.expectEqual("\"test\\\"quote\\A line\\\\back\"", result);
+}
+
+test "Browser: CSS.StyleDeclaration: isValidPropertyName - CSS custom properties and vendor prefixes" {
+    try testing.expect(isValidPropertyName("--custom-color"));
+    try testing.expect(isValidPropertyName("--my-variable"));
+    try testing.expect(isValidPropertyName("--123"));
+
+    try testing.expect(isValidPropertyName("-webkit-transform"));
+    try testing.expect(isValidPropertyName("-moz-border-radius"));
+    try testing.expect(isValidPropertyName("-ms-filter"));
+    try testing.expect(isValidPropertyName("-o-transition"));
+
+    try testing.expect(!isValidPropertyName("-123invalid"));
+    try testing.expect(!isValidPropertyName("--"));
+    try testing.expect(!isValidPropertyName("-"));
+}
+
+test "Browser: CSS.StyleDeclaration: startsWithFunction - case sensitivity and partial matches" {
+    try testing.expect(CSSKeywords.startsWithFunction("RGB(255, 0, 0)"));
+    try testing.expect(CSSKeywords.startsWithFunction("Rgb(255, 0, 0)"));
+    try testing.expect(CSSKeywords.startsWithFunction("URL(image.png)"));
+
+    try testing.expect(CSSKeywords.startsWithFunction("rg(something)"));
+    try testing.expect(CSSKeywords.startsWithFunction("ur(something)"));
+
+    try testing.expect(CSSKeywords.startsWithFunction("rgb(1,2,3)"));
+    try testing.expect(CSSKeywords.startsWithFunction("rgba(1,2,3,4)"));
+
+    try testing.expect(CSSKeywords.startsWithFunction("my-custom-function(args)"));
+    try testing.expect(CSSKeywords.startsWithFunction("function-with-dashes(test)"));
+
+    try testing.expect(!CSSKeywords.startsWithFunction("123function(test)"));
+}
+
+test "Browser: CSS.StyleDeclaration: isHexColor - Unicode and invalid characters" {
+    try testing.expect(!isHexColor("#ghijkl"));
+    try testing.expect(!isHexColor("#12345g"));
+    try testing.expect(!isHexColor("#xyz"));
+
+    try testing.expect(!isHexColor("#АВС"));
+
+    try testing.expect(!isHexColor("#1234567g"));
+    try testing.expect(!isHexColor("#g2345678"));
+}
+
+test "Browser: CSS.StyleDeclaration: complex integration scenarios" {
+    const allocator = testing.arena_allocator;
+
+    try testing.expect(isMultiValueProperty("rgb(255,0,0) url(bg.jpg)"));
+
+    try testing.expect(!needsQuotes("calc(100% - 20px)"));
+
+    const result = try escapeCSSValue(allocator, "fake(function with spaces");
+    try testing.expectEqual("\"fake(function with spaces\"", result);
+
+    const important_result = extractImportant("rgb(255,0,0) !important");
+    try testing.expect(important_result.is_important);
+    try testing.expectEqual("rgb(255,0,0)", important_result.value);
+}
+
+test "Browser: CSS.StyleDeclaration: performance edge cases - empty and minimal inputs" {
+    try testing.expect(!isNumericWithUnit(""));
+    try testing.expect(!isHexColor(""));
+    try testing.expect(!isMultiValueProperty(""));
+    try testing.expect(!isAlreadyQuoted(""));
+    try testing.expect(!isValidPropertyName(""));
+    try testing.expect(needsQuotes(""));
+    try testing.expect(!CSSKeywords.isKnownKeyword(""));
+    try testing.expect(!CSSKeywords.containsSpecialChar(""));
+    try testing.expect(!CSSKeywords.isValidUnit(""));
+    try testing.expect(!CSSKeywords.startsWithFunction(""));
+
+    try testing.expect(!isNumericWithUnit("a"));
+    try testing.expect(!isHexColor("a"));
+    try testing.expect(!isMultiValueProperty("a"));
+    try testing.expect(!isAlreadyQuoted("a"));
+    try testing.expect(isValidPropertyName("a"));
+    try testing.expect(!needsQuotes("a"));
+}

src/browser/cssom/CSSStyleSheet.zig

@@ -0,0 +1,95 @@
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const std = @import("std");
+
+const js = @import("../js/js.zig");
+const Page = @import("../page.zig").Page;
+const StyleSheet = @import("StyleSheet.zig");
+const CSSRuleList = @import("CSSRuleList.zig");
+const CSSImportRule = @import("CSSRule.zig").CSSImportRule;
+
+const CSSStyleSheet = @This();
+pub const prototype = *StyleSheet;
+
+proto: StyleSheet,
+css_rules: CSSRuleList,
+owner_rule: ?*CSSImportRule,
+
+const CSSStyleSheetOpts = struct {
+    base_url: ?[]const u8 = null,
+    // TODO: Suupport media
+    disabled: bool = false,
+};
+
+pub fn constructor(_opts: ?CSSStyleSheetOpts) !CSSStyleSheet {
+    const opts = _opts orelse CSSStyleSheetOpts{};
+    return .{
+        .proto = .{ .disabled = opts.disabled },
+        .css_rules = .constructor(),
+        .owner_rule = null,
+    };
+}
+
+pub fn get_ownerRule(_: *CSSStyleSheet) ?*CSSImportRule {
+    return null;
+}
+
+pub fn get_cssRules(self: *CSSStyleSheet) *CSSRuleList {
+    return &self.css_rules;
+}
+
+pub fn _insertRule(self: *CSSStyleSheet, rule: []const u8, _index: ?usize, page: *Page) !usize {
+    const index = _index orelse 0;
+    if (index > self.css_rules.list.items.len) {
+        return error.IndexSize;
+    }
+
+    const arena = page.arena;
+    try self.css_rules.list.insert(arena, index, try arena.dupe(u8, rule));
+    return index;
+}
+
+pub fn _deleteRule(self: *CSSStyleSheet, index: usize) !void {
+    if (index > self.css_rules.list.items.len) {
+        return error.IndexSize;
+    }
+
+    _ = self.css_rules.list.orderedRemove(index);
+}
+
+pub fn _replace(self: *CSSStyleSheet, text: []const u8, page: *Page) !js.Promise {
+    _ = self;
+    _ = text;
+    // TODO: clear self.css_rules
+    // parse text and re-populate self.css_rules
+
+    return page.js.resolvePromise({});
+}
+
+pub fn _replaceSync(self: *CSSStyleSheet, text: []const u8) !void {
+    _ = self;
+    _ = text;
+    // TODO: clear self.css_rules
+    // parse text and re-populate self.css_rules
+}
+
+const testing = @import("../../testing.zig");
+test "Browser: CSS.StyleSheet" {
+    try testing.htmlRunner("cssom/css_stylesheet.html");
+}

src/browser/cssom/StyleSheet.zig

@@ -0,0 +1,55 @@
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const parser = @import("../netsurf.zig");
+
+// https://developer.mozilla.org/en-US/docs/Web/API/StyleSheet#specifications
+const StyleSheet = @This();
+
+disabled: bool = false,
+href: []const u8 = "",
+owner_node: ?*parser.Node = null,
+parent_stylesheet: ?*StyleSheet = null,
+title: []const u8 = "",
+type: []const u8 = "text/css",
+
+pub fn get_disabled(self: *const StyleSheet) bool {
+    return self.disabled;
+}
+
+pub fn get_href(self: *const StyleSheet) []const u8 {
+    return self.href;
+}
+
+// TODO: media
+
+pub fn get_ownerNode(self: *const StyleSheet) ?*parser.Node {
+    return self.owner_node;
+}
+
+pub fn get_parentStyleSheet(self: *const StyleSheet) ?*StyleSheet {
+    return self.parent_stylesheet;
+}
+
+pub fn get_title(self: *const StyleSheet) []const u8 {
+    return self.title;
+}
+
+pub fn get_type(self: *const StyleSheet) []const u8 {
+    return self.type;
+}

src/browser/cssom/color.zig

@@ -19,23 +19,8 @@
 const std = @import("std");
 const Io = std.Io;
 
-pub fn isHexColor(value: []const u8) bool {
-    if (value.len == 0) {
-        return false;
-    }
-
-    if (value[0] != '#') {
-        return false;
-    }
-
-    const hex_part = value[1..];
-    switch (hex_part.len) {
-        3, 4, 6, 8 => for (hex_part) |c| if (!std.ascii.isHex(c)) return false,
-        else => return false,
-    }
-
-    return true;
-}
+const CSSParser = @import("CSSParser.zig");
+const isHexColor = @import("CSSStyleDeclaration.zig").isHexColor;
 
 pub const RGBA = packed struct(u32) {
     r: u8,

src/browser/cssom/cssom.zig

@@ -1,4 +1,4 @@
-// Copyright (C) 2023-2026  Lightpanda (Selecy SAS)
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
 //
 // Francis Bouvier <francis@lightpanda.io>
 // Pierre Tachoire <pierre@lightpanda.io>
@@ -16,13 +16,10 @@
 // You should have received a copy of the GNU Affero General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
-// Gets the Parent of child.
-// HtmlElement.of(script) -> *HTMLElement
-pub fn Struct(comptime T: type) type {
-    return switch (@typeInfo(T)) {
-        .pointer => |ptr| ptr.child,
-        .@"struct" => T,
-        .void => T,
-        else => unreachable,
-    };
-}
+pub const Interfaces = .{
+    @import("StyleSheet.zig"),
+    @import("CSSStyleSheet.zig"),
+    @import("CSSStyleDeclaration.zig"),
+    @import("CSSRuleList.zig"),
+    @import("CSSRule.zig").Interfaces,
+};

src/browser/dom/Animation.zig

@@ -0,0 +1,107 @@
+// Copyright (C) 2023-2025  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const std = @import("std");
+
+const js = @import("../js/js.zig");
+const Page = @import("../page.zig").Page;
+
+const Animation = @This();
+
+effect: ?js.Object,
+timeline: ?js.Object,
+ready_resolver: ?js.PromiseResolver,
+finished_resolver: ?js.PromiseResolver,
+
+pub fn constructor(effect: ?js.Object, timeline: ?js.Object) !Animation {
+    return .{
+        .effect = if (effect) |eo| try eo.persist() else null,
+        .timeline = if (timeline) |to| try to.persist() else null,
+        .ready_resolver = null,
+        .finished_resolver = null,
+    };
+}
+
+pub fn get_playState(self: *const Animation) []const u8 {
+    _ = self;
+    return "finished";
+}
+
+pub fn get_pending(self: *const Animation) bool {
+    _ = self;
+    return false;
+}
+
+pub fn get_finished(self: *Animation, page: *Page) !js.Promise {
+    if (self.finished_resolver == null) {
+        const resolver = page.js.createPromiseResolver(.none);
+        try resolver.resolve(self);
+        self.finished_resolver = resolver;
+    }
+    return self.finished_resolver.?.promise();
+}
+
+pub fn get_ready(self: *Animation, page: *Page) !js.Promise {
+    // never resolved, because we're always "finished"
+    if (self.ready_resolver == null) {
+        const resolver = page.js.createPromiseResolver(.none);
+        self.ready_resolver = resolver;
+    }
+    return self.ready_resolver.?.promise();
+}
+
+pub fn get_effect(self: *const Animation) ?js.Object {
+    return self.effect;
+}
+
+pub fn set_effect(self: *Animation, effect: js.Object) !void {
+    self.effect = try effect.persist();
+}
+
+pub fn get_timeline(self: *const Animation) ?js.Object {
+    return self.timeline;
+}
+
+pub fn set_timeline(self: *Animation, timeline: js.Object) !void {
+    self.timeline = try timeline.persist();
+}
+
+pub fn _play(self: *const Animation) void {
+    _ = self;
+}
+
+pub fn _pause(self: *const Animation) void {
+    _ = self;
+}
+
+pub fn _cancel(self: *const Animation) void {
+    _ = self;
+}
+
+pub fn _finish(self: *const Animation) void {
+    _ = self;
+}
+
+pub fn _reverse(self: *const Animation) void {
+    _ = self;
+}
+
+const testing = @import("../../testing.zig");
+test "Browser: DOM.Animation" {
+    try testing.htmlRunner("dom/animation.html");
+}

src/browser/dom/IntersectionObserver.zig

@@ -0,0 +1,329 @@
+// Copyright (C) 2023-2025  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const std = @import("std");
+
+const js = @import("../js/js.zig");
+const log = @import("../../log.zig");
+const parser = @import("../netsurf.zig");
+const Page = @import("../page.zig").Page;
+const Node = @import("node.zig").Node;
+const Element = @import("element.zig").Element;
+
+pub const Interfaces = .{
+    IntersectionObserver,
+    Entry,
+};
+
+// This implementation attempts to be as less wrong as possible. Since we don't
+// render, or know how things are positioned, our best guess isn't very good.
+const IntersectionObserver = @This();
+page: *Page,
+root: *parser.Node,
+callback: js.Function,
+event_node: parser.EventNode,
+observed_entries: std.ArrayList(Entry),
+pending_elements: std.ArrayList(*parser.Element),
+ready_elements: std.ArrayList(*parser.Element),
+
+pub fn constructor(callback: js.Function, opts_: ?IntersectionObserverOptions, page: *Page) !*IntersectionObserver {
+    const opts = opts_ orelse IntersectionObserverOptions{};
+
+    const self = try page.arena.create(IntersectionObserver);
+    self.* = .{
+        .page = page,
+        .callback = callback,
+        .ready_elements = .{},
+        .observed_entries = .{},
+        .pending_elements = .{},
+        .event_node = .{ .func = mutationCallback },
+        .root = opts.root orelse parser.documentToNode(parser.documentHTMLToDocument(page.window.document)),
+    };
+
+    _ = try parser.eventTargetAddEventListener(
+        parser.toEventTarget(parser.Node, self.root),
+        "DOMNodeInserted",
+        &self.event_node,
+        false,
+    );
+
+    _ = try parser.eventTargetAddEventListener(
+        parser.toEventTarget(parser.Node, self.root),
+        "DOMNodeRemoved",
+        &self.event_node,
+        false,
+    );
+
+    return self;
+}
+
+pub fn _disconnect(self: *IntersectionObserver) !void {
+    // We don't free as it is on an arena
+    self.ready_elements = .{};
+    self.observed_entries = .{};
+    self.pending_elements = .{};
+}
+
+pub fn _observe(self: *IntersectionObserver, target_element: *parser.Element, page: *Page) !void {
+    for (self.observed_entries.items) |*observer| {
+        if (observer.target == target_element) {
+            return; // Already observed
+        }
+    }
+
+    if (self.isPending(target_element)) {
+        return; // Already pending
+    }
+
+    for (self.ready_elements.items) |element| {
+        if (element == target_element) {
+            return; // Already primed
+        }
+    }
+
+    // We can never fire callbacks synchronously. Code like React expects any
+    // callback to fire in the future (e.g. via microtasks).
+    try self.ready_elements.append(self.page.arena, target_element);
+    if (self.ready_elements.items.len == 1) {
+        // this is our first ready entry, schedule a callback
+        try page.scheduler.add(self, processReady, 0, .{
+            .name = "intersection ready",
+        });
+    }
+}
+
+pub fn _unobserve(self: *IntersectionObserver, target: *parser.Element) !void {
+    if (self.removeObserved(target)) {
+        return;
+    }
+
+    for (self.ready_elements.items, 0..) |el, index| {
+        if (el == target) {
+            _ = self.ready_elements.swapRemove(index);
+            return;
+        }
+    }
+
+    for (self.pending_elements.items, 0..) |el, index| {
+        if (el == target) {
+            _ = self.pending_elements.swapRemove(index);
+            return;
+        }
+    }
+}
+
+pub fn _takeRecords(self: *IntersectionObserver) []Entry {
+    return self.observed_entries.items;
+}
+
+fn processReady(ctx: *anyopaque) ?u32 {
+    const self: *IntersectionObserver = @ptrCast(@alignCast(ctx));
+    self._processReady() catch |err| {
+        log.err(.web_api, "intersection ready", .{ .err = err });
+    };
+    return null;
+}
+
+fn _processReady(self: *IntersectionObserver) !void {
+    defer self.ready_elements.clearRetainingCapacity();
+    for (self.ready_elements.items) |element| {
+        // IntersectionObserver probably doesn't work like what your intuition
+        // thinks. As long as a node has a parent, even if that parent isn't
+        // connected and even if the two nodes don't intersect, it'll fire the
+        // callback once.
+        if (try Node.get_parentNode(@ptrCast(element)) == null) {
+            if (!self.isPending(element)) {
+                try self.pending_elements.append(self.page.arena, element);
+            }
+            continue;
+        }
+        try self.forceObserve(element);
+    }
+}
+
+fn isPending(self: *IntersectionObserver, element: *parser.Element) bool {
+    for (self.pending_elements.items) |el| {
+        if (el == element) {
+            return true;
+        }
+    }
+    return false;
+}
+
+fn mutationCallback(en: *parser.EventNode, event: *parser.Event) void {
+    const mutation_event = parser.eventToMutationEvent(event);
+    const self: *IntersectionObserver = @fieldParentPtr("event_node", en);
+    self._mutationCallback(mutation_event) catch |err| {
+        log.err(.web_api, "mutation callback", .{ .err = err, .source = "intersection observer" });
+    };
+}
+
+fn _mutationCallback(self: *IntersectionObserver, event: *parser.MutationEvent) !void {
+    const event_type = parser.eventType(@ptrCast(event));
+
+    if (std.mem.eql(u8, event_type, "DOMNodeInserted")) {
+        const node = parser.mutationEventRelatedNode(event) catch return orelse return;
+        if (parser.nodeType(node) != .element) {
+            return;
+        }
+        const el: *parser.Element = @ptrCast(node);
+        if (self.removePending(el)) {
+            // It was pending (because it wasn't in the root), but now it is
+            // we should observe it.
+            try self.forceObserve(el);
+        }
+        return;
+    }
+
+    if (std.mem.eql(u8, event_type, "DOMNodeRemoved")) {
+        const node = parser.mutationEventRelatedNode(event) catch return orelse return;
+        if (parser.nodeType(node) != .element) {
+            return;
+        }
+
+        const el: *parser.Element = @ptrCast(node);
+        if (self.removeObserved(el)) {
+            // It _was_ observed, it no longer is in our root, but if it was
+            // to get re-added, it should be observed again (I think), so
+            // we add it to our pending list
+            try self.pending_elements.append(self.page.arena, el);
+        }
+
+        return;
+    }
+
+    // impossible event type
+    unreachable;
+}
+
+// Exists to skip the checks made _observe when called from a DOMNodeInserted
+// event. In such events, the event handler has alread done the necessary
+// checks.
+fn forceObserve(self: *IntersectionObserver, target: *parser.Element) !void {
+    try self.observed_entries.append(self.page.arena, .{
+        .page = self.page,
+        .root = self.root,
+        .target = target,
+    });
+
+    var result: js.Function.Result = undefined;
+    self.callback.tryCall(void, .{self.observed_entries.items}, &result) catch {
+        log.debug(.user_script, "callback error", .{
+            .err = result.exception,
+            .stack = result.stack,
+            .source = "intersection observer",
+        });
+    };
+}
+
+fn removeObserved(self: *IntersectionObserver, target: *parser.Element) bool {
+    for (self.observed_entries.items, 0..) |*observer, index| {
+        if (observer.target == target) {
+            _ = self.observed_entries.swapRemove(index);
+            return true;
+        }
+    }
+    return false;
+}
+
+fn removePending(self: *IntersectionObserver, target: *parser.Element) bool {
+    for (self.pending_elements.items, 0..) |el, index| {
+        if (el == target) {
+            _ = self.pending_elements.swapRemove(index);
+            return true;
+        }
+    }
+    return false;
+}
+
+const IntersectionObserverOptions = struct {
+    root: ?*parser.Node = null, // Element or Document
+    rootMargin: ?[]const u8 = "0px 0px 0px 0px",
+    threshold: ?Threshold = .{ .single = 0.0 },
+
+    const Threshold = union(enum) {
+        single: f32,
+        list: []const f32,
+    };
+};
+
+// https://developer.mozilla.org/en-US/docs/Web/API/Entry
+// https://w3c.github.io/IntersectionObserver/#intersection-observer-entry
+pub const Entry = struct {
+    page: *Page,
+    root: *parser.Node,
+    target: *parser.Element,
+
+    // Returns the bounds rectangle of the target element as a DOMRectReadOnly. The bounds are computed as described in the documentation for Element.getBoundingClientRect().
+    pub fn get_boundingClientRect(self: *const Entry) !Element.DOMRect {
+        return Element._getBoundingClientRect(self.target, self.page);
+    }
+
+    // Returns the ratio of the intersectionRect to the boundingClientRect.
+    pub fn get_intersectionRatio(_: *const Entry) f32 {
+        return 1.0;
+    }
+
+    // Returns a DOMRectReadOnly representing the target's visible area.
+    pub fn get_intersectionRect(self: *const Entry) !Element.DOMRect {
+        return Element._getBoundingClientRect(self.target, self.page);
+    }
+
+    // A Boolean value which is true if the target element intersects with the
+    // intersection observer's root. If this is true, then, the
+    // Entry describes a transition into a state of
+    // intersection; if it's false, then you know the transition is from
+    // intersecting to not-intersecting.
+    pub fn get_isIntersecting(_: *const Entry) bool {
+        return true;
+    }
+
+    // Returns a DOMRectReadOnly for the intersection observer's root.
+    pub fn get_rootBounds(self: *const Entry) !Element.DOMRect {
+        const root = self.root;
+        if (@intFromPtr(root) == @intFromPtr(self.page.window.document)) {
+            return self.page.renderer.boundingRect();
+        }
+
+        const root_type = parser.nodeType(root);
+
+        var element: *parser.Element = undefined;
+        switch (root_type) {
+            .element => element = parser.nodeToElement(root),
+            .document => {
+                const doc = parser.nodeToDocument(root);
+                element = (try parser.documentGetDocumentElement(doc)).?;
+            },
+            else => return error.InvalidState,
+        }
+
+        return Element._getBoundingClientRect(element, self.page);
+    }
+
+    // The Element whose intersection with the root changed.
+    pub fn get_target(self: *const Entry) *parser.Element {
+        return self.target;
+    }
+
+    // TODO: pub fn get_time(self: *const Entry)
+};
+
+const testing = @import("../../testing.zig");
+test "Browser: DOM.IntersectionObserver" {
+    try testing.htmlRunner("dom/intersection_observer.html");
+}

src/browser/dom/MessageChannel.zig

@@ -0,0 +1,288 @@
+// Copyright (C) 2023-2025  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const std = @import("std");
+const log = @import("../../log.zig");
+const parser = @import("../netsurf.zig");
+
+const js = @import("../js/js.zig");
+const Page = @import("../page.zig").Page;
+const EventTarget = @import("../dom/event_target.zig").EventTarget;
+const EventHandler = @import("../events/event.zig").EventHandler;
+
+const Allocator = std.mem.Allocator;
+
+const MAX_QUEUE_SIZE = 10;
+
+pub const Interfaces = .{ MessageChannel, MessagePort };
+
+const MessageChannel = @This();
+
+port1: *MessagePort,
+port2: *MessagePort,
+
+pub fn constructor(page: *Page) !MessageChannel {
+    // Why do we allocate this rather than storing directly in the struct?
+    // https://github.com/lightpanda-io/project/discussions/165
+    const port1 = try page.arena.create(MessagePort);
+    const port2 = try page.arena.create(MessagePort);
+    port1.* = .{
+        .pair = port2,
+    };
+    port2.* = .{
+        .pair = port1,
+    };
+
+    return .{
+        .port1 = port1,
+        .port2 = port2,
+    };
+}
+
+pub fn get_port1(self: *const MessageChannel) *MessagePort {
+    return self.port1;
+}
+
+pub fn get_port2(self: *const MessageChannel) *MessagePort {
+    return self.port2;
+}
+
+pub const MessagePort = struct {
+    pub const prototype = *EventTarget;
+
+    proto: parser.EventTargetTBase = .{ .internal_target_type = .message_port },
+
+    pair: *MessagePort,
+    closed: bool = false,
+    started: bool = false,
+    onmessage_cbk: ?js.Function = null,
+    onmessageerror_cbk: ?js.Function = null,
+    // This is the queue of messages to dispatch to THIS MessagePort when the
+    // MessagePort is started.
+    queue: std.ArrayListUnmanaged(js.Object) = .empty,
+
+    pub const PostMessageOption = union(enum) {
+        transfer: js.Object,
+        options: Opts,
+
+        pub const Opts = struct {
+            transfer: js.Object,
+        };
+    };
+
+    pub fn _postMessage(self: *MessagePort, obj: js.Object, opts_: ?PostMessageOption, page: *Page) !void {
+        if (self.closed) {
+            return;
+        }
+
+        if (opts_ != null) {
+            log.warn(.web_api, "not implemented", .{ .feature = "MessagePort postMessage options" });
+        }
+
+        try self.pair.dispatchOrQueue(obj, page.arena);
+    }
+
+    // Start impacts the ability to receive a message.
+    // Given pair1 (started) and pair2 (not started), then:
+    //    pair2.postMessage('x'); //will be dispatched to pair1.onmessage
+    //    pair1.postMessage('x'); // will be queued until pair2 is started
+    pub fn _start(self: *MessagePort) !void {
+        if (self.started) {
+            return;
+        }
+        self.started = true;
+        for (self.queue.items) |data| {
+            try self.dispatch(data);
+        }
+        // we'll never use this queue again, but it's allocated with an arena
+        // we don't even need to clear it, but it seems a bit safer to do at
+        // least that
+        self.queue.clearRetainingCapacity();
+    }
+
+    // Closing seems to stop both the publishing and receiving of messages,
+    // effectively rendering the channel useless. It cannot be reversed.
+    pub fn _close(self: *MessagePort) void {
+        self.closed = true;
+        self.pair.closed = true;
+    }
+
+    pub fn get_onmessage(self: *MessagePort) ?js.Function {
+        return self.onmessage_cbk;
+    }
+    pub fn get_onmessageerror(self: *MessagePort) ?js.Function {
+        return self.onmessageerror_cbk;
+    }
+
+    pub fn set_onmessage(self: *MessagePort, listener: EventHandler.Listener, page: *Page) !void {
+        if (self.onmessage_cbk) |cbk| {
+            try self.unregister("message", cbk.id);
+        }
+        self.onmessage_cbk = try self.register(page.arena, "message", listener);
+
+        // When onmessage is set directly, then it's like start() was called.
+        // If addEventListener('message') is used, the app has to call start()
+        // explicitly.
+        try self._start();
+    }
+
+    pub fn set_onmessageerror(self: *MessagePort, listener: EventHandler.Listener, page: *Page) !void {
+        if (self.onmessageerror_cbk) |cbk| {
+            try self.unregister("messageerror", cbk.id);
+        }
+        self.onmessageerror_cbk = try self.register(page.arena, "messageerror", listener);
+    }
+
+    // called from our pair. If port1.postMessage("x") is called, then this
+    // will be called on port2.
+    fn dispatchOrQueue(self: *MessagePort, obj: js.Object, arena: Allocator) !void {
+        // our pair should have checked this already
+        std.debug.assert(self.closed == false);
+
+        if (self.started) {
+            return self.dispatch(try obj.persist());
+        }
+
+        if (self.queue.items.len > MAX_QUEUE_SIZE) {
+            // This isn't part of the spec, but not putting a limit is reckless
+            return error.MessageQueueLimit;
+        }
+        return self.queue.append(arena, try obj.persist());
+    }
+
+    fn dispatch(self: *MessagePort, obj: js.Object) !void {
+        // obj is already persisted, don't use `MessageEvent.constructor`, but
+        // go directly to `init`, which assumes persisted objects.
+        var evt = try MessageEvent.init(.{ .data = obj });
+        _ = try parser.eventTargetDispatchEvent(
+            parser.toEventTarget(MessagePort, self),
+            @as(*parser.Event, @ptrCast(&evt)),
+        );
+    }
+
+    fn register(
+        self: *MessagePort,
+        alloc: Allocator,
+        typ: []const u8,
+        listener: EventHandler.Listener,
+    ) !?js.Function {
+        const target = @as(*parser.EventTarget, @ptrCast(self));
+        const eh = (try EventHandler.register(alloc, target, typ, listener, null)) orelse unreachable;
+        return eh.callback;
+    }
+
+    fn unregister(self: *MessagePort, typ: []const u8, cbk_id: usize) !void {
+        const et = @as(*parser.EventTarget, @ptrCast(self));
+        const lst = try parser.eventTargetHasListener(et, typ, false, cbk_id);
+        if (lst == null) {
+            return;
+        }
+        try parser.eventTargetRemoveEventListener(et, typ, lst.?, false);
+    }
+};
+
+pub const MessageEvent = struct {
+    const Event = @import("../events/event.zig").Event;
+    const DOMException = @import("exceptions.zig").DOMException;
+
+    pub const prototype = *Event;
+    pub const Exception = DOMException;
+    pub const union_make_copy = true;
+
+    proto: parser.Event,
+    data: ?js.Object,
+
+    // You would think if port1 sends to port2, the source would be port2
+    // (which is how I read the documentation), but it appears to always be
+    // null. It can always be set explicitly via the constructor;
+    source: ?js.Object,
+
+    origin: []const u8,
+
+    // This is used for Server-Sent events. Appears to always be an empty
+    // string for MessagePort messages.
+    last_event_id: []const u8,
+
+    // This might be related to the "transfer" option of postMessage which
+    // we don't yet support. For "normal" message, it's always an empty array.
+    // Though it could be set explicitly via the constructor
+    ports: []*MessagePort,
+
+    const Options = struct {
+        data: ?js.Object = null,
+        source: ?js.Object = null,
+        origin: []const u8 = "",
+        lastEventId: []const u8 = "",
+        ports: []*MessagePort = &.{},
+    };
+
+    pub fn constructor(opts: Options) !MessageEvent {
+        return init(.{
+            .data = if (opts.data) |obj| try obj.persist() else null,
+            .source = if (opts.source) |obj| try obj.persist() else null,
+            .ports = opts.ports,
+            .origin = opts.origin,
+            .lastEventId = opts.lastEventId,
+        });
+    }
+
+    // This is like "constructor", but it assumes js.Objects have already been
+    // persisted. Necessary because this `new MessageEvent()` can be called
+    // directly from JS OR from a port.postMessage. In the latter case, data
+    // may have already been persisted (as it might need to be queued);
+    fn init(opts: Options) !MessageEvent {
+        const event = try parser.eventCreate();
+        defer parser.eventDestroy(event);
+        try parser.eventInit(event, "message", .{});
+        parser.eventSetInternalType(event, .message_event);
+
+        return .{
+            .proto = event.*,
+            .data = opts.data,
+            .source = opts.source,
+            .ports = opts.ports,
+            .origin = opts.origin,
+            .last_event_id = opts.lastEventId,
+        };
+    }
+
+    pub fn get_data(self: *const MessageEvent) !?js.Object {
+        return self.data;
+    }
+
+    pub fn get_origin(self: *const MessageEvent) []const u8 {
+        return self.origin;
+    }
+
+    pub fn get_source(self: *const MessageEvent) ?js.Object {
+        return self.source;
+    }
+
+    pub fn get_ports(self: *const MessageEvent) []*MessagePort {
+        return self.ports;
+    }
+
+    pub fn get_lastEventId(self: *const MessageEvent) []const u8 {
+        return self.last_event_id;
+    }
+};
+
+const testing = @import("../../testing.zig");
+test "Browser: DOM.MessageChannel" {
+    try testing.htmlRunner("dom/message_channel.html");
+}

src/browser/dom/attribute.zig

@@ -0,0 +1,75 @@
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+const parser = @import("../netsurf.zig");
+
+const Node = @import("node.zig").Node;
+
+// WEB IDL https://dom.spec.whatwg.org/#attr
+pub const Attr = struct {
+    pub const Self = parser.Attribute;
+    pub const prototype = *Node;
+    pub const subtype = .node;
+
+    pub fn get_namespaceURI(self: *parser.Attribute) ?[]const u8 {
+        return parser.nodeGetNamespace(parser.attributeToNode(self));
+    }
+
+    pub fn get_prefix(self: *parser.Attribute) ?[]const u8 {
+        return parser.nodeGetPrefix(parser.attributeToNode(self));
+    }
+
+    pub fn get_localName(self: *parser.Attribute) ![]const u8 {
+        return parser.nodeLocalName(parser.attributeToNode(self));
+    }
+
+    pub fn get_name(self: *parser.Attribute) ![]const u8 {
+        return parser.attributeGetName(self);
+    }
+
+    pub fn get_value(self: *parser.Attribute) !?[]const u8 {
+        return parser.attributeGetValue(self);
+    }
+
+    pub fn set_value(self: *parser.Attribute, v: []const u8) !?[]const u8 {
+        if (try parser.attributeGetOwnerElement(self)) |el| {
+            // if possible, go through the element, as that triggers a
+            // DOMAttrModified event (which MutationObserver cares about)
+            const name = try parser.attributeGetName(self);
+            try parser.elementSetAttribute(el, name, v);
+        } else {
+            try parser.attributeSetValue(self, v);
+        }
+        return v;
+    }
+
+    pub fn get_ownerElement(self: *parser.Attribute) !?*parser.Element {
+        return try parser.attributeGetOwnerElement(self);
+    }
+
+    pub fn get_specified(_: *parser.Attribute) bool {
+        return true;
+    }
+};
+
+// Tests
+// -----
+
+const testing = @import("../../testing.zig");
+test "Browser: DOM.Attribute" {
+    try testing.htmlRunner("dom/attribute.html");
+}

src/browser/dom/cdata_section.zig

@@ -0,0 +1,28 @@
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const parser = @import("../netsurf.zig");
+
+const Text = @import("text.zig").Text;
+
+// https://dom.spec.whatwg.org/#cdatasection
+pub const CDATASection = struct {
+    pub const Self = parser.CDATASection;
+    pub const prototype = *Text;
+    pub const subtype = .node;
+};

src/browser/dom/character_data.zig

@@ -0,0 +1,134 @@
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const std = @import("std");
+
+const parser = @import("../netsurf.zig");
+
+const Node = @import("node.zig").Node;
+const Comment = @import("comment.zig").Comment;
+const Text = @import("text.zig");
+const ProcessingInstruction = @import("processing_instruction.zig").ProcessingInstruction;
+const Element = @import("element.zig").Element;
+const ElementUnion = @import("element.zig").Union;
+
+// CharacterData interfaces
+pub const Interfaces = .{
+    Comment,
+    Text.Text,
+    Text.Interfaces,
+    ProcessingInstruction,
+};
+
+// CharacterData implementation
+pub const CharacterData = struct {
+    pub const Self = parser.CharacterData;
+    pub const prototype = *Node;
+    pub const subtype = .node;
+
+    // JS funcs
+    // --------
+
+    // Read attributes
+
+    pub fn get_length(self: *parser.CharacterData) !u32 {
+        return try parser.characterDataLength(self);
+    }
+
+    pub fn get_nextElementSibling(self: *parser.CharacterData) !?ElementUnion {
+        const res = parser.nodeNextElementSibling(parser.characterDataToNode(self));
+        if (res == null) {
+            return null;
+        }
+        return try Element.toInterface(res.?);
+    }
+
+    pub fn get_previousElementSibling(self: *parser.CharacterData) !?ElementUnion {
+        const res = parser.nodePreviousElementSibling(parser.characterDataToNode(self));
+        if (res == null) {
+            return null;
+        }
+        return try Element.toInterface(res.?);
+    }
+
+    // Read/Write attributes
+
+    pub fn get_data(self: *parser.CharacterData) []const u8 {
+        return parser.characterDataData(self);
+    }
+
+    pub fn set_data(self: *parser.CharacterData, data: []const u8) !void {
+        return try parser.characterDataSetData(self, data);
+    }
+
+    // JS methods
+    // ----------
+
+    pub fn _appendData(self: *parser.CharacterData, data: []const u8) !void {
+        return try parser.characterDataAppendData(self, data);
+    }
+
+    pub fn _deleteData(self: *parser.CharacterData, offset: u32, count: u32) !void {
+        return try parser.characterDataDeleteData(self, offset, count);
+    }
+
+    pub fn _insertData(self: *parser.CharacterData, offset: u32, data: []const u8) !void {
+        return try parser.characterDataInsertData(self, offset, data);
+    }
+
+    pub fn _replaceData(self: *parser.CharacterData, offset: u32, count: u32, data: []const u8) !void {
+        return try parser.characterDataReplaceData(self, offset, count, data);
+    }
+
+    pub fn _substringData(self: *parser.CharacterData, offset: u32, count: u32) ![]const u8 {
+        return parser.characterDataSubstringData(self, offset, count);
+    }
+
+    // netsurf's CharacterData (text, comment) doesn't implement the
+    // dom_node_get_attributes and thus will crash if we try to call nodeIsEqualNode.
+    pub fn _isEqualNode(self: *parser.CharacterData, other_node: *parser.Node) bool {
+        if (parser.nodeType(@ptrCast(@alignCast(self))) != parser.nodeType(other_node)) {
+            return false;
+        }
+
+        const other: *parser.CharacterData = @ptrCast(other_node);
+        if (std.mem.eql(u8, get_data(self), get_data(other)) == false) {
+            return false;
+        }
+
+        return true;
+    }
+
+    pub fn _before(self: *parser.CharacterData, nodes: []const Node.NodeOrText) !void {
+        const ref_node = parser.characterDataToNode(self);
+        return Node.before(ref_node, nodes);
+    }
+
+    pub fn _after(self: *parser.CharacterData, nodes: []const Node.NodeOrText) !void {
+        const ref_node = parser.characterDataToNode(self);
+        return Node.after(ref_node, nodes);
+    }
+};
+
+// Tests
+// -----
+
+const testing = @import("../../testing.zig");
+test "Browser: DOM.CharacterData" {
+    try testing.htmlRunner("dom/character_data.html");
+}

src/browser/dom/comment.zig

@@ -1,4 +1,4 @@
-// Copyright (C) 2023-2025  Lightpanda (Selecy SAS)
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
 //
 // Francis Bouvier <francis@lightpanda.io>
 // Pierre Tachoire <pierre@lightpanda.io>
@@ -16,31 +16,30 @@
 // You should have received a copy of the GNU Affero General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
-const String = @import("../../../../string.zig").String;
+const parser = @import("../netsurf.zig");
 
-const js = @import("../../../js/js.zig");
+const CharacterData = @import("character_data.zig").CharacterData;
 
-const Node = @import("../../Node.zig");
-const Element = @import("../../Element.zig");
-const HtmlElement = @import("../Html.zig");
+const Page = @import("../page.zig").Page;
 
-const Generic = @This();
-_tag_name: String,
-_tag: Element.Tag,
-_proto: *HtmlElement,
+// https://dom.spec.whatwg.org/#interface-comment
+pub const Comment = struct {
+    pub const Self = parser.Comment;
+    pub const prototype = *CharacterData;
+    pub const subtype = .node;
 
-pub fn asElement(self: *Generic) *Element {
-    return self._proto._proto;
-}
-pub fn asNode(self: *Generic) *Node {
-    return self.asElement().asNode();
-}
-
-pub const JsApi = struct {
-    pub const bridge = js.Bridge(Generic);
-
-    pub const Meta = struct {
-        pub const prototype_chain = bridge.prototypeChain();
-        pub var class_id: bridge.ClassId = undefined;
-    };
+    pub fn constructor(data: ?[]const u8, page: *const Page) !*parser.Comment {
+        return parser.documentCreateComment(
+            parser.documentHTMLToDocument(page.window.document),
+            data orelse "",
+        );
+    }
 };
+
+// Tests
+// -----
+
+const testing = @import("../../testing.zig");
+test "Browser: DOM.Comment" {
+    try testing.htmlRunner("dom/comment.html");
+}

src/browser/dom/css.zig

@@ -0,0 +1,80 @@
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const std = @import("std");
+
+const parser = @import("../netsurf.zig");
+
+const css = @import("../css/css.zig");
+const Node = @import("../css/libdom.zig").Node;
+const NodeList = @import("nodelist.zig").NodeList;
+
+const MatchFirst = struct {
+    n: ?*parser.Node = null,
+
+    pub fn match(m: *MatchFirst, n: Node) !void {
+        m.n = n.node;
+    }
+};
+
+pub fn querySelector(alloc: std.mem.Allocator, n: *parser.Node, selector: []const u8) !?*parser.Node {
+    const ps = try css.parse(alloc, selector, .{ .accept_pseudo_elts = true });
+    defer ps.deinit(alloc);
+
+    var m = MatchFirst{};
+
+    _ = try css.matchFirst(&ps, Node{ .node = n }, &m);
+    return m.n;
+}
+
+const MatchAll = struct {
+    alloc: std.mem.Allocator,
+    nl: NodeList,
+
+    fn init(alloc: std.mem.Allocator) MatchAll {
+        return .{
+            .alloc = alloc,
+            .nl = .{},
+        };
+    }
+
+    fn deinit(m: *MatchAll) void {
+        m.nl.deinit(m.alloc);
+    }
+
+    pub fn match(m: *MatchAll, n: Node) !void {
+        try m.nl.append(m.alloc, n.node);
+    }
+
+    fn toOwnedList(m: *MatchAll) NodeList {
+        // reset it.
+        defer m.nl = .{};
+        return m.nl;
+    }
+};
+
+pub fn querySelectorAll(alloc: std.mem.Allocator, n: *parser.Node, selector: []const u8) !NodeList {
+    const ps = try css.parse(alloc, selector, .{ .accept_pseudo_elts = true });
+    defer ps.deinit(alloc);
+
+    var m = MatchAll.init(alloc);
+    defer m.deinit();
+
+    try css.matchAll(&ps, Node{ .node = n }, &m);
+    return m.toOwnedList();
+}

src/browser/dom/document.zig

@@ -0,0 +1,385 @@
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const std = @import("std");
+const log = @import("../../log.zig");
+
+const js = @import("../js/js.zig");
+const parser = @import("../netsurf.zig");
+const Page = @import("../page.zig").Page;
+
+const Node = @import("node.zig").Node;
+const NodeList = @import("nodelist.zig").NodeList;
+const NodeUnion = @import("node.zig").Union;
+
+const collection = @import("html_collection.zig");
+const css = @import("css.zig");
+
+const Element = @import("element.zig").Element;
+const ElementUnion = @import("element.zig").Union;
+const TreeWalker = @import("tree_walker.zig").TreeWalker;
+const CSSStyleSheet = @import("../cssom/CSSStyleSheet.zig");
+const NodeIterator = @import("node_iterator.zig").NodeIterator;
+const Range = @import("range.zig").Range;
+
+const CustomEvent = @import("../events/custom_event.zig").CustomEvent;
+
+const DOMImplementation = @import("implementation.zig").DOMImplementation;
+
+// WEB IDL https://dom.spec.whatwg.org/#document
+pub const Document = struct {
+    pub const Self = parser.Document;
+    pub const prototype = *Node;
+    pub const subtype = .node;
+
+    pub fn constructor(page: *const Page) !*parser.DocumentHTML {
+        const doc = try parser.documentCreateDocument(
+            try parser.documentHTMLGetTitle(page.window.document),
+        );
+
+        // we have to work w/ document instead of html document.
+        const ddoc = parser.documentHTMLToDocument(doc);
+        const ccur = parser.documentHTMLToDocument(page.window.document);
+        try parser.documentSetDocumentURI(ddoc, try parser.documentGetDocumentURI(ccur));
+        try parser.documentSetInputEncoding(ddoc, try parser.documentGetInputEncoding(ccur));
+
+        return doc;
+    }
+
+    // JS funcs
+    // --------
+    pub fn get_implementation(_: *parser.Document) DOMImplementation {
+        return DOMImplementation{};
+    }
+
+    pub fn get_documentElement(self: *parser.Document) !?ElementUnion {
+        const e = try parser.documentGetDocumentElement(self);
+        if (e == null) return null;
+        return try Element.toInterface(e.?);
+    }
+
+    pub fn get_documentURI(self: *parser.Document) ![]const u8 {
+        return try parser.documentGetDocumentURI(self);
+    }
+
+    pub fn get_URL(self: *parser.Document) ![]const u8 {
+        return try get_documentURI(self);
+    }
+
+    // TODO implement contentType
+    pub fn get_contentType(self: *parser.Document) []const u8 {
+        _ = self;
+        return "text/html";
+    }
+
+    // TODO implement compactMode
+    pub fn get_compatMode(self: *parser.Document) []const u8 {
+        _ = self;
+        return "CSS1Compat";
+    }
+
+    pub fn get_characterSet(self: *parser.Document) ![]const u8 {
+        return try parser.documentGetInputEncoding(self);
+    }
+
+    // alias of get_characterSet
+    pub fn get_charset(self: *parser.Document) ![]const u8 {
+        return try get_characterSet(self);
+    }
+
+    // alias of get_characterSet
+    pub fn get_inputEncoding(self: *parser.Document) ![]const u8 {
+        return try get_characterSet(self);
+    }
+
+    pub fn get_doctype(self: *parser.Document) !?*parser.DocumentType {
+        return try parser.documentGetDoctype(self);
+    }
+
+    pub fn _createEvent(_: *parser.Document, eventCstr: []const u8) !union(enum) {
+        base: *parser.Event,
+        custom: CustomEvent,
+    } {
+        const eqlIgnoreCase = std.ascii.eqlIgnoreCase;
+
+        if (eqlIgnoreCase(eventCstr, "Event") or eqlIgnoreCase(eventCstr, "Events") or eqlIgnoreCase(eventCstr, "HTMLEvents")) {
+            return .{ .base = try parser.eventCreate() };
+        }
+
+        // Not documented in MDN but supported in Chrome.
+        // This is actually both instance of `Event` and `CustomEvent`.
+        if (std.ascii.eqlIgnoreCase(eventCstr, "CustomEvent")) {
+            return .{ .custom = try CustomEvent.constructor(eventCstr, null) };
+        }
+
+        return error.NotSupported;
+    }
+
+    pub fn _getElementById(self: *parser.Document, id: []const u8) !?ElementUnion {
+        const e = try parser.documentGetElementById(self, id) orelse return null;
+        return try Element.toInterface(e);
+    }
+
+    pub fn _createElement(self: *parser.Document, tag_name: []const u8) !ElementUnion {
+        // The element’s namespace is the HTML namespace when document is an HTML document
+        // https://dom.spec.whatwg.org/#ref-for-dom-document-createelement%E2%91%A0
+        const e = try parser.documentCreateElementNS(self, "http://www.w3.org/1999/xhtml", tag_name);
+        return Element.toInterface(e);
+    }
+
+    pub fn _createElementNS(self: *parser.Document, ns: []const u8, tag_name: []const u8) !ElementUnion {
+        const e = try parser.documentCreateElementNS(self, ns, tag_name);
+        return try Element.toInterface(e);
+    }
+
+    // We can't simply use libdom dom_document_get_elements_by_tag_name here.
+    // Indeed, netsurf implemented a previous dom spec when
+    // getElementsByTagName returned a NodeList.
+    // But since
+    // https://github.com/whatwg/dom/commit/190700b7c12ecfd3b5ebdb359ab1d6ea9cbf7749
+    // the spec changed to return an HTMLCollection instead.
+    // That's why we reimplemented getElementsByTagName by using an
+    // HTMLCollection in zig here.
+    pub fn _getElementsByTagName(self: *parser.Document, tag_name: js.String) !collection.HTMLCollection {
+        return collection.HTMLCollectionByTagName(parser.documentToNode(self), tag_name.string, .{
+            .include_root = true,
+        });
+    }
+
+    pub fn _getElementsByClassName(self: *parser.Document, class_names: js.String) !collection.HTMLCollection {
+        return collection.HTMLCollectionByClassName(parser.documentToNode(self), class_names.string, .{
+            .include_root = true,
+        });
+    }
+
+    pub fn _createDocumentFragment(self: *parser.Document) !*parser.DocumentFragment {
+        return try parser.documentCreateDocumentFragment(self);
+    }
+
+    pub fn _createTextNode(self: *parser.Document, data: []const u8) !*parser.Text {
+        return try parser.documentCreateTextNode(self, data);
+    }
+
+    pub fn _createCDATASection(self: *parser.Document, data: []const u8) !*parser.CDATASection {
+        return try parser.documentCreateCDATASection(self, data);
+    }
+
+    pub fn _createComment(self: *parser.Document, data: []const u8) !*parser.Comment {
+        return try parser.documentCreateComment(self, data);
+    }
+
+    pub fn _createProcessingInstruction(self: *parser.Document, target: []const u8, data: []const u8) !*parser.ProcessingInstruction {
+        return try parser.documentCreateProcessingInstruction(self, target, data);
+    }
+
+    pub fn _importNode(self: *parser.Document, node: *parser.Node, deep: ?bool) !NodeUnion {
+        const n = try parser.documentImportNode(self, node, deep orelse false);
+        return try Node.toInterface(n);
+    }
+
+    pub fn _adoptNode(self: *parser.Document, node: *parser.Node) !NodeUnion {
+        const n = try parser.documentAdoptNode(self, node);
+        return try Node.toInterface(n);
+    }
+
+    pub fn _createAttribute(self: *parser.Document, name: []const u8) !*parser.Attribute {
+        return try parser.documentCreateAttribute(self, name);
+    }
+
+    pub fn _createAttributeNS(self: *parser.Document, ns: []const u8, qname: []const u8) !*parser.Attribute {
+        return try parser.documentCreateAttributeNS(self, ns, qname);
+    }
+
+    // ParentNode
+    // https://dom.spec.whatwg.org/#parentnode
+    pub fn get_children(self: *parser.Document) !collection.HTMLCollection {
+        return collection.HTMLCollectionChildren(parser.documentToNode(self), .{
+            .include_root = false,
+        });
+    }
+
+    pub fn get_firstElementChild(self: *parser.Document) !?ElementUnion {
+        const elt = try parser.documentGetDocumentElement(self) orelse return null;
+        return try Element.toInterface(elt);
+    }
+
+    pub fn get_lastElementChild(self: *parser.Document) !?ElementUnion {
+        const elt = try parser.documentGetDocumentElement(self) orelse return null;
+        return try Element.toInterface(elt);
+    }
+
+    pub fn get_childElementCount(self: *parser.Document) !u32 {
+        _ = try parser.documentGetDocumentElement(self) orelse return 0;
+        return 1;
+    }
+
+    pub fn _querySelector(self: *parser.Document, selector: []const u8, page: *Page) !?ElementUnion {
+        if (selector.len == 0) return null;
+
+        const n = try css.querySelector(page.call_arena, parser.documentToNode(self), selector);
+
+        if (n == null) return null;
+
+        return try Element.toInterface(parser.nodeToElement(n.?));
+    }
+
+    pub fn _querySelectorAll(self: *parser.Document, selector: []const u8, page: *Page) !NodeList {
+        return css.querySelectorAll(page.arena, parser.documentToNode(self), selector);
+    }
+
+    pub fn _prepend(self: *parser.Document, nodes: []const Node.NodeOrText) !void {
+        return Node.prepend(parser.documentToNode(self), nodes);
+    }
+
+    pub fn _append(self: *parser.Document, nodes: []const Node.NodeOrText) !void {
+        return Node.append(parser.documentToNode(self), nodes);
+    }
+
+    pub fn _replaceChildren(self: *parser.Document, nodes: []const Node.NodeOrText) !void {
+        return Node.replaceChildren(parser.documentToNode(self), nodes);
+    }
+
+    pub fn _createTreeWalker(_: *parser.Document, root: *parser.Node, what_to_show: ?TreeWalker.WhatToShow, filter: ?TreeWalker.TreeWalkerOpts) !TreeWalker {
+        return TreeWalker.init(root, what_to_show, filter);
+    }
+
+    pub fn _createNodeIterator(_: *parser.Document, root: *parser.Node, what_to_show: ?NodeIterator.WhatToShow, filter: ?NodeIterator.NodeIteratorOpts) !NodeIterator {
+        return NodeIterator.init(root, what_to_show, filter);
+    }
+
+    pub fn getActiveElement(self: *parser.Document, page: *Page) !?*parser.Element {
+        if (page.getNodeState(@ptrCast(@alignCast(self)))) |state| {
+            if (state.active_element) |ae| {
+                return ae;
+            }
+        }
+
+        if (try parser.documentHTMLBody(page.window.document)) |body| {
+            return @ptrCast(@alignCast(body));
+        }
+
+        return try parser.documentGetDocumentElement(self);
+    }
+
+    pub fn get_activeElement(self: *parser.Document, page: *Page) !?ElementUnion {
+        const ae = (try getActiveElement(self, page)) orelse return null;
+        return try Element.toInterface(ae);
+    }
+
+    // TODO: some elements can't be focused, like if they're disabled
+    // but there doesn't seem to be a generic way to check this. For example
+    // we could look for the "disabled" attribute, but that's only meaningful
+    // on certain types, and libdom's vtable doesn't seem to expose this.
+    pub fn setFocus(self: *parser.Document, e: *parser.ElementHTML, page: *Page) !void {
+        const state = try page.getOrCreateNodeState(@ptrCast(@alignCast(self)));
+        state.active_element = @ptrCast(e);
+    }
+
+    pub fn _createRange(_: *parser.Document, page: *Page) Range {
+        return Range.constructor(page);
+    }
+
+    // TODO: dummy implementation
+    pub fn get_styleSheets(_: *parser.Document) []CSSStyleSheet {
+        return &.{};
+    }
+
+    pub fn get_adoptedStyleSheets(self: *parser.Document, page: *Page) !js.Object {
+        const state = try page.getOrCreateNodeState(@ptrCast(@alignCast(self)));
+        if (state.adopted_style_sheets) |obj| {
+            return obj;
+        }
+
+        const obj = try page.js.createArray(0).persist();
+        state.adopted_style_sheets = obj;
+        return obj;
+    }
+
+    pub fn set_adoptedStyleSheets(self: *parser.Document, sheets: js.Object, page: *Page) !void {
+        const state = try page.getOrCreateNodeState(@ptrCast(@alignCast(self)));
+        state.adopted_style_sheets = try sheets.persist();
+    }
+
+    pub fn _hasFocus(_: *parser.Document) bool {
+        log.debug(.web_api, "not implemented", .{ .feature = "Document hasFocus" });
+        return true;
+    }
+
+    pub fn _open(_: *parser.Document, page: *Page) !*parser.DocumentHTML {
+        if (page.open) {
+            return page.window.document;
+        }
+
+        // This implementation is invalid.
+        // According to MDN, we should cleanup registered listeners.
+        // So we sould cleanup previous DOM memory.
+        // But this implementation is more simple for now.
+        const html_doc = try parser.documentHTMLParseFromStr("");
+        try page.setDocument(html_doc);
+        page.open = true;
+
+        return page.window.document;
+    }
+
+    pub fn _close(_: *parser.Document, page: *Page) !void {
+        page.open = false;
+    }
+
+    pub fn _write(self: *parser.Document, str: []const u8, page: *Page) !void {
+        _ = try _open(self, page);
+
+        const document = parser.documentHTMLToDocument(page.window.document);
+        const fragment = try parser.documentParseFragmentFromStr(document, str);
+        const fragment_node = parser.documentFragmentToNode(fragment);
+
+        const fragment_html = parser.nodeFirstChild(fragment_node) orelse return;
+        const fragment_head = parser.nodeFirstChild(fragment_html) orelse return;
+        const fragment_body = parser.nodeNextSibling(fragment_head) orelse return;
+
+        const document_node = parser.documentToNode(document);
+        const document_html = parser.nodeFirstChild(document_node) orelse return;
+        const document_head = parser.nodeFirstChild(document_html) orelse return;
+        const document_body = parser.nodeNextSibling(document_head) orelse return;
+
+        {
+            const children = try parser.nodeGetChildNodes(fragment_head);
+            // always index 0, because nodeAppendChild moves the node out of
+            // the nodeList and into the new tree
+            while (parser.nodeListItem(children, 0)) |child| {
+                _ = try parser.nodeAppendChild(document_head, child);
+            }
+        }
+
+        {
+            const children = try parser.nodeGetChildNodes(fragment_body);
+            // always index 0, because nodeAppendChild moves the node out of
+            // the nodeList and into the new tree
+            while (parser.nodeListItem(children, 0)) |child| {
+                _ = try parser.nodeAppendChild(document_body, child);
+            }
+        }
+    }
+};
+
+const testing = @import("../../testing.zig");
+test "Browser: DOM.Document" {
+    try testing.htmlRunner("dom/document.html");
+}
+test "Browser: DOM.Document.write" {
+    try testing.htmlRunner("dom/document_write.html");
+}

src/browser/dom/document_fragment.zig

@@ -0,0 +1,96 @@
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const css = @import("css.zig");
+const parser = @import("../netsurf.zig");
+const Page = @import("../page.zig").Page;
+const NodeList = @import("nodelist.zig").NodeList;
+const Element = @import("element.zig").Element;
+const ElementUnion = @import("element.zig").Union;
+const collection = @import("html_collection.zig");
+
+const Node = @import("node.zig").Node;
+
+// WEB IDL https://dom.spec.whatwg.org/#documentfragment
+pub const DocumentFragment = struct {
+    pub const Self = parser.DocumentFragment;
+    pub const prototype = *Node;
+    pub const subtype = .node;
+
+    pub fn constructor(page: *const Page) !*parser.DocumentFragment {
+        return parser.documentCreateDocumentFragment(
+            parser.documentHTMLToDocument(page.window.document),
+        );
+    }
+
+    pub fn _isEqualNode(self: *parser.DocumentFragment, other_node: *parser.Node) bool {
+        const other_type = parser.nodeType(other_node);
+        if (other_type != .document_fragment) {
+            return false;
+        }
+        _ = self;
+        return true;
+    }
+
+    pub fn _prepend(self: *parser.DocumentFragment, nodes: []const Node.NodeOrText) !void {
+        return Node.prepend(parser.documentFragmentToNode(self), nodes);
+    }
+
+    pub fn _append(self: *parser.DocumentFragment, nodes: []const Node.NodeOrText) !void {
+        return Node.append(parser.documentFragmentToNode(self), nodes);
+    }
+
+    pub fn _replaceChildren(self: *parser.DocumentFragment, nodes: []const Node.NodeOrText) !void {
+        return Node.replaceChildren(parser.documentFragmentToNode(self), nodes);
+    }
+
+    pub fn _querySelector(self: *parser.DocumentFragment, selector: []const u8, page: *Page) !?ElementUnion {
+        if (selector.len == 0) return null;
+
+        const n = try css.querySelector(page.call_arena, parser.documentFragmentToNode(self), selector);
+
+        if (n == null) return null;
+
+        return try Element.toInterface(parser.nodeToElement(n.?));
+    }
+
+    pub fn _querySelectorAll(self: *parser.DocumentFragment, selector: []const u8, page: *Page) !NodeList {
+        return css.querySelectorAll(page.arena, parser.documentFragmentToNode(self), selector);
+    }
+
+    pub fn get_childElementCount(self: *parser.DocumentFragment) !u32 {
+        var children = try get_children(self);
+        return children.get_length();
+    }
+
+    pub fn get_children(self: *parser.DocumentFragment) !collection.HTMLCollection {
+        return collection.HTMLCollectionChildren(parser.documentFragmentToNode(self), .{
+            .include_root = false,
+        });
+    }
+
+    pub fn _getElementById(self: *parser.DocumentFragment, id: []const u8) !?ElementUnion {
+        const e = try parser.nodeGetElementById(@ptrCast(@alignCast(self)), id) orelse return null;
+        return try Element.toInterface(e);
+    }
+};
+
+const testing = @import("../../testing.zig");
+test "Browser: DOM.DocumentFragment" {
+    try testing.htmlRunner("dom/document_fragment.html");
+}

src/browser/dom/document_type.zig

@@ -0,0 +1,67 @@
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const std = @import("std");
+
+const parser = @import("../netsurf.zig");
+
+const Node = @import("node.zig").Node;
+
+// WEB IDL https://dom.spec.whatwg.org/#documenttype
+pub const DocumentType = struct {
+    pub const Self = parser.DocumentType;
+    pub const prototype = *Node;
+    pub const subtype = .node;
+
+    pub fn get_name(self: *parser.DocumentType) ![]const u8 {
+        return parser.documentTypeGetName(self);
+    }
+
+    pub fn get_publicId(self: *parser.DocumentType) []const u8 {
+        return parser.documentTypeGetPublicId(self);
+    }
+
+    pub fn get_systemId(self: *parser.DocumentType) []const u8 {
+        return parser.documentTypeGetSystemId(self);
+    }
+
+    // netsurf's DocumentType doesn't implement the dom_node_get_attributes
+    // and thus will crash if we try to call nodeIsEqualNode.
+    pub fn _isEqualNode(self: *parser.DocumentType, other_node: *parser.Node) !bool {
+        if (parser.nodeType(other_node) != .document_type) {
+            return false;
+        }
+
+        const other: *parser.DocumentType = @ptrCast(other_node);
+        if (std.mem.eql(u8, try get_name(self), try get_name(other)) == false) {
+            return false;
+        }
+        if (std.mem.eql(u8, get_publicId(self), get_publicId(other)) == false) {
+            return false;
+        }
+        if (std.mem.eql(u8, get_systemId(self), get_systemId(other)) == false) {
+            return false;
+        }
+        return true;
+    }
+};
+
+const testing = @import("../../testing.zig");
+test "Browser: DOM.DocumentType" {
+    try testing.htmlRunner("dom/document_type.html");
+}

src/browser/dom/dom.zig

@@ -0,0 +1,56 @@
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const DOMException = @import("exceptions.zig").DOMException;
+const EventTarget = @import("event_target.zig").EventTarget;
+const DOMImplementation = @import("implementation.zig").DOMImplementation;
+const NamedNodeMap = @import("namednodemap.zig").NamedNodeMap;
+const DOMTokenList = @import("token_list.zig");
+const NodeList = @import("nodelist.zig");
+const Node = @import("node.zig");
+const ResizeObserver = @import("resize_observer.zig");
+const MutationObserver = @import("mutation_observer.zig");
+const DOMParser = @import("dom_parser.zig").DOMParser;
+const TreeWalker = @import("tree_walker.zig").TreeWalker;
+const NodeIterator = @import("node_iterator.zig").NodeIterator;
+const NodeFilter = @import("node_filter.zig").NodeFilter;
+const PerformanceObserver = @import("performance_observer.zig").PerformanceObserver;
+
+pub const Interfaces = .{
+    DOMException,
+    EventTarget,
+    DOMImplementation,
+    NamedNodeMap,
+    NamedNodeMap.Iterator,
+    DOMTokenList.Interfaces,
+    NodeList.Interfaces,
+    Node.Node,
+    Node.Interfaces,
+    ResizeObserver.Interfaces,
+    MutationObserver.Interfaces,
+    DOMParser,
+    TreeWalker,
+    NodeIterator,
+    NodeFilter,
+    @import("performance.zig").Interfaces,
+    PerformanceObserver,
+    @import("range.zig").Interfaces,
+    @import("Animation.zig"),
+    @import("MessageChannel.zig").Interfaces,
+    @import("IntersectionObserver.zig").Interfaces,
+};

src/browser/dom/dom_parser.zig

@@ -1,4 +1,4 @@
-// Copyright (C) 2023-2025  Lightpanda (Selecy SAS)
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
 //
 // Francis Bouvier <francis@lightpanda.io>
 // Pierre Tachoire <pierre@lightpanda.io>
@@ -16,27 +16,26 @@
 // You should have received a copy of the GNU Affero General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
-const js = @import("../../../js/js.zig");
-const Node = @import("../../Node.zig");
-const Element = @import("../../Element.zig");
-const HtmlElement = @import("../Html.zig");
+const std = @import("std");
+const parser = @import("../netsurf.zig");
 
-const Div = @This();
-_proto: *HtmlElement,
+// https://developer.mozilla.org/en-US/docs/Web/API/DOMParser
+pub const DOMParser = struct {
+    pub fn constructor() !DOMParser {
+        return .{};
+    }
 
-pub fn asElement(self: *Div) *Element {
-    return self._proto._proto;
-}
-pub fn asNode(self: *Div) *Node {
-    return self.asElement().asNode();
-}
+    pub fn _parseFromString(_: *DOMParser, string: []const u8, mime_type: []const u8) !*parser.DocumentHTML {
+        if (!std.mem.eql(u8, mime_type, "text/html")) {
+            // TODO: Support XML
+            return error.TypeError;
+        }
 
-pub const JsApi = struct {
-    pub const bridge = js.Bridge(Div);
-
-    pub const Meta = struct {
-        pub const name = "HTMLDivElement";
-        pub const prototype_chain = bridge.prototypeChain();
-        pub var class_id: bridge.ClassId = undefined;
-    };
+        return try parser.documentHTMLParseFromStr(string);
+    }
 };
+
+const testing = @import("../../testing.zig");
+test "Browser: DOM.Parser" {
+    try testing.htmlRunner("dom/dom_parser.html");
+}

src/browser/dom/element.zig

@@ -0,0 +1,686 @@
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const std = @import("std");
+
+const js = @import("../js/js.zig");
+const parser = @import("../netsurf.zig");
+const Page = @import("../page.zig").Page;
+
+const css = @import("css.zig");
+const log = @import("../../log.zig");
+const dump = @import("../dump.zig");
+const collection = @import("html_collection.zig");
+
+const Node = @import("node.zig").Node;
+const Walker = @import("walker.zig").WalkerDepthFirst;
+const NodeList = @import("nodelist.zig").NodeList;
+const HTMLElem = @import("../html/elements.zig");
+const ShadowRoot = @import("../dom/shadow_root.zig").ShadowRoot;
+
+const Animation = @import("Animation.zig");
+
+pub const Union = @import("../html/elements.zig").Union;
+
+// WEB IDL https://dom.spec.whatwg.org/#element
+pub const Element = struct {
+    pub const Self = parser.Element;
+    pub const prototype = *Node;
+    pub const subtype = .node;
+
+    pub const DOMRect = struct {
+        x: f64,
+        y: f64,
+        width: f64,
+        height: f64,
+        bottom: f64,
+        right: f64,
+        top: f64,
+        left: f64,
+    };
+
+    pub fn toInterface(e: *parser.Element) !Union {
+        return toInterfaceT(Union, e);
+    }
+
+    pub fn toInterfaceT(comptime T: type, e: *parser.Element) !T {
+        const tagname = try parser.elementGetTagName(e) orelse {
+            // If the owner's document is HTML, assume we have an HTMLElement.
+            const doc = parser.nodeOwnerDocument(parser.elementToNode(e));
+            if (doc != null and !doc.?.is_html) {
+                return .{ .HTMLElement = @as(*parser.ElementHTML, @ptrCast(e)) };
+            }
+
+            return .{ .Element = e };
+        };
+
+        // TODO SVGElement and MathML are not supported yet.
+
+        const tag = parser.Tag.fromString(tagname) catch {
+            // If the owner's document is HTML, assume we have an HTMLElement.
+            const doc = parser.nodeOwnerDocument(parser.elementToNode(e));
+            if (doc != null and doc.?.is_html) {
+                return .{ .HTMLElement = @as(*parser.ElementHTML, @ptrCast(e)) };
+            }
+
+            return .{ .Element = e };
+        };
+
+        return HTMLElem.toInterfaceFromTag(T, e, tag);
+    }
+
+    // JS funcs
+    // --------
+
+    pub fn get_namespaceURI(self: *parser.Element) ?[]const u8 {
+        return parser.nodeGetNamespace(parser.elementToNode(self));
+    }
+
+    pub fn get_prefix(self: *parser.Element) ?[]const u8 {
+        return parser.nodeGetPrefix(parser.elementToNode(self));
+    }
+
+    pub fn get_localName(self: *parser.Element) ![]const u8 {
+        return try parser.nodeLocalName(parser.elementToNode(self));
+    }
+
+    pub fn get_tagName(self: *parser.Element) ![]const u8 {
+        return try parser.nodeName(parser.elementToNode(self));
+    }
+
+    pub fn get_dir(self: *parser.Element) ![]const u8 {
+        return try parser.elementGetAttribute(self, "dir") orelse "";
+    }
+
+    pub fn set_dir(self: *parser.Element, dir: []const u8) !void {
+        return parser.elementSetAttribute(self, "dir", dir);
+    }
+
+    pub fn get_id(self: *parser.Element) ![]const u8 {
+        return try parser.elementGetAttribute(self, "id") orelse "";
+    }
+
+    pub fn set_id(self: *parser.Element, id: []const u8) !void {
+        return try parser.elementSetAttribute(self, "id", id);
+    }
+
+    pub fn get_className(self: *parser.Element) ![]const u8 {
+        return try parser.elementGetAttribute(self, "class") orelse "";
+    }
+
+    pub fn set_className(self: *parser.Element, class: []const u8) !void {
+        return try parser.elementSetAttribute(self, "class", class);
+    }
+
+    pub fn get_slot(self: *parser.Element) ![]const u8 {
+        return try parser.elementGetAttribute(self, "slot") orelse "";
+    }
+
+    pub fn set_slot(self: *parser.Element, slot: []const u8) !void {
+        return try parser.elementSetAttribute(self, "slot", slot);
+    }
+
+    pub fn get_assignedSlot(self: *parser.Element, page: *const Page) !?*parser.Slot {
+        return @import("../SlotChangeMonitor.zig").findSlot(self, page);
+    }
+
+    pub fn get_classList(self: *parser.Element) !*parser.TokenList {
+        return try parser.tokenListCreate(self, "class");
+    }
+
+    pub fn get_attributes(self: *parser.Element) !*parser.NamedNodeMap {
+        // An element must have non-nil attributes.
+        return try parser.nodeGetAttributes(parser.elementToNode(self)) orelse unreachable;
+    }
+
+    pub fn get_innerHTML(self: *parser.Element, page: *Page) ![]const u8 {
+        var aw = std.Io.Writer.Allocating.init(page.call_arena);
+        try dump.writeChildren(parser.elementToNode(self), .{}, &aw.writer);
+        return aw.written();
+    }
+
+    pub fn get_outerHTML(self: *parser.Element, page: *Page) ![]const u8 {
+        var aw = std.Io.Writer.Allocating.init(page.call_arena);
+        try dump.writeNode(parser.elementToNode(self), .{}, &aw.writer);
+        return aw.written();
+    }
+
+    pub fn set_innerHTML(self: *parser.Element, str: []const u8, page: *Page) !void {
+        const node = parser.elementToNode(self);
+        const doc = parser.nodeOwnerDocument(node) orelse return parser.DOMError.WrongDocument;
+        // parse the fragment
+        const fragment = try parser.documentParseFragmentFromStr(doc, str);
+
+        // remove existing children
+        try Node.removeChildren(node);
+
+        const fragment_node = parser.documentFragmentToNode(fragment);
+
+        // I'm not sure what the exact behavior is supposed to be. Initially,
+        // we were only copying the body of the document fragment. But it seems
+        // like head elements should be copied too. Specifically, some sites
+        // create script tags via innerHTML, which we need to capture.
+        // If you play with this in a browser, you should notice that the
+        // behavior is different depending on whether you're in a blank page
+        // or an actual document. In a blank page, something like:
+        //    x.innerHTML = '<script></script>';
+        // does _not_ create an empty script, but in a real page, it does. Weird.
+        const html = parser.nodeFirstChild(fragment_node) orelse return;
+        const head = parser.nodeFirstChild(html) orelse return;
+        const body = parser.nodeNextSibling(head) orelse return;
+
+        if (try parser.elementTag(self) == .template) {
+            // HTMLElementTemplate is special. We don't append these as children
+            // of the template, but instead set its content as the body of the
+            // fragment. Simpler to do this by copying the body children into
+            // a new fragment
+            const clean = try parser.documentCreateDocumentFragment(doc);
+            const children = try parser.nodeGetChildNodes(body);
+            // always index 0, because nodeAppendChild moves the node out of
+            // the nodeList and into the new tree
+            while (parser.nodeListItem(children, 0)) |child| {
+                _ = try parser.nodeAppendChild(@ptrCast(@alignCast(clean)), child);
+            }
+
+            const state = try page.getOrCreateNodeState(node);
+            state.template_content = clean;
+            return;
+        }
+
+        // For any node other than a template, we copy the head and body elements
+        // as child nodes of the element
+        {
+            // First, copy some of the head element
+            const children = try parser.nodeGetChildNodes(head);
+            // always index 0, because nodeAppendChild moves the node out of
+            // the nodeList and into the new tree
+            while (parser.nodeListItem(children, 0)) |child| {
+                _ = try parser.nodeAppendChild(node, child);
+            }
+        }
+
+        {
+            const children = try parser.nodeGetChildNodes(body);
+            // always index 0, because nodeAppendChild moves the node out of
+            // the nodeList and into the new tree
+            while (parser.nodeListItem(children, 0)) |child| {
+                _ = try parser.nodeAppendChild(node, child);
+            }
+        }
+    }
+
+    /// Parses the given `input` string and inserts its children to an element at given `position`.
+    /// https://developer.mozilla.org/en-US/docs/Web/API/Element/insertAdjacentHTML
+    ///
+    /// TODO: Support for XML parsing and `TrustedHTML` instances.
+    pub fn _insertAdjacentHTML(self: *parser.Element, position: []const u8, input: []const u8) !void {
+        const self_node = parser.elementToNode(self);
+        const doc = parser.nodeOwnerDocument(self_node) orelse {
+            return parser.DOMError.WrongDocument;
+        };
+
+        // Parse the fragment.
+        // Should return error.Syntax on fail?
+        const fragment = try parser.documentParseFragmentFromStr(doc, input);
+        const fragment_node = parser.documentFragmentToNode(fragment);
+
+        // We always get it wrapped like so:
+        // <html><head></head><body>{ ... }</body></html>
+        // None of the following can be null.
+        const maybe_html = parser.nodeFirstChild(fragment_node);
+        std.debug.assert(maybe_html != null);
+        const html = maybe_html orelse return;
+
+        const maybe_body = parser.nodeLastChild(html);
+        std.debug.assert(maybe_body != null);
+        const body = maybe_body orelse return;
+
+        const children = try parser.nodeGetChildNodes(body);
+
+        // * `target_node` is `*Node` (where we actually insert),
+        // * `prev_node` is `?*Node`.
+        const target_node, const prev_node = blk: {
+            // Prefer case-sensitive match.
+            // "beforeend" was the most common case in my tests; we might adjust the order
+            // depending on which ones websites prefer most.
+            if (std.mem.eql(u8, position, "beforeend")) {
+                break :blk .{ self_node, null };
+            }
+
+            if (std.mem.eql(u8, position, "afterbegin")) {
+                // Get the first child; null indicates there are no children.
+                const first_child = parser.nodeFirstChild(self_node);
+                break :blk .{ self_node, first_child };
+            }
+
+            if (std.mem.eql(u8, position, "beforebegin")) {
+                // The node must have a parent node in order to use this variant.
+                const parent = parser.nodeParentNode(self_node) orelse return error.NoModificationAllowed;
+                // Parent cannot be Document.
+                // Should have checks for document_fragment and document_type?
+                if (parser.nodeType(parent) == .document) {
+                    return error.NoModificationAllowed;
+                }
+
+                break :blk .{ parent, self_node };
+            }
+
+            if (std.mem.eql(u8, position, "afterend")) {
+                // The node must have a parent node in order to use this variant.
+                const parent = parser.nodeParentNode(self_node) orelse return error.NoModificationAllowed;
+                // Parent cannot be Document.
+                if (parser.nodeType(parent) == .document) {
+                    return error.NoModificationAllowed;
+                }
+                // Get the next sibling or null; null indicates our node is the only one.
+                const sibling = parser.nodeNextSibling(self_node);
+                break :blk .{ parent, sibling };
+            }
+
+            // Thrown if:
+            // * position is not one of the four listed values.
+            // * The input is XML that is not well-formed.
+            return error.Syntax;
+        };
+
+        while (parser.nodeListItem(children, 0)) |child| {
+            _ = try parser.nodeInsertBefore(target_node, child, prev_node);
+        }
+    }
+
+    // The closest() method of the Element interface traverses the element and its parents (heading toward the document root) until it finds a node that matches the specified CSS selector.
+    // Returns the closest ancestor Element or itself, which matches the selectors. If there are no such element, null.
+    pub fn _closest(self: *parser.Element, selector: []const u8, page: *Page) !?*parser.Element {
+        const cssParse = @import("../css/css.zig").parse;
+        const CssNodeWrap = @import("../css/libdom.zig").Node;
+        const select = try cssParse(page.call_arena, selector, .{});
+
+        var current: CssNodeWrap = .{ .node = parser.elementToNode(self) };
+        while (true) {
+            if (try select.match(current)) {
+                if (!current.isElement()) {
+                    log.err(.browser, "closest invalid type", .{ .type = try current.tag() });
+                    return null;
+                }
+                return parser.nodeToElement(current.node);
+            }
+            current = current.parent() orelse return null;
+        }
+    }
+
+    // don't use parser.nodeHasAttributes(...) because that returns true/false
+    // based on the type, e.g. a node never as attributes, an element always has
+    // attributes. But, Element.hasAttributes is supposed to return true only
+    // if the element has at least 1 attribute.
+    pub fn _hasAttributes(self: *parser.Element) !bool {
+        // an element _must_ have at least an empty attribute
+        const node_map = try parser.nodeGetAttributes(parser.elementToNode(self)) orelse unreachable;
+        return try parser.namedNodeMapGetLength(node_map) > 0;
+    }
+
+    pub fn _getAttribute(self: *parser.Element, qname: []const u8) !?[]const u8 {
+        return try parser.elementGetAttribute(self, qname);
+    }
+
+    pub fn _getAttributeNS(self: *parser.Element, ns: []const u8, qname: []const u8) !?[]const u8 {
+        return try parser.elementGetAttributeNS(self, ns, qname);
+    }
+
+    pub fn _setAttribute(self: *parser.Element, qname: []const u8, value: []const u8) !void {
+        return try parser.elementSetAttribute(self, qname, value);
+    }
+
+    pub fn _setAttributeNS(self: *parser.Element, ns: []const u8, qname: []const u8, value: []const u8) !void {
+        return try parser.elementSetAttributeNS(self, ns, qname, value);
+    }
+
+    pub fn _removeAttribute(self: *parser.Element, qname: []const u8) !void {
+        return try parser.elementRemoveAttribute(self, qname);
+    }
+
+    pub fn _removeAttributeNS(self: *parser.Element, ns: []const u8, qname: []const u8) !void {
+        return try parser.elementRemoveAttributeNS(self, ns, qname);
+    }
+
+    pub fn _hasAttribute(self: *parser.Element, qname: []const u8) !bool {
+        return try parser.elementHasAttribute(self, qname);
+    }
+
+    pub fn _hasAttributeNS(self: *parser.Element, ns: []const u8, qname: []const u8) !bool {
+        return try parser.elementHasAttributeNS(self, ns, qname);
+    }
+
+    // https://dom.spec.whatwg.org/#dom-element-toggleattribute
+    pub fn _toggleAttribute(self: *parser.Element, qname: []u8, force: ?bool) !bool {
+        _ = std.ascii.lowerString(qname, qname);
+        const exists = try parser.elementHasAttribute(self, qname);
+
+        // If attribute is null, then:
+        if (!exists) {
+            // If force is not given or is true, create an attribute whose
+            // local name is qualifiedName, value is the empty string and node
+            // document is this’s node document, then append this attribute to
+            // this, and then return true.
+            if (force == null or force.?) {
+                try parser.elementSetAttribute(self, qname, "");
+                return true;
+            }
+            if (try parser.validateName(qname) == false) {
+                return parser.DOMError.InvalidCharacter;
+            }
+
+            // Return false.
+            return false;
+        }
+
+        // Otherwise, if force is not given or is false, remove an attribute
+        // given qualifiedName and this, and then return false.
+        if (force == null or !force.?) {
+            try parser.elementRemoveAttribute(self, qname);
+            return false;
+        }
+
+        // Return true.
+        return true;
+    }
+
+    pub fn _getAttributeNames(self: *parser.Element, page: *Page) ![]const []const u8 {
+        const attributes = try parser.nodeGetAttributes(@ptrCast(self)) orelse return &.{};
+        const ln = try parser.namedNodeMapGetLength(attributes);
+
+        const names = try page.call_arena.alloc([]const u8, ln);
+        var at: usize = 0;
+
+        for (0..ln) |i| {
+            const attribute = try parser.namedNodeMapItem(attributes, @intCast(i)) orelse break;
+            names[at] = try parser.attributeGetName(attribute);
+            at += 1;
+        }
+
+        return names[0..at];
+    }
+
+    pub fn _getAttributeNode(self: *parser.Element, name: []const u8) !?*parser.Attribute {
+        return try parser.elementGetAttributeNode(self, name);
+    }
+
+    pub fn _getAttributeNodeNS(self: *parser.Element, ns: []const u8, name: []const u8) !?*parser.Attribute {
+        return try parser.elementGetAttributeNodeNS(self, ns, name);
+    }
+
+    pub fn _setAttributeNode(self: *parser.Element, attr: *parser.Attribute) !?*parser.Attribute {
+        return try parser.elementSetAttributeNode(self, attr);
+    }
+
+    pub fn _setAttributeNodeNS(self: *parser.Element, attr: *parser.Attribute) !?*parser.Attribute {
+        return try parser.elementSetAttributeNodeNS(self, attr);
+    }
+
+    pub fn _removeAttributeNode(self: *parser.Element, attr: *parser.Attribute) !*parser.Attribute {
+        return try parser.elementRemoveAttributeNode(self, attr);
+    }
+
+    pub fn _getElementsByTagName(self: *parser.Element, tag_name: js.String) !collection.HTMLCollection {
+        return collection.HTMLCollectionByTagName(
+            parser.elementToNode(self),
+            tag_name.string,
+            .{ .include_root = false },
+        );
+    }
+
+    pub fn _getElementsByClassName(self: *parser.Element, class_names: js.String) !collection.HTMLCollection {
+        return try collection.HTMLCollectionByClassName(
+            parser.elementToNode(self),
+            class_names.string,
+            .{ .include_root = false },
+        );
+    }
+
+    // ParentNode
+    // https://dom.spec.whatwg.org/#parentnode
+    pub fn get_children(self: *parser.Element) !collection.HTMLCollection {
+        return collection.HTMLCollectionChildren(parser.elementToNode(self), .{
+            .include_root = false,
+        });
+    }
+
+    pub fn get_firstElementChild(self: *parser.Element) !?Union {
+        var children = try get_children(self);
+        return try children._item(0);
+    }
+
+    pub fn get_lastElementChild(self: *parser.Element) !?Union {
+        // TODO we could check the last child node first, if it's an element,
+        // we can return it directly instead of looping twice over the
+        // children.
+        var children = try get_children(self);
+        const ln = try children.get_length();
+        if (ln == 0) return null;
+        return try children._item(ln - 1);
+    }
+
+    pub fn get_childElementCount(self: *parser.Element) !u32 {
+        var children = try get_children(self);
+        return try children.get_length();
+    }
+
+    // NonDocumentTypeChildNode
+    // https://dom.spec.whatwg.org/#interface-nondocumenttypechildnode
+    pub fn get_previousElementSibling(self: *parser.Element) !?Union {
+        const res = parser.nodePreviousElementSibling(parser.elementToNode(self));
+        if (res == null) return null;
+        return try toInterface(res.?);
+    }
+
+    pub fn get_nextElementSibling(self: *parser.Element) !?Union {
+        const res = parser.nodeNextElementSibling(parser.elementToNode(self));
+        if (res == null) return null;
+        return try toInterface(res.?);
+    }
+
+    fn getElementById(self: *parser.Element, id: []const u8) !?*parser.Node {
+        // walk over the node tree fo find the node by id.
+        const root = parser.elementToNode(self);
+        const walker = Walker{};
+        var next: ?*parser.Node = null;
+        while (true) {
+            next = try walker.get_next(root, next) orelse return null;
+            // ignore non-element nodes.
+            if (parser.nodeType(next.?) != .element) {
+                continue;
+            }
+            const e = parser.nodeToElement(next.?);
+            if (std.mem.eql(u8, id, try get_id(e))) return next;
+        }
+    }
+
+    pub fn _querySelector(self: *parser.Element, selector: []const u8, page: *Page) !?Union {
+        if (selector.len == 0) return null;
+
+        const n = try css.querySelector(page.call_arena, parser.elementToNode(self), selector);
+
+        if (n == null) return null;
+
+        return try toInterface(parser.nodeToElement(n.?));
+    }
+
+    pub fn _querySelectorAll(self: *parser.Element, selector: []const u8, page: *Page) !NodeList {
+        return css.querySelectorAll(page.arena, parser.elementToNode(self), selector);
+    }
+
+    pub fn _prepend(self: *parser.Element, nodes: []const Node.NodeOrText) !void {
+        return Node.prepend(parser.elementToNode(self), nodes);
+    }
+
+    pub fn _append(self: *parser.Element, nodes: []const Node.NodeOrText) !void {
+        return Node.append(parser.elementToNode(self), nodes);
+    }
+
+    pub fn _before(self: *parser.Element, nodes: []const Node.NodeOrText) !void {
+        const ref_node = parser.elementToNode(self);
+        return Node.before(ref_node, nodes);
+    }
+
+    pub fn _after(self: *parser.Element, nodes: []const Node.NodeOrText) !void {
+        const ref_node = parser.elementToNode(self);
+        return Node.after(ref_node, nodes);
+    }
+
+    pub fn _replaceChildren(self: *parser.Element, nodes: []const Node.NodeOrText) !void {
+        return Node.replaceChildren(parser.elementToNode(self), nodes);
+    }
+
+    // A DOMRect object providing information about the size of an element and its position relative to the viewport.
+    // Returns a 0 DOMRect object if the element is eventually detached from the main window
+    pub fn _getBoundingClientRect(self: *parser.Element, page: *Page) !DOMRect {
+        // Since we are lazy rendering we need to do this check. We could store the renderer in a viewport such that it could cache these, but it would require tracking changes.
+        if (!page.isNodeAttached(parser.elementToNode(self))) {
+            return DOMRect{
+                .x = 0,
+                .y = 0,
+                .width = 0,
+                .height = 0,
+                .bottom = 0,
+                .right = 0,
+                .top = 0,
+                .left = 0,
+            };
+        }
+        return page.renderer.getRect(self);
+    }
+
+    // Returns a collection of DOMRect objects that indicate the bounding rectangles for each CSS border box in a client.
+    // We do not render so it only always return the element's bounding rect.
+    // Returns an empty array if the element is eventually detached from the main window
+    pub fn _getClientRects(self: *parser.Element, page: *Page) ![]DOMRect {
+        if (!page.isNodeAttached(parser.elementToNode(self))) {
+            return &.{};
+        }
+        const heap_ptr = try page.call_arena.create(DOMRect);
+        heap_ptr.* = try page.renderer.getRect(self);
+        return heap_ptr[0..1];
+    }
+
+    pub fn get_clientWidth(_: *parser.Element, page: *Page) u32 {
+        return page.renderer.width();
+    }
+
+    pub fn get_clientHeight(_: *parser.Element, page: *Page) u32 {
+        return page.renderer.height();
+    }
+
+    pub fn _matches(self: *parser.Element, selectors: []const u8, page: *Page) !bool {
+        const cssParse = @import("../css/css.zig").parse;
+        const CssNodeWrap = @import("../css/libdom.zig").Node;
+        const s = try cssParse(page.call_arena, selectors, .{});
+        return s.match(CssNodeWrap{ .node = parser.elementToNode(self) });
+    }
+
+    pub fn _scrollIntoViewIfNeeded(_: *parser.Element, center_if_needed: ?bool) void {
+        _ = center_if_needed;
+    }
+
+    const CheckVisibilityOpts = struct {
+        contentVisibilityAuto: bool,
+        opacityProperty: bool,
+        visibilityProperty: bool,
+        checkVisibilityCSS: bool,
+        checkOpacity: bool,
+    };
+
+    pub fn _checkVisibility(self: *parser.Element, opts: ?CheckVisibilityOpts) bool {
+        _ = self;
+        _ = opts;
+        return true;
+    }
+
+    const AttachShadowOpts = struct {
+        mode: []const u8, // must be specified
+    };
+    pub fn _attachShadow(self: *parser.Element, opts: AttachShadowOpts, page: *Page) !*ShadowRoot {
+        const mode = std.meta.stringToEnum(ShadowRoot.Mode, opts.mode) orelse return error.InvalidArgument;
+        const state = try page.getOrCreateNodeState(@ptrCast(@alignCast(self)));
+        if (state.shadow_root) |sr| {
+            if (mode != sr.mode) {
+                // this is the behavior per the spec
+                return error.NotSupportedError;
+            }
+
+            try Node.removeChildren(@ptrCast(@alignCast(sr.proto)));
+            return sr;
+        }
+
+        // Not sure what to do if there is no owner document
+        const doc = parser.nodeOwnerDocument(@ptrCast(self)) orelse return error.InvalidArgument;
+        const fragment = try parser.documentCreateDocumentFragment(doc);
+        const sr = try page.arena.create(ShadowRoot);
+        sr.* = .{
+            .host = self,
+            .mode = mode,
+            .proto = fragment,
+        };
+        state.shadow_root = sr;
+        parser.documentFragmentSetHost(sr.proto, @ptrCast(@alignCast(self)));
+
+        // Storing the ShadowRoot on the element makes sense, it's the ShadowRoot's
+        // parent. When we render, we go top-down, so we'll have the element, get
+        // its shadowroot, and go on. that's what the above code does.
+        // But we sometimes need to go bottom-up, e.g when we have a slot element
+        // and want to find the containing parent. Unforatunately , we don't have
+        // that link, so we need to create it. In the DOM, the ShadowRoot is
+        // represented by this DocumentFragment (it's the ShadowRoot's base prototype)
+        // So we can also store the ShadowRoot in the DocumentFragment's state.
+        const fragment_state = try page.getOrCreateNodeState(@ptrCast(@alignCast(fragment)));
+        fragment_state.shadow_root = sr;
+
+        return sr;
+    }
+
+    pub fn get_shadowRoot(self: *parser.Element, page: *Page) ?*ShadowRoot {
+        const state = page.getNodeState(@ptrCast(@alignCast(self))) orelse return null;
+        const sr = state.shadow_root orelse return null;
+        if (sr.mode == .closed) {
+            return null;
+        }
+        return sr;
+    }
+
+    pub fn _animate(self: *parser.Element, effect: js.Object, opts: js.Object) !Animation {
+        _ = self;
+        _ = opts;
+        return Animation.constructor(effect, null);
+    }
+
+    pub fn _remove(self: *parser.Element) !void {
+        // TODO: This hasn't been tested to make sure all references to this
+        // node are properly updated. A lot of libdom is lazy and will look
+        // for related elements JIT by walking the tree, but there could be
+        // cases in libdom or the Zig WebAPI where this reference is kept
+        const as_node: *parser.Node = @ptrCast(self);
+        const parent = parser.nodeParentNode(as_node) orelse return;
+        _ = try Node._removeChild(parent, as_node);
+    }
+};
+
+// Tests
+// -----
+
+const testing = @import("../../testing.zig");
+test "Browser: DOM.Element" {
+    try testing.htmlRunner("dom/element.html");
+}

src/browser/dom/event_target.zig

@@ -0,0 +1,175 @@
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const std = @import("std");
+const parser = @import("../netsurf.zig");
+const Page = @import("../page.zig").Page;
+
+const EventHandler = @import("../events/event.zig").EventHandler;
+
+const DOMException = @import("exceptions.zig").DOMException;
+const nod = @import("node.zig");
+
+pub const Union = union(enum) {
+    node: nod.Union,
+    xhr: *@import("../xhr/xhr.zig").XMLHttpRequest,
+    plain: *parser.EventTarget,
+    message_port: *@import("MessageChannel.zig").MessagePort,
+    screen: *@import("../html/screen.zig").Screen,
+    screen_orientation: *@import("../html/screen.zig").ScreenOrientation,
+    performance: *@import("performance.zig").Performance,
+    media_query_list: *@import("../html/media_query_list.zig").MediaQueryList,
+    navigation: *@import("../navigation/Navigation.zig"),
+};
+
+// EventTarget implementation
+pub const EventTarget = struct {
+    pub const Self = parser.EventTarget;
+    pub const Exception = DOMException;
+
+    // Extend libdom event target for pure zig struct.
+    base: parser.EventTargetTBase = parser.EventTargetTBase{ .internal_target_type = .plain },
+
+    pub fn toInterface(et: *parser.EventTarget, page: *Page) !Union {
+        // libdom assumes that all event targets are libdom nodes. They are not.
+
+        switch (parser.eventTargetInternalType(et)) {
+            .libdom_node => {
+                return .{ .node = try nod.Node.toInterface(@as(*parser.Node, @ptrCast(et))) };
+            },
+            .plain => return .{ .plain = et },
+            .abort_signal => {
+                // AbortSignal is a special case, it has its own internal type.
+                // We return it as a node, but we need to handle it differently.
+                return .{ .node = .{ .AbortSignal = @fieldParentPtr("proto", @as(*parser.EventTargetTBase, @ptrCast(et))) } };
+            },
+            .window => {
+                // The window is a common non-node target, but it's easy to handle as its a singleton.
+                std.debug.assert(@intFromPtr(et) == @intFromPtr(&page.window.base));
+                return .{ .node = .{ .Window = &page.window } };
+            },
+            .xhr => {
+                const XMLHttpRequestEventTarget = @import("../xhr/event_target.zig").XMLHttpRequestEventTarget;
+                const base: *XMLHttpRequestEventTarget = @fieldParentPtr("base", @as(*parser.EventTargetTBase, @ptrCast(et)));
+                return .{ .xhr = @fieldParentPtr("proto", base) };
+            },
+            .message_port => {
+                return .{ .message_port = @fieldParentPtr("proto", @as(*parser.EventTargetTBase, @ptrCast(et))) };
+            },
+            .screen => {
+                return .{ .screen = @fieldParentPtr("proto", @as(*parser.EventTargetTBase, @ptrCast(et))) };
+            },
+            .screen_orientation => {
+                return .{ .screen_orientation = @fieldParentPtr("proto", @as(*parser.EventTargetTBase, @ptrCast(et))) };
+            },
+            .performance => {
+                return .{ .performance = @fieldParentPtr("base", @as(*parser.EventTargetTBase, @ptrCast(et))) };
+            },
+            .media_query_list => {
+                return .{ .media_query_list = @fieldParentPtr("base", @as(*parser.EventTargetTBase, @ptrCast(et))) };
+            },
+            .navigation => {
+                const NavigationEventTarget = @import("../navigation/NavigationEventTarget.zig");
+                const base: *NavigationEventTarget = @fieldParentPtr("base", @as(*parser.EventTargetTBase, @ptrCast(et)));
+                return .{ .navigation = @fieldParentPtr("proto", base) };
+            },
+        }
+    }
+
+    // JS funcs
+    // --------
+    pub fn constructor(page: *Page) !*parser.EventTarget {
+        const et = try page.arena.create(EventTarget);
+        et.* = .{};
+        return @ptrCast(&et.base);
+    }
+
+    pub fn _addEventListener(
+        self: *parser.EventTarget,
+        typ: []const u8,
+        listener: EventHandler.Listener,
+        opts: ?EventHandler.Opts,
+        page: *Page,
+    ) !void {
+        _ = try EventHandler.register(page.arena, self, typ, listener, opts);
+        if (std.mem.eql(u8, typ, "slotchange")) {
+            try page.registerSlotChangeMonitor();
+        }
+    }
+
+    const RemoveEventListenerOpts = union(enum) {
+        opts: Opts,
+        capture: bool,
+
+        const Opts = struct {
+            capture: ?bool,
+        };
+    };
+
+    pub fn _removeEventListener(
+        self: *parser.EventTarget,
+        typ: []const u8,
+        listener: EventHandler.Listener,
+        opts_: ?RemoveEventListenerOpts,
+    ) !void {
+        var capture = false;
+        if (opts_) |opts| {
+            capture = switch (opts) {
+                .capture => |c| c,
+                .opts => |o| o.capture orelse false,
+            };
+        }
+
+        const cbk = (try listener.callback(self)) orelse return;
+
+        // check if event target has already this listener
+        const lst = try parser.eventTargetHasListener(
+            self,
+            typ,
+            capture,
+            cbk.id,
+        );
+        if (lst == null) {
+            return;
+        }
+
+        // remove listener
+        try parser.eventTargetRemoveEventListener(
+            self,
+            typ,
+            lst.?,
+            capture,
+        );
+    }
+
+    pub fn _dispatchEvent(self: *parser.EventTarget, event: *parser.Event, page: *Page) !bool {
+        const res = try parser.eventTargetDispatchEvent(self, event);
+
+        if (!parser.eventBubbles(event) or parser.eventIsStopped(event)) {
+            return res;
+        }
+
+        try page.window.dispatchForDocumentTarget(event);
+        return true;
+    }
+};
+
+const testing = @import("../../testing.zig");
+test "Browser: DOM.EventTarget" {
+    try testing.htmlRunner("dom/event_target.html");
+}

src/browser/dom/exceptions.zig

@@ -0,0 +1,224 @@
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const std = @import("std");
+const allocPrint = std.fmt.allocPrint;
+
+const parser = @import("../netsurf.zig");
+const Page = @import("../page.zig").Page;
+
+// https://webidl.spec.whatwg.org/#idl-DOMException
+pub const DOMException = struct {
+    err: ?parser.DOMError,
+    str: []const u8,
+
+    pub const ErrorSet = parser.DOMError;
+
+    // static attributes
+    pub const _INDEX_SIZE_ERR = 1;
+    pub const _DOMSTRING_SIZE_ERR = 2;
+    pub const _HIERARCHY_REQUEST_ERR = 3;
+    pub const _WRONG_DOCUMENT_ERR = 4;
+    pub const _INVALID_CHARACTER_ERR = 5;
+    pub const _NO_DATA_ALLOWED_ERR = 6;
+    pub const _NO_MODIFICATION_ALLOWED_ERR = 7;
+    pub const _NOT_FOUND_ERR = 8;
+    pub const _NOT_SUPPORTED_ERR = 9;
+    pub const _INUSE_ATTRIBUTE_ERR = 10;
+    pub const _INVALID_STATE_ERR = 11;
+    pub const _SYNTAX_ERR = 12;
+    pub const _INVALID_MODIFICATION_ERR = 13;
+    pub const _NAMESPACE_ERR = 14;
+    pub const _INVALID_ACCESS_ERR = 15;
+    pub const _VALIDATION_ERR = 16;
+    pub const _TYPE_MISMATCH_ERR = 17;
+    pub const _SECURITY_ERR = 18;
+    pub const _NETWORK_ERR = 19;
+    pub const _ABORT_ERR = 20;
+    pub const _URL_MISMATCH_ERR = 21;
+    pub const _QUOTA_EXCEEDED_ERR = 22;
+    pub const _TIMEOUT_ERR = 23;
+    pub const _INVALID_NODE_TYPE_ERR = 24;
+    pub const _DATA_CLONE_ERR = 25;
+
+    pub fn constructor(message_: ?[]const u8, name_: ?[]const u8, page: *const Page) !DOMException {
+        const message = message_ orelse "";
+        const err = if (name_) |n| error_from_str(n) else null;
+        const fixed_name = name(err);
+
+        if (message.len == 0) return .{ .err = err, .str = fixed_name };
+
+        const str = try allocPrint(page.arena, "{s}: {s}", .{ fixed_name, message });
+        return .{ .err = err, .str = str };
+    }
+
+    // TODO: deinit
+    pub fn init(alloc: std.mem.Allocator, err: anyerror, caller_name: []const u8) !DOMException {
+        const dom_error = @as(parser.DOMError, @errorCast(err));
+        const error_name = DOMException.name(dom_error);
+        const str = switch (dom_error) {
+            error.HierarchyRequest => try allocPrint(
+                alloc,
+                "{s}: Failed to execute '{s}' on 'Node': The new child element contains the parent.",
+                .{ error_name, caller_name },
+            ),
+            // todo add more custom error messages
+            else => try allocPrint(
+                alloc,
+                "{s}: Failed to execute '{s}' : {s}",
+                .{ error_name, caller_name, error_name },
+            ),
+            error.NoError => unreachable,
+        };
+        return .{ .err = dom_error, .str = str };
+    }
+
+    fn error_from_str(name_: []const u8) ?parser.DOMError {
+        // @speed: Consider length first, left as is for maintainability, awaiting switch on string support
+        if (std.mem.eql(u8, name_, "IndexSizeError")) return error.IndexSize;
+        if (std.mem.eql(u8, name_, "StringSizeError")) return error.StringSize;
+        if (std.mem.eql(u8, name_, "HierarchyRequestError")) return error.HierarchyRequest;
+        if (std.mem.eql(u8, name_, "WrongDocumentError")) return error.WrongDocument;
+        if (std.mem.eql(u8, name_, "InvalidCharacterError")) return error.InvalidCharacter;
+        if (std.mem.eql(u8, name_, "NoDataAllowedError")) return error.NoDataAllowed;
+        if (std.mem.eql(u8, name_, "NoModificationAllowedError")) return error.NoModificationAllowed;
+        if (std.mem.eql(u8, name_, "NotFoundError")) return error.NotFound;
+        if (std.mem.eql(u8, name_, "NotSupportedError")) return error.NotSupported;
+        if (std.mem.eql(u8, name_, "InuseAttributeError")) return error.InuseAttribute;
+        if (std.mem.eql(u8, name_, "InvalidStateError")) return error.InvalidState;
+        if (std.mem.eql(u8, name_, "SyntaxError")) return error.Syntax;
+        if (std.mem.eql(u8, name_, "InvalidModificationError")) return error.InvalidModification;
+        if (std.mem.eql(u8, name_, "NamespaceError")) return error.Namespace;
+        if (std.mem.eql(u8, name_, "InvalidAccessError")) return error.InvalidAccess;
+        if (std.mem.eql(u8, name_, "ValidationError")) return error.Validation;
+        if (std.mem.eql(u8, name_, "TypeMismatchError")) return error.TypeMismatch;
+        if (std.mem.eql(u8, name_, "SecurityError")) return error.Security;
+        if (std.mem.eql(u8, name_, "NetworkError")) return error.Network;
+        if (std.mem.eql(u8, name_, "AbortError")) return error.Abort;
+        if (std.mem.eql(u8, name_, "URLismatchError")) return error.URLismatch;
+        if (std.mem.eql(u8, name_, "QuotaExceededError")) return error.QuotaExceeded;
+        if (std.mem.eql(u8, name_, "TimeoutError")) return error.Timeout;
+        if (std.mem.eql(u8, name_, "InvalidNodeTypeError")) return error.InvalidNodeType;
+        if (std.mem.eql(u8, name_, "DataCloneError")) return error.DataClone;
+
+        // custom netsurf error
+        if (std.mem.eql(u8, name_, "UnspecifiedEventTypeError")) return error.UnspecifiedEventType;
+        if (std.mem.eql(u8, name_, "DispatchRequestError")) return error.DispatchRequest;
+        if (std.mem.eql(u8, name_, "NoMemoryError")) return error.NoMemory;
+        if (std.mem.eql(u8, name_, "AttributeWrongTypeError")) return error.AttributeWrongType;
+        return null;
+    }
+
+    fn name(err_: ?parser.DOMError) []const u8 {
+        const err = err_ orelse return "Error";
+
+        return switch (err) {
+            error.IndexSize => "IndexSizeError",
+            error.StringSize => "StringSizeError", // Legacy: DOMSTRING_SIZE_ERR
+            error.HierarchyRequest => "HierarchyRequestError",
+            error.WrongDocument => "WrongDocumentError",
+            error.InvalidCharacter => "InvalidCharacterError",
+            error.NoDataAllowed => "NoDataAllowedError", // Legacy: NO_DATA_ALLOWED_ERR
+            error.NoModificationAllowed => "NoModificationAllowedError",
+            error.NotFound => "NotFoundError",
+            error.NotSupported => "NotSupportedError",
+            error.InuseAttribute => "InuseAttributeError",
+            error.InvalidState => "InvalidStateError",
+            error.Syntax => "SyntaxError",
+            error.InvalidModification => "InvalidModificationError",
+            error.Namespace => "NamespaceError",
+            error.InvalidAccess => "InvalidAccessError",
+            error.Validation => "ValidationError", // Legacy: VALIDATION_ERR
+            error.TypeMismatch => "TypeMismatchError",
+            error.Security => "SecurityError",
+            error.Network => "NetworkError",
+            error.Abort => "AbortError",
+            error.URLismatch => "URLismatchError",
+            error.QuotaExceeded => "QuotaExceededError",
+            error.Timeout => "TimeoutError",
+            error.InvalidNodeType => "InvalidNodeTypeError",
+            error.DataClone => "DataCloneError",
+            error.NoError => unreachable,
+
+            // custom netsurf error
+            error.UnspecifiedEventType => "UnspecifiedEventTypeError",
+            error.DispatchRequest => "DispatchRequestError",
+            error.NoMemory => "NoMemoryError",
+            error.AttributeWrongType => "AttributeWrongTypeError",
+        };
+    }
+
+    // JS properties and methods
+
+    pub fn get_code(self: *const DOMException) u8 {
+        const err = self.err orelse return 0;
+        return switch (err) {
+            error.IndexSize => 1,
+            error.StringSize => 2,
+            error.HierarchyRequest => 3,
+            error.WrongDocument => 4,
+            error.InvalidCharacter => 5,
+            error.NoDataAllowed => 6,
+            error.NoModificationAllowed => 7,
+            error.NotFound => 8,
+            error.NotSupported => 9,
+            error.InuseAttribute => 10,
+            error.InvalidState => 11,
+            error.Syntax => 12,
+            error.InvalidModification => 13,
+            error.Namespace => 14,
+            error.InvalidAccess => 15,
+            error.Validation => 16,
+            error.TypeMismatch => 17,
+            error.Security => 18,
+            error.Network => 19,
+            error.Abort => 20,
+            error.URLismatch => 21,
+            error.QuotaExceeded => 22,
+            error.Timeout => 23,
+            error.InvalidNodeType => 24,
+            error.DataClone => 25,
+            error.NoError => unreachable,
+
+            // custom netsurf error
+            error.UnspecifiedEventType => 128,
+            error.DispatchRequest => 129,
+            error.NoMemory => 130,
+            error.AttributeWrongType => 131,
+        };
+    }
+
+    pub fn get_name(self: *const DOMException) []const u8 {
+        return DOMException.name(self.err);
+    }
+
+    pub fn get_message(self: *const DOMException) []const u8 {
+        const errName = DOMException.name(self.err);
+        if (self.str.len <= errName.len + 2) return "";
+        return self.str[errName.len + 2 ..]; // ! Requires str is formatted as "{name}: {message}"
+    }
+
+    pub fn _toString(self: *const DOMException) []const u8 {
+        return self.str;
+    }
+};
+
+const testing = @import("../../testing.zig");
+test "Browser: DOM.Exceptions" {
+    try testing.htmlRunner("dom/exceptions.html");
+}

src/browser/dom/html_collection.zig

@@ -0,0 +1,454 @@
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+
+const parser = @import("../netsurf.zig");
+
+const Element = @import("element.zig").Element;
+const Union = @import("element.zig").Union;
+const Walker = @import("walker.zig").Walker;
+
+const Matcher = union(enum) {
+    matchByName: MatchByName,
+    matchByTagName: MatchByTagName,
+    matchByClassName: MatchByClassName,
+    matchByLinks: MatchByLinks,
+    matchByAnchors: MatchByAnchors,
+    matchTrue: struct {},
+    matchFalse: struct {},
+
+    pub fn match(self: Matcher, node: *parser.Node) !bool {
+        switch (self) {
+            .matchTrue => return true,
+            .matchFalse => return false,
+            .matchByLinks => return MatchByLinks.match(node),
+            .matchByAnchors => return MatchByAnchors.match(node),
+            inline else => |m| return m.match(node),
+        }
+    }
+};
+
+pub const MatchByTagName = struct {
+    // tag is used to select node against their name.
+    // tag comparison is case insensitive.
+    tag: []const u8,
+    is_wildcard: bool,
+
+    fn init(tag_name: []const u8) MatchByTagName {
+        if (std.mem.eql(u8, tag_name, "*")) {
+            return .{ .tag = "*", .is_wildcard = true };
+        }
+
+        return .{
+            .tag = tag_name,
+            .is_wildcard = false,
+        };
+    }
+
+    pub fn match(self: MatchByTagName, node: *parser.Node) !bool {
+        return self.is_wildcard or std.ascii.eqlIgnoreCase(self.tag, try parser.nodeName(node));
+    }
+};
+
+pub fn HTMLCollectionByTagName(
+    root: ?*parser.Node,
+    tag_name: []const u8,
+    opts: Opts,
+) HTMLCollection {
+    return .{
+        .root = root,
+        .walker = .{ .walkerDepthFirst = .{} },
+        .matcher = .{ .matchByTagName = MatchByTagName.init(tag_name) },
+        .mutable = opts.mutable,
+        .include_root = opts.include_root,
+    };
+}
+
+pub const MatchByClassName = struct {
+    class_names: []const u8,
+
+    fn init(class_names: []const u8) !MatchByClassName {
+        return .{
+            .class_names = class_names,
+        };
+    }
+
+    pub fn match(self: MatchByClassName, node: *parser.Node) !bool {
+        const e = parser.nodeToElement(node);
+
+        var it = std.mem.splitScalar(u8, self.class_names, ' ');
+        while (it.next()) |c| {
+            if (!try parser.elementHasClass(e, c)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+};
+
+pub fn HTMLCollectionByClassName(
+    root: ?*parser.Node,
+    class_names: []const u8,
+    opts: Opts,
+) !HTMLCollection {
+    return HTMLCollection{
+        .root = root,
+        .walker = .{ .walkerDepthFirst = .{} },
+        .matcher = .{ .matchByClassName = try MatchByClassName.init(class_names) },
+        .mutable = opts.mutable,
+        .include_root = opts.include_root,
+    };
+}
+
+pub const MatchByName = struct {
+    name: []const u8,
+
+    fn init(name: []const u8) !MatchByName {
+        return .{ .name = name };
+    }
+
+    pub fn match(self: MatchByName, node: *parser.Node) !bool {
+        const e = parser.nodeToElement(node);
+        const nname = try parser.elementGetAttribute(e, "name") orelse return false;
+        return std.mem.eql(u8, self.name, nname);
+    }
+};
+
+pub fn HTMLCollectionByName(
+    root: ?*parser.Node,
+    name: []const u8,
+    opts: Opts,
+) !HTMLCollection {
+    return HTMLCollection{
+        .root = root,
+        .walker = .{ .walkerDepthFirst = .{} },
+        .matcher = .{ .matchByName = try MatchByName.init(name) },
+        .mutable = opts.mutable,
+        .include_root = opts.include_root,
+    };
+}
+
+// HTMLAllCollection is a special type: instances of it are falsy. It's the only
+// object in the WebAPI that behaves like this - in fact, it's even a special
+// case in the JavaScript spec.
+// This is important, because a lot of browser detection rely on this behavior
+// to determine what browser is running.
+
+// It's also possible to use an instance like a function:
+//   document.all(3)
+//   document.all('some_id')
+pub const HTMLAllCollection = struct {
+    pub const prototype = *HTMLCollection;
+
+    proto: HTMLCollection,
+
+    pub const mark_as_undetectable = true;
+
+    pub fn init(root: ?*parser.Node) HTMLAllCollection {
+        return .{ .proto = .{
+            .root = root,
+            .walker = .{ .walkerDepthFirst = .{} },
+            .matcher = .{ .matchTrue = .{} },
+            .include_root = true,
+        } };
+    }
+
+    const CAllAsFunctionArg = union(enum) {
+        index: u32,
+        id: []const u8,
+    };
+
+    pub fn jsCallAsFunction(self: *HTMLAllCollection, arg: CAllAsFunctionArg) !?Union {
+        return switch (arg) {
+            .index => |i| self.proto._item(i),
+            .id => |id| self.proto._namedItem(id),
+        };
+    }
+};
+
+pub fn HTMLCollectionChildren(
+    root: ?*parser.Node,
+    opts: Opts,
+) HTMLCollection {
+    return HTMLCollection{
+        .root = root,
+        .walker = .{ .walkerChildren = .{} },
+        .matcher = .{ .matchTrue = .{} },
+        .mutable = opts.mutable,
+        .include_root = opts.include_root,
+    };
+}
+
+pub fn HTMLCollectionEmpty() HTMLCollection {
+    return .{
+        .root = null,
+        .walker = .{ .walkerNone = .{} },
+        .matcher = .{ .matchFalse = .{} },
+        .include_root = false,
+    };
+}
+
+// MatchByLinks matches the a and area elements in the Document that have href
+// attributes.
+// https://html.spec.whatwg.org/#dom-document-links
+pub const MatchByLinks = struct {
+    pub fn match(node: *parser.Node) !bool {
+        const tag = try parser.nodeName(node);
+        if (!std.ascii.eqlIgnoreCase(tag, "a") and !std.ascii.eqlIgnoreCase(tag, "area")) {
+            return false;
+        }
+        const elem = @as(*parser.Element, @ptrCast(node));
+        return parser.elementHasAttribute(elem, "href");
+    }
+};
+
+pub fn HTMLCollectionByLinks(root: ?*parser.Node, opts: Opts) HTMLCollection {
+    return .{
+        .root = root,
+        .walker = .{ .walkerDepthFirst = .{} },
+        .matcher = .{ .matchByLinks = .{} },
+        .mutable = opts.mutable,
+        .include_root = opts.include_root,
+    };
+}
+
+// MatchByAnchors matches the a elements in the Document that have name
+// attributes.
+// https://html.spec.whatwg.org/#dom-document-anchors
+pub const MatchByAnchors = struct {
+    pub fn match(node: *parser.Node) !bool {
+        const tag = try parser.nodeName(node);
+        if (!std.ascii.eqlIgnoreCase(tag, "a")) return false;
+
+        const elem = @as(*parser.Element, @ptrCast(node));
+        return parser.elementHasAttribute(elem, "name");
+    }
+};
+
+pub fn HTMLCollectionByAnchors(root: ?*parser.Node, opts: Opts) HTMLCollection {
+    return .{
+        .root = root,
+        .walker = .{ .walkerDepthFirst = .{} },
+        .matcher = .{ .matchByAnchors = .{} },
+        .mutable = opts.mutable,
+        .include_root = opts.include_root,
+    };
+}
+
+pub const HTMLCollectionIterator = struct {
+    coll: *HTMLCollection,
+    index: u32 = 0,
+
+    pub const Return = struct {
+        value: ?Union,
+        done: bool,
+    };
+
+    pub fn _next(self: *HTMLCollectionIterator) !Return {
+        const e = try self.coll._item(self.index);
+        if (e == null) {
+            return Return{
+                .value = null,
+                .done = true,
+            };
+        }
+
+        self.index += 1;
+        return Return{
+            .value = e,
+            .done = false,
+        };
+    }
+};
+
+const Opts = struct {
+    include_root: bool,
+    mutable: bool = false,
+};
+
+// WEB IDL https://dom.spec.whatwg.org/#htmlcollection
+// HTMLCollection is re implemented in zig here because libdom
+// dom_html_collection expects a comparison function callback as argument.
+// But we wanted a dynamically comparison here, according to the match tagname.
+pub const HTMLCollection = struct {
+    matcher: Matcher,
+    walker: Walker,
+
+    root: ?*parser.Node,
+
+    // By default the HTMLCollection walk on the root's descendant only.
+    // But on somes cases, like for dom document, we want to walk over the root
+    // itself.
+    include_root: bool = false,
+
+    mutable: bool = false,
+
+    // save a state for the collection to improve the _item speed.
+    cur_idx: ?u32 = null,
+    cur_node: ?*parser.Node = null,
+
+    // start returns the first node to walk on.
+    fn start(self: *const HTMLCollection) !?*parser.Node {
+        if (self.root == null) return null;
+
+        if (self.include_root) {
+            return self.root.?;
+        }
+
+        return try self.walker.get_next(self.root.?, null);
+    }
+
+    pub fn _symbol_iterator(self: *HTMLCollection) HTMLCollectionIterator {
+        return HTMLCollectionIterator{
+            .coll = self,
+        };
+    }
+
+    /// get_length computes the collection's length dynamically according to
+    /// the current root structure.
+    // TODO: nodes retrieved must be de-referenced.
+    pub fn get_length(self: *HTMLCollection) !u32 {
+        if (self.root == null) return 0;
+
+        var len: u32 = 0;
+        var node = try self.start() orelse return 0;
+
+        while (true) {
+            if (parser.nodeType(node) == .element) {
+                if (try self.matcher.match(node)) {
+                    len += 1;
+                }
+            }
+
+            node = try self.walker.get_next(self.root.?, node) orelse break;
+        }
+
+        return len;
+    }
+
+    pub fn item(self: *HTMLCollection, index: u32) !?*parser.Node {
+        if (self.root == null) return null;
+
+        var i: u32 = 0;
+        var node: *parser.Node = undefined;
+
+        // Use the current state to improve speed if possible.
+        if (self.mutable == false and self.cur_idx != null and index >= self.cur_idx.?) {
+            i = self.cur_idx.?;
+            node = self.cur_node.?;
+        } else {
+            node = try self.start() orelse return null;
+        }
+
+        while (true) {
+            if (parser.nodeType(node) == .element) {
+                if (try self.matcher.match(node)) {
+                    // check if we found the searched element.
+                    if (i == index) {
+                        // save the current state
+                        self.cur_node = node;
+                        self.cur_idx = i;
+
+                        return node;
+                    }
+
+                    i += 1;
+                }
+            }
+
+            node = try self.walker.get_next(self.root.?, node) orelse break;
+        }
+
+        return null;
+    }
+
+    pub fn _item(self: *HTMLCollection, index: u32) !?Union {
+        const node = try self.item(index) orelse return null;
+        const e = @as(*parser.Element, @ptrCast(node));
+        return try Element.toInterface(e);
+    }
+
+    pub fn _namedItem(self: *const HTMLCollection, name: []const u8) !?Union {
+        if (self.root == null) return null;
+        if (name.len == 0) return null;
+
+        var node = try self.start() orelse return null;
+
+        while (true) {
+            if (parser.nodeType(node) == .element) {
+                if (try self.matcher.match(node)) {
+                    const elem = @as(*parser.Element, @ptrCast(node));
+
+                    var attr = try parser.elementGetAttribute(elem, "id");
+                    // check if the node id corresponds to the name argument.
+                    if (attr != null and std.mem.eql(u8, name, attr.?)) {
+                        return try Element.toInterface(elem);
+                    }
+
+                    attr = try parser.elementGetAttribute(elem, "name");
+                    // check if the node id corresponds to the name argument.
+                    if (attr != null and std.mem.eql(u8, name, attr.?)) {
+                        return try Element.toInterface(elem);
+                    }
+                }
+            }
+
+            node = try self.walker.get_next(self.root.?, node) orelse break;
+        }
+
+        return null;
+    }
+
+    fn item_name(elt: *parser.Element) !?[]const u8 {
+        if (try parser.elementGetAttribute(elt, "id")) |v| {
+            return v;
+        }
+        if (try parser.elementGetAttribute(elt, "name")) |v| {
+            return v;
+        }
+
+        return null;
+    }
+
+    pub fn indexed_get(self: *HTMLCollection, index: u32, has_value: *bool) !?Union {
+        return (try _item(self, index)) orelse {
+            has_value.* = false;
+            return undefined;
+        };
+    }
+
+    pub fn named_get(self: *const HTMLCollection, name: []const u8, has_value: *bool) !?Union {
+        // Even though an entry might have an empty id, the spec says
+        // that namedItem("") should always return null
+        if (name.len == 0) {
+            return null;
+        }
+        return (try _namedItem(self, name)) orelse {
+            has_value.* = false;
+            return undefined;
+        };
+    }
+};
+
+const testing = @import("../../testing.zig");
+test "Browser: DOM.HTMLCollection" {
+    try testing.htmlRunner("dom/html_collection.html");
+}

src/browser/dom/implementation.zig

@@ -0,0 +1,56 @@
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const parser = @import("../netsurf.zig");
+const DOMException = @import("exceptions.zig").DOMException;
+
+// WEB IDL https://dom.spec.whatwg.org/#domimplementation
+pub const DOMImplementation = struct {
+    pub const Exception = DOMException;
+
+    pub fn _createDocumentType(
+        _: *DOMImplementation,
+        qname: [:0]const u8,
+        publicId: [:0]const u8,
+        systemId: [:0]const u8,
+    ) !*parser.DocumentType {
+        return try parser.domImplementationCreateDocumentType(qname, publicId, systemId);
+    }
+
+    pub fn _createDocument(
+        _: *DOMImplementation,
+        namespace: ?[:0]const u8,
+        qname: ?[:0]const u8,
+        doctype: ?*parser.DocumentType,
+    ) !*parser.Document {
+        return try parser.domImplementationCreateDocument(namespace, qname, doctype);
+    }
+
+    pub fn _createHTMLDocument(_: *DOMImplementation, title: ?[]const u8) !*parser.DocumentHTML {
+        return try parser.domImplementationCreateHTMLDocument(title);
+    }
+
+    pub fn _hasFeature(_: *DOMImplementation) bool {
+        return true;
+    }
+};
+
+const testing = @import("../../testing.zig");
+test "Browser: DOM.Implementation" {
+    try testing.htmlRunner("dom/implementation.html");
+}

src/browser/dom/mutation_observer.zig

@@ -0,0 +1,407 @@
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const std = @import("std");
+
+const js = @import("../js/js.zig");
+const log = @import("../../log.zig");
+const parser = @import("../netsurf.zig");
+const Page = @import("../page.zig").Page;
+
+const NodeList = @import("nodelist.zig").NodeList;
+
+pub const Interfaces = .{
+    MutationObserver,
+    MutationRecord,
+};
+
+const Walker = @import("../dom/walker.zig").WalkerChildren;
+
+// WEB IDL https://dom.spec.whatwg.org/#interface-mutationobserver
+pub const MutationObserver = struct {
+    page: *Page,
+    cbk: js.Function,
+    scheduled: bool,
+    observers: std.ArrayListUnmanaged(*Observer),
+
+    // List of records which were observed. When the call scope ends, we need to
+    // execute our callback with it.
+    observed: std.ArrayListUnmanaged(MutationRecord),
+
+    pub fn constructor(cbk: js.Function, page: *Page) !MutationObserver {
+        return .{
+            .cbk = cbk,
+            .page = page,
+            .observed = .{},
+            .scheduled = false,
+            .observers = .empty,
+        };
+    }
+
+    pub fn _observe(self: *MutationObserver, node: *parser.Node, options_: ?Options) !void {
+        const arena = self.page.arena;
+        var options = options_ orelse Options{};
+        if (options.attributeFilter.len > 0) {
+            options.attributeFilter = try arena.dupe([]const u8, options.attributeFilter);
+        }
+
+        const observer = try arena.create(Observer);
+        observer.* = .{
+            .node = node,
+            .options = options,
+            .mutation_observer = self,
+            .event_node = .{ .id = self.cbk.id, .func = Observer.handle },
+        };
+
+        try self.observers.append(arena, observer);
+
+        // register node's events
+        if (options.childList or options.subtree) {
+            observer.dom_node_inserted_listener = try parser.eventTargetAddEventListener(
+                parser.toEventTarget(parser.Node, node),
+                "DOMNodeInserted",
+                &observer.event_node,
+                false,
+            );
+            observer.dom_node_removed_listener = try parser.eventTargetAddEventListener(
+                parser.toEventTarget(parser.Node, node),
+                "DOMNodeRemoved",
+                &observer.event_node,
+                false,
+            );
+        }
+        if (options.attr()) {
+            observer.dom_node_attribute_modified_listener = try parser.eventTargetAddEventListener(
+                parser.toEventTarget(parser.Node, node),
+                "DOMAttrModified",
+                &observer.event_node,
+                false,
+            );
+        }
+        if (options.cdata()) {
+            observer.dom_cdata_modified_listener = try parser.eventTargetAddEventListener(
+                parser.toEventTarget(parser.Node, node),
+                "DOMCharacterDataModified",
+                &observer.event_node,
+                false,
+            );
+        }
+        if (options.subtree) {
+            observer.dom_subtree_modified_listener = try parser.eventTargetAddEventListener(
+                parser.toEventTarget(parser.Node, node),
+                "DOMSubtreeModified",
+                &observer.event_node,
+                false,
+            );
+        }
+    }
+
+    fn callback(ctx: *anyopaque) ?u32 {
+        const self: *MutationObserver = @ptrCast(@alignCast(ctx));
+        self.scheduled = false;
+
+        const records = self.observed.items;
+        if (records.len == 0) {
+            return null;
+        }
+
+        defer self.observed.clearRetainingCapacity();
+
+        var result: js.Function.Result = undefined;
+        self.cbk.tryCallWithThis(void, self, .{records}, &result) catch {
+            log.debug(.user_script, "callback error", .{
+                .err = result.exception,
+                .stack = result.stack,
+                .source = "mutation observer",
+            });
+        };
+        return null;
+    }
+
+    pub fn _disconnect(self: *MutationObserver) !void {
+        for (self.observers.items) |observer| {
+            const event_target = parser.toEventTarget(parser.Node, observer.node);
+            if (observer.dom_node_inserted_listener) |listener| {
+                try parser.eventTargetRemoveEventListener(
+                    event_target,
+                    "DOMNodeInserted",
+                    listener,
+                    false,
+                );
+            }
+
+            if (observer.dom_node_removed_listener) |listener| {
+                try parser.eventTargetRemoveEventListener(
+                    event_target,
+                    "DOMNodeRemoved",
+                    listener,
+                    false,
+                );
+            }
+
+            if (observer.dom_node_attribute_modified_listener) |listener| {
+                try parser.eventTargetRemoveEventListener(
+                    event_target,
+                    "DOMAttrModified",
+                    listener,
+                    false,
+                );
+            }
+
+            if (observer.dom_cdata_modified_listener) |listener| {
+                try parser.eventTargetRemoveEventListener(
+                    event_target,
+                    "DOMCharacterDataModified",
+                    listener,
+                    false,
+                );
+            }
+
+            if (observer.dom_subtree_modified_listener) |listener| {
+                try parser.eventTargetRemoveEventListener(
+                    event_target,
+                    "DOMSubtreeModified",
+                    listener,
+                    false,
+                );
+            }
+        }
+        self.observers.clearRetainingCapacity();
+    }
+
+    // TODO
+    pub fn _takeRecords(_: *const MutationObserver) ?[]const u8 {
+        return &[_]u8{};
+    }
+};
+
+pub const MutationRecord = struct {
+    type: []const u8,
+    target: *parser.Node,
+    added_nodes: NodeList = .{},
+    removed_nodes: NodeList = .{},
+    previous_sibling: ?*parser.Node = null,
+    next_sibling: ?*parser.Node = null,
+    attribute_name: ?[]const u8 = null,
+    attribute_namespace: ?[]const u8 = null,
+    old_value: ?[]const u8 = null,
+
+    pub fn get_type(self: *const MutationRecord) []const u8 {
+        return self.type;
+    }
+
+    pub fn get_addedNodes(self: *MutationRecord) *NodeList {
+        return &self.added_nodes;
+    }
+
+    pub fn get_removedNodes(self: *MutationRecord) *NodeList {
+        return &self.removed_nodes;
+    }
+
+    pub fn get_target(self: *const MutationRecord) *parser.Node {
+        return self.target;
+    }
+
+    pub fn get_attributeName(self: *const MutationRecord) ?[]const u8 {
+        return self.attribute_name;
+    }
+
+    pub fn get_attributeNamespace(self: *const MutationRecord) ?[]const u8 {
+        return self.attribute_namespace;
+    }
+
+    pub fn get_previousSibling(self: *const MutationRecord) ?*parser.Node {
+        return self.previous_sibling;
+    }
+
+    pub fn get_nextSibling(self: *const MutationRecord) ?*parser.Node {
+        return self.next_sibling;
+    }
+
+    pub fn get_oldValue(self: *const MutationRecord) ?[]const u8 {
+        return self.old_value;
+    }
+};
+
+const Options = struct {
+    childList: bool = false,
+    attributes: bool = false,
+    characterData: bool = false,
+    subtree: bool = false,
+    attributeOldValue: bool = false,
+    characterDataOldValue: bool = false,
+    attributeFilter: [][]const u8 = &.{},
+
+    fn attr(self: Options) bool {
+        return self.attributes or self.attributeOldValue or self.attributeFilter.len > 0;
+    }
+
+    fn cdata(self: Options) bool {
+        return self.characterData or self.characterDataOldValue;
+    }
+};
+
+const Observer = struct {
+    node: *parser.Node,
+    options: Options,
+
+    // reference back to the MutationObserver so that we can access the arena
+    // and batch the mutation records.
+    mutation_observer: *MutationObserver,
+
+    event_node: parser.EventNode,
+
+    dom_node_inserted_listener: ?*parser.EventListener = null,
+    dom_node_removed_listener: ?*parser.EventListener = null,
+    dom_node_attribute_modified_listener: ?*parser.EventListener = null,
+    dom_cdata_modified_listener: ?*parser.EventListener = null,
+    dom_subtree_modified_listener: ?*parser.EventListener = null,
+
+    fn appliesTo(
+        self: *const Observer,
+        target: *parser.Node,
+        event_type: MutationEventType,
+        event: *parser.MutationEvent,
+    ) !bool {
+        if (event_type == .DOMAttrModified and self.options.attributeFilter.len > 0) {
+            const attribute_name = try parser.mutationEventAttributeName(event);
+            for (self.options.attributeFilter) |needle| blk: {
+                if (std.mem.eql(u8, attribute_name, needle)) {
+                    break :blk;
+                }
+            }
+            return false;
+        }
+
+        // mutation on any target is always ok.
+        if (self.options.subtree) {
+            return true;
+        }
+
+        // if target equals node, alway ok.
+        if (target == self.node) {
+            return true;
+        }
+
+        // no subtree, no same target and no childlist, always noky.
+        if (!self.options.childList) {
+            return false;
+        }
+
+        // target must be a child of o.node
+        const walker = Walker{};
+        var next: ?*parser.Node = null;
+        while (true) {
+            next = walker.get_next(self.node, next) catch break orelse break;
+            if (next.? == target) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    fn handle(en: *parser.EventNode, event: *parser.Event) void {
+        const self: *Observer = @fieldParentPtr("event_node", en);
+        self._handle(event) catch |err| {
+            log.err(.web_api, "handle error", .{ .err = err, .source = "mutation observer" });
+        };
+    }
+
+    fn _handle(self: *Observer, event: *parser.Event) !void {
+        var mutation_observer = self.mutation_observer;
+
+        const node = blk: {
+            const event_target = parser.eventTarget(event) orelse return;
+            break :blk parser.eventTargetToNode(event_target);
+        };
+
+        const mutation_event = parser.eventToMutationEvent(event);
+        const event_type = blk: {
+            const t = parser.eventType(event);
+            break :blk std.meta.stringToEnum(MutationEventType, t) orelse return;
+        };
+
+        if (try self.appliesTo(node, event_type, mutation_event) == false) {
+            return;
+        }
+
+        var record = MutationRecord{
+            .target = self.node,
+            .type = event_type.recordType(),
+        };
+
+        const arena = mutation_observer.page.arena;
+        switch (event_type) {
+            .DOMAttrModified => {
+                record.attribute_name = parser.mutationEventAttributeName(mutation_event) catch null;
+                if (self.options.attributeOldValue) {
+                    record.old_value = parser.mutationEventPrevValue(mutation_event);
+                }
+            },
+            .DOMCharacterDataModified => {
+                if (self.options.characterDataOldValue) {
+                    record.old_value = parser.mutationEventPrevValue(mutation_event);
+                }
+            },
+            .DOMNodeInserted => {
+                if (parser.mutationEventRelatedNode(mutation_event) catch null) |related_node| {
+                    try record.added_nodes.append(arena, related_node);
+                }
+            },
+            .DOMNodeRemoved => {
+                if (parser.mutationEventRelatedNode(mutation_event) catch null) |related_node| {
+                    try record.removed_nodes.append(arena, related_node);
+                }
+            },
+        }
+
+        try mutation_observer.observed.append(arena, record);
+
+        if (mutation_observer.scheduled == false) {
+            mutation_observer.scheduled = true;
+            try mutation_observer.page.scheduler.add(
+                mutation_observer,
+                MutationObserver.callback,
+                0,
+                .{ .name = "mutation_observer" },
+            );
+        }
+    }
+};
+
+const MutationEventType = enum {
+    DOMAttrModified,
+    DOMCharacterDataModified,
+    DOMNodeInserted,
+    DOMNodeRemoved,
+
+    fn recordType(self: MutationEventType) []const u8 {
+        return switch (self) {
+            .DOMAttrModified => "attributes",
+            .DOMCharacterDataModified => "characterData",
+            .DOMNodeInserted => "childList",
+            .DOMNodeRemoved => "childList",
+        };
+    }
+};
+
+const testing = @import("../../testing.zig");
+test "Browser: DOM.MutationObserver" {
+    try testing.htmlRunner("dom/mutation_observer.html");
+}

src/browser/dom/namednodemap.zig

@@ -0,0 +1,121 @@
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const parser = @import("../netsurf.zig");
+
+const DOMException = @import("exceptions.zig").DOMException;
+
+// WEB IDL https://dom.spec.whatwg.org/#namednodemap
+pub const NamedNodeMap = struct {
+    pub const Self = parser.NamedNodeMap;
+
+    pub const Exception = DOMException;
+    pub const Iterator = NamedNodeMapIterator;
+
+    // TODO implement LegacyUnenumerableNamedProperties.
+    // https://webidl.spec.whatwg.org/#LegacyUnenumerableNamedProperties
+
+    pub fn get_length(self: *parser.NamedNodeMap) !u32 {
+        return try parser.namedNodeMapGetLength(self);
+    }
+
+    pub fn _item(self: *parser.NamedNodeMap, index: u32) !?*parser.Attribute {
+        return try parser.namedNodeMapItem(self, index);
+    }
+
+    pub fn _getNamedItem(self: *parser.NamedNodeMap, qname: []const u8) !?*parser.Attribute {
+        return try parser.namedNodeMapGetNamedItem(self, qname);
+    }
+
+    pub fn _getNamedItemNS(
+        self: *parser.NamedNodeMap,
+        namespace: []const u8,
+        localname: []const u8,
+    ) !?*parser.Attribute {
+        return try parser.namedNodeMapGetNamedItemNS(self, namespace, localname);
+    }
+
+    pub fn _setNamedItem(self: *parser.NamedNodeMap, attr: *parser.Attribute) !?*parser.Attribute {
+        return try parser.namedNodeMapSetNamedItem(self, attr);
+    }
+
+    pub fn _setNamedItemNS(self: *parser.NamedNodeMap, attr: *parser.Attribute) !?*parser.Attribute {
+        return try parser.namedNodeMapSetNamedItemNS(self, attr);
+    }
+
+    pub fn _removeNamedItem(self: *parser.NamedNodeMap, qname: []const u8) !*parser.Attribute {
+        return try parser.namedNodeMapRemoveNamedItem(self, qname);
+    }
+
+    pub fn _removeNamedItemNS(
+        self: *parser.NamedNodeMap,
+        namespace: []const u8,
+        localname: []const u8,
+    ) !*parser.Attribute {
+        return try parser.namedNodeMapRemoveNamedItemNS(self, namespace, localname);
+    }
+
+    pub fn indexed_get(self: *parser.NamedNodeMap, index: u32, has_value: *bool) !*parser.Attribute {
+        return (try _item(self, index)) orelse {
+            has_value.* = false;
+            return undefined;
+        };
+    }
+
+    pub fn named_get(self: *parser.NamedNodeMap, name: []const u8, has_value: *bool) !*parser.Attribute {
+        return (try _getNamedItem(self, name)) orelse {
+            has_value.* = false;
+            return undefined;
+        };
+    }
+
+    pub fn _symbol_iterator(self: *parser.NamedNodeMap) NamedNodeMapIterator {
+        return .{ .map = self };
+    }
+};
+
+pub const NamedNodeMapIterator = struct {
+    index: u32 = 0,
+    map: *parser.NamedNodeMap,
+
+    pub const Return = struct {
+        done: bool,
+        value: ?*parser.Attribute,
+    };
+
+    pub fn _next(self: *NamedNodeMapIterator) !Return {
+        const e = try NamedNodeMap._item(self.map, self.index);
+        if (e == null) {
+            return .{
+                .value = null,
+                .done = true,
+            };
+        }
+
+        self.index += 1;
+        return .{
+            .value = e,
+            .done = false,
+        };
+    }
+};
+
+const testing = @import("../../testing.zig");
+test "Browser: DOM.NamedNodeMap" {
+    try testing.htmlRunner("dom/named_node_map.html");
+}

src/browser/dom/node.zig

@@ -0,0 +1,665 @@
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const std = @import("std");
+
+const log = @import("../../log.zig");
+const parser = @import("../netsurf.zig");
+const generate = @import("../js/generate.zig");
+
+const Page = @import("../page.zig").Page;
+const EventTarget = @import("event_target.zig").EventTarget;
+
+// DOM
+const Attr = @import("attribute.zig").Attr;
+const CData = @import("character_data.zig");
+const Element = @import("element.zig").Element;
+const ElementUnion = @import("element.zig").Union;
+const NodeList = @import("nodelist.zig").NodeList;
+const Document = @import("document.zig").Document;
+const DocumentType = @import("document_type.zig").DocumentType;
+const DocumentFragment = @import("document_fragment.zig").DocumentFragment;
+const HTMLCollection = @import("html_collection.zig").HTMLCollection;
+const HTMLAllCollection = @import("html_collection.zig").HTMLAllCollection;
+const HTMLCollectionIterator = @import("html_collection.zig").HTMLCollectionIterator;
+const ShadowRoot = @import("shadow_root.zig").ShadowRoot;
+const Walker = @import("walker.zig").WalkerDepthFirst;
+
+// HTML
+const HTML = @import("../html/html.zig");
+
+// Node interfaces
+pub const Interfaces = .{
+    Attr,
+    CData.CharacterData,
+    CData.Interfaces,
+    Element,
+    Document,
+    DocumentType,
+    DocumentFragment,
+    HTMLCollection,
+    HTMLAllCollection,
+    HTMLCollectionIterator,
+    HTML.Interfaces,
+};
+
+pub const Union = generate.Union(Interfaces);
+
+// Node implementation
+pub const Node = struct {
+    pub const Self = parser.Node;
+    pub const prototype = *EventTarget;
+    pub const subtype = .node;
+
+    pub fn toInterface(node: *parser.Node) !Union {
+        return switch (parser.nodeType(node)) {
+            .element => try Element.toInterfaceT(
+                Union,
+                @as(*parser.Element, @ptrCast(node)),
+            ),
+            .comment => .{ .Comment = @as(*parser.Comment, @ptrCast(node)) },
+            .text => .{ .Text = @as(*parser.Text, @ptrCast(node)) },
+            .cdata_section => .{ .CDATASection = @as(*parser.CDATASection, @ptrCast(node)) },
+            .processing_instruction => .{ .ProcessingInstruction = @as(*parser.ProcessingInstruction, @ptrCast(node)) },
+            .document => blk: {
+                const doc: *parser.Document = @ptrCast(node);
+                if (doc.is_html) {
+                    break :blk .{ .HTMLDocument = @as(*parser.DocumentHTML, @ptrCast(node)) };
+                }
+
+                break :blk .{ .Document = doc };
+            },
+            .document_type => .{ .DocumentType = @as(*parser.DocumentType, @ptrCast(node)) },
+            .attribute => .{ .Attr = @as(*parser.Attribute, @ptrCast(node)) },
+            .document_fragment => .{ .DocumentFragment = @as(*parser.DocumentFragment, @ptrCast(node)) },
+            else => @panic("node type not handled"), // TODO
+        };
+    }
+
+    // class attributes
+
+    pub const _ELEMENT_NODE = @intFromEnum(parser.NodeType.element);
+    pub const _ATTRIBUTE_NODE = @intFromEnum(parser.NodeType.attribute);
+    pub const _TEXT_NODE = @intFromEnum(parser.NodeType.text);
+    pub const _CDATA_SECTION_NODE = @intFromEnum(parser.NodeType.cdata_section);
+    pub const _PROCESSING_INSTRUCTION_NODE = @intFromEnum(parser.NodeType.processing_instruction);
+    pub const _COMMENT_NODE = @intFromEnum(parser.NodeType.comment);
+    pub const _DOCUMENT_NODE = @intFromEnum(parser.NodeType.document);
+    pub const _DOCUMENT_TYPE_NODE = @intFromEnum(parser.NodeType.document_type);
+    pub const _DOCUMENT_FRAGMENT_NODE = @intFromEnum(parser.NodeType.document_fragment);
+
+    // These 3 are deprecated, but both Chrome and Firefox still expose them
+    pub const _ENTITY_REFERENCE_NODE = @intFromEnum(parser.NodeType.entity_reference);
+    pub const _ENTITY_NODE = @intFromEnum(parser.NodeType.entity);
+    pub const _NOTATION_NODE = @intFromEnum(parser.NodeType.notation);
+
+    pub const _DOCUMENT_POSITION_DISCONNECTED = @intFromEnum(parser.DocumentPosition.disconnected);
+    pub const _DOCUMENT_POSITION_PRECEDING = @intFromEnum(parser.DocumentPosition.preceding);
+    pub const _DOCUMENT_POSITION_FOLLOWING = @intFromEnum(parser.DocumentPosition.following);
+    pub const _DOCUMENT_POSITION_CONTAINS = @intFromEnum(parser.DocumentPosition.contains);
+    pub const _DOCUMENT_POSITION_CONTAINED_BY = @intFromEnum(parser.DocumentPosition.contained_by);
+    pub const _DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = @intFromEnum(parser.DocumentPosition.implementation_specific);
+
+    // JS funcs
+    // --------
+
+    // Read-only attributes
+    pub fn get_baseURI(_: *parser.Node, page: *Page) ![]const u8 {
+        return page.url.raw;
+    }
+
+    pub fn get_firstChild(self: *parser.Node) !?Union {
+        const res = parser.nodeFirstChild(self);
+        if (res == null) {
+            return null;
+        }
+        return try Node.toInterface(res.?);
+    }
+
+    pub fn get_lastChild(self: *parser.Node) !?Union {
+        const res = parser.nodeLastChild(self);
+        if (res == null) {
+            return null;
+        }
+        return try Node.toInterface(res.?);
+    }
+
+    pub fn get_nextSibling(self: *parser.Node) !?Union {
+        const res = parser.nodeNextSibling(self);
+        if (res == null) {
+            return null;
+        }
+        return try Node.toInterface(res.?);
+    }
+
+    pub fn get_previousSibling(self: *parser.Node) !?Union {
+        const res = parser.nodePreviousSibling(self);
+        if (res == null) {
+            return null;
+        }
+        return try Node.toInterface(res.?);
+    }
+
+    pub fn get_parentNode(self: *parser.Node) !?Union {
+        const res = parser.nodeParentNode(self);
+        if (res == null) {
+            return null;
+        }
+        return try Node.toInterface(res.?);
+    }
+
+    pub fn get_parentElement(self: *parser.Node) !?ElementUnion {
+        const res = parser.nodeParentElement(self);
+        if (res == null) {
+            return null;
+        }
+        return try Element.toInterface(res.?);
+    }
+
+    pub fn get_nodeName(self: *parser.Node) ![]const u8 {
+        return try parser.nodeName(self);
+    }
+
+    pub fn get_nodeType(self: *parser.Node) !u8 {
+        return @intFromEnum(parser.nodeType(self));
+    }
+
+    pub fn get_ownerDocument(self: *parser.Node) !?*parser.DocumentHTML {
+        const res = parser.nodeOwnerDocument(self);
+        if (res == null) {
+            return null;
+        }
+        return @as(*parser.DocumentHTML, @ptrCast(res.?));
+    }
+
+    pub fn get_isConnected(self: *parser.Node) !bool {
+        var node = self;
+        while (true) {
+            const node_type = parser.nodeType(node);
+            if (node_type == .document) {
+                return true;
+            }
+
+            if (parser.nodeParentNode(node)) |parent| {
+                // didn't find a document, but node has a parent, let's see
+                // if it's connected;
+                node = parent;
+                continue;
+            }
+
+            if (node_type != .document_fragment) {
+                // doesn't have a parent and isn't a document_fragment
+                // can't be connected
+                return false;
+            }
+
+            if (parser.documentFragmentGetHost(@ptrCast(node))) |host| {
+                // node doesn't have a parent, but it's a document fragment
+                // with a host. The host is like the parent, but we only want to
+                // traverse up (or down) to it in specific cases, like isConnected.
+                node = host;
+                continue;
+            }
+            return false;
+        }
+    }
+
+    // Read/Write attributes
+
+    pub fn get_nodeValue(self: *parser.Node) !?[]const u8 {
+        return parser.nodeValue(self);
+    }
+
+    pub fn set_nodeValue(self: *parser.Node, data: []u8) !void {
+        try parser.nodeSetValue(self, data);
+    }
+
+    pub fn get_textContent(self: *parser.Node) ?[]const u8 {
+        return parser.nodeTextContent(self);
+    }
+
+    pub fn set_textContent(self: *parser.Node, data: []u8) !void {
+        return try parser.nodeSetTextContent(self, data);
+    }
+
+    // Methods
+
+    pub fn _appendChild(self: *parser.Node, child: *parser.Node) !Union {
+        const self_owner = parser.nodeOwnerDocument(self);
+        const child_owner = parser.nodeOwnerDocument(child);
+
+        // If the node to be inserted has a different ownerDocument than the parent node,
+        // modern browsers automatically adopt the node and its descendants into
+        // the parent's ownerDocument.
+        // This process is known as adoption.
+        // (7.1) https://dom.spec.whatwg.org/#concept-node-insert
+        if (child_owner == null or (self_owner != null and child_owner.? != self_owner.?)) {
+            const w = Walker{};
+            var current = child;
+            while (true) {
+                current.owner = self_owner;
+                current = try w.get_next(child, current) orelse break;
+            }
+        }
+
+        // TODO: DocumentFragment special case
+        const res = try parser.nodeAppendChild(self, child);
+        return try Node.toInterface(res);
+    }
+
+    pub fn _cloneNode(self: *parser.Node, deep: ?bool) !Union {
+        const clone = try parser.nodeCloneNode(self, deep orelse false);
+        return try Node.toInterface(clone);
+    }
+
+    pub fn _compareDocumentPosition(self: *parser.Node, other: *parser.Node) !u32 {
+        if (self == other) {
+            return 0;
+        }
+
+        const docself = parser.nodeOwnerDocument(self) orelse blk: {
+            if (parser.nodeType(self) == .document) {
+                break :blk @as(*parser.Document, @ptrCast(self));
+            }
+            break :blk null;
+        };
+        const docother = parser.nodeOwnerDocument(other) orelse blk: {
+            if (parser.nodeType(other) == .document) {
+                break :blk @as(*parser.Document, @ptrCast(other));
+            }
+            break :blk null;
+        };
+
+        // Both are in different document.
+        if (docself == null or docother == null or docself.? != docother.?) {
+            return @intFromEnum(parser.DocumentPosition.disconnected) +
+                @intFromEnum(parser.DocumentPosition.implementation_specific) +
+                @intFromEnum(parser.DocumentPosition.preceding);
+        }
+
+        if (@intFromPtr(self) == @intFromPtr(docself.?)) {
+            // if self is the document, and we already know other is in the
+            // document, then other is contained by and following self.
+            return @intFromEnum(parser.DocumentPosition.following) +
+                @intFromEnum(parser.DocumentPosition.contained_by);
+        }
+
+        const rootself = parser.nodeGetRootNode(self);
+        const rootother = parser.nodeGetRootNode(other);
+        if (rootself != rootother) {
+            return @intFromEnum(parser.DocumentPosition.disconnected) +
+                @intFromEnum(parser.DocumentPosition.implementation_specific) +
+                @intFromEnum(parser.DocumentPosition.preceding);
+        }
+
+        // TODO Both are in a different trees in the same document.
+
+        const w = Walker{};
+        var next: ?*parser.Node = null;
+
+        // Is other a descendant of self?
+        while (true) {
+            next = try w.get_next(self, next) orelse break;
+            if (other == next) {
+                return @intFromEnum(parser.DocumentPosition.following) +
+                    @intFromEnum(parser.DocumentPosition.contained_by);
+            }
+        }
+
+        // Is self a descendant of other?
+        next = null;
+        while (true) {
+            next = try w.get_next(other, next) orelse break;
+            if (self == next) {
+                return @intFromEnum(parser.DocumentPosition.contains) +
+                    @intFromEnum(parser.DocumentPosition.preceding);
+            }
+        }
+
+        next = null;
+        while (true) {
+            next = try w.get_next(parser.documentToNode(docself.?), next) orelse break;
+            if (other == next) {
+                // other precedes self.
+                return @intFromEnum(parser.DocumentPosition.preceding);
+            }
+            if (self == next) {
+                // other follows self.
+                return @intFromEnum(parser.DocumentPosition.following);
+            }
+        }
+
+        return 0;
+    }
+
+    pub fn _contains(self: *parser.Node, other: *parser.Node) bool {
+        return parser.nodeContains(self, other);
+    }
+
+    // Returns itself or ancestor object inheriting from Node.
+    // - An Element inside a standard web page will return an HTMLDocument object representing the entire page (or <iframe>).
+    // - An Element inside a shadow DOM will return the associated ShadowRoot.
+    // - An Element that is not attached to a document or a shadow tree will return the root of the DOM tree it belongs to
+    const GetRootNodeResult = union(enum) {
+        shadow_root: *ShadowRoot,
+        node: Union,
+    };
+    pub fn _getRootNode(self: *parser.Node, options: ?struct { composed: bool = false }, page: *Page) !GetRootNodeResult {
+        const composed = if (options) |opts| opts.composed else false;
+
+        var current_root = parser.nodeGetRootNode(self);
+
+        while (true) {
+            const node_type = parser.nodeType(current_root);
+
+            if (node_type == .document_fragment) {
+                if (parser.documentFragmentGetHost(@ptrCast(current_root))) |host| {
+                    if (page.getNodeState(host)) |state| {
+                        if (state.shadow_root) |sr| {
+                            if (!composed) {
+                                return .{ .shadow_root = sr };
+                            }
+                            current_root = parser.nodeGetRootNode(@ptrCast(sr.host));
+                            continue;
+                        }
+                    }
+                }
+            }
+            break;
+        }
+
+        return .{ .node = try Node.toInterface(current_root) };
+    }
+
+    pub fn _hasChildNodes(self: *parser.Node) bool {
+        return parser.nodeHasChildNodes(self);
+    }
+
+    fn is_template(self: *parser.Node) !bool {
+        if (parser.nodeType(self) != .element) {
+            return false;
+        }
+
+        const e = parser.nodeToElement(self);
+        return try parser.elementTag(e) == .template;
+    }
+
+    pub fn get_childNodes(self: *parser.Node, page: *Page) !NodeList {
+        // special case for template:
+        // > The Node.childNodes property of the <template> element is always empty
+        // https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Elements/template#usage_notes
+        if (try is_template(self)) {
+            return .{};
+        }
+
+        const allocator = page.arena;
+        var list: NodeList = .{};
+
+        var n = parser.nodeFirstChild(self) orelse return list;
+        while (true) {
+            try list.append(allocator, n);
+            n = parser.nodeNextSibling(n) orelse return list;
+        }
+    }
+
+    pub fn _insertBefore(self: *parser.Node, new_node: *parser.Node, ref_node_: ?*parser.Node) !Union {
+        if (ref_node_ == null) {
+            return _appendChild(self, new_node);
+        }
+
+        const self_owner = parser.nodeOwnerDocument(self);
+        const new_node_owner = parser.nodeOwnerDocument(new_node);
+
+        // If the node to be inserted has a different ownerDocument than the parent node,
+        // modern browsers automatically adopt the node and its descendants into
+        // the parent's ownerDocument.
+        // This process is known as adoption.
+        // (7.1) https://dom.spec.whatwg.org/#concept-node-insert
+        if (new_node_owner == null or (self_owner != null and new_node_owner.? != self_owner.?)) {
+            const w = Walker{};
+            var current = new_node;
+            while (true) {
+                current.owner = self_owner;
+                current = try w.get_next(new_node, current) orelse break;
+            }
+        }
+
+        return Node.toInterface(try parser.nodeInsertBefore(self, new_node, ref_node_.?));
+    }
+
+    pub fn _isDefaultNamespace(self: *parser.Node, namespace: ?[]const u8) !bool {
+        return parser.nodeIsDefaultNamespace(self, namespace);
+    }
+
+    pub fn _isEqualNode(self: *parser.Node, other: *parser.Node) !bool {
+        // TODO: other is not an optional parameter, but can be null.
+        return try parser.nodeIsEqualNode(self, other);
+    }
+
+    pub fn _isSameNode(self: *parser.Node, other: *parser.Node) bool {
+        // TODO: other is not an optional parameter, but can be null.
+        // NOTE: there is no need to use isSameNode(); instead use the === strict equality operator
+        return parser.nodeIsSameNode(self, other);
+    }
+
+    pub fn _lookupPrefix(self: *parser.Node, namespace: ?[]const u8) !?[]const u8 {
+        // TODO: other is not an optional parameter, but can be null.
+        if (namespace == null) {
+            return null;
+        }
+        if (std.mem.eql(u8, namespace.?, "")) {
+            return null;
+        }
+        return try parser.nodeLookupPrefix(self, namespace.?);
+    }
+
+    pub fn _lookupNamespaceURI(self: *parser.Node, prefix: ?[]const u8) !?[]const u8 {
+        // TODO: other is not an optional parameter, but can be null.
+        return try parser.nodeLookupNamespaceURI(self, prefix);
+    }
+
+    pub fn _normalize(self: *parser.Node) !void {
+        return try parser.nodeNormalize(self);
+    }
+
+    pub fn _removeChild(self: *parser.Node, child: *parser.Node) !Union {
+        const res = try parser.nodeRemoveChild(self, child);
+        return try Node.toInterface(res);
+    }
+
+    pub fn _replaceChild(self: *parser.Node, new_child: *parser.Node, old_child: *parser.Node) !Union {
+        const res = try parser.nodeReplaceChild(self, new_child, old_child);
+        return try Node.toInterface(res);
+    }
+
+    // Check if the hierarchy node tree constraints are respected.
+    // For now, it checks only if new nodes are not self.
+    // TODO implements the others constraints.
+    // see https://dom.spec.whatwg.org/#concept-node-tree
+    pub fn hierarchy(self: *parser.Node, nodes: []const NodeOrText) bool {
+        for (nodes) |n| {
+            if (n.is(self)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    pub fn prepend(self: *parser.Node, nodes: []const NodeOrText) !void {
+        if (nodes.len == 0) {
+            return;
+        }
+
+        // check hierarchy
+        if (!hierarchy(self, nodes)) {
+            return parser.DOMError.HierarchyRequest;
+        }
+
+        const doc = (parser.nodeOwnerDocument(self)) orelse return;
+
+        if (parser.nodeFirstChild(self)) |first| {
+            for (nodes) |node| {
+                _ = try parser.nodeInsertBefore(self, try node.toNode(doc), first);
+            }
+            return;
+        }
+
+        for (nodes) |node| {
+            _ = try parser.nodeAppendChild(self, try node.toNode(doc));
+        }
+    }
+
+    pub fn append(self: *parser.Node, nodes: []const NodeOrText) !void {
+        if (nodes.len == 0) {
+            return;
+        }
+
+        // check hierarchy
+        if (!hierarchy(self, nodes)) {
+            return parser.DOMError.HierarchyRequest;
+        }
+
+        const doc = (parser.nodeOwnerDocument(self)) orelse return;
+        for (nodes) |node| {
+            _ = try parser.nodeAppendChild(self, try node.toNode(doc));
+        }
+    }
+
+    pub fn replaceChildren(self: *parser.Node, nodes: []const NodeOrText) !void {
+        if (nodes.len == 0) {
+            return;
+        }
+
+        // check hierarchy
+        if (!hierarchy(self, nodes)) {
+            return parser.DOMError.HierarchyRequest;
+        }
+
+        // remove existing children
+        try removeChildren(self);
+
+        const doc = (parser.nodeOwnerDocument(self)) orelse return;
+        // add new children
+        for (nodes) |node| {
+            _ = try parser.nodeAppendChild(self, try node.toNode(doc));
+        }
+    }
+
+    pub fn removeChildren(self: *parser.Node) !void {
+        if (!parser.nodeHasChildNodes(self)) return;
+
+        const children = try parser.nodeGetChildNodes(self);
+        const ln = parser.nodeListLength(children);
+        var i: u32 = 0;
+        while (i < ln) {
+            defer i += 1;
+            // we always retrieve the 0 index child on purpose: libdom nodelist
+            // are dynamic. So the next child to remove is always as pos 0.
+            const child = parser.nodeListItem(children, 0) orelse continue;
+            _ = try parser.nodeRemoveChild(self, child);
+        }
+    }
+
+    pub fn before(self: *parser.Node, nodes: []const NodeOrText) !void {
+        const parent = parser.nodeParentNode(self) orelse return;
+        const doc = (parser.nodeOwnerDocument(parent)) orelse return;
+
+        var sibling: ?*parser.Node = self;
+        // have to find the first sibling that isn't in nodes
+        CHECK: while (sibling) |s| {
+            for (nodes) |n| {
+                if (n.is(s)) {
+                    sibling = parser.nodePreviousSibling(s);
+                    continue :CHECK;
+                }
+            }
+            break;
+        }
+
+        if (sibling == null) {
+            sibling = parser.nodeFirstChild(parent);
+        }
+
+        if (sibling) |ref_node| {
+            for (nodes) |node| {
+                _ = try parser.nodeInsertBefore(parent, try node.toNode(doc), ref_node);
+            }
+            return;
+        }
+
+        return Node.prepend(self, nodes);
+    }
+
+    pub fn after(self: *parser.Node, nodes: []const NodeOrText) !void {
+        const parent = parser.nodeParentNode(self) orelse return;
+        const doc = (parser.nodeOwnerDocument(parent)) orelse return;
+
+        // have to find the first sibling that isn't in nodes
+        var sibling = parser.nodeNextSibling(self);
+        CHECK: while (sibling) |s| {
+            for (nodes) |n| {
+                if (n.is(s)) {
+                    sibling = parser.nodeNextSibling(s);
+                    continue :CHECK;
+                }
+            }
+            break;
+        }
+
+        if (sibling) |ref_node| {
+            for (nodes) |node| {
+                _ = try parser.nodeInsertBefore(parent, try node.toNode(doc), ref_node);
+            }
+            return;
+        }
+
+        for (nodes) |node| {
+            _ = try parser.nodeAppendChild(parent, try node.toNode(doc));
+        }
+    }
+
+    // A lot of functions take either a node or text input.
+    // The text input is to be converted into a Text node.
+    pub const NodeOrText = union(enum) {
+        text: []const u8,
+        node: *parser.Node,
+
+        fn toNode(self: NodeOrText, doc: *parser.Document) !*parser.Node {
+            return switch (self) {
+                .node => |n| n,
+                .text => |txt| @ptrCast(@alignCast(try parser.documentCreateTextNode(doc, txt))),
+            };
+        }
+
+        // Whether the node represented by the NodeOrText is the same as the
+        // given Node. Always false for text values as these represent as-of-yet
+        // created Text nodes.
+        fn is(self: NodeOrText, other: *parser.Node) bool {
+            return switch (self) {
+                .text => false,
+                .node => |n| n == other,
+            };
+        }
+    };
+};
+
+const testing = @import("../../testing.zig");
+test "Browser: DOM.Node" {
+    try testing.htmlRunner("dom/node.html");
+    try testing.htmlRunner("dom/node_owner.html");
+}

src/browser/dom/node_filter.zig

@@ -0,0 +1,83 @@
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const std = @import("std");
+const js = @import("../js/js.zig");
+const parser = @import("../netsurf.zig");
+const Node = @import("node.zig").Node;
+
+pub const NodeFilter = struct {
+    pub const _FILTER_ACCEPT: u16 = 1;
+    pub const _FILTER_REJECT: u16 = 2;
+    pub const _FILTER_SKIP: u16 = 3;
+
+    pub const _SHOW_ALL: u32 = std.math.maxInt(u32);
+    pub const _SHOW_ELEMENT: u32 = 0b1;
+    pub const _SHOW_ATTRIBUTE: u32 = 0b10;
+    pub const _SHOW_TEXT: u32 = 0b100;
+    pub const _SHOW_CDATA_SECTION: u32 = 0b1000;
+    pub const _SHOW_ENTITY_REFERENCE: u32 = 0b10000;
+    pub const _SHOW_ENTITY: u32 = 0b100000;
+    pub const _SHOW_PROCESSING_INSTRUCTION: u32 = 0b1000000;
+    pub const _SHOW_COMMENT: u32 = 0b10000000;
+    pub const _SHOW_DOCUMENT: u32 = 0b100000000;
+    pub const _SHOW_DOCUMENT_TYPE: u32 = 0b1000000000;
+    pub const _SHOW_DOCUMENT_FRAGMENT: u32 = 0b10000000000;
+    pub const _SHOW_NOTATION: u32 = 0b100000000000;
+};
+
+const VerifyResult = enum { accept, skip, reject };
+
+pub fn verify(what_to_show: u32, filter: ?js.Function, node: *parser.Node) !VerifyResult {
+    const node_type = parser.nodeType(node);
+
+    // Verify that we can show this node type.
+    // Per the DOM spec, what_to_show filters which nodes to return, but should
+    // still traverse children. So we return .skip (not .reject) when the node
+    // type doesn't match.
+    if (!switch (node_type) {
+        .attribute => what_to_show & NodeFilter._SHOW_ATTRIBUTE != 0,
+        .cdata_section => what_to_show & NodeFilter._SHOW_CDATA_SECTION != 0,
+        .comment => what_to_show & NodeFilter._SHOW_COMMENT != 0,
+        .document => what_to_show & NodeFilter._SHOW_DOCUMENT != 0,
+        .document_fragment => what_to_show & NodeFilter._SHOW_DOCUMENT_FRAGMENT != 0,
+        .document_type => what_to_show & NodeFilter._SHOW_DOCUMENT_TYPE != 0,
+        .element => what_to_show & NodeFilter._SHOW_ELEMENT != 0,
+        .entity => what_to_show & NodeFilter._SHOW_ENTITY != 0,
+        .entity_reference => what_to_show & NodeFilter._SHOW_ENTITY_REFERENCE != 0,
+        .notation => what_to_show & NodeFilter._SHOW_NOTATION != 0,
+        .processing_instruction => what_to_show & NodeFilter._SHOW_PROCESSING_INSTRUCTION != 0,
+        .text => what_to_show & NodeFilter._SHOW_TEXT != 0,
+    }) return .skip;
+
+    // Verify that we aren't filtering it out.
+    if (filter) |f| {
+        const acceptance = try f.call(u16, .{try Node.toInterface(node)});
+        return switch (acceptance) {
+            NodeFilter._FILTER_ACCEPT => .accept,
+            NodeFilter._FILTER_REJECT => .reject,
+            NodeFilter._FILTER_SKIP => .skip,
+            else => .reject,
+        };
+    } else return .accept;
+}
+
+const testing = @import("../../testing.zig");
+test "Browser: DOM.NodeFilter" {
+    try testing.htmlRunner("dom/node_filter.html");
+}

src/browser/dom/node_iterator.zig

@@ -0,0 +1,302 @@
+// Copyright (C) 2023-2025  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const std = @import("std");
+
+const js = @import("../js/js.zig");
+const parser = @import("../netsurf.zig");
+const NodeFilter = @import("node_filter.zig");
+const Node = @import("node.zig").Node;
+const NodeUnion = @import("node.zig").Union;
+const DOMException = @import("exceptions.zig").DOMException;
+
+// https://developer.mozilla.org/en-US/docs/Web/API/NodeIterator
+// While this is similar to TreeWalker it has its own implementation as there are several subtle differences
+// For example:
+// - nextNode returns the reference node, whereas TreeWalker returns the next node
+// - Skip and reject are equivalent for NodeIterator, for TreeWalker they are different
+pub const NodeIterator = struct {
+    pub const Exception = DOMException;
+
+    root: *parser.Node,
+    reference_node: *parser.Node,
+    what_to_show: u32,
+    filter: ?NodeIteratorOpts,
+    filter_func: ?js.Function,
+    pointer_before_current: bool = true,
+    // used to track / block recursive filters
+    is_in_callback: bool = false,
+
+    // One of the few cases where null and undefined resolve to different default.
+    // We need the raw JsObject so that we can probe the tri state:
+    // null, undefined or i32.
+    pub const WhatToShow = js.Object;
+
+    pub const NodeIteratorOpts = union(enum) {
+        function: js.Function,
+        object: struct { acceptNode: js.Function },
+    };
+
+    pub fn init(node: *parser.Node, what_to_show_: ?WhatToShow, filter: ?NodeIteratorOpts) !NodeIterator {
+        var filter_func: ?js.Function = null;
+        if (filter) |f| {
+            filter_func = switch (f) {
+                .function => |func| func,
+                .object => |o| o.acceptNode,
+            };
+        }
+
+        var what_to_show: u32 = undefined;
+        if (what_to_show_) |wts| {
+            switch (try wts.triState(NodeIterator, "what_to_show", u32)) {
+                .null => what_to_show = 0,
+                .undefined => what_to_show = NodeFilter.NodeFilter._SHOW_ALL,
+                .value => |v| what_to_show = v,
+            }
+        } else {
+            what_to_show = NodeFilter.NodeFilter._SHOW_ALL;
+        }
+
+        return .{
+            .root = node,
+            .filter = filter,
+            .reference_node = node,
+            .filter_func = filter_func,
+            .what_to_show = what_to_show,
+        };
+    }
+
+    pub fn get_filter(self: *const NodeIterator) ?NodeIteratorOpts {
+        return self.filter;
+    }
+
+    pub fn get_pointerBeforeReferenceNode(self: *const NodeIterator) bool {
+        return self.pointer_before_current;
+    }
+
+    pub fn get_referenceNode(self: *const NodeIterator) !NodeUnion {
+        return try Node.toInterface(self.reference_node);
+    }
+
+    pub fn get_root(self: *const NodeIterator) !NodeUnion {
+        return try Node.toInterface(self.root);
+    }
+
+    pub fn get_whatToShow(self: *const NodeIterator) u32 {
+        return self.what_to_show;
+    }
+
+    pub fn _nextNode(self: *NodeIterator) !?NodeUnion {
+        try self.callbackStart();
+        defer self.callbackEnd();
+
+        if (self.pointer_before_current) {
+            // Unlike TreeWalker, NodeIterator starts at the first node
+            if (.accept == try NodeFilter.verify(self.what_to_show, self.filter_func, self.reference_node)) {
+                self.pointer_before_current = false;
+                return try Node.toInterface(self.reference_node);
+            }
+        }
+
+        if (try self.firstChild(self.reference_node)) |child| {
+            self.reference_node = child;
+            self.pointer_before_current = false;
+            return try Node.toInterface(child);
+        }
+
+        var current = self.reference_node;
+        while (current != self.root) {
+            // Try to get next sibling (including .skip/.reject nodes we need to descend into)
+            if (try self.nextSiblingOrSkipReject(current)) |result| {
+                if (result.should_descend) {
+                    // This is a .skip/.reject node - try to find acceptable children within it
+                    if (try self.firstChild(result.node)) |child| {
+                        self.reference_node = child;
+                        return try Node.toInterface(child);
+                    }
+                    // No acceptable children, continue looking at this node's siblings
+                    current = result.node;
+                    continue;
+                }
+                // This is an .accept node - return it
+                self.reference_node = result.node;
+                return try Node.toInterface(result.node);
+            }
+
+            current = (parser.nodeParentNode(current)) orelse break;
+        }
+
+        return null;
+    }
+
+    pub fn _previousNode(self: *NodeIterator) !?NodeUnion {
+        try self.callbackStart();
+        defer self.callbackEnd();
+
+        if (!self.pointer_before_current) {
+            if (.accept == try NodeFilter.verify(self.what_to_show, self.filter_func, self.reference_node)) {
+                self.pointer_before_current = true;
+                // Still need to verify as last may be first as well
+                return try Node.toInterface(self.reference_node);
+            }
+        }
+        if (self.reference_node == self.root) {
+            return null;
+        }
+
+        var current = self.reference_node;
+        while (parser.nodePreviousSibling(current)) |previous| {
+            current = previous;
+
+            switch (try NodeFilter.verify(self.what_to_show, self.filter_func, current)) {
+                .accept => {
+                    // Get last child if it has one.
+                    if (try self.lastChild(current)) |child| {
+                        self.reference_node = child;
+                        return try Node.toInterface(child);
+                    }
+
+                    // Otherwise, this node is our previous one.
+                    self.reference_node = current;
+                    return try Node.toInterface(current);
+                },
+                .reject, .skip => {
+                    // Get last child if it has one.
+                    if (try self.lastChild(current)) |child| {
+                        self.reference_node = child;
+                        return try Node.toInterface(child);
+                    }
+                },
+            }
+        }
+
+        if (current != self.root) {
+            if (try self.parentNode(current)) |parent| {
+                self.reference_node = parent;
+                return try Node.toInterface(parent);
+            }
+        }
+
+        return null;
+    }
+
+    pub fn _detach(self: *const NodeIterator) void {
+        // no-op as per spec
+        _ = self;
+    }
+
+    fn firstChild(self: *const NodeIterator, node: *parser.Node) !?*parser.Node {
+        const children = try parser.nodeGetChildNodes(node);
+        const child_count = parser.nodeListLength(children);
+
+        for (0..child_count) |i| {
+            const index: u32 = @intCast(i);
+            const child = (parser.nodeListItem(children, index)) orelse return null;
+
+            switch (try NodeFilter.verify(self.what_to_show, self.filter_func, child)) {
+                .accept => return child, // NOTE: Skip and reject are equivalent for NodeIterator, this is different from TreeWalker
+                .reject, .skip => if (try self.firstChild(child)) |gchild| return gchild,
+            }
+        }
+
+        return null;
+    }
+
+    fn lastChild(self: *const NodeIterator, node: *parser.Node) !?*parser.Node {
+        const children = try parser.nodeGetChildNodes(node);
+        const child_count = parser.nodeListLength(children);
+
+        var index: u32 = child_count;
+        while (index > 0) {
+            index -= 1;
+            const child = (parser.nodeListItem(children, index)) orelse return null;
+
+            switch (try NodeFilter.verify(self.what_to_show, self.filter_func, child)) {
+                .accept => return child, // NOTE: Skip and reject are equivalent for NodeIterator, this is different from TreeWalker
+                .reject, .skip => if (try self.lastChild(child)) |gchild| return gchild,
+            }
+        }
+
+        return null;
+    }
+
+    // This implementation is actually the same as :TreeWalker
+    fn parentNode(self: *const NodeIterator, node: *parser.Node) !?*parser.Node {
+        if (self.root == node) return null;
+
+        var current = node;
+        while (true) {
+            if (current == self.root) return null;
+            current = (parser.nodeParentNode(current)) orelse return null;
+
+            switch (try NodeFilter.verify(self.what_to_show, self.filter_func, current)) {
+                .accept => return current,
+                .reject, .skip => continue,
+            }
+        }
+    }
+
+    // This implementation is actually the same as :TreeWalker
+    fn nextSibling(self: *const NodeIterator, node: *parser.Node) !?*parser.Node {
+        var current = node;
+
+        while (true) {
+            current = (parser.nodeNextSibling(current)) orelse return null;
+
+            switch (try NodeFilter.verify(self.what_to_show, self.filter_func, current)) {
+                .accept => return current,
+                .skip, .reject => continue,
+            }
+        }
+
+        return null;
+    }
+
+    // Get the next sibling that is either acceptable or should be descended into (skip/reject)
+    fn nextSiblingOrSkipReject(self: *const NodeIterator, node: *parser.Node) !?struct { node: *parser.Node, should_descend: bool } {
+        var current = node;
+
+        while (true) {
+            current = (parser.nodeNextSibling(current)) orelse return null;
+
+            switch (try NodeFilter.verify(self.what_to_show, self.filter_func, current)) {
+                .accept => return .{ .node = current, .should_descend = false },
+                .skip, .reject => return .{ .node = current, .should_descend = true },
+            }
+        }
+
+        return null;
+    }
+
+    fn callbackStart(self: *NodeIterator) !void {
+        if (self.is_in_callback) {
+            // this is the correct DOMExeption
+            return error.InvalidState;
+        }
+        self.is_in_callback = true;
+    }
+
+    fn callbackEnd(self: *NodeIterator) void {
+        self.is_in_callback = false;
+    }
+};
+
+const testing = @import("../../testing.zig");
+test "Browser: DOM.NodeIterator" {
+    try testing.htmlRunner("dom/node_iterator.html");
+}

src/browser/dom/nodelist.zig

@@ -0,0 +1,188 @@
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+
+const js = @import("../js/js.zig");
+const log = @import("../../log.zig");
+const parser = @import("../netsurf.zig");
+
+const NodeUnion = @import("node.zig").Union;
+const Node = @import("node.zig").Node;
+
+const U32Iterator = @import("../iterator/iterator.zig").U32Iterator;
+
+const DOMException = @import("exceptions.zig").DOMException;
+
+pub const Interfaces = .{
+    NodeListIterator,
+    NodeList,
+};
+
+pub const NodeListIterator = struct {
+    coll: *NodeList,
+    index: u32 = 0,
+
+    pub const Return = struct {
+        value: ?NodeUnion,
+        done: bool,
+    };
+
+    pub fn _next(self: *NodeListIterator) !Return {
+        const e = try self.coll._item(self.index);
+        if (e == null) {
+            return Return{
+                .value = null,
+                .done = true,
+            };
+        }
+
+        self.index += 1;
+        return Return{
+            .value = e,
+            .done = false,
+        };
+    }
+};
+
+pub const NodeListEntriesIterator = struct {
+    coll: *NodeList,
+    index: u32 = 0,
+
+    pub const Return = struct {
+        value: ?NodeUnion,
+        done: bool,
+    };
+
+    pub fn _next(self: *NodeListEntriesIterator) !Return {
+        const e = try self.coll._item(self.index);
+        if (e == null) {
+            return Return{
+                .value = null,
+                .done = true,
+            };
+        }
+
+        self.index += 1;
+        return Return{
+            .value = e,
+            .done = false,
+        };
+    }
+};
+
+// Nodelist is implemented in pure Zig b/c libdom's NodeList doesn't allow to
+// append nodes.
+// WEB IDL https://dom.spec.whatwg.org/#nodelist
+//
+// TODO: a Nodelist can be either static or live. But the current
+// implementation allows only static nodelist.
+// see https://dom.spec.whatwg.org/#old-style-collections
+pub const NodeList = struct {
+    pub const Exception = DOMException;
+    const NodesArrayList = std.ArrayListUnmanaged(*parser.Node);
+
+    nodes: NodesArrayList = .{},
+
+    pub fn deinit(self: *NodeList, allocator: Allocator) void {
+        self.nodes.deinit(allocator);
+    }
+
+    pub fn ensureTotalCapacity(self: *NodeList, allocator: Allocator, n: usize) !void {
+        return self.nodes.ensureTotalCapacity(allocator, n);
+    }
+
+    pub fn append(self: *NodeList, allocator: Allocator, node: *parser.Node) !void {
+        try self.nodes.append(allocator, node);
+    }
+
+    pub fn appendAssumeCapacity(self: *NodeList, node: *parser.Node) void {
+        self.nodes.appendAssumeCapacity(node);
+    }
+
+    pub fn get_length(self: *const NodeList) u32 {
+        return @intCast(self.nodes.items.len);
+    }
+
+    pub fn _item(self: *const NodeList, index: u32) !?NodeUnion {
+        if (index >= self.nodes.items.len) {
+            return null;
+        }
+
+        const n = self.nodes.items[index];
+        return try Node.toInterface(n);
+    }
+
+    // This code works, but it's _MUCH_ slower than using postAttach. The benefit
+    // of this version, is that it's "live"..but we're talking many orders of
+    // magnitude slower.
+    //
+    // You can test it by commenting out `postAttach`, uncommenting this and
+    // running:
+    //    zig build wpt --  tests/wpt/dom/nodes/NodeList-static-length-getter-tampered-indexOf-1.html
+    //
+    // I think this _is_ the right way to do it, but I must be doing something
+    // wrong to make it so slow.
+    // pub fn indexed_get(self: *const NodeList, index: u32, has_value: *bool) !?NodeUnion {
+    //     return (try self._item(index)) orelse {
+    //         has_value.* = false;
+    //         return null;
+    //     };
+    // }
+
+    pub fn _forEach(self: *NodeList, cbk: js.Function) !void { // TODO handle thisArg
+        for (self.nodes.items, 0..) |n, i| {
+            const ii: u32 = @intCast(i);
+            var result: js.Function.Result = undefined;
+            cbk.tryCall(void, .{ n, ii, self }, &result) catch {
+                log.debug(.user_script, "forEach callback", .{ .err = result.exception, .stack = result.stack });
+            };
+        }
+    }
+
+    pub fn _keys(self: *NodeList) U32Iterator {
+        return .{
+            .length = self.get_length(),
+        };
+    }
+
+    pub fn _values(self: *NodeList) NodeListIterator {
+        return .{
+            .coll = self,
+        };
+    }
+
+    pub fn _symbol_iterator(self: *NodeList) NodeListIterator {
+        return self._values();
+    }
+
+    // TODO entries() https://developer.mozilla.org/en-US/docs/Web/API/NodeList/entries
+    pub fn postAttach(self: *NodeList, js_this: js.This) !void {
+        const len = self.get_length();
+        for (0..len) |i| {
+            const node = try self._item(@intCast(i)) orelse unreachable;
+            try js_this.setIndex(@intCast(i), node, .{});
+        }
+    }
+};
+
+const testing = @import("../../testing.zig");
+test "Browser: DOM.NodeList" {
+    try testing.htmlRunner("dom/node_list.html");
+}

src/browser/dom/performance.zig

@@ -0,0 +1,206 @@
+// Copyright (C) 2023-2025  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const std = @import("std");
+
+const js = @import("../js/js.zig");
+const parser = @import("../netsurf.zig");
+const EventTarget = @import("../dom/event_target.zig").EventTarget;
+const Page = @import("../page.zig").Page;
+
+const milliTimestamp = @import("../../datetime.zig").milliTimestamp;
+
+pub const Interfaces = .{
+    Performance,
+    PerformanceEntry,
+    PerformanceMark,
+};
+
+// https://developer.mozilla.org/en-US/docs/Web/API/Performance
+pub const Performance = struct {
+    pub const prototype = *EventTarget;
+
+    // Extend libdom event target for pure zig struct.
+    base: parser.EventTargetTBase = parser.EventTargetTBase{ .internal_target_type = .performance },
+
+    time_origin: u64,
+    // if (Window.crossOriginIsolated) -> Resolution in isolated contexts:       5 microseconds
+    // else                            -> Resolution in non-isolated contexts: 100 microseconds
+    const ms_resolution = 100;
+
+    pub fn init() Performance {
+        return .{
+            .time_origin = milliTimestamp(),
+        };
+    }
+
+    pub fn get_timeOrigin(self: *const Performance) u64 {
+        return self.time_origin;
+    }
+
+    pub fn reset(self: *Performance) void {
+        self.time_origin = milliTimestamp();
+    }
+
+    pub fn _now(self: *const Performance) u64 {
+        return milliTimestamp() - self.time_origin;
+    }
+
+    pub fn _mark(_: *Performance, name: js.String, _options: ?PerformanceMark.Options, page: *Page) !PerformanceMark {
+        const mark: PerformanceMark = try .constructor(name, _options, page);
+        // TODO: Should store this in an entries list
+        return mark;
+    }
+
+    // TODO: fn _mark should record the marks in a lookup
+    pub fn _clearMarks(_: *Performance, name: ?[]const u8) void {
+        _ = name;
+    }
+
+    // TODO: fn _measures should record the marks in a lookup
+    pub fn _clearMeasures(_: *Performance, name: ?[]const u8) void {
+        _ = name;
+    }
+
+    // TODO: fn _measures should record the marks in a lookup
+    pub fn _getEntriesByName(_: *Performance, name: []const u8, typ: ?[]const u8) []PerformanceEntry {
+        _ = name;
+        _ = typ;
+        return &.{};
+    }
+
+    // TODO: fn _measures should record the marks in a lookup
+    pub fn _getEntriesByType(_: *Performance, typ: []const u8) []PerformanceEntry {
+        _ = typ;
+        return &.{};
+    }
+};
+
+// https://developer.mozilla.org/en-US/docs/Web/API/PerformanceEntry
+pub const PerformanceEntry = struct {
+    const PerformanceEntryType = enum {
+        element,
+        event,
+        first_input,
+        largest_contentful_paint,
+        layout_shift,
+        long_animation_frame,
+        longtask,
+        mark,
+        measure,
+        navigation,
+        paint,
+        resource,
+        taskattribution,
+        visibility_state,
+
+        pub fn toString(self: PerformanceEntryType) []const u8 {
+            return switch (self) {
+                .first_input => "first-input",
+                .largest_contentful_paint => "largest-contentful-paint",
+                .layout_shift => "layout-shift",
+                .long_animation_frame => "long-animation-frame",
+                .visibility_state => "visibility-state",
+                else => @tagName(self),
+            };
+        }
+    };
+
+    duration: f64 = 0.0,
+    entry_type: PerformanceEntryType,
+    name: []const u8,
+    start_time: f64 = 0.0,
+
+    pub fn get_duration(self: *const PerformanceEntry) f64 {
+        return self.duration;
+    }
+
+    pub fn get_entryType(self: *const PerformanceEntry) PerformanceEntryType {
+        return self.entry_type;
+    }
+
+    pub fn get_name(self: *const PerformanceEntry) []const u8 {
+        return self.name;
+    }
+
+    pub fn get_startTime(self: *const PerformanceEntry) f64 {
+        return self.start_time;
+    }
+};
+
+// https://developer.mozilla.org/en-US/docs/Web/API/PerformanceMark
+pub const PerformanceMark = struct {
+    pub const prototype = *PerformanceEntry;
+
+    proto: PerformanceEntry,
+    detail: ?js.Object,
+
+    const Options = struct {
+        detail: ?js.Object = null,
+        startTime: ?f64 = null,
+    };
+
+    pub fn constructor(name: js.String, _options: ?Options, page: *Page) !PerformanceMark {
+        const perf = &page.window.performance;
+
+        const options = _options orelse Options{};
+        const start_time = options.startTime orelse @as(f64, @floatFromInt(perf._now()));
+
+        if (start_time < 0.0) {
+            return error.TypeError;
+        }
+
+        const detail = if (options.detail) |d| try d.persist() else null;
+        const proto = PerformanceEntry{ .name = name.string, .entry_type = .mark, .start_time = start_time };
+
+        return .{ .proto = proto, .detail = detail };
+    }
+
+    pub fn get_detail(self: *const PerformanceMark) ?js.Object {
+        return self.detail;
+    }
+};
+
+const testing = @import("./../../testing.zig");
+
+test "Performance: get_timeOrigin" {
+    var perf = Performance.init();
+    const time_origin = perf.get_timeOrigin();
+    try testing.expect(time_origin >= 0);
+}
+
+test "Performance: now" {
+    var perf = Performance.init();
+
+    // Monotonically increasing
+    var now = perf._now();
+    while (now <= 0) { // Loop for now to not be 0
+        try testing.expectEqual(now, 0);
+        now = perf._now();
+    }
+
+    var after = perf._now();
+    while (after <= now) { // Loop until after > now
+        try testing.expectEqual(after, now);
+        after = perf._now();
+    }
+}
+
+test "Browser: Performance.Mark" {
+    try testing.htmlRunner("dom/performance.html");
+}

src/browser/dom/performance_observer.zig

@@ -0,0 +1,58 @@
+// Copyright (C) 2023-2025  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const std = @import("std");
+const js = @import("../js/js.zig");
+
+const PerformanceEntry = @import("performance.zig").PerformanceEntry;
+
+// https://developer.mozilla.org/en-US/docs/Web/API/PerformanceObserver
+pub const PerformanceObserver = struct {
+    pub const _supportedEntryTypes = [0][]const u8{};
+
+    pub fn constructor(cbk: js.Function) PerformanceObserver {
+        _ = cbk;
+        return .{};
+    }
+
+    pub fn _observe(self: *const PerformanceObserver, options_: ?Options) void {
+        _ = self;
+        _ = options_;
+        return;
+    }
+
+    pub fn _disconnect(self: *PerformanceObserver) void {
+        _ = self;
+    }
+
+    pub fn _takeRecords(_: *const PerformanceObserver) []PerformanceEntry {
+        return &[_]PerformanceEntry{};
+    }
+};
+
+const Options = struct {
+    buffered: ?bool = null,
+    durationThreshold: ?f64 = null,
+    entryTypes: ?[]const []const u8 = null,
+    type: ?[]const u8 = null,
+};
+
+const testing = @import("../../testing.zig");
+test "Browser: DOM.PerformanceObserver" {
+    try testing.htmlRunner("dom/performance_observer.html");
+}

src/browser/dom/processing_instruction.zig

@@ -0,0 +1,92 @@
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const std = @import("std");
+
+const parser = @import("../netsurf.zig");
+const Node = @import("node.zig").Node;
+const Page = @import("../page.zig").Page;
+
+// https://dom.spec.whatwg.org/#processinginstruction
+pub const ProcessingInstruction = struct {
+    pub const Self = parser.ProcessingInstruction;
+
+    // TODO for libdom processing instruction inherit from node.
+    // But the spec says it must inherit from CDATA.
+    pub const prototype = *Node;
+    pub const subtype = .node;
+
+    pub fn get_target(self: *parser.ProcessingInstruction) ![]const u8 {
+        // libdom stores the ProcessingInstruction target in the node's name.
+        return try parser.nodeName(parser.processingInstructionToNode(self));
+    }
+
+    // There's something wrong when we try to clone a ProcessInstruction normally.
+    // The resulting object can't be cast back into a node (it crashes). This is
+    // a simple workaround.
+    pub fn _cloneNode(self: *parser.ProcessingInstruction, _: ?bool, page: *Page) !*parser.ProcessingInstruction {
+        return try parser.documentCreateProcessingInstruction(
+            @ptrCast(page.window.document),
+            try get_target(self),
+            (try get_data(self)) orelse "",
+        );
+    }
+
+    pub fn get_data(self: *parser.ProcessingInstruction) !?[]const u8 {
+        return parser.nodeValue(parser.processingInstructionToNode(self));
+    }
+
+    pub fn set_data(self: *parser.ProcessingInstruction, data: []u8) !void {
+        try parser.nodeSetValue(parser.processingInstructionToNode(self), data);
+    }
+
+    // netsurf's ProcessInstruction doesn't implement the dom_node_get_attributes
+    // and thus will crash if we try to call nodeIsEqualNode.
+    pub fn _isEqualNode(self: *parser.ProcessingInstruction, other_node: *parser.Node) !bool {
+        if (parser.nodeType(other_node) != .processing_instruction) {
+            return false;
+        }
+
+        const other: *parser.ProcessingInstruction = @ptrCast(other_node);
+
+        if (std.mem.eql(u8, try get_target(self), try get_target(other)) == false) {
+            return false;
+        }
+
+        {
+            const self_data = try get_data(self);
+            const other_data = try get_data(other);
+            if (self_data == null and other_data != null) {
+                return false;
+            }
+            if (self_data != null and other_data == null) {
+                return false;
+            }
+            if (std.mem.eql(u8, self_data.?, other_data.?) == false) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+};
+
+const testing = @import("../../testing.zig");
+test "Browser: DOM.ProcessingInstruction" {
+    try testing.htmlRunner("dom/processing_instruction.html");
+}

src/browser/dom/range.zig

@@ -0,0 +1,390 @@
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const std = @import("std");
+
+const parser = @import("../netsurf.zig");
+const Page = @import("../page.zig").Page;
+
+const Node = @import("node.zig").Node;
+const NodeUnion = @import("node.zig").Union;
+const DOMException = @import("exceptions.zig").DOMException;
+
+pub const Interfaces = .{
+    AbstractRange,
+    Range,
+};
+
+pub const AbstractRange = struct {
+    collapsed: bool,
+    end_node: *parser.Node,
+    end_offset: u32,
+    start_node: *parser.Node,
+    start_offset: u32,
+
+    pub fn updateCollapsed(self: *AbstractRange) void {
+        // TODO: Eventually, compare properly.
+        self.collapsed = false;
+    }
+
+    pub fn get_collapsed(self: *const AbstractRange) bool {
+        return self.collapsed;
+    }
+
+    pub fn get_endContainer(self: *const AbstractRange) !NodeUnion {
+        return Node.toInterface(self.end_node);
+    }
+
+    pub fn get_endOffset(self: *const AbstractRange) u32 {
+        return self.end_offset;
+    }
+
+    pub fn get_startContainer(self: *const AbstractRange) !NodeUnion {
+        return Node.toInterface(self.start_node);
+    }
+
+    pub fn get_startOffset(self: *const AbstractRange) u32 {
+        return self.start_offset;
+    }
+};
+
+pub const Range = struct {
+    pub const Exception = DOMException;
+    pub const prototype = *AbstractRange;
+
+    proto: AbstractRange,
+
+    pub const _START_TO_START = 0;
+    pub const _START_TO_END = 1;
+    pub const _END_TO_END = 2;
+    pub const _END_TO_START = 3;
+
+    // The Range() constructor returns a newly created Range object whose start
+    // and end is the global Document object.
+    // https://developer.mozilla.org/en-US/docs/Web/API/Range/Range
+    pub fn constructor(page: *Page) Range {
+        const proto: AbstractRange = .{
+            .collapsed = true,
+            .end_node = parser.documentHTMLToNode(page.window.document),
+            .end_offset = 0,
+            .start_node = parser.documentHTMLToNode(page.window.document),
+            .start_offset = 0,
+        };
+
+        return .{ .proto = proto };
+    }
+
+    pub fn _setStart(self: *Range, node: *parser.Node, offset_: i32) !void {
+        try ensureValidOffset(node, offset_);
+        const offset: u32 = @intCast(offset_);
+        const position = compare(node, offset, self.proto.end_node, self.proto.end_offset) catch |err| switch (err) {
+            error.WrongDocument => blk: {
+                // allow a node with a different root than the current, or
+                // a disconnected one. Treat it as if it's "after", so that
+                // we also update the end_offset and end_node.
+                break :blk 1;
+            },
+            else => return err,
+        };
+
+        if (position == 1) {
+            // if we're setting the node after the current end, the end must
+            // be set too.
+            self.proto.end_offset = offset;
+            self.proto.end_node = node;
+        }
+        self.proto.start_node = node;
+        self.proto.start_offset = offset;
+        self.proto.updateCollapsed();
+    }
+
+    pub fn _setStartBefore(self: *Range, node: *parser.Node) !void {
+        const parent, const index = try getParentAndIndex(node);
+        self.proto.start_node = parent;
+        self.proto.start_offset = index;
+    }
+
+    pub fn _setStartAfter(self: *Range, node: *parser.Node) !void {
+        const parent, const index = try getParentAndIndex(node);
+        self.proto.start_node = parent;
+        self.proto.start_offset = index + 1;
+    }
+
+    pub fn _setEnd(self: *Range, node: *parser.Node, offset_: i32) !void {
+        try ensureValidOffset(node, offset_);
+        const offset: u32 = @intCast(offset_);
+
+        const position = compare(node, offset, self.proto.start_node, self.proto.start_offset) catch |err| switch (err) {
+            error.WrongDocument => blk: {
+                // allow a node with a different root than the current, or
+                // a disconnected one. Treat it as if it's "before", so that
+                // we also update the end_offset and end_node.
+                break :blk -1;
+            },
+            else => return err,
+        };
+
+        if (position == -1) {
+            // if we're setting the node before the current start, the start
+            // must be set too.
+            self.proto.start_offset = offset;
+            self.proto.start_node = node;
+        }
+
+        self.proto.end_node = node;
+        self.proto.end_offset = offset;
+        self.proto.updateCollapsed();
+    }
+
+    pub fn _setEndBefore(self: *Range, node: *parser.Node) !void {
+        const parent, const index = try getParentAndIndex(node);
+        self.proto.end_node = parent;
+        self.proto.end_offset = index;
+    }
+
+    pub fn _setEndAfter(self: *Range, node: *parser.Node) !void {
+        const parent, const index = try getParentAndIndex(node);
+        self.proto.end_node = parent;
+        self.proto.end_offset = index + 1;
+    }
+
+    pub fn _createContextualFragment(_: *Range, fragment: []const u8, page: *Page) !*parser.DocumentFragment {
+        const document_html = page.window.document;
+        const document = parser.documentHTMLToDocument(document_html);
+        const doc_frag = try parser.documentParseFragmentFromStr(document, fragment);
+        return doc_frag;
+    }
+
+    pub fn _selectNodeContents(self: *Range, node: *parser.Node) !void {
+        self.proto.start_node = node;
+        self.proto.start_offset = 0;
+        self.proto.end_node = node;
+
+        // Set end_offset
+        switch (parser.nodeType(node)) {
+            .text, .cdata_section, .comment, .processing_instruction => {
+                // For text-like nodes, end_offset should be the length of the text data
+                if (parser.nodeValue(node)) |text_data| {
+                    self.proto.end_offset = @intCast(text_data.len);
+                } else {
+                    self.proto.end_offset = 0;
+                }
+            },
+            else => {
+                // For element and other nodes, end_offset is the number of children
+                const child_nodes = try parser.nodeGetChildNodes(node);
+                const child_count = parser.nodeListLength(child_nodes);
+                self.proto.end_offset = @intCast(child_count);
+            },
+        }
+
+        self.proto.updateCollapsed();
+    }
+
+    // creates a copy
+    pub fn _cloneRange(self: *const Range) Range {
+        return .{
+            .proto = .{
+                .collapsed = self.proto.collapsed,
+                .end_node = self.proto.end_node,
+                .end_offset = self.proto.end_offset,
+                .start_node = self.proto.start_node,
+                .start_offset = self.proto.start_offset,
+            },
+        };
+    }
+
+    pub fn _comparePoint(self: *const Range, node: *parser.Node, offset_: i32) !i32 {
+        const start = self.proto.start_node;
+        if (parser.nodeGetRootNode(start) != parser.nodeGetRootNode(node)) {
+            // WPT really wants this error to be first. Later, when we check
+            // if the relative position is 'disconnected', it'll also catch this
+            // case, but WPT will complain because it sometimes also sends
+            // invalid offsets, and it wants WrongDocument to be raised.
+            return error.WrongDocument;
+        }
+
+        if (parser.nodeType(node) == .document_type) {
+            return error.InvalidNodeType;
+        }
+
+        try ensureValidOffset(node, offset_);
+
+        const offset: u32 = @intCast(offset_);
+        if (try compare(node, offset, start, self.proto.start_offset) == -1) {
+            return -1;
+        }
+
+        if (try compare(node, offset, self.proto.end_node, self.proto.end_offset) == 1) {
+            return 1;
+        }
+
+        return 0;
+    }
+
+    pub fn _isPointInRange(self: *const Range, node: *parser.Node, offset_: i32) !bool {
+        return self._comparePoint(node, offset_) catch |err| switch (err) {
+            error.WrongDocument => return false,
+            else => return err,
+        } == 0;
+    }
+
+    pub fn _intersectsNode(self: *const Range, node: *parser.Node) !bool {
+        const start_root = parser.nodeGetRootNode(self.proto.start_node);
+        const node_root = parser.nodeGetRootNode(node);
+        if (start_root != node_root) {
+            return false;
+        }
+
+        const parent, const index = getParentAndIndex(node) catch |err| switch (err) {
+            error.InvalidNodeType => return true, // if node has no parent, we return true.
+            else => return err,
+        };
+
+        if (try compare(parent, index + 1, self.proto.start_node, self.proto.start_offset) != 1) {
+            // node isn't after start, can't intersect
+            return false;
+        }
+
+        if (try compare(parent, index, self.proto.end_node, self.proto.end_offset) != -1) {
+            // node isn't before end, can't intersect
+            return false;
+        }
+
+        return true;
+    }
+
+    pub fn _compareBoundaryPoints(self: *const Range, how: i32, other: *const Range) !i32 {
+        return switch (how) {
+            _START_TO_START => compare(self.proto.start_node, self.proto.start_offset, other.proto.start_node, other.proto.start_offset),
+            _START_TO_END => compare(self.proto.start_node, self.proto.start_offset, other.proto.end_node, other.proto.end_offset),
+            _END_TO_END => compare(self.proto.end_node, self.proto.end_offset, other.proto.end_node, other.proto.end_offset),
+            _END_TO_START => compare(self.proto.end_node, self.proto.end_offset, other.proto.start_node, other.proto.start_offset),
+            else => error.NotSupported, // this is the correct DOM Exception to return
+        };
+    }
+
+    // The Range.detach() method does nothing. It used to disable the Range
+    // object and enable the browser to release associated resources. The
+    // method has been kept for compatibility.
+    // https://developer.mozilla.org/en-US/docs/Web/API/Range/detach
+    pub fn _detach(_: *Range) void {}
+};
+
+fn ensureValidOffset(node: *parser.Node, offset: i32) !void {
+    if (offset < 0) {
+        return error.IndexSize;
+    }
+
+    // not >= because 0 seems to represent the node itself.
+    if (offset > try nodeLength(node)) {
+        return error.IndexSize;
+    }
+}
+
+fn nodeLength(node: *parser.Node) !usize {
+    switch (try isTextual(node)) {
+        true => return ((parser.nodeTextContent(node)) orelse "").len,
+        false => {
+            const children = try parser.nodeGetChildNodes(node);
+            return @intCast(parser.nodeListLength(children));
+        },
+    }
+}
+
+fn isTextual(node: *parser.Node) !bool {
+    return switch (parser.nodeType(node)) {
+        .text, .comment, .cdata_section => true,
+        else => false,
+    };
+}
+
+fn getParentAndIndex(child: *parser.Node) !struct { *parser.Node, u32 } {
+    const parent = (parser.nodeParentNode(child)) orelse return error.InvalidNodeType;
+    const children = try parser.nodeGetChildNodes(parent);
+    const ln = parser.nodeListLength(children);
+    var i: u32 = 0;
+    while (i < ln) {
+        defer i += 1;
+        const c = parser.nodeListItem(children, i) orelse continue;
+        if (c == child) {
+            return .{ parent, i };
+        }
+    }
+
+    // should not be possible to reach this point
+    return error.InvalidNodeType;
+}
+
+// implementation is largely copied from the WPT helper called getPosition in
+// the common.js of the dom folder.
+fn compare(node_a: *parser.Node, offset_a: u32, node_b: *parser.Node, offset_b: u32) !i32 {
+    if (node_a == node_b) {
+        // This is a simple and common case, where the two nodes are the same
+        // We just need to compare their offsets
+        if (offset_a == offset_b) {
+            return 0;
+        }
+        return if (offset_a < offset_b) -1 else 1;
+    }
+
+    // We're probably comparing two different nodes. "Probably", because the
+    // above case on considered the offset if the two nodes were the same
+    // as-is. They could still be the same here, if we first consider the
+    // offset.
+    const position = try Node._compareDocumentPosition(node_b, node_a);
+    if (position & @intFromEnum(parser.DocumentPosition.disconnected) == @intFromEnum(parser.DocumentPosition.disconnected)) {
+        return error.WrongDocument;
+    }
+
+    if (position & @intFromEnum(parser.DocumentPosition.following) == @intFromEnum(parser.DocumentPosition.following)) {
+        return switch (try compare(node_b, offset_b, node_a, offset_a)) {
+            -1 => 1,
+            1 => -1,
+            else => unreachable,
+        };
+    }
+
+    if (position & @intFromEnum(parser.DocumentPosition.contains) == @intFromEnum(parser.DocumentPosition.contains)) {
+        // node_a contains node_b
+        var child = node_b;
+        while (parser.nodeParentNode(child)) |parent| {
+            if (parent == node_a) {
+                // child.parentNode == node_a
+                break;
+            }
+            child = parent;
+        } else {
+            // this should not happen, because  Node._compareDocumentPosition
+            // has told us that node_a contains node_b, so one of node_b's
+            // parent's MUST be node_a. But somehow we do end up here sometimes.
+            return -1;
+        }
+
+        const child_parent, const child_index = try getParentAndIndex(child);
+        std.debug.assert(node_a == child_parent);
+        return if (offset_a <= child_index) -1 else 1;
+    }
+
+    return -1;
+}
+
+const testing = @import("../../testing.zig");
+test "Browser: Range" {
+    try testing.htmlRunner("dom/range.html");
+}

src/browser/dom/resize_observer.zig

@@ -16,38 +16,39 @@
 // You should have received a copy of the GNU Affero General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
-const std = @import("std");
+const js = @import("../js/js.zig");
+const parser = @import("../netsurf.zig");
 
-const js = @import("../../js/js.zig");
-
-const NavigationHistoryEntry = @import("NavigationHistoryEntry.zig");
-
-pub const NavigationType = enum {
-    push,
-    replace,
-    traverse,
-    reload,
+pub const Interfaces = .{
+    ResizeObserver,
 };
 
-pub const NavigationKind = union(NavigationType) {
-    push: ?[]const u8,
-    replace: ?[]const u8,
-    traverse: usize,
-    reload,
+// WEB IDL https://drafts.csswg.org/resize-observer/#resize-observer-interface
+pub const ResizeObserver = struct {
+    pub fn constructor(cbk: js.Function) ResizeObserver {
+        _ = cbk;
+        return .{};
+    }
 
-    pub fn toNavigationType(self: NavigationKind) NavigationType {
-        return std.meta.activeTag(self);
+    pub fn _observe(self: *const ResizeObserver, element: *parser.Element, options_: ?Options) void {
+        _ = self;
+        _ = element;
+        _ = options_;
+        return;
+    }
+
+    pub fn _unobserve(self: *const ResizeObserver, element: *parser.Element) void {
+        _ = self;
+        _ = element;
+        return;
+    }
+
+    // TODO
+    pub fn _disconnect(self: *ResizeObserver) void {
+        _ = self;
     }
 };
 
-pub const NavigationState = struct {
-    source: enum { history, navigation },
-    value: ?[]const u8,
-};
-
-// https://developer.mozilla.org/en-US/docs/Web/API/NavigationTransition
-pub const NavigationTransition = struct {
-    finished: js.Promise.Global,
-    from: NavigationHistoryEntry,
-    navigation_type: NavigationType,
+const Options = struct {
+    box: []const u8,
 };

src/browser/dom/shadow_root.zig

@@ -0,0 +1,101 @@
+// Copyright (C) 2023-2025  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const std = @import("std");
+const dump = @import("../dump.zig");
+const parser = @import("../netsurf.zig");
+
+const js = @import(".././js/js.zig");
+const Page = @import("../page.zig").Page;
+const Node = @import("node.zig").Node;
+const Element = @import("element.zig").Element;
+const ElementUnion = @import("element.zig").Union;
+
+// WEB IDL https://dom.spec.whatwg.org/#interface-shadowroot
+pub const ShadowRoot = struct {
+    pub const prototype = *parser.DocumentFragment;
+    pub const subtype = .node;
+
+    mode: Mode,
+    host: *parser.Element,
+    proto: *parser.DocumentFragment,
+    adopted_style_sheets: ?js.Object = null,
+
+    pub const Mode = enum {
+        open,
+        closed,
+    };
+
+    pub fn get_host(self: *const ShadowRoot) !ElementUnion {
+        return Element.toInterface(self.host);
+    }
+
+    pub fn get_adoptedStyleSheets(self: *ShadowRoot, page: *Page) !js.Object {
+        if (self.adopted_style_sheets) |obj| {
+            return obj;
+        }
+
+        const obj = try page.js.createArray(0).persist();
+        self.adopted_style_sheets = obj;
+        return obj;
+    }
+
+    pub fn set_adoptedStyleSheets(self: *ShadowRoot, sheets: js.Object) !void {
+        self.adopted_style_sheets = try sheets.persist();
+    }
+
+    pub fn get_innerHTML(self: *ShadowRoot, page: *Page) ![]const u8 {
+        var aw = std.Io.Writer.Allocating.init(page.call_arena);
+        try dump.writeChildren(parser.documentFragmentToNode(self.proto), .{}, &aw.writer);
+        return aw.written();
+    }
+
+    pub fn set_innerHTML(self: *ShadowRoot, str_: ?[]const u8) !void {
+        const sr_doc = parser.documentFragmentToNode(self.proto);
+        const doc = parser.nodeOwnerDocument(sr_doc) orelse return parser.DOMError.WrongDocument;
+        try Node.removeChildren(sr_doc);
+        const str = str_ orelse return;
+
+        const fragment = try parser.documentParseFragmentFromStr(doc, str);
+        const fragment_node = parser.documentFragmentToNode(fragment);
+
+        // Element.set_innerHTML also has some weirdness here. It isn't clear
+        // what should and shouldn't be set. Whatever string you pass to libdom,
+        // it always creates a full HTML document, with an html, head and body
+        // element.
+        // For ShadowRoot, it appears the only the children within the body should
+        // be set.
+        const html = parser.nodeFirstChild(fragment_node) orelse return;
+        const head = parser.nodeFirstChild(html) orelse return;
+        const body = parser.nodeNextSibling(head) orelse return;
+
+        const children = try parser.nodeGetChildNodes(body);
+        const ln = parser.nodeListLength(children);
+        for (0..ln) |_| {
+            // always index 0, because nodeAppendChild moves the node out of
+            // the nodeList and into the new tree
+            const child = parser.nodeListItem(children, 0) orelse continue;
+            _ = try parser.nodeAppendChild(sr_doc, child);
+        }
+    }
+};
+
+const testing = @import("../../testing.zig");
+test "Browser: DOM.ShadowRoot" {
+    try testing.htmlRunner("dom/shadow_root.html");
+}

src/browser/dom/text.zig

@@ -0,0 +1,62 @@
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const parser = @import("../netsurf.zig");
+const Page = @import("../page.zig").Page;
+
+const CharacterData = @import("character_data.zig").CharacterData;
+const CDATASection = @import("cdata_section.zig").CDATASection;
+
+// Text interfaces
+pub const Interfaces = .{
+    CDATASection,
+};
+
+pub const Text = struct {
+    pub const Self = parser.Text;
+    pub const prototype = *CharacterData;
+    pub const subtype = .node;
+
+    pub fn constructor(data: ?[]const u8, page: *const Page) !*parser.Text {
+        return parser.documentCreateTextNode(
+            parser.documentHTMLToDocument(page.window.document),
+            data orelse "",
+        );
+    }
+
+    // JS funcs
+    // --------
+
+    // Read attributes
+
+    pub fn get_wholeText(self: *parser.Text) ![]const u8 {
+        return try parser.textWholdeText(self);
+    }
+
+    // JS methods
+    // ----------
+
+    pub fn _splitText(self: *parser.Text, offset: u32) !*parser.Text {
+        return try parser.textSplitText(self, offset);
+    }
+};
+
+const testing = @import("../../testing.zig");
+test "Browser: DOM.Text" {
+    try testing.htmlRunner("dom/text.html");
+}

src/browser/dom/token_list.zig

@@ -0,0 +1,174 @@
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const std = @import("std");
+
+const js = @import("../js/js.zig");
+const log = @import("../../log.zig");
+const parser = @import("../netsurf.zig");
+const iterator = @import("../iterator/iterator.zig");
+
+const DOMException = @import("exceptions.zig").DOMException;
+
+pub const Interfaces = .{
+    DOMTokenList,
+    DOMTokenListIterable,
+    TokenListEntriesIterator,
+    TokenListEntriesIterator.Iterable,
+};
+
+// https://dom.spec.whatwg.org/#domtokenlist
+pub const DOMTokenList = struct {
+    pub const Self = parser.TokenList;
+    pub const Exception = DOMException;
+
+    pub fn get_length(self: *parser.TokenList) !u32 {
+        return parser.tokenListGetLength(self);
+    }
+
+    pub fn _item(self: *parser.TokenList, index: u32) !?[]const u8 {
+        return parser.tokenListItem(self, index);
+    }
+
+    pub fn _contains(self: *parser.TokenList, token: []const u8) !bool {
+        return parser.tokenListContains(self, token);
+    }
+
+    pub fn _add(self: *parser.TokenList, tokens: []const []const u8) !void {
+        for (tokens) |token| {
+            try parser.tokenListAdd(self, token);
+        }
+    }
+
+    pub fn _remove(self: *parser.TokenList, tokens: []const []const u8) !void {
+        for (tokens) |token| {
+            try parser.tokenListRemove(self, token);
+        }
+    }
+
+    /// If token is the empty string, then throw a "SyntaxError" DOMException.
+    /// If token contains any ASCII whitespace, then throw an
+    /// "InvalidCharacterError" DOMException.
+    fn validateToken(token: []const u8) !void {
+        if (token.len == 0) {
+            return parser.DOMError.Syntax;
+        }
+        for (token) |c| {
+            if (std.ascii.isWhitespace(c)) return parser.DOMError.InvalidCharacter;
+        }
+    }
+
+    pub fn _toggle(self: *parser.TokenList, token: []const u8, force: ?bool) !bool {
+        try validateToken(token);
+        const exists = try parser.tokenListContains(self, token);
+        if (exists) {
+            if (force == null or force.? == false) {
+                try parser.tokenListRemove(self, token);
+                return false;
+            }
+            return true;
+        }
+
+        if (force == null or force.? == true) {
+            try parser.tokenListAdd(self, token);
+            return true;
+        }
+        return false;
+    }
+
+    pub fn _replace(self: *parser.TokenList, token: []const u8, new: []const u8) !bool {
+        try validateToken(token);
+        try validateToken(new);
+        const exists = try parser.tokenListContains(self, token);
+        if (!exists) return false;
+        try parser.tokenListRemove(self, token);
+        try parser.tokenListAdd(self, new);
+        return true;
+    }
+
+    // TODO to implement.
+    pub fn _supports(_: *parser.TokenList, token: []const u8) !bool {
+        try validateToken(token);
+        return error.TypeError;
+    }
+
+    pub fn get_value(self: *parser.TokenList) !?[]const u8 {
+        return (try parser.tokenListGetValue(self)) orelse "";
+    }
+
+    pub fn set_value(self: *parser.TokenList, value: []const u8) !void {
+        return parser.tokenListSetValue(self, value);
+    }
+
+    pub fn _toString(self: *parser.TokenList) ![]const u8 {
+        return (try get_value(self)) orelse "";
+    }
+
+    pub fn _keys(self: *parser.TokenList) !iterator.U32Iterator {
+        return .{ .length = try get_length(self) };
+    }
+
+    pub fn _values(self: *parser.TokenList) DOMTokenListIterable {
+        return DOMTokenListIterable.init(.{ .token_list = self });
+    }
+
+    pub fn _entries(self: *parser.TokenList) TokenListEntriesIterator {
+        return TokenListEntriesIterator.init(.{ .token_list = self });
+    }
+
+    pub fn _symbol_iterator(self: *parser.TokenList) DOMTokenListIterable {
+        return _values(self);
+    }
+
+    // TODO handle thisArg
+    pub fn _forEach(self: *parser.TokenList, cbk: js.Function, this_arg: js.Object) !void {
+        var entries = _entries(self);
+        while (try entries._next()) |entry| {
+            var result: js.Function.Result = undefined;
+            cbk.tryCallWithThis(void, this_arg, .{ entry.@"1", entry.@"0", self }, &result) catch {
+                log.debug(.user_script, "callback error", .{
+                    .err = result.exception,
+                    .stack = result.stack,
+                    .soure = "tokenList foreach",
+                });
+            };
+        }
+    }
+};
+
+const DOMTokenListIterable = iterator.Iterable(Iterator, "DOMTokenListIterable");
+const TokenListEntriesIterator = iterator.NumericEntries(Iterator, "TokenListEntriesIterator");
+
+pub const Iterator = struct {
+    index: u32 = 0,
+    token_list: *parser.TokenList,
+
+    // used when wrapped in an iterator.NumericEntries
+    pub const Error = parser.DOMError;
+
+    pub fn _next(self: *Iterator) !?[]const u8 {
+        const index = self.index;
+        self.index = index + 1;
+        return DOMTokenList._item(self.token_list, index);
+    }
+};
+
+const testing = @import("../../testing.zig");
+test "Browser: DOM.TokenList" {
+    try testing.htmlRunner("dom/token_list.html");
+}

src/browser/dom/tree_walker.zig

@@ -0,0 +1,314 @@
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const std = @import("std");
+const js = @import("../js/js.zig");
+const parser = @import("../netsurf.zig");
+
+const NodeFilter = @import("node_filter.zig");
+const Node = @import("node.zig").Node;
+const NodeUnion = @import("node.zig").Union;
+
+// https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker
+pub const TreeWalker = struct {
+    root: *parser.Node,
+    current_node: *parser.Node,
+    what_to_show: u32,
+    filter: ?TreeWalkerOpts,
+    filter_func: ?js.Function,
+
+    // One of the few cases where null and undefined resolve to different default.
+    // We need the raw JsObject so that we can probe the tri state:
+    // null, undefined or i32.
+    pub const WhatToShow = js.Object;
+
+    pub const TreeWalkerOpts = union(enum) {
+        function: js.Function,
+        object: struct { acceptNode: js.Function },
+    };
+
+    pub fn init(node: *parser.Node, what_to_show_: ?WhatToShow, filter: ?TreeWalkerOpts) !TreeWalker {
+        var filter_func: ?js.Function = null;
+
+        if (filter) |f| {
+            filter_func = switch (f) {
+                .function => |func| func,
+                .object => |o| o.acceptNode,
+            };
+        }
+
+        var what_to_show: u32 = undefined;
+        if (what_to_show_) |wts| {
+            switch (try wts.triState(TreeWalker, "what_to_show", u32)) {
+                .null => what_to_show = 0,
+                .undefined => what_to_show = NodeFilter.NodeFilter._SHOW_ALL,
+                .value => |v| what_to_show = v,
+            }
+        } else {
+            what_to_show = NodeFilter.NodeFilter._SHOW_ALL;
+        }
+
+        return .{
+            .root = node,
+            .current_node = node,
+            .what_to_show = what_to_show,
+            .filter = filter,
+            .filter_func = filter_func,
+        };
+    }
+
+    pub fn get_root(self: *TreeWalker) !NodeUnion {
+        return try Node.toInterface(self.root);
+    }
+
+    pub fn get_currentNode(self: *TreeWalker) !NodeUnion {
+        return try Node.toInterface(self.current_node);
+    }
+
+    pub fn get_whatToShow(self: *TreeWalker) u32 {
+        return self.what_to_show;
+    }
+
+    pub fn get_filter(self: *TreeWalker) ?TreeWalkerOpts {
+        return self.filter;
+    }
+
+    pub fn set_currentNode(self: *TreeWalker, node: *parser.Node) !void {
+        self.current_node = node;
+    }
+
+    fn firstChild(self: *const TreeWalker, node: *parser.Node) !?*parser.Node {
+        const children = try parser.nodeGetChildNodes(node);
+        const child_count = parser.nodeListLength(children);
+
+        for (0..child_count) |i| {
+            const index: u32 = @intCast(i);
+            const child = (parser.nodeListItem(children, index)) orelse return null;
+
+            switch (try NodeFilter.verify(self.what_to_show, self.filter_func, child)) {
+                .accept => return child,
+                .reject => continue,
+                .skip => if (try self.firstChild(child)) |gchild| return gchild,
+            }
+        }
+
+        return null;
+    }
+
+    fn lastChild(self: *const TreeWalker, node: *parser.Node) !?*parser.Node {
+        const children = try parser.nodeGetChildNodes(node);
+        const child_count = parser.nodeListLength(children);
+
+        var index: u32 = child_count;
+        while (index > 0) {
+            index -= 1;
+            const child = (parser.nodeListItem(children, index)) orelse return null;
+
+            switch (try NodeFilter.verify(self.what_to_show, self.filter_func, child)) {
+                .accept => return child,
+                .reject => continue,
+                .skip => if (try self.lastChild(child)) |gchild| return gchild,
+            }
+        }
+
+        return null;
+    }
+
+    fn nextSibling(self: *const TreeWalker, node: *parser.Node) !?*parser.Node {
+        var current = node;
+
+        while (true) {
+            current = (parser.nodeNextSibling(current)) orelse return null;
+
+            switch (try NodeFilter.verify(self.what_to_show, self.filter_func, current)) {
+                .accept => return current,
+                .skip, .reject => continue,
+            }
+        }
+
+        return null;
+    }
+
+    // Get the next sibling that is either acceptable or should be descended into (skip)
+    fn nextSiblingOrSkip(self: *const TreeWalker, node: *parser.Node) !?struct { node: *parser.Node, should_descend: bool } {
+        var current = node;
+
+        while (true) {
+            current = (parser.nodeNextSibling(current)) orelse return null;
+
+            switch (try NodeFilter.verify(self.what_to_show, self.filter_func, current)) {
+                .accept => return .{ .node = current, .should_descend = false },
+                .skip => return .{ .node = current, .should_descend = true },
+                .reject => continue,
+            }
+        }
+
+        return null;
+    }
+
+    fn previousSibling(self: *const TreeWalker, node: *parser.Node) !?*parser.Node {
+        var current = node;
+
+        while (true) {
+            current = (parser.nodePreviousSibling(current)) orelse return null;
+
+            switch (try NodeFilter.verify(self.what_to_show, self.filter_func, current)) {
+                .accept => return current,
+                .skip, .reject => continue,
+            }
+        }
+
+        return null;
+    }
+
+    fn parentNode(self: *const TreeWalker, node: *parser.Node) !?*parser.Node {
+        if (self.root == node) return null;
+
+        var current = node;
+        while (true) {
+            if (current == self.root) return null;
+            current = (parser.nodeParentNode(current)) orelse return null;
+
+            switch (try NodeFilter.verify(self.what_to_show, self.filter_func, current)) {
+                .accept => return current,
+                .reject, .skip => continue,
+            }
+        }
+    }
+
+    pub fn _firstChild(self: *TreeWalker) !?NodeUnion {
+        if (try self.firstChild(self.current_node)) |child| {
+            self.current_node = child;
+            return try Node.toInterface(child);
+        }
+
+        return null;
+    }
+
+    pub fn _lastChild(self: *TreeWalker) !?NodeUnion {
+        if (try self.lastChild(self.current_node)) |child| {
+            self.current_node = child;
+            return try Node.toInterface(child);
+        }
+
+        return null;
+    }
+
+    pub fn _nextNode(self: *TreeWalker) !?NodeUnion {
+        var current = self.current_node;
+
+        // First, try to go to first child of current node
+        if (try self.firstChild(current)) |child| {
+            self.current_node = child;
+            return try Node.toInterface(child);
+        }
+
+        // No acceptable children, move to next node in tree
+        while (current != self.root) {
+            const result = try self.nextSiblingOrSkip(current) orelse {
+                // No next sibling, go up to parent and continue
+                // or, if there is no parent, we're done
+                current = (parser.nodeParentNode(current)) orelse break;
+                continue;
+            };
+
+            if (!result.should_descend) {
+                // This is an .accept node - return it
+                self.current_node = result.node;
+                return try Node.toInterface(result.node);
+            }
+
+            // This is a .skip node - try to find acceptable children within it
+            if (try self.firstChild(result.node)) |child| {
+                self.current_node = child;
+                return try Node.toInterface(child);
+            }
+            // No acceptable children, continue looking at this node's siblings
+            current = result.node;
+        }
+
+        return null;
+    }
+
+    pub fn _nextSibling(self: *TreeWalker) !?NodeUnion {
+        if (try self.nextSibling(self.current_node)) |sibling| {
+            self.current_node = sibling;
+            return try Node.toInterface(sibling);
+        }
+
+        return null;
+    }
+
+    pub fn _parentNode(self: *TreeWalker) !?NodeUnion {
+        if (try self.parentNode(self.current_node)) |parent| {
+            self.current_node = parent;
+            return try Node.toInterface(parent);
+        }
+
+        return null;
+    }
+
+    pub fn _previousNode(self: *TreeWalker) !?NodeUnion {
+        if (self.current_node == self.root) return null;
+
+        var current = self.current_node;
+        while (parser.nodePreviousSibling(current)) |previous| {
+            current = previous;
+
+            switch (try NodeFilter.verify(self.what_to_show, self.filter_func, current)) {
+                .accept => {
+                    // Get last child if it has one.
+                    if (try self.lastChild(current)) |child| {
+                        self.current_node = child;
+                        return try Node.toInterface(child);
+                    }
+
+                    // Otherwise, this node is our previous one.
+                    self.current_node = current;
+                    return try Node.toInterface(current);
+                },
+                .reject => continue,
+                .skip => {
+                    // Get last child if it has one.
+                    if (try self.lastChild(current)) |child| {
+                        self.current_node = child;
+                        return try Node.toInterface(child);
+                    }
+                },
+            }
+        }
+
+        if (current != self.root) {
+            if (try self.parentNode(current)) |parent| {
+                self.current_node = parent;
+                return try Node.toInterface(parent);
+            }
+        }
+
+        return null;
+    }
+
+    pub fn _previousSibling(self: *TreeWalker) !?NodeUnion {
+        if (try self.previousSibling(self.current_node)) |sibling| {
+            self.current_node = sibling;
+            return try Node.toInterface(sibling);
+        }
+
+        return null;
+    }
+};

src/browser/dom/walker.zig

@@ -0,0 +1,102 @@
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const parser = @import("../netsurf.zig");
+
+pub const Walker = union(enum) {
+    walkerDepthFirst: WalkerDepthFirst,
+    walkerChildren: WalkerChildren,
+    walkerNone: WalkerNone,
+
+    pub fn get_next(self: Walker, root: *parser.Node, cur: ?*parser.Node) !?*parser.Node {
+        switch (self) {
+            inline else => |case| return case.get_next(root, cur),
+        }
+    }
+};
+
+// WalkerDepthFirst iterates over the DOM tree to return the next following
+// node or null at the end.
+//
+// This implementation is a zig version of Netsurf code.
+// http://source.netsurf-browser.org/libdom.git/tree/src/html/html_collection.c#n177
+//
+// The iteration is a depth first as required by the specification.
+// https://dom.spec.whatwg.org/#htmlcollection
+// https://dom.spec.whatwg.org/#concept-tree-order
+pub const WalkerDepthFirst = struct {
+    pub fn get_next(_: WalkerDepthFirst, root: *parser.Node, cur: ?*parser.Node) !?*parser.Node {
+        var n = cur orelse root;
+
+        // TODO deinit next
+        if (parser.nodeFirstChild(n)) |next| {
+            return next;
+        }
+
+        // TODO deinit next
+        if (parser.nodeNextSibling(n)) |next| {
+            return next;
+        }
+
+        // TODO deinit parent
+        // Back to the parent of cur.
+        // If cur has no parent, then the iteration is over.
+        var parent = parser.nodeParentNode(n) orelse return null;
+
+        // TODO deinit lastchild
+        var lastchild = parser.nodeLastChild(parent);
+        while (n != root and n == lastchild) {
+            n = parent;
+
+            // TODO deinit parent
+            // Back to the prev's parent.
+            // If prev has no parent, then the loop must stop.
+            parent = parser.nodeParentNode(n) orelse break;
+
+            // TODO deinit lastchild
+            lastchild = parser.nodeLastChild(parent);
+        }
+
+        if (n == root) {
+            return null;
+        }
+
+        return parser.nodeNextSibling(n);
+    }
+};
+
+// WalkerChildren iterates over the root's children only.
+pub const WalkerChildren = struct {
+    pub fn get_next(_: WalkerChildren, root: *parser.Node, cur: ?*parser.Node) !?*parser.Node {
+        // On walk start, we return the first root's child.
+        if (cur == null) return parser.nodeFirstChild(root);
+
+        // If cur is root, then return null.
+        // This is a special case, if the root is included in the walk, we
+        // don't want to go further to find children.
+        if (root == cur.?) return null;
+
+        return parser.nodeNextSibling(cur.?);
+    }
+};
+
+pub const WalkerNone = struct {
+    pub fn get_next(_: WalkerNone, _: *parser.Node, _: ?*parser.Node) !?*parser.Node {
+        return null;
+    }
+};

src/browser/dump.zig

@@ -1,4 +1,4 @@
-// Copyright (C) 2023-2025  Lightpanda (Selecy SAS)
+// Copyright (C) 2023-2024  Lightpanda (Selecy SAS)
 //
 // Francis Bouvier <francis@lightpanda.io>
 // Pierre Tachoire <pierre@lightpanda.io>
@@ -17,344 +17,323 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 const std = @import("std");
-const Page = @import("Page.zig");
-const Node = @import("webapi/Node.zig");
-const Slot = @import("webapi/element/html/Slot.zig");
-const IFrame = @import("webapi/element/html/IFrame.zig");
 
-const IS_DEBUG = @import("builtin").mode == .Debug;
+const parser = @import("netsurf.zig");
+const Page = @import("page.zig").Page;
+const Walker = @import("dom/walker.zig").WalkerChildren;
 
 pub const Opts = struct {
-    with_base: bool = false,
-    with_frames: bool = false,
-    strip: Opts.Strip = .{},
-    shadow: Opts.Shadow = .rendered,
+    // set to include element shadowroots in the dump
+    page: ?*const Page = null,
 
-    pub const Strip = struct {
+    strip_mode: StripMode = .{},
+
+    pub const StripMode = struct {
         js: bool = false,
         ui: bool = false,
         css: bool = false,
     };
-
-    pub const Shadow = enum {
-        // Skip shadow DOM entirely (innerHTML/outerHTML)
-        skip,
-
-        // Dump everyhting (like "view source")
-        complete,
-
-        // Resolve slot elements (like what actually gets rendered)
-        rendered,
-    };
 };
 
-pub fn root(doc: *Node.Document, opts: Opts, writer: *std.Io.Writer, page: *Page) !void {
-    if (doc.is(Node.Document.HTMLDocument)) |html_doc| {
-        blk: {
-            // Ideally we just render the doctype which is part of the document
-            if (doc.asNode().firstChild()) |first| {
-                if (first._type == .document_type) {
-                    break :blk;
-                }
-            }
-            // But if the doc has no child, or the first child isn't a doctype
-            // well force it.
-            try writer.writeAll("<!DOCTYPE html>");
-        }
+// writer must be a std.io.Writer
+pub fn writeHTML(doc: *parser.Document, opts: Opts, writer: *std.Io.Writer) !void {
+    try writer.writeAll("<!DOCTYPE html>\n");
+    try writeChildren(parser.documentToNode(doc), opts, writer);
+    try writer.writeAll("\n");
+}
 
-        if (opts.with_base) {
-            const parent = if (html_doc.getHead()) |head| head.asNode() else doc.asNode();
-            const base = try doc.createElement("base", null, page);
-            try base.setAttributeSafe(comptime .wrap("base"), .wrap(page.base()), page);
-            _ = try parent.insertBefore(base.asNode(), parent.firstChild(), page);
-        }
+// Spec: https://www.w3.org/TR/xml/#sec-prolog-dtd
+pub fn writeDocType(doc_type: *parser.DocumentType, writer: *std.Io.Writer) !void {
+    try writer.writeAll("<!DOCTYPE ");
+    try writer.writeAll(try parser.documentTypeGetName(doc_type));
+
+    const public_id = parser.documentTypeGetPublicId(doc_type);
+    const system_id = parser.documentTypeGetSystemId(doc_type);
+    if (public_id.len != 0 and system_id.len != 0) {
+        try writer.writeAll(" PUBLIC \"");
+        try writeEscapedAttributeValue(writer, public_id);
+        try writer.writeAll("\" \"");
+        try writeEscapedAttributeValue(writer, system_id);
+        try writer.writeAll("\"");
+    } else if (public_id.len != 0) {
+        try writer.writeAll(" PUBLIC \"");
+        try writeEscapedAttributeValue(writer, public_id);
+        try writer.writeAll("\"");
+    } else if (system_id.len != 0) {
+        try writer.writeAll(" SYSTEM \"");
+        try writeEscapedAttributeValue(writer, system_id);
+        try writer.writeAll("\"");
     }
-
-    return deep(doc.asNode(), opts, writer, page);
+    // Internal subset is not implemented
+    try writer.writeAll(">");
 }
 
-pub fn deep(node: *Node, opts: Opts, writer: *std.Io.Writer, page: *Page) error{WriteFailed}!void {
-    return _deep(node, opts, false, writer, page);
-}
-
-fn _deep(node: *Node, opts: Opts, comptime force_slot: bool, writer: *std.Io.Writer, page: *Page) error{WriteFailed}!void {
-    switch (node._type) {
-        .cdata => |cd| {
-            if (node.is(Node.CData.Comment)) |_| {
-                try writer.writeAll("<!--");
-                try writer.writeAll(cd.getData().str());
-                try writer.writeAll("-->");
-            } else if (node.is(Node.CData.ProcessingInstruction)) |pi| {
-                try writer.writeAll("<?");
-                try writer.writeAll(pi._target);
-                try writer.writeAll(" ");
-                try writer.writeAll(cd.getData().str());
-                try writer.writeAll("?>");
-            } else {
-                if (shouldEscapeText(node._parent)) {
-                    try writeEscapedText(cd.getData().str(), writer);
-                } else {
-                    try writer.writeAll(cd.getData().str());
-                }
-            }
-        },
-        .element => |el| {
-            if (shouldStripElement(el, opts)) {
+pub fn writeNode(node: *parser.Node, opts: Opts, writer: *std.Io.Writer) anyerror!void {
+    switch (parser.nodeType(node)) {
+        .element => {
+            // open the tag
+            const tag_type = try parser.nodeHTMLGetTagType(node) orelse .undef;
+            if (try isStripped(tag_type, node, opts.strip_mode)) {
                 return;
             }
 
-            // When opts.shadow == .rendered, we normally skip any element with
-            // a slot attribute. Only the "active" element will get rendered into
-            // the <slot name="X">. However, the `deep` function is itself used
-            // to render that "active" content, so when we're trying to render
-            // it, we don't want to skip it.
-            if ((comptime force_slot == false) and opts.shadow == .rendered) {
-                if (el.getAttributeSafe(comptime .wrap("slot"))) |_| {
-                    // Skip - will be rendered by the Slot if it's the active container
-                    return;
+            const tag = try parser.nodeLocalName(node);
+            try writer.writeAll("<");
+            try writer.writeAll(tag);
+
+            // write the attributes
+            const _map = try parser.nodeGetAttributes(node);
+            if (_map) |map| {
+                const ln = try parser.namedNodeMapGetLength(map);
+                for (0..ln) |i| {
+                    const attr = try parser.namedNodeMapItem(map, @intCast(i)) orelse break;
+                    try writer.writeAll(" ");
+                    try writer.writeAll(try parser.attributeGetName(attr));
+                    try writer.writeAll("=\"");
+                    const attribute_value = try parser.attributeGetValue(attr) orelse "";
+                    try writeEscapedAttributeValue(writer, attribute_value);
+                    try writer.writeAll("\"");
                 }
             }
 
-            try el.format(writer);
+            try writer.writeAll(">");
 
-            if (opts.shadow == .rendered) {
-                if (el.is(Slot)) |slot| {
-                    try dumpSlotContent(slot, opts, writer, page);
-                    return writer.writeAll("</slot>");
-                }
-            }
-            if (opts.shadow != .skip) {
-                if (page._element_shadow_roots.get(el)) |shadow| {
-                    try children(shadow.asNode(), opts, writer, page);
-                    // In rendered mode, light DOM is only shown through slots, not directly
-                    if (opts.shadow == .rendered) {
-                        // Skip rendering light DOM children
-                        if (!isVoidElement(el)) {
-                            try writer.writeAll("</");
-                            try writer.writeAll(el.getTagNameDump());
-                            try writer.writeByte('>');
-                        }
-                        return;
+            if (opts.page) |page| {
+                if (page.getNodeState(node)) |state| {
+                    if (state.shadow_root) |sr| {
+                        try writeChildren(@ptrCast(@alignCast(sr.proto)), opts, writer);
                     }
                 }
             }
 
-            if (opts.with_frames and el.is(IFrame) != null) {
-                const frame = el.as(IFrame);
-                if (frame.getContentDocument()) |doc| {
-                    // A frame's document should always ahave a page, but
-                    // I'm not willing to crash a release build on that assertion.
-                    if (comptime IS_DEBUG) {
-                        std.debug.assert(doc._page != null);
-                    }
-                    if (doc._page) |frame_page| {
-                        try writer.writeByte('\n');
-                        root(doc, opts, writer, frame_page) catch return error.WriteFailed;
-                        try writer.writeByte('\n');
-                    }
-                }
+            // void elements can't have any content.
+            if (try isVoid(parser.nodeToElement(node))) return;
+
+            if (tag_type == .script) {
+                try writer.writeAll(parser.nodeTextContent(node) orelse "");
             } else {
-                try children(node, opts, writer, page);
+                // write the children
+                // TODO avoid recursion
+                try writeChildren(node, opts, writer);
             }
 
-            if (!isVoidElement(el)) {
-                try writer.writeAll("</");
-                try writer.writeAll(el.getTagNameDump());
-                try writer.writeByte('>');
-            }
+            // close the tag
+            try writer.writeAll("</");
+            try writer.writeAll(tag);
+            try writer.writeAll(">");
         },
-        .document => try children(node, opts, writer, page),
-        .document_type => |dt| {
-            try writer.writeAll("<!DOCTYPE ");
-            try writer.writeAll(dt.getName());
-
-            const public_id = dt.getPublicId();
-            const system_id = dt.getSystemId();
-            if (public_id.len != 0 and system_id.len != 0) {
-                try writer.writeAll(" PUBLIC \"");
-                try writeEscapedText(public_id, writer);
-                try writer.writeAll("\" \"");
-                try writeEscapedText(system_id, writer);
-                try writer.writeByte('"');
-            } else if (public_id.len != 0) {
-                try writer.writeAll(" PUBLIC \"");
-                try writeEscapedText(public_id, writer);
-                try writer.writeByte('"');
-            } else if (system_id.len != 0) {
-                try writer.writeAll(" SYSTEM \"");
-                try writeEscapedText(system_id, writer);
-                try writer.writeByte('"');
-            }
-            try writer.writeAll(">\n");
+        .text => {
+            const v = parser.nodeValue(node) orelse return;
+            try writeEscapedTextNode(writer, v);
         },
-        .document_fragment => try children(node, opts, writer, page),
-        .attribute => {
-            // Not called normally, but can be called via XMLSerializer.serializeToString
-            // in which case it should return an empty string
-            try writer.writeAll("");
+        .cdata_section => {
+            const v = parser.nodeValue(node) orelse return;
+            try writer.writeAll("<![CDATA[");
+            try writer.writeAll(v);
+            try writer.writeAll("]]>");
         },
+        .comment => {
+            const v = parser.nodeValue(node) orelse return;
+            try writer.writeAll("<!--");
+            try writer.writeAll(v);
+            try writer.writeAll("-->");
+        },
+        // TODO handle processing instruction dump
+        .processing_instruction => return,
+        // document fragment is outside of the main document DOM, so we
+        // don't output it.
+        .document_fragment => return,
+        // document will never be called, but required for completeness.
+        .document => return,
+        // done globally instead, but required for completeness. Only the outer DOCTYPE should be written
+        .document_type => return,
+        // deprecated
+        .attribute => return,
+        .entity_reference => return,
+        .entity => return,
+        .notation => return,
     }
 }
 
-pub fn children(parent: *Node, opts: Opts, writer: *std.Io.Writer, page: *Page) !void {
-    var it = parent.childrenIterator();
-    while (it.next()) |child| {
-        try deep(child, opts, writer, page);
+// writer must be a std.io.Writer
+pub fn writeChildren(root: *parser.Node, opts: Opts, writer: *std.Io.Writer) !void {
+    const walker = Walker{};
+    var next: ?*parser.Node = null;
+    while (true) {
+        next = try walker.get_next(root, next) orelse break;
+        try writeNode(next.?, opts, writer);
     }
 }
 
-pub fn toJSON(node: *Node, writer: *std.json.Stringify) !void {
-    try writer.beginObject();
-
-    try writer.objectField("type");
-    switch (node.type) {
-        .cdata => {
-            try writer.write("cdata");
-        },
-        .document => {
-            try writer.write("document");
-        },
-        .document_type => {
-            try writer.write("document_type");
-        },
-        .element => |*el| {
-            try writer.write("element");
-            try writer.objectField("tag");
-            try writer.write(el.tagName());
-
-            try writer.objectField("attributes");
-            try writer.beginObject();
-            var it = el.attributeIterator();
-            while (it.next()) |attr| {
-                try writer.objectField(attr.name);
-                try writer.write(attr.value);
-            }
-            try writer.endObject();
-        },
+fn isStripped(tag_type: parser.Tag, node: *parser.Node, strip_mode: Opts.StripMode) !bool {
+    if (strip_mode.js and try isJsRelated(tag_type, node)) {
+        return true;
     }
 
-    try writer.objectField("children");
-    try writer.beginArray();
-    var it = node.childrenIterator();
-    while (it.next()) |child| {
-        try toJSON(child, writer);
-    }
-    try writer.endArray();
-    try writer.endObject();
-}
-
-fn dumpSlotContent(slot: *Slot, opts: Opts, writer: *std.Io.Writer, page: *Page) !void {
-    const assigned = slot.assignedNodes(null, page) catch return;
-
-    if (assigned.len > 0) {
-        for (assigned) |assigned_node| {
-            try _deep(assigned_node, opts, true, writer, page);
-        }
-    } else {
-        try children(slot.asNode(), opts, writer, page);
-    }
-}
-
-fn isVoidElement(el: *const Node.Element) bool {
-    return switch (el._type) {
-        .html => |html| switch (html._type) {
-            .br, .hr, .img, .input, .link, .meta => true,
-            else => false,
-        },
-        .svg => false,
-    };
-}
-
-fn shouldStripElement(el: *const Node.Element, opts: Opts) bool {
-    const tag_name = el.getTagNameDump();
-
-    if (opts.strip.js) {
-        if (std.mem.eql(u8, tag_name, "script")) return true;
-        if (std.mem.eql(u8, tag_name, "noscript")) return true;
-
-        if (std.mem.eql(u8, tag_name, "link")) {
-            if (el.getAttributeSafe(comptime .wrap("as"))) |as| {
-                if (std.mem.eql(u8, as, "script")) return true;
-            }
-            if (el.getAttributeSafe(comptime .wrap("rel"))) |rel| {
-                if (std.mem.eql(u8, rel, "modulepreload") or std.mem.eql(u8, rel, "preload")) {
-                    if (el.getAttributeSafe(comptime .wrap("as"))) |as| {
-                        if (std.mem.eql(u8, as, "script")) return true;
-                    }
-                }
-            }
-        }
+    if (strip_mode.css and try isCssRelated(tag_type, node)) {
+        return true;
     }
 
-    if (opts.strip.css or opts.strip.ui) {
-        if (std.mem.eql(u8, tag_name, "style")) return true;
-
-        if (std.mem.eql(u8, tag_name, "link")) {
-            if (el.getAttributeSafe(comptime .wrap("rel"))) |rel| {
-                if (std.mem.eql(u8, rel, "stylesheet")) return true;
-            }
-        }
+    if (strip_mode.ui and try isUIRelated(tag_type, node)) {
+        return true;
     }
-
-    if (opts.strip.ui) {
-        if (std.mem.eql(u8, tag_name, "img")) return true;
-        if (std.mem.eql(u8, tag_name, "picture")) return true;
-        if (std.mem.eql(u8, tag_name, "video")) return true;
-        if (std.mem.eql(u8, tag_name, "audio")) return true;
-        if (std.mem.eql(u8, tag_name, "svg")) return true;
-        if (std.mem.eql(u8, tag_name, "canvas")) return true;
-        if (std.mem.eql(u8, tag_name, "iframe")) return true;
-    }
-
     return false;
 }
 
-fn shouldEscapeText(node_: ?*Node) bool {
-    const node = node_ orelse return true;
-    if (node.is(Node.Element.Html.Script) != null) {
-        return false;
+fn isJsRelated(tag_type: parser.Tag, node: *parser.Node) !bool {
+    if (tag_type == .script) {
+        return true;
     }
-    // When scripting is enabled, <noscript> is a raw text element per the HTML spec
-    // (https://html.spec.whatwg.org/multipage/parsing.html#serialising-html-fragments).
-    // Its text content must not be HTML-escaped during serialization.
-    if (node.is(Node.Element.Html.Generic)) |generic| {
-        if (generic._tag == .noscript) return false;
+    if (tag_type == .link) {
+        const el = parser.nodeToElement(node);
+        const as = try parser.elementGetAttribute(el, "as") orelse return false;
+        if (!std.ascii.eqlIgnoreCase(as, "script")) {
+            return false;
+        }
+
+        const rel = try parser.elementGetAttribute(el, "rel") orelse return false;
+        return std.ascii.eqlIgnoreCase(rel, "preload");
     }
-    return true;
+    return false;
 }
-fn writeEscapedText(text: []const u8, writer: *std.Io.Writer) !void {
-    // Fast path: if no special characters, write directly
-    const first_special = std.mem.indexOfAnyPos(u8, text, 0, &.{ '&', '<', '>', 194 }) orelse {
-        return writer.writeAll(text);
+
+fn isCssRelated(tag_type: parser.Tag, node: *parser.Node) !bool {
+    if (tag_type == .style) {
+        return true;
+    }
+    if (tag_type == .link) {
+        const el = parser.nodeToElement(node);
+        const rel = try parser.elementGetAttribute(el, "rel") orelse return false;
+        return std.ascii.eqlIgnoreCase(rel, "stylesheet");
+    }
+    return false;
+}
+
+fn isUIRelated(tag_type: parser.Tag, node: *parser.Node) !bool {
+    if (try isCssRelated(tag_type, node)) {
+        return true;
+    }
+    if (tag_type == .img or tag_type == .picture or tag_type == .video) {
+        return true;
+    }
+    if (tag_type == .undef) {
+        const name = try parser.nodeLocalName(node);
+        if (std.mem.eql(u8, name, "svg")) {
+            return true;
+        }
+    }
+    return false;
+}
+
+// area, base, br, col, embed, hr, img, input, link, meta, source, track, wbr
+// https://html.spec.whatwg.org/#void-elements
+fn isVoid(elem: *parser.Element) !bool {
+    const tag = try parser.elementTag(elem);
+    return switch (tag) {
+        .area, .base, .br, .col, .embed, .hr, .img, .input, .link => true,
+        .meta, .source, .track, .wbr => true,
+        else => false,
     };
+}
 
-    try writer.writeAll(text[0..first_special]);
-    var remaining = try writeEscapedByte(text, first_special, writer);
-
-    while (std.mem.indexOfAnyPos(u8, remaining, 0, &.{ '&', '<', '>', 194 })) |offset| {
-        try writer.writeAll(remaining[0..offset]);
-        remaining = try writeEscapedByte(remaining, offset, writer);
-    }
-
-    if (remaining.len > 0) {
-        try writer.writeAll(remaining);
+fn writeEscapedTextNode(writer: *std.Io.Writer, value: []const u8) !void {
+    var v = value;
+    while (v.len > 0) {
+        const index = std.mem.indexOfAnyPos(u8, v, 0, &.{ '&', '<', '>', 194 }) orelse {
+            return writer.writeAll(v);
+        };
+        try writer.writeAll(v[0..index]);
+        switch (v[index]) {
+            '&' => try writer.writeAll("&amp;"),
+            '<' => try writer.writeAll("&lt;"),
+            '>' => try writer.writeAll("&gt;"),
+            194 => {
+                // non breaking space
+                if (v.len > index + 1 and v[index + 1] == 160) {
+                    try writer.writeAll("&nbsp;");
+                    v = v[index + 2 ..];
+                    continue;
+                }
+                try writer.writeByte(194);
+            },
+            else => unreachable,
+        }
+        v = v[index + 1 ..];
     }
 }
 
-fn writeEscapedByte(input: []const u8, index: usize, writer: *std.Io.Writer) ![]const u8 {
-    switch (input[index]) {
-        '&' => try writer.writeAll("&amp;"),
-        '<' => try writer.writeAll("&lt;"),
-        '>' => try writer.writeAll("&gt;"),
-        194 => {
-            // non breaking space
-            if (input.len > index + 1 and input[index + 1] == 160) {
-                try writer.writeAll("&nbsp;");
-                return input[index + 2 ..];
-            }
-            try writer.writeByte(194);
-        },
-        else => unreachable,
+fn writeEscapedAttributeValue(writer: *std.Io.Writer, value: []const u8) !void {
+    var v = value;
+    while (v.len > 0) {
+        const index = std.mem.indexOfAnyPos(u8, v, 0, &.{ '&', '<', '>', '"' }) orelse {
+            return writer.writeAll(v);
+        };
+        try writer.writeAll(v[0..index]);
+        switch (v[index]) {
+            '&' => try writer.writeAll("&amp;"),
+            '<' => try writer.writeAll("&lt;"),
+            '>' => try writer.writeAll("&gt;"),
+            '"' => try writer.writeAll("&quot;"),
+            else => unreachable,
+        }
+        v = v[index + 1 ..];
     }
-    return input[index + 1 ..];
+}
+
+const testing = std.testing;
+test "dump.writeHTML" {
+    parser.init();
+    defer parser.deinit();
+
+    try testWriteHTML(
+        "<div id=\"content\">Over 9000!</div>",
+        "<div id=\"content\">Over 9000!</div>",
+    );
+
+    try testWriteHTML(
+        "<root><!-- a comment --></root>",
+        "<root><!-- a comment --></root>",
+    );
+
+    try testWriteHTML(
+        "<p>&lt; &gt; &amp;</p>",
+        "<p>&lt; &gt; &amp;</p>",
+    );
+
+    try testWriteHTML(
+        "<p id=\"&quot;&gt;&lt;&amp;&quot;''\">wat?</p>",
+        "<p id='\">&lt;&amp;&quot;&#39;&apos;'>wat?</p>",
+    );
+
+    try testWriteFullHTML(
+        \\<!DOCTYPE html>
+        \\<html><head><title>It's over what?</title><meta name="a" value="b">
+        \\</head><body>9000</body></html>
+        \\
+    , "<html><title>It's over what?</title><meta name=a value=\"b\">\n<body>9000");
+
+    try testWriteHTML(
+        "<p>hi</p><script>alert(power > 9000)</script>",
+        "<p>hi</p><script>alert(power > 9000)</script>",
+    );
+}
+
+fn testWriteHTML(comptime expected_body: []const u8, src: []const u8) !void {
+    const expected =
+        "<!DOCTYPE html>\n<html><head></head><body>" ++
+        expected_body ++
+        "</body></html>\n";
+    return testWriteFullHTML(expected, src);
+}
+
+fn testWriteFullHTML(comptime expected: []const u8, src: []const u8) !void {
+    var aw = std.Io.Writer.Allocating.init(testing.allocator);
+    defer aw.deinit();
+
+    const doc_html = try parser.documentHTMLParseFromStr(src);
+    defer parser.documentHTMLClose(doc_html) catch {};
+
+    const doc = parser.documentHTMLToDocument(doc_html);
+    try writeHTML(doc, .{}, &aw.writer);
+    try testing.expectEqualStrings(expected, aw.written());
 }

src/browser/encoding/TextDecoder.zig

@@ -0,0 +1,102 @@
+// Copyright (C) 2023-2025  Lightpanda (Selecy SAS)
+//
+// Francis Bouvier <francis@lightpanda.io>
+// Pierre Tachoire <pierre@lightpanda.io>
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+const std = @import("std");
+const log = @import("../../log.zig");
+
+const Page = @import("../page.zig").Page;
+
+// https://encoding.spec.whatwg.org/#interface-textdecoder
+const TextDecoder = @This();
+
+const SupportedLabels = enum {
+    utf8,
+    @"utf-8",
+    @"unicode-1-1-utf-8",
+};
+
+const Options = struct {
+    fatal: bool = false,
+    ignoreBOM: bool = false,
+};
+
+fatal: bool,
+ignore_bom: bool,
+stream: std.ArrayList(u8),
+
+pub fn constructor(label_: ?[]const u8, opts_: ?Options) !TextDecoder {
+    if (label_) |l| {
+        _ = std.meta.stringToEnum(SupportedLabels, l) orelse {
+            log.warn(.web_api, "not implemented", .{ .feature = "TextDecoder label", .label = l });
+            return error.NotImplemented;
+        };
+    }
+    const opts = opts_ orelse Options{};
+    return .{
+        .stream = .empty,
+        .fatal = opts.fatal,
+        .ignore_bom = opts.ignoreBOM,
+    };
+}
+
+pub fn get_encoding(_: *const TextDecoder) []const u8 {
+    return "utf-8";
+}
+
+pub fn get_ignoreBOM(self: *const TextDecoder) bool {
+    return self.ignore_bom;
+}
+
+pub fn get_fatal(self: *const TextDecoder) bool {
+    return self.fatal;
+}
+
+const DecodeOptions = struct {
+    stream: bool = false,
+};
+pub fn _decode(self: *TextDecoder, str_: ?[]const u8, opts_: ?DecodeOptions, page: *Page) ![]const u8 {
+    var str = str_ orelse return "";
+    const opts: DecodeOptions = opts_ orelse .{};
+
+    if (self.stream.items.len > 0) {
+        try self.stream.appendSlice(page.arena, str);
+        str = self.stream.items;
+    }
+
+    if (self.fatal and !std.unicode.utf8ValidateSlice(str)) {
+        if (opts.stream) {
+            if (self.stream.items.len == 0) {
+                try self.stream.appendSlice(page.arena, str);
+            }
+            return "";
+        }
+        return error.InvalidUtf8;
+    }
+
+    self.stream.clearRetainingCapacity();
+    if (self.ignore_bom == false and std.mem.startsWith(u8, str, &.{ 0xEF, 0xBB, 0xBF })) {
+        return str[3..];
+    }
+
+    return str;
+}
+
+const testing = @import("../../testing.zig");
+test "Browser: Encoding.TextDecoder" {
+    try testing.htmlRunner("encoding/decoder.html");
+}

src/browser/encoding/TextEncoder.zig

@@ -16,33 +16,33 @@
 // You should have received a copy of the GNU Affero General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
+const std = @import("std");
+
 const js = @import("../js/js.zig");
 
-const Document = @import("Document.zig");
-const Node = @import("Node.zig");
+// https://encoding.spec.whatwg.org/#interface-textencoder
+const TextEncoder = @This();
 
-const XMLDocument = @This();
-
-_proto: *Document,
-
-pub fn asDocument(self: *XMLDocument) *Document {
-    return self._proto;
+pub fn constructor() !TextEncoder {
+    return .{};
 }
 
-pub fn asNode(self: *XMLDocument) *Node {
-    return self._proto.asNode();
+pub fn get_encoding(_: *const TextEncoder) []const u8 {
+    return "utf-8";
 }
 
-pub fn asEventTarget(self: *XMLDocument) *@import("EventTarget.zig") {
-    return self._proto.asEventTarget();
+pub fn _encode(_: *const TextEncoder, v: []const u8) !js.TypedArray(u8) {
+    // Ensure the input is a valid utf-8
+    // It seems chrome accepts invalid utf-8 sequence.
+    //
+    if (!std.unicode.utf8ValidateSlice(v)) {
+        return error.InvalidUtf8;
+    }
+
+    return .{ .values = v };
 }
 
-pub const JsApi = struct {
-    pub const bridge = js.Bridge(XMLDocument);
-
-    pub const Meta = struct {
-        pub const name = "XMLDocument";
-        pub const prototype_chain = bridge.prototypeChain();
-        pub var class_id: bridge.ClassId = undefined;
-    };
-};
+const testing = @import("../../testing.zig");
+test "Browser: Encoding.TextEncoder" {
+    try testing.htmlRunner("encoding/encoder.html");
+}

src/browser/encoding/encoding.zig

@@ -16,20 +16,7 @@
 // You should have received a copy of the GNU Affero General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
-const std = @import("std");
-const js = @import("js.zig");
-
-const v8 = js.v8;
-
-const Integer = @This();
-
-handle: *const v8.Integer,
-
-pub fn init(isolate: *v8.Isolate, value: anytype) Integer {
-    const handle = switch (@TypeOf(value)) {
-        i8, i16, i32 => v8.v8__Integer__New(isolate, value).?,
-        u8, u16, u32 => v8.v8__Integer__NewFromUnsigned(isolate, value).?,
-        else => |T| @compileError("cannot create v8::Integer from: " ++ @typeName(T)),
-    };
-    return .{ .handle = handle };
-}
+pub const Interfaces = .{
+    @import("TextDecoder.zig"),
+    @import("TextEncoder.zig"),
+};