geometrix 0.5.10 → 0.5.12

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "geometrix",
-	"version": "0.5.10",
+	"version": "0.5.12",
 	"description": "The 2D geometry engine of the parametrix",
 	"private": false,
 	"repository": {
@@ -64,6 +64,12 @@
 			"default": "./dist/index.js"
 		}
 	},
+	"files": [
+		"dist",
+		"!dist/**/*.map",
+		"!dist/**/*.test.*",
+		"!dist/**/*.spec.*"
+	],
 	"types": "./dist/index.d.ts",
 	"type": "module"
 }

package/.eslintignore

@@ -1,17 +0,0 @@
-.DS_Store
-node_modules
-/build
-/.svelte-kit
-/package
-.env
-.env.*
-!.env.example
-
-# Ignore files for PNPM, NPM and YARN
-pnpm-lock.yaml
-package-lock.json
-yarn.lock
-
-# ignore recommended by eslint
-vitest.config.ts
-dist/

package/.eslintrc.cjs

@@ -1,24 +0,0 @@
-module.exports = {
-	extends: [
-		'eslint:recommended',
-		'plugin:@typescript-eslint/recommended-type-checked',
-		//'plugin:@typescript-eslint/strict-type-checked',
-		'plugin:@typescript-eslint/stylistic-type-checked',
-		'prettier'
-	],
-	plugins: ['@typescript-eslint'],
-	parser: '@typescript-eslint/parser',
-	parserOptions: {
-		//sourceType: 'module',
-		//ecmaVersion: 2020,
-		project: true,
-		tsconfigRootDir: __dirname
-	},
-	root: true
-	//env: {
-	//	browser: true,
-	//	es2021: true,
-	//	node: true
-	//},
-	//ignorePatterns: ['*.cjs'],
-};

package/.prettierignore

@@ -1,15 +0,0 @@
-.DS_Store
-node_modules
-/build
-/dist
-/.svelte-kit
-/package
-.env
-.env.*
-!.env.example
-README.md
-
-# Ignore files for PNPM, NPM and YARN
-pnpm-lock.yaml
-package-lock.json
-yarn.lock

package/.prettierrc

@@ -1,8 +0,0 @@
-{
-	"useTabs": true,
-	"singleQuote": true,
-	"trailingComma": "none",
-	"printWidth": 100,
-	"plugins": [],
-	"overrides": []
-}

package/src/aaExportContent.ts

@@ -1,213 +0,0 @@
-// aaExportContent.ts
-
-import type { tParamVal } from './designParams';
-import type { tGeom } from './aaParamGeom';
-import { colors } from './canvas_utils';
-import { Point, point, pointMinMax } from './point';
-import type { tContour } from './contour';
-import type { Figure } from './figure';
-import { mergeFaces } from './figure';
-import type { SvgWriter } from './write_svg';
-import { svgWriter } from './write_svg';
-import { dxfWriter } from './write_dxf';
-import { paxWrite } from './write_pax';
-import { oscadWrite } from './write_openscad';
-import { ojscadWrite } from './write_openjscad';
-import * as zip from '@zip.js/zip.js';
-
-// SVG
-class MinMaxPoint {
-	xMin: number;
-	xMax: number;
-	yMin: number;
-	yMax: number;
-	firstDone: boolean;
-	constructor() {
-		this.firstDone = false;
-		this.xMin = 0;
-		this.xMax = 0;
-		this.yMin = 0;
-		this.yMax = 0;
-	}
-	addAContour(aCtr: tContour[]) {
-		if (aCtr.length > 0) {
-			const pts: Point[] = [];
-			if (this.firstDone) {
-				pts.push(point(this.xMin, this.yMin));
-				pts.push(point(this.xMax, this.yMax));
-			}
-			for (const ctr of aCtr) {
-				pts.push(...ctr.generatePoints());
-			}
-			const [Xmin, Xmax, Ymin, Ymax] = pointMinMax(pts);
-			this.xMin = Xmin;
-			this.xMax = Xmax;
-			this.yMin = Ymin;
-			this.yMax = Ymax;
-		}
-	}
-	getViewBox() {
-		const Xdelta = Math.round((this.xMax - this.xMin) * 1.1) + 10;
-		const Ydelta = Math.round((this.yMax - this.yMin) * 1.1) + 10;
-		const Xmin2 = Math.round(this.xMin - Xdelta * 0.05);
-		const Ymin2 = Math.round(this.yMin - Ydelta * 0.05);
-		return [Xmin2, Xdelta, Ymin2, Ydelta];
-	}
-}
-
-interface tGroup {
-	gpName: string;
-	gpColor: string;
-	ctrs: tContour[];
-}
-
-class SvgWriter2 {
-	minMax: MinMaxPoint;
-	groups: tGroup[];
-	svg: SvgWriter;
-	constructor() {
-		this.minMax = new MinMaxPoint();
-		this.groups = [];
-		this.svg = svgWriter();
-	}
-	addAContour(aCtrs: tContour[], groupId = '', icolor = colors.contour) {
-		this.minMax.addAContour(aCtrs);
-		const grp: tGroup = { gpName: groupId, gpColor: icolor, ctrs: aCtrs };
-		this.groups.push(grp);
-	}
-	makeSvg(yCeiling: number) {
-		for (const grp of this.groups) {
-			if (grp.gpName !== '') {
-				this.svg.addGroup(grp.gpName);
-			}
-			for (const ctr of grp.ctrs) {
-				let ctrColor = ctr.imposedColor;
-				if (ctrColor === '') {
-					ctrColor = grp.gpColor;
-				}
-				this.svg.addSvgString(ctr.toSvg(yCeiling, ctrColor));
-			}
-			if (grp.gpName !== '') {
-				this.svg.closeGroup();
-			}
-		}
-	}
-	stringify() {
-		const [Xmin2, Xdelta, Ymin2, Ydelta] = this.minMax.getViewBox();
-		this.svg.addHeader(Xmin2, Xdelta, Ymin2, Ydelta);
-		this.makeSvg(this.minMax.yMax + this.minMax.yMin);
-		return this.svg.stringify();
-	}
-}
-function svgWriter2(): SvgWriter2 {
-	const rSvgWriter2 = new SvgWriter2();
-	return rSvgWriter2;
-}
-function figureToSvg(aCtr: tContour[]): string {
-	const sw2 = svgWriter2();
-	sw2.addAContour(aCtr);
-	return sw2.stringify();
-}
-function figureToSvgDeco(fig: Figure) {
-	const sw2 = svgWriter2();
-	sw2.addAContour(fig.mainList, 'main', colors.main);
-	sw2.addAContour(fig.mainBList, 'mainB', colors.mainB);
-	sw2.addAContour(fig.secondList, 'second', colors.second);
-	sw2.addAContour(fig.secondBList, 'secondB', colors.secondB);
-	sw2.addAContour(fig.dynamicsList, 'dynamics', colors.dynamics);
-	const rSvgDeco = sw2.stringify();
-	return rSvgDeco;
-}
-
-// DXF
-function figureToDxf(aCtr: tContour[]): string {
-	const dxf = dxfWriter();
-	//const firstDxfLayer = dxf.addLayer('first');
-	for (const ctr of aCtr) {
-		if (ctr.circle) {
-			const seg = ctr.toDxfSeg()[0];
-			dxf.addCircle(seg.p1x, seg.p1y, seg.radius);
-		} else {
-			for (const seg of ctr.toDxfSeg()) {
-				if (seg.arc) {
-					dxf.addArc(seg.p1x, seg.p1y, seg.radius, seg.a1, seg.a2);
-				} else {
-					dxf.addLine(seg.p1x, seg.p1y, seg.p2x, seg.p2y);
-				}
-			}
-		}
-	}
-	const rDxf = dxf.stringify();
-	return rDxf;
-}
-
-// PAX
-function makePax(paramVal: tParamVal, geome0: tGeom): string {
-	const rStr = paxWrite().getPaxStr(paramVal, geome0);
-	return rStr;
-}
-
-// OpenSCad
-function makeOpenscad(geome0: tGeom): string {
-	const paxJson = paxWrite().getPaxJson({}, geome0);
-	const rStr = oscadWrite().getExportFile(paxJson);
-	return rStr;
-}
-
-// OpenJSCAD
-function makeOpenjscad(geome0: tGeom): string {
-	const paxJson = paxWrite().getPaxJson({}, geome0);
-	const rStr = ojscadWrite().getExportFile(paxJson);
-	return rStr;
-}
-
-// ZIP
-async function makeZip(
-	paramVal: tParamVal,
-	geome0: tGeom,
-	tSim: number,
-	geome1: tGeom
-): Promise<Blob> {
-	// zip writer preparation
-	const zipFileWriter = new zip.BlobWriter('application/zip');
-	const zipWriter = new zip.ZipWriter(zipFileWriter);
-	const partName = geome0.partName;
-	// zip payload
-	const zParam = new zip.TextReader(JSON.stringify(paramVal, null, 2));
-	await zipWriter.add(`param_${partName}.json`, zParam);
-	const zLog0 = new zip.TextReader(geome0.logstr);
-	await zipWriter.add(`geom_${partName}_log.txt`, zLog0);
-	const zLog1 = new zip.TextReader(geome1.logstr);
-	await zipWriter.add(`geom_${partName}_t${tSim}_log.txt`, zLog1);
-	for (const face in geome0.fig) {
-		const svgOne = new zip.TextReader(figureToSvg(geome0.fig[face].mainList));
-		await zipWriter.add(`face_${partName}_${face}.svg`, svgOne);
-		const dxfOne = new zip.TextReader(figureToDxf(geome0.fig[face].mainList));
-		await zipWriter.add(`face_${partName}_${face}.dxf`, dxfOne);
-		const svgOneDeco = new zip.TextReader(figureToSvgDeco(geome0.fig[face]));
-		await zipWriter.add(`deco_${partName}_${face}.svg`, svgOneDeco);
-		const svgOneDecoT = new zip.TextReader(figureToSvgDeco(geome1.fig[face]));
-		await zipWriter.add(`deco_${partName}_${face}_t${tSim}.svg`, svgOneDecoT);
-	}
-	const mergedFace = mergeFaces(geome0.fig);
-	const svgMerged = new zip.TextReader(figureToSvg(mergedFace.mainList));
-	await zipWriter.add(`face_${partName}_all_merged.svg`, svgMerged);
-	const dxfMerged = new zip.TextReader(figureToDxf(mergedFace.mainList));
-	await zipWriter.add(`face_${partName}_all_merged.dxf`, dxfMerged);
-	const svgMergedDeco = new zip.TextReader(figureToSvgDeco(mergedFace));
-	await zipWriter.add(`deco_${partName}_all_merged.svg`, svgMergedDeco);
-	const svgMergedDecoT = new zip.TextReader(figureToSvgDeco(mergedFace));
-	await zipWriter.add(`deco_${partName}_all_merged_t${tSim}.svg`, svgMergedDecoT);
-	const zPax = new zip.TextReader(makePax(paramVal, geome0));
-	await zipWriter.add(`${partName}.pax.json`, zPax);
-	const zSCad = new zip.TextReader(makeOpenscad(geome0));
-	await zipWriter.add(`${partName}_noarc_openscad.scad`, zSCad);
-	const zJScad = new zip.TextReader(makeOpenjscad(geome0));
-	await zipWriter.add(`${partName}_noarc_jscad.js`, zJScad);
-	// zip writer finalization
-	await zipWriter.close();
-	const rFileContent = await zipFileWriter.getData();
-	return rFileContent;
-}
-
-export { figureToSvg, figureToDxf, makePax, makeOpenscad, makeOpenjscad, makeZip };

package/src/aaExportFile.ts

@@ -1,141 +0,0 @@
-// aaExportFile.ts
-
-import type { tParamVal } from './designParams';
-import type { tGeomFunc } from './aaParamGeom';
-import {
-	figureToSvg,
-	figureToDxf,
-	makePax,
-	makeOpenscad,
-	makeOpenjscad,
-	makeZip
-} from './aaExportContent';
-import { mergeFaces } from './figure';
-
-enum EFormat {
-	eSVG,
-	eSVGALL,
-	eDXF,
-	eDXFALL,
-	ePAX,
-	eOPENSCAD,
-	eJSCAD,
-	eZIP
-}
-
-function fileTextContent(
-	fgeom: tGeomFunc,
-	paramVal: tParamVal,
-	eFace: string,
-	exportFormat: EFormat
-): string {
-	const geome0 = fgeom(0, paramVal);
-	let rFileContent = '';
-	if (!geome0.calcErr) {
-		const figList = Object.keys(geome0.fig);
-		if (exportFormat === EFormat.eSVG) {
-			if (figList.includes(eFace)) {
-				const figu = geome0.fig[eFace];
-				rFileContent = figureToSvg(figu.mainList);
-			} else {
-				console.log(`err749: fileTextContent eFace ${eFace} invalid`);
-			}
-		} else if (exportFormat === EFormat.eSVGALL) {
-			const figu = mergeFaces(geome0.fig);
-			rFileContent = figureToSvg(figu.mainList);
-		} else if (exportFormat === EFormat.eDXF) {
-			if (figList.includes(eFace)) {
-				const figu = geome0.fig[eFace];
-				rFileContent = figureToDxf(figu.mainList);
-			} else {
-				console.log(`err759: fileTextContent eFace ${eFace} invalid`);
-			}
-		} else if (exportFormat === EFormat.eDXFALL) {
-			const figu = mergeFaces(geome0.fig);
-			rFileContent = figureToDxf(figu.mainList);
-		} else if (exportFormat === EFormat.ePAX) {
-			rFileContent = makePax(paramVal, geome0);
-		} else if (exportFormat === EFormat.eOPENSCAD) {
-			rFileContent = makeOpenscad(geome0);
-		} else if (exportFormat === EFormat.eJSCAD) {
-			rFileContent = makeOpenjscad(geome0);
-		} else {
-			console.log(`err912: unknown exportFormat ${exportFormat}`);
-		}
-	} else {
-		console.log('err931: error by calling geome ${geome0.calcErr}');
-	}
-	return rFileContent;
-}
-
-async function fileBinContent(
-	fgeom: tGeomFunc,
-	tSim: number,
-	paramVal: tParamVal,
-	exportFormat: EFormat
-): Promise<Blob> {
-	const geome0 = fgeom(0, paramVal);
-	const geome1 = fgeom(tSim, paramVal);
-	let rFileContent = new Blob();
-	if (!geome0.calcErr && !geome1.calcErr) {
-		if (exportFormat === EFormat.eZIP) {
-			rFileContent = await makeZip(paramVal, geome0, tSim, geome1);
-		} else {
-			console.log(`err913: unknown exportFormat ${exportFormat}`);
-		}
-	} else {
-		console.log('err932: error by calling geome ${geome0.calcErr} ${geome1.calcErr}');
-	}
-	return rFileContent;
-}
-
-function fileMime(exportFormat: EFormat): string {
-	let rMime = '';
-	if (exportFormat === EFormat.eSVG || exportFormat === EFormat.eSVGALL) {
-		rMime = 'image/svg+xml';
-	} else if (exportFormat === EFormat.eDXF || exportFormat === EFormat.eDXFALL) {
-		rMime = 'application/dxf';
-	} else if (exportFormat === EFormat.ePAX) {
-		rMime = 'application/json';
-		//rMime = 'text/plain';
-	} else if (exportFormat === EFormat.eOPENSCAD) {
-		rMime = 'text/plain';
-	} else if (exportFormat === EFormat.eJSCAD) {
-		rMime = 'text/plain';
-	} else if (exportFormat === EFormat.eZIP) {
-		rMime = 'application/zip';
-		//} else {
-		//	console.log(`err903: unknown exportFormat ${exportFormat}`);
-	}
-	return rMime;
-}
-
-function fileSuffix(exportFormat: EFormat): string {
-	let rSuffix = '';
-	if (exportFormat === EFormat.eSVG || exportFormat === EFormat.eSVGALL) {
-		rSuffix = '.svg';
-	} else if (exportFormat === EFormat.eDXF || exportFormat === EFormat.eDXFALL) {
-		rSuffix = '.dxf';
-	} else if (exportFormat === EFormat.ePAX) {
-		rSuffix = '.pax.json';
-	} else if (exportFormat === EFormat.eOPENSCAD) {
-		rSuffix = '_noarc_openscad.scad';
-	} else if (exportFormat === EFormat.eJSCAD) {
-		rSuffix = '_noarc_jscad.js';
-	} else if (exportFormat === EFormat.eZIP) {
-		rSuffix = '.zip';
-		//} else {
-		//	console.log(`err904: unknown exportFormat ${exportFormat}`);
-	}
-	return rSuffix;
-}
-
-function fileBin(exportFormat: EFormat): boolean {
-	let rBin = false;
-	if (exportFormat === EFormat.eZIP) {
-		rBin = true;
-	}
-	return rBin;
-}
-
-export { EFormat, fileBinContent, fileTextContent, fileMime, fileSuffix, fileBin };

package/src/aaParamGeom.ts

@@ -1,62 +0,0 @@
-// aaParamGeom.ts
-
-import type { tParamDef, tParamVal } from './designParams';
-import type { tFaces } from './figure';
-import type { tVolume } from './volume';
-import type { tSubDesign } from './sub_design';
-
-interface tGeom {
-	partName: string;
-	calcErr: boolean;
-	logstr: string;
-	fig: tFaces;
-	vol: tVolume;
-	sub: tSubDesign;
-}
-type tGeomFunc = (t: number, ipVal: tParamVal) => tGeom;
-
-interface tPageDef {
-	pTitle: string;
-	pDescription: string;
-	pDef: tParamDef;
-	pGeom: tGeomFunc;
-}
-type tAllPageDef = Record<string, tPageDef>;
-type tAllLink = Record<string, string>; // partName: its-link
-
-function fround(ireal: number, iprecision = 1000.0): number {
-	return Math.floor(ireal * iprecision) / iprecision;
-}
-
-function initGeom(partName: string): tGeom {
-	const rGeom: tGeom = {
-		partName: partName,
-		calcErr: true,
-		logstr: '',
-		fig: {},
-		vol: { extrudes: [], volumes: [] },
-		sub: {}
-	};
-	return rGeom;
-}
-
-function checkGeom(iGeom: tGeom) {
-	if (iGeom.calcErr) {
-		let errMsg = `err182: Error in sub-design ${iGeom.partName}\n`;
-		errMsg += prefixLog(iGeom.logstr, iGeom.partName);
-		throw errMsg;
-	}
-}
-
-function prefixLog(iLog: string, iPartName: string): string {
-	let rLog = '';
-	for (const oneline of iLog.split('\n')) {
-		if (oneline !== '') {
-			rLog += `[${iPartName}]: ${oneline}\n`;
-		}
-	}
-	return rLog;
-}
-
-export type { tGeom, tGeomFunc, tPageDef, tAllPageDef, tAllLink };
-export { fround, initGeom, checkGeom, prefixLog };

package/src/angle_utils.test.ts

@@ -1,83 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-	degToRad,
-	radToDeg,
-	roundZero,
-	withinZero2Pi,
-	withinPiPi,
-	withinZeroPi,
-	withinHPiHPi
-} from './angle_utils';
-
-describe('angle suit', () => {
-	it('radian to degree', () => {
-		expect(radToDeg(Math.PI / 6)).toBeCloseTo(30, 5);
-	});
-	it('degree to radian', () => {
-		expect(degToRad(-45)).toBeCloseTo(-Math.PI / 4, 5);
-	});
-	it('roundZero', () => {
-		expect(roundZero(degToRad(90) - Math.PI / 2)).toBe(0);
-	});
-	// withinZero2Pi
-	it('withinZero2Pi 1', () => {
-		expect(withinZero2Pi(Math.PI / 3)).toBeCloseTo(Math.PI / 3, 5);
-	});
-	it('withinZero2Pi 2', () => {
-		expect(withinZero2Pi((-2 * Math.PI) / 3)).toBeCloseTo((4 * Math.PI) / 3, 5);
-	});
-	it('withinZero2Pi 3', () => {
-		expect(withinZero2Pi(-Math.PI / 3)).toBeCloseTo((5 * Math.PI) / 3, 5);
-	});
-	it('withinZero2Pi 4', () => {
-		expect(withinZero2Pi((8 * Math.PI) / 3)).toBeCloseTo((2 * Math.PI) / 3, 5);
-	});
-	it('withinZero2Pi 5', () => {
-		expect(withinZero2Pi((-14 * Math.PI) / 3)).toBeCloseTo((4 * Math.PI) / 3, 5);
-	});
-	// withinPiPi
-	it('withinPiPi 1', () => {
-		expect(withinPiPi((3 * Math.PI) / 8)).toBeCloseTo((3 * Math.PI) / 8, 5);
-	});
-	it('withinPiPi 2', () => {
-		expect(withinPiPi((7 * Math.PI) / 8)).toBeCloseTo((7 * Math.PI) / 8, 5);
-	});
-	it('withinPiPi 3', () => {
-		expect(withinPiPi((9 * Math.PI) / 8)).toBeCloseTo((-7 * Math.PI) / 8, 5);
-	});
-	it('withinPiPi 4', () => {
-		expect(withinPiPi((15 * Math.PI) / 8)).toBeCloseTo(-Math.PI / 8, 5);
-	});
-	it('withinPiPi 5', () => {
-		expect(withinPiPi((-13 * Math.PI) / 8)).toBeCloseTo((3 * Math.PI) / 8, 5);
-	});
-	// withinZeroPi
-	it('withinZeroPi 1', () => {
-		expect(withinZeroPi((2 * Math.PI) / 7)).toBeCloseTo((2 * Math.PI) / 7, 5);
-	});
-	it('withinZeroPi 2', () => {
-		expect(withinZeroPi((6 * Math.PI) / 7)).toBeCloseTo((6 * Math.PI) / 7, 5);
-	});
-	it('withinZeroPi 3', () => {
-		expect(withinZeroPi((9 * Math.PI) / 7)).toBeCloseTo((2 * Math.PI) / 7, 5);
-	});
-	it('withinZeroPi 4', () => {
-		expect(withinZeroPi(-Math.PI / 7)).toBeCloseTo((6 * Math.PI) / 7, 5);
-	});
-	it('withinZeroPi 5', () => {
-		expect(withinZeroPi((-4 * Math.PI) / 7)).toBeCloseTo((3 * Math.PI) / 7, 5);
-	});
-	// withinHPiHPi
-	it('withinHPiHPi 1', () => {
-		expect(withinHPiHPi((2 * Math.PI) / 7)).toBeCloseTo((2 * Math.PI) / 7, 5);
-	});
-	it('withinHPiHPi 2', () => {
-		expect(withinHPiHPi((5 * Math.PI) / 9)).toBeCloseTo((-4 * Math.PI) / 9, 5);
-	});
-	it('withinHPiHPi 3', () => {
-		expect(withinHPiHPi((-8 * Math.PI) / 9)).toBeCloseTo(Math.PI / 9, 5);
-	});
-	it('withinHPiHPi 4', () => {
-		expect(withinHPiHPi((17 * Math.PI) / 9)).toBeCloseTo(-Math.PI / 9, 5);
-	});
-});

package/src/angle_utils.ts

@@ -1,98 +0,0 @@
-// angle_utils.ts
-// some useful functions manipulating angles
-// angle_utils.ts has no dependency
-
-const tolerance = 10 ** -4;
-
-/* utils for angles */
-
-function degToRad(degrees: number): number {
-	return degrees * (Math.PI / 180);
-}
-
-function radToDeg(rad: number): number {
-	return rad / (Math.PI / 180);
-}
-
-function roundZero(ix: number): number {
-	let rx = ix;
-	if (Math.abs(rx) < tolerance) {
-		rx = 0;
-	}
-	return rx;
-}
-
-function withinZero2Pi(ia: number): number {
-	let ra = ia % (2 * Math.PI);
-	if (ra < 0) {
-		//console.log(`dbg026: ${ra}`);
-		ra += 2 * Math.PI;
-	}
-	return ra;
-}
-
-function withinPiPi(ia: number): number {
-	let ra = withinZero2Pi(ia);
-	if (ra > Math.PI) {
-		ra -= 2 * Math.PI;
-	}
-	return ra;
-}
-
-function withinZeroPi(ia: number): number {
-	let ra = ia % Math.PI;
-	if (ra < 0) {
-		ra += Math.PI;
-	}
-	return ra;
-}
-
-function withinHPiHPi(ia: number): number {
-	let ra = withinZeroPi(ia);
-	if (ra > Math.PI / 2) {
-		ra -= Math.PI;
-	}
-	return ra;
-}
-
-function orientedArc(aStart: number, aStop: number, ccw: boolean): number {
-	const arc = withinPiPi(aStop) - withinPiPi(aStart);
-	const arc2 = ccw ? withinZero2Pi(arc) : withinZero2Pi(arc) - 2 * Math.PI;
-	return arc2;
-}
-
-function isWithin(aNew: number, aStart: number, aStop: number, ccw: boolean): boolean {
-	let rYes = false;
-	if (roundZero(withinPiPi(aNew - aStart)) === 0) {
-		rYes = true;
-	} else if (roundZero(withinPiPi(aNew - aStop)) === 0) {
-		rYes = true;
-	} else {
-		const arcOrig = orientedArc(aStart, aStop, ccw);
-		const arcNew = orientedArc(aStart, aNew, ccw);
-		if (Math.abs(arcNew) < Math.abs(arcOrig)) {
-			rYes = true;
-		}
-	}
-	return rYes;
-}
-
-function ffix(ifloat: number): string {
-	return ifloat.toFixed(2);
-}
-
-/* export */
-
-export {
-	tolerance,
-	degToRad,
-	radToDeg,
-	roundZero,
-	withinZero2Pi,
-	withinPiPi,
-	withinZeroPi,
-	withinHPiHPi,
-	orientedArc,
-	isWithin,
-	ffix
-};