ducjs 1.0.0

package/dist/utils/filebyte.js

@@ -0,0 +1,117 @@
+/**
+ * Synchronously converts data to a Base64 Data URL.
+ *
+ * This function is truly synchronous and works in both Node.js and browser environments.
+ *
+ * @param data The input data. Can be a UTF-8 string, a Uint8Array, or an ArrayBuffer.
+ * @param mimeType The MIME type for the Data URL.
+ * @returns A fully formed Base64 Data URL string.
+ */
+export function toDataURL(data, mimeType = 'application/octet-stream' // A more generic default
+) {
+    try {
+        // If data is already a valid data URL, return it directly.
+        if (typeof data === 'string' && data.startsWith('data:')) {
+            return data;
+        }
+        let base64String;
+        if (typeof data === 'string') {
+            // Handle UTF-8 strings by converting them to a byte array first,
+            // then encoding. This is more robust than the btoa(unescape(encodeURIComponent(...))) trick.
+            const bytes = new TextEncoder().encode(data);
+            base64String = uint8ArrayToBase64(bytes);
+        }
+        else {
+            // For ArrayBuffer, we need to create a Uint8Array view.
+            // If it's already a Uint8Array, we can use it directly.
+            const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
+            base64String = uint8ArrayToBase64(bytes);
+        }
+        return `data:${mimeType};base64,${base64String}`;
+    }
+    catch (error) {
+        console.error('Error generating data URL:', error);
+        throw error; // Re-throw the error after logging
+    }
+}
+/**
+ * Synchronously decodes a Base64 Data URL into its constituent parts.
+ *
+ * This function only supports Base64 encoded Data URLs.
+ *
+ * @param dataUrl The Base64 Data URL string (e.g., "data:image/png;base64,iVBOR...").
+ * @returns An object containing the decoded Uint8Array and the MIME type.
+ * @throws An error if the input is not a valid or supported Data URL.
+ */
+export function fromDataURL(dataUrl) {
+    // 1. Validation
+    if (!dataUrl.startsWith('data:')) {
+        throw new Error('Invalid Data URL: Must start with "data:".');
+    }
+    // 2. Find the metadata/data separator (the first comma)
+    const commaIndex = dataUrl.indexOf(',');
+    if (commaIndex === -1) {
+        throw new Error('Invalid Data URL: No comma separator found.');
+    }
+    // 3. Extract header and base64 data
+    const header = dataUrl.substring(5, commaIndex); // "data:".length is 5
+    const base64Data = dataUrl.substring(commaIndex + 1);
+    // 4. Parse header to get MIME type and check for base64 encoding
+    const headerParts = header.split(';');
+    const mimeType = headerParts[0] || 'application/octet-stream'; // Default MIME if empty
+    if (headerParts[headerParts.length - 1] !== 'base64') {
+        throw new Error('Unsupported Data URL: Only base64 encoding is supported.');
+    }
+    // 5. Decode the base64 data using our helper function
+    const data = base64ToUint8Array(base64Data);
+    return { data, mimeType };
+}
+export function uint8ArrayToBase64(bytes) {
+    // Node.js environment
+    if (typeof Buffer !== 'undefined') {
+        return Buffer.from(bytes).toString('base64');
+    }
+    // Browser environment
+    let binary = '';
+    const len = bytes.byteLength;
+    for (let i = 0; i < len; i++) {
+        binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+}
+export function base64ToUint8Array(base64) {
+    // Node.js environment
+    if (typeof Buffer !== 'undefined') {
+        return new Uint8Array(Buffer.from(base64, 'base64'));
+    }
+    // Browser environment
+    // Sanitize the base64 string by removing any characters that are not part of the standard base64 alphabet
+    const sanitizedBase64 = base64.replace(/[^A-Za-z0-9+/=]/g, '');
+    const binaryString = atob(sanitizedBase64);
+    const bytes = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+        bytes[i] = binaryString.charCodeAt(i);
+    }
+    return bytes;
+}
+/**
+ * Converts a Uint8Array to a browser File object.
+ *
+ * @param bytes The Uint8Array containing the binary data of the file.
+ * @param fileName The desired name for the file, including its extension (e.g., "thumbnail.png").
+ * @param options Optional settings for the file.
+ * @param options.mimeType The MIME type of the file (e.g., "image/png"). Defaults to "application/octet-stream".
+ * @param options.lastModified The timestamp (milliseconds since epoch) for the file's last modified date. Defaults to the current time.
+ * @returns A File object.
+ */
+export function uint8ArrayToFile(bytes, fileName, options = {}) {
+    var _a, _b;
+    // Set default values for options
+    const mimeType = (_a = options.mimeType) !== null && _a !== void 0 ? _a : 'application/octet-stream';
+    const lastModified = (_b = options.lastModified) !== null && _b !== void 0 ? _b : Date.now();
+    // Create and return the File object
+    return new File([new Uint8Array(bytes)], fileName, {
+        type: mimeType,
+        lastModified: lastModified,
+    });
+}

package/dist/utils/functionCodec.d.ts

@@ -0,0 +1,5 @@
+export declare function isEncodedFunctionString(val: unknown): val is string;
+export declare function encodeFunctionString(fn: Function): string;
+export declare function tryDecodeFunctionString(val: string): string | null;
+export declare function reviveEncodedFunction(val: unknown): unknown;
+export declare function reviveFunctionsDeep(obj: any, seen?: WeakSet<object>): any;

package/dist/utils/functionCodec.js

@@ -0,0 +1,86 @@
+// Utilities to encode functions as strings for safe structured cloning, and revive them later on main thread.
+const FN_SENTINEL = "__DUCFN__:";
+function b64EncodeUtf8(str) {
+    try {
+        // Browser
+        // eslint-disable-next-line no-undef
+        return btoa(unescape(encodeURIComponent(str)));
+    }
+    catch (_a) {
+        // Node
+        return Buffer.from(str, "utf-8").toString("base64");
+    }
+}
+function b64DecodeUtf8(b64) {
+    try {
+        // Browser
+        // eslint-disable-next-line no-undef
+        return decodeURIComponent(escape(atob(b64)));
+    }
+    catch (_a) {
+        // Node
+        return Buffer.from(b64, "base64").toString("utf-8");
+    }
+}
+export function isEncodedFunctionString(val) {
+    return typeof val === "string" && val.startsWith(FN_SENTINEL);
+}
+export function encodeFunctionString(fn) {
+    const code = fn.toString();
+    return FN_SENTINEL + b64EncodeUtf8(code);
+}
+export function tryDecodeFunctionString(val) {
+    if (!isEncodedFunctionString(val))
+        return null;
+    const b64 = val.slice(FN_SENTINEL.length);
+    try {
+        return b64DecodeUtf8(b64);
+    }
+    catch (_a) {
+        return null;
+    }
+}
+export function reviveEncodedFunction(val) {
+    if (!isEncodedFunctionString(val))
+        return val;
+    const code = tryDecodeFunctionString(val);
+    if (!code)
+        return val;
+    try {
+        // Wrap in parentheses to handle arrow functions and function declarations uniformly
+        // eslint-disable-next-line no-eval
+        const revived = eval(`(${code})`);
+        if (typeof revived === "function")
+            return revived;
+        return val;
+    }
+    catch (_a) {
+        return val;
+    }
+}
+export function reviveFunctionsDeep(obj, seen = new WeakSet()) {
+    if (obj == null)
+        return obj;
+    if (typeof obj === "string")
+        return reviveEncodedFunction(obj);
+    if (typeof obj !== "object")
+        return obj;
+    if (seen.has(obj))
+        return obj;
+    seen.add(obj);
+    if (Array.isArray(obj)) {
+        for (let i = 0; i < obj.length; i++) {
+            obj[i] = reviveFunctionsDeep(obj[i], seen);
+        }
+        return obj;
+    }
+    for (const [k, v] of Object.entries(obj)) {
+        if (typeof v === "string" && isEncodedFunctionString(v)) {
+            obj[k] = reviveEncodedFunction(v);
+        }
+        else {
+            obj[k] = reviveFunctionsDeep(v, seen);
+        }
+    }
+    return obj;
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,32 @@
+export * from "./elements";
+export * from "./math";
+export * from "./state";
+export * from "./constants";
+export * from "./shape";
+export * from "./bounds";
+export * from "./normalize";
+export * from "./url";
+export * from "./version";
+export * from "./filebyte";
+export * from "./functionCodec";
+/**
+ * supply `null` as message if non-never value is valid, you just need to
+ * typecheck against it
+ */
+export declare const assertNever: (value: never, message: string | null, softAssert?: boolean) => never;
+export declare const getUpdatedTimestamp: () => number;
+export declare const isFiniteNumber: (value: any) => value is number;
+/**
+ * Transforms array of objects containing `id` attribute,
+ * or array of ids (strings), into a Map, keyd by `id`.
+ */
+export declare const arrayToMap: <T extends {
+    id: string;
+} | string>(items: readonly T[] | Map<string, T>) => Map<any, any>;
+/**
+ * Checks whether first directional character is RTL. Meaning whether it starts
+ *  with RTL characters, or indeterminate (numbers etc.) characters followed by
+ *  RTL.
+ * See https://github.com/excalidraw/excalidraw/pull/1722#discussion_r436340171
+ */
+export declare const isRTL: (text: string) => boolean;

package/dist/utils/index.js

@@ -0,0 +1,53 @@
+export * from "./elements";
+export * from "./math";
+export * from "./state";
+export * from "./constants";
+export * from "./shape";
+export * from "./bounds";
+export * from "./normalize";
+export * from "./url";
+export * from "./version";
+export * from "./filebyte";
+export * from "./functionCodec";
+/**
+ * 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());
+};
+const RS_LTR_CHARS = "A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02B8\u0300-\u0590\u0800-\u1FFF" +
+    "\u2C00-\uFB1C\uFDFE-\uFE6F\uFEFD-\uFFFF";
+const RS_RTL_CHARS = "\u0591-\u07FF\uFB1D-\uFDFD\uFE70-\uFEFC";
+const RE_RTL_CHECK = new RegExp(`^[^${RS_LTR_CHARS}]*[${RS_RTL_CHARS}]`);
+/**
+ * Checks whether first directional character is RTL. Meaning whether it starts
+ *  with RTL characters, or indeterminate (numbers etc.) characters followed by
+ *  RTL.
+ * See https://github.com/excalidraw/excalidraw/pull/1722#discussion_r436340171
+ */
+export const isRTL = (text) => RE_RTL_CHECK.test(text);

package/dist/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 GAPoint = NVector;
+export type GADirection = NVector;
+export type GALine = NVector;
+export type GATransform = NVector;
+export declare const point: (x: number, y: number) => GAPoint;
+export declare const origin: () => GAPoint;
+export declare const direction: (x: number, y: number) => GADirection;
+export declare const offset: (x: number, y: number) => GADirection;
+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/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/utils/math/algebra/gadirections.d.ts

@@ -0,0 +1,9 @@
+import type { GALine, GADirection, GAPoint } from "ducjs/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 fromDirection: (point: GAPoint) => GAPoint;
+export declare const fromTo: (from: GAPoint, to: GAPoint) => GADirection;
+export declare const directionOrthogonal: (direction: GADirection) => GADirection;
+export declare const orthogonalToLine: (line: GALine) => GADirection;

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

@@ -0,0 +1,18 @@
+import * as GA from "ducjs/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 fromDirection = (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 directionOrthogonal = (direction) => GA.inormalized([0, 0, 0, 0, -direction[5], direction[4], 0, 0]);
+export const orthogonalToLine = (line) => GA.mul(line, GA.I);

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

@@ -0,0 +1,23 @@
+import type { GALine, GAPoint } from "ducjs/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) => GALine;
+export declare const equation: (a: number, b: number, c: number) => GALine;
+export declare const through: (from: GAPoint, to: GAPoint) => GALine;
+export declare const orthogonal: (line: GALine, point: GAPoint) => GALine;
+export declare const orthogonalThrough: (against: GAPoint, intersection: GAPoint) => GALine;
+export declare const parallel: (line: GALine, distance: number) => GALine;
+export declare const parallelThrough: (line: GALine, point: GAPoint) => GALine;
+export declare const distance: (line1: GALine, line2: GALine) => number;
+export declare const angle: (line1: GALine, line2: GALine) => number;
+export declare const sign: (line: GALine) => number;