anubicharts 0.0.0-stage → 0.1.0

package/DERIVAZIONE.md

@@ -0,0 +1,33 @@
+# Derivation from Lightweight Charts, function by function (2026-11-10)
+
+(The file name is kept from the original Italian version; the content below is the English translation.)
+
+This file lists, for each part of the engine, whether it is original, was rewritten from pixel measurements of Lightweight Charts (LW), or
+is still treated as a derived work of Lightweight Charts (Apache-2.0). Sources: the maintainers' internal measurement notes and two
+reviews done by AI (Claude) sessions. "Status" is the verdict of the second review, updated after the fixes that followed it.
+
+| Part | File | Declared status |
+|---|---|---|
+| Public interface (createChart, series, scales, panes, primitives, markers) | `lw.js` | **Follows the LW API** for compatibility (a documented interface) |
+| `candleWidth`, `bodyShare` | `bars.js` | `bodyShare` is a table of 81 measured thresholds with interpolation (no formula); the case structure of `candleWidth` (fixed zone, parity) is similar to the original: **inspired** |
+| `candleParts`, `candleRects` | `bars.js` | **Derived/inspired**: same order of passes, same wick and border rule (measured on pixels, but they coincide with the original's structure); text rewritten |
+| `barWidth`, `barParts`, `barRects` | `bars.js` | Width re-expressed from measurements; tick threshold and ticks inside the stem equal to the original: **inspired** |
+| `histGap`, `histColumns` | `bars.js` | **Derived/inspired**: gap, narrowing below 4 px and side choice coincide with the original |
+| Histogram heights | `lw.js` `drawHistogram` | **Derived** (a few lines of arithmetic equal to the original) |
+| `pointMarker` | `bars.js` | Radius and centre measured over 36 combinations; half-pixel correction in the odd case: **inspired** |
+| `priceAxisWidth`, `timeAxisHeight`, `crossPriceLabel`, `crossTimeLabel`, `timeTickMinDist` | `lw.js` | Lines and formulas fitted to measurements (fixtures): **measured** |
+| `measureAxis` | `lw.js` | Rewritten from measurements after the second review (all grid labels, no constants from the original source): **measured** |
+| `niceStep`, `priceTicks`, `minMove` rule | `pricescale.js` | Table of steps measured, different algorithm; steps with `minMove` derived from 190 pixel comparisons: **measured** |
+| `weightOf`, `TickIndex.pick`, time filling | `timeticks.js`, `lw.js` | Year, month, day, hour scheme common to every time axis; single level and filling measured with `tickMarkFormatter`: **measured/inspired** |
+| `updateBase` (last-bar rule) | `lw.js` | Behaviour documented by the API (`shiftVisibleRangeOnNewBar`), threshold measured (rightOffset greater than -1): **measured** |
+| Long press at 240 ms | `lw.js` `onDown` | Same value as LW, measured with synthetic events: **measured** |
+| `dashPhases`, `dashOrigin` | `glx.js`, `lw.js` | Dash phase observed and verified over 72 combinations: **measured** |
+| LOD (pyramid), GPU packets, WebGL (`gl*.js`, `glprim.js`), script primitives, interaction | various | Original work by AnubiAI |
+
+All parts marked "derived/inspired" must be treated as derived works of Lightweight Charts (Apache-2.0): they keep the copyright and
+license notice and the attribution note (see `NOTICE`).
+
+The measurement fixtures used by the tests are in `test/fixtures/`: they contain numbers measured on LW's rendered output (pixel positions
+and sizes), not LW source code.
+
+This is **not** a clean-room implementation and no clean-room claim is made.

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2023 TradingView, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,21 @@
+AnubiCharts, the AnubiQuant chart engine
+Copyright (c) 2026 AnubiAI (anubiai.com)
+
+This product contains parts derived from, or inspired by, TradingView Lightweight Charts(TM)
+Copyright (c) 2025 TradingView, Inc. (https://www.tradingview.com/), distributed under the Apache License 2.0.
+The text of the license is in the LICENSE file of this directory.
+
+The public interface (createChart, addSeries, timeScale, priceScale, panes, primitives, markers, names and default values of the
+documented options) follows the Lightweight Charts v5 API for compatibility.
+
+The geometry and behaviour parts (candle and bar widths, histogram columns, ticks, point markers, crosshair labels, last-bar rule,
+choice of time labels, grid steps, scale widths) were rewritten by looking at the pixels produced by Lightweight Charts rather than by
+copying its code, but a strict clean room is NOT claimed: the people who wrote them already knew the algorithms, and a second
+independent review (see DERIVAZIONE.md) judged some of them derived. The function-by-function list is in DERIVAZIONE.md.
+
+As requested by Lightweight Charts, whoever shows a chart built with this library must display, in a visible place (for example an
+"About and credits" page), the attribution notice to TradingView with a link to https://www.tradingview.com/.
+
+Lightweight Charts is a trademark of TradingView, Inc. This project is not affiliated with or endorsed by TradingView, Inc.
+
+The rest of the code (level of detail, data pyramid, WebGL drawing, script primitives, interaction) is original work by AnubiAI.

package/README.md

@@ -1,3 +1,120 @@
-# Temporary Holding Version
+# AnubiCharts
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A WebGL2 chart renderer for financial time series (candles, bars, lines, areas, histograms, multiple panes) with an API
+**compatible with TradingView Lightweight Charts v5** (`createChart`, `addSeries`, `timeScale`, `priceScale`, `panes`, primitives, markers).
+Made by [AnubiAI](https://anubiai.com); it is the chart engine of our trading platform, AnubiQuant. License: **Apache-2.0**.
+
+![20,000 synthetic candles with volume, drawn by AnubiCharts](docs/screenshot.png)
+
+> Status: early (0.1.0). It is not a full replacement for Lightweight Charts: see *Known limits*.
+
+## Install
+
+```
+npm install anubicharts
+```
+
+Plain ES modules, no dependencies, no build step of its own; use it with a bundler (Vite, webpack, esbuild…) or any setup that resolves
+bare imports. It needs a browser with **WebGL2** (available in current Chrome, Edge, Firefox and Safari); there is no Canvas fallback. So far it has been tested in Chrome only.
+
+## Quick start
+
+```html
+<div id="chart" style="width:800px;height:400px"></div>
+<script type="module">
+  import { createChart, CandlestickSeries } from anubicharts;
+  const chart = createChart(document.getElementById('chart'), { autoSize: true });
+  const series = chart.addSeries(CandlestickSeries, {});
+  series.setData([{ time: 1700000000, open: 1, high: 2, low: 0.5, close: 1.5 } /* ... */]);
+</script>
+```
+
+To try it from a clone instead, import `./src/lw.js` as the examples do, and serve the folder with any static server (ES modules do not
+load from `file://`), for example `python -m http.server`:
+
+- `examples/basic.html`: 20,000 candles with volume.
+- `examples/benchmark.html`: pan and zoom tests for each engine (see *Performance*).
+- `examples/solo.html`: one engine per page with a live frame counter (`?engine=aq|lw`, `?mode=zoom`, `?vis=3000`, `?w=940`).
+- `examples/compare.html`: the two engines side by side, panned in the same animation frame.
+
+The Anubi mark is shown at the bottom-left of the first pane, like the logo of Lightweight Charts; turn it off with `layout: { attributionLogo: false }`.
+
+## Coming from Lightweight Charts
+
+Change the import and keep the rest:
+
+```js
+// before
+import { createChart, CandlestickSeries } from 'lightweight-charts';
+// after
+import { createChart, CandlestickSeries } from 'anubicharts';
+```
+
+Provided: `createChart`; the series `CandlestickSeries`, `BarSeries`, `LineSeries`, `AreaSeries`, `BaselineSeries`, `HistogramSeries`;
+`createSeriesMarkers`; `timeScale()`, `priceScale()`, `panes()`, primitives, price lines, crosshair and `takeScreenshot`; the enums
+`LineStyle`, `LineType`, `CrosshairMode`, `PriceScaleMode`, `ColorType`, `LastPriceAnimationMode`, `PriceLineSource`, `TickMarkType`,
+`MismatchDirection`, `TrackingModeExitMode`; and `isBusinessDay` / `isUTCTimestamp`. Not provided: custom series and the other chart types
+(`createChartEx`, yield curve, options charts) and the watermark plugins. A few visual details differ, see *Known limits*.
+
+## How it works
+
+Series data is stored in columns with a level-of-detail pyramid (min/max of any range in O(log n)). Candles and lines are uploaded to
+the GPU once, and panning and zooming are done with uniforms, so scrolling does not rewrite buffers. One WebGL canvas serves all panes.
+
+## Performance
+
+Measured against the **stock** Lightweight Charts 5.2.1, one engine per page (`examples/solo.html`), 20,000 candles + 37 moving averages,
+Chrome on Windows, the integrated Intel UHD 630 (the GPU the browser used on this machine):
+
+| Display / chart width / visible bars | AnubiCharts | Lightweight Charts 5.2.1 |
+|---|---|---|
+| 144 Hz, 940 px, 3000 bars: pan | 6.9 ms/frame (145 fps) | 27.8 ms/frame (36 fps) |
+| 144 Hz, 940 px, 3000 bars: zoom 600-3000 | 6.9 ms/frame (145 fps) | 27.7 ms/frame (36 fps) |
+| 144 Hz, 470 px, 3000 bars: pan or zoom | 6.9 ms/frame (145 fps) | 13.9 ms/frame (72 fps) |
+| 144 Hz, full-width page, 600 bars: pan (`benchmark.html`) | 6.9 ms/frame | 13.9 ms/frame (p95 20.8 ms) |
+| **60 Hz**, 761 px, 3000 bars: pan | 16.7 ms/frame (60 fps, no frame over 20 ms) | 33.4 ms/frame (30 fps, p95 50.2 ms) |
+
+Numbers are medians of the interval between animation frames, i.e. what the browser produces. AnubiCharts sits at the refresh period of the
+display, so it cannot show less than that. The advantage depends on how much there is to draw (width, visible bars, number of series).
+This is **one machine and one scenario**. On a phone with a 144 Hz display AnubiCharts ran at 144 fps (informal check, not measured with
+the benchmark page).
+
+The videos replay the 144 Hz timings of each engine in slow motion (x0.25); they are rebuilt from the measured frame timings, not screen
+recordings (MP4 versions: `docs/compare-fps.mp4`, `docs/compare-zoom.mp4`).
+
+![AnubiCharts at 145 fps and Lightweight Charts at 36 fps on the same pan](docs/compare-fps.gif)
+
+![AnubiCharts and Lightweight Charts zooming the same chart](docs/compare-zoom.gif)
+
+**Measure it yourself.** Open `examples/benchmark.html` over HTTP and run the pan and zoom tests for each engine. The page loads
+**unmodified** Lightweight Charts 5.2.1 from a CDN, uses the same deterministic data for both, and reports the median, 95th percentile and
+maximum frame interval plus your GPU and browser. Run each engine several times and ignore the first run. With monitors of different
+refresh rates, set the one you test on as the primary display: on a 60 Hz monitor next to a 144 Hz one, Chrome on Windows kept reporting
+about 143 frames per second while the screen showed 60. We would love numbers from other GPUs and from real phones (open an issue).
+
+## Tests
+
+`npm test` runs 28 tests (Node 18+, no dependencies) on the pure parts: candle, bar and histogram geometry against measurements of
+Lightweight Charts' rendered output (`test/fixtures/`), price and time scales, tick selection, the data pyramid and the dash phase.
+WebGL rendering itself is not covered by automated tests yet.
+
+## Known limits
+
+- Tested in Chrome (on Windows) only; Firefox and Safari are untested.
+- Phone testing is informal so far (one phone with a 144 Hz display, no benchmark numbers); a crash seen on one phone earlier has not been reproduced in emulation.
+- Fractional device pixel ratios were checked only with an emulated test bench.
+- Axis time labels differ from Lightweight Charts in some timeframes.
+- The last-value label on the price scale (last visible bar, as in Lightweight Charts) was matched in 39 measured cases, not exhaustively.
+- No custom series; Pine-style plots are not native series.
+- Below 1 px per bar the engine aggregates bars (by design).
+
+## Relation to Lightweight Charts
+
+The public API follows Lightweight Charts v5 for compatibility. Several geometry details (candle and bar widths, histogram columns, ticks)
+were reproduced by measuring Lightweight Charts' pixel output; some parts are still treated as derived works and are declared in
+`DERIVAZIONE.md` and `NOTICE`, with attribution to TradingView, Inc. (Apache-2.0). This is **not** a clean-room implementation.
+Lightweight Charts is a trademark of TradingView, Inc.; this project is not affiliated with or endorsed by TradingView.
+
+## License
+
+Apache-2.0, see `LICENSE` and `NOTICE`. Copyright (c) 2026 AnubiAI (anubiai.com).

package/package.json

@@ -1,6 +1,37 @@
 {
   "name": "anubicharts",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "WebGL2 chart renderer with a Lightweight Charts v5-compatible API",
+  "type": "module",
+  "main": "src/lw.js",
+  "exports": {
+    ".": "./src/lw.js"
+  },
+  "files": [
+    "src",
+    "LICENSE",
+    "NOTICE",
+    "DERIVAZIONE.md",
+    "README.md"
+  ],
+  "license": "Apache-2.0",
+  "author": "AnubiAI (anubiai.com)",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/anubiai/anubicharts.git"
+  },
+  "homepage": "https://github.com/anubiai/anubicharts#readme",
+  "bugs": {
+    "url": "https://github.com/anubiai/anubicharts/issues"
+  },
+  "keywords": [
+    "charts",
+    "webgl",
+    "candlestick",
+    "financial",
+    "lightweight-charts"
+  ],
+  "scripts": {
+    "test": "node --test test/*.test.js"
+  }
+}

package/src/bars.js

@@ -0,0 +1,197 @@
+/*
+ * AnubiCharts, the AnubiQuant chart engine. Copyright (c) 2026 AnubiAI (anubiai.com).
+ * Licensed under the Apache License, Version 2.0; see LICENSE. Parts are derived from, or inspired by, TradingView Lightweight Charts(TM),
+ * Copyright (c) 2025 TradingView, Inc. (Apache-2.0); see NOTICE and DERIVAZIONE.md. Not affiliated with TradingView, Inc.
+ */
+/**
+ * Device-pixel geometry of candles, OHLC bars and histograms (pure functions, no access to the canvas or the GPU).
+ * Written from a specification obtained by MEASURING the pixels that Lightweight Charts produces in Chrome (tables in
+ * test/fixtures/lw-measures-*.json; the measurement bench is not published). Provenance stated honestly: the person who wrote the
+ * code already knew, in general terms, the algorithms of that library and the previous code of this engine; this is not a clean
+ * room in the strict legal sense, but a rewrite guided by measurements with a proof of equivalence (see DERIVAZIONE.md).
+ */
+
+/**
+ * Width of a candle body, in CSS pixels: s(sp) = sp · share, with share 1 for close bars (spacing ≤ 4) and then decreasing towards
+ * 0.8. It is NOT a formula: it is a table of measured thresholds (test/fixtures/lw-measures-bodyshare.json: for each spacing at
+ * which the width in device pixels moves to the next value, at DPR 1, 2, 3, 4 and a few more, bisection to 1e-4) and its deviation
+ * d(sp) = s − 0.8·sp, interpolated with a local monotone cubic (non-uniform Catmull-Rom). A rational function fitted to those
+ * points was wrong by up to 0.009 px of spacing, and at every threshold there was a window in which aq and LW gave different
+ * widths (423 cases out of 63,600).
+ */
+const SHARE_TAB = [[4,0.8],[4.30528,0.69863],[4.42801,0.65759],[4.69769,0.57518],[4.87451,0.52896],[4.99999,0.50001],[5.16746,0.46603],[5.34997,0.43431],[5.77901,0.37679],[6.47969,0.31625],[6.7055,0.30227],[7.15018,0.27986],[7.58844,0.26258],[7.80581,0.25535],[8.45279,0.23777],[9.09443,0.22446],[9.30749,0.22067],[9.73248,0.21402],[10.1564,0.20821],[10.36797,0.20562],[11.00161,0.19871],[11.63382,0.19294],[11.84433,0.1912],[12.26494,0.18805],[12.68521,0.18516],[12.89521,0.18383],[13.52481,0.18015],[14.15386,0.17691],[14.36345,0.17591],[14.78242,0.17406],[15.20127,0.17232],[15.41063,0.1715],[16.03842,0.16926],[16.66604,0.16717],[16.87517,0.16653],[17.29334,0.16533],[17.71147,0.16416],[17.92048,0.16362],[18.54742,0.16206],[19.17419,0.16065],[19.38307,0.16021],[19.80082,0.15934],[20.21851,0.15853],[20.42731,0.15815],[21.05375,0.157],[21.68007,0.15594],[21.88879,0.15564],[22.30625,0.155],[22.72367,0.1544],[22.9324,0.15408],[23.55847,0.15322],[24.18447,0.15242],[24.39314,0.15216],[24.81041,0.15167],[25.22765,0.15121],[25.43629,0.15097],[26.06211,0.15031],[26.68789,0.14969],[26.89649,0.14947],[27.31368,0.14906],[27.73079,0.1487],[27.93937,0.1485],[28.56503,0.14798],[29.19064,0.14749],[29.39919,0.14731],[29.81629,0.14697],[30.23331,0.14668],[30.44184,0.14653],[31.06743,0.14606],[31.69293,0.14566],[31.90144,0.14551],[32.31846,0.14523],[32.73541,0.145],[32.94391,0.14487],[33.5694,0.14448],[34.19481,0.14415],[34.4033,0.14403],[34.82026,0.14379],[35.23722,0.14356],[35.44564,0.14349],[36.07105,0.14316],[36.69645,0.14284]];
+const SHARE_M = SHARE_TAB.map((p, i, a) => { const l = a[Math.max(0, i - 1)], r = a[Math.min(a.length - 1, i + 1)]; return (r[1] - l[1]) / (r[0] - l[0]); });
+function bodyExtent(sp) {
+  const n = SHARE_TAB.length;
+  if (sp >= SHARE_TAB[n - 1][0]) { const [x, y] = SHARE_TAB[n - 1]; return 0.8 * sp + y + Math.min(0, SHARE_M[n - 1]) * (sp - x); } // beyond the last measurement: slope of the deviation, never rising
+  let lo = 0, hi = n - 1; while (hi - lo > 1) { const m = (lo + hi) >> 1; if (SHARE_TAB[m][0] <= sp) lo = m; else hi = m; }
+  const [x0, y0] = SHARE_TAB[lo], [x1, y1] = SHARE_TAB[lo + 1], h = x1 - x0, t = (sp - x0) / h, t2 = t * t, t3 = t2 * t;
+  const d = (2 * t3 - 3 * t2 + 1) * y0 + (t3 - 2 * t2 + t) * h * SHARE_M[lo] + (-2 * t3 + 3 * t2) * y1 + (t3 - t2) * h * SHARE_M[lo + 1];
+  return 0.8 * sp + d;
+}
+export function bodyShare(spacing) {
+  if (spacing <= 4) return 1;
+  return bodyExtent(spacing) / spacing;
+}
+
+/**
+ * Width (device pixels) of a candle's outline, borders included, for a spacing in CSS pixels and a horizontal pixel ratio `hpr`.
+ * It always has the same parity as the wick (so the wick falls at the centre of the body).
+ */
+export function candleWidth(spacing, hpr) {
+  const unit = Math.max(1, Math.floor(hpr)), full = Math.floor(spacing * hpr);
+  const fixed = spacing >= 2.5 && spacing <= 4; // intermediate zone: three fixed CSS pixels, even beyond the spacing (candles overlap: measured)
+  let w = fixed ? Math.floor(3 * hpr) : Math.floor(spacing * hpr * bodyShare(spacing));
+  w = Math.max(unit, fixed ? w : Math.min(w, full));
+  if (w >= 2 && w % 2 !== unit % 2) w--;
+  return w;
+}
+
+/** Wick and border widths for a body `body` pixels wide. */
+export function candleParts(body, hpr, spacing) {
+  const unit = Math.max(1, Math.floor(hpr));
+  const wick = Math.max(unit, Math.min(Math.min(unit, Math.floor(spacing * hpr)), body));
+  let border = unit;
+  if (body <= 2 * border) border = Math.max(unit, Math.floor((body - 1) / 2));
+  return { wick, border, hollow: body <= 2 * border };
+}
+
+/**
+ * Rectangles of a series of candles. `bars`: { n, x[] (centre in device pixels, integer), o[], h[], l[], c[] (y in device pixels,
+ * with decimals), body[], border[], wick[] (packed colours) }. Returns the rectangles [x0, y0, x1, y1, colour] in `out`
+ * (Float32Array in groups of 5, with `outU` a Uint32 view of the same buffer) starting at `at`; returns how many. Three passes:
+ * wicks, borders, bodies (order matters with transparent colours). Wicks and borders do not enter the previous candle.
+ */
+export function candleRects(bars, geom, flags, out, outU, y0) {
+  const { n, x, o, h, l, c } = bars;
+  const { width, wick, border, hollow } = geom;
+  const half = Math.floor(width / 2), wickHalf = Math.floor(wick / 2);
+  let k = 0;
+  const put = (xa, ya, w, hh, col) => {
+    if (w <= 0 || hh <= 0) return;
+    const q = k * 5;
+    out[q] = xa; out[q + 1] = y0 + ya; out[q + 2] = xa + w; out[q + 3] = y0 + ya + hh; outU[q + 4] = col; k++;
+  };
+  const top = (j) => Math.round(Math.min(o[j], c[j])), bot = (j) => Math.round(Math.max(o[j], c[j]));
+  if (flags.wick) {
+    let edge = -Infinity; // last column occupied by the previous candle
+    for (let j = 0; j < n; j++) {
+      let a = x[j] - wickHalf; const b = a + wick - 1;
+      if (a <= edge) a = edge + 1;
+      const t = top(j), bt = bot(j), hi = Math.round(h[j]), lo = Math.round(l[j]);
+      if (b >= a) { put(a, hi, b - a + 1, t - hi, bars.wick[j]); put(a, bt + 1, b - a + 1, lo - bt, bars.wick[j]); }
+      edge = x[j] - half + width - 1;
+    }
+  }
+  if (flags.border) {
+    let edge = -Infinity;
+    for (let j = 0; j < n; j++) {
+      let a = x[j] - half; const b = a + width - 1;
+      if (a <= edge) a = edge + 1;
+      const t = top(j), bt = bot(j), col = bars.border[j];
+      if (hollow) put(a, t, b - a + 1, bt - t + 1, col);
+      else {
+        put(a, t, border, bt - t + 1, col);
+        put(b - border + 1, t, border, bt - t + 1, col);
+        put(a + border, t, b - a + 1 - 2 * border, border, col);
+        put(a + border, bt - border + 1, b - a + 1 - 2 * border, border, col);
+      }
+      edge = b;
+    }
+  }
+  if (!flags.border || !hollow) {
+    const bd = flags.border ? border : 0;
+    for (let j = 0; j < n; j++) {
+      const a = x[j] - half + bd, b = x[j] - half + width - 1 - bd, t = top(j) + bd, bt = bot(j) - bd;
+      if (bt >= t) put(a, t, b - a + 1, bt - t + 1, bars.body[j]);
+    }
+  }
+  return k;
+}
+
+/**
+ * OHLC bars: total width (stem + ticks, device pixels), measured on LW at DPR 1, 1.5, 2, 2.5, 3, 4. With `u = max(1, floor(hpr))`
+ * odd (odd stem) it is 6n - 1, with u even 6n + 1, where n grows by one every 20/3 device pixels of spacing (n = floor(0.15 · sp ·
+ * hpr + 0.5) for odd u, floor(0.15 · sp · hpr) for even u), at least 1.
+ */
+export function barWidth(spacing, hpr) {
+  const unit = Math.max(1, Math.floor(hpr)), dev = spacing * hpr;
+  if (unit % 2) return 6 * Math.max(1, Math.floor((3 * dev) / 20 + 0.5)) - 1;
+  return 6 * Math.max(1, Math.floor((3 * dev) / 20)) + 1;
+}
+
+/**
+ * Stem and ticks of an OHLC bar: the stem is `u` wide (thin bars) or a third of the total width (rounded down, with the same
+ * parity as `u` by construction); the ticks share the rest, the left one takes the pixel less.
+ */
+export function barParts(spacing, hpr, thin) {
+  const unit = Math.max(1, Math.floor(hpr)), width = barWidth(spacing, hpr);
+  const stem = thin ? unit : Math.max(unit, Math.floor(width / 3));
+  // with spacing below floor(1.5 · hpr) CSS pixels (1 at DPR 1, 3 at DPR 2, 6 at DPR 4: measured) only the stems remain
+  if (spacing < Math.floor(1.5 * hpr)) return { stem, left: 0, right: 0 };
+  const rest = Math.max(0, width - stem), left = Math.floor(rest / 2);
+  return { stem, left, right: rest - left };
+}
+
+/**
+ * Rectangles of a series of OHLC bars. `bars`: as for candleRects (integer centre x, o[], h[], l[], c[] in device pixels with
+ * decimals, body[] = colour). `geom`: { stem, left, right } (widths in pixels). Per bar: stem from round(high) to round(low),
+ * extended by floor(stem/2) at each end; left tick at the open and right tick at the close, as tall as the stem and centred on
+ * round(value), but pushed inside the stem. The stem starts at x - floor(stem/2). Returns how many rectangles.
+ */
+export function barRects(bars, geom, out, outU, y0) {
+  const { n, x, o, h, l, c } = bars, { stem, left, right } = geom, half = Math.floor(stem / 2);
+  let k = 0;
+  const put = (xa, ya, xb, yb, col) => { const q = k * 5; out[q] = xa; out[q + 1] = y0 + ya; out[q + 2] = xb; out[q + 3] = y0 + yb; outU[q + 4] = col; k++; };
+  for (let j = 0; j < n; j++) {
+    const a = x[j] - half, col = bars.body[j], top = Math.round(h[j]) - half, bot = Math.max(Math.round(l[j]) + half, top + 1);
+    // the ticks stay inside the stem (measured: with the close on the low the tick moves up one row)
+    const tick = (v) => Math.max(top, Math.min(Math.round(v) - half, bot - stem));
+    put(a, top, a + stem, bot, col);
+    if (left > 0) { const yo = tick(o[j]); put(a - left, yo, a, yo + stem, col); }
+    if (right > 0) { const yc = tick(c[j]); put(a + stem, yc, a + stem + right, yc + stem, col); }
+  }
+  return k;
+}
+
+/** Gap in device pixels between two histogram columns (none with bars narrower than one pixel). */
+export const histGap = (pitch, hpr) => (Math.ceil(pitch) <= 1 ? 0 : Math.max(1, Math.floor(hpr)));
+
+/**
+ * Columns of a histogram. cx[]: centres in device pixels (with decimals); adj[]: consecutiveness (two bars are adjacent if their
+ * values differ by 1); pitch: spacing in device pixels; gapPx: gap between two columns. Writes left[] and right[]. Measured
+ * specification: column round(pitch) - gap wide, centred on the rounded centre; between two adjacent bars the gap becomes exactly
+ * gapPx: too large, the next column is widened to the left; too small, the previous one is shortened.
+ */
+export function histColumns(n, cx, adj, pitch, gapPx, left, right) {
+  const w0 = Math.round(pitch) - gapPx, half = Math.floor(w0 / 2);
+  for (let j = 0; j < n; j++) { const r = Math.round(cx[j]); left[j] = r - half; right[j] = left[j] + w0 - 1; }
+  for (let j = 1; j < n; j++) {
+    if (adj[j] !== adj[j - 1] + 1) continue;
+    const gap = left[j] - right[j - 1] - 1;
+    if (gap > gapPx) left[j] -= gap - gapPx;
+    else if (gap < gapPx) right[j - 1] -= gapPx - gap;
+  }
+  let narrow = Infinity;
+  for (let j = 0; j < n; j++) { if (right[j] < left[j]) right[j] = left[j]; narrow = Math.min(narrow, right[j] - left[j] + 1); }
+  // narrow columns (less than 4 pixels): all like the narrowest; the extra pixel is taken from the side towards which the rounding
+  // of the centre moved the column
+  if (gapPx > 0 && narrow < 4) {
+    for (let j = 0; j < n; j++) {
+      const extra = right[j] - left[j] + 1 - narrow;
+      if (extra <= 0) continue;
+      if (Math.round(cx[j]) > cx[j]) right[j] -= extra; else left[j] += extra;
+    }
+  }
+}
+
+/**
+ * Point markers (pointMarkersVisible): CSS radius = pointMarkersRadius or lineWidth/2 + 2. Measured on LW (36 combinations, DPR
+ * 1-4): the centroid is at the exact y and at round(x·dpr) + 0.5 when floor(dpr) is odd (0 if even); the covered area matches a
+ * circle of radius cssRadius·dpr, plus 0.4 px in the odd case (within 9%: with the smallest radii, 2.5 px, the soft edge matters
+ * more).
+ */
+export function pointMarker(dpr, lineWidth, radiusCss) {
+  const corr = (Math.max(1, Math.floor(dpr)) % 2) / 2, r = radiusCss || lineWidth / 2 + 2;
+  return { radius: r * dpr + (corr ? 0.4 : 0), xCorr: corr };
+}