@tradecanvas/core 1.4.0 → 1.10.0

package/dist/webgl/recordedCommands.d.ts

@@ -0,0 +1,75 @@
+import { RGBA } from './glColor.js';
+/** A clip or bounds in device pixels. */
+export interface Box {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+}
+export type GpuPaint = 
+/** Premultiplied, global alpha applied. */
+{
+    kind: 'solid';
+    color: RGBA;
+}
+/**
+ * Along (x0, y0) → (x1, y1) in device pixels. Stop colours are kept
+ * unpremultiplied (global alpha applied to their alpha): Canvas 2D blends
+ * between them so, and premultiplies after.
+ */
+ | {
+    kind: 'linear';
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+    stops: {
+        offset: number;
+        color: RGBA;
+    }[];
+};
+export type GpuCommand = 
+/** Axis-aligned rectangles, already clipped: left, top, right, bottom, then a premultiplied colour (8 numbers each). */
+{
+    type: 'rects';
+    values: number[];
+}
+/**
+ * Polylines: x, y, w, cum per point (w 1 drawn, 0 a neighbour only, -1 a
+ * break; cum the length along the line so far, for dashes), with two
+ * points before the first segment and two after the last.
+ */
+ | {
+    type: 'stroke';
+    points: number[];
+    color: RGBA;
+    width: number;
+    cap: 0 | 1 | 2;
+    dash: number[] | null;
+    clip: Box;
+}
+/** Polygons as spans (see polygonSpans.ts), each pixel inside in one of them. */
+ | {
+    type: 'fill';
+    spans: number[];
+    bounds: Box;
+    paint: GpuPaint;
+    clip: Box;
+}
+/** Discs: x, y, radius, then a premultiplied colour (7 numbers each). */
+ | {
+    type: 'circles';
+    values: number[];
+    clip: Box;
+};
+export declare const intersect: (a: Box, b: Box) => Box;
+export declare const isEmpty: (b: Box) => boolean;
+/** The box around x, y pairs, grown by `pad` each side. */
+export declare function boundsOf(points: readonly number[], pad?: number): Box;
+/**
+ * Whether any two boxes overlap over some area (touching doesn't count).
+ * Canvas 2D paints the union of a path's pieces once; drawn one by one,
+ * see-through or antialiased pieces that overlap would paint some pixels twice.
+ */
+export declare function anyOverlap(boxes: readonly Box[]): boolean;
+//# sourceMappingURL=recordedCommands.d.ts.map

package/dist/webgl/recordedCommands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recordedCommands.d.ts","sourceRoot":"","sources":["../../src/webgl/recordedCommands.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AAEzC,yCAAyC;AACzC,MAAM,WAAW,GAAG;IAClB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,MAAM,QAAQ;AAClB,2CAA2C;AACzC;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,IAAI,CAAA;CAAE;AAChC;;;;GAIG;GACD;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,IAAI,CAAA;KAAE,EAAE,CAAA;CAAE,CAAC;AAEjH,MAAM,MAAM,UAAU;AACpB,wHAAwH;AACtH;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE;AACrC;;;;GAIG;GACD;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAC;IAAC,KAAK,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IAAC,IAAI,EAAE,GAAG,CAAA;CAAE;AACpH,iFAAiF;GAC/E;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,EAAE,GAAG,CAAC;IAAC,KAAK,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,GAAG,CAAA;CAAE;AAC5E,yEAAyE;GACvE;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,GAAG,CAAA;CAAE,CAAC;AAErD,eAAO,MAAM,SAAS,GAAI,GAAG,GAAG,EAAE,GAAG,GAAG,KAAG,GAAmH,CAAC;AAE/J,eAAO,MAAM,OAAO,GAAI,GAAG,GAAG,KAAG,OAAwC,CAAC;AAE1E,2DAA2D;AAC3D,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,GAAG,SAAI,GAAG,GAAG,CAWhE;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,GAAG,EAAE,GAAG,OAAO,CASzD"}

package/dist/webgl/recordedPath.d.ts

@@ -0,0 +1,51 @@
+/** A gradient made on the recording context. */
+export declare class RecordedGradient {
+    readonly x0: number;
+    readonly y0: number;
+    readonly x1: number;
+    readonly y1: number;
+    readonly stops: {
+        offset: number;
+        color: string;
+    }[];
+    constructor(x0: number, y0: number, x1: number, y1: number);
+    addColorStop(offset: number, color: string): void;
+}
+/** The browser's Path2D (a stand-in where there is none, as in tests). */
+declare const NativePath2D: {
+    new (path?: Path2D | string): Path2D;
+};
+/**
+ * A Path2D made while a step records. It is a real Path2D too (a chart that
+ * keeps one and draws it on a real context later still can), and remembers
+ * its calls to play them back on the recording context when it's filled,
+ * stroked or clipped (at the transform of that moment, as Canvas 2D does).
+ * Calls the GPU can't follow (ellipses, SVG path data…) mark it, and the
+ * step goes to Canvas 2D.
+ */
+export declare class RecordedPath extends NativePath2D {
+    readonly calls: [string, number[]][];
+    unsupported: boolean;
+    constructor(from?: Path2D | string);
+    private note;
+    /** A call the GPU can't follow: still made on the real path, and the step goes to Canvas 2D. */
+    private unfollowed;
+    moveTo(x: number, y: number): void;
+    lineTo(x: number, y: number): void;
+    closePath(): void;
+    rect(x: number, y: number, w: number, h: number): void;
+    arc(x: number, y: number, r: number, a0: number, a1: number, ccw?: boolean): void;
+    quadraticCurveTo(cx: number, cy: number, x: number, y: number): void;
+    bezierCurveTo(c1x: number, c1y: number, c2x: number, c2y: number, x: number, y: number): void;
+    arcTo(...a: Parameters<Path2D['arcTo']>): void;
+    ellipse(...a: Parameters<Path2D['ellipse']>): void;
+    roundRect(...a: Parameters<Path2D['roundRect']>): void;
+    addPath(path: Path2D, transform?: DOMMatrix2DInit): void;
+}
+/**
+ * Run `draw` with the global Path2D swapped for RecordedPath, so the paths
+ * it makes record too; put back after, as it was (own property or none).
+ */
+export declare function withRecordedPaths(draw: () => void): void;
+export {};
+//# sourceMappingURL=recordedPath.d.ts.map

package/dist/webgl/recordedPath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recordedPath.d.ts","sourceRoot":"","sources":["../../src/webgl/recordedPath.ts"],"names":[],"mappings":"AAAA,gDAAgD;AAChD,qBAAa,gBAAgB;IAEf,QAAQ,CAAC,EAAE,EAAE,MAAM;IAAE,QAAQ,CAAC,EAAE,EAAE,MAAM;IAAE,QAAQ,CAAC,EAAE,EAAE,MAAM;IAAE,QAAQ,CAAC,EAAE,EAAE,MAAM;IAD9F,QAAQ,CAAC,KAAK,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAM;gBACpC,EAAE,EAAE,MAAM,EAAW,EAAE,EAAE,MAAM,EAAW,EAAE,EAAE,MAAM,EAAW,EAAE,EAAE,MAAM;IAC9F,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;CAIlD;AAED,0EAA0E;AAC1E,QAAA,MAAM,YAAY,EAAE;IAAE,KAAK,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAA;CACiD,CAAC;AAE5G;;;;;;;GAOG;AACH,qBAAa,YAAa,SAAQ,YAAY;IAC5C,QAAQ,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,CAAM;IAC1C,WAAW,UAAS;gBAER,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM;IAUlC,OAAO,CAAC,IAAI;IAMZ,gGAAgG;IAChG,OAAO,CAAC,UAAU;IAKlB,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAClC,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAClC,SAAS,IAAI,IAAI;IACjB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IACtD,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,GAAG,IAAI;IACjF,gBAAgB,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IACpE,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAE7F,KAAK,CAAC,GAAG,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,GAAG,IAAI;IAC9C,OAAO,CAAC,GAAG,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,GAAG,IAAI;IAClD,SAAS,CAAC,GAAG,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,GAAG,IAAI;IAEtD,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,eAAe,GAAG,IAAI;CAQzD;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,IAAI,GAAG,IAAI,CAWxD"}

package/dist/webgl/recordedShaders.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Shaders for drawing recorded Canvas 2D: strokes, filled polygons and
+ * discs, in device pixels. Each fragment works out how much of its pixel the
+ * shape covers, as Canvas 2D antialiasing does, times how much of it the
+ * clip lets through.
+ */
+/**
+ * A stroke, one segment per instance: the segment's two points and two
+ * neighbours either side (x, y, w, length along; w 1 drawn, 0 a neighbour
+ * only, -1 none). The quad covers the segment and its round ends.
+ */
+export declare const STROKE_VS = "#version 300 es\nprecision highp float;\nuniform vec2 u_canvas;\nuniform vec4 u_clip;\n\nvec4 toClip(vec2 dev) {\n  return vec4(dev.x / u_canvas.x * 2.0 - 1.0, 1.0 - dev.y / u_canvas.y * 2.0, 0.0, 1.0);\n}\n\nvec2 corner(int k) {\n  if (k == 0) return vec2(0.0, 0.0);\n  if (k == 1 || k == 4) return vec2(1.0, 0.0);\n  if (k == 2 || k == 3) return vec2(0.0, 1.0);\n  return vec2(1.0, 1.0);\n}\nconst vec4 NOWHERE = vec4(-2.0, -2.0, 0.0, 1.0);\n\nuniform float u_hw;\nin vec4 a_p0;\nin vec4 a_p1;\nin vec4 a_p2;\nin vec4 a_p3;\nin vec4 a_p4;\nin vec4 a_p5;\nflat out vec4 v_p0;\nflat out vec4 v_p1;\nflat out vec4 v_p2;\nflat out vec4 v_p3;\nflat out vec4 v_p4;\nflat out vec4 v_p5;\n\nvoid main() {\n  v_p0 = a_p0; v_p1 = a_p1; v_p2 = a_p2; v_p3 = a_p3; v_p4 = a_p4; v_p5 = a_p5;\n  if (a_p2.z < 0.5 || a_p3.z < 0.5) { gl_Position = NOWHERE; return; }\n  vec2 a = a_p2.xy;\n  vec2 b = a_p3.xy;\n  vec2 d = b - a;\n  float len = length(d);\n  vec2 dir = len > 0.0 ? d / len : vec2(1.0, 0.0);\n  vec2 n = vec2(-dir.y, dir.x);\n  float m = u_hw + 1.0;\n  vec2 cr = corner(gl_VertexID % 6);\n  vec2 pos = mix(a - dir * m, b + dir * m, cr.x) + n * mix(-m, m, cr.y);\n  gl_Position = toClip(pos);\n}\n";
+/**
+ * A stroke is the union of its segments, round where they join: each pixel
+ * is drawn once, by the nearest segment of those around it, with the
+ * coverage of the nearest distance. The line's own ends take its cap. A
+ * dashed line goes segment by segment, its pattern counted along the line.
+ */
+export declare const STROKE_FS = "#version 300 es\nprecision highp float;\nuniform vec2 u_canvas;\nuniform vec4 u_clip;\n\nvec4 toClip(vec2 dev) {\n  return vec4(dev.x / u_canvas.x * 2.0 - 1.0, 1.0 - dev.y / u_canvas.y * 2.0, 0.0, 1.0);\n}\n\n// This fragment's pixel centre in device pixels, y down.\nvec2 pixelCentre() { return vec2(gl_FragCoord.x, u_canvas.y - gl_FragCoord.y); }\n\n// The share of the pixel centred at p inside the clip.\nfloat clipCoverage(vec2 p) {\n  vec2 lo = p - 0.5;\n  vec2 c = clamp(min(lo + 1.0, u_clip.zw) - max(lo, u_clip.xy), 0.0, 1.0);\n  return c.x * c.y;\n}\n\nuniform vec4 u_color;\nuniform float u_hw;\nuniform int u_cap;\nuniform vec4 u_dash;\nflat in vec4 v_p0;\nflat in vec4 v_p1;\nflat in vec4 v_p2;\nflat in vec4 v_p3;\nflat in vec4 v_p4;\nflat in vec4 v_p5;\nout vec4 outColor;\n\nfloat segDist(vec2 p, vec2 a, vec2 b) {\n  vec2 ab = b - a;\n  float l2 = dot(ab, ab);\n  float t = l2 > 0.0 ? clamp(dot(p - a, ab) / l2, 0.0, 1.0) : 0.0;\n  return length(p - a - t * ab);\n}\n\nbool joined(vec4 a, vec4 b) { return a.z > -0.5 && b.z > -0.5; }\n\n// The share of a pixel at distance d from the centre line inside a line hw either side.\nfloat across(float d) { return clamp(min(u_hw, d + 0.5) - max(-u_hw, d - 0.5), 0.0, 1.0); }\n\n// The share of [s - 0.5, s + 0.5] inside [lo, hi].\nfloat span(float s, float lo, float hi) { return clamp(min(s + 0.5, hi) - max(s - 0.5, lo), 0.0, 1.0); }\n\n// The share of [s - 0.5, s + 0.5] on a dash.\nfloat onDash(float s) {\n  float period = u_dash.x + u_dash.y + u_dash.z + u_dash.w;\n  float base = s - mod(s, period);\n  float on = 0.0;\n  for (int k = -1; k <= 1; k++) {\n    float p0 = base + float(k) * period;\n    on += span(s, p0, p0 + u_dash.x);\n    on += span(s, p0 + u_dash.x + u_dash.y, p0 + u_dash.x + u_dash.y + u_dash.z);\n  }\n  return min(on, 1.0);\n}\n\nvoid main() {\n  vec2 p = pixelCentre();\n  float clipCov = clipCoverage(p);\n  if (clipCov <= 0.0) discard;\n  vec2 a = v_p2.xy;\n  vec2 b = v_p3.xy;\n  vec2 ab = b - a;\n  float len = length(ab);\n  vec2 dir = len > 0.0 ? ab / len : vec2(1.0, 0.0);\n  float along = dot(p - a, dir);\n  float perp = abs(dot(p - a, vec2(-dir.y, dir.x)));\n  bool startEnd = v_p1.z < -0.5;\n  bool finalEnd = v_p4.z < -0.5;\n\n  float cov;\n  if (u_dash.x + u_dash.y > 0.0) {\n    cov = across(perp) * onDash(v_p2.w + along) * span(along, 0.0, len);\n  } else {\n    float self = segDist(p, a, b);\n    float nearest = self;\n    if (joined(v_p0, v_p1)) { float d = segDist(p, v_p0.xy, v_p1.xy); if (d <= self) discard; nearest = min(nearest, d); }\n    if (joined(v_p1, v_p2)) { float d = segDist(p, v_p1.xy, v_p2.xy); if (d <= self) discard; nearest = min(nearest, d); }\n    if (joined(v_p3, v_p4)) { float d = segDist(p, v_p3.xy, v_p4.xy); if (d < self) discard; nearest = min(nearest, d); }\n    if (joined(v_p4, v_p5)) { float d = segDist(p, v_p4.xy, v_p5.xy); if (d < self) discard; nearest = min(nearest, d); }\n    cov = across(nearest);\n    // Past an end of the line: its cap, square-ended (butt or square) or round.\n    float before = startEnd ? -along : -1e9;\n    float after = finalEnd ? along - len : -1e9;\n    if (u_cap != 1 && (before > -0.5 || after > -0.5)) {\n      float reach = u_cap == 2 ? u_hw : 0.0;\n      float lo = startEnd ? -reach : -1e9;\n      float hi = finalEnd ? len + reach : 1e9;\n      cov = across(perp) * span(along, lo, hi);\n    }\n  }\n  if (cov <= 0.0) discard;\n  outColor = u_color * (cov * clipCov);\n}\n";
+/**
+ * Filled polygons as spans (polygonSpans.ts), one per instance: between x0
+ * and x1 the fill lies between two straight lines, a and b, whichever is on
+ * top. The quad covers the span's box.
+ */
+export declare const SPAN_VS = "#version 300 es\nprecision highp float;\nuniform vec2 u_canvas;\nuniform vec4 u_clip;\n\nvec4 toClip(vec2 dev) {\n  return vec4(dev.x / u_canvas.x * 2.0 - 1.0, 1.0 - dev.y / u_canvas.y * 2.0, 0.0, 1.0);\n}\n\nvec2 corner(int k) {\n  if (k == 0) return vec2(0.0, 0.0);\n  if (k == 1 || k == 4) return vec2(1.0, 0.0);\n  if (k == 2 || k == 3) return vec2(0.0, 1.0);\n  return vec2(1.0, 1.0);\n}\nconst vec4 NOWHERE = vec4(-2.0, -2.0, 0.0, 1.0);\n\nin vec2 a_x;\nin vec4 a_ab;\nin vec2 a_ends;\nflat out vec2 v_x;\nflat out vec4 v_ab;\nflat out vec2 v_ends;\n\nvoid main() {\n  v_x = a_x;\n  v_ab = a_ab;\n  v_ends = a_ends;\n  float lo = min(min(a_ab.x, a_ab.y), min(a_ab.z, a_ab.w));\n  float hi = max(max(a_ab.x, a_ab.y), max(a_ab.z, a_ab.w));\n  vec2 cr = corner(gl_VertexID % 6);\n  gl_Position = toClip(mix(vec2(floor(a_x.x), floor(lo) - 1.0), vec2(ceil(a_x.y), ceil(hi) + 1.0), cr));\n}\n";
+/**
+ * The share of the pixel inside the span: across, the part of its column
+ * between the two lines (at the pixel's centre); along, whole pixels by
+ * their centre between neighbouring spans (so no seam where they meet), the
+ * part inside at the polygon's own two ends. Then the paint: a colour, or a
+ * linear gradient of up to four stops blended unpremultiplied, as Canvas 2D
+ * blends them.
+ */
+export declare const SPAN_FS = "#version 300 es\nprecision highp float;\nuniform vec2 u_canvas;\nuniform vec4 u_clip;\n\nvec4 toClip(vec2 dev) {\n  return vec4(dev.x / u_canvas.x * 2.0 - 1.0, 1.0 - dev.y / u_canvas.y * 2.0, 0.0, 1.0);\n}\n\n// This fragment's pixel centre in device pixels, y down.\nvec2 pixelCentre() { return vec2(gl_FragCoord.x, u_canvas.y - gl_FragCoord.y); }\n\n// The share of the pixel centred at p inside the clip.\nfloat clipCoverage(vec2 p) {\n  vec2 lo = p - 0.5;\n  vec2 c = clamp(min(lo + 1.0, u_clip.zw) - max(lo, u_clip.xy), 0.0, 1.0);\n  return c.x * c.y;\n}\n\nuniform int u_kind;\nuniform vec4 u_color;\nuniform vec4 u_line;\nuniform vec4 u_offsets;\nuniform int u_stops;\nuniform vec4 u_stop0;\nuniform vec4 u_stop1;\nuniform vec4 u_stop2;\nuniform vec4 u_stop3;\nflat in vec2 v_x;\nflat in vec4 v_ab;\nflat in vec2 v_ends;\nout vec4 outColor;\n\nvec4 stopColor(int i) {\n  if (i == 0) return u_stop0;\n  if (i == 1) return u_stop1;\n  if (i == 2) return u_stop2;\n  return u_stop3;\n}\n\nvec4 gradient(vec2 p) {\n  vec2 g = u_line.zw - u_line.xy;\n  float l2 = dot(g, g);\n  // A gradient of no length paints nothing.\n  if (l2 <= 0.0) return vec4(0.0);\n  float t = dot(p - u_line.xy, g) / l2;\n  vec4 c = stopColor(0);\n  for (int i = 1; i < 4; i++) {\n    if (i >= u_stops) break;\n    float o0 = u_offsets[i - 1];\n    float o1 = u_offsets[i];\n    if (t >= o1) c = stopColor(i);\n    else if (t > o0) { c = mix(stopColor(i - 1), stopColor(i), (t - o0) / max(o1 - o0, 1e-6)); break; }\n    else break;\n  }\n  return vec4(c.rgb * c.a, c.a);\n}\n\nvoid main() {\n  vec2 p = pixelCentre();\n  float x0 = v_x.x;\n  float x1 = v_x.y;\n  float left = v_ends.x > 0.5 ? clamp(p.x + 0.5 - x0, 0.0, 1.0) : (p.x >= x0 ? 1.0 : 0.0);\n  float right = v_ends.y > 0.5 ? clamp(x1 - (p.x - 0.5), 0.0, 1.0) : (p.x < x1 ? 1.0 : 0.0);\n  float along = v_ends.x > 0.5 && v_ends.y > 0.5\n    ? clamp(min(p.x + 0.5, x1) - max(p.x - 0.5, x0), 0.0, 1.0)\n    : min(left, right);\n  float t = clamp((clamp(p.x, x0, x1) - x0) / max(x1 - x0, 1e-6), 0.0, 1.0);\n  float ya = mix(v_ab.x, v_ab.y, t);\n  float yb = mix(v_ab.z, v_ab.w, t);\n  float across = clamp(min(p.y + 0.5, max(ya, yb)) - max(p.y - 0.5, min(ya, yb)), 0.0, 1.0);\n  float cov = along * across * clipCoverage(p);\n  if (cov <= 0.0) discard;\n  vec4 color = u_kind == 1 ? gradient(p) : u_color;\n  outColor = color * cov;\n}\n";
+/** Discs, one per instance: centre, radius, premultiplied colour. */
+export declare const DISC_VS = "#version 300 es\nprecision highp float;\nuniform vec2 u_canvas;\nuniform vec4 u_clip;\n\nvec4 toClip(vec2 dev) {\n  return vec4(dev.x / u_canvas.x * 2.0 - 1.0, 1.0 - dev.y / u_canvas.y * 2.0, 0.0, 1.0);\n}\n\nvec2 corner(int k) {\n  if (k == 0) return vec2(0.0, 0.0);\n  if (k == 1 || k == 4) return vec2(1.0, 0.0);\n  if (k == 2 || k == 3) return vec2(0.0, 1.0);\n  return vec2(1.0, 1.0);\n}\nconst vec4 NOWHERE = vec4(-2.0, -2.0, 0.0, 1.0);\n\nin vec3 a_disc;\nin vec4 a_color;\nflat out vec3 v_disc;\nflat out vec4 v_color;\nvoid main() {\n  v_disc = a_disc;\n  v_color = a_color;\n  float m = a_disc.z + 1.0;\n  gl_Position = toClip(mix(a_disc.xy - m, a_disc.xy + m, corner(gl_VertexID % 6)));\n}\n";
+export declare const DISC_FS = "#version 300 es\nprecision highp float;\nuniform vec2 u_canvas;\nuniform vec4 u_clip;\n\nvec4 toClip(vec2 dev) {\n  return vec4(dev.x / u_canvas.x * 2.0 - 1.0, 1.0 - dev.y / u_canvas.y * 2.0, 0.0, 1.0);\n}\n\n// This fragment's pixel centre in device pixels, y down.\nvec2 pixelCentre() { return vec2(gl_FragCoord.x, u_canvas.y - gl_FragCoord.y); }\n\n// The share of the pixel centred at p inside the clip.\nfloat clipCoverage(vec2 p) {\n  vec2 lo = p - 0.5;\n  vec2 c = clamp(min(lo + 1.0, u_clip.zw) - max(lo, u_clip.xy), 0.0, 1.0);\n  return c.x * c.y;\n}\n\nflat in vec3 v_disc;\nflat in vec4 v_color;\nout vec4 outColor;\nvoid main() {\n  vec2 p = pixelCentre();\n  float cov = clamp(v_disc.z + 0.5 - length(p - v_disc.xy), 0.0, 1.0) * clipCoverage(p);\n  if (cov <= 0.0) discard;\n  outColor = v_color * cov;\n}\n";
+//# sourceMappingURL=recordedShaders.d.ts.map

package/dist/webgl/recordedShaders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recordedShaders.d.ts","sourceRoot":"","sources":["../../src/webgl/recordedShaders.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAkCH;;;;GAIG;AACH,eAAO,MAAM,SAAS,grCA6BrB,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,SAAS,w4GA+ErB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,OAAO,i4BAiBnB,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,OAAO,00EA0DnB,CAAC;AAEF,qEAAqE;AACrE,eAAO,MAAM,OAAO,msBAWnB,CAAC;AAEF,eAAO,MAAM,OAAO,yzBAUnB,CAAC"}

package/dist/webgl/recorder.d.ts

@@ -0,0 +1,67 @@
+import { Rect } from '@tradecanvas/commons';
+import { GpuRecorder, GpuRegion } from '../engine/gpu.js';
+import { GpuCommand } from './recordedCommands.js';
+export type { Box, GpuCommand, GpuPaint } from './recordedCommands.js';
+export { anyOverlap } from './recordedCommands.js';
+declare class Recorder implements GpuRecorder {
+    private readonly dpr;
+    private readonly measure;
+    readonly commands: GpuCommand[];
+    readonly ctx: CanvasRenderingContext2D;
+    /** Where text goes: the region being recorded. */
+    private texts;
+    private state;
+    private stack;
+    private path;
+    private ok;
+    constructor(dpr: number, measure: CanvasRenderingContext2D | null);
+    region(clip: Rect): GpuRegion;
+    private reset;
+    private unsupported;
+    private copyState;
+    /** Whether the transform keeps axes axis-aligned (no rotation or skew). */
+    private axisAligned;
+    /** Axis-aligned and the same scale both ways: lines keep their width, circles stay round. */
+    private uniform;
+    private setMatrix;
+    private multiply;
+    private current;
+    private moveTo;
+    private lineTo;
+    private closePath;
+    private rect;
+    private arc;
+    /** A curve flattened into lines (the GPU draws only lines), finer as it is longer. */
+    private curve;
+    private withPath;
+    /** Run `use` on `path`'s shape instead of the current path. */
+    private onPath;
+    /** The style as the GPU paints it, or null when it can't. */
+    private paint;
+    /** Whether the state draws as plain source-over paint (no shadow, filter or other blending). */
+    private plain;
+    private fill;
+    private fillRects;
+    private stroke;
+    /** The dash pattern in device pixels as two on-off pairs, null for solid; undefined when the GPU can't dash these lines (it dashes single segments, butt-capped). */
+    private dash;
+    /**
+     * Whether the GPU's stroke looks as Canvas 2D's would: joins round enough
+     * to pass for the `lineJoin` asked for, pieces that don't overlap (Canvas
+     * 2D paints their union once), and, see-through, no segment so short that
+     * a pixel might be painted by more than the nearest few.
+     */
+    private drawsAlike;
+    /** Clip to the path: one axis-aligned rectangle (the winding rule makes no difference to it). */
+    private clip;
+    private text;
+    private measureText;
+    private methods;
+    private proxy;
+    /** A state property set as Canvas 2D sets it: invalid values are ignored. */
+    private setProp;
+}
+/** A recorder for one frame at `dpr`; `measure` measures text (and lends its canvas). */
+export declare function createRecorder(dpr: number, measure: CanvasRenderingContext2D | null): Recorder;
+export type { Recorder };
+//# sourceMappingURL=recorder.d.ts.map

package/dist/webgl/recorder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recorder.d.ts","sourceRoot":"","sources":["../../src/webgl/recorder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAC;AACjD,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAG/D,OAAO,EAAsD,KAAK,UAAU,EAAiB,MAAM,uBAAuB,CAAC;AAI3H,YAAY,EAAE,GAAG,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACvE,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAyEnD,cAAM,QAAS,YAAW,WAAW;IAUvB,OAAO,CAAC,QAAQ,CAAC,GAAG;IAAU,OAAO,CAAC,QAAQ,CAAC,OAAO;IATlE,QAAQ,CAAC,QAAQ,EAAE,UAAU,EAAE,CAAM;IACrC,QAAQ,CAAC,GAAG,EAAE,wBAAwB,CAAC;IACvC,kDAAkD;IAClD,OAAO,CAAC,KAAK,CAAgB;IAC7B,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,KAAK,CAAe;IAC5B,OAAO,CAAC,IAAI,CAAiB;IAC7B,OAAO,CAAC,EAAE,CAAQ;gBAEW,GAAG,EAAE,MAAM,EAAmB,OAAO,EAAE,wBAAwB,GAAG,IAAI;IAKnG,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,SAAS;IAwB7B,OAAO,CAAC,KAAK;IA6Bb,OAAO,CAAC,WAAW;IAInB,OAAO,CAAC,SAAS;IAOjB,2EAA2E;IAC3E,OAAO,CAAC,WAAW;IAKnB,6FAA6F;IAC7F,OAAO,CAAC,OAAO;IAKf,OAAO,CAAC,SAAS;IAIjB,OAAO,CAAC,QAAQ;IAOhB,OAAO,CAAC,OAAO;IAIf,OAAO,CAAC,MAAM;IAMd,OAAO,CAAC,MAAM;IAUd,OAAO,CAAC,SAAS;IAQjB,OAAO,CAAC,IAAI;IAcZ,OAAO,CAAC,GAAG;IAyBX,sFAAsF;IACtF,OAAO,CAAC,KAAK;IAqBb,OAAO,CAAC,QAAQ;IAQhB,+DAA+D;IAC/D,OAAO,CAAC,MAAM;IAiBd,6DAA6D;IAC7D,OAAO,CAAC,KAAK;IAsBb,gGAAgG;IAChG,OAAO,CAAC,KAAK;IAQb,OAAO,CAAC,IAAI;IAiCZ,OAAO,CAAC,SAAS;IAWjB,OAAO,CAAC,MAAM;IAkBd,qKAAqK;IACrK,OAAO,CAAC,IAAI;IAUZ;;;;;OAKG;IACH,OAAO,CAAC,UAAU;IAYlB,iGAAiG;IACjG,OAAO,CAAC,IAAI;IAMZ,OAAO,CAAC,IAAI;IAMZ,OAAO,CAAC,WAAW;IAYnB,OAAO,CAAC,OAAO;IA0Cf,OAAO,CAAC,KAAK;IAqBb,6EAA6E;IAC7E,OAAO,CAAC,OAAO;CAmBhB;AAoCD,yFAAyF;AACzF,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,wBAAwB,GAAG,IAAI,GAAG,QAAQ,CAE9F;AAED,YAAY,EAAE,QAAQ,EAAE,CAAC"}

package/dist/webgl/seriesUploads.d.ts

@@ -0,0 +1,40 @@
+import { DataSeries } from '@tradecanvas/commons';
+/** Floats per bar on the GPU: open, high, low, close (from the base price), volume, up (1) or down (0). */
+export declare const FLOATS_PER_BAR = 6;
+/** The bars to write to the GPU buffer after a `sync`: `[from, to)`, or all of them. */
+export interface SeriesChange {
+    full: boolean;
+    from: number;
+    to: number;
+}
+/**
+ * The series as the GPU takes it, kept in step with the chart's bars at the
+ * least cost. Prices are stored relative to a base price (float32 keeps 24
+ * bits: 84,814.20 in absolute terms would lose its cents) and the direction
+ * is stored as a flag, so a bar is never mistaken for up or down by float
+ * rounding. The chart ticks and appends in the same array: a live tick
+ * rewrites one bar and new bars are appended. A new array (new data, older
+ * bars paged in) or a changed bar in a sample of the rest writes everything.
+ */
+export declare class SeriesUploads {
+    private buffer;
+    private count;
+    private basePrice;
+    /**
+     * Bars as they were written, to tell a tick from new history: the last
+     * one, the one before it, and a sample spread over the rest.
+     */
+    private samples;
+    private last;
+    /** The array last written: the chart ticks and appends in place, and replaces it for new history. */
+    private source;
+    get values(): Float32Array;
+    get length(): number;
+    get base(): number;
+    sync(data: DataSeries): SeriesChange;
+    private reset;
+    private ensure;
+    private write;
+    private remember;
+}
+//# sourceMappingURL=seriesUploads.d.ts.map

package/dist/webgl/seriesUploads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seriesUploads.d.ts","sourceRoot":"","sources":["../../src/webgl/seriesUploads.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAW,MAAM,sBAAsB,CAAC;AAEhE,2GAA2G;AAC3G,eAAO,MAAM,cAAc,IAAI,CAAC;AAEhC,wFAAwF;AACxF,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,OAAO,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACZ;AAKD;;;;;;;;GAQG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,SAAS,CAAK;IACtB;;;OAGG;IACH,OAAO,CAAC,OAAO,CAAyC;IACxD,OAAO,CAAC,IAAI,CAAwB;IACpC,qGAAqG;IACrG,OAAO,CAAC,MAAM,CAA2B;IAEzC,IAAI,MAAM,IAAI,YAAY,CAEzB;IAED,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,YAAY;IA8BpC,OAAO,CAAC,KAAK;IAOb,OAAO,CAAC,MAAM;IAMd,OAAO,CAAC,KAAK;IAgBb,OAAO,CAAC,QAAQ;CAajB"}

package/dist/webgl/shaders.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The shaders. Each draws axis-aligned rectangles, one instance per
+ * rectangle under the bars, bar (or pixel column when zoomed out), placed on
+ * device pixels by the same rules as `charts/pixelGrid.ts`, so GPU bars line
+ * up with what the 2D layer draws over them (crosshair, drawings). `floor(v + 0.5)` is used for
+ * rounding: GLSL's `round()` may round halves either way, `Math.round` does not.
+ */
+/** Candles, a bar per instance: 6 vertices for the wick, then 6 for the body. */
+export declare const CANDLE_BARS_VS = "#version 300 es\nprecision highp float;\nuniform vec2 u_canvas;\nuniform float u_dpr;\nuniform int u_log;\nuniform int u_invert;\nuniform float u_yA;\nuniform float u_yB;\nuniform float u_logOffset;\nuniform float u_min;\nuniform float u_logFloor;\nuniform float u_logK;\nuniform float u_top;\nuniform float u_bottom;\nout vec4 v_color;\n\n// A price (relative to the base price) to a CSS-pixel y, as priceToYMapper\n// does; mappedY in yMapping.ts is the same steps in TypeScript.\nfloat cssY(float rel) {\n  if (u_log == 1) {\n    float v = log(max(1.0 + (rel + u_logOffset) / u_min, u_logFloor)) * u_logK;\n    return u_invert == 1 ? u_top + v : u_bottom - v;\n  }\n  return u_yA + rel * u_yB;\n}\n\nfloat snap(float v) { return floor(v + 0.5); }\n\nvec4 toClip(vec2 dev) {\n  return vec4(dev.x / u_canvas.x * 2.0 - 1.0, 1.0 - dev.y / u_canvas.y * 2.0, 0.0, 1.0);\n}\n\n// The corners of a quad as two triangles.\nvec2 corner(int k) {\n  if (k == 0) return vec2(0.0, 0.0);\n  if (k == 1 || k == 4) return vec2(1.0, 0.0);\n  if (k == 2 || k == 3) return vec2(0.0, 1.0);\n  return vec2(1.0, 1.0);\n}\n\n// Nothing to draw: every vertex at one point off the canvas.\nconst vec4 NOWHERE = vec4(-2.0, -2.0, 0.0, 1.0);\n\nin vec4 a_ohlc;\nin vec2 a_vd;\nuniform float u_x0;\nuniform float u_unit;\nuniform float u_wick;\nuniform float u_body;\nuniform vec4 u_upBody;\nuniform vec4 u_downBody;\nuniform vec4 u_upWick;\nuniform vec4 u_downWick;\n\nvoid main() {\n  int vid = gl_VertexID % 12;\n  vec2 cr = corner(vid % 6);\n  bool up = a_vd.y > 0.5;\n  float cx = (u_x0 + float(gl_InstanceID) * u_unit) * u_dpr;\n  float wickLeft = snap(cx - u_wick * 0.5);\n  float left;\n  float width;\n  float top;\n  float height;\n  if (vid < 6) {\n    float h = snap(cssY(a_ohlc.y) * u_dpr);\n    float l = snap(cssY(a_ohlc.z) * u_dpr);\n    left = wickLeft;\n    width = u_wick;\n    top = min(h, l);\n    height = max(abs(l - h), 1.0);\n    v_color = up ? u_upWick : u_downWick;\n  } else {\n    float o = snap(cssY(a_ohlc.x) * u_dpr);\n    float c = snap(cssY(a_ohlc.w) * u_dpr);\n    left = wickLeft - (u_body - u_wick) * 0.5;\n    width = u_body;\n    top = min(o, c);\n    height = max(abs(c - o), u_wick);\n    v_color = up ? u_upBody : u_downBody;\n  }\n  gl_Position = toClip(vec2(left + cr.x * width, top + cr.y * height));\n}\n";
+/** Volume, a bar per instance, under the candle bodies. */
+export declare const VOLUME_BARS_VS = "#version 300 es\nprecision highp float;\nuniform vec2 u_canvas;\nuniform float u_dpr;\nuniform int u_log;\nuniform int u_invert;\nuniform float u_yA;\nuniform float u_yB;\nuniform float u_logOffset;\nuniform float u_min;\nuniform float u_logFloor;\nuniform float u_logK;\nuniform float u_top;\nuniform float u_bottom;\nout vec4 v_color;\n\n// A price (relative to the base price) to a CSS-pixel y, as priceToYMapper\n// does; mappedY in yMapping.ts is the same steps in TypeScript.\nfloat cssY(float rel) {\n  if (u_log == 1) {\n    float v = log(max(1.0 + (rel + u_logOffset) / u_min, u_logFloor)) * u_logK;\n    return u_invert == 1 ? u_top + v : u_bottom - v;\n  }\n  return u_yA + rel * u_yB;\n}\n\nfloat snap(float v) { return floor(v + 0.5); }\n\nvec4 toClip(vec2 dev) {\n  return vec4(dev.x / u_canvas.x * 2.0 - 1.0, 1.0 - dev.y / u_canvas.y * 2.0, 0.0, 1.0);\n}\n\n// The corners of a quad as two triangles.\nvec2 corner(int k) {\n  if (k == 0) return vec2(0.0, 0.0);\n  if (k == 1 || k == 4) return vec2(1.0, 0.0);\n  if (k == 2 || k == 3) return vec2(0.0, 1.0);\n  return vec2(1.0, 1.0);\n}\n\n// Nothing to draw: every vertex at one point off the canvas.\nconst vec4 NOWHERE = vec4(-2.0, -2.0, 0.0, 1.0);\n\nin vec4 a_ohlc;\nin vec2 a_vd;\nuniform float u_x0;\nuniform float u_unit;\nuniform float u_wick;\nuniform float u_body;\nuniform float u_volBottom;\nuniform float u_volScale;\nuniform vec4 u_volUp;\nuniform vec4 u_volDown;\n\nvoid main() {\n  vec2 cr = corner(gl_VertexID % 6);\n  float cx = (u_x0 + float(gl_InstanceID) * u_unit) * u_dpr;\n  float left = snap(cx - u_wick * 0.5) - (u_body - u_wick) * 0.5;\n  float bottom = snap(u_volBottom * u_dpr);\n  float top = snap((u_volBottom - a_vd.x * u_volScale) * u_dpr);\n  if (bottom - top < 1.0) { gl_Position = NOWHERE; v_color = vec4(0.0); return; }\n  v_color = a_vd.y > 0.5 ? u_volUp : u_volDown;\n  gl_Position = toClip(vec2(left + cr.x * u_body, top + cr.y * (bottom - top)));\n}\n";
+/**
+ * Zoomed out: a pixel column per instance, from the CPU (x, high, low,
+ * volume, up), reaching the next column with no gap.
+ */
+export declare const CANDLE_COLUMNS_VS = "#version 300 es\nprecision highp float;\nuniform vec2 u_canvas;\nuniform float u_dpr;\nuniform int u_log;\nuniform int u_invert;\nuniform float u_yA;\nuniform float u_yB;\nuniform float u_logOffset;\nuniform float u_min;\nuniform float u_logFloor;\nuniform float u_logK;\nuniform float u_top;\nuniform float u_bottom;\nout vec4 v_color;\n\n// A price (relative to the base price) to a CSS-pixel y, as priceToYMapper\n// does; mappedY in yMapping.ts is the same steps in TypeScript.\nfloat cssY(float rel) {\n  if (u_log == 1) {\n    float v = log(max(1.0 + (rel + u_logOffset) / u_min, u_logFloor)) * u_logK;\n    return u_invert == 1 ? u_top + v : u_bottom - v;\n  }\n  return u_yA + rel * u_yB;\n}\n\nfloat snap(float v) { return floor(v + 0.5); }\n\nvec4 toClip(vec2 dev) {\n  return vec4(dev.x / u_canvas.x * 2.0 - 1.0, 1.0 - dev.y / u_canvas.y * 2.0, 0.0, 1.0);\n}\n\n// The corners of a quad as two triangles.\nvec2 corner(int k) {\n  if (k == 0) return vec2(0.0, 0.0);\n  if (k == 1 || k == 4) return vec2(1.0, 0.0);\n  if (k == 2 || k == 3) return vec2(0.0, 1.0);\n  return vec2(1.0, 1.0);\n}\n\n// Nothing to draw: every vertex at one point off the canvas.\nconst vec4 NOWHERE = vec4(-2.0, -2.0, 0.0, 1.0);\n\nin vec4 a_col;\nin float a_up;\nuniform vec4 u_upBody;\nuniform vec4 u_downBody;\n\nvoid main() {\n  vec2 cr = corner(gl_VertexID % 6);\n  float left = snap(a_col.x * u_dpr);\n  float width = max(1.0, snap((a_col.x + 1.0) * u_dpr) - left);\n  float t = snap(cssY(a_col.y) * u_dpr);\n  float b = snap(cssY(a_col.z) * u_dpr);\n  v_color = a_up > 0.5 ? u_upBody : u_downBody;\n  gl_Position = toClip(vec2(left + cr.x * width, min(t, b) + cr.y * max(abs(b - t), 1.0)));\n}\n";
+export declare const VOLUME_COLUMNS_VS = "#version 300 es\nprecision highp float;\nuniform vec2 u_canvas;\nuniform float u_dpr;\nuniform int u_log;\nuniform int u_invert;\nuniform float u_yA;\nuniform float u_yB;\nuniform float u_logOffset;\nuniform float u_min;\nuniform float u_logFloor;\nuniform float u_logK;\nuniform float u_top;\nuniform float u_bottom;\nout vec4 v_color;\n\n// A price (relative to the base price) to a CSS-pixel y, as priceToYMapper\n// does; mappedY in yMapping.ts is the same steps in TypeScript.\nfloat cssY(float rel) {\n  if (u_log == 1) {\n    float v = log(max(1.0 + (rel + u_logOffset) / u_min, u_logFloor)) * u_logK;\n    return u_invert == 1 ? u_top + v : u_bottom - v;\n  }\n  return u_yA + rel * u_yB;\n}\n\nfloat snap(float v) { return floor(v + 0.5); }\n\nvec4 toClip(vec2 dev) {\n  return vec4(dev.x / u_canvas.x * 2.0 - 1.0, 1.0 - dev.y / u_canvas.y * 2.0, 0.0, 1.0);\n}\n\n// The corners of a quad as two triangles.\nvec2 corner(int k) {\n  if (k == 0) return vec2(0.0, 0.0);\n  if (k == 1 || k == 4) return vec2(1.0, 0.0);\n  if (k == 2 || k == 3) return vec2(0.0, 1.0);\n  return vec2(1.0, 1.0);\n}\n\n// Nothing to draw: every vertex at one point off the canvas.\nconst vec4 NOWHERE = vec4(-2.0, -2.0, 0.0, 1.0);\n\nin vec4 a_col;\nin float a_up;\nuniform float u_volBottom;\nuniform float u_volScale;\nuniform vec4 u_volUp;\nuniform vec4 u_volDown;\n\nvoid main() {\n  vec2 cr = corner(gl_VertexID % 6);\n  float left = snap(a_col.x * u_dpr);\n  float width = max(1.0, snap((a_col.x + 1.0) * u_dpr) - left);\n  float bottom = snap(u_volBottom * u_dpr);\n  float top = snap((u_volBottom - a_col.w * u_volScale) * u_dpr);\n  if (bottom - top < 1.0) { gl_Position = NOWHERE; v_color = vec4(0.0); return; }\n  v_color = a_up > 0.5 ? u_volUp : u_volDown;\n  gl_Position = toClip(vec2(left + cr.x * width, top + cr.y * (bottom - top)));\n}\n";
+/**
+ * Rectangles under the bars (grid lines, session shading, break lines): one
+ * per instance, in CSS pixels (left, top, right, bottom), in a premultiplied
+ * colour, dashed down from the top when a_dash (on, off) is set. The quad
+ * covers every device pixel the rectangle touches; the fragment shader works
+ * out how much of each it covers, as Canvas 2D antialiases an edge at a
+ * fractional pixel ratio.
+ */
+export declare const RECT_VS = "#version 300 es\nprecision highp float;\nuniform vec2 u_canvas;\nuniform float u_dpr;\nuniform int u_log;\nuniform int u_invert;\nuniform float u_yA;\nuniform float u_yB;\nuniform float u_logOffset;\nuniform float u_min;\nuniform float u_logFloor;\nuniform float u_logK;\nuniform float u_top;\nuniform float u_bottom;\nout vec4 v_color;\n\n// A price (relative to the base price) to a CSS-pixel y, as priceToYMapper\n// does; mappedY in yMapping.ts is the same steps in TypeScript.\nfloat cssY(float rel) {\n  if (u_log == 1) {\n    float v = log(max(1.0 + (rel + u_logOffset) / u_min, u_logFloor)) * u_logK;\n    return u_invert == 1 ? u_top + v : u_bottom - v;\n  }\n  return u_yA + rel * u_yB;\n}\n\nfloat snap(float v) { return floor(v + 0.5); }\n\nvec4 toClip(vec2 dev) {\n  return vec4(dev.x / u_canvas.x * 2.0 - 1.0, 1.0 - dev.y / u_canvas.y * 2.0, 0.0, 1.0);\n}\n\n// The corners of a quad as two triangles.\nvec2 corner(int k) {\n  if (k == 0) return vec2(0.0, 0.0);\n  if (k == 1 || k == 4) return vec2(1.0, 0.0);\n  if (k == 2 || k == 3) return vec2(0.0, 1.0);\n  return vec2(1.0, 1.0);\n}\n\n// Nothing to draw: every vertex at one point off the canvas.\nconst vec4 NOWHERE = vec4(-2.0, -2.0, 0.0, 1.0);\n\nin vec4 a_rect;\nin vec4 a_color;\nin vec2 a_dash;\nflat out vec4 v_rect;\nflat out vec2 v_dash;\n\nvoid main() {\n  vec2 cr = corner(gl_VertexID % 6);\n  v_rect = a_rect * u_dpr;\n  v_dash = a_dash * u_dpr;\n  v_color = a_color;\n  gl_Position = toClip(mix(floor(v_rect.xy), ceil(v_rect.zw), cr));\n}\n";
+/**
+ * The colour times the share of the pixel covered. For the grid (u_union),
+ * coverage goes out as alpha, so that where lines cross the blend gives the
+ * union of their coverage, as one 2D path does.
+ */
+export declare const RECT_FS = "#version 300 es\nprecision highp float;\nuniform vec2 u_canvas;\nuniform int u_union;\nin vec4 v_color;\nflat in vec4 v_rect;\nflat in vec2 v_dash;\nout vec4 outColor;\n\n// The share of rows [y, y + 1] inside the rectangle and, dashed, on a dash.\nfloat rows(float y) {\n  float lo = max(y, v_rect.y);\n  float hi = min(y + 1.0, v_rect.w);\n  if (hi <= lo) return 0.0;\n  if (v_dash.x <= 0.0) return hi - lo;\n  // A dash period is longer than a device pixel, so the row meets the dash\n  // of the period it starts in and the next (a third to spare).\n  float period = v_dash.x + v_dash.y;\n  float first = v_rect.y + floor((lo - v_rect.y) / period) * period;\n  float on = 0.0;\n  for (int i = 0; i < 3; i++) {\n    float start = first + float(i) * period;\n    on += max(0.0, min(hi, start + v_dash.x) - max(lo, start));\n  }\n  return on;\n}\n\nvoid main() {\n  // This pixel's top-left corner in device pixels, y down.\n  vec2 p = vec2(floor(gl_FragCoord.x), u_canvas.y - floor(gl_FragCoord.y) - 1.0);\n  float coverage = clamp(min(p.x + 1.0, v_rect.z) - max(p.x, v_rect.x), 0.0, 1.0) * rows(p.y);\n  outColor = u_union == 1 ? vec4(v_color.rgb * coverage, coverage) : v_color * coverage;\n}\n";
+/**
+ * Every bar program fills with its (premultiplied) colour, clipped to the
+ * plot: a pixel the plot's edge cuts gets the share inside, as a 2D clip
+ * antialiases an edge at a fractional pixel ratio.
+ */
+export declare const FILL_FS = "#version 300 es\nprecision highp float;\nuniform vec2 u_canvas;\nuniform vec4 u_clip;\nin vec4 v_color;\nout vec4 outColor;\n\nvoid main() {\n  vec2 p = vec2(floor(gl_FragCoord.x), u_canvas.y - floor(gl_FragCoord.y) - 1.0);\n  vec2 c = clamp(min(p + 1.0, u_clip.zw) - max(p, u_clip.xy), 0.0, 1.0);\n  outColor = v_color * (c.x * c.y);\n}\n";
+//# sourceMappingURL=shaders.d.ts.map

package/dist/webgl/shaders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shaders.d.ts","sourceRoot":"","sources":["../../src/webgl/shaders.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AA8CH,iFAAiF;AACjF,eAAO,MAAM,cAAc,wxEAyC1B,CAAC;AAEF,2DAA2D;AAC3D,eAAO,MAAM,cAAc,y6DAsB1B,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,iBAAiB,8pDAe7B,CAAC;AAEF,eAAO,MAAM,iBAAiB,ozDAkB7B,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,OAAO,u/CAcnB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,OAAO,mrCAiCnB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,OAAO,wVAYnB,CAAC"}

package/dist/webgl/strokeGeometry.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Strokes as the GPU draws them: round where segments join. Canvas 2D joins
+ * by `lineJoin` (miter by default); the two differ only at the outside of a
+ * turn, and only by a sliver until the turn gets sharp.
+ */
+/** A line to stroke: x, y pairs in device pixels. */
+export interface Polyline {
+    points: number[];
+    closed: boolean;
+}
+/**
+ * Whether a join of `line` turns sharply enough that a `join` join of half
+ * width `hw` would visibly differ from a round one. A miter reaches
+ * hw / cos(θ/2) out at a turn of θ (bevelled past `miterLimit`), a bevel
+ * stops at hw·cos(θ/2); a round join reaches hw.
+ */
+export declare function hasSharpJoin(line: Polyline, hw: number, join: CanvasLineJoin, miterLimit: number): boolean;
+/** Whether some segment of `line` is shorter than `length`. */
+export declare function hasShortSegment(line: Polyline, length: number): boolean;
+/**
+ * The lines packed for the stroke shader: x, y, w, cum per point, where w is
+ * 1 for a point of the line, 0 for a neighbour only (a closed line's corners
+ * repeated around its seam), -1 for a break; cum is the length along the
+ * line so far. Two points come before the first segment and two after the
+ * last, so each segment sees two neighbours either side.
+ */
+export declare function packStroke(lines: readonly Polyline[]): number[];
+//# sourceMappingURL=strokeGeometry.d.ts.map

package/dist/webgl/strokeGeometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strokeGeometry.d.ts","sourceRoot":"","sources":["../../src/webgl/strokeGeometry.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,qDAAqD;AACrD,MAAM,WAAW,QAAQ;IACvB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;CACjB;AAKD;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAsB1G;AAED,+DAA+D;AAC/D,wBAAgB,eAAe,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAMvE;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,QAAQ,EAAE,GAAG,MAAM,EAAE,CA2B/D"}

package/dist/webgl/yMapping.d.ts

@@ -0,0 +1,32 @@
+import { ViewportState } from '@tradecanvas/commons';
+/**
+ * Price-to-pixel uniforms for a frame, as `priceToYMapper` maps (linear or
+ * log, upright or inverted). Prices reach the GPU relative to a base price.
+ */
+export interface YMapping {
+    log: number;
+    invert: number;
+    /** Linear: y = yA + rel * yB. */
+    yA: number;
+    yB: number;
+    /** Log: the base price less the lowest price, and the lowest price. */
+    logOffset: number;
+    min: number;
+    /** Log: the smallest price ratio to the lowest price taken, as `priceToYMapper` floors prices at `Number.EPSILON`. */
+    logFloor: number;
+    logK: number;
+    top: number;
+    bottom: number;
+}
+export declare function yMapping(viewport: ViewportState, base: number): YMapping;
+/**
+ * The CSS-pixel y the shaders compute for a price `rel` above the base
+ * (`cssY` in shaders.ts), step by step; `f` rounds each step, as float32
+ * does on the GPU (identity for double precision).
+ *
+ * Log scale goes through log(1 + (price − min) / min) rather than
+ * log(price) − log(min): float32 keeps the small difference exactly where
+ * the two large logarithms would lose it.
+ */
+export declare function mappedY(m: YMapping, rel: number, f?: (x: number) => number): number;
+//# sourceMappingURL=yMapping.d.ts.map

package/dist/webgl/yMapping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"yMapping.d.ts","sourceRoot":"","sources":["../../src/webgl/yMapping.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1D;;;GAGG;AACH,MAAM,WAAW,QAAQ;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,iCAAiC;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,uEAAuE;IACvE,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,sHAAsH;IACtH,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,GAAG,QAAQ,CAgBxE;AAED;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,GAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAiB,GAAG,MAAM,CAO7F"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tradecanvas/core",
-  "version": "1.4.0",
+  "version": "1.10.0",
   "type": "module",
   "description": "Canvas rendering engine for @tradecanvas/chart",
   "license": "MIT",
@@ -34,7 +34,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@tradecanvas/commons": "1.4.0"
+    "@tradecanvas/commons": "1.10.0"
   },
   "devDependencies": {
     "jsdom": "^25.0.1",