pts 1.0.1 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pts",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "A library for visualization and creative coding.",
   "type": "commonjs",
   "main": "./dist/index.js",

package/src/Color.ts

@@ -5,6 +5,32 @@ import { Util } from "./Util";
 import { Num, Geom } from "./Num";
 import { type PtLike, type ColorType } from "./Types";
 
+// Module state behind Color's static accessors: a static field would be
+// emitted as an assignment after the class, which bundlers keep, and with it
+// the class and everything it references (see Util.ts). The initializers are
+// marked pure so a bundle without Color drops them. Internal code reads
+// `Color.ranges`, not `_colorRanges`, so redefining the static still reaches
+// the conversions.
+
+// XYZ property for Standard Observer 2deg, Daylight/sRGB illuminant D65
+const D65 = /* @__PURE__ */ new Pt(95.047, 100, 108.883, 1);
+
+let _colorRanges: { [name: string]: Group } = /* @__PURE__ */ colorRanges();
+
+function colorRanges(): { [name: string]: Group } {
+  return {
+    rgb: new Group(new Pt(0, 255), new Pt(0, 255), new Pt(0, 255)),
+    hsl: new Group(new Pt(0, 360), new Pt(0, 1), new Pt(0, 1)),
+    hsb: new Group(new Pt(0, 360), new Pt(0, 1), new Pt(0, 1)),
+    lab: new Group(new Pt(0, 100), new Pt(-128, 127), new Pt(-128, 127)),
+    lch: new Group(new Pt(0, 100), new Pt(0, 100), new Pt(0, 360)),
+    luv: new Group(new Pt(0, 100), new Pt(-134, 220), new Pt(-140, 122)),
+    xyz: new Group(new Pt(0, 100), new Pt(0, 100), new Pt(0, 100)),
+    oklab: new Group(new Pt(0, 1), new Pt(-0.4, 0.4), new Pt(-0.4, 0.4)),
+    oklch: new Group(new Pt(0, 1), new Pt(0, 0.4), new Pt(0, 360)),
+  };
+}
+
 /**
  * Color is a subclass of Pt. Since a color in a color space is analogous to a point or vector in a space, you can apply all Pt operations to colors too. The Color class provides support for many color spaces like HSL and LAB.
  * Convert non-RGB colors to RGB before using `.hex`, `.rgb`, or `.rgba` for rendering. These getters format the channels; they don't convert between color spaces.
@@ -15,26 +41,28 @@ import { type PtLike, type ColorType } from "./Types";
  * ```
  */
 export class Color extends Pt {
-  // XYZ property for Standard Observer 2deg, Daylight/sRGB illuminant D65
-  private static D65: PtLike = new Pt(95.047, 100, 108.883, 1);
-
   protected _mode: ColorType = "rgb";
   private _isNorm: boolean = false;
 
   /**
    * Value range for each color space
    */
-  static ranges: { [name: string]: Group } = {
-    rgb: new Group(new Pt(0, 255), new Pt(0, 255), new Pt(0, 255)),
-    hsl: new Group(new Pt(0, 360), new Pt(0, 1), new Pt(0, 1)),
-    hsb: new Group(new Pt(0, 360), new Pt(0, 1), new Pt(0, 1)),
-    lab: new Group(new Pt(0, 100), new Pt(-128, 127), new Pt(-128, 127)),
-    lch: new Group(new Pt(0, 100), new Pt(0, 100), new Pt(0, 360)),
-    luv: new Group(new Pt(0, 100), new Pt(-134, 220), new Pt(-140, 122)),
-    xyz: new Group(new Pt(0, 100), new Pt(0, 100), new Pt(0, 100)),
-    oklab: new Group(new Pt(0, 1), new Pt(-0.4, 0.4), new Pt(-0.4, 0.4)),
-    oklch: new Group(new Pt(0, 1), new Pt(0, 0.4), new Pt(0, 360)),
-  };
+  static get ranges(): { [name: string]: Group } {
+    return _colorRanges;
+  }
+  static set ranges(value: { [name: string]: Group }) {
+    // as with a static field, an assignment on a subclass stays on the subclass
+    if (this === Color) {
+      _colorRanges = value;
+    } else {
+      Object.defineProperty(this, "ranges", {
+        value,
+        writable: true,
+        enumerable: true,
+        configurable: true,
+      });
+    }
+  }
 
   /**
    * Create a Color. Same as creating a Pt. Optionally you may use [`Color.from`](#link) to create a color.
@@ -779,7 +807,7 @@ export class Color extends Pt {
     const kap = 24389 / 27;
 
     // adjust for D65
-    c.divide(Color.D65);
+    c.divide(D65);
 
     const fn = (n: number) => (n > eps ? Math.cbrt(n) : (kap * n + 16) / 116);
     const cy = fn(c[1]);
@@ -812,7 +840,7 @@ export class Color extends Pt {
     const eps = 216 / 24389;
     const kap = 24389 / 27;
 
-    const d = Color.D65;
+    const d = D65;
     const xxx = Math.pow(x, 3);
     const zzz = Math.pow(z, 3);
 
@@ -850,12 +878,8 @@ export class Color extends Pt {
     y = y / 100;
     const L = y > eps ? 116 * Math.cbrt(y) - 16 : kap * y;
 
-    const refU =
-      (4 * Color.D65[0]) /
-      (Color.D65[0] + 15 * Color.D65[1] + 3 * Color.D65[2]);
-    const refV =
-      (9 * Color.D65[1]) /
-      (Color.D65[0] + 15 * Color.D65[1] + 3 * Color.D65[2]);
+    const refU = (4 * D65[0]) / (D65[0] + 15 * D65[1] + 3 * D65[2]);
+    const refV = (9 * D65[1]) / (D65[0] + 15 * D65[1] + 3 * D65[2]);
 
     const cc = Color.luv(
       L,
@@ -891,12 +915,8 @@ export class Color extends Pt {
     const fy = (l + 16) / 116;
     let y = l > kap * eps ? fy * fy * fy : l / kap;
 
-    const refU =
-      (4 * Color.D65[0]) /
-      (Color.D65[0] + 15 * Color.D65[1] + 3 * Color.D65[2]);
-    const refV =
-      (9 * Color.D65[1]) /
-      (Color.D65[0] + 15 * Color.D65[1] + 3 * Color.D65[2]);
+    const refU = (4 * D65[0]) / (D65[0] + 15 * D65[1] + 3 * D65[2]);
+    const refV = (9 * D65[1]) / (D65[0] + 15 * D65[1] + 3 * D65[2]);
 
     u = u / (13 * l) + refU;
     v = v / (13 * l) + refV;

package/src/Create.ts

@@ -261,7 +261,8 @@ const __noise_permTable = [
 // The doubled base permutation table, built once and shared by every unseeded
 // Noise instance (a per-instance copy would allocate 512 entries per point in
 // `Create.noisePts`). `seed()` swaps in a seeded table instead of mutating.
-const __noise_permDoubled = __noise_permTable.concat(__noise_permTable);
+const __noise_permDoubled =
+  /* @__PURE__ */ __noise_permTable.concat(__noise_permTable);
 
 // Memoize the last seeded table: `Create.noisePts` seeds every point with the
 // same value, so all its Noise Pts share one table.

package/src/LinearAlgebra.ts

@@ -1,7 +1,6 @@
 /*! Pts.js is licensed under Apache License 2.0. Copyright © 2017-current William Ngan and contributors. (https://github.com/williamngan/pts) */
 
 import { Pt, Group } from "./Pt";
-import { Line } from "./Op";
 import { type PtLike, type GroupLike } from "./Types";
 
 /**
@@ -506,17 +505,19 @@ export class Mat {
    * @param p1 second end point to define the reflection line
    */
   static reflectAt2DMatrix(p1: PtLike, p2: PtLike) {
-    const intercept = Line.intercept(p1, p2);
-
-    if (intercept == undefined) {
+    // The slope and y-intercept as `Line.intercept` computes them, inlined so
+    // this module does not import Op: a Pt-only bundle would otherwise keep
+    // every geometry class.
+    if (p2[0] - p1[0] === 0) {
       return [
         new Pt([-1, 0, 0]),
         new Pt([0, 1, 0]),
         new Pt([p1[0] + p2[0], 0, 1]),
       ];
     } else {
-      const yi = intercept.yi;
-      const ang2 = Math.atan(intercept.slope) * 2;
+      const slope = (p2[1] - p1[1]) / (p2[0] - p1[0]);
+      const yi = p1[1] - slope * p1[0];
+      const ang2 = Math.atan(slope) * 2;
       const cosA = Math.cos(ang2);
       const sinA = Math.sin(ang2);
 

package/src/Num.ts

@@ -1,7 +1,6 @@
 /*! Pts.js is licensed under Apache License 2.0. Copyright © 2017-current William Ngan and contributors. (https://github.com/williamngan/pts) */
 
 import { Const, Util } from "./Util";
-import { Curve } from "./Op";
 import { Pt, Group } from "./Pt";
 import { Vec, Mat } from "./LinearAlgebra";
 import {
@@ -890,7 +889,7 @@ export class Shaping {
   }
 
   /**
-   * Cubic bezier curve. This reuses the bezier functions in Curve class. Note that `t` is the curve parameter, not the x position: unlike CSS `cubic-bezier(...)`, this returns the curve's y value at parameter `t` rather than solving y at x = t.
+   * Cubic bezier curve from (0, 0) to (1, 1) with two control points. Note that `t` is the curve parameter, not the x position: unlike CSS `cubic-bezier(...)`, this returns the curve's y value at parameter `t` rather than solving y at x = t.
    * @param t a value between 0 to 1
    * @param c the value to shape, default is 1
    * @param p1` a Pt object specifying the first control Pt. Default is `Pt(0.1, 0.7).
@@ -902,14 +901,20 @@ export class Shaping {
     p1: PtLike = [0.1, 0.7],
     p2: PtLike = [0.9, 0.2],
   ): number {
-    const curve = new Group(new Pt(0, 0), new Pt(p1), new Pt(p2), new Pt(1, 1));
-    return (
-      c *
-      Curve.bezierStep(
-        new Pt(t * t * t, t * t, t, 1),
-        Curve.controlPoints(curve),
-      ).y
-    );
+    // `Curve.bezierStep` on the controls (0, 0), p1, p2, (1, 1), inlined so
+    // this module does not import Op (a Pt-only bundle would otherwise keep
+    // every geometry class). The float32 rounding of that Pt-based evaluation
+    // is kept: the powers of t, the control values and the result are float32,
+    // and the weighted sum has the same terms in the same order.
+    const t3 = Math.fround(t * t * t);
+    const t2 = Math.fround(t * t);
+    const t1 = Math.fround(t);
+    const y =
+      (-t3 + 3 * t2 - 3 * t1 + 1) * 0 +
+      (3 * t3 - 6 * t2 + 3 * t1) * new Pt(p1)[1] +
+      (-3 * t3 + 3 * t2) * new Pt(p2)[1] +
+      t3 * 1;
+    return c * Math.fround(y);
   }
 
   /**

package/src/Svg.ts

@@ -963,6 +963,7 @@ export class SVGSpace extends DOMSpace {
 
 let _svgFormGroupID = 0;
 let _svgFormDomID = 0;
+let _svgFormOffscreenWarned = false;
 
 // rendering-context style keys and their legacy inline-style names
 const _legacyStyleKeys: Record<string, string> = {
@@ -1081,10 +1082,9 @@ export class SVGForm extends CanvasForm<SVGSpace> {
     SVGForm._warnOffscreen();
   }
 
-  private static _offscreenWarned = false;
   private static _warnOffscreen() {
-    if (SVGForm._offscreenWarned) return;
-    SVGForm._offscreenWarned = true;
+    if (_svgFormOffscreenWarned) return;
+    _svgFormOffscreenWarned = true;
     Util.warn(
       "offscreen canvases are not supported in SVG output; use CanvasSpace",
     );

package/src/UI.ts

@@ -98,6 +98,11 @@ export const UIPointerActions = {
 export type UIPointerAction =
   (typeof UIPointerActions)[keyof typeof UIPointerActions];
 
+// module state behind the `_counter` accessor, so no static field assignment
+// follows the class (which would defeat tree-shaking); internal code still
+// uses `UI._counter` (see Util.ts)
+let _uiCounter = 0;
+
 /**
  * **[Experimental]** An abstract class that represents an UI element. It wraps a [`Group`](#link) and supports UI event handling.
  * Extend this class to create custom UI elements.
@@ -107,7 +112,22 @@ export class UI {
   _group: Group;
   _shape: string;
 
-  protected static _counter: number = 0;
+  protected static get _counter(): number {
+    return _uiCounter;
+  }
+  protected static set _counter(n: number) {
+    // as with a static field, an assignment on a subclass stays on the subclass
+    if (this === UI) {
+      _uiCounter = n;
+    } else {
+      Object.defineProperty(this, "_counter", {
+        value: n,
+        writable: true,
+        enumerable: true,
+        configurable: true,
+      });
+    }
+  }
   protected _id: string;
   protected _actions: { [type: string]: (UIHandler | null)[] };
   // built-in machinery (UIButton hover, UIDragger drag) registers here, so

package/src/Util.ts

@@ -94,11 +94,33 @@ export const Const = {
   gaussian: 0.3989422804014327,
 };
 
+// Mutable statics live in module state behind accessors: a static field would
+// be emitted as an assignment after the class, which bundlers keep, and with
+// it the class and everything it references (see Svg.ts). Internal code still
+// goes through the public static, so redefining it (Object.defineProperty, an
+// assignment through a Proxy) takes effect as it did with a field.
+let _utilWarnLevel: WarningType = "mute";
+
 /**
  * Util class provides static helper functions.
  */
 export class Util {
-  static _warnLevel: WarningType = "mute";
+  static get _warnLevel(): WarningType {
+    return _utilWarnLevel;
+  }
+  static set _warnLevel(lv: WarningType) {
+    // as with a static field, an assignment on a subclass stays on the subclass
+    if (this === Util) {
+      _utilWarnLevel = lv;
+    } else {
+      Object.defineProperty(this, "_warnLevel", {
+        value: lv,
+        writable: true,
+        enumerable: true,
+        configurable: true,
+      });
+    }
+  }
 
   /**
    * Set a global warning level setting. If no parameter is passed, this will return the current warn-level. See [`Util.warn`](#link).

package/src/_triangulate.ts

@@ -43,9 +43,12 @@ const EMPTY: Triangulation = {
 const EPS = 1.1102230246251565e-16;
 // Bounds on the rounding error of the determinants below, relative to the sum
 // of the absolute values of their terms (the classic forward error analysis
-// of the orientation and in-circle determinants).
-const ORIENT_BOUND = (3 + 16 * EPS) * EPS;
-const INCIRCLE_BOUND = (10 + 96 * EPS) * EPS;
+// of the orientation and in-circle determinants). Computed through a function
+// marked pure so bundles that never triangulate drop them: a bundler that
+// turns these consts into vars cannot prove the bare products side-effect free.
+const errorBound = (a: number, b: number) => (a + b * EPS) * EPS;
+const ORIENT_BOUND = /* @__PURE__ */ errorBound(3, 16);
+const INCIRCLE_BOUND = /* @__PURE__ */ errorBound(10, 96);
 // Coordinates that become integers below 2^31 when scaled by one power of two
 // (pixel grids, halves, quarters, every Float32 value in a sane range) keep
 // their differences exact in a double; the products those differences form are
@@ -322,15 +325,28 @@ function _incircleInt(
 // Exact evaluation: each double is sign * mantissa * 2^exponent with an
 // integer mantissa, so scaling every input to the smallest exponent gives
 // exact integers whose determinant has the same sign as the real one.
-const _bits = new Float64Array(1);
-const _words = new Uint32Array(_bits.buffer);
-_bits[0] = 1;
-const HI = _words[1] === 0x3ff00000 ? 1 : 0;
-const LO = HI ^ 1;
+// Views over one buffer, and the indices of the words holding a double's
+// high bits (sign, exponent, top of the mantissa) and low bits. Every
+// initializer is a call marked pure, so a bundle that never triangulates
+// drops all of it (a bundler cannot prove `HI ^ 1` free of side effects).
+const _buffer = /* @__PURE__ */ new ArrayBuffer(8);
+const _bits = /* @__PURE__ */ new Float64Array(_buffer);
+const _words = /* @__PURE__ */ new Uint32Array(_buffer);
+const HI = /* @__PURE__ */ wordIndex(true);
+const LO = /* @__PURE__ */ wordIndex(false);
+
+function wordIndex(high: boolean): number {
+  // little-endian hosts store the high word of 1.0 (0x3ff00000) second
+  const probe = new Float64Array([1]);
+  const highSecond = new Uint32Array(probe.buffer)[1] === 0x3ff00000;
+  return high === highSecond ? 1 : 0;
+}
+
 const _mant = new Float64Array(8);
 const _expo = new Int32Array(8);
-// BigInt is only touched inside the exact fallback, so loading this module
-// never requires it
+// BigInt is used only when called: by `crossingParameter` (every proper
+// crossing in the polygon overlay) and by the exact predicates below, so
+// loading this module never requires it
 
 function _scaled(values: Float64Array, count: number): bigint[] {
   let minExpo = 0x7fffffff;
@@ -360,8 +376,9 @@ function _scaled(values: Float64Array, count: number): bigint[] {
 }
 
 // `Number(bigint)` is finite below 2^1024; shift in whole limbs until then.
-const FINITE_LIMIT = BigInt(1) << BigInt(1023);
-const SHIFT_STEP = BigInt(64);
+// Created on first use, so loading this module never evaluates BigInt.
+let _finiteLimit: bigint | undefined;
+let _shiftStep: bigint;
 
 /**
  * Parameter of a known proper crossing along a→b. Evaluate the determinants
@@ -391,11 +408,15 @@ export function crossingParameter(
   // Keep the conversion finite even when the input doubles span hundreds of
   // binary exponents. The numerator is between zero and the denominator, and
   // a denominator of ordinary size needs no shift at all.
+  if (_finiteLimit === undefined) {
+    _finiteLimit = BigInt(1) << BigInt(1023);
+    _shiftStep = BigInt(64);
+  }
   let shift = BigInt(0);
   let scaled = denominator;
-  while (scaled >= FINITE_LIMIT) {
-    scaled >>= SHIFT_STEP;
-    shift += SHIFT_STEP;
+  while (scaled >= _finiteLimit) {
+    scaled >>= _shiftStep;
+    shift += _shiftStep;
   }
   return Number(numerator >> shift) / Number(scaled);
 }