@equinor/esv-intersection 3.0.0-beta.6 → 3.0.0

package/dist/layers/schematicInterfaces.d.ts

@@ -1,208 +1,208 @@
-export declare function assertNever(x: never): never;
-/**
- * The closure type of the outline
- */
-export type OutlineClosure = 'None' | 'TopAndBottom' | 'Top' | 'Bottom';
-export interface HoleSize {
-    kind: 'hole';
-    id: string;
-    diameter: number;
-    start: number;
-    end: number;
-}
-export interface CasingWindow {
-    id: string;
-    start: number;
-    end: number;
-}
-export interface Casing {
-    kind: 'casing';
-    id: string;
-    diameter: number;
-    start: number;
-    end: number;
-    hasShoe: boolean;
-    innerDiameter: number;
-    windows?: CasingWindow[];
-}
-interface SymbolComponent {
-    id: string;
-    diameter: number;
-    start: number;
-    end: number;
-    symbolKey: string;
-}
-export interface PAndASymbol extends SymbolComponent {
-    kind: 'pAndASymbol';
-}
-export declare const isPAndASymbol: (item: PAndA) => item is PAndASymbol;
-export interface CementSqueeze {
-    kind: 'cementSqueeze';
-    id: string;
-    start: number;
-    end: number;
-    /**
-     * Referenced Casing and Completion ids
-     */
-    referenceIds: string[];
-}
-export declare const isCementSqueeze: (item: PAndA) => item is CementSqueeze;
-export interface CementPlug {
-    kind: 'cementPlug';
-    id: string;
-    start: number;
-    end: number;
-    /**
-     * Referenced Casing, Completion ids
-     */
-    referenceIds: string[];
-}
-export declare const isCementPlug: (item: PAndA) => item is CementSqueeze;
-export type PAndA = PAndASymbol | CementSqueeze | CementPlug;
-interface BaseCompletion {
-    id: string;
-    diameter: number;
-    start: number;
-    end: number;
-}
-export interface Screen extends BaseCompletion {
-    kind: 'screen';
-}
-export interface Tubing extends BaseCompletion {
-    kind: 'tubing';
-}
-export interface CompletionSymbol extends BaseCompletion {
-    kind: 'completionSymbol';
-    symbolKey: string;
-}
-export type Completion = Tubing | Screen | CompletionSymbol;
-export declare const foldCompletion: <T>(fScreen: (obj: Screen) => T, fTubing: (obj: Tubing) => T, fSymbol: (obj: CompletionSymbol) => T) => (completion: Completion) => T;
-export interface Cement {
-    kind: 'cement';
-    id: string;
-    /**
-     *  Referenced Casing and Completion ids
-     */
-    referenceIds: string[];
-    toc: number;
-}
-/**
- * 'Open hole' and 'Open hole screen' are not included as they are not visualized and also not included in the ruleset
- */
-export type PerforationSubKind = 'Perforation' | 'Open hole gravel pack' | 'Open hole frac pack' | 'Cased hole frac pack' | 'Cased hole gravel pack' | 'Cased hole fracturation';
-export interface Perforation {
-    kind: 'perforation';
-    subKind: PerforationSubKind;
-    id: string;
-    start: number;
-    end: number;
-    /**
-     * is the perforation open or sealed?
-     */
-    isOpen: boolean;
-}
-export declare const foldPerforationSubKind: <T>(options: {
-    Perforation: (kind: 'Perforation') => T;
-    OpenHoleGravelPack: (kind: 'Open hole gravel pack') => T;
-    OpenHoleFracPack: (kind: 'Open hole frac pack') => T;
-    CasedHoleGravelPack: (kind: 'Cased hole gravel pack') => T;
-    CasedHoleFracPack: (kind: 'Cased hole frac pack') => T;
-    CasedHoleFracturation: (kind: 'Cased hole fracturation') => T;
-}, subKind: PerforationSubKind) => T;
-export declare const shouldPerforationStartAtHoleDiameter: (perf: Perforation) => boolean;
-export declare const shouldPerforationStartAtCasingDiameter: (perf: Perforation) => boolean;
-export declare const hasPacking: (perf: Perforation) => boolean;
-export declare function hasFracLines(perf: Perforation): boolean;
-export declare function hasSpikes(perf: Perforation): boolean;
-export declare function isSubkindCasedHoleGravelPack(perf: Perforation): boolean;
-export declare function isSubKindPerforation(perf: Perforation): boolean;
-export declare function isSubKindCasedHoleFracPack(perf: Perforation): boolean;
-export declare function isOpenHoleFracPack(perf: Perforation): boolean;
-export declare const intersect: (a: Perforation, b: Perforation) => boolean;
-export interface SchematicData {
-    holeSizes: HoleSize[];
-    casings: Casing[];
-    cements: Cement[];
-    completion: Completion[];
-    pAndA: PAndA[];
-    symbols: {
-        [key: string]: string;
-    };
-    perforations: Perforation[];
-}
-export interface InternalLayerOptions {
-    holeLayerId: string;
-    casingLayerId: string;
-    completionLayerId: string;
-    cementLayerId: string;
-    pAndALayerId: string;
-    perforationLayerId: string;
-}
-export declare const defaultInternalLayerOptions: (layerId: string) => InternalLayerOptions;
-export interface HoleOptions {
-    firstColor: string;
-    secondColor: string;
-    lineColor: string;
-}
-export declare const defaultHoleOptions: HoleOptions;
-export interface CasingShoeSize {
-    width: number;
-    length: number;
-}
-export interface WindowOptions {
-    dashColor: string;
-    dashLength: number;
-    spaceLength: number;
-}
-export interface CasingOptions {
-    solidColor: string;
-    lineColor: string;
-    shoeSize: CasingShoeSize;
-    windowOptions: WindowOptions;
-}
-export declare const defaultCasingOptions: CasingOptions;
-export interface PerforationOptions {
-    stroke: string;
-    yellow: string;
-    grey: string;
-    red: string;
-    outline: string;
-    transparent: string;
-    spikeWidth: number;
-    spikeLength: number;
-    packingOpacity: number;
-    fracLineLength: number;
-    fracLineCurve: number;
-    scalingFactor: number;
-}
-export declare const defaultPerforationOptions: PerforationOptions;
-export interface CementOptions {
-    firstColor: string;
-    secondColor: string;
-    scalingFactor: number;
-}
-export declare const defaultCementOptions: CementOptions;
-export interface CementSqueezeOptions {
-    firstColor: string;
-    secondColor: string;
-    scalingFactor: number;
-}
-export declare const defaultCementSqueezeOptions: CementSqueezeOptions;
-export interface ScreenOptions {
-    scalingFactor: number;
-    lineColor: string;
-}
-export declare const defaultScreenOptions: ScreenOptions;
-export interface TubingOptions {
-    innerColor: string;
-    outerColor: string;
-    scalingFactor: number;
-}
-export declare const defaultTubingOptions: TubingOptions;
-export interface CementPlugOptions {
-    firstColor: string;
-    secondColor: string;
-    scalingFactor: number;
-}
-export declare const defaultCementPlugOptions: CementPlugOptions;
-export {};
+export declare function assertNever(x: never): never;
+/**
+ * The closure type of the outline
+ */
+export declare type OutlineClosure = 'None' | 'TopAndBottom' | 'Top' | 'Bottom';
+export interface HoleSize {
+    kind: 'hole';
+    id: string;
+    diameter: number;
+    start: number;
+    end: number;
+}
+export interface CasingWindow {
+    id: string;
+    start: number;
+    end: number;
+}
+export interface Casing {
+    kind: 'casing';
+    id: string;
+    diameter: number;
+    start: number;
+    end: number;
+    hasShoe: boolean;
+    innerDiameter: number;
+    windows?: CasingWindow[];
+}
+interface SymbolComponent {
+    id: string;
+    diameter: number;
+    start: number;
+    end: number;
+    symbolKey: string;
+}
+export interface PAndASymbol extends SymbolComponent {
+    kind: 'pAndASymbol';
+}
+export declare const isPAndASymbol: (item: PAndA) => item is PAndASymbol;
+export interface CementSqueeze {
+    kind: 'cementSqueeze';
+    id: string;
+    start: number;
+    end: number;
+    /**
+     * Referenced Casing and Completion ids
+     */
+    referenceIds: string[];
+}
+export declare const isCementSqueeze: (item: PAndA) => item is CementSqueeze;
+export interface CementPlug {
+    kind: 'cementPlug';
+    id: string;
+    start: number;
+    end: number;
+    /**
+     * Referenced Casing, Completion ids
+     */
+    referenceIds: string[];
+}
+export declare const isCementPlug: (item: PAndA) => item is CementSqueeze;
+export declare type PAndA = PAndASymbol | CementSqueeze | CementPlug;
+interface BaseCompletion {
+    id: string;
+    diameter: number;
+    start: number;
+    end: number;
+}
+export interface Screen extends BaseCompletion {
+    kind: 'screen';
+}
+export interface Tubing extends BaseCompletion {
+    kind: 'tubing';
+}
+export interface CompletionSymbol extends BaseCompletion {
+    kind: 'completionSymbol';
+    symbolKey: string;
+}
+export declare type Completion = Tubing | Screen | CompletionSymbol;
+export declare const foldCompletion: <T>(fScreen: (obj: Screen) => T, fTubing: (obj: Tubing) => T, fSymbol: (obj: CompletionSymbol) => T) => (completion: Completion) => T;
+export interface Cement {
+    kind: 'cement';
+    id: string;
+    /**
+     *  Referenced Casing and Completion ids
+     */
+    referenceIds: string[];
+    toc: number;
+}
+/**
+ * 'Open hole' and 'Open hole screen' are not included as they are not visualized and also not included in the ruleset
+ */
+export declare type PerforationSubKind = 'Perforation' | 'Open hole gravel pack' | 'Open hole frac pack' | 'Cased hole frac pack' | 'Cased hole gravel pack' | 'Cased hole fracturation';
+export interface Perforation {
+    kind: 'perforation';
+    subKind: PerforationSubKind;
+    id: string;
+    start: number;
+    end: number;
+    /**
+     * is the perforation open or sealed?
+     */
+    isOpen: boolean;
+}
+export declare const foldPerforationSubKind: <T>(options: {
+    Perforation: (kind: 'Perforation') => T;
+    OpenHoleGravelPack: (kind: 'Open hole gravel pack') => T;
+    OpenHoleFracPack: (kind: 'Open hole frac pack') => T;
+    CasedHoleGravelPack: (kind: 'Cased hole gravel pack') => T;
+    CasedHoleFracPack: (kind: 'Cased hole frac pack') => T;
+    CasedHoleFracturation: (kind: 'Cased hole fracturation') => T;
+}, subKind: PerforationSubKind) => T;
+export declare const shouldPerforationStartAtHoleDiameter: (perf: Perforation) => boolean;
+export declare const shouldPerforationStartAtCasingDiameter: (perf: Perforation) => boolean;
+export declare const hasPacking: (perf: Perforation) => boolean;
+export declare function hasFracLines(perf: Perforation): boolean;
+export declare function hasSpikes(perf: Perforation): boolean;
+export declare function isSubkindCasedHoleGravelPack(perf: Perforation): boolean;
+export declare function isSubKindPerforation(perf: Perforation): boolean;
+export declare function isSubKindCasedHoleFracPack(perf: Perforation): boolean;
+export declare function isOpenHoleFracPack(perf: Perforation): boolean;
+export declare const intersect: (a: Perforation, b: Perforation) => boolean;
+export interface SchematicData {
+    holeSizes: HoleSize[];
+    casings: Casing[];
+    cements: Cement[];
+    completion: Completion[];
+    pAndA: PAndA[];
+    symbols: {
+        [key: string]: string;
+    };
+    perforations: Perforation[];
+}
+export interface InternalLayerOptions {
+    holeLayerId: string;
+    casingLayerId: string;
+    completionLayerId: string;
+    cementLayerId: string;
+    pAndALayerId: string;
+    perforationLayerId: string;
+}
+export declare const defaultInternalLayerOptions: (layerId: string) => InternalLayerOptions;
+export interface HoleOptions {
+    firstColor: string;
+    secondColor: string;
+    lineColor: string;
+}
+export declare const defaultHoleOptions: HoleOptions;
+export interface CasingShoeSize {
+    width: number;
+    length: number;
+}
+export interface WindowOptions {
+    dashColor: string;
+    dashLength: number;
+    spaceLength: number;
+}
+export interface CasingOptions {
+    solidColor: string;
+    lineColor: string;
+    shoeSize: CasingShoeSize;
+    windowOptions: WindowOptions;
+}
+export declare const defaultCasingOptions: CasingOptions;
+export interface PerforationOptions {
+    stroke: string;
+    yellow: string;
+    grey: string;
+    red: string;
+    outline: string;
+    transparent: string;
+    spikeWidth: number;
+    spikeLength: number;
+    packingOpacity: number;
+    fracLineLength: number;
+    fracLineCurve: number;
+    scalingFactor: number;
+}
+export declare const defaultPerforationOptions: PerforationOptions;
+export interface CementOptions {
+    firstColor: string;
+    secondColor: string;
+    scalingFactor: number;
+}
+export declare const defaultCementOptions: CementOptions;
+export interface CementSqueezeOptions {
+    firstColor: string;
+    secondColor: string;
+    scalingFactor: number;
+}
+export declare const defaultCementSqueezeOptions: CementSqueezeOptions;
+export interface ScreenOptions {
+    scalingFactor: number;
+    lineColor: string;
+}
+export declare const defaultScreenOptions: ScreenOptions;
+export interface TubingOptions {
+    innerColor: string;
+    outerColor: string;
+    scalingFactor: number;
+}
+export declare const defaultTubingOptions: TubingOptions;
+export interface CementPlugOptions {
+    firstColor: string;
+    secondColor: string;
+    scalingFactor: number;
+}
+export declare const defaultCementPlugOptions: CementPlugOptions;
+export {};

package/dist/tubing1.svg

@@ -0,0 +1,3 @@
+<svg width="100" height="100" viewBox="0 0 100 100" fill="none" xmlns="http://www.w3.org/2000/svg">
+    <path d="M10 0H90V100H10V0Z" fill="#D9D9D9"/>
+</svg>

package/dist/tubing2.svg

@@ -0,0 +1,6 @@
+<svg width="100" height="100" viewBox="0 0 100 100" fill="none" xmlns="http://www.w3.org/2000/svg">
+    <path d="M10 0H90V100H10V0Z" fill="#D9D9D9"/>
+    <path d="M0 25H10V75H0V25Z" fill="#B5B2B2"/>
+    <path d="M45 25H55V75H45V25Z" fill="#B5B2B2"/>
+    <path d="M90 25H100V75H90V25Z" fill="#B5B2B2"/>
+</svg>

package/dist/tubing3.svg

@@ -0,0 +1,12 @@
+<svg width="100" height="100" viewBox="0 0 100 100" fill="none" xmlns="http://www.w3.org/2000/svg">
+    <path d="M10 0H90V100H10V0Z" fill="#D9D9D9"/>
+    <path d="M0 25H10V75H0V25Z" fill="#B5B2B2"/>
+    <path d="M45 25H55V75H45V25Z" fill="#B5B2B2"/>
+    <path d="M25 65H30V80H25V65Z" fill="#313131"/>
+    <path d="M25 42H30V57H25V42Z" fill="#313131"/>
+    <path d="M25 21H30V36H25V21Z" fill="#313131"/>
+    <path d="M70 64H75V79H70V64Z" fill="#313131"/>
+    <path d="M70 41H75V56H70V41Z" fill="#313131"/>
+    <path d="M70 20H75V35H70V20Z" fill="#313131"/>
+    <path d="M90 25H100V75H90V25Z" fill="#B5B2B2"/>
+</svg>

package/dist/utils/arc-length.d.ts

@@ -1,23 +1,23 @@
-import { Vector } from 'curve-interpolator/dist/src/interfaces';
-type fx = (n: number) => Vector;
-export declare class ArcLength {
-    /**
-     * Calculate using an adaptive bisect method
-     * @param {Number} func Curve function returning [x,y]
-     * @param {Number} minLimit Min limit
-     * @param {Number} maxLimit Max limit
-     * @param {Number} tolerance Result tolerance
-     * @param {Number} minDepth Min recursive depth before accepting solution
-     * @param {Number} maxDepth Max recursive depth
-     */
-    static bisect(func: fx, minLimit?: number, maxLimit?: number, tolerance?: number, minDepth?: number, maxDepth?: number): number;
-    /**
-     * Calculate using trapezoid method
-     * @param {Number} func Curve function returning [x,y]
-     * @param {Number} minLimit Min limit
-     * @param {Number} maxLimit Max limit
-     * @param {Number} segments Number of segments
-     */
-    static trapezoid(func: fx, minLimit?: number, maxLimit?: number, segments?: number): number;
-}
-export {};
+import { Vector } from 'curve-interpolator/dist/src/interfaces';
+declare type fx = (n: number) => Vector;
+export declare class ArcLength {
+    /**
+     * Calculate using an adaptive bisect method
+     * @param {Number} func Curve function returning [x,y]
+     * @param {Number} minLimit Min limit
+     * @param {Number} maxLimit Max limit
+     * @param {Number} tolerance Result tolerance
+     * @param {Number} minDepth Min recursive depth before accepting solution
+     * @param {Number} maxDepth Max recursive depth
+     */
+    static bisect(func: fx, minLimit?: number, maxLimit?: number, tolerance?: number, minDepth?: number, maxDepth?: number): number;
+    /**
+     * Calculate using trapezoid method
+     * @param {Number} func Curve function returning [x,y]
+     * @param {Number} minLimit Min limit
+     * @param {Number} maxLimit Max limit
+     * @param {Number} segments Number of segments
+     */
+    static trapezoid(func: fx, minLimit?: number, maxLimit?: number, segments?: number): number;
+}
+export {};

package/dist/utils/binary-search.d.ts

@@ -1,8 +1,8 @@
-/**
- * Find index where value[index] =< searchValue and value[index+1] >= searchValue using binary search
- * @param {Number} values Array of sorted values
- * @param {Number} searchValue Value to search for
- */
-export declare class BinarySearch {
-    static search(values: number[], searchValue: number): number;
-}
+/**
+ * Find index where value[index] =< searchValue and value[index+1] >= searchValue using binary search
+ * @param {Number} values Array of sorted values
+ * @param {Number} searchValue Value to search for
+ */
+export declare class BinarySearch {
+    static search(values: number[], searchValue: number): number;
+}

package/dist/utils/color.d.ts

@@ -1,5 +1,5 @@
-/**
- * Convert color string to number
- */
-export declare function convertColor(colorStr: string): number;
-export declare function colorToCSSColor(color: number | string): string;
+/**
+ * Convert color string to number
+ */
+export declare function convertColor(colorStr: string): number;
+export declare function colorToCSSColor(color: number | string): string;

package/dist/utils/index.d.ts

@@ -1 +1 @@
-export * from './text';
+export * from './text';

package/dist/utils/root-finder.d.ts

@@ -1,34 +1,34 @@
-type fx = (n: number) => number;
-export declare class RootFinder {
-    /**
-     * Find root using newthons method
-     * @param {Number} func f(x)
-     * @param {Number} precision Accuracy of result
-     * @param {Number} maxIterations Max number of iterations to use
-     * @param {Number} start Starting position
-     * @param {Number} minLimit Min limit of result
-     * @param {Number} maxLimit Max limit of result
-     */
-    static newton(func: fx, precision?: number, maxIterations?: number, start?: number, minLimit?: number, maxLimit?: number): number;
-    /**
-     * Find root using bisect method
-     * @param {Number} func f(x)
-     * @param {Number} precision Accuracy of result
-     * @param {Number} maxIterations Max number of iterations to use
-     * @param {Number} start Starting position
-     * @param {Number} minLimit Min limit of result
-     * @param {Number} maxLimit Max limit of result
-     */
-    static bisect(func: fx, precision?: number, maxIterations?: number, start?: number, minLimit?: number, maxLimit?: number): number;
-    /**
-     * Find root by trying available methods
-     * @param {Number} func f(x)
-     * @param {Number} precision Accuracy of result
-     * @param {Number} maxIterations Max number of iterations to use
-     * @param {Number} start Starting position
-     * @param {Number} minLimit Min limit of result
-     * @param {Number} maxLimit Max limit of result
-     */
-    static findRoot(func: fx, precision?: number, maxIterations?: number, start?: number, minLimit?: number, maxLimit?: number): number;
-}
-export {};
+declare type fx = (n: number) => number;
+export declare class RootFinder {
+    /**
+     * Find root using newthons method
+     * @param {Number} func f(x)
+     * @param {Number} precision Accuracy of result
+     * @param {Number} maxIterations Max number of iterations to use
+     * @param {Number} start Starting position
+     * @param {Number} minLimit Min limit of result
+     * @param {Number} maxLimit Max limit of result
+     */
+    static newton(func: fx, precision?: number, maxIterations?: number, start?: number, minLimit?: number, maxLimit?: number): number;
+    /**
+     * Find root using bisect method
+     * @param {Number} func f(x)
+     * @param {Number} precision Accuracy of result
+     * @param {Number} maxIterations Max number of iterations to use
+     * @param {Number} start Starting position
+     * @param {Number} minLimit Min limit of result
+     * @param {Number} maxLimit Max limit of result
+     */
+    static bisect(func: fx, precision?: number, maxIterations?: number, start?: number, minLimit?: number, maxLimit?: number): number;
+    /**
+     * Find root by trying available methods
+     * @param {Number} func f(x)
+     * @param {Number} precision Accuracy of result
+     * @param {Number} maxIterations Max number of iterations to use
+     * @param {Number} start Starting position
+     * @param {Number} minLimit Min limit of result
+     * @param {Number} maxLimit Max limit of result
+     */
+    static findRoot(func: fx, precision?: number, maxIterations?: number, start?: number, minLimit?: number, maxLimit?: number): number;
+}
+export {};

package/dist/utils/text.d.ts

@@ -1,14 +1,14 @@
-import { BoundingBox } from '../interfaces';
-import { ScaleLinear } from 'd3-scale';
-export declare function pixelsPerUnit(x: ScaleLinear<number, number>): number;
-export declare function calcSize(factor: number, min: number, max: number, x: ScaleLinear<number, number>): number;
-export declare function isOverlappingHorizontally(r1: BoundingBox, r2: BoundingBox): boolean;
-export declare function isOverlapping(r1: BoundingBox, r2: BoundingBox, horizontalPadding?: number, verticalPadding?: number): boolean;
-export declare function getOverlap(r1: BoundingBox, r2: BoundingBox): {
-    dx: number;
-    dy: number;
-};
-export declare function getOverlapOffset(r1: BoundingBox, r2: BoundingBox, horizontalPadding?: number, verticalPadding?: number): {
-    dx: number;
-    dy: number;
-};
+import { BoundingBox } from '../interfaces';
+import { ScaleLinear } from 'd3-scale';
+export declare function pixelsPerUnit(x: ScaleLinear<number, number>): number;
+export declare function calcSize(factor: number, min: number, max: number, x: ScaleLinear<number, number>): number;
+export declare function isOverlappingHorizontally(r1: BoundingBox, r2: BoundingBox): boolean;
+export declare function isOverlapping(r1: BoundingBox, r2: BoundingBox, horizontalPadding?: number, verticalPadding?: number): boolean;
+export declare function getOverlap(r1: BoundingBox, r2: BoundingBox): {
+    dx: number;
+    dy: number;
+};
+export declare function getOverlapOffset(r1: BoundingBox, r2: BoundingBox, horizontalPadding?: number, verticalPadding?: number): {
+    dx: number;
+    dy: number;
+};

package/dist/utils/vectorUtils.d.ts

@@ -1,15 +1,15 @@
-import { IPoint, Point } from 'pixi.js';
-import Vector2 from '@equinor/videx-vector2';
-export declare const pointToVector: (p: IPoint) => Vector2;
-export declare const pointToArray: (p: IPoint) => [number, number];
-export declare const vectorToPoint: (v: Vector2) => Point;
-export declare const vectorToArray: (v: Vector2) => [number, number];
-export declare const arrayToPoint: (a: number[]) => Point;
-export declare const arrayToVector: (a: number[]) => Vector2;
-export declare const calcDist: (prev: [number, number], point: [number, number]) => number;
-export declare const calcDistPoint: (prev: Point, point: Point) => number;
-export declare const calcNormal: (p1: Point, p2: Point) => Point;
-export declare const convertToUnitVector: (p: Point) => Point;
-export declare const createNormals: (points: IPoint[]) => Vector2[];
-export declare const offsetPoint: (point: IPoint, vector: Vector2, offset: number) => Point;
-export declare const offsetPoints: (points: IPoint[], vectors: Vector2[], offset: number) => Point[];
+import { IPoint, Point } from 'pixi.js';
+import Vector2 from '@equinor/videx-vector2';
+export declare const pointToVector: (p: IPoint) => Vector2;
+export declare const pointToArray: (p: IPoint) => [number, number];
+export declare const vectorToPoint: (v: Vector2) => Point;
+export declare const vectorToArray: (v: Vector2) => [number, number];
+export declare const arrayToPoint: (a: number[]) => Point;
+export declare const arrayToVector: (a: number[]) => Vector2;
+export declare const calcDist: (prev: [number, number], point: [number, number]) => number;
+export declare const calcDistPoint: (prev: Point, point: Point) => number;
+export declare const calcNormal: (p1: Point, p2: Point) => Point;
+export declare const convertToUnitVector: (p: Point) => Point;
+export declare const createNormals: (points: IPoint[]) => Vector2[];
+export declare const offsetPoint: (point: IPoint, vector: Vector2, offset: number) => Point;
+export declare const offsetPoints: (points: IPoint[], vectors: Vector2[], offset: number) => Point[];