@khanacademy/kmath 0.0.8 → 0.1.1

package/dist/es/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../src/number.js","../../src/vector.js","../../src/point.js","../../src/line.js","../../src/ray.js"],"sourcesContent":["// @flow\n/**\n * Number Utils\n * A number is a js-number, e.g. 5.12\n */\n\nimport _ from \"underscore\";\n\nexport const DEFAULT_TOLERANCE: number = 1e-9;\n\n// TODO: Should this just be Number.Epsilon\nexport const EPSILON: number = Math.pow(2, -42);\n\nexport function is(x: any): boolean {\n    return _.isNumber(x) && !_.isNaN(x);\n}\n\nexport function equal(x: number, y: number, tolerance?: number): boolean {\n    // Checking for undefined makes this function behave nicely\n    // with vectors of different lengths that are _.zip'd together\n    if (x == null || y == null) {\n        return x === y;\n    }\n    // We check === here so that +/-Infinity comparisons work correctly\n    if (x === y) {\n        return true;\n    }\n    if (tolerance == null) {\n        tolerance = DEFAULT_TOLERANCE;\n    }\n    return Math.abs(x - y) < tolerance;\n}\n\nexport function sign(\n    x: number,\n    tolerance?: number,\n): number /* Should be: 0 | 1 | -1 */ {\n    return equal(x, 0, tolerance) ? 0 : Math.abs(x) / x;\n}\n\nexport function isInteger(num: number, tolerance?: number): boolean {\n    return equal(Math.round(num), num, tolerance);\n}\n\n// Round a number to a certain number of decimal places\nexport function round(num: number, precision: number): number {\n    const factor = Math.pow(10, precision);\n    return Math.round(num * factor) / factor;\n}\n\n// Round num to the nearest multiple of increment\n// i.e. roundTo(83, 5) -> 85\nexport function roundTo(num: number, increment: number): number {\n    return Math.round(num / increment) * increment;\n}\n\nexport function floorTo(num: number, increment: number): number {\n    return Math.floor(num / increment) * increment;\n}\n\nexport function ceilTo(num: number, increment: number): number {\n    return Math.ceil(num / increment) * increment;\n}\n\n/**\n * toFraction\n *\n * Returns a [numerator, denominator] array rational representation\n * of `decimal`\n *\n * See http://en.wikipedia.org/wiki/Continued_fraction for implementation\n * details\n *\n * toFraction(4/8) => [1, 2]\n * toFraction(0.66) => [33, 50]\n * toFraction(0.66, 0.01) => [2/3]\n * toFraction(283 + 1/3) => [850, 3]\n */\nexport function toFraction(\n    decimal: number,\n    tolerance: number = EPSILON, // can't be 0\n    maxDenominator: number = 1000,\n): [number, number] {\n    // Initialize everything to compute successive terms of\n    // continued-fraction approximations via recurrence relation\n    let n = [1, 0];\n    let d = [0, 1];\n    let a = Math.floor(decimal);\n    let rem = decimal - a;\n\n    while (d[0] <= maxDenominator) {\n        if (equal(n[0] / d[0], decimal, tolerance)) {\n            return [n[0], d[0]];\n        }\n        n = [a * n[0] + n[1], n[0]];\n        d = [a * d[0] + d[1], d[0]];\n        a = Math.floor(1 / rem);\n        rem = 1 / rem - a;\n    }\n\n    // We failed to find a nice rational representation,\n    // so return an irrational \"fraction\"\n    return [decimal, 1];\n}\n","// @flow\n/**\n * Vector Utils\n * A vector is an array of numbers e.g. [0, 3, 4].\n */\n\nimport _ from \"underscore\";\n\nimport * as knumber from \"./number.js\";\n\ntype Vector = $ReadOnlyArray<number>;\n\nfunction arraySum(array: $ReadOnlyArray<number>): number {\n    return array.reduce((memo, arg) => memo + arg, 0);\n}\n\nfunction arrayProduct(array: $ReadOnlyArray<number>): number {\n    return array.reduce((memo, arg) => memo * arg, 1);\n}\n\n/**\n * Checks if the given vector contains only numbers and, optionally, is of the\n * right dimension (length).\n *\n * is([1, 2, 3]) -> true\n * is([1, \"Hello\", 3]) -> false\n * is([1, 2, 3], 1) -> false\n */\nexport function is<T>(vec: $ReadOnlyArray<T>, dimension?: number): boolean {\n    if (!_.isArray(vec)) {\n        return false;\n    }\n    if (dimension !== undefined && vec.length !== dimension) {\n        return false;\n    }\n    return vec.every(knumber.is);\n}\n\n// Normalize to a unit vector\nexport function normalize<V: Vector>(v: V): V {\n    return scale(v, 1 / length(v));\n}\n\n// Length/magnitude of a vector\nexport function length(v: Vector): number {\n    return Math.sqrt(dot(v, v));\n}\n// Dot product of two vectors\nexport function dot(a: Vector, b: Vector): number {\n    // $FlowFixMe[incompatible-call] underscore doesn't like $ReadOnlyArray\n    const zipped = _.zip(a, b);\n    const multiplied = zipped.map(arrayProduct);\n    return arraySum(multiplied);\n}\n\n/* vector-add multiple [x, y] coords/vectors\n *\n * add([1, 2], [3, 4]) -> [4, 6]\n */\nexport function add<V: Vector>(...vecs: $ReadOnlyArray<V>): V {\n    // $FlowFixMe[incompatible-call] underscore doesn't like $ReadOnlyArray\n    const zipped = _.zip(...vecs);\n    return zipped.map(arraySum);\n}\n\nexport function subtract<V: Vector>(v1: V, v2: V): V {\n    // $FlowFixMe[incompatible-call] underscore doesn't like $ReadOnlyArray\n    return _.zip(v1, v2).map((dim) => dim[0] - dim[1]);\n}\n\nexport function negate<V: Vector>(v: V): V {\n    // $FlowFixMe[incompatible-return] Flow's `.map()` libdef is lacking\n    return v.map((x) => {\n        return -x;\n    });\n}\n\n// Scale a vector\nexport function scale<V: Vector>(v1: V, scalar: number): V {\n    // $FlowFixMe[incompatible-return] Flow's `.map()` libdef is lacking\n    return v1.map((x) => {\n        return x * scalar;\n    });\n}\n\nexport function equal(v1: Vector, v2: Vector, tolerance?: number): boolean {\n    // _.zip will nicely deal with the lengths, going through\n    // the length of the longest vector. knumber.equal then\n    // returns false for any number compared to the undefined\n    // passed in if one of the vectors is shorter.\n    // $FlowFixMe[incompatible-call] underscore doesn't like $ReadOnlyArray\n    return _.zip(v1, v2).every((pair) =>\n        knumber.equal(pair[0], pair[1], tolerance),\n    );\n}\n\nexport function codirectional(\n    v1: Vector,\n    v2: Vector,\n    tolerance?: number,\n): boolean {\n    // The origin is trivially codirectional with all other vectors.\n    // This gives nice semantics for codirectionality between points when\n    // comparing their difference vectors.\n    if (\n        knumber.equal(length(v1), 0, tolerance) ||\n        knumber.equal(length(v2), 0, tolerance)\n    ) {\n        return true;\n    }\n\n    v1 = normalize(v1);\n    v2 = normalize(v2);\n\n    return equal(v1, v2, tolerance);\n}\n\nexport function collinear(v1: Vector, v2: Vector, tolerance?: number): boolean {\n    return (\n        codirectional(v1, v2, tolerance) ||\n        codirectional(v1, negate(v2), tolerance)\n    );\n}\n\n// TODO(jeremy) These coordinate conversion functions really only handle 2D points (ie. [number, number])\n\n// Convert a cartesian coordinate into a radian polar coordinate\nexport function polarRadFromCart(\n    v: $ReadOnlyArray<number>,\n): $ReadOnlyArray<number> {\n    const radius = length(v);\n    let theta = Math.atan2(v[1], v[0]);\n\n    // Convert angle range from [-pi, pi] to [0, 2pi]\n    if (theta < 0) {\n        theta += 2 * Math.PI;\n    }\n\n    return [radius, theta];\n}\n\n// Converts a cartesian coordinate into a degree polar coordinate\nexport function polarDegFromCart(\n    v: $ReadOnlyArray<number>,\n): $ReadOnlyArray<number> /* TODO: convert to tuple/Point */ {\n    const polar = polarRadFromCart(v);\n    return [polar[0], (polar[1] * 180) / Math.PI];\n}\n\n/* Convert a polar coordinate into a cartesian coordinate\n *\n * Examples:\n * cartFromPolarRad(5, Math.PI)\n */\nexport function cartFromPolarRad(\n    radius: number,\n    theta?: number = 0,\n): $ReadOnlyArray<number> /* TODO: convert to tuple/Point */ {\n    return [radius * Math.cos(theta), radius * Math.sin(theta)];\n}\n\n/* Convert a polar coordinate into a cartesian coordinate\n *\n * Examples:\n * cartFromPolarDeg(5, 30)\n */\nexport function cartFromPolarDeg(\n    radius: number,\n    theta?: number = 0,\n): $ReadOnlyArray<number> {\n    return cartFromPolarRad(radius, (theta * Math.PI) / 180);\n}\n\n// Rotate vector\nexport function rotateRad(\n    v: $ReadOnlyArray<number>,\n    theta: number,\n): $ReadOnlyArray<number> {\n    const polar = polarRadFromCart(v);\n    const angle = polar[1] + theta;\n    return cartFromPolarRad(polar[0], angle);\n}\n\nexport function rotateDeg(\n    v: $ReadOnlyArray<number>,\n    theta: number,\n): $ReadOnlyArray<number> {\n    const polar = polarDegFromCart(v);\n    const angle = polar[1] + theta;\n    return cartFromPolarDeg(polar[0], angle);\n}\n\n// Angle between two vectors\nexport function angleRad(v1: Vector, v2: Vector): number {\n    return Math.acos(dot(v1, v2) / (length(v1) * length(v2)));\n}\n\nexport function angleDeg(v1: Vector, v2: Vector): number {\n    return (angleRad(v1, v2) * 180) / Math.PI;\n}\n\n// Vector projection of v1 onto v2\nexport function projection<V: Vector>(v1: V, v2: V): V {\n    const scalar = dot(v1, v2) / dot(v2, v2);\n    return scale(v2, scalar);\n}\n\n// Round each number to a certain number of decimal places\nexport function round<V: Vector>(vec: V, precision: V | number): V {\n    // $FlowFixMe[incompatible-return] Flow's `.map()` libdef is lacking\n    return vec.map((elem, i) =>\n        // $FlowFixMe[prop-missing]\n        // $FlowFixMe[incompatible-call]\n        knumber.round(elem, precision[i] || precision),\n    );\n}\n\n// Round each number to the nearest increment\nexport function roundTo<V: Vector>(vec: V, increment: V | number): V {\n    // $FlowFixMe[incompatible-return] Flow's `.map()` libdef is lacking\n    return vec.map((elem, i) =>\n        // $FlowFixMe[prop-missing]\n        // $FlowFixMe[incompatible-call]\n        knumber.roundTo(elem, increment[i] || increment),\n    );\n}\n\nexport function floorTo<V: Vector>(vec: V, increment: V | number): V {\n    // $FlowFixMe[incompatible-return] Flow's `.map()` libdef is lacking\n    return vec.map((elem, i) =>\n        // $FlowFixMe[prop-missing]\n        // $FlowFixMe[incompatible-call]\n        knumber.floorTo(elem, increment[i] || increment),\n    );\n}\n\nexport function ceilTo<V: Vector>(vec: V, increment: V | number): V {\n    // $FlowFixMe[incompatible-return] Flow's `.map()` libdef is lacking\n    return vec.map((elem, i) =>\n        // $FlowFixMe[prop-missing]\n        // $FlowFixMe[incompatible-call]\n        knumber.ceilTo(elem, increment[i] || increment),\n    );\n}\n","// @flow\n/**\n * Point Utils\n * A point is an array of two numbers e.g. [0, 0].\n */\n\nimport _ from \"underscore\";\n\nimport * as knumber from \"./number.js\";\nimport * as kvector from \"./vector.js\";\n\n// A point, in 2D, 3D, or nD space.\nexport type Point = $ReadOnlyArray<number>;\n\n// Rotate point (around origin unless a center is specified)\nexport function rotateRad(point: Point, theta: number, center?: Point): Point {\n    if (center === undefined) {\n        return kvector.rotateRad(point, theta);\n    } else {\n        return kvector.add(\n            center,\n            kvector.rotateRad(kvector.subtract(point, center), theta),\n        );\n    }\n}\n\nexport function rotateDeg(point: Point, theta: number, center?: Point): Point {\n    if (center === undefined) {\n        return kvector.rotateDeg(point, theta);\n    } else {\n        return kvector.add(\n            center,\n            kvector.rotateDeg(kvector.subtract(point, center), theta),\n        );\n    }\n}\n\n// Distance between two points\nexport function distanceToPoint(point1: Point, point2: Point): number {\n    return kvector.length(kvector.subtract(point1, point2));\n}\n\n// Distance between point and line\nexport function distanceToLine(point: Point, line: [Point, Point]): number {\n    const lv = kvector.subtract(line[1], line[0]);\n    const pv = kvector.subtract(point, line[0]);\n    const projectedPv = kvector.projection(pv, lv);\n    const distancePv = kvector.subtract(projectedPv, pv);\n    return kvector.length(distancePv);\n}\n\n// Reflect point over line\nexport function reflectOverLine<P: Point>(point: P, line: [P, P]): P {\n    const lv = kvector.subtract(line[1], line[0]);\n    const pv = kvector.subtract(point, line[0]);\n    const projectedPv = kvector.projection(pv, lv);\n    const reflectedPv = kvector.subtract(kvector.scale(projectedPv, 2), pv);\n    return kvector.add(line[0], reflectedPv);\n}\n\n/**\n * Compares two points, returning -1, 0, or 1, for use with\n * Array.prototype.sort\n *\n * Note: This technically doesn't satisfy the total-ordering\n * requirements of Array.prototype.sort unless equalityTolerance\n * is 0. In some cases very close points that compare within a\n * few equalityTolerances could appear in the wrong order.\n */\nexport function compare(\n    point1: Point,\n    point2: Point,\n    equalityTolerance?: number,\n): number /* TODO: convert to -1 | 0 | 1 type */ {\n    if (point1.length !== point2.length) {\n        return point1.length - point2.length;\n    }\n    for (let i = 0; i < point1.length; i++) {\n        if (!knumber.equal(point1[i], point2[i], equalityTolerance)) {\n            return point1[i] - point2[i];\n        }\n    }\n    return 0;\n}\n\n// Check if a value is a point\nexport const is = kvector.is;\n\n// Add and subtract vector(s)\nexport const addVector = kvector.add;\nexport const addVectors = kvector.add;\nexport const subtractVector = kvector.subtract;\nexport const equal = kvector.equal;\n\n// Convert from cartesian to polar and back\nexport const polarRadFromCart = kvector.polarRadFromCart;\nexport const polarDegFromCart = kvector.polarDegFromCart;\nexport const cartFromPolarRad = kvector.cartFromPolarRad;\nexport const cartFromPolarDeg = kvector.cartFromPolarDeg;\n\n// Rounding\nexport const round = kvector.round;\nexport const roundTo = kvector.roundTo;\nexport const floorTo = kvector.floorTo;\nexport const ceilTo = kvector.ceilTo;\n","// @flow\n/**\n * Line Utils\n * A line is an array of two points e.g. [[-5, 0], [5, 0]].\n */\n\nimport * as kpoint from \"./point.js\";\nimport * as kvector from \"./vector.js\";\n\nimport type {Point} from \"./point.js\";\n\nexport type Line = [Point, Point];\n\nexport function distanceToPoint(line: Line, point: Point): number {\n    return kpoint.distanceToLine(point, line);\n}\n\nexport function reflectPoint(line: Line, point: Point): Point {\n    return kpoint.reflectOverLine(point, line);\n}\n\nexport function midpoint(line: Line): Point {\n    return [(line[0][0] + line[1][0]) / 2, (line[0][1] + line[1][1]) / 2];\n}\n\nexport function equal(line1: Line, line2: Line, tolerance?: number): boolean {\n    // TODO: A nicer implementation might just check collinearity of\n    // vectors using underscore magick\n    // Compare the directions of the lines\n    const v1 = kvector.subtract(line1[1], line1[0]);\n    const v2 = kvector.subtract(line2[1], line2[0]);\n    if (!kvector.collinear(v1, v2, tolerance)) {\n        return false;\n    }\n    // If the start point is the same for the two lines, then they are the same\n    if (kpoint.equal(line1[0], line2[0])) {\n        return true;\n    }\n    // Make sure that the direction to get from line1 to\n    // line2 is the same as the direction of the lines\n    const line1ToLine2Vector = kvector.subtract(line2[0], line1[0]);\n    return kvector.collinear(v1, line1ToLine2Vector, tolerance);\n}\n","// @flow\n/**\n * Ray Utils\n * A ray (→) is an array of an endpoint and another point along the ray.\n * For example, [[0, 0], [1, 0]] is the ray starting at the origin and\n * traveling along the positive x-axis.\n */\n\nimport * as kpoint from \"./point.js\";\nimport * as kvector from \"./vector.js\";\n\nimport type {Point} from \"./point\";\n\nexport type Ray = [Point, Point];\n\nexport function equal(ray1: Ray, ray2: Ray, tolerance?: number): boolean {\n    // Compare the directions of the rays\n    const v1 = kvector.subtract(ray1[1], ray1[0]);\n    const v2 = kvector.subtract(ray2[1], ray2[0]);\n\n    const sameOrigin = kpoint.equal(ray1[0], ray2[0]);\n    const codirectional = kvector.codirectional(v1, v2, tolerance);\n\n    return sameOrigin && codirectional;\n}\n"],"names":["DEFAULT_TOLERANCE","EPSILON","Math","pow","is","x","_","isNumber","isNaN","equal","y","tolerance","abs","sign","isInteger","num","round","precision","factor","roundTo","increment","floorTo","floor","ceilTo","ceil","toFraction","decimal","maxDenominator","n","d","a","rem","arraySum","array","reduce","memo","arg","arrayProduct","vec","dimension","isArray","undefined","length","every","knumber","normalize","v","scale","sqrt","dot","b","zipped","zip","multiplied","map","add","subtract","v1","v2","dim","negate","scalar","pair","codirectional","collinear","polarRadFromCart","radius","theta","atan2","PI","polarDegFromCart","polar","cartFromPolarRad","cos","sin","cartFromPolarDeg","rotateRad","angle","rotateDeg","angleRad","acos","angleDeg","projection","elem","i","point","center","kvector","distanceToPoint","point1","point2","distanceToLine","line","lv","pv","projectedPv","distancePv","reflectOverLine","reflectedPv","compare","equalityTolerance","addVector","addVectors","subtractVector","kpoint","reflectPoint","midpoint","line1","line2","line1ToLine2Vector","ray1","ray2","sameOrigin"],"mappings":"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"}
+{"version":3,"file":"index.js","sources":["../../src/number.ts","../../src/vector.ts","../../src/point.ts","../../src/line.ts","../../src/ray.ts"],"sourcesContent":["/**\n * Number Utils\n * A number is a js-number, e.g. 5.12\n */\n\nimport _ from \"underscore\";\n\nexport const DEFAULT_TOLERANCE = 1e-9;\n\n// TODO: Should this just be Number.Epsilon\nexport const EPSILON: number = Math.pow(2, -42);\n\nexport function is(x: any): boolean {\n    return _.isNumber(x) && !_.isNaN(x);\n}\n\nexport function equal(x: number, y: number, tolerance?: number): boolean {\n    // Checking for undefined makes this function behave nicely\n    // with vectors of different lengths that are _.zip'd together\n    if (x == null || y == null) {\n        return x === y;\n    }\n    // We check === here so that +/-Infinity comparisons work correctly\n    if (x === y) {\n        return true;\n    }\n    if (tolerance == null) {\n        tolerance = DEFAULT_TOLERANCE;\n    }\n    return Math.abs(x - y) < tolerance;\n}\n\nexport function sign(\n    x: number,\n    tolerance?: number,\n): number /* Should be: 0 | 1 | -1 */ {\n    return equal(x, 0, tolerance) ? 0 : Math.abs(x) / x;\n}\n\nexport function isInteger(num: number, tolerance?: number): boolean {\n    return equal(Math.round(num), num, tolerance);\n}\n\n// Round a number to a certain number of decimal places\nexport function round(num: number, precision: number): number {\n    const factor = Math.pow(10, precision);\n    return Math.round(num * factor) / factor;\n}\n\n// Round num to the nearest multiple of increment\n// i.e. roundTo(83, 5) -> 85\nexport function roundTo(num: number, increment: number): number {\n    return Math.round(num / increment) * increment;\n}\n\nexport function floorTo(num: number, increment: number): number {\n    return Math.floor(num / increment) * increment;\n}\n\nexport function ceilTo(num: number, increment: number): number {\n    return Math.ceil(num / increment) * increment;\n}\n\n/**\n * toFraction\n *\n * Returns a [numerator, denominator] array rational representation\n * of `decimal`\n *\n * See http://en.wikipedia.org/wiki/Continued_fraction for implementation\n * details\n *\n * toFraction(4/8) => [1, 2]\n * toFraction(0.66) => [33, 50]\n * toFraction(0.66, 0.01) => [2/3]\n * toFraction(283 + 1/3) => [850, 3]\n */\nexport function toFraction(\n    decimal: number,\n    // can't be 0\n    tolerance: number = EPSILON,\n    maxDenominator = 1000,\n): [number, number] {\n    // Initialize everything to compute successive terms of\n    // continued-fraction approximations via recurrence relation\n    let n = [1, 0];\n    let d = [0, 1];\n    let a = Math.floor(decimal);\n    let rem = decimal - a;\n\n    while (d[0] <= maxDenominator) {\n        if (equal(n[0] / d[0], decimal, tolerance)) {\n            return [n[0], d[0]];\n        }\n        n = [a * n[0] + n[1], n[0]];\n        d = [a * d[0] + d[1], d[0]];\n        a = Math.floor(1 / rem);\n        rem = 1 / rem - a;\n    }\n\n    // We failed to find a nice rational representation,\n    // so return an irrational \"fraction\"\n    return [decimal, 1];\n}\n","/**\n * Vector Utils\n * A vector is an array of numbers e.g. [0, 3, 4].\n */\n\nimport _ from \"underscore\";\n\nimport * as knumber from \"./number\";\n\ntype Vector = ReadonlyArray<number>;\n\nfunction arraySum(array: ReadonlyArray<number>): number {\n    return array.reduce((memo, arg) => memo + arg, 0);\n}\n\nfunction arrayProduct(array: ReadonlyArray<number>): number {\n    return array.reduce((memo, arg) => memo * arg, 1);\n}\n\n/**\n * Checks if the given vector contains only numbers and, optionally, is of the\n * right dimension (length).\n *\n * is([1, 2, 3]) -> true\n * is([1, \"Hello\", 3]) -> false\n * is([1, 2, 3], 1) -> false\n */\nexport function is<T>(vec: ReadonlyArray<T>, dimension?: number): boolean {\n    if (!_.isArray(vec)) {\n        return false;\n    }\n    if (dimension !== undefined && vec.length !== dimension) {\n        return false;\n    }\n    return vec.every(knumber.is);\n}\n\n// Normalize to a unit vector\nexport function normalize<V extends Vector>(v: V): V {\n    return scale(v, 1 / length(v));\n}\n\n// Length/magnitude of a vector\nexport function length(v: Vector): number {\n    return Math.sqrt(dot(v, v));\n}\n// Dot product of two vectors\nexport function dot(a: Vector, b: Vector): number {\n    const zipped = _.zip(a, b);\n    const multiplied = zipped.map(arrayProduct);\n    return arraySum(multiplied);\n}\n\n/* vector-add multiple [x, y] coords/vectors\n *\n * add([1, 2], [3, 4]) -> [4, 6]\n */\nexport function add<V extends Vector>(...vecs: ReadonlyArray<V>): V {\n    const zipped = _.zip(...vecs);\n    // @ts-expect-error [FEI-5003] - TS2322 - Type 'number[]' is not assignable to type 'V'.\n    return zipped.map(arraySum);\n}\n\nexport function subtract<V extends Vector>(v1: V, v2: V): V {\n    // @ts-expect-error [FEI-5003] - TS2322 - Type 'number[]' is not assignable to type 'V'.\n    return _.zip(v1, v2).map((dim) => dim[0] - dim[1]);\n}\n\nexport function negate<V extends Vector>(v: V): V {\n    // @ts-expect-error [FEI-5003] - TS2322 - Type 'number[]' is not assignable to type 'V'.\n    return v.map((x) => {\n        return -x;\n    });\n}\n\n// Scale a vector\nexport function scale<V extends Vector>(v1: V, scalar: number): V {\n    // @ts-expect-error [FEI-5003] - TS2322 - Type 'number[]' is not assignable to type 'V'.\n    return v1.map((x) => {\n        return x * scalar;\n    });\n}\n\nexport function equal(v1: Vector, v2: Vector, tolerance?: number): boolean {\n    // _.zip will nicely deal with the lengths, going through\n    // the length of the longest vector. knumber.equal then\n    // returns false for any number compared to the undefined\n    // passed in if one of the vectors is shorter.\n    return _.zip(v1, v2).every((pair) =>\n        knumber.equal(pair[0], pair[1], tolerance),\n    );\n}\n\nexport function codirectional(\n    v1: Vector,\n    v2: Vector,\n    tolerance?: number,\n): boolean {\n    // The origin is trivially codirectional with all other vectors.\n    // This gives nice semantics for codirectionality between points when\n    // comparing their difference vectors.\n    if (\n        knumber.equal(length(v1), 0, tolerance) ||\n        knumber.equal(length(v2), 0, tolerance)\n    ) {\n        return true;\n    }\n\n    v1 = normalize(v1);\n    v2 = normalize(v2);\n\n    return equal(v1, v2, tolerance);\n}\n\nexport function collinear(v1: Vector, v2: Vector, tolerance?: number): boolean {\n    return (\n        codirectional(v1, v2, tolerance) ||\n        codirectional(v1, negate(v2), tolerance)\n    );\n}\n\n// TODO(jeremy) These coordinate conversion functions really only handle 2D points (ie. [number, number])\n\n// Convert a cartesian coordinate into a radian polar coordinate\nexport function polarRadFromCart(\n    v: ReadonlyArray<number>,\n): ReadonlyArray<number> {\n    const radius = length(v);\n    let theta = Math.atan2(v[1], v[0]);\n\n    // Convert angle range from [-pi, pi] to [0, 2pi]\n    if (theta < 0) {\n        theta += 2 * Math.PI;\n    }\n\n    return [radius, theta];\n}\n\n// Converts a cartesian coordinate into a degree polar coordinate\nexport function polarDegFromCart(\n    v: ReadonlyArray<number>,\n): ReadonlyArray<number> /* TODO: convert to tuple/Point */ {\n    const polar = polarRadFromCart(v);\n    return [polar[0], (polar[1] * 180) / Math.PI];\n}\n\n/* Convert a polar coordinate into a cartesian coordinate\n *\n * Examples:\n * cartFromPolarRad(5, Math.PI)\n */\nexport function cartFromPolarRad(\n    radius: number,\n    theta = 0,\n): ReadonlyArray<number> /* TODO: convert to tuple/Point */ {\n    return [radius * Math.cos(theta), radius * Math.sin(theta)];\n}\n\n/* Convert a polar coordinate into a cartesian coordinate\n *\n * Examples:\n * cartFromPolarDeg(5, 30)\n */\nexport function cartFromPolarDeg(\n    radius: number,\n    theta = 0,\n): ReadonlyArray<number> {\n    return cartFromPolarRad(radius, (theta * Math.PI) / 180);\n}\n\n// Rotate vector\nexport function rotateRad(\n    v: ReadonlyArray<number>,\n    theta: number,\n): ReadonlyArray<number> {\n    const polar = polarRadFromCart(v);\n    const angle = polar[1] + theta;\n    return cartFromPolarRad(polar[0], angle);\n}\n\nexport function rotateDeg(\n    v: ReadonlyArray<number>,\n    theta: number,\n): ReadonlyArray<number> {\n    const polar = polarDegFromCart(v);\n    const angle = polar[1] + theta;\n    return cartFromPolarDeg(polar[0], angle);\n}\n\n// Angle between two vectors\nexport function angleRad(v1: Vector, v2: Vector): number {\n    return Math.acos(dot(v1, v2) / (length(v1) * length(v2)));\n}\n\nexport function angleDeg(v1: Vector, v2: Vector): number {\n    return (angleRad(v1, v2) * 180) / Math.PI;\n}\n\n// Vector projection of v1 onto v2\nexport function projection<V extends Vector>(v1: V, v2: V): V {\n    const scalar = dot(v1, v2) / dot(v2, v2);\n    return scale(v2, scalar);\n}\n\n// Round each number to a certain number of decimal places\nexport function round<V extends Vector>(vec: V, precision: V | number): V {\n    // @ts-expect-error [FEI-5003] - TS2322 - Type 'number[]' is not assignable to type 'V'.\n    return vec.map((elem, i) =>\n        // $FlowFixMe[prop-missing]\n        // $FlowFixMe[incompatible-call]\n        knumber.round(elem, precision[i] || precision),\n    );\n}\n\n// Round each number to the nearest increment\nexport function roundTo<V extends Vector>(vec: V, increment: V | number): V {\n    // @ts-expect-error [FEI-5003] - TS2322 - Type 'number[]' is not assignable to type 'V'.\n    return vec.map((elem, i) =>\n        // $FlowFixMe[prop-missing]\n        // $FlowFixMe[incompatible-call]\n        knumber.roundTo(elem, increment[i] || increment),\n    );\n}\n\nexport function floorTo<V extends Vector>(vec: V, increment: V | number): V {\n    // @ts-expect-error [FEI-5003] - TS2322 - Type 'number[]' is not assignable to type 'V'.\n    return vec.map((elem, i) =>\n        // $FlowFixMe[prop-missing]\n        // $FlowFixMe[incompatible-call]\n        knumber.floorTo(elem, increment[i] || increment),\n    );\n}\n\nexport function ceilTo<V extends Vector>(vec: V, increment: V | number): V {\n    // @ts-expect-error [FEI-5003] - TS2322 - Type 'number[]' is not assignable to type 'V'.\n    return vec.map((elem, i) =>\n        // $FlowFixMe[prop-missing]\n        // $FlowFixMe[incompatible-call]\n        knumber.ceilTo(elem, increment[i] || increment),\n    );\n}\n","/**\n * Point Utils\n * A point is an array of two numbers e.g. [0, 0].\n */\n\nimport _ from \"underscore\";\n\nimport * as knumber from \"./number\";\nimport * as kvector from \"./vector\";\n\n// A point, in 2D, 3D, or nD space.\nexport type Point = ReadonlyArray<number>;\n\n// Rotate point (around origin unless a center is specified)\nexport function rotateRad(point: Point, theta: number, center?: Point): Point {\n    if (center === undefined) {\n        return kvector.rotateRad(point, theta);\n    } else {\n        return kvector.add(\n            center,\n            kvector.rotateRad(kvector.subtract(point, center), theta),\n        );\n    }\n}\n\nexport function rotateDeg(point: Point, theta: number, center?: Point): Point {\n    if (center === undefined) {\n        return kvector.rotateDeg(point, theta);\n    } else {\n        return kvector.add(\n            center,\n            kvector.rotateDeg(kvector.subtract(point, center), theta),\n        );\n    }\n}\n\n// Distance between two points\nexport function distanceToPoint(point1: Point, point2: Point): number {\n    return kvector.length(kvector.subtract(point1, point2));\n}\n\n// Distance between point and line\nexport function distanceToLine(point: Point, line: [Point, Point]): number {\n    const lv = kvector.subtract(line[1], line[0]);\n    const pv = kvector.subtract(point, line[0]);\n    const projectedPv = kvector.projection(pv, lv);\n    const distancePv = kvector.subtract(projectedPv, pv);\n    return kvector.length(distancePv);\n}\n\n// Reflect point over line\nexport function reflectOverLine<P extends Point>(point: P, line: [P, P]): P {\n    const lv = kvector.subtract(line[1], line[0]);\n    const pv = kvector.subtract(point, line[0]);\n    const projectedPv = kvector.projection(pv, lv);\n    const reflectedPv = kvector.subtract(kvector.scale(projectedPv, 2), pv);\n    return kvector.add(line[0], reflectedPv);\n}\n\n/**\n * Compares two points, returning -1, 0, or 1, for use with\n * Array.prototype.sort\n *\n * Note: This technically doesn't satisfy the total-ordering\n * requirements of Array.prototype.sort unless equalityTolerance\n * is 0. In some cases very close points that compare within a\n * few equalityTolerances could appear in the wrong order.\n */\nexport function compare(\n    point1: Point,\n    point2: Point,\n    equalityTolerance?: number,\n): number /* TODO: convert to -1 | 0 | 1 type */ {\n    if (point1.length !== point2.length) {\n        return point1.length - point2.length;\n    }\n    for (let i = 0; i < point1.length; i++) {\n        if (!knumber.equal(point1[i], point2[i], equalityTolerance)) {\n            return point1[i] - point2[i];\n        }\n    }\n    return 0;\n}\n\n// Check if a value is a point\nexport const is = kvector.is;\n\n// Add and subtract vector(s)\nexport const addVector = kvector.add;\nexport const addVectors = kvector.add;\nexport const subtractVector = kvector.subtract;\nexport const equal = kvector.equal;\n\n// Convert from cartesian to polar and back\nexport const polarRadFromCart = kvector.polarRadFromCart;\nexport const polarDegFromCart = kvector.polarDegFromCart;\nexport const cartFromPolarRad = kvector.cartFromPolarRad;\nexport const cartFromPolarDeg = kvector.cartFromPolarDeg;\n\n// Rounding\nexport const round = kvector.round;\nexport const roundTo = kvector.roundTo;\nexport const floorTo = kvector.floorTo;\nexport const ceilTo = kvector.ceilTo;\n","/**\n * Line Utils\n * A line is an array of two points e.g. [[-5, 0], [5, 0]].\n */\n\nimport * as kpoint from \"./point\";\nimport * as kvector from \"./vector\";\n\nimport type {Point} from \"./point\";\n\nexport type Line = [Point, Point];\n\nexport function distanceToPoint(line: Line, point: Point): number {\n    return kpoint.distanceToLine(point, line);\n}\n\nexport function reflectPoint(line: Line, point: Point): Point {\n    return kpoint.reflectOverLine(point, line);\n}\n\nexport function midpoint(line: Line): Point {\n    return [(line[0][0] + line[1][0]) / 2, (line[0][1] + line[1][1]) / 2];\n}\n\nexport function equal(line1: Line, line2: Line, tolerance?: number): boolean {\n    // TODO: A nicer implementation might just check collinearity of\n    // vectors using underscore magick\n    // Compare the directions of the lines\n    const v1 = kvector.subtract(line1[1], line1[0]);\n    const v2 = kvector.subtract(line2[1], line2[0]);\n    if (!kvector.collinear(v1, v2, tolerance)) {\n        return false;\n    }\n    // If the start point is the same for the two lines, then they are the same\n    if (kpoint.equal(line1[0], line2[0])) {\n        return true;\n    }\n    // Make sure that the direction to get from line1 to\n    // line2 is the same as the direction of the lines\n    const line1ToLine2Vector = kvector.subtract(line2[0], line1[0]);\n    return kvector.collinear(v1, line1ToLine2Vector, tolerance);\n}\n","/**\n * Ray Utils\n * A ray (→) is an array of an endpoint and another point along the ray.\n * For example, [[0, 0], [1, 0]] is the ray starting at the origin and\n * traveling along the positive x-axis.\n */\n\nimport * as kpoint from \"./point\";\nimport * as kvector from \"./vector\";\n\nimport type {Point} from \"./point\";\n\nexport type Ray = [Point, Point];\n\nexport function equal(ray1: Ray, ray2: Ray, tolerance?: number): boolean {\n    // Compare the directions of the rays\n    const v1 = kvector.subtract(ray1[1], ray1[0]);\n    const v2 = kvector.subtract(ray2[1], ray2[0]);\n\n    const sameOrigin = kpoint.equal(ray1[0], ray2[0]);\n    const codirectional = kvector.codirectional(v1, v2, tolerance);\n\n    return sameOrigin && codirectional;\n}\n"],"names":["DEFAULT_TOLERANCE","EPSILON","Math","pow","is","x","_","isNumber","isNaN","equal","y","tolerance","abs","sign","isInteger","num","round","precision","factor","roundTo","increment","floorTo","floor","ceilTo","ceil","toFraction","decimal","maxDenominator","n","d","a","rem","arraySum","array","reduce","memo","arg","arrayProduct","vec","dimension","isArray","undefined","length","every","knumber","normalize","v","scale","sqrt","dot","b","zipped","zip","multiplied","map","add","vecs","subtract","v1","v2","dim","negate","scalar","pair","codirectional","collinear","polarRadFromCart","radius","theta","atan2","PI","polarDegFromCart","polar","cartFromPolarRad","cos","sin","cartFromPolarDeg","rotateRad","angle","rotateDeg","angleRad","acos","angleDeg","projection","elem","i","point","center","kvector","distanceToPoint","point1","point2","distanceToLine","line","lv","pv","projectedPv","distancePv","reflectOverLine","reflectedPv","compare","equalityTolerance","addVector","addVectors","subtractVector","kpoint","reflectPoint","midpoint","line1","line2","line1ToLine2Vector","ray1","ray2","sameOrigin"],"mappings":"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"}

package/dist/index.d.ts

@@ -1,2 +1,5 @@
-// @flow
-export * from "../src/index.js";
+export * as number from "./number";
+export * as vector from "./vector";
+export * as point from "./point";
+export * as line from "./line";
+export * as ray from "./ray";

package/dist/index.js

@@ -12,8 +12,9 @@ var ___default = /*#__PURE__*/_interopDefaultLegacy(_);
  * Number Utils
  * A number is a js-number, e.g. 5.12
  */
-const DEFAULT_TOLERANCE = 1e-9; // TODO: Should this just be Number.Epsilon
+const DEFAULT_TOLERANCE = 1e-9;
 
+// TODO: Should this just be Number.Epsilon
 const EPSILON = Math.pow(2, -42);
 function is$2(x) {
   return ___default["default"].isNumber(x) && !___default["default"].isNaN(x);
@@ -23,34 +24,31 @@ function equal$4(x, y, tolerance) {
   // with vectors of different lengths that are _.zip'd together
   if (x == null || y == null) {
     return x === y;
-  } // We check === here so that +/-Infinity comparisons work correctly
-
-
+  }
+  // We check === here so that +/-Infinity comparisons work correctly
   if (x === y) {
     return true;
   }
-
   if (tolerance == null) {
     tolerance = DEFAULT_TOLERANCE;
   }
-
   return Math.abs(x - y) < tolerance;
 }
-function sign(x, tolerance)
-/* Should be: 0 | 1 | -1 */
-{
+function sign(x, tolerance) /* Should be: 0 | 1 | -1 */{
   return equal$4(x, 0, tolerance) ? 0 : Math.abs(x) / x;
 }
 function isInteger(num, tolerance) {
   return equal$4(Math.round(num), num, tolerance);
-} // Round a number to a certain number of decimal places
+}
 
+// Round a number to a certain number of decimal places
 function round$2(num, precision) {
   const factor = Math.pow(10, precision);
   return Math.round(num * factor) / factor;
-} // Round num to the nearest multiple of increment
-// i.e. roundTo(83, 5) -> 85
+}
 
+// Round num to the nearest multiple of increment
+// i.e. roundTo(83, 5) -> 85
 function roundTo$2(num, increment) {
   return Math.round(num / increment) * increment;
 }
@@ -60,6 +58,7 @@ function floorTo$2(num, increment) {
 function ceilTo$2(num, increment) {
   return Math.ceil(num / increment) * increment;
 }
+
 /**
  * toFraction
  *
@@ -74,7 +73,6 @@ function ceilTo$2(num, increment) {
  * toFraction(0.66, 0.01) => [2/3]
  * toFraction(283 + 1/3) => [850, 3]
  */
-
 function toFraction(decimal) {
   let tolerance = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : EPSILON;
   let maxDenominator = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1000;
@@ -84,20 +82,18 @@ function toFraction(decimal) {
   let d = [0, 1];
   let a = Math.floor(decimal);
   let rem = decimal - a;
-
   while (d[0] <= maxDenominator) {
     if (equal$4(n[0] / d[0], decimal, tolerance)) {
       return [n[0], d[0]];
     }
-
     n = [a * n[0] + n[1], n[0]];
     d = [a * d[0] + d[1], d[0]];
     a = Math.floor(1 / rem);
     rem = 1 / rem - a;
-  } // We failed to find a nice rational representation,
-  // so return an irrational "fraction"
-
+  }
 
+  // We failed to find a nice rational representation,
+  // so return an irrational "fraction"
   return [decimal, 1];
 }
 
@@ -120,14 +116,13 @@ var number = /*#__PURE__*/Object.freeze({
  * Vector Utils
  * A vector is an array of numbers e.g. [0, 3, 4].
  */
-
 function arraySum(array) {
   return array.reduce((memo, arg) => memo + arg, 0);
 }
-
 function arrayProduct(array) {
   return array.reduce((memo, arg) => memo * arg, 1);
 }
+
 /**
  * Checks if the given vector contains only numbers and, optionally, is of the
  * right dimension (length).
@@ -136,59 +131,55 @@ function arrayProduct(array) {
  * is([1, "Hello", 3]) -> false
  * is([1, 2, 3], 1) -> false
  */
-
-
 function is$1(vec, dimension) {
   if (!___default["default"].isArray(vec)) {
     return false;
   }
-
   if (dimension !== undefined && vec.length !== dimension) {
     return false;
   }
-
   return vec.every(is$2);
-} // Normalize to a unit vector
+}
 
+// Normalize to a unit vector
 function normalize(v) {
   return scale(v, 1 / length(v));
-} // Length/magnitude of a vector
+}
 
+// Length/magnitude of a vector
 function length(v) {
   return Math.sqrt(dot(v, v));
-} // Dot product of two vectors
-
+}
+// Dot product of two vectors
 function dot(a, b) {
-  // $FlowFixMe[incompatible-call] underscore doesn't like $ReadOnlyArray
   const zipped = ___default["default"].zip(a, b);
-
   const multiplied = zipped.map(arrayProduct);
   return arraySum(multiplied);
 }
+
 /* vector-add multiple [x, y] coords/vectors
  *
  * add([1, 2], [3, 4]) -> [4, 6]
  */
-
 function add() {
-  // $FlowFixMe[incompatible-call] underscore doesn't like $ReadOnlyArray
   const zipped = ___default["default"].zip(...arguments);
-
+  // @ts-expect-error [FEI-5003] - TS2322 - Type 'number[]' is not assignable to type 'V'.
   return zipped.map(arraySum);
 }
 function subtract(v1, v2) {
-  // $FlowFixMe[incompatible-call] underscore doesn't like $ReadOnlyArray
+  // @ts-expect-error [FEI-5003] - TS2322 - Type 'number[]' is not assignable to type 'V'.
   return ___default["default"].zip(v1, v2).map(dim => dim[0] - dim[1]);
 }
 function negate(v) {
-  // $FlowFixMe[incompatible-return] Flow's `.map()` libdef is lacking
+  // @ts-expect-error [FEI-5003] - TS2322 - Type 'number[]' is not assignable to type 'V'.
   return v.map(x => {
     return -x;
   });
-} // Scale a vector
+}
 
+// Scale a vector
 function scale(v1, scalar) {
-  // $FlowFixMe[incompatible-return] Flow's `.map()` libdef is lacking
+  // @ts-expect-error [FEI-5003] - TS2322 - Type 'number[]' is not assignable to type 'V'.
   return v1.map(x => {
     return x * scalar;
   });
@@ -198,7 +189,6 @@ function equal$3(v1, v2, tolerance) {
   // the length of the longest vector. knumber.equal then
   // returns false for any number compared to the undefined
   // passed in if one of the vectors is shorter.
-  // $FlowFixMe[incompatible-call] underscore doesn't like $ReadOnlyArray
   return ___default["default"].zip(v1, v2).every(pair => equal$4(pair[0], pair[1], tolerance));
 }
 function codirectional(v1, v2, tolerance) {
@@ -208,56 +198,55 @@ function codirectional(v1, v2, tolerance) {
   if (equal$4(length(v1), 0, tolerance) || equal$4(length(v2), 0, tolerance)) {
     return true;
   }
-
   v1 = normalize(v1);
   v2 = normalize(v2);
   return equal$3(v1, v2, tolerance);
 }
 function collinear(v1, v2, tolerance) {
   return codirectional(v1, v2, tolerance) || codirectional(v1, negate(v2), tolerance);
-} // TODO(jeremy) These coordinate conversion functions really only handle 2D points (ie. [number, number])
-// Convert a cartesian coordinate into a radian polar coordinate
+}
+
+// TODO(jeremy) These coordinate conversion functions really only handle 2D points (ie. [number, number])
 
+// Convert a cartesian coordinate into a radian polar coordinate
 function polarRadFromCart$1(v) {
   const radius = length(v);
-  let theta = Math.atan2(v[1], v[0]); // Convert angle range from [-pi, pi] to [0, 2pi]
+  let theta = Math.atan2(v[1], v[0]);
 
+  // Convert angle range from [-pi, pi] to [0, 2pi]
   if (theta < 0) {
     theta += 2 * Math.PI;
   }
-
   return [radius, theta];
-} // Converts a cartesian coordinate into a degree polar coordinate
+}
 
-function polarDegFromCart$1(v)
-/* TODO: convert to tuple/Point */
-{
+// Converts a cartesian coordinate into a degree polar coordinate
+function polarDegFromCart$1(v) /* TODO: convert to tuple/Point */{
   const polar = polarRadFromCart$1(v);
   return [polar[0], polar[1] * 180 / Math.PI];
 }
+
 /* Convert a polar coordinate into a cartesian coordinate
  *
  * Examples:
  * cartFromPolarRad(5, Math.PI)
  */
-
-function cartFromPolarRad$1(radius)
-/* TODO: convert to tuple/Point */
-{
+function cartFromPolarRad$1(radius) /* TODO: convert to tuple/Point */{
   let theta = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
   return [radius * Math.cos(theta), radius * Math.sin(theta)];
 }
+
 /* Convert a polar coordinate into a cartesian coordinate
  *
  * Examples:
  * cartFromPolarDeg(5, 30)
  */
-
 function cartFromPolarDeg$1(radius) {
   let theta = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
   return cartFromPolarRad$1(radius, theta * Math.PI / 180);
-} // Rotate vector
+}
 
+// Rotate vector
 function rotateRad$1(v, theta) {
   const polar = polarRadFromCart$1(v);
   const angle = polar[1] + theta;
@@ -267,42 +256,50 @@ function rotateDeg$1(v, theta) {
   const polar = polarDegFromCart$1(v);
   const angle = polar[1] + theta;
   return cartFromPolarDeg$1(polar[0], angle);
-} // Angle between two vectors
+}
 
+// Angle between two vectors
 function angleRad(v1, v2) {
   return Math.acos(dot(v1, v2) / (length(v1) * length(v2)));
 }
 function angleDeg(v1, v2) {
   return angleRad(v1, v2) * 180 / Math.PI;
-} // Vector projection of v1 onto v2
+}
 
+// Vector projection of v1 onto v2
 function projection(v1, v2) {
   const scalar = dot(v1, v2) / dot(v2, v2);
   return scale(v2, scalar);
-} // Round each number to a certain number of decimal places
+}
 
+// Round each number to a certain number of decimal places
 function round$1(vec, precision) {
-  // $FlowFixMe[incompatible-return] Flow's `.map()` libdef is lacking
-  return vec.map((elem, i) => // $FlowFixMe[prop-missing]
+  // @ts-expect-error [FEI-5003] - TS2322 - Type 'number[]' is not assignable to type 'V'.
+  return vec.map((elem, i) =>
+  // $FlowFixMe[prop-missing]
   // $FlowFixMe[incompatible-call]
   round$2(elem, precision[i] || precision));
-} // Round each number to the nearest increment
+}
 
+// Round each number to the nearest increment
 function roundTo$1(vec, increment) {
-  // $FlowFixMe[incompatible-return] Flow's `.map()` libdef is lacking
-  return vec.map((elem, i) => // $FlowFixMe[prop-missing]
+  // @ts-expect-error [FEI-5003] - TS2322 - Type 'number[]' is not assignable to type 'V'.
+  return vec.map((elem, i) =>
+  // $FlowFixMe[prop-missing]
   // $FlowFixMe[incompatible-call]
   roundTo$2(elem, increment[i] || increment));
 }
 function floorTo$1(vec, increment) {
-  // $FlowFixMe[incompatible-return] Flow's `.map()` libdef is lacking
-  return vec.map((elem, i) => // $FlowFixMe[prop-missing]
+  // @ts-expect-error [FEI-5003] - TS2322 - Type 'number[]' is not assignable to type 'V'.
+  return vec.map((elem, i) =>
+  // $FlowFixMe[prop-missing]
   // $FlowFixMe[incompatible-call]
   floorTo$2(elem, increment[i] || increment));
 }
 function ceilTo$1(vec, increment) {
-  // $FlowFixMe[incompatible-return] Flow's `.map()` libdef is lacking
-  return vec.map((elem, i) => // $FlowFixMe[prop-missing]
+  // @ts-expect-error [FEI-5003] - TS2322 - Type 'number[]' is not assignable to type 'V'.
+  return vec.map((elem, i) =>
+  // $FlowFixMe[prop-missing]
   // $FlowFixMe[incompatible-call]
   ceilTo$2(elem, increment[i] || increment));
 }
@@ -340,6 +337,8 @@ var vector = /*#__PURE__*/Object.freeze({
  * A point is an array of two numbers e.g. [0, 0].
  */
 
+// A point, in 2D, 3D, or nD space.
+
 // Rotate point (around origin unless a center is specified)
 function rotateRad(point, theta, center) {
   if (center === undefined) {
@@ -354,20 +353,23 @@ function rotateDeg(point, theta, center) {
   } else {
     return add(center, rotateDeg$1(subtract(point, center), theta));
   }
-} // Distance between two points
+}
 
+// Distance between two points
 function distanceToPoint$1(point1, point2) {
   return length(subtract(point1, point2));
-} // Distance between point and line
+}
 
+// Distance between point and line
 function distanceToLine(point, line) {
   const lv = subtract(line[1], line[0]);
   const pv = subtract(point, line[0]);
   const projectedPv = projection(pv, lv);
   const distancePv = subtract(projectedPv, pv);
   return length(distancePv);
-} // Reflect point over line
+}
 
+// Reflect point over line
 function reflectOverLine(point, line) {
   const lv = subtract(line[1], line[0]);
   const pv = subtract(point, line[0]);
@@ -375,6 +377,7 @@ function reflectOverLine(point, line) {
   const reflectedPv = subtract(scale(projectedPv, 2), pv);
   return add(line[0], reflectedPv);
 }
+
 /**
  * Compares two points, returning -1, 0, or 1, for use with
  * Array.prototype.sort
@@ -384,35 +387,34 @@ function reflectOverLine(point, line) {
  * is 0. In some cases very close points that compare within a
  * few equalityTolerances could appear in the wrong order.
  */
-
-function compare(point1, point2, equalityTolerance)
-/* TODO: convert to -1 | 0 | 1 type */
-{
+function compare(point1, point2, equalityTolerance) /* TODO: convert to -1 | 0 | 1 type */{
   if (point1.length !== point2.length) {
     return point1.length - point2.length;
   }
-
   for (let i = 0; i < point1.length; i++) {
     if (!equal$4(point1[i], point2[i], equalityTolerance)) {
       return point1[i] - point2[i];
     }
   }
-
   return 0;
-} // Check if a value is a point
+}
 
-const is = is$1; // Add and subtract vector(s)
+// Check if a value is a point
+const is = is$1;
 
+// Add and subtract vector(s)
 const addVector = add;
 const addVectors = add;
 const subtractVector = subtract;
-const equal$2 = equal$3; // Convert from cartesian to polar and back
+const equal$2 = equal$3;
 
+// Convert from cartesian to polar and back
 const polarRadFromCart = polarRadFromCart$1;
 const polarDegFromCart = polarDegFromCart$1;
 const cartFromPolarRad = cartFromPolarRad$1;
-const cartFromPolarDeg = cartFromPolarDeg$1; // Rounding
+const cartFromPolarDeg = cartFromPolarDeg$1;
 
+// Rounding
 const round = round$1;
 const roundTo = roundTo$1;
 const floorTo = floorTo$1;
@@ -460,18 +462,15 @@ function equal$1(line1, line2, tolerance) {
   // Compare the directions of the lines
   const v1 = subtract(line1[1], line1[0]);
   const v2 = subtract(line2[1], line2[0]);
-
   if (!collinear(v1, v2, tolerance)) {
     return false;
-  } // If the start point is the same for the two lines, then they are the same
-
-
+  }
+  // If the start point is the same for the two lines, then they are the same
   if (equal$2(line1[0], line2[0])) {
     return true;
-  } // Make sure that the direction to get from line1 to
+  }
+  // Make sure that the direction to get from line1 to
   // line2 is the same as the direction of the lines
-
-
   const line1ToLine2Vector = subtract(line2[0], line1[0]);
   return collinear(v1, line1ToLine2Vector, tolerance);
 }

package/dist/index.js.flow

@@ -1,2 +1,11 @@
-// @flow
-export * from "../src/index.js";
+/**
+ * Flowtype definitions for data
+ * Generated by Flowgen from a Typescript Definition
+ * Flowgen v1.21.0
+ * @flow
+ */
+declare export * as number from "./number";
+declare export * as vector from "./vector";
+declare export * as point from "./point";
+declare export * as line from "./line";
+declare export * as ray from "./ray";