@dra2020/baseclient 1.0.13 → 1.0.14

package/dist/ot-js/otarray.d.ts

@@ -0,0 +1,111 @@
+import * as OT from "./ottypes";
+export declare const OpInsert: number;
+export declare const OpDelete: number;
+export declare const OpRetain: number;
+export declare const OpCursor: number;
+export declare const OpSet: number;
+export declare const OpTmpRetain: number;
+export declare type OTSingleArrayEdit = [number, number, any];
+export declare type OTEdits = OTSingleArrayEdit[];
+declare enum OTalignEdgesType {
+    AlignForCompose = 0,
+    AlignForTransform = 1
+}
+export interface IOTArrayLikeOperations {
+    underlyingTypeName(): string;
+    empty(): any;
+    insert(t: any, pos: number, tInsert: any): any;
+    delete(t: any, pos: number, len: number): any;
+    set(t: any, pos: number, tSet: any): any;
+    append(t: any, tAppend: any): any;
+    substr(t: any, pos: number, len: number): any;
+    substrOf(t: any, pos: number, len: number, tsub: any): any;
+    constructN(n: number): any;
+    equal(t1: any, t2: any): boolean;
+    copy(t: any): any;
+    length(t: any): number;
+}
+export declare class OTSingleArrayEditor {
+    raw: IOTArrayLikeOperations;
+    constructor(raw: IOTArrayLikeOperations);
+    copy(a: OTSingleArrayEdit): OTSingleArrayEdit;
+    isDelete(a: OTSingleArrayEdit): boolean;
+    isNotDelete(a: OTSingleArrayEdit): boolean;
+    isCursor(a: OTSingleArrayEdit): boolean;
+    isNotCursor(a: OTSingleArrayEdit): boolean;
+    isTmpRetain(a: OTSingleArrayEdit): boolean;
+    isNotTmpRetainOrDelete(a: OTSingleArrayEdit): boolean;
+    isTmpRetainOrDelete(a: OTSingleArrayEdit): boolean;
+    isIgnore(a: OTSingleArrayEdit): boolean;
+    isNoOp(a: OTSingleArrayEdit): boolean;
+    isEqual(a1: OTSingleArrayEdit, a2: OTSingleArrayEdit): boolean;
+    appendValue(a: OTSingleArrayEdit, s: any): void;
+    empty(a: OTSingleArrayEdit): void;
+    setIgnore(a: OTSingleArrayEdit): void;
+    substr(aIn: OTSingleArrayEdit, pos: number, len: number): void;
+    substrFromRaw(aIn: OTSingleArrayEdit, pos: number, len: number, s: any): void;
+    copyWithSubstr(aIn: OTSingleArrayEdit, pos: number, len: number): OTSingleArrayEdit;
+}
+export declare class OTStringOperations implements IOTArrayLikeOperations {
+    underlyingTypeName(): string;
+    empty(): any;
+    insert(a: any, pos: number, aInsert: any): any;
+    delete(a: any, pos: number, len: number): any;
+    set(a: any, pos: number, aSet: any): any;
+    append(a: any, aAppend: any): any;
+    substr(a: any, pos: number, len: number): any;
+    substrOf(a: any, pos: number, len: number, aSub: any): any;
+    constructN(n: number): any;
+    equal(a1: any, a2: any): boolean;
+    copy(a: any): any;
+    length(a: any): number;
+}
+export declare class OTArrayOperations implements IOTArrayLikeOperations {
+    underlyingTypeName(): string;
+    empty(): any;
+    insert(a: any, pos: number, aInsert: any): any;
+    delete(a: any, pos: number, len: number): any;
+    set(a: any, pos: number, aSet: any): any;
+    append(a: any, aAppend: any): any;
+    substr(a: any, pos: number, len: number): any;
+    substrOf(a: any, pos: number, len: number, aSub: any): any;
+    constructN(n: number): any;
+    equal(a1: any, a2: any): boolean;
+    copy(a: any): any;
+    length(a: any): number;
+}
+export declare class OTArrayLikeResource extends OT.OTResourceBase {
+    editor: OTSingleArrayEditor;
+    constructor(ed: OTSingleArrayEditor, rname: string);
+    copy(): OTArrayLikeResource;
+    moveEdits(newA: OTEdits, iStart: number, iEnd?: number, pred?: (a: OTSingleArrayEdit) => boolean): void;
+    equal(rhs: OTArrayLikeResource): boolean;
+    effectivelyEqual(rhs: OTArrayLikeResource): boolean;
+    basesConsistent(rhs: OTArrayLikeResource): void;
+    originalLength(): number;
+    finalLength(): number;
+    apply(aValue: any): any;
+    coalesce(bDeleteCursor?: boolean): void;
+    fullyCoalesce(): void;
+    invert(sInput: any): void;
+    alignEdges(rhs: OTArrayLikeResource, st: OTalignEdgesType): void;
+    getCursorCache(): any;
+    compose(rhs: OTArrayLikeResource): void;
+    performTransformReorder(bForceRetainBeforeInsert: boolean, newA: OTEdits, iBegin: number, iEnd: number): void;
+    normalizeNewRetainsAfterTransform(bForceRetainBeforeInsert: boolean): void;
+    transform(prior: OTArrayLikeResource, bPriorIsService: boolean): void;
+    generateRandom(nInitial: number, clientID: string): void;
+}
+export declare class OTStringResource extends OTArrayLikeResource {
+    static _editor: OTSingleArrayEditor;
+    constructor(rname: string);
+    static factory(rname: string): OTStringResource;
+    copy(): OTStringResource;
+}
+export declare class OTArrayResource extends OTArrayLikeResource {
+    static _editor: OTSingleArrayEditor;
+    constructor(rname: string);
+    static factory(rname: string): OTArrayResource;
+    copy(): OTArrayResource;
+}
+export {};

package/dist/ot-js/otclientengine.d.ts

@@ -0,0 +1,38 @@
+import * as LogAbstract from "../logabstract/all";
+import * as OTC from "./otcomposite";
+import * as OTE from "./otengine";
+export declare class OTClientEngine extends OTE.OTEngine {
+    clientID: string;
+    resourceID: string;
+    isNeedAck: boolean;
+    isNeedResend: boolean;
+    bReadOnly: boolean;
+    clientSequenceNo: number;
+    stateServer: OTC.OTCompositeResource;
+    stateLocal: OTC.OTCompositeResource;
+    valCache: any;
+    prefailCache: any;
+    actionAllClient: OTC.OTCompositeResource;
+    actionAllPendingClient: OTC.OTCompositeResource;
+    actionSentClient: OTC.OTCompositeResource;
+    actionSentClientOriginal: OTC.OTCompositeResource;
+    actionServerInterposedSentClient: OTC.OTCompositeResource;
+    constructor(ilog: LogAbstract.ILog, rid: string, cid: string);
+    initialize(): void;
+    serverClock(): number;
+    rid(): string;
+    cid(): string;
+    toPartialValue(resourceName: string): any;
+    toValue(): any;
+    toPrefailValue(): any;
+    clearPrefail(): void;
+    setReadOnly(b: boolean): void;
+    startLocalEdit(): OTC.OTCompositeResource;
+    isPending(): boolean;
+    getPending(): OTC.OTCompositeResource;
+    resetPending(): void;
+    failbackToInitialState(): void;
+    failbackToServerState(): void;
+    addRemote(orig: OTC.OTCompositeResource): void;
+    addLocalEdit(orig: OTC.OTCompositeResource): void;
+}

package/dist/ot-js/otcomposite.d.ts

@@ -0,0 +1,37 @@
+import * as OT from "./ottypes";
+import * as OTA from "./otarray";
+import * as OTM from "./otmap";
+import * as OTC from "./otcounter";
+export declare const clockInitialValue: number;
+export declare const clockTerminateValue: number;
+export declare const clockRandomizeValue: number;
+export declare const clockFailureValue: number;
+export declare const clockInitializeValue: number;
+export declare const clockUndoValue: number;
+export declare const clockSeenValue: number;
+export declare class OTCompositeResource extends OT.OTResourceBase {
+    resourceID: string;
+    clientID: string;
+    clock: number;
+    clientSequenceNo: number;
+    static typeRegistry: any;
+    constructor(rid: string, cid: string);
+    static registerType(underlyingType: string, factory: (resourceName: string) => OT.OTResourceBase): void;
+    findResource(rname: string, utype?: string, bConstruct?: boolean): OT.IOTResource;
+    map(rid: string): OTM.OTMapResource;
+    array(rid: string): OTA.OTArrayResource;
+    counter(rid: string): OTC.OTCounterResource;
+    garbageCollect(map: any): boolean;
+    isEmpty(): boolean;
+    copy(): OTCompositeResource;
+    effectivelyEqual(rhs: OTCompositeResource): boolean;
+    transform(rhs: OTCompositeResource, bPriorIsService: boolean): void;
+    compose(rhs: OTCompositeResource): void;
+    apply(runningValue: any): any;
+    toPartialValue(resourceName: string): any;
+    toValue(): any;
+    minimize(): void;
+    static constructResource(rname: string, utype: string): OT.IOTResource;
+    static constructFromObject(o: any): OTCompositeResource;
+    toJSON(): any;
+}

package/dist/ot-js/otcounter.d.ts

@@ -0,0 +1,17 @@
+import * as OT from "./ottypes";
+export declare const OpCounterAdd = 1;
+export declare const OpCounterDel = 2;
+export declare type CounterEdit = [number, string, any];
+export declare class OTCounterResource extends OT.OTResourceBase {
+    constructor(rid: string);
+    static factory(rid: string): OTCounterResource;
+    copy(): OTCounterResource;
+    effectivelyEqual(rhs: OTCounterResource): boolean;
+    transform(prior: OTCounterResource, bPriorIsService: boolean): void;
+    compose(rhs: OTCounterResource): void;
+    apply(startValue: any): any;
+    minimize(): any;
+    loadObject(o: any): any;
+    toObject(): any;
+    fromObject(o: any): void;
+}

package/dist/ot-js/otengine.d.ts

@@ -0,0 +1,22 @@
+import * as LogAbstract from "../logabstract/all";
+import * as OTC from "./otcomposite";
+export interface IOTEngine {
+    cid(): string;
+    rid(): string;
+    toPartialValue(resourceName: string): any;
+    startLocalEdit(): OTC.OTCompositeResource;
+    addLocalEdit(e: OTC.OTCompositeResource): void;
+}
+export declare class OTEngine implements IOTEngine {
+    ilog: LogAbstract.ILog;
+    onList: any;
+    constructor(ilog: LogAbstract.ILog);
+    on(eventName: string, cb: any): void;
+    off(eventName: string, cb: any): void;
+    emit(eventName: string): void;
+    cid(): string;
+    rid(): string;
+    toPartialValue(resourceName: string): any;
+    startLocalEdit(): OTC.OTCompositeResource;
+    addLocalEdit(e: OTC.OTCompositeResource): void;
+}

package/dist/ot-js/otmap.d.ts

@@ -0,0 +1,19 @@
+import * as OT from './ottypes';
+export declare const OpMapSet = 1;
+export declare const OpMapDel = 2;
+export declare type MapEdit = [number, string, any];
+export declare class OTMapResource extends OT.OTResourceBase {
+    constructor(rid: string);
+    static factory(rid: string): OTMapResource;
+    set(p: string, a: any): OTMapResource;
+    del(p: string): OTMapResource;
+    copy(): OTMapResource;
+    effectivelyEqual(rhs: OTMapResource): boolean;
+    transform(prior: OTMapResource, bPriorIsService: boolean): void;
+    compose(rhs: OTMapResource): void;
+    apply(startValue: any): any;
+    minimize(): any;
+    loadObject(o: any): any;
+    toObject(): any;
+    fromObject(o: any): void;
+}

package/dist/ot-js/otserverengine.d.ts

@@ -0,0 +1,38 @@
+import * as LogAbstract from '../logabstract/all';
+import * as OTC from "./otcomposite";
+import * as OTE from "./otengine";
+export declare const ClientIDForServer: string;
+export declare class OTServerEngine extends OTE.OTEngine {
+    stateServer: OTC.OTCompositeResource;
+    logServer: OTC.OTCompositeResource[];
+    valCache: any;
+    fullCache: any;
+    highSequence: any;
+    clientSequenceNo: number;
+    constructor(ilog: LogAbstract.ILog, rid: string);
+    serverClock(): number;
+    rid(): string;
+    cid(): string;
+    startLocalEdit(): OTC.OTCompositeResource;
+    resetCaches(): void;
+    toPartialValue(resourceName: string): any;
+    toValue(): any;
+    getProp(s: string): any;
+    getName(): string;
+    getType(): string;
+    getDescription(): string;
+    getCreatedBy(): string;
+    getCreateTime(): string;
+    getCreatedByName(): string;
+    hasSeenEvent(orig: OTC.OTCompositeResource): boolean;
+    isNextEvent(orig: OTC.OTCompositeResource): boolean;
+    rememberSeenEvent(orig: OTC.OTCompositeResource): void;
+    forgetEvents(orig: OTC.OTCompositeResource): void;
+    clientHighSequence(cid: string): number;
+    garbageCollect(): void;
+    addServer(orig: OTC.OTCompositeResource): number;
+    addLocalEdit(orig: OTC.OTCompositeResource): void;
+    toJSON(): any;
+    validateLog(): void;
+    loadFromObject(o: any): void;
+}

package/dist/ot-js/otsession.d.ts

@@ -0,0 +1,111 @@
+export declare const ESuccess: number;
+export declare const EFail: number;
+export declare const EFull: number;
+export declare const ERetry: number;
+export declare const ENoSession: number;
+export declare const EClockSeen: number;
+export declare const EClockFailure: number;
+export declare const EClockReset: number;
+export declare const ENoUser: number;
+export declare const EBadRequest: number;
+export declare const ELoadFailed: number;
+export declare const ENoPerm: number;
+export declare const ENoAccess: number;
+export declare const EMaintenance: number;
+export declare const EClockAnomaly: number;
+export declare const FilterMyMaps: number;
+export declare const FilterSharedWithMe: number;
+export declare const FilterMyPublic: number;
+export declare const FilterRecent: number;
+export declare const FilterTrash: number;
+export declare const FilterPublic: number;
+export declare const FilterOfficial: number;
+export declare const FilterCount: number;
+export declare type Filter = number;
+export declare const PermNone: number;
+export declare const PermRead: number;
+export declare const PermWrite: number;
+export declare const PermOwner: number;
+export declare const PermAdmin: number;
+export declare const PermEdit: number;
+export declare const PermAll: number;
+export declare type Permission = number;
+export declare const ServerStateRunning: number;
+export declare const ServerStateMaintenance: number;
+export declare type ServerState = number;
+export interface AccessSessionMap {
+    [key: string]: string;
+}
+export interface AccessMap {
+    [key: string]: Access;
+}
+export interface Access {
+    userIDs: string[];
+    perm: Permission;
+}
+export interface Revision {
+    id: string;
+    modifyTime: any;
+    label?: string;
+}
+export declare type RevisionList = Revision[];
+export interface SessionUser {
+    id: string;
+    name: string;
+}
+export interface ActiveUser {
+    id: string;
+    name: string;
+    active: number;
+}
+export interface SessionUserIndex {
+    [key: string]: SessionUser;
+}
+export interface SessionUserList {
+    [key: string]: number;
+}
+export interface SessionProps {
+    id: string;
+    name: string;
+    type: string;
+    description: string;
+    labels: string[];
+    createdBy: string;
+    lastActive: any;
+    createTime: any;
+    modifyTime: any;
+    clientCount: number;
+    maxClients: number;
+    requestCount: number;
+    deleted: boolean;
+    published?: string;
+    official: boolean;
+    loadFailed: boolean;
+    accessMap: AccessMap;
+    revisions: RevisionList;
+    xprops?: {
+        [prop: string]: string;
+    };
+}
+export declare type LabelUpdate = {
+    [name: string]: boolean | null;
+};
+export interface SessionUpdateProps {
+    id: string;
+    deleted?: boolean;
+    published?: boolean;
+    official?: boolean;
+    name?: string;
+    description?: string;
+    labelupdate?: LabelUpdate;
+    access?: Access;
+    accessUpdate?: AccessMap;
+    restore?: string;
+    revision?: Revision;
+}
+export interface SessionsIndex {
+    [key: string]: SessionProps;
+}
+export declare function accessFindUser(a: Access, uid: string): Permission;
+export declare function accessMapFindUser(accessMap: AccessMap, uid: string, aid?: string): Permission;
+export declare function SessionFilterFunction(p: SessionProps, uid: string, f: number): boolean;

package/dist/ot-js/ottypes.d.ts

@@ -0,0 +1,29 @@
+export interface IOTResource {
+    resourceName: string;
+    underlyingType: string;
+    edits: any[];
+    length: number;
+    empty(): void;
+    isEmpty(): boolean;
+    copy(): IOTResource;
+    effectivelyEqual(rhs: IOTResource): boolean;
+    transform(rhs: IOTResource, bPriorIsService: boolean): void;
+    compose(rhs: IOTResource): void;
+    apply(startValue: any): any;
+    minimize(): void;
+}
+export declare class OTResourceBase implements IOTResource {
+    resourceName: string;
+    underlyingType: string;
+    edits: any[];
+    constructor(rname: string, utype: string);
+    get length(): number;
+    empty(): void;
+    isEmpty(): boolean;
+    copy(): OTResourceBase;
+    effectivelyEqual(rhs: OTResourceBase): boolean;
+    transform(rhs: OTResourceBase, bPriorIsService: boolean): void;
+    compose(rhs: OTResourceBase): void;
+    apply(startValue: any): any;
+    minimize(): void;
+}

package/dist/poly/all.d.ts

@@ -0,0 +1,15 @@
+export * from './poly';
+export * from './union';
+export * from './quad';
+export * from './polylabel';
+export * from './polysimplify';
+export * from './polypack';
+export * from './polybin';
+export * from './boundbox';
+export * from './blend';
+export * from './cartesian';
+export * from './minbound';
+export * from './polyround';
+export * from './topo';
+export * from './selfintersect';
+export * from './shamos';

package/dist/poly/blend.d.ts

@@ -0,0 +1 @@
+export declare function blend(polys: any[]): any;

package/dist/poly/boundbox.d.ts

@@ -0,0 +1,16 @@
+export interface BoundBox {
+    left?: number;
+    top?: number;
+    right?: number;
+    bottom?: number;
+}
+export declare function boundboxWidth(bb: BoundBox): number;
+export declare function boundboxHeight(bb: BoundBox): number;
+export declare function boundboxCX(bb: BoundBox): number;
+export declare function boundboxCY(bb: BoundBox): number;
+export declare function clipLon(lon: number): number;
+export declare function boundboxExtend(bbox: BoundBox, x: number, y: number): void;
+export declare function boundbox(poly: any, bbox?: BoundBox): BoundBox;
+export declare function boundboxPoly(bb: BoundBox): any;
+export declare function boundboxArea(poly: any): number;
+export declare function boundboxIntersects(bb1: BoundBox, bb2: BoundBox): boolean;

package/dist/poly/cartesian.d.ts

@@ -0,0 +1,5 @@
+import * as GeoJSON from 'geojson';
+export declare function polyParts(poly: any): GeoJSON.FeatureCollection;
+export declare function polyAreaFlat(poly: any): number;
+export declare function polyPerimeterFlat(poly: any): number;
+export declare function polyDiameterFlat(poly: any): number;

package/dist/poly/graham-scan.d.ts

@@ -0,0 +1,8 @@
+import { PolyOptions } from './poly';
+export declare function makeConvexHullGrahamScan(poly: any, options?: PolyOptions): any;
+/**
+ * Graham's Scan Convex Hull Algorithm
+ * @desc An implementation of the Graham's Scan Convex Hull algorithm in JavaScript.
+ * @author Brian Barnett, brian@3kb.co.uk, http://brianbar.net/ || http://3kb.co.uk/
+ * @version 1.0.5
+ */

package/dist/poly/hash.d.ts

@@ -0,0 +1 @@
+export declare function qhash(o: any, keys?: any): any;

package/dist/poly/matrix.d.ts

@@ -0,0 +1,24 @@
+export declare type Matrix = number[][];
+export declare type Vector = number[];
+export declare type Range = number[];
+export declare type Index = number[][];
+export declare type applyCB = (v: Vector) => number;
+export declare const enum Dim {
+    Rows = 0,
+    Columns = 1
+}
+export declare function matrix(a: Matrix): Matrix;
+export declare function multiply(a: Matrix, b: Matrix): Matrix;
+export declare function transpose(a: Matrix): Matrix;
+export declare function apply(a: Matrix, over: Dim, cb: applyCB): Vector;
+export declare function min(v: Vector): number;
+export declare function max(v: Vector): number;
+export declare function concat(a: Matrix, b: Matrix, by: Dim): Matrix;
+export declare function row(a: Matrix, i: number): Vector;
+export declare function column(a: Matrix, j: number): Vector;
+export declare function subtract(a: Vector, b: Vector): Vector;
+export declare function dotMultiply(a: Vector, b: Vector): Vector;
+export declare function index(a: Range, b: Range): Index;
+export declare function range(start: number, end: number, includeEnd?: boolean): Vector;
+export declare function subset(a: Matrix, select: Index): Matrix;
+export declare function dotProduct(a: Vector, b: Vector): number;

package/dist/poly/minbound.d.ts

@@ -0,0 +1 @@
+export declare function minimumBoundingRectangle(poly: any): any;

package/dist/poly/poly.d.ts

@@ -0,0 +1,52 @@
+import * as PP from './polypack';
+export interface TickOptions {
+    maxLeafCount?: number;
+    maxDepth?: number;
+    tickStep?: number;
+}
+export declare const DefaultTickOptions: {
+    maxLeafCount: number;
+    maxDepth: number;
+    tickStep: number;
+};
+export declare const EARTH_RADIUS = 6371000;
+export interface PolyOptions {
+    noLatitudeCorrection?: boolean;
+}
+export declare const DefaultOptions: PolyOptions;
+export declare function polySimpleArea(b: Float64Array, iOffset: number, n: number): number;
+export declare function polyNormalize(poly: any): PP.PolyPack;
+export declare function polyNull(poly: any): boolean;
+export declare function polyArea(poly: any): number;
+export declare function polyDiameter(poly: any, options?: PolyOptions): number;
+export declare function polyPerimeter(poly: any, options?: PolyOptions): number;
+export declare class Circle {
+    x: number;
+    y: number;
+    r: number;
+    constructor(x: number, y: number, r: number);
+}
+export declare function polyToCircle(poly: any): Circle | null;
+export declare function polyToPolsbyPopperCircle(poly: any, options?: PolyOptions): Circle | null;
+export declare function polyFromCircle(c: Circle, nSegments?: number): any;
+export declare function polyToExteriorPoints(poly: any): any;
+export declare function polyConvexHull(poly: any, altAlgorithm?: any): any;
+export declare function makeConvexHullMonotoneChain2D(poly: any): any;
+export interface CompactnessDescription {
+    value: number;
+    reock: number;
+    polsby_popper: number;
+    convex_hull: number;
+    schwartzberg: number;
+}
+export declare function polyCompactness(poly: any, options?: PolyOptions): CompactnessDescription;
+export interface PolyDescription {
+    npoly: number;
+    nhole: number;
+    npoint: number;
+}
+export declare function polyDescribe(poly: any): PolyDescription;
+export declare function npoints(poly: any): number;
+export declare function polyTransform(poly: any, transformFn: any): any;
+export declare function featureRewind(poly: any): any;
+export declare function polyRewindRings(pp: any, bLog?: boolean): any;

package/dist/poly/polybin.d.ts

@@ -0,0 +1,5 @@
+import * as Util from '../util/all';
+export declare function packCollection(coder: Util.Coder, col: any): ArrayBuffer;
+export declare function unpackCollection(coder: Util.Coder, ab: ArrayBuffer): any;
+export declare function topoToBuffer(coder: Util.Coder, topo: any): ArrayBuffer;
+export declare function topoFromBuffer(coder: Util.Coder, ab: ArrayBuffer): any;

package/dist/poly/polylabel.d.ts

@@ -0,0 +1,7 @@
+interface PolyLabelResult {
+    x: number;
+    y: number;
+    d: number;
+}
+export declare function polyLabel(poly: any, precision?: number, debug?: boolean): PolyLabelResult;
+export {};

package/dist/poly/polypack.d.ts

@@ -0,0 +1,30 @@
+export interface PolyPack {
+    offset: number;
+    length: number;
+    buffer: any;
+}
+export declare function polyPackSize(coords: any): number;
+declare type EachRingCB = (buffer: Float64Array, iPoly: number, iRing: number, iOffset: number, nPoints: number) => void;
+declare type EachPointCB = (buffer: Float64Array, iPoly: number, iRing: number, iOffset: number) => void;
+export declare function polyPackEachRing(pack: PolyPack, cb: EachRingCB): void;
+export declare function polyPackEachPoint(pack: PolyPack, cb: EachPointCB): void;
+export declare function polyPackCountPoints(pack: PolyPack): number;
+export declare function polyPacked(f: any): boolean;
+export declare function normalizeArcs(arcs: any): any;
+export declare function countArcPolygons(arcs: any): number;
+export declare function countArcRings(arcs: any, iPoly?: number): number;
+export declare function countOneArcPoints(topo: any, ring: any): number;
+export declare function countArcPoints(topo: any, arcs: any, iPoly?: number): number;
+export declare function polyPackTopoArcs(topo: any, arcs: any, iPoly?: number): PolyPack;
+export declare function polyPack(coords: any, prepack?: PolyPack): PolyPack;
+export declare function polyPackCopy(coords: any): PolyPack;
+export declare function polyUnpack(prepack: any): any;
+export declare function featurePackSize(f: any): number;
+export declare function featurePack(f: any, prepack?: PolyPack): any;
+export declare function featureUnpack(f: any): any;
+export declare type SavePack = WeakMap<any, any>;
+export declare function featureUnpackTemporarily(f: any, save?: SavePack): SavePack;
+export declare function featureRepack(f: any, save: SavePack): any;
+export declare function featurePackString(f: any): string;
+export declare function featureUnpackString(s: string): any;
+export {};

package/dist/poly/polyround.d.ts

@@ -0,0 +1 @@
+export declare function polyRound(o: any): any;

package/dist/poly/polysimplify.d.ts

@@ -0,0 +1 @@
+export declare function polySimplify(poly: any, tolerance?: number): void;

package/dist/poly/quad.d.ts

@@ -0,0 +1,48 @@
+import * as FSM from '../fsm/all';
+import * as Poly from './poly';
+import * as BB from './boundbox';
+export interface WrappedPoly {
+    box: BB.BoundBox;
+    p: any;
+}
+export interface WorkDone {
+    nUnion: number;
+    nDifference: number;
+    ms: number;
+}
+export declare function unionPolys(polys: any[]): any;
+export interface QuadOptions {
+    maxLeafCount?: number;
+    maxDepth?: number;
+    tickStep?: number;
+}
+export declare const DefaultQuadOptions: QuadOptions;
+export interface TickCounter {
+    ticks: number;
+}
+declare class QuadLevel {
+    options: QuadOptions;
+    level: number;
+    children: QuadLevel[];
+    features: any[];
+    box: BB.BoundBox;
+    asyncUnion: any;
+    constructor(options: QuadOptions, level: number, box: BB.BoundBox, features: WrappedPoly[]);
+    private featureInBox;
+    union(): any;
+    get isempty(): boolean;
+    tickUnion(tickCounter: TickCounter): void;
+}
+export declare class FsmQuadTree extends FSM.Fsm {
+    quad: QuadLevel;
+    asyncUnion: any;
+    isempty: boolean;
+    options: Poly.TickOptions;
+    work: WorkDone;
+    constructor(env: FSM.FsmEnvironment, options?: Poly.TickOptions, col?: any);
+    initialize(col: any): void;
+    cancel(): any;
+    get result(): any;
+    tick(): void;
+}
+export {};

package/dist/poly/selfintersect.d.ts

@@ -0,0 +1 @@
+export declare function selfIntersect(poly: any): boolean;