koffi 1.3.5 → 1.3.8

package/doc/dist/html/_sources/benchmarks.md.txt

@@ -1,5 +1,7 @@
 # Benchmarks
 
+## Overview
+
 Here is a quick overview of the execution time of Koffi calls on three benchmarks, where it is compared to a theoretical ideal FFI implementation (approximated with pre-compiled static N-API glue code):
 
 - The first benchmark is based on `rand()` calls
@@ -8,14 +10,18 @@ Here is a quick overview of the execution time of Koffi calls on three benchmark
 
 <table style="margin: 0 auto;">
     <tr>
-        <td><a href="_static/perf_linux_20220623_2.png" target="_blank"><img src="_static/perf_linux_20220623_2.png" alt="Linux performance" style="width: 350px;"/></a></td>
-        <td><a href="_static/perf_windows_20220623_2.png" target="_blank"><img src="_static/perf_windows_20220623_2.png" alt="Windows performance" style="width: 350px;"/></a></td>
+        <td><a href="_static/perf_linux_20220628.png" target="_blank"><img src="_static/perf_linux_20220628.png" alt="Linux performance" style="width: 350px;"/></a></td>
+        <td><a href="_static/perf_windows_20220628.png" target="_blank"><img src="_static/perf_windows_20220628.png" alt="Windows performance" style="width: 350px;"/></a></td>
     </tr>
 </table>
 
 These results are detailed and explained below, and compared to node-ffi/node-ffi-napi.
 
-## rand results
+## Linux x86_64
+
+The results presented below were measured on my x86_64 Linux machine (Intel® Core™ i5-4460).
+
+### rand results
 
 This test is based around repeated calls to a simple standard C function atoi, and has three implementations:
 
@@ -23,95 +29,109 @@ This test is based around repeated calls to a simple standard C function atoi, a
 - the second one calls atoi through Koffi
 - the third one uses the official Node.js FFI implementation, node-ffi-napi
 
+Benchmark     | Iteration time | Relative performance | Overhead
+------------- | -------------- | -------------------- | --------
+rand_napi     | 644 ns         | x1.00                | (ref)
+rand_koffi    | 950 ns         | x0.68                | +48%
+rand_node_ffi | 30350 ns       | x0.02                | +4613%
+
 Because rand is a pretty small function, the FFI overhead is clearly visible.
 
-### Linux x86_64
+### atoi results
 
-The results below were measured on my x86_64 Linux machine (AMD® Ryzen™ 7 4700U):
+This test is similar to the rand one, but it is based on atoi, which takes a string parameter. Javascript (V8) to C string conversion is relatively slow and heavy.
 
-Benchmark     | Iterations | Total time  | Relative performance | Overhead
-------------- | ---------- | ----------- | -------------------- | ----------
-rand_napi     | 20000000   | 1.44s       | (baseline)           | (baseline)
-rand_koffi    | 20000000   | 2.60s       | x0.55                | +81%
-rand_node_ffi | 20000000   | 107.58s     | x0.01                | +7400%
+Benchmark     | Iteration time | Relative performance | Overhead
+------------- | -------------- | -------------------- | --------
+atoi_napi     | 1104 ns        | x1.00                | (ref)
+atoi_koffi    | 1778 ns        | x0.62                | +61%
+atoi_node_ffi | 125300 ns      | x0.009               | +11250%
 
-### Windows x86_64
+Because atoi is a pretty small function, the FFI overhead is clearly visible.
 
-The results below were measured on my x86_64 Windows machine (Intel® Core™ i5-4460):
+### Raylib results
+
+This benchmark uses the CPU-based image drawing functions in Raylib. The calls are much heavier than in the atoi benchmark, thus the FFI overhead is reduced. In this implementation, Koffi is compared to:
 
-Benchmark     | Iterations | Total time  | Relative performance | Overhead
-------------- | ---------- | ----------- | -------------------- | ----------
-rand_napi     | 20000000   | 2.10s       | (baseline)           | (baseline)
-rand_koffi    | 20000000   | 3.87s       | x0.54                | +84%
-rand_node_ffi | 20000000   | 87.84s      | x0.02                | +4100%
+- Baseline: Full C++ version of the code (no JS)
+- [node-raylib](https://github.com/RobLoach/node-raylib): This is a native wrapper implemented with N-API
 
-## atoi results
+Benchmark          | Iteration time | Relative performance | Overhead
+------------------ | -------------- | -------------------- | --------
+raylib_cc          | 215.7 µs       | x1.20                | -17%
+raylib_node_raylib | 258.9 µs       | x1.00                | (ref)
+raylib_koffi       | 311.6 µs       | x0.83                | +20%
+raylib_node_ffi    | 928.4 µs       | x0.28                | +259%
 
-This test is similar to the rand one, but it is based on atoi, which takes a string parameter. Javascript (V8) to C string conversion is relatively slow and heavy.
+## Windows x86_64
 
-Because rand is a pretty small function, the FFI overhead is clearly visible.
+The results presented below were measured on my x86_64 Windows machine (Intel® Core™ i5-4460).
+
+### rand results
 
-### Linux x86_64
+This test is based around repeated calls to a simple standard C function atoi, and has three implementations:
 
-The results below were measured on my x86_64 Linux machine (AMD® Ryzen™ 7 4700U):
+- the first one is the reference, it calls atoi through an N-API module, and is close to the theoretical limit of a perfect (no overhead) Node.js > C FFI implementation (pre-compiled static glue code)
+- the second one calls atoi through Koffi
+- the third one uses the official Node.js FFI implementation, node-ffi-napi
 
-Benchmark     | Iterations | Total time  | Relative performance | Overhead
-------------- | ---------- | ----------- | -------------------- | ----------
-atoi_napi     | 20000000   | 2.97s       | (baseline)           | (baseline)
-atoi_koffi    | 20000000   | 5.07s       | x0.58                | +71%
-atoi_node_ffi | 20000000   | 693.16s     | x0.005               | +23000%
+Benchmark     | Iteration time | Relative performance | Overhead
+------------- | -------------- | -------------------- | --------
+rand_napi     | 965 ns         | x1.00                | (ref)
+rand_koffi    | 1248 ns        | x0.77                | +29%
+rand_node_ffi | 41500 ns       | x0.02                | +4203%
 
-### Windows x86_64
+Because rand is a pretty small function, the FFI overhead is clearly visible.
 
-The results below were measured on my x86_64 Windows machine (Intel® Core™ i5-4460):
+### atoi results
 
-Benchmark     | Iterations | Total time  | Relative performance | Overhead
-------------- | ---------- | ----------- | -------------------- | ----------
-atoi_napi     | 20000000   | 2.97s       | (baseline)           | (baseline)
-atoi_koffi    | 20000000   | 5.91s       | x0.50                | +99%
-atoi_node_ffi | 20000000   | 479.34s     | x0.006               | +16000%
+This test is similar to the rand one, but it is based on atoi, which takes a string parameter. Javascript (V8) to C string conversion is relatively slow and heavy.
 
-## Raylib results
+The results below were measured on my x86_64 Windows machine (Intel® Core™ i5-4460):
 
-This benchmark uses the CPU-based image drawing functions in Raylib. The calls are much heavier than in the atoi benchmark, thus the FFI overhead is reduced. In this implementation, Koffi is compared to:
+Benchmark     | Iteration time | Relative performance | Overhead
+------------- | -------------- | -------------------- | --------
+atoi_napi     | 1393 ns        | x1.00                | (ref)
+atoi_koffi    | 2246 ns        | x0.62                | +61%
+atoi_node_ffi | 157550 ns      | x0.009               | +11210%
 
-- Baseline: Full C++ version of the code (no JS)
-- [node-raylib](https://github.com/RobLoach/node-raylib): This is a native wrapper implemented with N-API
+Because atoi is a pretty small function, the FFI overhead is clearly visible.
 
-### Linux x86_64
+### Raylib results
 
-The results below were measured on my x86_64 Linux machine (AMD® Ryzen™ 7 4700U):
+This benchmark uses the CPU-based image drawing functions in Raylib. The calls are much heavier than in the atoi benchmark, thus the FFI overhead is reduced. In this implementation, Koffi is compared to:
 
-Benchmark          | Iterations | Total time  | Relative performance | Overhead
----------------    | ---------- | ----------- | -------------------- | ----------
-raylib_cc          | 100        | 9.31s       | x1.17                | -15%
-raylib_node_raylib | 100        | 10.90s      | (baseline)           | (baseline)
-raylib_koffi       | 100        | 12.86s      | x0.84                | +18%
-raylib_node_ffi    | 100        | 35.76s      | x0.30                | +228%
+- [node-raylib](https://github.com/RobLoach/node-raylib) (baseline): This is a native wrapper implemented with N-API
+- raylib_cc: C++ implementation of the benchmark, without any Javascript
 
-### Windows x86_64
+Benchmark          | Iteration time | Relative performance | Overhead
+------------------ | -------------- | -------------------- | --------
+raylib_cc          | 211.8 µs       | x1.25                | -20%
+raylib_node_raylib | 264.4 µs       | x1.00                | (ref)
+raylib_koffi       | 318.9 µs       | x0.83                | +21%
+raylib_node_ffi    | 1146.2 µs      | x0.23                | +334%
 
-The results below were measured on my x86_64 Windows machine (Intel® Core™ i5-4460):
+Please note that in order to get fair numbers for raylib_node_raylib, it was recompiled with clang-cl before running the benchmark with the following commands:
 
-Benchmark          | Iterations | Total time  | Relative performance | Overhead
----------------    | ---------- | ----------- | -------------------- | ----------
-raylib_cc          | 100        | 10.67s      | x1.17                | -12%
-raylib_node_raylib | 100        | 12.05s      | (baseline)           | (baseline)
-raylib_koffi       | 100        | 14.84s      | x0.81                | +23%
-raylib_node_ffi    | 100        | 44.63s      | x0.27                | +270%
+```batch
+cd node_modules\raylib
+rmdir /S /Q bin build
+npx cmake-js compile -t ClangCL
+```
 
 ## Running benchmarks
 
 Open a console, go to `koffi/benchmark` and run `../../cnoke/cnoke.js` (or `node ..\..\cnoke\cnoke.js` on Windows) before doing anything else.
 
+Please note that all benchmark results are made with Clang-built binaries.
+
 ```sh
 cd koffi/benchmark
-node ../../cnoke/cnoke.js
+node ../../cnoke/cnoke.js --prefer-clang
 ```
 
-Once this is done, you can execute each implementation, e.g. `build/raylib_cc` or `node ./atoi_koffi.js`. You can optionally define a custom number of iterations, e.g. `node ./atoi_koffi.js 10000000`.
+Once everything is built and ready, run:
 
 ```sh
-node ./atoi_napi.js
-node ./atoi_koffi.js
+node benchmark.js
 ```

package/doc/dist/html/_sources/contribute.md.txt

@@ -69,7 +69,7 @@ Note that the machine disk content may change each time the machine runs, so the
 And now you can run the tests with:
 
 ```sh
-node qemu.js # Several options are available, use --help
+node qemu.js test # Several options are available, use --help
 ```
 
 And be patient, this can be pretty slow for emulated machines. The Linux machines have and use ccache to build Koffi, so subsequent build steps will get much more tolerable.
@@ -78,8 +78,8 @@ By default, machines are started and stopped for each test. But you can start th
 
 ```sh
 node qemu.js start # Start the machines
-node qemu.js # Test (without shutting down)
-node qemu.js # Test again
+node qemu.js test # Test (without shutting down)
+node qemu.js test # Test again
 node qemu.js stop # Stop everything
 ```
 
@@ -109,18 +109,15 @@ node qemu.js info debian_x64
 
 ## Todo list
 
-After the release of version 1.3.0, the current priorities for the next major release are:
+The following features and improvements are planned, not necessarily in that order:
 
-- Automate Windows/AArch64 (qemu) and macOS/AArch64 (how?) tests and builds
-- Create a real-world example, using several libraries (Raylib, SQLite, libsodium) to illustrate how to work with various C API styles
-
-The following features are also planned eventually, not necessarily in that order:
-
-- Optimize passing of structs and arrays, with separate HFA-specific helper functions
+- Provide better ways to automatically deal with caller/heap-allocated memory (strings, etc.)
+- Optimize passing of structs and arrays (avoid setting named properties one by one? separate HFA-specific helper functions?)
+- Automate Windows/AArch64 (qemu) and macOS/AArch64 (how? ... thanks Apple) tests
+- Create a real-world example, using several libraries (Raylib, SQLite, libsodium) to illustrate various C API styles
 - Add simple struct type parser
 - Add more ways to manually encode and decode various types to and from byte arrays
 - Add support for unions
-- Provide better ways to automatically deal with caller/heap-allocated memory (strings, etc.)
 - Port Koffi to PowerPC (POWER9+) ABI
 - Fix assembly unwind and CFI directives for better debugging experience
 

package/doc/dist/html/_sources/functions.md.txt

@@ -19,8 +19,8 @@ You can use the returned object to load C functions from the library. To do so,
 To declare a function, you need to specify its non-mangled name, its return type, and its parameters. Use an ellipsis as the last parameter for variadic functions.
 
 ```js
-const printf = lib.func('printf', 'int', ['string', '...']);
-const atoi = lib.func('atoi', 'int', ['string']);
+const printf = lib.func('printf', 'int', ['str', '...']);
+const atoi = lib.func('atoi', 'int', ['str']);
 ```
 
 Koffi automatically tries mangled names for non-standard x86 calling conventions. See the section [on standard calls](#synchronous-calls) for more information on this subject.
@@ -31,7 +31,7 @@ If you prefer, you can declare functions using simple C-like prototype strings,
 
 ```js
 const printf = lib.func('int printf(const char *fmt, ...)');
-const atoi = lib.func('int atoi(string)'); // The parameter name is not used by Koffi, and optional
+const atoi = lib.func('int atoi(str)'); // The parameter name is not used by Koffi, and optional
 ```
 
 You can use `()` or `(void)` for functions that take no argument.
@@ -58,8 +58,8 @@ const koffi = require('koffi');
 const lib = koffi.load('user32.dll');
 
 // The following two declarations are equivalent, and use Stdcall
-const MessageBoxA_1 = lib.stdcall('MessageBoxA', 'int', ['void *', 'string', 'string', 'uint']);
-const MessageBoxA_2 = lib.func('int __stdcall MessageBoxA(void *hwnd, string text, string caption, uint type)');
+const MessageBoxA_1 = lib.stdcall('MessageBoxA', 'int', ['void *', 'str', 'str', 'uint']);
+const MessageBoxA_2 = lib.func('int __stdcall MessageBoxA(void *hwnd, str text, str caption, uint type)');
 ```
 
 ## Asynchronous calls
@@ -95,10 +95,10 @@ Variadic functions are declared with an ellipsis as the last argument.
 In order to call a variadic function, you must provide two Javascript arguments for each additional C parameter, the first one is the expected type and the second one is the value.
 
 ```js
-const printf = lib.func('printf', 'int', ['string', '...']);
+const printf = lib.func('printf', 'int', ['str', '...']);
 
 // The variadic arguments are: 6 (int), 8.5 (double), 'THE END' (const char *)
-printf('Integer %d, double %g, string %s', 'int', 6, 'double', 8.5, 'string', 'THE END');
+printf('Integer %d, double %g, str %s', 'int', 6, 'double', 8.5, 'str', 'THE END');
 ```
 
 On x86 platforms, only the Cdecl convention can be used for variadic functions.
@@ -159,7 +159,8 @@ const lib = koffi.load('sqlite.so');
 const sqlite3_db = koffi.handle('sqlite3_db');
 
 // Use koffi.out() on a pointer to copy out (from C to JS) after the call
-const sqlite3_open_v2 = lib.func('sqlite3_open_v2', 'int', ['string', koffi.out(koffi.pointer(sqlite3_db)), 'int', 'string']);
+const sqlite3_open_v2 = lib.func('sqlite3_open_v2', 'int', ['str', koffi.out(koffi.pointer(sqlite3_db)), 'int', 'str']);
+const sqlite3_close_v2 = lib.func('sqlite3_close_v2', 'int', [sqlite3_db]);
 
 const SQLITE_OPEN_READWRITE = 0x2;
 const SQLITE_OPEN_CREATE = 0x4;

package/doc/dist/html/_sources/index.rst.txt

@@ -11,6 +11,9 @@ Koffi is a **fast and easy-to-use C FFI module for Node.js**, featuring:
 * Javascript functions can be used as C callbacks (since 1.2.0)
 * Well-tested code base for :ref:`popular OS/architecture combinations<Supported platforms>`
 
+
+Koffi requires a recent `Node.js <https://nodejs.org/>`_ version with N-API version 8 support, see :ref:`this page<Node.js>` for more information.
+
 Table of contents
 -----------------
 

package/doc/dist/html/_sources/platforms.md.txt

@@ -1,4 +1,18 @@
-# Supported platforms
+# Requirements
+
+## Node.js
+
+Koffi requires a recent [Node.js](https://nodejs.org/) version with [N-API](https://nodejs.org/api/n-api.html) version 8 support:
+
+- Node < 12.22.0 is not supported
+- _Node 12.x_: Node 12.22.0 or newer
+- _Node 14.x_: Node 14.17.0 or newer
+- _Node 15.x_: Node 15.12.0 or newer
+- Node 16.0.0 or later versions
+
+Use [NVM](https://github.com/nvm-sh/nvm) to install more recent Node versions on older Linux distributions.
+
+## Supported platforms
 
 The following combinations of OS and architectures __are officially supported and tested__ at the moment:
 
@@ -10,10 +24,8 @@ ARM32 LE [^2]      | ⬜️ *N/A*    | ✅ Yes   | ⬜️ *N/A*    | 🟨 Probab
 ARM64 (AArch64) LE | ✅ Yes      | ✅ Yes   | ✅ Yes      | ✅ Yes      | 🟨 Probably
 RISC-V 64 [^3]     | ⬜️ *N/A*    | ✅ Yes   | ⬜️ *N/A*    | 🟨 Probably | 🟨 Probably
 
-For all fully supported platforms (green check marks), a prebuilt binary is included in the NPM package which means you can install Koffi without a C++ compiler.
-
-Node 12 or later is required, earlier versions are not supported. Use [NVM](https://github.com/nvm-sh/nvm) to install recent Node versions on older Linux distributions.
-
 [^1]: The following call conventions are supported for forward calls: cdecl, stdcall, MS fastcall, thiscall. Only cdecl and stdcall can be used for C to JS callbacks.
 [^2]: The prebuilt binary uses the hard float ABI and expects a VFP coprocessor. Build from source to use Koffi with a different ABI (softfp, soft).
 [^3]: The prebuilt binary uses the LP64D (double-precision float) ABI. The LP64 ABI is supported in theory if you build Koffi from source (untested), the LP64F ABI is not supported.
+
+For all fully supported platforms (green check marks), a prebuilt binary is included in the NPM package which means you can install Koffi without a C++ compiler.

package/doc/dist/html/_sources/start.md.txt

@@ -1,5 +1,7 @@
 # Quick start
 
+## Install Koffi
+
 You can install Koffi with npm:
 
 ```sh
@@ -71,7 +73,7 @@ printf('Local time: %02d:%02d:%02d\n', 'int', now.tm_hour, 'int', now.tm_min, 'i
 
 This is a small example targeting the Win32 API, using `MessageBox()` to show a *Hello World!* message to the user.
 
-It illustrates the use of the x86 stdcall calling convention.
+It illustrates the use of the x86 stdcall calling convention, and the use of UTF-8 and UTF-16 string arguments.
 
 ```js
 const koffi = require('koffi');
@@ -80,10 +82,19 @@ const koffi = require('koffi');
 const lib = koffi.load('user32.dll');
 
 // Declare constants
+const MB_OK = 0x0;
+const MB_YESNO = 0x4;
+const MB_ICONQUESTION = 0x20;
 const MB_ICONINFORMATION = 0x40;
+const IDOK = 1;
+const IDYES = 6;
+const IDNO = 7;
 
 // Find functions
-const MessageBoxA = lib.stdcall('MessageBoxA', 'int', ['void *', 'string', 'string', 'uint']);
+const MessageBoxA = lib.stdcall('MessageBoxA', 'int', ['void *', 'str', 'str', 'uint']);
+const MessageBoxW = lib.stdcall('MessageBoxW', 'int', ['void *', 'str16', 'str16', 'uint']);
 
-MessageBoxA(null, 'Hello World!', 'Koffi', MB_ICONINFORMATION);
+let ret = MessageBoxA(null, 'Do you want another message box?', 'Koffi', MB_YESNO | MB_ICONQUESTION);
+if (ret == IDYES)
+    MessageBoxW(null, 'Hello World!', 'Koffi', MB_ICONINFORMATION);
 ```

package/doc/dist/html/_sources/types.md.txt

@@ -46,14 +46,18 @@ Koffi also accepts BigInt values when converting from JS to C integers. If the v
 
 Koffi defines a few more types that can change size depending on the OS and the architecture:
 
-JS type          | C type        | Signedness | Note
----------------- | ------------- | ---------- | ------------------------------------------------
-Boolean          | bool          |            | Usually one byte
-Number (integer) | long          | Signed     | 4 or 8 bytes depending on platform (LP64, LLP64)
-Number (integer) | ulong         | Unsigned   | 4 or 8 bytes depending on platform (LP64, LLP64)
-Number (integer) | unsigned long | Unsigned   | 4 or 8 bytes depending on platform (LP64, LLP64)
-String           | string        |            | JS strings are converted to and from UTF-8
-String           | string16      |            | JS strings are converted to and from UTF-16 (LE)
+JS type          | C type           | Signedness | Note
+---------------- | ---------------- | ---------- | ------------------------------------------------
+Boolean          | bool             |            | Usually one byte
+Number (integer) | long             | Signed     | 4 or 8 bytes depending on platform (LP64, LLP64)
+Number (integer) | ulong            | Unsigned   | 4 or 8 bytes depending on platform (LP64, LLP64)
+Number (integer) | unsigned long    | Unsigned   | 4 or 8 bytes depending on platform (LP64, LLP64)
+Number (integer) | intptr           | Signed     | 4 or 8 bytes depending on register width
+Number (integer) | intptr_t         | Signed     | 4 or 8 bytes depending on register width
+Number (integer) | uintptr          | Unsigned   | 4 or 8 bytes depending on register width
+Number (integer) | uintptr_t        | Unsigned   | 4 or 8 bytes depending on register width
+String           | str (string)     |            | JS strings are converted to and from UTF-8
+String           | str16 (string16) |            | JS strings are converted to and from UTF-16 (LE)
 
 Primitive types can be specified by name (in a string) or through `koffi.types`:
 
@@ -87,7 +91,7 @@ typedef struct A {
 const A = koffi.struct('A', {
     a: 'int',
     b: 'char',
-    c: 'string',
+    c: 'str',
     d: koffi.struct({
         d1: 'double',
         d2: 'double'
@@ -270,11 +274,11 @@ const koffi = require('koffi');
 const lib = koffi.load('./handles.so');
 
 const Concat = koffi.handle('Concat');
-const ConcatNewOut = lib.func('bool ConcatNewOut(Concat *out)');
 const ConcatNew = lib.func('Concat ConcatNew()');
 const ConcatFree = lib.func('void ConcatFree(Concat c)');
 const ConcatAppend = lib.func('bool ConcatAppend(Concat c, const char *frag)');
 const ConcatBuild = lib.func('const char *ConcatBuild(Concat c)');
+const ConcatNewOut = lib.func('bool ConcatNewOut(_Out_ Concat out)');
 
 let c = ConcatNew();
 if (!c) {
@@ -385,7 +389,7 @@ const WIN32_FIND_DATA = koffi.struct('WIN32_FIND_DATA', {
     wFinderFlags: 'ushort' // Obsolete. Do not use
 });
 
-const FindFirstFile = lib.func('HANDLE __stdcall FindFirstFileW(string16 path, _Out_ WIN32_FIND_DATA *data)');
+const FindFirstFile = lib.func('HANDLE __stdcall FindFirstFileW(str16 path, _Out_ WIN32_FIND_DATA *data)');
 const FindNextFile = lib.func('bool __stdcall FindNextFileW(HANDLE h, _Out_ WIN32_FIND_DATA *data)');
 const FindClose = lib.func('bool __stdcall FindClose(HANDLE h)');
 const GetLastError = lib.func('uint GetLastError()');

package/doc/dist/html/_static/basic.css

@@ -237,16 +237,6 @@ a.headerlink {
     visibility: hidden;
 }
 
-a.brackets:before,
-span.brackets > a:before{
-    content: "[";
-}
-
-a.brackets:after,
-span.brackets > a:after {
-    content: "]";
-}
-
 h1:hover > a.headerlink,
 h2:hover > a.headerlink,
 h3:hover > a.headerlink,
@@ -334,14 +324,18 @@ aside.sidebar {
 p.sidebar-title {
     font-weight: bold;
 }
+nav.contents,
+aside.topic,
 
-div.admonition, div.topic, aside.topic, blockquote {
+div.admonition, div.topic, blockquote {
     clear: left;
 }
 
 /* -- topics ---------------------------------------------------------------- */
+nav.contents,
+aside.topic,
 
-div.topic, aside.topic {
+div.topic {
     border: 1px solid #ccc;
     padding: 7px;
     margin: 10px 0 10px 0;
@@ -379,16 +373,20 @@ div.body p.centered {
 
 div.sidebar > :last-child,
 aside.sidebar > :last-child,
-div.topic > :last-child,
+nav.contents > :last-child,
 aside.topic > :last-child,
+
+div.topic > :last-child,
 div.admonition > :last-child {
     margin-bottom: 0;
 }
 
 div.sidebar::after,
 aside.sidebar::after,
-div.topic::after,
+nav.contents::after,
 aside.topic::after,
+
+div.topic::after,
 div.admonition::after,
 blockquote::after {
     display: block;