@knowvah/dot-engine 0.1.0

package/src/common/arm-pow-data.ts

@@ -0,0 +1,201 @@
+// SPDX-License-Identifier: EPL-2.0
+//
+// Data tables for the double-precision pow() of ARM optimized-routines,
+// extracted from its MIT-licensed published source (math/pow_log_data.c,
+// math/exp_data.c).
+//
+//   Copyright (c) 2018, Arm Limited.
+//   SPDX-License-Identifier: MIT OR Apache-2.0 WITH LLVM-exception
+//
+// Values are bit patterns [hi32, lo32] of IEEE-754 doubles (uint64 for
+// the exp table). See arm-pow.ts for the algorithm and provenance.
+
+/** ln2 high/low split. */
+export const ARM_LN2HI = [0x3fe62e42, 0xfefa3800];
+export const ARM_LN2LO = [0x3d2ef357, 0x93c76730];
+
+/** Log polynomial coefficients A[0..6] (pre-scaled). */
+export const ARM_LOG_POLY: number[] = [
+  0xbfe00000, 0x00000000, 0xbfe55555, 0x55555560, 0x3fe00000, 0x00000006, 0x3fe99999, 0x9959554e,
+  0xbfe55555, 0x5529a47a, 0xbff2495b, 0x9b4845e9, 0x3ff0002b, 0x8b263fc3,
+];
+
+/** Log table: 128 × (invc, logc, logctail) bit patterns. */
+export const ARM_LOG_TAB: number[] = [
+  0x3ff6a000, 0x00000000, 0xbfd62c82, 0xf2b9c800, 0x3cfab424, 0x28375680, 0x3ff68000, 0x00000000,
+  0xbfd5d1bd, 0xbf580800, 0xbd1ca508, 0xd8e0f720, 0x3ff66000, 0x00000000, 0xbfd57677, 0x17455800,
+  0xbd2362a4, 0xd5b6506d, 0x3ff64000, 0x00000000, 0xbfd51aad, 0x872df800, 0xbce684e4, 0x9eb067d5,
+  0x3ff62000, 0x00000000, 0xbfd4be5f, 0x95777800, 0xbd041b69, 0x93293ee0, 0x3ff60000, 0x00000000,
+  0xbfd4618b, 0xc21c6000, 0x3d13d82f, 0x484c84cc, 0x3ff5e000, 0x00000000, 0xbfd40430, 0x8686a800,
+  0x3cdc42f3, 0xed820b3a, 0x3ff5c000, 0x00000000, 0xbfd3a64c, 0x55694800, 0x3d20b1c6, 0x86519460,
+  0x3ff5a000, 0x00000000, 0xbfd347dd, 0x9a988000, 0x3d25594d, 0xd4c58092, 0x3ff58000, 0x00000000,
+  0xbfd2e8e2, 0xbae12000, 0x3d267b1e, 0x99b72bd8, 0x3ff56000, 0x00000000, 0xbfd2895a, 0x13de8800,
+  0x3d15ca14, 0xb6cfb03f, 0x3ff56000, 0x00000000, 0xbfd2895a, 0x13de8800, 0x3d15ca14, 0xb6cfb03f,
+  0x3ff54000, 0x00000000, 0xbfd22941, 0xfbcf7800, 0xbd165a24, 0x2853da76, 0x3ff52000, 0x00000000,
+  0xbfd1c898, 0xc1699800, 0xbd1fafbc, 0x68e75404, 0x3ff50000, 0x00000000, 0xbfd1675c, 0xababa800,
+  0x3d1f1fc6, 0x3382a8f0, 0x3ff4e000, 0x00000000, 0xbfd1058b, 0xf9ae4800, 0xbd26a8c4, 0xfd055a66,
+  0x3ff4c000, 0x00000000, 0xbfd0a324, 0xe2739000, 0xbd0c6bee, 0x7ef4030e, 0x3ff4a000, 0x00000000,
+  0xbfd04025, 0x94b4d000, 0xbcf036b8, 0x9ef42d7f, 0x3ff4a000, 0x00000000, 0xbfd04025, 0x94b4d000,
+  0xbcf036b8, 0x9ef42d7f, 0x3ff48000, 0x00000000, 0xbfcfb918, 0x6d5e4000, 0x3d0d572a, 0xab993c87,
+  0x3ff46000, 0x00000000, 0xbfcef0ad, 0xcbdc6000, 0x3d2b26b7, 0x9c86af24, 0x3ff44000, 0x00000000,
+  0xbfce2707, 0x6e2af000, 0xbd172f4f, 0x543fff10, 0x3ff42000, 0x00000000, 0xbfcd5c21, 0x6b4fc000,
+  0x3d21ba91, 0xbbca681b, 0x3ff40000, 0x00000000, 0xbfcc8ff7, 0xc79aa000, 0x3d27794f, 0x689f8434,
+  0x3ff40000, 0x00000000, 0xbfcc8ff7, 0xc79aa000, 0x3d27794f, 0x689f8434, 0x3ff3e000, 0x00000000,
+  0xbfcbc286, 0x742d9000, 0x3d194eb0, 0x318bb78f, 0x3ff3c000, 0x00000000, 0xbfcaf3c9, 0x4e80c000,
+  0x3cba4e63, 0x3fcd9066, 0x3ff3a000, 0x00000000, 0xbfca23bc, 0x1fe2b000, 0xbd258c64, 0xdc46c1ea,
+  0x3ff3a000, 0x00000000, 0xbfca23bc, 0x1fe2b000, 0xbd258c64, 0xdc46c1ea, 0x3ff38000, 0x00000000,
+  0xbfc9525a, 0x9cf45000, 0xbd2ad1d9, 0x04c1d4e3, 0x3ff36000, 0x00000000, 0xbfc87fa0, 0x6520d000,
+  0x3d2bbdbf, 0x7fdbfa09, 0x3ff34000, 0x00000000, 0xbfc7ab89, 0x0210e000, 0x3d2bdb90, 0x72534a58,
+  0x3ff34000, 0x00000000, 0xbfc7ab89, 0x0210e000, 0x3d2bdb90, 0x72534a58, 0x3ff32000, 0x00000000,
+  0xbfc6d60f, 0xe719d000, 0xbd10e46a, 0xa3b2e266, 0x3ff30000, 0x00000000, 0xbfc5ff30, 0x70a79000,
+  0xbd1e9e43, 0x9f105039, 0x3ff30000, 0x00000000, 0xbfc5ff30, 0x70a79000, 0xbd1e9e43, 0x9f105039,
+  0x3ff2e000, 0x00000000, 0xbfc526e5, 0xe3a1b000, 0xbd20de8b, 0x90075b8f, 0x3ff2c000, 0x00000000,
+  0xbfc44d2b, 0x6ccb8000, 0x3d170cc1, 0x6135783c, 0x3ff2c000, 0x00000000, 0xbfc44d2b, 0x6ccb8000,
+  0x3d170cc1, 0x6135783c, 0x3ff2a000, 0x00000000, 0xbfc371fc, 0x201e9000, 0x3cf17886, 0x4d27543a,
+  0x3ff28000, 0x00000000, 0xbfc29552, 0xf81ff000, 0xbd248d30, 0x1771c408, 0x3ff26000, 0x00000000,
+  0xbfc1b72a, 0xd52f6000, 0xbd2e80a4, 0x1811a396, 0x3ff26000, 0x00000000, 0xbfc1b72a, 0xd52f6000,
+  0xbd2e80a4, 0x1811a396, 0x3ff24000, 0x00000000, 0xbfc0d77e, 0x7cd09000, 0x3d0a6996, 0x88e85bf4,
+  0x3ff24000, 0x00000000, 0xbfc0d77e, 0x7cd09000, 0x3d0a6996, 0x88e85bf4, 0x3ff22000, 0x00000000,
+  0xbfbfec91, 0x31dbe000, 0xbd257554, 0x5ca333f2, 0x3ff20000, 0x00000000, 0xbfbe2707, 0x6e2b0000,
+  0x3d2a342c, 0x2af0003c, 0x3ff20000, 0x00000000, 0xbfbe2707, 0x6e2b0000, 0x3d2a342c, 0x2af0003c,
+  0x3ff1e000, 0x00000000, 0xbfbc5e54, 0x8f5bc000, 0xbd1d0c57, 0x585fbe06, 0x3ff1c000, 0x00000000,
+  0xbfba926d, 0x3a4ae000, 0x3d253935, 0xe85baac8, 0x3ff1c000, 0x00000000, 0xbfba926d, 0x3a4ae000,
+  0x3d253935, 0xe85baac8, 0x3ff1a000, 0x00000000, 0xbfb8c345, 0xd631a000, 0x3d137c29, 0x4d2f5668,
+  0x3ff1a000, 0x00000000, 0xbfb8c345, 0xd631a000, 0x3d137c29, 0x4d2f5668, 0x3ff18000, 0x00000000,
+  0xbfb6f0d2, 0x8ae56000, 0xbd269737, 0xc93373da, 0x3ff16000, 0x00000000, 0xbfb51b07, 0x3f062000,
+  0x3d1f025b, 0x61c65e57, 0x3ff16000, 0x00000000, 0xbfb51b07, 0x3f062000, 0x3d1f025b, 0x61c65e57,
+  0x3ff14000, 0x00000000, 0xbfb341d7, 0x961be000, 0x3d2c5eda, 0xccf913df, 0x3ff14000, 0x00000000,
+  0xbfb341d7, 0x961be000, 0x3d2c5eda, 0xccf913df, 0x3ff12000, 0x00000000, 0xbfb16536, 0xeea38000,
+  0x3d147c5e, 0x768fa309, 0x3ff10000, 0x00000000, 0xbfaf0a30, 0xc0118000, 0x3d2d599e, 0x83368e91,
+  0x3ff10000, 0x00000000, 0xbfaf0a30, 0xc0118000, 0x3d2d599e, 0x83368e91, 0x3ff0e000, 0x00000000,
+  0xbfab42dd, 0x71198000, 0x3d1c827a, 0xe5d6704c, 0x3ff0e000, 0x00000000, 0xbfab42dd, 0x71198000,
+  0x3d1c827a, 0xe5d6704c, 0x3ff0c000, 0x00000000, 0xbfa77458, 0xf632c000, 0xbd2cfc46, 0x34f2a1ee,
+  0x3ff0c000, 0x00000000, 0xbfa77458, 0xf632c000, 0xbd2cfc46, 0x34f2a1ee, 0x3ff0a000, 0x00000000,
+  0xbfa39e87, 0xb9fec000, 0x3cf502b7, 0xf526feaa, 0x3ff0a000, 0x00000000, 0xbfa39e87, 0xb9fec000,
+  0x3cf502b7, 0xf526feaa, 0x3ff08000, 0x00000000, 0xbf9f829b, 0x0e780000, 0xbd298026, 0x7c7e09e4,
+  0x3ff08000, 0x00000000, 0xbf9f829b, 0x0e780000, 0xbd298026, 0x7c7e09e4, 0x3ff06000, 0x00000000,
+  0xbf97b91b, 0x07d58000, 0xbd288d54, 0x93faa639, 0x3ff04000, 0x00000000, 0xbf8fc0a8, 0xb0fc0000,
+  0xbcdf1e7c, 0xf6d3a69c, 0x3ff04000, 0x00000000, 0xbf8fc0a8, 0xb0fc0000, 0xbcdf1e7c, 0xf6d3a69c,
+  0x3ff02000, 0x00000000, 0xbf7fe02a, 0x6b100000, 0xbd19e23f, 0x0dda40e4, 0x3ff02000, 0x00000000,
+  0xbf7fe02a, 0x6b100000, 0xbd19e23f, 0x0dda40e4, 0x3ff00000, 0x00000000, 0x00000000, 0x00000000,
+  0x00000000, 0x00000000, 0x3ff00000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+  0x3fefc000, 0x00000000, 0x3f801015, 0x75890000, 0xbd10c76b, 0x999d2be8, 0x3fef8000, 0x00000000,
+  0x3f902056, 0x58938000, 0xbd23dc5b, 0x06e2f7d2, 0x3fef4000, 0x00000000, 0x3f984925, 0x28c90000,
+  0xbd2aa0ba, 0x325a0c34, 0x3fef0000, 0x00000000, 0x3fa0415d, 0x89e74000, 0x3d0111c0, 0x5cf1d753,
+  0x3feec000, 0x00000000, 0x3fa466ae, 0xd42e0000, 0xbd2c1673, 0x75bdfd28, 0x3fee8000, 0x00000000,
+  0x3fa894aa, 0x149fc000, 0xbd197995, 0xd05a267d, 0x3fee4000, 0x00000000, 0x3faccb73, 0xcdddc000,
+  0xbd1a68f2, 0x47d82807, 0x3fee2000, 0x00000000, 0x3faeea31, 0xc006c000, 0xbd0e113e, 0x4fc93b7b,
+  0x3fede000, 0x00000000, 0x3fb1973b, 0xd1466000, 0xbd25325d, 0x560d9e9b, 0x3feda000, 0x00000000,
+  0x3fb3bdf5, 0xa7d1e000, 0x3d2cc85e, 0xa5db4ed7, 0x3fed6000, 0x00000000, 0x3fb5e95a, 0x4d97a000,
+  0xbd2c6906, 0x3c5d1d1e, 0x3fed4000, 0x00000000, 0x3fb700d3, 0x0aeac000, 0x3cec1e8d, 0xa99ded32,
+  0x3fed0000, 0x00000000, 0x3fb9335e, 0x5d594000, 0x3d23115c, 0x3abd47da, 0x3fecc000, 0x00000000,
+  0x3fbb6ac8, 0x8dad6000, 0xbd139080, 0x2bf768e5, 0x3feca000, 0x00000000, 0x3fbc8858, 0x01bc4000,
+  0x3d2646d1, 0xc65aacd3, 0x3fec6000, 0x00000000, 0x3fbec739, 0x830a2000, 0xbd2dc068, 0xafe645e0,
+  0x3fec4000, 0x00000000, 0x3fbfe891, 0x39dbe000, 0xbd2534d6, 0x4fa10afd, 0x3fec0000, 0x00000000,
+  0x3fc1178e, 0x8227e000, 0x3d21ef78, 0xce2d07f2, 0x3febe000, 0x00000000, 0x3fc1aa2b, 0x7e23f000,
+  0x3d2ca78e, 0x44389934, 0x3feba000, 0x00000000, 0x3fc2d161, 0x0c868000, 0x3d039d6c, 0xcb81b4a1,
+  0x3feb8000, 0x00000000, 0x3fc365fc, 0xb0159000, 0x3cc62fa8, 0x234b7289, 0x3feb4000, 0x00000000,
+  0x3fc4913d, 0x8333b000, 0x3d258379, 0x54fdb678, 0x3feb2000, 0x00000000, 0x3fc527e5, 0xe4a1b000,
+  0x3d2633e8, 0xe5697dc7, 0x3feae000, 0x00000000, 0x3fc6574e, 0xbe8c1000, 0x3d19cf8b, 0x2c3c2e78,
+  0x3feac000, 0x00000000, 0x3fc6f012, 0x8b757000, 0xbd25118d, 0xe59c21e1, 0x3feaa000, 0x00000000,
+  0x3fc7898d, 0x85445000, 0xbd1c6610, 0x70914305, 0x3fea6000, 0x00000000, 0x3fc8beaf, 0xeb390000,
+  0xbd073d54, 0xaae92cd1, 0x3fea4000, 0x00000000, 0x3fc95a5a, 0xdcf70000, 0x3d07f228, 0x58a0ff6f,
+  0x3fea0000, 0x00000000, 0x3fca93ed, 0x3c8ae000, 0xbd287243, 0x50562169, 0x3fe9e000, 0x00000000,
+  0x3fcb31d8, 0x575bd000, 0xbd0c358d, 0x4eace1aa, 0x3fe9c000, 0x00000000, 0x3fcbd087, 0x383be000,
+  0xbd2d4bc4, 0x595412b6, 0x3fe9a000, 0x00000000, 0x3fcc6ffb, 0xc6f01000, 0xbcf1ec72, 0xc5962bd2,
+  0x3fe96000, 0x00000000, 0x3fcdb13d, 0xb0d49000, 0xbd2aff2a, 0xf715b035, 0x3fe94000, 0x00000000,
+  0x3fce530e, 0xffe71000, 0x3cc21227, 0x6041f430, 0x3fe92000, 0x00000000, 0x3fcef5ad, 0xe4dd0000,
+  0xbcca2115, 0x65bb8e11, 0x3fe90000, 0x00000000, 0x3fcf991c, 0x6cb3b000, 0x3d1bcbec, 0xca0cdf30,
+  0x3fe8c000, 0x00000000, 0x3fd07138, 0x604d5800, 0x3cf89cdb, 0x16ed4e91, 0x3fe8a000, 0x00000000,
+  0x3fd0c42d, 0x67616000, 0x3d27188b, 0x163ceae9, 0x3fe88000, 0x00000000, 0x3fd1178e, 0x8227e800,
+  0xbd2c210e, 0x63a5f01c, 0x3fe86000, 0x00000000, 0x3fd16b5c, 0xcbacf800, 0x3d2b9acd, 0xf7a51681,
+  0x3fe84000, 0x00000000, 0x3fd1bf99, 0x635a6800, 0x3d2ca6ed, 0x5147bdb7, 0x3fe82000, 0x00000000,
+  0x3fd21445, 0x6d0eb800, 0x3d0a87de, 0xba46baea, 0x3fe7e000, 0x00000000, 0x3fd2bef0, 0x7cdc9000,
+  0x3d2a9cfa, 0x4a5004f4, 0x3fe7c000, 0x00000000, 0x3fd314f1, 0xe1d36000, 0xbd28e27a, 0xd3213cb8,
+  0x3fe7a000, 0x00000000, 0x3fd36b67, 0x76be1000, 0x3d116ecd, 0xb0f177c8, 0x3fe78000, 0x00000000,
+  0x3fd3c252, 0x77333000, 0x3d183b54, 0xb606bd5c, 0x3fe76000, 0x00000000, 0x3fd419b4, 0x23d5e800,
+  0x3d08e436, 0xec90e09d, 0x3fe74000, 0x00000000, 0x3fd4718d, 0xc271c800, 0xbd2f27ce, 0x0967d675,
+  0x3fe72000, 0x00000000, 0x3fd4c9e0, 0x9e173000, 0xbd2e2089, 0x1b0ad8a4, 0x3fe70000, 0x00000000,
+  0x3fd522ae, 0x0738a000, 0x3d2ebe70, 0x8164c759, 0x3fe6e000, 0x00000000, 0x3fd57bf7, 0x53c8d000,
+  0x3d1faded, 0xee5d40ef, 0x3fe6c000, 0x00000000, 0x3fd5d5bd, 0xdf596000, 0xbd0a0b2a, 0x08a465dc,
+];
+
+/** Exp argument-reduction constants. */
+export const ARM_INVLN2N = [0x40671547, 0x652b82fe];
+export const ARM_SHIFT = [0x43380000, 0x00000000];
+export const ARM_NEGLN2HIN = [0xbf762e42, 0xfefa0000];
+export const ARM_NEGLN2LON = [0xbd0cf79a, 0xbc9e3b3a];
+
+/** Exp polynomial coefficients (poly[0..5]). */
+export const ARM_EXP_POLY: number[] = [
+  0x3fdfffff, 0xfffffdbd, 0x3fc55555, 0x5555543c, 0x3fa55555, 0xcf172b91, 0x3f811111, 0x67a4d017,
+  0x43380000, 0x00000000, 0x42c80000, 0x00000000,
+];
+
+/** Exp table: 256 uint64 entries (tail/sbits pairs) as [hi32, lo32]. */
+export const ARM_EXP_TAB: number[] = [
+  0x00000000, 0x00000000, 0x3ff00000, 0x00000000, 0x3c9b3b4f, 0x1a88bf6e, 0x3feff63d, 0xa9fb3335,
+  0xbc716013, 0x9cd8dc5d, 0x3fefec9a, 0x3e778061, 0xbc905e7a, 0x108766d1, 0x3fefe315, 0xe86e7f85,
+  0x3c8cd252, 0x3567f613, 0x3fefd9b0, 0xd3158574, 0xbc8bce80, 0x23f98efa, 0x3fefd06b, 0x29ddf6de,
+  0x3c60f74e, 0x61e6c861, 0x3fefc745, 0x18759bc8, 0x3c90a3e4, 0x5b33d399, 0x3fefbe3e, 0xcac6f383,
+  0x3c979aa6, 0x5d837b6d, 0x3fefb558, 0x6cf9890f, 0x3c8eb51a, 0x92fdeffc, 0x3fefac92, 0x2b7247f7,
+  0x3c3ebe3d, 0x702f9cd1, 0x3fefa3ec, 0x32d3d1a2, 0xbc6a0334, 0x89906e0b, 0x3fef9b66, 0xaffed31b,
+  0xbc955652, 0x2a2fbd0e, 0x3fef9301, 0xd0125b51, 0xbc5080ef, 0x8c4eea55, 0x3fef8abd, 0xc06c31cc,
+  0xbc91c923, 0xb9d5f416, 0x3fef829a, 0xaea92de0, 0x3c80d3e3, 0xe95c55af, 0x3fef7a98, 0xc8a58e51,
+  0xbc801b15, 0xeaa59348, 0x3fef72b8, 0x3c7d517b, 0xbc8f1ff0, 0x55de323d, 0x3fef6af9, 0x388c8dea,
+  0x3c8b898c, 0x3f1353bf, 0x3fef635b, 0xeb6fcb75, 0xbc96d99c, 0x7611eb26, 0x3fef5be0, 0x84045cd4,
+  0x3c9aecf7, 0x3e3a2f60, 0x3fef5487, 0x3168b9aa, 0xbc8fe782, 0xcb86389d, 0x3fef4d50, 0x22fcd91d,
+  0x3c8a6f41, 0x44a6c38d, 0x3fef463b, 0x88628cd6, 0x3c807a05, 0xb0e4047d, 0x3fef3f49, 0x917ddc96,
+  0x3c968efd, 0xe3a8a894, 0x3fef387a, 0x6e756238, 0x3c875e18, 0xf274487d, 0x3fef31ce, 0x4fb2a63f,
+  0x3c80472b, 0x981fe7f2, 0x3fef2b45, 0x65e27cdd, 0xbc96b87b, 0x3f71085e, 0x3fef24df, 0xe1f56381,
+  0x3c82f7e1, 0x6d09ab31, 0x3fef1e9d, 0xf51fdee1, 0xbc3d219b, 0x1a6fbffa, 0x3fef187f, 0xd0dad990,
+  0x3c8b3782, 0x720c0ab4, 0x3fef1285, 0xa6e4030b, 0x3c6e1492, 0x89cecb8f, 0x3fef0caf, 0xa93e2f56,
+  0x3c834d75, 0x4db0abb6, 0x3fef06fe, 0x0a31b715, 0x3c864201, 0xe2ac744c, 0x3fef0170, 0xfc4cd831,
+  0x3c8fdd39, 0x5dd3f84a, 0x3feefc08, 0xb26416ff, 0xbc86a380, 0x3b8e5b04, 0x3feef6c5, 0x5f929ff1,
+  0xbc924aed, 0xcc4b5068, 0x3feef1a7, 0x373aa9cb, 0xbc9907f8, 0x1b512d8e, 0x3feeecae, 0x6d05d866,
+  0xbc71d1e8, 0x3e9436d2, 0x3feee7db, 0x34e59ff7, 0xbc991919, 0xb3ce1b15, 0x3feee32d, 0xc313a8e5,
+  0x3c859f48, 0xa72a4c6d, 0x3feedea6, 0x4c123422, 0xbc931260, 0x7a28698a, 0x3feeda45, 0x04ac801c,
+  0xbc58a78f, 0x4817895b, 0x3feed60a, 0x21f72e2a, 0xbc7c2c9b, 0x67499a1b, 0x3feed1f5, 0xd950a897,
+  0x3c4363ed, 0x60c2ac11, 0x3feece08, 0x6061892d, 0x3c966609, 0x3b0664ef, 0x3feeca41, 0xed1d0057,
+  0x3c6ecce1, 0xdaa10379, 0x3feec6a2, 0xb5c13cd0, 0x3c93ff8e, 0x3f0f1230, 0x3feec32a, 0xf0d7d3de,
+  0x3c7690ce, 0xbb7aafb0, 0x3feebfda, 0xd5362a27, 0x3c931dbd, 0xeb54e077, 0x3feebcb2, 0x99fddd0d,
+  0xbc8f9434, 0x0071a38e, 0x3feeb9b2, 0x769d2ca7, 0xbc87decc, 0xdc93a349, 0x3feeb6da, 0xa2cf6642,
+  0xbc78dec6, 0xbd0f385f, 0x3feeb42b, 0x569d4f82, 0xbc861246, 0xec7b5cf6, 0x3feeb1a4, 0xca5d920f,
+  0x3c933505, 0x18fdd78e, 0x3feeaf47, 0x36b527da, 0x3c7b98b7, 0x2f8a9b05, 0x3feead12, 0xd497c7fd,
+  0x3c9063e1, 0xe21c5409, 0x3feeab07, 0xdd485429, 0x3c34c785, 0x5019c6ea, 0x3feea926, 0x8a5946b7,
+  0x3c9432e6, 0x2b64c035, 0x3feea76f, 0x15ad2148, 0xbc8ce44a, 0x6199769f, 0x3feea5e1, 0xb976dc09,
+  0xbc8c33c5, 0x3bef4da8, 0x3feea47e, 0xb03a5585, 0xbc845378, 0x892be9ae, 0x3feea346, 0x34ccc320,
+  0xbc93cedd, 0x78565858, 0x3feea238, 0x82552225, 0x3c5710aa, 0x807e1964, 0x3feea155, 0xd44ca973,
+  0xbc93b3ef, 0xbf5e2228, 0x3feea09e, 0x667f3bcd, 0xbc6a12ad, 0x8734b982, 0x3feea012, 0x750bdabf,
+  0xbc6367ef, 0xb86da9ee, 0x3fee9fb2, 0x3c651a2f, 0xbc80dc3d, 0x54e08851, 0x3fee9f7d, 0xf9519484,
+  0xbc781f64, 0x7e5a3ecf, 0x3fee9f75, 0xe8ec5f74, 0xbc86ee4a, 0xc08b7db0, 0x3fee9f9a, 0x48a58174,
+  0xbc861932, 0x1e55e68a, 0x3fee9feb, 0x564267c9, 0x3c909ccb, 0x5e09d4d3, 0x3feea069, 0x4fde5d3f,
+  0xbc7b32dc, 0xb94da51d, 0x3feea114, 0x73eb0187, 0x3c94ecfd, 0x5467c06b, 0x3feea1ed, 0x0130c132,
+  0x3c65ebe1, 0xabd66c55, 0x3feea2f3, 0x36cf4e62, 0xbc88a1c5, 0x2fb3cf42, 0x3feea427, 0x543e1a12,
+  0xbc9369b6, 0xf13b3734, 0x3feea589, 0x994cce13, 0xbc805e84, 0x3a19ff1e, 0x3feea71a, 0x4623c7ad,
+  0xbc94d450, 0xd872576e, 0x3feea8d9, 0x9b4492ed, 0x3c90ad67, 0x5b0e8a00, 0x3feeaac7, 0xd98a6699,
+  0x3c8db72f, 0xc1f0eab4, 0x3feeace5, 0x422aa0db, 0xbc65b660, 0x9cc5e7ff, 0x3feeaf32, 0x16b5448c,
+  0x3c7bf683, 0x59f35f44, 0x3feeb1ae, 0x99157736, 0xbc93091f, 0xa71e3d83, 0x3feeb45b, 0x0b91ffc6,
+  0xbc5da9b8, 0x8b6c1e29, 0x3feeb737, 0xb0cdc5e5, 0xbc6c23f9, 0x7c90b959, 0x3feeba44, 0xcbc8520f,
+  0xbc924343, 0x22f4f9aa, 0x3feebd82, 0x9fde4e50, 0xbc85ca6c, 0xd7668e4b, 0x3feec0f1, 0x70ca07ba,
+  0x3c71affc, 0x2b91ce27, 0x3feec491, 0x82a3f090, 0x3c6dd235, 0xe10a73bb, 0x3feec863, 0x19e32323,
+  0xbc87c504, 0x22622263, 0x3feecc66, 0x7b5de565, 0x3c8b1c86, 0xe3e231d5, 0x3feed09b, 0xec4a2d33,
+  0xbc91bbd1, 0xd3bcbb15, 0x3feed503, 0xb23e255d, 0x3c90cc31, 0x9cee31d2, 0x3feed99e, 0x1330b358,
+  0x3c846984, 0x6e735ab3, 0x3feede6b, 0x5579fdbf, 0xbc82dfcd, 0x978e9db4, 0x3feee36b, 0xbfd3f37a,
+  0x3c8c1a77, 0x92cb3387, 0x3feee89f, 0x995ad3ad, 0xbc907b8f, 0x4ad1d9fa, 0x3feeee07, 0x298db666,
+  0xbc55c3d9, 0x56dcaeba, 0x3feef3a2, 0xb84f15fb, 0xbc90a40e, 0x3da6f640, 0x3feef972, 0x8de5593a,
+  0xbc68d6f4, 0x38ad9334, 0x3feeff76, 0xf2fb5e47, 0xbc91eee2, 0x6b588a35, 0x3fef05b0, 0x30a1064a,
+  0x3c74ffd7, 0x0a5fddcd, 0x3fef0c1e, 0x904bc1d2, 0xbc91bdfb, 0xfa9298ac, 0x3fef12c2, 0x5bd71e09,
+  0x3c736eae, 0x30af0cb3, 0x3fef199b, 0xdd85529c, 0x3c8ee332, 0x5c9ffd94, 0x3fef20ab, 0x5fffd07a,
+  0x3c84e08f, 0xd10959ac, 0x3fef27f1, 0x2e57d14b, 0x3c63cdaf, 0x384e1a67, 0x3fef2f6d, 0x9406e7b5,
+  0x3c676b2c, 0x6c921968, 0x3fef3720, 0xdcef9069, 0xbc808a18, 0x83ccb5d2, 0x3fef3f0b, 0x555dc3fa,
+  0xbc8fad5d, 0x3ffffa6f, 0x3fef472d, 0x4a07897c, 0xbc900dae, 0x3875a949, 0x3fef4f87, 0x080d89f2,
+  0x3c74a385, 0xa63d07a7, 0x3fef5818, 0xdcfba487, 0xbc82919e, 0x2040220f, 0x3fef60e3, 0x16c98398,
+  0x3c8e5a50, 0xd5c192ac, 0x3fef69e6, 0x03db3285, 0x3c843a59, 0xac016b4b, 0x3fef7321, 0xf301b460,
+  0xbc82d521, 0x07b43e1f, 0x3fef7c97, 0x337b9b5f, 0xbc892ab9, 0x3b470dc9, 0x3fef8646, 0x14f5a129,
+  0x3c74b604, 0x603a88d3, 0x3fef902e, 0xe78b3ff6, 0x3c83c5ec, 0x519d7271, 0x3fef9a51, 0xfbc74c83,
+  0xbc8ff712, 0x8fd391f0, 0x3fefa4af, 0xa2a490da, 0xbc8dae98, 0xe223747d, 0x3fefaf48, 0x2d8e67f1,
+  0x3c8ec3bc, 0x41aa2008, 0x3fefba1b, 0xee615a27, 0x3c842b94, 0xc3a9eb32, 0x3fefc52b, 0x376bba97,
+  0x3c8a64a9, 0x31d185ee, 0x3fefd076, 0x5b6e4540, 0xbc8e37ba, 0xe43be3ed, 0x3fefdbfd, 0xad9cbe14,
+  0x3c77893b, 0x4d91cd9d, 0x3fefe7c1, 0x819e90d8, 0x3c5305c1, 0x4160cc89, 0x3feff3c2, 0x2b8f71f1,
+];

package/src/common/arm-pow.ts

@@ -0,0 +1,296 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Double-precision pow(x, y) ported from ARM optimized-routines
+ * (math/pow.c, the HAVE_FAST_FMA + TOINT_INTRINSICS aarch64 config),
+ * which is permissively licensed and EPL-2.0-compatible:
+ *
+ *   Copyright (c) 2018-2026, Arm Limited.
+ *   SPDX-License-Identifier: MIT OR Apache-2.0 WITH LLVM-exception
+ *
+ * Source: https://github.com/ARM-software/optimized-routines
+ * (math/pow.c, math/pow_log_data.c, math/exp_data.c). The data
+ * tables are in arm-pow-data.ts, extracted from that MIT source.
+ *
+ * Why a hand-rolled pow: graphviz sfdp's repulsive force calls
+ * pow(dist, 1−p) with a RUNTIME exponent, so the reference binary
+ * issues real libm calls whose ~0.5-ULP rounding is chaotically
+ * amplified by the force loop. V8's Math.pow and x·x diverge from
+ * any libm; this ~0.54-ULP implementation is the closest portable,
+ * legally clean match. (It is NOT bit-identical to Apple's libm,
+ * which generated the macOS golden refs — see the mission journal.)
+ *
+ * Only the normal-finite fast path sfdp exercises is ported; special
+ * cases (0, inf, nan, negative base, over/underflow) throw.
+ *
+ * @see ARM optimized-routines math/pow.c (log_inline, exp_inline, pow)
+ */
+
+import { fma } from './fma.js';
+import { cround } from './arith.js';
+import {
+  ARM_LN2HI,
+  ARM_LN2LO,
+  ARM_LOG_POLY,
+  ARM_LOG_TAB,
+  ARM_INVLN2N,
+  ARM_NEGLN2HIN,
+  ARM_NEGLN2LON,
+  ARM_EXP_POLY,
+  ARM_EXP_TAB,
+} from './arm-pow-data.js';
+
+const BUF = new ArrayBuffer(8);
+const F64 = new Float64Array(BUF);
+const U32 = new Uint32Array(BUF);
+
+/** asdouble: reconstruct a double from a BigInt bit pattern. */
+function asDoubleBig(bits: bigint): number {
+  U32[0] = Number(bits & 0xffffffffn);
+  U32[1] = Number((bits >> 32n) & 0xffffffffn);
+  return F64[0]!;
+}
+
+/** asuint64: a double's bits as a BigInt. */
+function asUint64(x: number): bigint {
+  F64[0] = x;
+  return (BigInt(U32[1]! >>> 0) << 32n) | BigInt(U32[0]! >>> 0);
+}
+
+/** Bits [hi32, lo32] → double. */
+function fromPair(p: number[]): number {
+  U32[1] = p[0]!;
+  U32[0] = p[1]!;
+  return F64[0]!;
+}
+
+/** top12(x): top 12 bits of the double (sign + 11 exponent bits). */
+function top12(x: number): number {
+  F64[0] = x;
+  return (U32[1]! >>> 20) & 0xfff;
+}
+
+const LN2HI = fromPair(ARM_LN2HI);
+const LN2LO = fromPair(ARM_LN2LO);
+const A: number[] = [];
+for (let i = 0; i < 7; i++) A.push(fromPair([ARM_LOG_POLY[2 * i]!, ARM_LOG_POLY[2 * i + 1]!]));
+
+const INVLN2N = fromPair(ARM_INVLN2N);
+const NEGLN2HIN = fromPair(ARM_NEGLN2HIN);
+const NEGLN2LON = fromPair(ARM_NEGLN2LON);
+const EC: number[] = [];
+for (let i = 0; i < 6; i++) EC.push(fromPair([ARM_EXP_POLY[2 * i]!, ARM_EXP_POLY[2 * i + 1]!]));
+
+const POW_LOG_TABLE_BITS = 7;
+const N_LOG = 1 << POW_LOG_TABLE_BITS;
+const EXP_TABLE_BITS = 7;
+const N_EXP = 1 << EXP_TABLE_BITS;
+const OFF = 0x3fe6955500000000n;
+
+/** Bit patterns and sign bias for the pow special-case branch. */
+const INF_BITS = 0x7ff0000000000000n;
+const ONE_BITS = 0x3ff0000000000000n; // asuint64(1.0)
+/** SIGN_BIAS = 0x800 << EXP_TABLE_BITS. @see ARM pow.c */
+const SIGN_BIAS = 0x800 << EXP_TABLE_BITS;
+
+/** Exp poly constants C2..C5 (poly[5−ORDER+i], ORDER = 5). */
+const C2 = EC[0]!;
+const C3 = EC[1]!;
+const C4 = EC[2]!;
+const C5 = EC[3]!;
+
+/** Log table accessors (triples invc, logc, logctail). */
+function logInvc(i: number): number { return fromPair([ARM_LOG_TAB[6 * i]!, ARM_LOG_TAB[6 * i + 1]!]); }
+function logLogc(i: number): number { return fromPair([ARM_LOG_TAB[6 * i + 2]!, ARM_LOG_TAB[6 * i + 3]!]); }
+function logTail(i: number): number { return fromPair([ARM_LOG_TAB[6 * i + 4]!, ARM_LOG_TAB[6 * i + 5]!]); }
+
+/** Exp table entry (uint64) as a BigInt. */
+function expTab(idx: number): bigint {
+  return (BigInt(ARM_EXP_TAB[2 * idx]! >>> 0) << 32n) | BigInt(ARM_EXP_TAB[2 * idx + 1]! >>> 0);
+}
+
+const MASK64 = (1n << 64n) - 1n;
+
+/** Result of log_inline: y plus a tail term. */
+interface LogResult {
+  y: number;
+  tail: number;
+}
+
+/**
+ * y + tail = log(x) with ~15 extra bits, ix being the bits of x.
+ * @see ARM optimized-routines math/pow.c:log_inline (HAVE_FAST_FMA)
+ */
+function logInline(ix: bigint): LogResult {
+  const tmp = (ix - OFF) & MASK64;
+  const i = Number((tmp >> BigInt(52 - POW_LOG_TABLE_BITS)) % BigInt(N_LOG));
+  const k = Number(BigInt.asIntN(64, tmp) >> 52n); /* arithmetic shift */
+  const iz = (ix - (tmp & (0xfffn << 52n))) & MASK64;
+  const z = asDoubleBig(iz);
+  const kd = k;
+
+  const invc = logInvc(i);
+  const logc = logLogc(i);
+  const logctail = logTail(i);
+
+  const r = fma(z, invc, -1.0);
+
+  const t1 = kd * LN2HI + logc;
+  const t2 = t1 + r;
+  const lo1 = kd * LN2LO + logctail;
+  const lo2 = t1 - t2 + r;
+
+  const ar = A[0]! * r;
+  const ar2 = r * ar;
+  const ar3 = r * ar2;
+  const hi = t2 + ar2;
+  const lo3 = fma(ar, r, -ar2);
+  const lo4 = t2 - hi + ar2;
+  const p = ar3 * (A[1]! + r * A[2]! + ar2 * (A[3]! + r * A[4]! + ar2 * (A[5]! + r * A[6]!)));
+  const lo = lo1 + lo2 + lo3 + lo4 + p;
+  const y = hi + lo;
+  return { y, tail: hi - y + lo };
+}
+
+/**
+ * sign·exp(x + xtail). Tiny argument → 1 + x; over/underflow → signed inf/0
+ * (via expOverflow, matching libm rather than throwing).
+ * @see ARM optimized-routines math/pow.c:exp_inline (TOINT_INTRINSICS)
+ */
+function expInline(x: number, xtail: number, signBias: number): number {
+  const abstop = top12(x) & 0x7ff;
+  const band = (abstop - top12(2 ** -54)) >>> 0;
+  if (band >= ((top12(512.0) - top12(2 ** -54)) >>> 0)) {
+    /* tiny argument: exp(x) ≈ 1 + x. @see pow.c:exp_inline (abstop branch) */
+    if (band >= 0x80000000) {
+      const one = 1.0 + x;
+      return signBias ? -one : one;
+    }
+    /* large/overflow argument — bounded for sfdp, but return the signed
+     * over/underflow instead of crashing on a pathological input. */
+    return expOverflow(x, signBias);
+  }
+
+  const z = INVLN2N * x;
+  const kd = cround(z);                  // roundtoint (round-half-away-from-zero)
+  const ki = BigInt(kd);                 // converttoint (in-range)
+  const r0 = x + kd * NEGLN2HIN + kd * NEGLN2LON;
+  const r = r0 + xtail;
+
+  const idx = 2 * Number(((ki % BigInt(N_EXP)) + BigInt(N_EXP)) % BigInt(N_EXP));
+  const top = ((ki + BigInt(signBias)) << BigInt(52 - EXP_TABLE_BITS)) & MASK64;
+  const tail = asDoubleBig(expTab(idx));
+  const sbits = (expTab(idx + 1) + top) & MASK64;
+
+  const r2 = r * r;
+  /* EXP_POLY_ORDER == 5 */
+  const tmp = tail + r + r2 * (C2 + r * C3) + r2 * r2 * (C4 + r * C5);
+  const scale = asDoubleBig(sbits);
+  return scale + scale * tmp;
+}
+
+/**
+ * Reached only for the exp_inline overflow band (|result| would over/underflow).
+ * sfdp's x^y is bounded and never triggers it — but rather than throw, return
+ * the correctly-signed over/underflow so a pathological input still renders
+ * (matching libm) instead of crashing the layout.
+ * @see ARM optimized-routines math/pow.c:exp_inline specialcase
+ */
+function expOverflow(x: number, signBias: number): number {
+  // x is the exp argument; large positive → overflow, large negative → underflow.
+  const neg = signBias !== 0;
+  if (x > 0) return neg ? -Infinity : Infinity;
+  return neg ? -0 : 0;
+}
+
+/** unsigned 64-bit wrap. */
+function u64(v: bigint): bigint { return v & MASK64; }
+const INF2M1 = u64(2n * INF_BITS - 1n);
+
+/**
+ * zeroinfnan(i): true when the double with bits i is zero, inf, or nan.
+ * @see ARM optimized-routines math/pow.c:zeroinfnan
+ */
+function zeroinfnan(i: bigint): boolean {
+  return u64(2n * i - 1n) >= INF2M1;
+}
+
+/**
+ * checkint(iy): 0 if y is not an integer, 1 if odd integer, 2 if even integer.
+ * @see ARM optimized-routines math/pow.c:checkint
+ */
+function checkint(iy: bigint): number {
+  const e = Number((iy >> 52n) & 0x7ffn);
+  if (e < 0x3ff) return 0;
+  if (e > 0x3ff + 52) return 2;
+  const shift = BigInt(0x3ff + 52 - e);
+  if ((iy & ((1n << shift) - 1n)) !== 0n) return 0;
+  if ((iy & (1n << shift)) !== 0n) return 1;
+  return 2;
+}
+
+/**
+ * pow(x, y). The normal-finite fast path is the log_inline/exp_inline core;
+ * the special-case branch (x or y is 0/inf/nan, negative base, subnormal base,
+ * or extreme |y|) is ported faithfully so armPow returns exactly what libm's
+ * pow returns — including `pow(NaN, y) = NaN`. This matters for sfdp graphs
+ * whose force loop blows up to NaN under a large `repulsiveforce` (e.g. 2556,
+ * repulsiveforce=100 → the native oracle itself emits all-`nan` positions):
+ * the port must reproduce the same NaN, not throw.
+ * @see ARM optimized-routines math/pow.c:pow
+ */
+export function armPow(x: number, y: number): number {
+  let signBias = 0;
+  let ix = asUint64(x);
+  const iy = asUint64(y);
+  let topx = top12(x);
+  const topy = top12(y);
+  if (
+    ((topx - 0x001) >>> 0) >= (0x7ff - 0x001) ||
+    ((((topy & 0x7ff) - 0x3be) >>> 0) >= (0x43e - 0x3be))
+  ) {
+    // Special cases: (x < 0x1p-126 or inf or nan) or (|y| < 0x1p-65 or |y| >= 0x1p63).
+    if (zeroinfnan(iy)) {
+      if (u64(2n * iy) === 0n) return 1.0;              // pow(x, 0) = 1
+      if (ix === ONE_BITS) return 1.0;                  // pow(1, y) = 1
+      if (u64(2n * ix) > u64(2n * INF_BITS) || u64(2n * iy) > u64(2n * INF_BITS)) {
+        return x + y;                                   // nan operand → nan
+      }
+      if (u64(2n * ix) === u64(2n * ONE_BITS)) return 1.0; // pow(±1, ±inf) = 1
+      // (|x|<1 && y<0) or (|x|>1 && y>=0) → 0, else inf. `yNonNeg` is !(iy>>63).
+      const yNonNeg = (iy >> 63n) === 0n;
+      if ((u64(2n * ix) < u64(2n * ONE_BITS)) === yNonNeg) return 0.0;
+      return y * y;                                     // inf
+    }
+    if (zeroinfnan(ix)) {
+      let x2 = x * x;
+      if ((ix >> 63n) === 1n && checkint(iy) === 1) { x2 = -x2; signBias = SIGN_BIAS; }
+      if (u64(2n * ix) === 0n && (iy >> 63n) === 1n) return signBias ? -Infinity : Infinity;
+      return (iy >> 63n) === 1n ? 1 / x2 : x2;          // pow(NaN, y>0) = NaN
+    }
+    // Here x and y are non-zero finite.
+    if ((ix >> 63n) === 1n) {                           // finite x < 0
+      const yint = checkint(iy);
+      if (yint === 0) return NaN;                       // pow(neg, non-integer) invalid
+      if (yint === 1) signBias = SIGN_BIAS;
+      ix = ix & 0x7fffffffffffffffn;
+      topx = topx & 0x7ff;
+    }
+    if ((((topy & 0x7ff) - 0x3be) >>> 0) >= (0x43e - 0x3be)) {
+      if (ix === ONE_BITS) return 1.0;
+      if ((topy & 0x7ff) < 0x3be) return 1.0;           // |y| tiny → x^y ≈ 1
+      // |y| >= 0x1p63 → 0 or inf.
+      return ((ix > ONE_BITS) === (topy < 0x800))
+        ? (signBias ? -Infinity : Infinity)
+        : (signBias ? -0 : 0);
+    }
+    if (topx === 0) {                                   // normalize subnormal x
+      ix = asUint64(x * 2 ** 52) & 0x7fffffffffffffffn;
+      ix = ix - (52n << 52n);
+    }
+  }
+  const { y: hi, tail: lo } = logInline(ix);
+  const ehi = y * hi;
+  const elo = y * lo + fma(y, hi, -ehi);
+  return expInline(ehi, elo, signBias);
+}

package/src/common/arrows-constants.ts

@@ -0,0 +1,175 @@
+// SPDX-License-Identifier: EPL-2.0
+
+/**
+ * Arrow type and modifier constants, name/type tables ported from
+ * lib/common/arrows.c internal definitions.
+ *
+ * @see lib/common/arrows.c
+ */
+
+// ---------------------------------------------------------------------------
+// Numeric constants
+// ---------------------------------------------------------------------------
+
+/** @see lib/common/arrows.c:#define EPSILON */
+export const EPSILON = 0.0001;
+
+/** Standard arrow length in points. @see lib/common/arrows.c:#define ARROW_LENGTH */
+export const ARROW_LENGTH = 10.0;
+
+/** Number of arrow heads per flag word. @see lib/common/arrows.c:#define NUMB_OF_ARROW_HEADS */
+export const NUMB_OF_ARROW_HEADS = 4;
+
+/** Bits per arrow slot in the flag word. @see lib/common/arrows.c:#define BITS_PER_ARROW */
+export const BITS_PER_ARROW = 8;
+
+/** Bits used for the arrow type portion. @see lib/common/arrows.c:#define BITS_PER_ARROW_TYPE */
+export const BITS_PER_ARROW_TYPE = 4;
+
+// ---------------------------------------------------------------------------
+// Arrow type codes (low BITS_PER_ARROW_TYPE bits of each arrow slot)
+// ---------------------------------------------------------------------------
+
+/** @see lib/common/arrows.c:#define ARR_TYPE_NONE */
+export const ARR_TYPE_NONE = 0;
+/** @see lib/common/arrows.c:#define ARR_TYPE_NORM */
+export const ARR_TYPE_NORM = 1;
+/** @see lib/common/arrows.c:#define ARR_TYPE_CROW */
+export const ARR_TYPE_CROW = 2;
+/** @see lib/common/arrows.c:#define ARR_TYPE_TEE */
+export const ARR_TYPE_TEE = 3;
+/** @see lib/common/arrows.c:#define ARR_TYPE_BOX */
+export const ARR_TYPE_BOX = 4;
+/** @see lib/common/arrows.c:#define ARR_TYPE_DIAMOND */
+export const ARR_TYPE_DIAMOND = 5;
+/** @see lib/common/arrows.c:#define ARR_TYPE_DOT */
+export const ARR_TYPE_DOT = 6;
+/** @see lib/common/arrows.c:#define ARR_TYPE_CURVE */
+export const ARR_TYPE_CURVE = 7;
+/** @see lib/common/arrows.c:#define ARR_TYPE_GAP */
+export const ARR_TYPE_GAP = 8;
+
+// ---------------------------------------------------------------------------
+// Per-type length factors (ratio of this arrow type's length to the standard
+// ARROW_LENGTH). @see lib/common/arrows.c:Arrowtypes (lenfact column)
+// ---------------------------------------------------------------------------
+
+/** @see lib/common/arrows.c:Arrowtypes ARR_TYPE_NORM lenfact */
+export const ARR_LENFACT_NORM = 1.0;
+/** @see lib/common/arrows.c:Arrowtypes ARR_TYPE_CROW lenfact */
+export const ARR_LENFACT_CROW = 1.0;
+/** @see lib/common/arrows.c:Arrowtypes ARR_TYPE_TEE lenfact */
+export const ARR_LENFACT_TEE = 0.5;
+/** @see lib/common/arrows.c:Arrowtypes ARR_TYPE_BOX lenfact */
+export const ARR_LENFACT_BOX = 1.0;
+/** @see lib/common/arrows.c:Arrowtypes ARR_TYPE_DIAMOND lenfact */
+export const ARR_LENFACT_DIAMOND = 1.2;
+/** @see lib/common/arrows.c:Arrowtypes ARR_TYPE_DOT lenfact */
+export const ARR_LENFACT_DOT = 0.8;
+/** @see lib/common/arrows.c:Arrowtypes ARR_TYPE_CURVE lenfact */
+export const ARR_LENFACT_CURVE = 1.0;
+/** @see lib/common/arrows.c:Arrowtypes ARR_TYPE_GAP lenfact */
+export const ARR_LENFACT_GAP = 0.5;
+
+/**
+ * Length factor indexed by ARR_TYPE_* code. ARR_TYPE_NONE (0) has no shape;
+ * it maps to 0 so a none-arrow contributes no clip length.
+ * @see lib/common/arrows.c:Arrowtypes
+ */
+export const ARR_LENFACT_BY_TYPE: readonly number[] = (() => {
+  const t: number[] = [];
+  t[ARR_TYPE_NONE] = 0;
+  t[ARR_TYPE_NORM] = ARR_LENFACT_NORM;
+  t[ARR_TYPE_CROW] = ARR_LENFACT_CROW;
+  t[ARR_TYPE_TEE] = ARR_LENFACT_TEE;
+  t[ARR_TYPE_BOX] = ARR_LENFACT_BOX;
+  t[ARR_TYPE_DIAMOND] = ARR_LENFACT_DIAMOND;
+  t[ARR_TYPE_DOT] = ARR_LENFACT_DOT;
+  t[ARR_TYPE_CURVE] = ARR_LENFACT_CURVE;
+  t[ARR_TYPE_GAP] = ARR_LENFACT_GAP;
+  return t;
+})();
+
+/** Mask selecting the type-code portion (low BITS_PER_ARROW_TYPE bits). */
+export const ARR_TYPE_MASK = (1 << BITS_PER_ARROW_TYPE) - 1;
+
+// ---------------------------------------------------------------------------
+// Arrow modifier flags (upper 4 bits of each arrow slot)
+// ---------------------------------------------------------------------------
+
+/** Open/outline only. @see lib/common/arrows.c:#define ARR_MOD_OPEN */
+export const ARR_MOD_OPEN = 1 << (BITS_PER_ARROW_TYPE + 0);
+/** Inverted direction. @see lib/common/arrows.c:#define ARR_MOD_INV */
+export const ARR_MOD_INV = 1 << (BITS_PER_ARROW_TYPE + 1);
+/** Left half only. @see lib/common/arrows.c:#define ARR_MOD_LEFT */
+export const ARR_MOD_LEFT = 1 << (BITS_PER_ARROW_TYPE + 2);
+/** Right half only. @see lib/common/arrows.c:#define ARR_MOD_RIGHT */
+export const ARR_MOD_RIGHT = 1 << (BITS_PER_ARROW_TYPE + 3);
+
+// ---------------------------------------------------------------------------
+// Named tables (name → flag mapping)
+// ---------------------------------------------------------------------------
+
+/** One entry in an arrow name/flag table. @see lib/common/arrows.c:arrowname_t */
+export interface ArrowNameEntry {
+  readonly name: string;
+  readonly type: number;
+}
+
+/**
+ * Backward-compatibility synonyms for deprecated arrow names.
+ * Evaluated before Arrownames so "invempty" resolves correctly.
+ * @see lib/common/arrows.c:Arrowsynonyms
+ */
+export const ARROW_SYNONYMS: readonly ArrowNameEntry[] = [
+  { name: 'invempty', type: ARR_TYPE_NORM | ARR_MOD_INV | ARR_MOD_OPEN },
+];
+
+/**
+ * Modifier prefix tokens.
+ * @see lib/common/arrows.c:Arrowmods
+ */
+export const ARROW_MODS: readonly ArrowNameEntry[] = [
+  { name: 'o',    type: ARR_MOD_OPEN },
+  { name: 'r',    type: ARR_MOD_RIGHT },
+  { name: 'l',    type: ARR_MOD_LEFT },
+  { name: 'e',    type: ARR_MOD_OPEN },   // deprecated alias for 'o'
+  { name: 'half', type: ARR_MOD_LEFT },   // deprecated alias for 'l'
+];
+
+/**
+ * Primary arrow shape names.
+ * @see lib/common/arrows.c:Arrownames
+ */
+export const ARROW_NAMES_TABLE: readonly ArrowNameEntry[] = [
+  { name: 'normal',  type: ARR_TYPE_NORM },
+  { name: 'crow',    type: ARR_TYPE_CROW },
+  { name: 'tee',     type: ARR_TYPE_TEE },
+  { name: 'box',     type: ARR_TYPE_BOX },
+  { name: 'diamond', type: ARR_TYPE_DIAMOND },
+  { name: 'dot',     type: ARR_TYPE_DOT },
+  { name: 'none',    type: ARR_TYPE_GAP },
+  { name: 'inv',     type: ARR_TYPE_NORM | ARR_MOD_INV },
+  { name: 'vee',     type: ARR_TYPE_CROW | ARR_MOD_INV },
+  // kludge: "open" → "pen" (prefix "o" already consumed as ARR_MOD_OPEN)
+  { name: 'pen',     type: ARR_TYPE_CROW | ARR_MOD_INV },
+  // kludge: "empty" → "mpty" (prefix "e" already consumed as ARR_MOD_OPEN)
+  { name: 'mpty',    type: ARR_TYPE_NORM },
+  { name: 'curve',   type: ARR_TYPE_CURVE },
+  { name: 'icurve',  type: ARR_TYPE_CURVE | ARR_MOD_INV },
+];
+
+/**
+ * Direction strings and their corresponding start/end flag values.
+ * @see lib/common/arrows.c:Arrowdirs
+ */
+export const ARROW_DIRS: readonly {
+  dir: string;
+  sflag: number;
+  eflag: number;
+}[] = [
+  { dir: 'forward', sflag: ARR_TYPE_NONE, eflag: ARR_TYPE_NORM },
+  { dir: 'back',    sflag: ARR_TYPE_NORM, eflag: ARR_TYPE_NONE },
+  { dir: 'both',    sflag: ARR_TYPE_NORM, eflag: ARR_TYPE_NORM },
+  { dir: 'none',    sflag: ARR_TYPE_NONE, eflag: ARR_TYPE_NONE },
+];