@ccpc/math 0.1.0 → 0.1.3

package/types/util/surface_util.d.ts

@@ -0,0 +1,13 @@
+import { Curve3 } from '../geometry/curve3d';
+import { Surface } from '../geometry/surface';
+import { Curve2 } from '../geometry/curve2';
+import { Tol } from '../base/tol';
+export declare class SurfaceUtil {
+    /**
+     * 调整curve2d的uv使得wire的uv连续封闭
+     * @param loop3d
+     * @param surface
+     * @param discreteCurveLoops
+     */
+    static unifyCurve2dUVBetweenCurves(loop3d: Curve3[], surface: Surface, loop2d: Curve2[], tol?: Tol): void;
+}

package/types/util/util.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 定义一些工具类方法
+ */
+export declare class Util {
+    static degreeToRadian(angle: number): number;
+    static radianToDegree(radius: number): number;
+    static isNearlyEqual(a: number, b: number, optTolerance?: number): boolean;
+    static isNearlySmaller(a: number, b: number, optTolerance?: number): boolean;
+    static isNearlySmallerOrEqual(a: number, b: number, optTolerance?: number): boolean;
+    static isNearlyBigger(a: number, b: number, optTolerance?: number): boolean;
+    static isNearlyBiggerOrEqual(a: number, b: number, optTolerance?: number): boolean;
+    static isNearly0(a: number, optTolerance?: number): boolean;
+    static isInRange(a: number, b: number, c: number, optTolerance?: number): boolean;
+    static randomInRange(min: number, max: number): number;
+    static sum(array: number[]): number;
+    static clamp(value: number, min: number, max: number): number;
+    static getUniqueOnes<T>(values: T[], equals: (a: T, b: T) => boolean): T[];
+}

package/types/util/uv_util.d.ts

@@ -0,0 +1,68 @@
+import { Tol } from '../base/tol';
+import { Vec } from '../base/vec';
+import { Curve } from '../geometry/curve';
+import { Surface } from '../geometry/surface';
+import { types } from '../type_define/i_types';
+export declare class UvUtil {
+    private static _TEST_OUTPUT;
+    static logCurveLoops(discreteCurveLoops: types.IXY[][][], tag?: string): void;
+    static logConnectedLoops(p2Loops: types.IXY[][], tag?: string): void;
+    /**
+     * 处理一条curve离散后的3d点反求参数得到的uv点的位置问题：跨越曲面周期位置的参数问题
+     * @param surface 曲面
+     * @param discreteUVs 曲线离散后计算的uv点
+     * @param uvEps
+     */
+    static unifyUvForCurvePts(surface: Surface, discreteUVs: types.IXY[], uvEps?: types.IXY): void;
+    /**
+     * 调整 uv 使得各环上 uv 连续
+     * @param surface
+     * @param discreteCurveLoops
+     * @param uvEps
+     * @param getPoleDiscreteUvs 获取极点的离散差值点的回调函数
+     */
+    static unifyUvBetweenCurves(surface: Surface, discreteCurveLoops: types.IXY[][][], uvEps: types.IXY, getPoleDiscreteUvs?: (pt1: types.IXY, pt2: types.IXY) => types.IXY[]): void;
+    /**
+     * 各内环根据外环调整 uv 周期
+     * @param surface
+     * @param p2Loops
+     * @param uvEps
+     */
+    static unifyUvBetweenLoops(surface: Surface, p2Loops: types.IXY[][], uvEps: types.IXY): void;
+    /**
+     * 合并各离散曲线为离散环
+     * @param discreteCurveLoops
+     * @param uvEps
+     */
+    static connectUvCurves(discreteCurveLoops: types.IXY[][][], uvEps: types.IXY): types.IXY[][];
+    static areEqual(point1: types.IXY, point2: types.IXY, eps: types.IXY): boolean;
+    /**
+     * 获取曲面极点 v 值
+     * @param surface
+     */
+    static getPoleVs(surface: Surface): number[];
+    /**
+     * 推导曲面 uv 容差
+     * @param surface
+     * @param tol
+     */
+    static getSurfaceUvEps(surface: Surface, tol: Tol): types.IXY;
+    /**
+     * 推导曲线 uv 容差
+     * @param curve
+     * @param tol
+     */
+    static getCurveEps<PointType extends Vec>(curve: Curve<PointType>, tol: Tol): number;
+    /**
+     * 将原始 uv 转换为弧长参数化的 uv，以便于贴图
+     * @param uvs
+     * @param surface
+     * @param clone 为 true 时，返回新数组对象；为 false 时，直接修改输入数组，并返回该数组
+     */
+    static parseUvInArcLength(uvs: types.numberArr2[], surface: Surface, clone?: boolean): types.numberArr2[];
+    private static _getPoleIndex;
+    private static _interpolated;
+    private static _interpolate;
+    private static _getUPeriod;
+    private static _getVPeriod;
+}

package/types/verb/export_verb.d.ts

@@ -0,0 +1,2 @@
+import * as verb from './verb';
+export { verb };

package/types/wasm/a2d.d.ts

@@ -0,0 +1,19 @@
+import { C2d, C2dType } from "./c2d";
+import { P2D, IP2D } from "./pt";
+import { Curve2 as MathCurve } from '../geometry/curve2';
+import { Arc2 as MathArc2d } from '../geometry/arc2d';
+import { IBx2 } from "./bx2";
+export declare class A2D extends C2d {
+    r: number;
+    center: P2D;
+    beta: number;
+    constructor(start: IP2D, end: IP2D, r: number, beta: number, center: IP2D, id?: number);
+    get type(): C2dType;
+    static toMathCurve(curve2d: A2D): MathArc2d;
+    toMathCurve(): MathCurve;
+    rev(): C2d;
+    toRev(): C2d;
+    toBuffer(type: Int32Array, data: Float64Array, typeStep: number, dataStep: number, index: number): void;
+    inside(pos: IP2D): boolean;
+    updateBox2d(b: IBx2): void;
+}

package/types/wasm/bx2.d.ts

@@ -0,0 +1,16 @@
+import { IP2D, P2D } from "./pt";
+export interface IBx2 {
+    min: IP2D;
+    max: IP2D;
+}
+export declare class Bx2 {
+    min: P2D;
+    max: P2D;
+    constructor();
+    union(b: IBx2): void;
+    update(b: IP2D | IP2D[]): void;
+    toArray(): {
+        x: number;
+        y: number;
+    }[];
+}

package/types/wasm/c2d.d.ts

@@ -0,0 +1,29 @@
+import { P2D, IP2D } from "./pt";
+import { Curve2 as MathCurve } from "../geometry/curve2";
+import { IBx2 } from "./bx2";
+export declare enum C2dType {
+    line = 0,
+    arc = 1,
+    ellipse = 2,
+    bezier2d3 = 3,
+    hyperbola = 4,
+    any = 5
+}
+export declare abstract class C2d {
+    start: P2D;
+    end: P2D;
+    id: number;
+    constructor(start: IP2D | undefined, end: IP2D | undefined, id?: number);
+    _toBuffer(ty: number, type: Int32Array, data: Float64Array, typeStep: number, dataStep: number, index: number): number;
+    abstract toMathCurve(): MathCurve;
+    abstract get type(): C2dType;
+    abstract rev(): C2d;
+    abstract toRev(): C2d;
+    abstract toBuffer(type: Int32Array, data: Float64Array, typeStep: number, dataStep: number, index: number): void;
+    abstract updateBox2d(b: IBx2): void;
+    static curveSizeWasm: number;
+}
+export interface ConfigurableCurve {
+    curve: MathCurve;
+    rate: number | undefined;
+}

package/types/wasm/elli.d.ts

@@ -0,0 +1,19 @@
+import { C2d, C2dType } from "./c2d";
+import { P2D, IP2D } from "./pt";
+import { Curve2 as MathCurve } from "../geometry/curve2";
+import { IBx2 } from "./bx2";
+export declare class Elli extends C2d {
+    a: number;
+    b: number;
+    rotate: number;
+    center: P2D;
+    beta: number;
+    constructor(start: IP2D, end: IP2D, a: number, b: number, rotate: number, center: IP2D, beta: number, id?: number);
+    get type(): C2dType;
+    rev(): C2d;
+    toRev(): C2d;
+    static toMathCurve(ell: Elli): MathCurve;
+    toMathCurve(): MathCurve;
+    toBuffer(type: Int32Array, data: Float64Array, typeStep: number, dataStep: number, index: number): void;
+    updateBox2d(b: IBx2): void;
+}

package/types/wasm/grapher2d.d.ts

@@ -0,0 +1,39 @@
+import { Curve2 } from '../geometry/curve2';
+import { Vec2 } from '../base/vec2';
+export interface IGrapher2DInput {
+    id?: number | string;
+}
+export interface IGrapher2DOutput extends IGrapher2DInput {
+    oldId?: (number | string)[];
+}
+export interface IGrapher2DInEdge extends IGrapher2DInput {
+    curve: Curve2;
+    lregion?: number | string;
+    rregion?: number | string;
+    from?: number | string;
+    to?: number | string;
+}
+export interface IGrapher2DOutPoint extends IGrapher2DOutput {
+    point: Vec2;
+}
+export interface IGrapher2DEdge extends IGrapher2DOutput {
+    curve: Curve2;
+    from: IGrapher2DOutPoint;
+    to: IGrapher2DOutPoint;
+    coedges: IGrapher2DCoeEdge[];
+}
+export interface IGrapher2DCoeEdge extends IGrapher2DOutput {
+    edge: IGrapher2DEdge;
+    isRev: boolean;
+    region: IGrapher2DDualRegion;
+}
+export interface IGrapher2DDualRegion extends IGrapher2DOutput {
+    outer: IGrapher2DCoeEdge[];
+    holes: IGrapher2DCoeEdge[][];
+    link: IGrapher2DDualRegion[];
+    depth: number;
+}
+export interface IGrapher2DResult {
+    root: IGrapher2DDualRegion;
+    list: IGrapher2DDualRegion[];
+}

package/types/wasm/grapherutil.d.ts

@@ -0,0 +1,9 @@
+import { IGrapher2DDualRegion, IGrapher2DInEdge, IGrapher2DCoeEdge, IGrapher2DEdge } from "./grapher2d";
+export declare class RegionUtil {
+    static traverseRegion(root: IGrapher2DDualRegion, doSomething: (v: IGrapher2DDualRegion) => void | undefined): void;
+    static traverseCoEdge(root: IGrapher2DDualRegion, doSomething: (v: IGrapher2DCoeEdge) => void | undefined): void;
+    static getOriginalRegion(root: IGrapher2DDualRegion): Map<number | string, IGrapher2DDualRegion[]>;
+    static getCoEdgeOrderByOriginal(root: IGrapher2DDualRegion, ori: IGrapher2DInEdge[]): Map<IGrapher2DInEdge, IGrapher2DEdge[]>;
+    static mergeDualRegion(a: IGrapher2DDualRegion, b: IGrapher2DDualRegion, delEdes: Set<IGrapher2DEdge>): void;
+    static adaptiveIdAllocation(list: IGrapher2DDualRegion[], empty: (a: IGrapher2DDualRegion) => boolean, withBg: (a: IGrapher2DDualRegion) => boolean): void;
+}

package/types/wasm/l2d.d.ts

@@ -0,0 +1,14 @@
+import { C2d, C2dType } from "./c2d";
+import { IP2D } from "./pt";
+import { Curve2 as MathCurve } from "../geometry/curve2";
+import { IBx2 } from "./bx2";
+export declare class L2D extends C2d {
+    constructor(start: IP2D, end: IP2D, id?: number);
+    get type(): C2dType;
+    toRev(): C2d;
+    static toMathCurve(line: L2D): MathCurve;
+    toMathCurve(): MathCurve;
+    rev(): C2d;
+    toBuffer(type: Int32Array, data: Float64Array, typeStep: number, dataStep: number, index: number): void;
+    updateBox2d(b: IBx2): void;
+}

package/types/wasm/loader.d.ts

@@ -0,0 +1,8 @@
+import { WasmInstance } from "./wasminstance";
+import { GeomLibWrapper } from "./wrapper";
+export declare class GeomError extends Error {
+    message: string;
+    constructor(message: string);
+}
+export declare const loadWasmInstanceAsync: () => Promise<GeomLibWrapper>;
+export declare const getGeomInstance: () => WasmInstance;

package/types/wasm/pt.d.ts

@@ -0,0 +1,19 @@
+export interface TPt {
+    tag: number;
+    x: number;
+    y: number;
+}
+export interface IP2D {
+    x: number;
+    y: number;
+}
+export declare class P2D {
+    x: number;
+    y: number;
+    constructor(x?: number, y?: number);
+    clone(): P2D;
+    dot(input?: IP2D | undefined): number;
+    length(): number;
+    normalize(): P2D;
+    normal(): P2D;
+}

package/types/wasm/wasm-geom.d.ts

@@ -0,0 +1,296 @@
+export function asyncLoad(): Promise<any>;
+export function init(_moduleOverrides: any, ...args: any[]): {
+    inspect(): string;
+    readonly arguments: void;
+    readonly thisProgram: void;
+    readonly quit: void;
+    readonly read: void;
+    readonly readAsync: void;
+    readonly readBinary: void;
+    readonly setWindowTitle: void;
+    readonly wasmBinary: void;
+    readonly noExitRuntime: void;
+    readonly INITIAL_MEMORY: void;
+    preloadedImages: {};
+    preloadedAudios: {};
+    FS_createDataFile: () => void;
+    FS_createPreloadedFile: () => void;
+    BindingError: any;
+    InternalError: any;
+    UnboundTypeError: any;
+    ___wasm_call_ctors: (...args: any[]) => any;
+    _malloc: (...args: any[]) => any;
+    ___getTypeName: (...args: any[]) => any;
+    ___embind_register_native_and_builtin_types: (...args: any[]) => any;
+    ___errno_location: (...args: any[]) => any;
+    _free: (...args: any[]) => any;
+    _setThrew: (...args: any[]) => any;
+    stackSave: (...args: any[]) => any;
+    stackRestore: (...args: any[]) => any;
+    stackAlloc: (...args: any[]) => any;
+    dynCall_iii: (...args: any[]) => any;
+    ___set_stack_limit: (...args: any[]) => any;
+    dynCall_ii: (...args: any[]) => any;
+    dynCall_vi: (...args: any[]) => any;
+    dynCall_v: (...args: any[]) => any;
+    dynCall_iiiiiidi: (...args: any[]) => any;
+    dynCall_viiiiidi: (...args: any[]) => any;
+    dynCall_i: (...args: any[]) => any;
+    dynCall_iiiiddddii: (...args: any[]) => any;
+    dynCall_viiiddddii: (...args: any[]) => any;
+    dynCall_viidd: (...args: any[]) => any;
+    dynCall_vii: (...args: any[]) => any;
+    dynCall_viid: (...args: any[]) => any;
+    dynCall_viii: (...args: any[]) => any;
+    dynCall_vidi: (...args: any[]) => any;
+    dynCall_diddi: (...args: any[]) => any;
+    dynCall_iiii: (...args: any[]) => any;
+    dynCall_jiji: (...args: any[]) => any;
+    dynCall_iidiiii: (...args: any[]) => any;
+    dynCall_viiiiii: (...args: any[]) => any;
+    dynCall_viiiii: (...args: any[]) => any;
+    dynCall_viiii: (...args: any[]) => any;
+    __growWasmMemory: (...args: any[]) => any;
+    intArrayFromString(): void;
+    intArrayToString(): void;
+    ccall(): void;
+    cwrap(): void;
+    setValue(): void;
+    getValue(): void;
+    allocate(): void;
+    getMemory(): void;
+    UTF8ArrayToString(): void;
+    UTF8ToString(): void;
+    stringToUTF8Array(): void;
+    stringToUTF8(): void;
+    lengthBytesUTF8(): void;
+    stackTrace(): void;
+    addOnPreRun(): void;
+    addOnInit(): void;
+    addOnPreMain(): void;
+    addOnExit(): void;
+    addOnPostRun(): void;
+    writeStringToMemory(): void;
+    writeArrayToMemory(): void;
+    writeAsciiToMemory(): void;
+    addRunDependency(): void;
+    removeRunDependency(): void;
+    FS_createFolder(): void;
+    FS_createPath(): void;
+    FS_createLazyFile(): void;
+    FS_createLink(): void;
+    FS_createDevice(): void;
+    FS_unlink(): void;
+    dynamicAlloc(): void;
+    loadDynamicLibrary(): void;
+    loadWebAssemblyModule(): void;
+    getLEB(): void;
+    getFunctionTables(): void;
+    alignFunctionTables(): void;
+    registerFunctions(): void;
+    addFunction(): void;
+    removeFunction(): void;
+    getFuncWrapper(): void;
+    prettyPrint(): void;
+    makeBigInt(): void;
+    dynCall(): void;
+    getCompilerSetting(): void;
+    print(): void;
+    printErr(): void;
+    getTempRet0(): void;
+    setTempRet0(): void;
+    callMain(): void;
+    abort(): void;
+    stringToNewUTF8(): void;
+    emscripten_realloc_buffer(): void;
+    ENV(): void;
+    ERRNO_CODES(): void;
+    ERRNO_MESSAGES(): void;
+    setErrNo(): void;
+    DNS(): void;
+    GAI_ERRNO_MESSAGES(): void;
+    Protocols(): void;
+    Sockets(): void;
+    traverseStack(): void;
+    UNWIND_CACHE(): void;
+    withBuiltinMalloc(): void;
+    readAsmConstArgsArray(): void;
+    readAsmConstArgs(): void;
+    jstoi_q(): void;
+    jstoi_s(): void;
+    getExecutableName(): void;
+    listenOnce(): void;
+    autoResumeAudioContext(): void;
+    abortStackOverflow(): void;
+    reallyNegative(): void;
+    formatString(): void;
+    PATH(): void;
+    PATH_FS(): void;
+    SYSCALLS(): void;
+    syscallMmap2(): void;
+    syscallMunmap(): void;
+    flush_NO_FILESYSTEM(): void;
+    JSEvents(): void;
+    specialHTMLTargets(): void;
+    maybeCStringToJsString(): void;
+    findEventTarget(): void;
+    findCanvasEventTarget(): void;
+    polyfillSetImmediate(): void;
+    demangle(): void;
+    demangleAll(): void;
+    jsStackTrace(): void;
+    getEnvStrings(): void;
+    checkWasiClock(): void;
+    writeI53ToI64(): void;
+    writeI53ToI64Clamped(): void;
+    writeI53ToI64Signaling(): void;
+    writeI53ToU64Clamped(): void;
+    writeI53ToU64Signaling(): void;
+    readI53FromI64(): void;
+    readI53FromU64(): void;
+    convertI32PairToI53(): void;
+    convertU32PairToI53(): void;
+    exceptionLast(): void;
+    exceptionCaught(): void;
+    ExceptionInfoAttrs(): void;
+    ExceptionInfo(): void;
+    CatchInfo(): void;
+    exception_addRef(): void;
+    exception_decRef(): void;
+    Browser(): void;
+    SDL_unicode(): void;
+    SDL_ttfContext(): void;
+    SDL_audio(): void;
+    SDL(): void;
+    SDL_gfx(): void;
+    emval_handle_array(): void;
+    emval_free_list(): void;
+    emval_symbols(): void;
+    init_emval(): void;
+    count_emval_handles(): void;
+    get_first_emval(): void;
+    getStringOrSymbol(): void;
+    requireHandle(): void;
+    emval_newers(): void;
+    craftEmvalAllocator(): void;
+    emval_get_global(): void;
+    emval_methodCallers(): void;
+    PureVirtualError(): void;
+    init_embind(): void;
+    throwInternalError(): void;
+    throwBindingError(): void;
+    throwUnboundTypeError(): void;
+    ensureOverloadTable(): void;
+    exposePublicSymbol(): void;
+    replacePublicSymbol(): void;
+    extendError(): void;
+    createNamedFunction(): void;
+    registeredInstances(): void;
+    getBasestPointer(): void;
+    registerInheritedInstance(): void;
+    unregisterInheritedInstance(): void;
+    getInheritedInstance(): void;
+    getInheritedInstanceCount(): void;
+    getLiveInheritedInstances(): void;
+    registeredTypes(): void;
+    awaitingDependencies(): void;
+    typeDependencies(): void;
+    registeredPointers(): void;
+    registerType(): void;
+    whenDependentTypesAreResolved(): void;
+    embind_charCodes(): void;
+    embind_init_charCodes(): void;
+    readLatin1String(): void;
+    getTypeName(): void;
+    heap32VectorToArray(): void;
+    requireRegisteredType(): void;
+    getShiftFromSize(): void;
+    integerReadValueFromPointer(): void;
+    enumReadValueFromPointer(): void;
+    floatReadValueFromPointer(): void;
+    simpleReadValueFromPointer(): void;
+    runDestructors(): void;
+    new_(): void;
+    craftInvokerFunction(): void;
+    embind__requireFunction(): void;
+    tupleRegistrations(): void;
+    structRegistrations(): void;
+    genericPointerToWireType(): void;
+    constNoSmartPtrRawPointerToWireType(): void;
+    nonConstNoSmartPtrRawPointerToWireType(): void;
+    init_RegisteredPointer(): void;
+    RegisteredPointer(): void;
+    RegisteredPointer_getPointee(): void;
+    RegisteredPointer_destructor(): void;
+    RegisteredPointer_deleteObject(): void;
+    RegisteredPointer_fromWireType(): void;
+    runDestructor(): void;
+    releaseClassHandle(): void;
+    finalizationGroup(): void;
+    detachFinalizer_deps(): void;
+    detachFinalizer(): void;
+    attachFinalizer(): void;
+    makeClassHandle(): void;
+    init_ClassHandle(): void;
+    ClassHandle(): void;
+    ClassHandle_isAliasOf(): void;
+    throwInstanceAlreadyDeleted(): void;
+    ClassHandle_clone(): void;
+    ClassHandle_delete(): void;
+    deletionQueue(): void;
+    ClassHandle_isDeleted(): void;
+    ClassHandle_deleteLater(): void;
+    flushPendingDeletes(): void;
+    delayFunction(): void;
+    setDelayFunction(): void;
+    RegisteredClass(): void;
+    shallowCopyInternalPointer(): void;
+    downcastPointer(): void;
+    upcastPointer(): void;
+    validateThis(): void;
+    char_0(): void;
+    char_9(): void;
+    makeLegalFunctionName(): void;
+    warnOnce(): void;
+    AsciiToString(): void;
+    stringToAscii(): void;
+    UTF16ToString(): void;
+    stringToUTF16(): void;
+    lengthBytesUTF16(): void;
+    UTF32ToString(): void;
+    stringToUTF32(): void;
+    lengthBytesUTF32(): void;
+    allocateUTF8(): void;
+    allocateUTF8OnStack(): void;
+    writeStackCookie: () => void;
+    checkStackCookie: () => void;
+    intArrayFromBase64(): void;
+    tryParseAsDataURI(): void;
+    readonly ALLOC_NORMAL: void;
+    readonly ALLOC_STACK: void;
+    readonly ALLOC_DYNAMIC: void;
+    readonly ALLOC_NONE: void;
+    run: (args: any) => void;
+    preInit: any;
+};
+export namespace package1 {
+    let name: string;
+    let version: string;
+    let description: string;
+    let main: string;
+    let types: string;
+    let scripts: {
+        "install-emcc": string;
+        build: string;
+        rebuild: string;
+        "build-dev": string;
+    };
+    let author: string;
+    let license: string;
+    let devDependencies: {
+        math: string;
+        "@types/node": string;
+        lodash: string;
+        typescript: string;
+    };
+}

package/types/wasm/wasminstance.d.ts

@@ -0,0 +1,19 @@
+export interface WasmInstance {
+    _malloc(nofBytes: number): number;
+    _free(ptr: number): void;
+    _realloc(ptr: number, len: number): number;
+    HEAPF64: {
+        buffer: ArrayBuffer;
+    };
+    HEAPF32: {
+        buffer: ArrayBuffer;
+    };
+    package: any;
+    helloword(): void;
+    search(cptr: number, cbitsize: number, aptr: number, acount: number, tol: number, clean: number): any;
+    getCurveSize(): number;
+    clipperInter(ptr: number, bitsize: number, tol: number, tolAngle: number, scanLineBegin: number, scanLineEnd: number, performCross: boolean, midIndex: number): any;
+    clipperDiff(ptr: number, bitsize: number, tol: number, tolAngle: number, scanLineBegin: number, scanLineEnd: number, performCross: boolean, midIndex: number): any;
+    clipperUnion(ptr: number, bitsize: number, tol: number, tolAngle: number, scanLineBegin: number, scanLineEnd: number, performCross: boolean, midIndex: number): any;
+    clipperXor(ptr: number, bitsize: number, tol: number, tolAngle: number, scanLineBegin: number, scanLineEnd: number, performCross: boolean, midIndex: number): any;
+}

package/types/wasm/wrapper.d.ts

@@ -0,0 +1,82 @@
+import { Curve2 as MathCurve2d } from '../geometry/curve2';
+import { IGrapher2DInEdge, IGrapher2DResult } from './grapher2d';
+import { WasmInstance } from './wasminstance';
+interface BufferEdges {
+    edgeCount: number;
+    curveData: number;
+    idData: number;
+    ptr: number;
+}
+interface BufferPoints {
+    data: number;
+    list: number;
+    begin: number;
+    count: number;
+}
+interface BufferRegion {
+    id: number;
+    obegin: number;
+    oend: number;
+    loopbegin: number;
+    loopend: number;
+    holes: {
+        loopbegin: number;
+        loopend: number;
+    }[];
+}
+interface BufferRegions {
+    regions: BufferRegion[];
+    loopsPtr: number;
+    regionOldPtr: number;
+}
+export interface Grapher2DResultForWasm {
+    alledge: BufferEdges;
+    point: BufferPoints;
+    regions: BufferRegions;
+}
+declare class GeomLibWrapper {
+    private _instance;
+    get instance(): WasmInstance;
+    initialize(): Promise<void>;
+    helloworld(): void;
+    search(input: IGrapher2DInEdge[], clean?: number, tol?: number): IGrapher2DResult;
+    union(loops1: MathCurve2d[][], loops2?: MathCurve2d[][], tol?: {
+        angleEps: number;
+        lengthEps: number;
+    }, fast?: boolean): MathCurve2d[][][];
+    intersect(loops1: MathCurve2d[][], loops2: MathCurve2d[][], tol?: {
+        angleEps: number;
+        lengthEps: number;
+    }, fast?: boolean): MathCurve2d[][][];
+    different(loops1: MathCurve2d[][], loops2: MathCurve2d[][], tol?: {
+        angleEps: number;
+        lengthEps: number;
+    }, fast?: boolean): MathCurve2d[][][];
+    xor(loops1: MathCurve2d[][], loops2: MathCurve2d[][], tol?: {
+        angleEps: number;
+        lengthEps: number;
+    }, fast?: boolean): MathCurve2d[][][];
+    simplfy(loops: MathCurve2d[][], tol?: {
+        angleEps: number;
+        lengthEps: number;
+    }): MathCurve2d[][][];
+    private cueveLoopsTomathCurveLoops;
+    private cueveTomathCurve;
+    private mathCurveToCueves;
+    private _getPathByBufferEx;
+    private _processGrapher2DBuffer_Points;
+    private _processGrapher2DBuffer_Edge;
+    private _processGrapher2DBuffer_Regions;
+    private _processGrapher2DBuffer;
+    private _getPathByBuffer;
+    private _paraseBuffer;
+    private _clipperInter;
+    private _clipperDiff;
+    private _clipperUnion;
+    private _clipperXor;
+    private curvesToBuffer;
+    private getRot;
+    private getPTS;
+}
+declare const Geom: GeomLibWrapper;
+export { GeomLibWrapper, Geom, };