ducjs 1.0.0

package/dist/legacy/v1/utils/index.js

@@ -0,0 +1,40 @@
+/**
+ * supply `null` as message if non-never value is valid, you just need to
+ * typecheck against it
+ */
+export const assertNever = (value, message, softAssert) => {
+    if (!message) {
+        return value;
+    }
+    if (softAssert) {
+        console.error(message);
+        return value;
+    }
+    throw new Error(message);
+};
+export const getUpdatedTimestamp = () => Date.now();
+export const isFiniteNumber = (value) => {
+    return typeof value === "number" && Number.isFinite(value);
+};
+/**
+ * Transforms array of objects containing `id` attribute,
+ * or array of ids (strings), into a Map, keyd by `id`.
+ */
+export const arrayToMap = (items) => {
+    if (items instanceof Map) {
+        return items;
+    }
+    return items.reduce((acc, element) => {
+        acc.set(typeof element === "string" ? element : element.id, element);
+        return acc;
+    }, new Map());
+};
+export const updateActiveTool = (appState, data) => {
+    var _a, _b, _c;
+    if (data.type === "custom") {
+        return Object.assign(Object.assign({}, appState.activeTool), { type: "custom", customType: data.customType, locked: (_a = data.locked) !== null && _a !== void 0 ? _a : appState.activeTool.locked });
+    }
+    return Object.assign(Object.assign({}, appState.activeTool), { lastActiveTool: data.lastActiveToolBeforeEraser === undefined
+            ? appState.activeTool.lastActiveTool
+            : data.lastActiveToolBeforeEraser, type: data.type, customType: null, locked: (_b = data.locked) !== null && _b !== void 0 ? _b : appState.activeTool.locked, fromSelection: (_c = data.fromSelection) !== null && _c !== void 0 ? _c : false });
+};

package/dist/legacy/v1/utils/math/algebra/ga.d.ts

@@ -0,0 +1,63 @@
+/**
+ * This is a 2D Projective Geometric Algebra implementation.
+ *
+ * For wider context on geometric algebra visit see https://bivector.net.
+ *
+ * For this specific algebra see cheatsheet https://bivector.net/2DPGA.pdf.
+ *
+ * Converted from generator written by enki, with a ton of added on top.
+ *
+ * This library uses 8-vectors to represent points, directions and lines
+ * in 2D space.
+ *
+ * An array `[a, b, c, d, e, f, g, h]` represents a n(8)vector:
+ *   a + b*e0 + c*e1 + d*e2 + e*e01 + f*e20 + g*e12 + h*e012
+ *
+ * See GAPoint, GALine, GADirection and GATransform modules for common
+ * operations.
+ */
+export type Point = NVector;
+export type Direction = NVector;
+export type Line = NVector;
+export type Transform = NVector;
+export declare const point: (x: number, y: number) => Point;
+export declare const origin: () => Point;
+export declare const direction: (x: number, y: number) => Direction;
+export declare const offset: (x: number, y: number) => Direction;
+type NVector = readonly [
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number
+];
+export declare const nvector: (value?: number, index?: number) => NVector;
+export declare const toString: (nvector: NVector) => string;
+export declare const reverse: (nvector: NVector) => NVector;
+export declare const dual: (nvector: NVector) => NVector;
+export declare const conjugate: (nvector: NVector) => NVector;
+export declare const involute: (nvector: NVector) => NVector;
+export declare const add: (a: NVector, b: NVector | number) => NVector;
+export declare const sub: (a: NVector, b: NVector | number) => NVector;
+export declare const mul: (a: NVector, b: NVector | number) => NVector;
+export declare const mulScalar: (a: NVector, b: NVector) => number;
+export declare const meet: (a: NVector, b: NVector) => NVector;
+export declare const join: (a: NVector, b: NVector) => NVector;
+export declare const joinScalar: (a: NVector, b: NVector) => number;
+export declare const dot: (a: NVector, b: NVector) => NVector;
+export declare const norm: (a: NVector) => number;
+export declare const inorm: (a: NVector) => number;
+export declare const normalized: (a: NVector) => NVector;
+export declare const inormalized: (a: NVector) => NVector;
+export declare const E0: NVector;
+export declare const E1: NVector;
+export declare const E2: NVector;
+export declare const E01: NVector;
+export declare const E20: NVector;
+export declare const E12: NVector;
+export declare const E012: NVector;
+export declare const I: NVector;
+export {};

package/dist/legacy/v1/utils/math/algebra/ga.js

@@ -0,0 +1,268 @@
+/**
+ * This is a 2D Projective Geometric Algebra implementation.
+ *
+ * For wider context on geometric algebra visit see https://bivector.net.
+ *
+ * For this specific algebra see cheatsheet https://bivector.net/2DPGA.pdf.
+ *
+ * Converted from generator written by enki, with a ton of added on top.
+ *
+ * This library uses 8-vectors to represent points, directions and lines
+ * in 2D space.
+ *
+ * An array `[a, b, c, d, e, f, g, h]` represents a n(8)vector:
+ *   a + b*e0 + c*e1 + d*e2 + e*e01 + f*e20 + g*e12 + h*e012
+ *
+ * See GAPoint, GALine, GADirection and GATransform modules for common
+ * operations.
+ */
+export const point = (x, y) => [0, 0, 0, 0, y, x, 1, 0];
+export const origin = () => [0, 0, 0, 0, 0, 0, 1, 0];
+export const direction = (x, y) => {
+    const norm = Math.hypot(x, y); // same as `inorm(direction(x, y))`
+    return [0, 0, 0, 0, y / norm, x / norm, 0, 0];
+};
+export const offset = (x, y) => [
+    0,
+    0,
+    0,
+    0,
+    y,
+    x,
+    0,
+    0,
+];
+// These are labels for what each number in an nvector represents
+const NVECTOR_BASE = ["1", "e0", "e1", "e2", "e01", "e20", "e12", "e012"];
+// Used to represent points, lines and transformations
+export const nvector = (value = 0, index = 0) => {
+    const result = [0, 0, 0, 0, 0, 0, 0, 0];
+    if (index < 0 || index > 7) {
+        throw new Error(`Expected \`index\` between 0 and 7, got \`${index}\``);
+    }
+    if (value !== 0) {
+        result[index] = value;
+    }
+    return result;
+};
+const STRING_EPSILON = 0.000001;
+export const toString = (nvector) => {
+    const result = nvector
+        .map((value, index) => Math.abs(value) > STRING_EPSILON
+        ? value.toFixed(7).replace(/(\.|0+)$/, "") +
+            (index > 0 ? NVECTOR_BASE[index] : "")
+        : null)
+        .filter((representation) => representation != null)
+        .join(" + ");
+    return result === "" ? "0" : result;
+};
+// Reverse the order of the basis blades.
+export const reverse = (nvector) => [
+    nvector[0],
+    nvector[1],
+    nvector[2],
+    nvector[3],
+    -nvector[4],
+    -nvector[5],
+    -nvector[6],
+    -nvector[7],
+];
+// Poincare duality operator.
+export const dual = (nvector) => [
+    nvector[7],
+    nvector[6],
+    nvector[5],
+    nvector[4],
+    nvector[3],
+    nvector[2],
+    nvector[1],
+    nvector[0],
+];
+// Clifford Conjugation
+export const conjugate = (nvector) => [
+    nvector[0],
+    -nvector[1],
+    -nvector[2],
+    -nvector[3],
+    -nvector[4],
+    -nvector[5],
+    -nvector[6],
+    nvector[7],
+];
+// Main involution
+export const involute = (nvector) => [
+    nvector[0],
+    -nvector[1],
+    -nvector[2],
+    -nvector[3],
+    nvector[4],
+    nvector[5],
+    nvector[6],
+    -nvector[7],
+];
+// Multivector addition
+export const add = (a, b) => {
+    if (isNumber(b)) {
+        return [a[0] + b, a[1], a[2], a[3], a[4], a[5], a[6], a[7]];
+    }
+    return [
+        a[0] + b[0],
+        a[1] + b[1],
+        a[2] + b[2],
+        a[3] + b[3],
+        a[4] + b[4],
+        a[5] + b[5],
+        a[6] + b[6],
+        a[7] + b[7],
+    ];
+};
+// Multivector subtraction
+export const sub = (a, b) => {
+    if (isNumber(b)) {
+        return [a[0] - b, a[1], a[2], a[3], a[4], a[5], a[6], a[7]];
+    }
+    return [
+        a[0] - b[0],
+        a[1] - b[1],
+        a[2] - b[2],
+        a[3] - b[3],
+        a[4] - b[4],
+        a[5] - b[5],
+        a[6] - b[6],
+        a[7] - b[7],
+    ];
+};
+// The geometric product.
+export const mul = (a, b) => {
+    if (isNumber(b)) {
+        return [
+            a[0] * b,
+            a[1] * b,
+            a[2] * b,
+            a[3] * b,
+            a[4] * b,
+            a[5] * b,
+            a[6] * b,
+            a[7] * b,
+        ];
+    }
+    return [
+        mulScalar(a, b),
+        b[1] * a[0] +
+            b[0] * a[1] -
+            b[4] * a[2] +
+            b[5] * a[3] +
+            b[2] * a[4] -
+            b[3] * a[5] -
+            b[7] * a[6] -
+            b[6] * a[7],
+        b[2] * a[0] + b[0] * a[2] - b[6] * a[3] + b[3] * a[6],
+        b[3] * a[0] + b[6] * a[2] + b[0] * a[3] - b[2] * a[6],
+        b[4] * a[0] +
+            b[2] * a[1] -
+            b[1] * a[2] +
+            b[7] * a[3] +
+            b[0] * a[4] +
+            b[6] * a[5] -
+            b[5] * a[6] +
+            b[3] * a[7],
+        b[5] * a[0] -
+            b[3] * a[1] +
+            b[7] * a[2] +
+            b[1] * a[3] -
+            b[6] * a[4] +
+            b[0] * a[5] +
+            b[4] * a[6] +
+            b[2] * a[7],
+        b[6] * a[0] + b[3] * a[2] - b[2] * a[3] + b[0] * a[6],
+        b[7] * a[0] +
+            b[6] * a[1] +
+            b[5] * a[2] +
+            b[4] * a[3] +
+            b[3] * a[4] +
+            b[2] * a[5] +
+            b[1] * a[6] +
+            b[0] * a[7],
+    ];
+};
+export const mulScalar = (a, b) => b[0] * a[0] + b[2] * a[2] + b[3] * a[3] - b[6] * a[6];
+// The outer/exterior/wedge product.
+export const meet = (a, b) => [
+    b[0] * a[0],
+    b[1] * a[0] + b[0] * a[1],
+    b[2] * a[0] + b[0] * a[2],
+    b[3] * a[0] + b[0] * a[3],
+    b[4] * a[0] + b[2] * a[1] - b[1] * a[2] + b[0] * a[4],
+    b[5] * a[0] - b[3] * a[1] + b[1] * a[3] + b[0] * a[5],
+    b[6] * a[0] + b[3] * a[2] - b[2] * a[3] + b[0] * a[6],
+    b[7] * a[0] +
+        b[6] * a[1] +
+        b[5] * a[2] +
+        b[4] * a[3] +
+        b[3] * a[4] +
+        b[2] * a[5] +
+        b[1] * a[6],
+];
+// The regressive product.
+export const join = (a, b) => [
+    joinScalar(a, b),
+    a[1] * b[7] + a[4] * b[5] - a[5] * b[4] + a[7] * b[1],
+    a[2] * b[7] - a[4] * b[6] + a[6] * b[4] + a[7] * b[2],
+    a[3] * b[7] + a[5] * b[6] - a[6] * b[5] + a[7] * b[3],
+    a[4] * b[7] + a[7] * b[4],
+    a[5] * b[7] + a[7] * b[5],
+    a[6] * b[7] + a[7] * b[6],
+    a[7] * b[7],
+];
+export const joinScalar = (a, b) => a[0] * b[7] +
+    a[1] * b[6] +
+    a[2] * b[5] +
+    a[3] * b[4] +
+    a[4] * b[3] +
+    a[5] * b[2] +
+    a[6] * b[1] +
+    a[7] * b[0];
+// The inner product.
+export const dot = (a, b) => [
+    b[0] * a[0] + b[2] * a[2] + b[3] * a[3] - b[6] * a[6],
+    b[1] * a[0] +
+        b[0] * a[1] -
+        b[4] * a[2] +
+        b[5] * a[3] +
+        b[2] * a[4] -
+        b[3] * a[5] -
+        b[7] * a[6] -
+        b[6] * a[7],
+    b[2] * a[0] + b[0] * a[2] - b[6] * a[3] + b[3] * a[6],
+    b[3] * a[0] + b[6] * a[2] + b[0] * a[3] - b[2] * a[6],
+    b[4] * a[0] + b[7] * a[3] + b[0] * a[4] + b[3] * a[7],
+    b[5] * a[0] + b[7] * a[2] + b[0] * a[5] + b[2] * a[7],
+    b[6] * a[0] + b[0] * a[6],
+    b[7] * a[0] + b[0] * a[7],
+];
+export const norm = (a) => Math.sqrt(Math.abs(a[0] * a[0] - a[2] * a[2] - a[3] * a[3] + a[6] * a[6]));
+export const inorm = (a) => Math.sqrt(Math.abs(a[7] * a[7] - a[5] * a[5] - a[4] * a[4] + a[1] * a[1]));
+export const normalized = (a) => {
+    const n = norm(a);
+    if (n === 0 || n === 1) {
+        return a;
+    }
+    const sign = a[6] < 0 ? -1 : 1;
+    return mul(a, sign / n);
+};
+export const inormalized = (a) => {
+    const n = inorm(a);
+    if (n === 0 || n === 1) {
+        return a;
+    }
+    return mul(a, 1 / n);
+};
+const isNumber = (a) => typeof a === "number";
+export const E0 = nvector(1, 1);
+export const E1 = nvector(1, 2);
+export const E2 = nvector(1, 3);
+export const E01 = nvector(1, 4);
+export const E20 = nvector(1, 5);
+export const E12 = nvector(1, 6);
+export const E012 = nvector(1, 7);
+export const I = E012;

package/dist/legacy/v1/utils/math/algebra/gadirections.d.ts

@@ -0,0 +1,9 @@
+import type { Line, Direction, Point } from "ducjs/legacy/v1/utils/math/algebra/ga";
+/**
+ * A direction is stored as an array `[0, 0, 0, 0, y, x, 0, 0]` representing
+ * vector `(x, y)`.
+ */
+export declare const from: (point: Point) => Point;
+export declare const fromTo: (from: Point, to: Point) => Direction;
+export declare const orthogonal: (direction: Direction) => Direction;
+export declare const orthogonalToLine: (line: Line) => Direction;

package/dist/legacy/v1/utils/math/algebra/gadirections.js

@@ -0,0 +1,18 @@
+import * as GA from "ducjs/legacy/v1/utils/math/algebra/ga";
+/**
+ * A direction is stored as an array `[0, 0, 0, 0, y, x, 0, 0]` representing
+ * vector `(x, y)`.
+ */
+export const from = (point) => [
+    0,
+    0,
+    0,
+    0,
+    point[4],
+    point[5],
+    0,
+    0,
+];
+export const fromTo = (from, to) => GA.inormalized([0, 0, 0, 0, to[4] - from[4], to[5] - from[5], 0, 0]);
+export const orthogonal = (direction) => GA.inormalized([0, 0, 0, 0, -direction[5], direction[4], 0, 0]);
+export const orthogonalToLine = (line) => GA.mul(line, GA.I);

package/dist/legacy/v1/utils/math/algebra/galines.d.ts

@@ -0,0 +1,23 @@
+import type { Line, Point } from "ducjs/legacy/v1/utils/math/algebra/ga";
+/**
+ * A line is stored as an array `[0, c, a, b, 0, 0, 0, 0]` representing:
+ *   c * e0 + a * e1 + b*e2
+ *
+ * This maps to a standard formula `a * x + b * y + c`.
+ *
+ * `(-b, a)` corresponds to a 2D vector parallel to the line. The lines
+ * have a natural orientation, corresponding to that vector.
+ *
+ * The magnitude ("norm") of the line is `sqrt(a ^ 2 + b ^ 2)`.
+ * `c / norm(line)` is the oriented distance from line to origin.
+ */
+export declare const vector: (x: number, y: number) => Line;
+export declare const equation: (a: number, b: number, c: number) => Line;
+export declare const through: (from: Point, to: Point) => Line;
+export declare const orthogonal: (line: Line, point: Point) => Line;
+export declare const orthogonalThrough: (against: Point, intersection: Point) => Line;
+export declare const parallel: (line: Line, distance: number) => Line;
+export declare const parallelThrough: (line: Line, point: Point) => Line;
+export declare const distance: (line1: Line, line2: Line) => number;
+export declare const angle: (line1: Line, line2: Line) => number;
+export declare const sign: (line: Line) => number;

package/dist/legacy/v1/utils/math/algebra/galines.js

@@ -0,0 +1,32 @@
+import * as GA from "ducjs/legacy/v1/utils/math/algebra/ga";
+/**
+ * A line is stored as an array `[0, c, a, b, 0, 0, 0, 0]` representing:
+ *   c * e0 + a * e1 + b*e2
+ *
+ * This maps to a standard formula `a * x + b * y + c`.
+ *
+ * `(-b, a)` corresponds to a 2D vector parallel to the line. The lines
+ * have a natural orientation, corresponding to that vector.
+ *
+ * The magnitude ("norm") of the line is `sqrt(a ^ 2 + b ^ 2)`.
+ * `c / norm(line)` is the oriented distance from line to origin.
+ */
+// Returns line with direction (x, y) through origin
+export const vector = (x, y) => GA.normalized([0, 0, -y, x, 0, 0, 0, 0]);
+// For equation ax + by + c = 0.
+export const equation = (a, b, c) => GA.normalized([0, c, a, b, 0, 0, 0, 0]);
+export const through = (from, to) => GA.normalized(GA.join(to, from));
+export const orthogonal = (line, point) => GA.dot(line, point);
+// Returns a line perpendicular to the line through `against` and `intersection`
+// going through `intersection`.
+export const orthogonalThrough = (against, intersection) => orthogonal(through(against, intersection), intersection);
+export const parallel = (line, distance) => {
+    const result = line.slice();
+    result[1] -= distance;
+    return result;
+};
+export const parallelThrough = (line, point) => orthogonal(orthogonal(point, line), point);
+export const distance = (line1, line2) => GA.inorm(GA.meet(line1, line2));
+export const angle = (line1, line2) => Math.acos(GA.dot(line1, line2)[0]);
+// The orientation of the line
+export const sign = (line) => Math.sign(line[1]);

package/dist/legacy/v1/utils/math/algebra/gapoints.d.ts

@@ -0,0 +1,8 @@
+import type { Point, Line } from "ducjs/legacy/v1/utils/math/algebra/ga";
+export declare const from: ([x, y]: readonly [number, number]) => Point;
+export declare const toTuple: (point: Point) => [number, number];
+export declare const abs: (point: Point) => Point;
+export declare const intersect: (line1: Line, line2: Line) => Point;
+export declare const project: (point: Point, line: Line) => Point;
+export declare const distance: (point1: Point, point2: Point) => number;
+export declare const distanceToLine: (point: Point, line: Line) => number;

package/dist/legacy/v1/utils/math/algebra/gapoints.js

@@ -0,0 +1,30 @@
+import * as GA from "ducjs/legacy/v1/utils/math/algebra/ga";
+import * as GALine from "ducjs/legacy/v1/utils/math/algebra/galines";
+import { join } from "ducjs/legacy/v1/utils/math/algebra/ga";
+export const from = ([x, y]) => [
+    0,
+    0,
+    0,
+    0,
+    y,
+    x,
+    1,
+    0,
+];
+export const toTuple = (point) => [point[5], point[4]];
+export const abs = (point) => [
+    0,
+    0,
+    0,
+    0,
+    Math.abs(point[4]),
+    Math.abs(point[5]),
+    1,
+    0,
+];
+export const intersect = (line1, line2) => GA.normalized(GA.meet(line1, line2));
+// Projects `point` onto the `line`.
+// The returned point is the closest point on the `line` to the `point`.
+export const project = (point, line) => intersect(GALine.orthogonal(line, point), line);
+export const distance = (point1, point2) => GA.norm(join(point1, point2));
+export const distanceToLine = (point, line) => GA.joinScalar(point, line);

package/dist/legacy/v1/utils/math/algebra/gatransforms.d.ts

@@ -0,0 +1,10 @@
+import type { Line, Direction, Point, Transform } from "ducjs/legacy/v1/utils/math/algebra/ga";
+/**
+ * TODO: docs
+ */
+export declare const rotation: (pivot: Point, angle: number) => Transform;
+export declare const translation: (direction: Direction) => Transform;
+export declare const translationOrthogonal: (direction: Direction, distance: number) => Transform;
+export declare const translationAlong: (line: Line, distance: number) => Transform;
+export declare const compose: (motor1: Transform, motor2: Transform) => Transform;
+export declare const apply: (motor: Transform, nvector: Point | Direction | Line) => Point | Direction | Line;

package/dist/legacy/v1/utils/math/algebra/gatransforms.js

@@ -0,0 +1,23 @@
+import * as GA from "ducjs/legacy/v1/utils/math/algebra/ga";
+import * as GADirection from "ducjs/legacy/v1/utils/math/algebra/gadirections";
+/**
+ * TODO: docs
+ */
+export const rotation = (pivot, angle) => GA.add(GA.mul(pivot, Math.sin(angle / 2)), Math.cos(angle / 2));
+export const translation = (direction) => [
+    1,
+    0,
+    0,
+    0,
+    -(0.5 * direction[5]),
+    0.5 * direction[4],
+    0,
+    0,
+];
+export const translationOrthogonal = (direction, distance) => {
+    const scale = 0.5 * distance;
+    return [1, 0, 0, 0, scale * direction[4], scale * direction[5], 0, 0];
+};
+export const translationAlong = (line, distance) => GA.add(GA.mul(GADirection.orthogonalToLine(line), 0.5 * distance), 1);
+export const compose = (motor1, motor2) => GA.mul(motor2, motor1);
+export const apply = (motor, nvector) => GA.normalized(GA.mul(GA.mul(motor, nvector), GA.reverse(motor)));

package/dist/legacy/v1/utils/math/bbox.d.ts

@@ -0,0 +1,10 @@
+import { Bounds, LineSegment } from "ducjs/legacy/v1/types/geometryTypes";
+import { GeometricPoint } from "ducjs/legacy/v1/types/geometryTypes";
+export declare function getBBox(line: LineSegment): Bounds;
+export declare function crossProduct(a: GeometricPoint, b: GeometricPoint): number;
+export declare function doBBoxesIntersect(a: Bounds, b: Bounds): boolean;
+export declare function translate(a: GeometricPoint, b: GeometricPoint): GeometricPoint;
+export declare function isPointOnLine(l: LineSegment, p: GeometricPoint): boolean;
+export declare function isPointRightOfLine(l: LineSegment, p: GeometricPoint): boolean;
+export declare function isLineSegmentTouchingOrCrossingLine(a: LineSegment, b: LineSegment): boolean;
+export declare function doLineSegmentsIntersect(a: LineSegment, b: LineSegment): boolean;

package/dist/legacy/v1/utils/math/bbox.js

@@ -0,0 +1,42 @@
+export function getBBox(line) {
+    return [
+        Math.min(line[0].x, line[1].x),
+        Math.min(line[0].y, line[1].y),
+        Math.max(line[0].x, line[1].x),
+        Math.max(line[0].y, line[1].y),
+    ];
+}
+export function crossProduct(a, b) {
+    return a.x * b.y - b.x * a.y;
+}
+export function doBBoxesIntersect(a, b) {
+    return a[0] <= b[2] && a[2] >= b[0] && a[1] <= b[3] && a[3] >= b[1];
+}
+export function translate(a, b) {
+    return { x: a.x - b.x, y: a.y - b.y };
+}
+const EPSILON = 0.000001;
+export function isPointOnLine(l, p) {
+    const p1 = translate(l[1], l[0]);
+    const p2 = translate(p, l[0]);
+    const r = crossProduct(p1, p2);
+    return Math.abs(r) < EPSILON;
+}
+export function isPointRightOfLine(l, p) {
+    const p1 = translate(l[1], l[0]);
+    const p2 = translate(p, l[0]);
+    return crossProduct(p1, p2) < 0;
+}
+export function isLineSegmentTouchingOrCrossingLine(a, b) {
+    return (isPointOnLine(a, b[0]) ||
+        isPointOnLine(a, b[1]) ||
+        (isPointRightOfLine(a, b[0])
+            ? !isPointRightOfLine(a, b[1])
+            : isPointRightOfLine(a, b[1])));
+}
+// https://martin-thoma.com/how-to-check-if-two-line-segments-intersect/
+export function doLineSegmentsIntersect(a, b) {
+    return (doBBoxesIntersect(getBBox(a), getBBox(b)) &&
+        isLineSegmentTouchingOrCrossingLine(a, b) &&
+        isLineSegmentTouchingOrCrossingLine(b, a));
+}