ducjs 2.0.0 → 2.1.0

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

@@ -1,40 +0,0 @@
-/**
- * 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

@@ -1,63 +0,0 @@
-/**
- * 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

@@ -1,268 +0,0 @@
-/**
- * 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

@@ -1,9 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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));
-}