@performant-software/geospatial 3.1.25-beta.1 → 3.1.25-beta.2

package/dist/index.cjs351.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("./index.cjs302.js"),m=require("./index.cjs217.js");var g=class s{mapId;tile;tileUrl;tileKey;fetchableTileKey;options;constructor(e,i,t,l){this.tile=e,this.mapId=i,this.tileUrl=t,this.options=l,this.tileKey=r.tileKey(e),this.fetchableTileKey=r.fetchableTileKey(this)}static fromWarpedMap(e,i,t){const l=i.image.getTileImageRequest(e.tileZoomLevel,e.column,e.row);return new s(e,i.mapId,i.image.getImageUrl(l,{preferredFormats:["webp","jpg"]}),m.mergePartialOptions(t,{imageRequest:l}))}static fromSprite(e,i,t,l){const a=t.tileSize[0],c=t.tileSize[1],o={column:0,row:0,tileZoomLevel:{scaleFactor:e.scaleFactor,width:a,height:c,originalWidth:a*e.scaleFactor,originalHeight:c*e.scaleFactor,columns:1,rows:1},imageSize:i},n=t.image.getTileImageRequest(o.tileZoomLevel,o.column,o.row);return new s(o,t.mapId,e.imageId,m.mergePartialOptions(l,{imageRequest:n}))}};exports.FetchableTile=g;
+//# sourceMappingURL=index.cjs351.js.map

package/dist/index.cjs351.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs351.js","sources":["../../../node_modules/@allmaps/render/dist/tilecache/FetchableTile.js"],"sourcesContent":["import { fetchableTileKey, tileKey } from \"../shared/tiles.js\";\nimport { mergePartialOptions } from \"@allmaps/stdlib\";\n//#region src/tilecache/FetchableTile.ts\n/**\n* Class for tiles that can be fetched.\n*/\nvar FetchableTile = class FetchableTile {\n\tmapId;\n\ttile;\n\ttileUrl;\n\ttileKey;\n\tfetchableTileKey;\n\toptions;\n\t/**\n\t* Creates an instance of FetchableTile.\n\t*\n\t* @constructor\n\t* @param tile - the tile\n\t* @param mapId - Map ID\n\t* @param tileUrl - Tile URL\n\t* @param imageRequest - Image Request\n\t* @param options - FetchableTileOptions\n\t*/\n\tconstructor(tile, mapId, tileUrl, options) {\n\t\tthis.tile = tile;\n\t\tthis.mapId = mapId;\n\t\tthis.tileUrl = tileUrl;\n\t\tthis.options = options;\n\t\tthis.tileKey = tileKey(tile);\n\t\tthis.fetchableTileKey = fetchableTileKey(this);\n\t}\n\t/**\n\t* Creates an instance of FetchableTile from a WarpedMap.\n\t*\n\t* @constructor\n\t* @param tile - the tile\n\t* @param warpedMap - A WarpedMap with fetched image\n\t*/\n\tstatic fromWarpedMap(tile, warpedMap, options) {\n\t\tconst tileImageRequest = warpedMap.image.getTileImageRequest(tile.tileZoomLevel, tile.column, tile.row);\n\t\treturn new FetchableTile(tile, warpedMap.mapId, warpedMap.image.getImageUrl(tileImageRequest, { preferredFormats: [\"webp\", \"jpg\"] }), mergePartialOptions(options, { imageRequest: tileImageRequest }));\n\t}\n\t/**\n\t* Creates an instance of FetchableTile from a sprite.\n\t*\n\t* @constructor\n\t* @param sprite - Sprite\n\t* @param imageSize - imageSize\n\t* @param warpedMap - A WarpedMap with fetched image\n\t*/\n\tstatic fromSprite(sprite, imageSize, warpedMap, options) {\n\t\tconst width = warpedMap.tileSize[0];\n\t\tconst height = warpedMap.tileSize[1];\n\t\tconst tile = {\n\t\t\tcolumn: 0,\n\t\t\trow: 0,\n\t\t\ttileZoomLevel: {\n\t\t\t\tscaleFactor: sprite.scaleFactor,\n\t\t\t\twidth,\n\t\t\t\theight,\n\t\t\t\toriginalWidth: width * sprite.scaleFactor,\n\t\t\t\toriginalHeight: height * sprite.scaleFactor,\n\t\t\t\tcolumns: 1,\n\t\t\t\trows: 1\n\t\t\t},\n\t\t\timageSize\n\t\t};\n\t\tconst tileImageRequest = warpedMap.image.getTileImageRequest(tile.tileZoomLevel, tile.column, tile.row);\n\t\treturn new FetchableTile(tile, warpedMap.mapId, sprite.imageId, mergePartialOptions(options, { imageRequest: tileImageRequest }));\n\t}\n};\n//#endregion\nexport { FetchableTile };\n\n//# sourceMappingURL=FetchableTile.js.map"],"names":["FetchableTile","tile","mapId","tileUrl","options","tileKey","fetchableTileKey","warpedMap","tileImageRequest","mergePartialOptions","sprite","imageSize","width","height"],"mappings":"oJAMA,IAAIA,EAAgB,MAAMA,CAAc,CACvC,MACA,KACA,QACA,QACA,iBACA,QAWA,YAAYC,EAAMC,EAAOC,EAASC,EAAS,CAC1C,KAAK,KAAOH,EACZ,KAAK,MAAQC,EACb,KAAK,QAAUC,EACf,KAAK,QAAUC,EACf,KAAK,QAAUC,EAAAA,QAAQJ,CAAI,EAC3B,KAAK,iBAAmBK,EAAAA,iBAAiB,IAAI,CAC9C,CAQA,OAAO,cAAcL,EAAMM,EAAWH,EAAS,CAC9C,MAAMI,EAAmBD,EAAU,MAAM,oBAAoBN,EAAK,cAAeA,EAAK,OAAQA,EAAK,GAAG,EACtG,OAAO,IAAID,EAAcC,EAAMM,EAAU,MAAOA,EAAU,MAAM,YAAYC,EAAkB,CAAE,iBAAkB,CAAC,OAAQ,KAAK,CAAA,CAAG,EAAGC,EAAAA,oBAAoBL,EAAS,CAAE,aAAcI,CAAA,CAAkB,CAAC,CACvM,CASA,OAAO,WAAWE,EAAQC,EAAWJ,EAAWH,EAAS,CACxD,MAAMQ,EAAQL,EAAU,SAAS,CAAC,EAC5BM,EAASN,EAAU,SAAS,CAAC,EAC7BN,EAAO,CACZ,OAAQ,EACR,IAAK,EACL,cAAe,CACd,YAAaS,EAAO,YACpB,MAAAE,EACA,OAAAC,EACA,cAAeD,EAAQF,EAAO,YAC9B,eAAgBG,EAASH,EAAO,YAChC,QAAS,EACT,KAAM,CAAA,EAEP,UAAAC,CAAA,EAEKH,EAAmBD,EAAU,MAAM,oBAAoBN,EAAK,cAAeA,EAAK,OAAQA,EAAK,GAAG,EACtG,OAAO,IAAID,EAAcC,EAAMM,EAAU,MAAOG,EAAO,QAASD,EAAAA,oBAAoBL,EAAS,CAAE,aAAcI,CAAA,CAAkB,CAAC,CACjI,CACD","x_google_ignoreList":[0]}

package/dist/index.cjs352.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const l=require("./index.cjs302.js"),i=require("./index.cjs215.js");var s=class extends EventTarget{fetchableTile;fetchFn;abortController;data;cachedTilesFromSprites;constructor(e,t){super(),this.fetchableTile=e,this.fetchFn=t,this.abortController=new AbortController}isCachedTile(){return this.data!==void 0}isTileFromSprites(){return this.fetchableTile.options?.spritesInfo!=null}getCachedTilesFromSprites(){return this.cachedTilesFromSprites}abort(){this.abortController.signal.aborted||this.abortController.abort()}shouldPrune(e,t){const r=this.fetchableTile.tile;if(this.isTileFromSprites())return!1;if(!e)return!0;if(e.overviewTileZoomLevelForViewport&&r.tileZoomLevel.scaleFactor==e.overviewTileZoomLevelForViewport.scaleFactor)return!1;if(e.resourceViewportRingBboxForViewport===void 0||e.tileZoomLevelForViewport===void 0)return!0;const o=Math.log2(r.tileZoomLevel.scaleFactor)-Math.log2(e.tileZoomLevelForViewport.scaleFactor);return o>t.maxHigherLog2ScaleFactorDiff||-o>t.maxLowerLog2ScaleFactorDiff||!i.doBboxesIntersect(i.bufferBboxByRatio(l.computeBboxTile(r),Math.pow(2,o)),e.resourceViewportRingBboxForViewport)}};exports.CacheableTile=s;
+//# sourceMappingURL=index.cjs352.js.map

package/dist/index.cjs352.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs352.js","sources":["../../../node_modules/@allmaps/render/dist/tilecache/CacheableTile.js"],"sourcesContent":["import { computeBboxTile } from \"../shared/tiles.js\";\nimport { bufferBboxByRatio, doBboxesIntersect } from \"@allmaps/stdlib\";\n//#region src/tilecache/CacheableTile.ts\n/**\n* Class for tiles that can be cached.\n*/\nvar CacheableTile = class extends EventTarget {\n\tfetchableTile;\n\tfetchFn;\n\tabortController;\n\tdata;\n\tcachedTilesFromSprites;\n\t/**\n\t* Creates an instance of CacheableTile.\n\t*\n\t* Note that there can be multiple FetchableTiles with the same tileUrl, but only one CachedTile per tileUrl.\n\t*\n\t* @constructor\n\t* @param fetchableTile - The FetchableTile which created this CachedTile.\n\t* @param fetchFn - Optional fetch function to use\n\t*/\n\tconstructor(fetchableTile, fetchFn) {\n\t\tsuper();\n\t\tthis.fetchableTile = fetchableTile;\n\t\tthis.fetchFn = fetchFn;\n\t\tthis.abortController = new AbortController();\n\t}\n\t/**\n\t* Whether a tile has fetched its data\n\t*\n\t* @returns\n\t*/\n\tisCachedTile() {\n\t\treturn this.data !== void 0;\n\t}\n\tisTileFromSprites() {\n\t\treturn this.fetchableTile.options?.spritesInfo != void 0;\n\t}\n\tgetCachedTilesFromSprites() {\n\t\treturn this.cachedTilesFromSprites;\n\t}\n\t/**\n\t* Abort the fetch\n\t*/\n\tabort() {\n\t\tif (!this.abortController.signal.aborted) this.abortController.abort();\n\t}\n\tshouldPrune(mapPruneInfo, mapPruneConstants) {\n\t\tconst tile = this.fetchableTile.tile;\n\t\tif (this.isTileFromSprites()) return false;\n\t\tif (!mapPruneInfo) return true;\n\t\tif (mapPruneInfo.overviewTileZoomLevelForViewport && tile.tileZoomLevel.scaleFactor == mapPruneInfo.overviewTileZoomLevelForViewport.scaleFactor) return false;\n\t\tif (mapPruneInfo.resourceViewportRingBboxForViewport === void 0 || mapPruneInfo.tileZoomLevelForViewport === void 0) return true;\n\t\tconst log2ScaleFactorDiff = Math.log2(tile.tileZoomLevel.scaleFactor) - Math.log2(mapPruneInfo.tileZoomLevelForViewport.scaleFactor);\n\t\tif (log2ScaleFactorDiff > mapPruneConstants.maxHigherLog2ScaleFactorDiff) return true;\n\t\tif (-log2ScaleFactorDiff > mapPruneConstants.maxLowerLog2ScaleFactorDiff) return true;\n\t\tif (!doBboxesIntersect(bufferBboxByRatio(computeBboxTile(tile), Math.pow(2, log2ScaleFactorDiff)), mapPruneInfo.resourceViewportRingBboxForViewport)) return true;\n\t\treturn false;\n\t}\n};\n//#endregion\nexport { CacheableTile };\n\n//# sourceMappingURL=CacheableTile.js.map"],"names":["CacheableTile","fetchableTile","fetchFn","mapPruneInfo","mapPruneConstants","tile","log2ScaleFactorDiff","doBboxesIntersect","bufferBboxByRatio","computeBboxTile"],"mappings":"oJAMA,IAAIA,EAAgB,cAAc,WAAY,CAC7C,cACA,QACA,gBACA,KACA,uBAUA,YAAYC,EAAeC,EAAS,CACnC,MAAA,EACA,KAAK,cAAgBD,EACrB,KAAK,QAAUC,EACf,KAAK,gBAAkB,IAAI,eAC5B,CAMA,cAAe,CACd,OAAO,KAAK,OAAS,MACtB,CACA,mBAAoB,CACnB,OAAO,KAAK,cAAc,SAAS,aAAe,IACnD,CACA,2BAA4B,CAC3B,OAAO,KAAK,sBACb,CAIA,OAAQ,CACF,KAAK,gBAAgB,OAAO,SAAS,KAAK,gBAAgB,MAAA,CAChE,CACA,YAAYC,EAAcC,EAAmB,CAC5C,MAAMC,EAAO,KAAK,cAAc,KAChC,GAAI,KAAK,kBAAA,EAAqB,MAAO,GACrC,GAAI,CAACF,EAAc,MAAO,GAC1B,GAAIA,EAAa,kCAAoCE,EAAK,cAAc,aAAeF,EAAa,iCAAiC,YAAa,MAAO,GACzJ,GAAIA,EAAa,sCAAwC,QAAUA,EAAa,2BAA6B,OAAQ,MAAO,GAC5H,MAAMG,EAAsB,KAAK,KAAKD,EAAK,cAAc,WAAW,EAAI,KAAK,KAAKF,EAAa,yBAAyB,WAAW,EAGnI,OAFIG,EAAsBF,EAAkB,8BACxC,CAACE,EAAsBF,EAAkB,6BACzC,CAACG,EAAAA,kBAAkBC,EAAAA,kBAAkBC,EAAAA,gBAAgBJ,CAAI,EAAG,KAAK,IAAI,EAAGC,CAAmB,CAAC,EAAGH,EAAa,mCAAmC,CAEpJ,CACD","x_google_ignoreList":[0]}

package/dist/index.cjs353.js

@@ -0,0 +1,2 @@
+"use strict";const I=require("./index.cjs468.js");class y{constructor(t=9){this._maxEntries=Math.max(4,t),this._minEntries=Math.max(2,Math.ceil(this._maxEntries*.4)),this.clear()}all(){return this._all(this.data,[])}search(t){let i=this.data;const n=[];if(!X(t,i))return n;const h=this.toBBox,s=[];for(;i;){for(let r=0;r<i.children.length;r++){const l=i.children[r],a=i.leaf?h(l):l;X(t,a)&&(i.leaf?n.push(l):M(t,a)?this._all(l,n):s.push(l))}i=s.pop()}return n}collides(t){let i=this.data;if(!X(t,i))return!1;const n=[];for(;i;){for(let h=0;h<i.children.length;h++){const s=i.children[h],r=i.leaf?this.toBBox(s):s;if(X(t,r)){if(i.leaf||M(t,r))return!0;n.push(s)}}i=n.pop()}return!1}load(t){if(!(t&&t.length))return this;if(t.length<this._minEntries){for(let n=0;n<t.length;n++)this.insert(t[n]);return this}let i=this._build(t.slice(),0,t.length-1,0);if(!this.data.children.length)this.data=i;else if(this.data.height===i.height)this._splitRoot(this.data,i);else{if(this.data.height<i.height){const n=this.data;this.data=i,i=n}this._insert(i,this.data.height-i.height-1,!0)}return this}insert(t){return t&&this._insert(t,this.data.height-1),this}clear(){return this.data=x([]),this}remove(t,i){if(!t)return this;let n=this.data;const h=this.toBBox(t),s=[],r=[];let l,a,c;for(;n||s.length;){if(n||(n=s.pop(),a=s[s.length-1],l=r.pop(),c=!0),n.leaf){const o=S(t,n.children,i);if(o!==-1)return n.children.splice(o,1),s.push(n),this._condense(s),this}!c&&!n.leaf&&M(n,h)?(s.push(n),r.push(l),l=0,a=n,n=n.children[0]):a?(l++,n=a.children[l],c=!1):n=null}return this}toBBox(t){return t}compareMinX(t,i){return t.minX-i.minX}compareMinY(t,i){return t.minY-i.minY}toJSON(){return this.data}fromJSON(t){return this.data=t,this}_all(t,i){const n=[];for(;t;)t.leaf?i.push(...t.children):n.push(...t.children),t=n.pop();return i}_build(t,i,n,h){const s=n-i+1;let r=this._maxEntries,l;if(s<=r)return l=x(t.slice(i,n+1)),f(l,this.toBBox),l;h||(h=Math.ceil(Math.log(s)/Math.log(r)),r=Math.ceil(s/Math.pow(r,h-1))),l=x([]),l.leaf=!1,l.height=h;const a=Math.ceil(s/r),c=a*Math.ceil(Math.sqrt(r));g(t,i,n,c,this.compareMinX);for(let o=i;o<=n;o+=c){const m=Math.min(o+c-1,n);g(t,o,m,a,this.compareMinY);for(let d=o;d<=m;d+=a){const _=Math.min(d+a-1,m);l.children.push(this._build(t,d,_,h-1))}}return f(l,this.toBBox),l}_chooseSubtree(t,i,n,h){for(;h.push(i),!(i.leaf||h.length-1===n);){let s=1/0,r=1/0,l;for(let a=0;a<i.children.length;a++){const c=i.children[a],o=Y(c),m=A(t,c)-o;m<r?(r=m,s=o<s?o:s,l=c):m===r&&o<s&&(s=o,l=c)}i=l||i.children[0]}return i}_insert(t,i,n){const h=n?t:this.toBBox(t),s=[],r=this._chooseSubtree(h,this.data,i,s);for(r.children.push(t),p(r,h);i>=0&&s[i].children.length>this._maxEntries;)this._split(s,i),i--;this._adjustParentBBoxes(h,s,i)}_split(t,i){const n=t[i],h=n.children.length,s=this._minEntries;this._chooseSplitAxis(n,s,h);const r=this._chooseSplitIndex(n,s,h),l=x(n.children.splice(r,n.children.length-r));l.height=n.height,l.leaf=n.leaf,f(n,this.toBBox),f(l,this.toBBox),i?t[i-1].children.push(l):this._splitRoot(n,l)}_splitRoot(t,i){this.data=x([t,i]),this.data.height=t.height+1,this.data.leaf=!1,f(this.data,this.toBBox)}_chooseSplitIndex(t,i,n){let h,s=1/0,r=1/0;for(let l=i;l<=n-i;l++){const a=u(t,0,l,this.toBBox),c=u(t,l,n,this.toBBox),o=O(a,c),m=Y(a)+Y(c);o<s?(s=o,h=l,r=m<r?m:r):o===s&&m<r&&(r=m,h=l)}return h||n-i}_chooseSplitAxis(t,i,n){const h=t.leaf?this.compareMinX:w,s=t.leaf?this.compareMinY:E,r=this._allDistMargin(t,i,n,h),l=this._allDistMargin(t,i,n,s);r<l&&t.children.sort(h)}_allDistMargin(t,i,n,h){t.children.sort(h);const s=this.toBBox,r=u(t,0,i,s),l=u(t,n-i,n,s);let a=B(r)+B(l);for(let c=i;c<n-i;c++){const o=t.children[c];p(r,t.leaf?s(o):o),a+=B(r)}for(let c=n-i-1;c>=i;c--){const o=t.children[c];p(l,t.leaf?s(o):o),a+=B(l)}return a}_adjustParentBBoxes(t,i,n){for(let h=n;h>=0;h--)p(i[h],t)}_condense(t){for(let i=t.length-1,n;i>=0;i--)t[i].children.length===0?i>0?(n=t[i-1].children,n.splice(n.indexOf(t[i]),1)):this.clear():f(t[i],this.toBBox)}}function S(e,t,i){if(!i)return t.indexOf(e);for(let n=0;n<t.length;n++)if(i(e,t[n]))return n;return-1}function f(e,t){u(e,0,e.children.length,t,e)}function u(e,t,i,n,h){h||(h=x(null)),h.minX=1/0,h.minY=1/0,h.maxX=-1/0,h.maxY=-1/0;for(let s=t;s<i;s++){const r=e.children[s];p(h,e.leaf?n(r):r)}return h}function p(e,t){return e.minX=Math.min(e.minX,t.minX),e.minY=Math.min(e.minY,t.minY),e.maxX=Math.max(e.maxX,t.maxX),e.maxY=Math.max(e.maxY,t.maxY),e}function w(e,t){return e.minX-t.minX}function E(e,t){return e.minY-t.minY}function Y(e){return(e.maxX-e.minX)*(e.maxY-e.minY)}function B(e){return e.maxX-e.minX+(e.maxY-e.minY)}function A(e,t){return(Math.max(t.maxX,e.maxX)-Math.min(t.minX,e.minX))*(Math.max(t.maxY,e.maxY)-Math.min(t.minY,e.minY))}function O(e,t){const i=Math.max(e.minX,t.minX),n=Math.max(e.minY,t.minY),h=Math.min(e.maxX,t.maxX),s=Math.min(e.maxY,t.maxY);return Math.max(0,h-i)*Math.max(0,s-n)}function M(e,t){return e.minX<=t.minX&&e.minY<=t.minY&&t.maxX<=e.maxX&&t.maxY<=e.maxY}function X(e,t){return t.minX<=e.maxX&&t.minY<=e.maxY&&t.maxX>=e.minX&&t.maxY>=e.minY}function x(e){return{children:e,height:1,leaf:!0,minX:1/0,minY:1/0,maxX:-1/0,maxY:-1/0}}function g(e,t,i,n,h){const s=[t,i];for(;s.length;){if(i=s.pop(),t=s.pop(),i-t<=n)continue;const r=t+Math.ceil((i-t)/n/2)*n;I(e,r,t,i,h),s.push(t,r,r,i)}}module.exports=y;
+//# sourceMappingURL=index.cjs353.js.map

package/dist/index.cjs353.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs353.js","sources":["../../../node_modules/@allmaps/render/node_modules/rbush/index.js"],"sourcesContent":["import quickselect from 'quickselect';\n\nexport default class RBush {\n    constructor(maxEntries = 9) {\n        // max entries in a node is 9 by default; min node fill is 40% for best performance\n        this._maxEntries = Math.max(4, maxEntries);\n        this._minEntries = Math.max(2, Math.ceil(this._maxEntries * 0.4));\n        this.clear();\n    }\n\n    all() {\n        return this._all(this.data, []);\n    }\n\n    search(bbox) {\n        let node = this.data;\n        const result = [];\n\n        if (!intersects(bbox, node)) return result;\n\n        const toBBox = this.toBBox;\n        const nodesToSearch = [];\n\n        while (node) {\n            for (let i = 0; i < node.children.length; i++) {\n                const child = node.children[i];\n                const childBBox = node.leaf ? toBBox(child) : child;\n\n                if (intersects(bbox, childBBox)) {\n                    if (node.leaf) result.push(child);\n                    else if (contains(bbox, childBBox)) this._all(child, result);\n                    else nodesToSearch.push(child);\n                }\n            }\n            node = nodesToSearch.pop();\n        }\n\n        return result;\n    }\n\n    collides(bbox) {\n        let node = this.data;\n\n        if (!intersects(bbox, node)) return false;\n\n        const nodesToSearch = [];\n        while (node) {\n            for (let i = 0; i < node.children.length; i++) {\n                const child = node.children[i];\n                const childBBox = node.leaf ? this.toBBox(child) : child;\n\n                if (intersects(bbox, childBBox)) {\n                    if (node.leaf || contains(bbox, childBBox)) return true;\n                    nodesToSearch.push(child);\n                }\n            }\n            node = nodesToSearch.pop();\n        }\n\n        return false;\n    }\n\n    load(data) {\n        if (!(data && data.length)) return this;\n\n        if (data.length < this._minEntries) {\n            for (let i = 0; i < data.length; i++) {\n                this.insert(data[i]);\n            }\n            return this;\n        }\n\n        // recursively build the tree with the given data from scratch using OMT algorithm\n        let node = this._build(data.slice(), 0, data.length - 1, 0);\n\n        if (!this.data.children.length) {\n            // save as is if tree is empty\n            this.data = node;\n\n        } else if (this.data.height === node.height) {\n            // split root if trees have the same height\n            this._splitRoot(this.data, node);\n\n        } else {\n            if (this.data.height < node.height) {\n                // swap trees if inserted one is bigger\n                const tmpNode = this.data;\n                this.data = node;\n                node = tmpNode;\n            }\n\n            // insert the small tree into the large tree at appropriate level\n            this._insert(node, this.data.height - node.height - 1, true);\n        }\n\n        return this;\n    }\n\n    insert(item) {\n        if (item) this._insert(item, this.data.height - 1);\n        return this;\n    }\n\n    clear() {\n        this.data = createNode([]);\n        return this;\n    }\n\n    remove(item, equalsFn) {\n        if (!item) return this;\n\n        let node = this.data;\n        const bbox = this.toBBox(item);\n        const path = [];\n        const indexes = [];\n        let i, parent, goingUp;\n\n        // depth-first iterative tree traversal\n        while (node || path.length) {\n\n            if (!node) { // go up\n                node = path.pop();\n                parent = path[path.length - 1];\n                i = indexes.pop();\n                goingUp = true;\n            }\n\n            if (node.leaf) { // check current node\n                const index = findItem(item, node.children, equalsFn);\n\n                if (index !== -1) {\n                    // item found, remove the item and condense tree upwards\n                    node.children.splice(index, 1);\n                    path.push(node);\n                    this._condense(path);\n                    return this;\n                }\n            }\n\n            if (!goingUp && !node.leaf && contains(node, bbox)) { // go down\n                path.push(node);\n                indexes.push(i);\n                i = 0;\n                parent = node;\n                node = node.children[0];\n\n            } else if (parent) { // go right\n                i++;\n                node = parent.children[i];\n                goingUp = false;\n\n            } else node = null; // nothing found\n        }\n\n        return this;\n    }\n\n    toBBox(item) { return item; }\n\n    compareMinX(a, b) { return a.minX - b.minX; }\n    compareMinY(a, b) { return a.minY - b.minY; }\n\n    toJSON() { return this.data; }\n\n    fromJSON(data) {\n        this.data = data;\n        return this;\n    }\n\n    _all(node, result) {\n        const nodesToSearch = [];\n        while (node) {\n            if (node.leaf) result.push(...node.children);\n            else nodesToSearch.push(...node.children);\n\n            node = nodesToSearch.pop();\n        }\n        return result;\n    }\n\n    _build(items, left, right, height) {\n\n        const N = right - left + 1;\n        let M = this._maxEntries;\n        let node;\n\n        if (N <= M) {\n            // reached leaf level; return leaf\n            node = createNode(items.slice(left, right + 1));\n            calcBBox(node, this.toBBox);\n            return node;\n        }\n\n        if (!height) {\n            // target height of the bulk-loaded tree\n            height = Math.ceil(Math.log(N) / Math.log(M));\n\n            // target number of root entries to maximize storage utilization\n            M = Math.ceil(N / Math.pow(M, height - 1));\n        }\n\n        node = createNode([]);\n        node.leaf = false;\n        node.height = height;\n\n        // split the items into M mostly square tiles\n\n        const N2 = Math.ceil(N / M);\n        const N1 = N2 * Math.ceil(Math.sqrt(M));\n\n        multiSelect(items, left, right, N1, this.compareMinX);\n\n        for (let i = left; i <= right; i += N1) {\n\n            const right2 = Math.min(i + N1 - 1, right);\n\n            multiSelect(items, i, right2, N2, this.compareMinY);\n\n            for (let j = i; j <= right2; j += N2) {\n\n                const right3 = Math.min(j + N2 - 1, right2);\n\n                // pack each entry recursively\n                node.children.push(this._build(items, j, right3, height - 1));\n            }\n        }\n\n        calcBBox(node, this.toBBox);\n\n        return node;\n    }\n\n    _chooseSubtree(bbox, node, level, path) {\n        while (true) {\n            path.push(node);\n\n            if (node.leaf || path.length - 1 === level) break;\n\n            let minArea = Infinity;\n            let minEnlargement = Infinity;\n            let targetNode;\n\n            for (let i = 0; i < node.children.length; i++) {\n                const child = node.children[i];\n                const area = bboxArea(child);\n                const enlargement = enlargedArea(bbox, child) - area;\n\n                // choose entry with the least area enlargement\n                if (enlargement < minEnlargement) {\n                    minEnlargement = enlargement;\n                    minArea = area < minArea ? area : minArea;\n                    targetNode = child;\n\n                } else if (enlargement === minEnlargement) {\n                    // otherwise choose one with the smallest area\n                    if (area < minArea) {\n                        minArea = area;\n                        targetNode = child;\n                    }\n                }\n            }\n\n            node = targetNode || node.children[0];\n        }\n\n        return node;\n    }\n\n    _insert(item, level, isNode) {\n        const bbox = isNode ? item : this.toBBox(item);\n        const insertPath = [];\n\n        // find the best node for accommodating the item, saving all nodes along the path too\n        const node = this._chooseSubtree(bbox, this.data, level, insertPath);\n\n        // put the item into the node\n        node.children.push(item);\n        extend(node, bbox);\n\n        // split on node overflow; propagate upwards if necessary\n        while (level >= 0) {\n            if (insertPath[level].children.length > this._maxEntries) {\n                this._split(insertPath, level);\n                level--;\n            } else break;\n        }\n\n        // adjust bboxes along the insertion path\n        this._adjustParentBBoxes(bbox, insertPath, level);\n    }\n\n    // split overflowed node into two\n    _split(insertPath, level) {\n        const node = insertPath[level];\n        const M = node.children.length;\n        const m = this._minEntries;\n\n        this._chooseSplitAxis(node, m, M);\n\n        const splitIndex = this._chooseSplitIndex(node, m, M);\n\n        const newNode = createNode(node.children.splice(splitIndex, node.children.length - splitIndex));\n        newNode.height = node.height;\n        newNode.leaf = node.leaf;\n\n        calcBBox(node, this.toBBox);\n        calcBBox(newNode, this.toBBox);\n\n        if (level) insertPath[level - 1].children.push(newNode);\n        else this._splitRoot(node, newNode);\n    }\n\n    _splitRoot(node, newNode) {\n        // split root node\n        this.data = createNode([node, newNode]);\n        this.data.height = node.height + 1;\n        this.data.leaf = false;\n        calcBBox(this.data, this.toBBox);\n    }\n\n    _chooseSplitIndex(node, m, M) {\n        let index;\n        let minOverlap = Infinity;\n        let minArea = Infinity;\n\n        for (let i = m; i <= M - m; i++) {\n            const bbox1 = distBBox(node, 0, i, this.toBBox);\n            const bbox2 = distBBox(node, i, M, this.toBBox);\n\n            const overlap = intersectionArea(bbox1, bbox2);\n            const area = bboxArea(bbox1) + bboxArea(bbox2);\n\n            // choose distribution with minimum overlap\n            if (overlap < minOverlap) {\n                minOverlap = overlap;\n                index = i;\n\n                minArea = area < minArea ? area : minArea;\n\n            } else if (overlap === minOverlap) {\n                // otherwise choose distribution with minimum area\n                if (area < minArea) {\n                    minArea = area;\n                    index = i;\n                }\n            }\n        }\n\n        return index || M - m;\n    }\n\n    // sorts node children by the best axis for split\n    _chooseSplitAxis(node, m, M) {\n        const compareMinX = node.leaf ? this.compareMinX : compareNodeMinX;\n        const compareMinY = node.leaf ? this.compareMinY : compareNodeMinY;\n        const xMargin = this._allDistMargin(node, m, M, compareMinX);\n        const yMargin = this._allDistMargin(node, m, M, compareMinY);\n\n        // if total distributions margin value is minimal for x, sort by minX,\n        // otherwise it's already sorted by minY\n        if (xMargin < yMargin) node.children.sort(compareMinX);\n    }\n\n    // total margin of all possible split distributions where each node is at least m full\n    _allDistMargin(node, m, M, compare) {\n        node.children.sort(compare);\n\n        const toBBox = this.toBBox;\n        const leftBBox = distBBox(node, 0, m, toBBox);\n        const rightBBox = distBBox(node, M - m, M, toBBox);\n        let margin = bboxMargin(leftBBox) + bboxMargin(rightBBox);\n\n        for (let i = m; i < M - m; i++) {\n            const child = node.children[i];\n            extend(leftBBox, node.leaf ? toBBox(child) : child);\n            margin += bboxMargin(leftBBox);\n        }\n\n        for (let i = M - m - 1; i >= m; i--) {\n            const child = node.children[i];\n            extend(rightBBox, node.leaf ? toBBox(child) : child);\n            margin += bboxMargin(rightBBox);\n        }\n\n        return margin;\n    }\n\n    _adjustParentBBoxes(bbox, path, level) {\n        // adjust bboxes along the given tree path\n        for (let i = level; i >= 0; i--) {\n            extend(path[i], bbox);\n        }\n    }\n\n    _condense(path) {\n        // go through the path, removing empty nodes and updating bboxes\n        for (let i = path.length - 1, siblings; i >= 0; i--) {\n            if (path[i].children.length === 0) {\n                if (i > 0) {\n                    siblings = path[i - 1].children;\n                    siblings.splice(siblings.indexOf(path[i]), 1);\n\n                } else this.clear();\n\n            } else calcBBox(path[i], this.toBBox);\n        }\n    }\n}\n\nfunction findItem(item, items, equalsFn) {\n    if (!equalsFn) return items.indexOf(item);\n\n    for (let i = 0; i < items.length; i++) {\n        if (equalsFn(item, items[i])) return i;\n    }\n    return -1;\n}\n\n// calculate node's bbox from bboxes of its children\nfunction calcBBox(node, toBBox) {\n    distBBox(node, 0, node.children.length, toBBox, node);\n}\n\n// min bounding rectangle of node children from k to p-1\nfunction distBBox(node, k, p, toBBox, destNode) {\n    if (!destNode) destNode = createNode(null);\n    destNode.minX = Infinity;\n    destNode.minY = Infinity;\n    destNode.maxX = -Infinity;\n    destNode.maxY = -Infinity;\n\n    for (let i = k; i < p; i++) {\n        const child = node.children[i];\n        extend(destNode, node.leaf ? toBBox(child) : child);\n    }\n\n    return destNode;\n}\n\nfunction extend(a, b) {\n    a.minX = Math.min(a.minX, b.minX);\n    a.minY = Math.min(a.minY, b.minY);\n    a.maxX = Math.max(a.maxX, b.maxX);\n    a.maxY = Math.max(a.maxY, b.maxY);\n    return a;\n}\n\nfunction compareNodeMinX(a, b) { return a.minX - b.minX; }\nfunction compareNodeMinY(a, b) { return a.minY - b.minY; }\n\nfunction bboxArea(a)   { return (a.maxX - a.minX) * (a.maxY - a.minY); }\nfunction bboxMargin(a) { return (a.maxX - a.minX) + (a.maxY - a.minY); }\n\nfunction enlargedArea(a, b) {\n    return (Math.max(b.maxX, a.maxX) - Math.min(b.minX, a.minX)) *\n           (Math.max(b.maxY, a.maxY) - Math.min(b.minY, a.minY));\n}\n\nfunction intersectionArea(a, b) {\n    const minX = Math.max(a.minX, b.minX);\n    const minY = Math.max(a.minY, b.minY);\n    const maxX = Math.min(a.maxX, b.maxX);\n    const maxY = Math.min(a.maxY, b.maxY);\n\n    return Math.max(0, maxX - minX) *\n           Math.max(0, maxY - minY);\n}\n\nfunction contains(a, b) {\n    return a.minX <= b.minX &&\n           a.minY <= b.minY &&\n           b.maxX <= a.maxX &&\n           b.maxY <= a.maxY;\n}\n\nfunction intersects(a, b) {\n    return b.minX <= a.maxX &&\n           b.minY <= a.maxY &&\n           b.maxX >= a.minX &&\n           b.maxY >= a.minY;\n}\n\nfunction createNode(children) {\n    return {\n        children,\n        height: 1,\n        leaf: true,\n        minX: Infinity,\n        minY: Infinity,\n        maxX: -Infinity,\n        maxY: -Infinity\n    };\n}\n\n// sort an array so that items come in groups of n unsorted items, with groups sorted between each other;\n// combines selection algorithm with binary divide & conquer approach\n\nfunction multiSelect(arr, left, right, n, compare) {\n    const stack = [left, right];\n\n    while (stack.length) {\n        right = stack.pop();\n        left = stack.pop();\n\n        if (right - left <= n) continue;\n\n        const mid = left + Math.ceil((right - left) / n / 2) * n;\n        quickselect(arr, mid, left, right, compare);\n\n        stack.push(left, mid, mid, right);\n    }\n}\n"],"names":["RBush","maxEntries","bbox","node","result","intersects","toBBox","nodesToSearch","i","child","childBBox","contains","data","tmpNode","item","createNode","equalsFn","path","indexes","parent","goingUp","index","findItem","a","b","items","left","right","height","N","M","calcBBox","N2","N1","multiSelect","right2","j","right3","level","minArea","minEnlargement","targetNode","area","bboxArea","enlargement","enlargedArea","isNode","insertPath","extend","m","splitIndex","newNode","minOverlap","bbox1","distBBox","bbox2","overlap","intersectionArea","compareMinX","compareNodeMinX","compareMinY","compareNodeMinY","xMargin","yMargin","compare","leftBBox","rightBBox","margin","bboxMargin","siblings","k","p","destNode","minX","minY","maxX","maxY","children","arr","stack","mid","quickselect"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/index.cjs354.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function U(c,s){return(c<<s|c>>>32-s)>>>0}function j(c){const s=new TextEncoder().encode(c),r=s.length,L=r*8,S=(r+9+63&-64)-r,d=new Uint8Array(r+S);d.set(s),d[r]=128;const h=new DataView(d.buffer),m=d.length;h.setUint32(m-8,Math.floor(L/4294967296),!1),h.setUint32(m-4,L>>>0,!1);let g=1732584193,u=4023233417,H=2562383102,p=271733878,w=3285377520;const o=new Uint32Array(80);for(let a=0;a<m;a+=64){for(let e=0;e<16;e++)o[e]=h.getUint32(a+e*4,!1);for(let e=16;e<80;e++)o[e]=U(o[e-3]^o[e-8]^o[e-14]^o[e-16],1);let b=g,t=u,n=H,l=p,y=w;for(let e=0;e<80;e++){let i,f;e<20?(i=(t&n|~t&l)>>>0,f=1518500249):e<40?(i=t^n^l,f=1859775393):e<60?(i=t&n|t&l|n&l,f=2400959708):(i=t^n^l,f=3395469782);const x=U(b,5)+i+y+f+o[e]>>>0;y=l,l=n,n=U(t,30),t=b,b=x}g=g+b>>>0,u=u+t>>>0,H=H+n>>>0,p=p+l>>>0,w=w+y>>>0}return[g,u,H,p,w].map(a=>a.toString(16).padStart(8,"0")).join("")}exports.sha1Hex=j;
+//# sourceMappingURL=index.cjs354.js.map

package/dist/index.cjs354.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs354.js","sources":["../../../node_modules/@allmaps/id/dist/sha1.js"],"sourcesContent":["/**\n * Pure TypeScript SHA-1 implementation.\n * No external dependencies — works in all environments including Cloudflare Workers.\n *\n * Based on the SHA-1 specification (FIPS PUB 180-4).\n */\nfunction rotl(n, s) {\n    return ((n << s) | (n >>> (32 - s))) >>> 0;\n}\n/**\n * Computes the SHA-1 hash of a UTF-8 string and returns it as a hex string.\n *\n * @param message - Input string.\n * @returns Hex-encoded SHA-1 digest.\n */\nexport function sha1Hex(message) {\n    // Encode string to UTF-8 bytes\n    const msgBytes = new TextEncoder().encode(message);\n    const msgLen = msgBytes.length;\n    // Pre-processing: adding padding bits\n    // Message length in bits\n    const bitLen = msgLen * 8;\n    // Padding: 1 byte 0x80, then zeros, then 8 bytes for the 64-bit length.\n    // Total padded length must be a multiple of 64 bytes.\n    const padLen = ((msgLen + 9 + 63) & ~63) - msgLen;\n    const padded = new Uint8Array(msgLen + padLen);\n    padded.set(msgBytes);\n    padded[msgLen] = 0x80;\n    // Append original length in bits as big-endian 64-bit integer.\n    // JavaScript's bit ops are 32-bit, so split into two 32-bit words.\n    const dataView = new DataView(padded.buffer);\n    const totalLen = padded.length;\n    dataView.setUint32(totalLen - 8, Math.floor(bitLen / 0x100000000), false);\n    dataView.setUint32(totalLen - 4, bitLen >>> 0, false);\n    // Initial hash values (H0–H4)\n    let H0 = 0x67452301;\n    let H1 = 0xefcdab89;\n    let H2 = 0x98badcfe;\n    let H3 = 0x10325476;\n    let H4 = 0xc3d2e1f0;\n    // Process each 512-bit (64-byte) block\n    const W = new Uint32Array(80);\n    for (let offset = 0; offset < totalLen; offset += 64) {\n        // Prepare message schedule\n        for (let i = 0; i < 16; i++) {\n            W[i] = dataView.getUint32(offset + i * 4, false);\n        }\n        for (let i = 16; i < 80; i++) {\n            W[i] = rotl(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16], 1);\n        }\n        let a = H0;\n        let b = H1;\n        let c = H2;\n        let d = H3;\n        let e = H4;\n        for (let i = 0; i < 80; i++) {\n            let f;\n            let k;\n            if (i < 20) {\n                f = ((b & c) | (~b & d)) >>> 0;\n                k = 0x5a827999;\n            }\n            else if (i < 40) {\n                f = b ^ c ^ d;\n                k = 0x6ed9eba1;\n            }\n            else if (i < 60) {\n                f = (b & c) | (b & d) | (c & d);\n                k = 0x8f1bbcdc;\n            }\n            else {\n                f = b ^ c ^ d;\n                k = 0xca62c1d6;\n            }\n            const temp = (rotl(a, 5) + f + e + k + W[i]) >>> 0;\n            e = d;\n            d = c;\n            c = rotl(b, 30);\n            b = a;\n            a = temp;\n        }\n        H0 = (H0 + a) >>> 0;\n        H1 = (H1 + b) >>> 0;\n        H2 = (H2 + c) >>> 0;\n        H3 = (H3 + d) >>> 0;\n        H4 = (H4 + e) >>> 0;\n    }\n    return [H0, H1, H2, H3, H4]\n        .map((h) => h.toString(16).padStart(8, '0'))\n        .join('');\n}\n"],"names":["rotl","n","sha1Hex","message","msgBytes","msgLen","bitLen","padLen","padded","dataView","totalLen","H0","H1","H2","H3","H4","W","offset","i","a","b","c","d","e","f","k","temp","h"],"mappings":"gFAMA,SAASA,EAAKC,EAAG,EAAG,CAChB,OAASA,GAAK,EAAMA,IAAO,GAAK,KAAS,CAC7C,CAOO,SAASC,EAAQC,EAAS,CAE7B,MAAMC,EAAW,IAAI,cAAc,OAAOD,CAAO,EAC3CE,EAASD,EAAS,OAGlBE,EAASD,EAAS,EAGlBE,GAAWF,EAAS,EAAI,GAAM,KAAOA,EACrCG,EAAS,IAAI,WAAWH,EAASE,CAAM,EAC7CC,EAAO,IAAIJ,CAAQ,EACnBI,EAAOH,CAAM,EAAI,IAGjB,MAAMI,EAAW,IAAI,SAASD,EAAO,MAAM,EACrCE,EAAWF,EAAO,OACxBC,EAAS,UAAUC,EAAW,EAAG,KAAK,MAAMJ,EAAS,UAAW,EAAG,EAAK,EACxEG,EAAS,UAAUC,EAAW,EAAGJ,IAAW,EAAG,EAAK,EAEpD,IAAIK,EAAK,WACLC,EAAK,WACLC,EAAK,WACLC,EAAK,UACLC,EAAK,WAET,MAAMC,EAAI,IAAI,YAAY,EAAE,EAC5B,QAASC,EAAS,EAAGA,EAASP,EAAUO,GAAU,GAAI,CAElD,QAASC,EAAI,EAAGA,EAAI,GAAIA,IACpBF,EAAEE,CAAC,EAAIT,EAAS,UAAUQ,EAASC,EAAI,EAAG,EAAK,EAEnD,QAASA,EAAI,GAAIA,EAAI,GAAIA,IACrBF,EAAEE,CAAC,EAAIlB,EAAKgB,EAAEE,EAAI,CAAC,EAAIF,EAAEE,EAAI,CAAC,EAAIF,EAAEE,EAAI,EAAE,EAAIF,EAAEE,EAAI,EAAE,EAAG,CAAC,EAE9D,IAAIC,EAAIR,EACJS,EAAIR,EACJS,EAAIR,EACJS,EAAIR,EACJS,EAAIR,EACR,QAASG,EAAI,EAAGA,EAAI,GAAIA,IAAK,CACzB,IAAIM,EACAC,EACAP,EAAI,IACJM,GAAMJ,EAAIC,EAAM,CAACD,EAAIE,KAAQ,EAC7BG,EAAI,YAECP,EAAI,IACTM,EAAIJ,EAAIC,EAAIC,EACZG,EAAI,YAECP,EAAI,IACTM,EAAKJ,EAAIC,EAAMD,EAAIE,EAAMD,EAAIC,EAC7BG,EAAI,aAGJD,EAAIJ,EAAIC,EAAIC,EACZG,EAAI,YAER,MAAMC,EAAQ1B,EAAKmB,EAAG,CAAC,EAAIK,EAAID,EAAIE,EAAIT,EAAEE,CAAC,IAAO,EACjDK,EAAID,EACJA,EAAID,EACJA,EAAIrB,EAAKoB,EAAG,EAAE,EACdA,EAAID,EACJA,EAAIO,CACR,CACAf,EAAMA,EAAKQ,IAAO,EAClBP,EAAMA,EAAKQ,IAAO,EAClBP,EAAMA,EAAKQ,IAAO,EAClBP,EAAMA,EAAKQ,IAAO,EAClBP,EAAMA,EAAKQ,IAAO,CACtB,CACA,MAAO,CAACZ,EAAIC,EAAIC,EAAIC,EAAIC,CAAE,EACrB,IAAKY,GAAMA,EAAE,SAAS,EAAE,EAAE,SAAS,EAAG,GAAG,CAAC,EAC1C,KAAK,EAAE,CAChB","x_google_ignoreList":[0]}

package/dist/index.cjs355.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function t(e){return Array.isArray(e)?`[${e.map(r=>t(r)).join(",")}]`:typeof e=="number"?`${e}`:typeof e=="string"?`"${e}"`:typeof e=="object"&&e!==null?Object.keys(e).sort().map(r=>`${r}:${t(e[r])}`).join("|"):String(e)}exports.serialize=t;
+//# sourceMappingURL=index.cjs355.js.map

package/dist/index.cjs355.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs355.js","sources":["../../../node_modules/@allmaps/id/dist/checksum.js"],"sourcesContent":["/**\n * Serializes any JavaScript type to a string. If the\n * type is an object, first sortthe object by its keys.\n *\n * @param obj - JavaScript type to serialize.\n * @returns `obj` serialized to a string.\n */\nexport function serialize(obj) {\n    if (Array.isArray(obj)) {\n        return `[${obj.map((i) => serialize(i)).join(',')}]`;\n    }\n    else if (typeof obj === 'number') {\n        return `${obj}`;\n    }\n    else if (typeof obj === 'string') {\n        return `\"${obj}\"`;\n    }\n    else if (typeof obj === 'object' && obj !== null) {\n        return Object.keys(obj)\n            .sort()\n            .map((key) => `${key}:${serialize(obj[key])}`)\n            .join('|');\n    }\n    return String(obj);\n}\n"],"names":["serialize","obj","i","key"],"mappings":"gFAOO,SAASA,EAAUC,EAAK,CAC3B,OAAI,MAAM,QAAQA,CAAG,EACV,IAAIA,EAAI,IAAKC,GAAMF,EAAUE,CAAC,CAAC,EAAE,KAAK,GAAG,CAAC,IAE5C,OAAOD,GAAQ,SACb,GAAGA,CAAG,GAER,OAAOA,GAAQ,SACb,IAAIA,CAAG,IAET,OAAOA,GAAQ,UAAYA,IAAQ,KACjC,OAAO,KAAKA,CAAG,EACjB,OACA,IAAKE,GAAQ,GAAGA,CAAG,IAAIH,EAAUC,EAAIE,CAAG,CAAC,CAAC,EAAE,EAC5C,KAAK,GAAG,EAEV,OAAOF,CAAG,CACrB","x_google_ignoreList":[0]}

package/dist/index.cjs356.js

@@ -0,0 +1,2 @@
+"use strict";function e(n,t){return n<t?-1:n>t?1:n>=t?0:NaN}module.exports=e;
+//# sourceMappingURL=index.cjs356.js.map

package/dist/index.cjs356.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs356.js","sources":["../../../node_modules/d3-geo/node_modules/d3-array/src/ascending.js"],"sourcesContent":["export default function(a, b) {\n  return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;\n}\n"],"names":["ascending","a","b"],"mappings":"aAAA,SAAAA,EAAwBC,EAAGC,EAAG,CAC5B,OAAOD,EAAIC,EAAI,GAAKD,EAAIC,EAAI,EAAID,GAAKC,EAAI,EAAI,GAC/C","x_google_ignoreList":[0]}

package/dist/index.cjs357.js

@@ -0,0 +1,2 @@
+"use strict";const s=require("./index.cjs356.js");function i(e){return e.length===1&&(e=c(e)),{left:function(r,f,n,t){for(n==null&&(n=0),t==null&&(t=r.length);n<t;){var u=n+t>>>1;e(r[u],f)<0?n=u+1:t=u}return n},right:function(r,f,n,t){for(n==null&&(n=0),t==null&&(t=r.length);n<t;){var u=n+t>>>1;e(r[u],f)>0?t=u:n=u+1}return n}}}function c(e){return function(r,f){return s(e(r),f)}}module.exports=i;
+//# sourceMappingURL=index.cjs357.js.map

package/dist/index.cjs357.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs357.js","sources":["../../../node_modules/d3-geo/node_modules/d3-array/src/bisector.js"],"sourcesContent":["import ascending from \"./ascending\";\n\nexport default function(compare) {\n  if (compare.length === 1) compare = ascendingComparator(compare);\n  return {\n    left: function(a, x, lo, hi) {\n      if (lo == null) lo = 0;\n      if (hi == null) hi = a.length;\n      while (lo < hi) {\n        var mid = lo + hi >>> 1;\n        if (compare(a[mid], x) < 0) lo = mid + 1;\n        else hi = mid;\n      }\n      return lo;\n    },\n    right: function(a, x, lo, hi) {\n      if (lo == null) lo = 0;\n      if (hi == null) hi = a.length;\n      while (lo < hi) {\n        var mid = lo + hi >>> 1;\n        if (compare(a[mid], x) > 0) hi = mid;\n        else lo = mid + 1;\n      }\n      return lo;\n    }\n  };\n}\n\nfunction ascendingComparator(f) {\n  return function(d, x) {\n    return ascending(f(d), x);\n  };\n}\n"],"names":["bisector","compare","ascendingComparator","a","x","lo","hi","mid","f","d","ascending"],"mappings":"kDAEA,SAAAA,EAAwBC,EAAS,CAC/B,OAAIA,EAAQ,SAAW,IAAGA,EAAUC,EAAoBD,CAAO,GACxD,CACL,KAAM,SAASE,EAAGC,EAAGC,EAAIC,EAAI,CAG3B,IAFID,GAAM,OAAMA,EAAK,GACjBC,GAAM,OAAMA,EAAKH,EAAE,QAChBE,EAAKC,GAAI,CACd,IAAIC,EAAMF,EAAKC,IAAO,EAClBL,EAAQE,EAAEI,CAAG,EAAGH,CAAC,EAAI,IAAQG,EAAM,EAClCD,EAAKC,CACZ,CACA,OAAOF,CACT,EACA,MAAO,SAASF,EAAGC,EAAGC,EAAIC,EAAI,CAG5B,IAFID,GAAM,OAAMA,EAAK,GACjBC,GAAM,OAAMA,EAAKH,EAAE,QAChBE,EAAKC,GAAI,CACd,IAAIC,EAAMF,EAAKC,IAAO,EAClBL,EAAQE,EAAEI,CAAG,EAAGH,CAAC,EAAI,EAAGE,EAAKC,IACvBA,EAAM,CAClB,CACA,OAAOF,CACT,CAAA,CAEJ,CAEA,SAASH,EAAoBM,EAAG,CAC9B,OAAO,SAASC,EAAGL,EAAG,CACpB,OAAOM,EAAUF,EAAEC,CAAC,EAAGL,CAAC,CAC1B,CACF","x_google_ignoreList":[0]}

package/dist/index.cjs358.js

@@ -0,0 +1,2 @@
+"use strict";const N=require("./index.cjs271.js"),C=Math.pow(2,-52),j=new Uint32Array(512);class Y{static from(t,i=Q,h=V){const o=t.length,l=new Float64Array(o*2);for(let n=0;n<o;n++){const r=t[n];l[2*n]=i(r),l[2*n+1]=h(r)}return new Y(l)}constructor(t){const i=t.length>>1;if(i>0&&typeof t[0]!="number")throw new Error("Expected coords to contain numbers.");this.coords=t;const h=Math.max(2*i-5,0);this._triangles=new Uint32Array(h*3),this._halfedges=new Int32Array(h*3),this._hashSize=Math.ceil(Math.sqrt(i)),this._hullPrev=new Uint32Array(i),this._hullNext=new Uint32Array(i),this._hullTri=new Uint32Array(i),this._hullHash=new Int32Array(this._hashSize),this._ids=new Uint32Array(i),this._dists=new Float64Array(i),this.trianglesLen=0,this._cx=0,this._cy=0,this._hullStart=0,this.hull=this._triangles,this.triangles=this._triangles,this.halfedges=this._halfedges,this.update()}update(){const{coords:t,_hullPrev:i,_hullNext:h,_hullTri:o,_hullHash:l}=this,n=t.length>>1;let r=1/0,f=1/0,g=-1/0,b=-1/0;for(let e=0;e<n;e++){const u=t[2*e],a=t[2*e+1];u<r&&(r=u),a<f&&(f=a),u>g&&(g=u),a>b&&(b=a),this._ids[e]=e}const x=(r+g)/2,m=(f+b)/2;let c=0,y=0,d=0;for(let e=0,u=1/0;e<n;e++){const a=X(x,m,t[2*e],t[2*e+1]);a<u&&(c=e,u=a)}const T=t[2*c],M=t[2*c+1];for(let e=0,u=1/0;e<n;e++){if(e===c)continue;const a=X(T,M,t[2*e],t[2*e+1]);a<u&&a>0&&(y=e,u=a)}let U=t[2*y],k=t[2*y+1],G=1/0;for(let e=0;e<n;e++){if(e===c||e===y)continue;const u=B(T,M,U,k,t[2*e],t[2*e+1]);u<G&&(d=e,G=u)}let D=t[2*d],E=t[2*d+1];if(G===1/0){for(let a=0;a<n;a++)this._dists[a]=t[2*a]-t[0]||t[2*a+1]-t[1];L(this._ids,this._dists,0,n-1);const e=new Uint32Array(n);let u=0;for(let a=0,w=-1/0;a<n;a++){const A=this._ids[a],S=this._dists[A];S>w&&(e[u++]=A,w=S)}this.hull=e.subarray(0,u),this.triangles=new Uint32Array(0),this.halfedges=new Int32Array(0);return}if(N.orient2d(T,M,U,k,D,E)<0){const e=y,u=U,a=k;y=d,U=D,k=E,d=e,D=u,E=a}const v=J(T,M,U,k,D,E);this._cx=v.x,this._cy=v.y;for(let e=0;e<n;e++)this._dists[e]=X(t[2*e],t[2*e+1],v.x,v.y);L(this._ids,this._dists,0,n-1),this._hullStart=c;let P=3;h[c]=i[d]=y,h[y]=i[c]=d,h[d]=i[y]=c,o[c]=0,o[y]=1,o[d]=2,l.fill(-1),l[this._hashKey(T,M)]=c,l[this._hashKey(U,k)]=y,l[this._hashKey(D,E)]=d,this.trianglesLen=0,this._addTriangle(c,y,d,-1,-1,-1);for(let e=0,u=0,a=0;e<this._ids.length;e++){const w=this._ids[e],A=t[2*w],S=t[2*w+1];if(e>0&&Math.abs(A-u)<=C&&Math.abs(S-a)<=C||(u=A,a=S,w===c||w===y||w===d))continue;let z=0;for(let H=0,F=this._hashKey(A,S);H<this._hashSize&&(z=l[(F+H)%this._hashSize],!(z!==-1&&z!==h[z]));H++);z=i[z];let _=z,p;for(;p=h[_],N.orient2d(A,S,t[2*_],t[2*_+1],t[2*p],t[2*p+1])>=0;)if(_=p,_===z){_=-1;break}if(_===-1)continue;let K=this._addTriangle(_,w,h[_],-1,-1,o[_]);o[w]=this._legalize(K+2),o[_]=K,P++;let I=h[_];for(;p=h[I],N.orient2d(A,S,t[2*I],t[2*I+1],t[2*p],t[2*p+1])<0;)K=this._addTriangle(I,w,p,o[w],-1,o[I]),o[w]=this._legalize(K+2),h[I]=I,P--,I=p;if(_===z)for(;p=i[_],N.orient2d(A,S,t[2*p],t[2*p+1],t[2*_],t[2*_+1])<0;)K=this._addTriangle(p,w,_,-1,o[_],o[p]),this._legalize(K+2),o[p]=K,h[_]=_,P--,_=p;this._hullStart=i[w]=_,h[_]=i[I]=w,h[w]=I,l[this._hashKey(A,S)]=w,l[this._hashKey(t[2*_],t[2*_+1])]=_}this.hull=new Uint32Array(P);for(let e=0,u=this._hullStart;e<P;e++)this.hull[e]=u,u=h[u];this.triangles=this._triangles.subarray(0,this.trianglesLen),this.halfedges=this._halfedges.subarray(0,this.trianglesLen)}_hashKey(t,i){return Math.floor(O(t-this._cx,i-this._cy)*this._hashSize)%this._hashSize}_legalize(t){const{_triangles:i,_halfedges:h,coords:o}=this;let l=0,n=0;for(;;){const r=h[t],f=t-t%3;if(n=f+(t+2)%3,r===-1){if(l===0)break;t=j[--l];continue}const g=r-r%3,b=f+(t+1)%3,x=g+(r+2)%3,m=i[n],c=i[t],y=i[b],d=i[x];if(R(o[2*m],o[2*m+1],o[2*c],o[2*c+1],o[2*y],o[2*y+1],o[2*d],o[2*d+1])){i[t]=d,i[r]=m;const M=h[x];if(M===-1){let k=this._hullStart;do{if(this._hullTri[k]===x){this._hullTri[k]=t;break}k=this._hullPrev[k]}while(k!==this._hullStart)}this._link(t,M),this._link(r,h[n]),this._link(n,x);const U=g+(r+1)%3;l<j.length&&(j[l++]=U)}else{if(l===0)break;t=j[--l]}}return n}_link(t,i){this._halfedges[t]=i,i!==-1&&(this._halfedges[i]=t)}_addTriangle(t,i,h,o,l,n){const r=this.trianglesLen;return this._triangles[r]=t,this._triangles[r+1]=i,this._triangles[r+2]=h,this._link(r,o),this._link(r+1,l),this._link(r+2,n),this.trianglesLen+=3,r}}function O(s,t){const i=s/(Math.abs(s)+Math.abs(t));return(t>0?3-i:1+i)/4}function X(s,t,i,h){const o=s-i,l=t-h;return o*o+l*l}function R(s,t,i,h,o,l,n,r){const f=s-n,g=t-r,b=i-n,x=h-r,m=o-n,c=l-r,y=f*f+g*g,d=b*b+x*x,T=m*m+c*c;return f*(x*T-d*c)-g*(b*T-d*m)+y*(b*c-x*m)<0}function B(s,t,i,h,o,l){const n=i-s,r=h-t,f=o-s,g=l-t,b=n*n+r*r,x=f*f+g*g,m=.5/(n*g-r*f),c=(g*b-r*x)*m,y=(n*x-f*b)*m;return c*c+y*y}function J(s,t,i,h,o,l){const n=i-s,r=h-t,f=o-s,g=l-t,b=n*n+r*r,x=f*f+g*g,m=.5/(n*g-r*f),c=s+(g*b-r*x)*m,y=t+(n*x-f*b)*m;return{x:c,y}}function L(s,t,i,h){if(h-i<=20)for(let o=i+1;o<=h;o++){const l=s[o],n=t[l];let r=o-1;for(;r>=i&&t[s[r]]>n;)s[r+1]=s[r--];s[r+1]=l}else{const o=i+h>>1;let l=i+1,n=h;q(s,o,l),t[s[i]]>t[s[h]]&&q(s,i,h),t[s[l]]>t[s[h]]&&q(s,l,h),t[s[i]]>t[s[l]]&&q(s,i,l);const r=s[l],f=t[r];for(;;){do l++;while(t[s[l]]<f);do n--;while(t[s[n]]>f);if(n<l)break;q(s,l,n)}s[i+1]=s[n],s[n]=r,h-l+1>=n-i?(L(s,t,l,h),L(s,t,i,n-1)):(L(s,t,i,n-1),L(s,t,l,h))}}function q(s,t,i){const h=s[t];s[t]=s[i],s[i]=h}function Q(s){return s[0]}function V(s){return s[1]}module.exports=Y;
+//# sourceMappingURL=index.cjs358.js.map

package/dist/index.cjs358.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs358.js","sources":["../../../node_modules/delaunator/index.js"],"sourcesContent":["\nconst EPSILON = Math.pow(2, -52);\nconst EDGE_STACK = new Uint32Array(512);\n\nimport {orient2d} from 'robust-predicates';\n\n/** @template {ArrayLike<number>} T */\nexport default class Delaunator {\n\n    /**\n     * Constructs a delaunay triangulation object given an array of points (`[x, y]` by default).\n     * `getX` and `getY` are optional functions of the form `(point) => value` for custom point formats.\n     *\n     * @template P\n     * @param {P[]} points\n     * @param {(p: P) => number} [getX]\n     * @param {(p: P) => number} [getY]\n     */\n    // @ts-expect-error TS2322\n    static from(points, getX = defaultGetX, getY = defaultGetY) {\n        const n = points.length;\n        const coords = new Float64Array(n * 2);\n\n        for (let i = 0; i < n; i++) {\n            const p = points[i];\n            coords[2 * i] = getX(p);\n            coords[2 * i + 1] = getY(p);\n        }\n\n        return new Delaunator(coords);\n    }\n\n    /**\n     * Constructs a delaunay triangulation object given an array of point coordinates of the form:\n     * `[x0, y0, x1, y1, ...]` (use a typed array for best performance). Duplicate points are skipped.\n     *\n     * @param {T} coords\n     */\n    constructor(coords) {\n        const n = coords.length >> 1;\n        if (n > 0 && typeof coords[0] !== 'number') throw new Error('Expected coords to contain numbers.');\n\n        this.coords = coords;\n\n        // arrays that will store the triangulation graph\n        const maxTriangles = Math.max(2 * n - 5, 0);\n        /** @private */ this._triangles = new Uint32Array(maxTriangles * 3);\n        /** @private */ this._halfedges = new Int32Array(maxTriangles * 3);\n\n        // temporary arrays for tracking the edges of the advancing convex hull\n        /** @private */ this._hashSize = Math.ceil(Math.sqrt(n));\n        /** @private */ this._hullPrev = new Uint32Array(n); // edge to prev edge\n        /** @private */ this._hullNext = new Uint32Array(n); // edge to next edge\n        /** @private */ this._hullTri = new Uint32Array(n); // edge to adjacent triangle\n        /** @private */ this._hullHash = new Int32Array(this._hashSize); // angular edge hash\n\n        // temporary arrays for sorting points\n        /** @private */ this._ids = new Uint32Array(n);\n        /** @private */ this._dists = new Float64Array(n);\n\n        /** @private */ this.trianglesLen = 0;\n        /** @private */ this._cx = 0;\n        /** @private */ this._cy = 0;\n        /** @private */ this._hullStart = 0;\n\n\n        /** A `Uint32Array` array of indices that reference points on the convex hull of the input data, counter-clockwise. */\n        this.hull = this._triangles;\n        /** A `Uint32Array` array of triangle vertex indices (each group of three numbers forms a triangle). All triangles are directed counterclockwise. */\n        this.triangles = this._triangles;\n        /**\n         * A `Int32Array` array of triangle half-edge indices that allows you to traverse the triangulation.\n         * `i`-th half-edge in the array corresponds to vertex `triangles[i]` the half-edge is coming from.\n         * `halfedges[i]` is the index of a twin half-edge in an adjacent triangle (or `-1` for outer half-edges on the convex hull).\n         */\n        this.halfedges = this._halfedges;\n\n        this.update();\n    }\n\n    /**\n     * Updates the triangulation if you modified `delaunay.coords` values in place, avoiding expensive memory allocations.\n     * Useful for iterative relaxation algorithms such as Lloyd's.\n     */\n    update() {\n        const {coords, _hullPrev: hullPrev, _hullNext: hullNext, _hullTri: hullTri, _hullHash: hullHash} =  this;\n        const n = coords.length >> 1;\n\n        // populate an array of point indices; calculate input data bbox\n        let minX = Infinity;\n        let minY = Infinity;\n        let maxX = -Infinity;\n        let maxY = -Infinity;\n\n        for (let i = 0; i < n; i++) {\n            const x = coords[2 * i];\n            const y = coords[2 * i + 1];\n            if (x < minX) minX = x;\n            if (y < minY) minY = y;\n            if (x > maxX) maxX = x;\n            if (y > maxY) maxY = y;\n            this._ids[i] = i;\n        }\n        const cx = (minX + maxX) / 2;\n        const cy = (minY + maxY) / 2;\n\n        let i0 = 0, i1 = 0, i2 = 0;\n\n        // pick a seed point close to the center\n        for (let i = 0, minDist = Infinity; i < n; i++) {\n            const d = dist(cx, cy, coords[2 * i], coords[2 * i + 1]);\n            if (d < minDist) {\n                i0 = i;\n                minDist = d;\n            }\n        }\n        const i0x = coords[2 * i0];\n        const i0y = coords[2 * i0 + 1];\n\n        // find the point closest to the seed\n        for (let i = 0, minDist = Infinity; i < n; i++) {\n            if (i === i0) continue;\n            const d = dist(i0x, i0y, coords[2 * i], coords[2 * i + 1]);\n            if (d < minDist && d > 0) {\n                i1 = i;\n                minDist = d;\n            }\n        }\n        let i1x = coords[2 * i1];\n        let i1y = coords[2 * i1 + 1];\n\n        let minRadius = Infinity;\n\n        // find the third point which forms the smallest circumcircle with the first two\n        for (let i = 0; i < n; i++) {\n            if (i === i0 || i === i1) continue;\n            const r = circumradius(i0x, i0y, i1x, i1y, coords[2 * i], coords[2 * i + 1]);\n            if (r < minRadius) {\n                i2 = i;\n                minRadius = r;\n            }\n        }\n        let i2x = coords[2 * i2];\n        let i2y = coords[2 * i2 + 1];\n\n        if (minRadius === Infinity) {\n            // order collinear points by dx (or dy if all x are identical)\n            // and return the list as a hull\n            for (let i = 0; i < n; i++) {\n                this._dists[i] = (coords[2 * i] - coords[0]) || (coords[2 * i + 1] - coords[1]);\n            }\n            quicksort(this._ids, this._dists, 0, n - 1);\n            const hull = new Uint32Array(n);\n            let j = 0;\n            for (let i = 0, d0 = -Infinity; i < n; i++) {\n                const id = this._ids[i];\n                const d = this._dists[id];\n                if (d > d0) {\n                    hull[j++] = id;\n                    d0 = d;\n                }\n            }\n            this.hull = hull.subarray(0, j);\n            this.triangles = new Uint32Array(0);\n            this.halfedges = new Int32Array(0);\n            return;\n        }\n\n        // swap the order of the seed points for counter-clockwise orientation\n        if (orient2d(i0x, i0y, i1x, i1y, i2x, i2y) < 0) {\n            const i = i1;\n            const x = i1x;\n            const y = i1y;\n            i1 = i2;\n            i1x = i2x;\n            i1y = i2y;\n            i2 = i;\n            i2x = x;\n            i2y = y;\n        }\n\n        const center = circumcenter(i0x, i0y, i1x, i1y, i2x, i2y);\n        this._cx = center.x;\n        this._cy = center.y;\n\n        for (let i = 0; i < n; i++) {\n            this._dists[i] = dist(coords[2 * i], coords[2 * i + 1], center.x, center.y);\n        }\n\n        // sort the points by distance from the seed triangle circumcenter\n        quicksort(this._ids, this._dists, 0, n - 1);\n\n        // set up the seed triangle as the starting hull\n        this._hullStart = i0;\n        let hullSize = 3;\n\n        hullNext[i0] = hullPrev[i2] = i1;\n        hullNext[i1] = hullPrev[i0] = i2;\n        hullNext[i2] = hullPrev[i1] = i0;\n\n        hullTri[i0] = 0;\n        hullTri[i1] = 1;\n        hullTri[i2] = 2;\n\n        hullHash.fill(-1);\n        hullHash[this._hashKey(i0x, i0y)] = i0;\n        hullHash[this._hashKey(i1x, i1y)] = i1;\n        hullHash[this._hashKey(i2x, i2y)] = i2;\n\n        this.trianglesLen = 0;\n        this._addTriangle(i0, i1, i2, -1, -1, -1);\n\n        for (let k = 0, xp = 0, yp = 0; k < this._ids.length; k++) {\n            const i = this._ids[k];\n            const x = coords[2 * i];\n            const y = coords[2 * i + 1];\n\n            // skip near-duplicate points\n            if (k > 0 && Math.abs(x - xp) <= EPSILON && Math.abs(y - yp) <= EPSILON) continue;\n            xp = x;\n            yp = y;\n\n            // skip seed triangle points\n            if (i === i0 || i === i1 || i === i2) continue;\n\n            // find a visible edge on the convex hull using edge hash\n            let start = 0;\n            for (let j = 0, key = this._hashKey(x, y); j < this._hashSize; j++) {\n                start = hullHash[(key + j) % this._hashSize];\n                if (start !== -1 && start !== hullNext[start]) break;\n            }\n\n            start = hullPrev[start];\n            let e = start, q;\n            while (q = hullNext[e], orient2d(x, y, coords[2 * e], coords[2 * e + 1], coords[2 * q], coords[2 * q + 1]) >= 0) {\n                e = q;\n                if (e === start) {\n                    e = -1;\n                    break;\n                }\n            }\n            if (e === -1) continue; // likely a near-duplicate point; skip it\n\n            // add the first triangle from the point\n            let t = this._addTriangle(e, i, hullNext[e], -1, -1, hullTri[e]);\n\n            // recursively flip triangles from the point until they satisfy the Delaunay condition\n            hullTri[i] = this._legalize(t + 2);\n            hullTri[e] = t; // keep track of boundary triangles on the hull\n            hullSize++;\n\n            // walk forward through the hull, adding more triangles and flipping recursively\n            let n = hullNext[e];\n            while (q = hullNext[n], orient2d(x, y, coords[2 * n], coords[2 * n + 1], coords[2 * q], coords[2 * q + 1]) < 0) {\n                t = this._addTriangle(n, i, q, hullTri[i], -1, hullTri[n]);\n                hullTri[i] = this._legalize(t + 2);\n                hullNext[n] = n; // mark as removed\n                hullSize--;\n                n = q;\n            }\n\n            // walk backward from the other side, adding more triangles and flipping\n            if (e === start) {\n                while (q = hullPrev[e], orient2d(x, y, coords[2 * q], coords[2 * q + 1], coords[2 * e], coords[2 * e + 1]) < 0) {\n                    t = this._addTriangle(q, i, e, -1, hullTri[e], hullTri[q]);\n                    this._legalize(t + 2);\n                    hullTri[q] = t;\n                    hullNext[e] = e; // mark as removed\n                    hullSize--;\n                    e = q;\n                }\n            }\n\n            // update the hull indices\n            this._hullStart = hullPrev[i] = e;\n            hullNext[e] = hullPrev[n] = i;\n            hullNext[i] = n;\n\n            // save the two new edges in the hash table\n            hullHash[this._hashKey(x, y)] = i;\n            hullHash[this._hashKey(coords[2 * e], coords[2 * e + 1])] = e;\n        }\n\n        this.hull = new Uint32Array(hullSize);\n        for (let i = 0, e = this._hullStart; i < hullSize; i++) {\n            this.hull[i] = e;\n            e = hullNext[e];\n        }\n\n        // trim typed triangle mesh arrays\n        this.triangles = this._triangles.subarray(0, this.trianglesLen);\n        this.halfedges = this._halfedges.subarray(0, this.trianglesLen);\n    }\n\n    /**\n     * Calculate an angle-based key for the edge hash used for advancing convex hull.\n     *\n     * @param {number} x\n     * @param {number} y\n     * @private\n     */\n    _hashKey(x, y) {\n        return Math.floor(pseudoAngle(x - this._cx, y - this._cy) * this._hashSize) % this._hashSize;\n    }\n\n    /**\n     * Flip an edge in a pair of triangles if it doesn't satisfy the Delaunay condition.\n     *\n     * @param {number} a\n     * @private\n     */\n    _legalize(a) {\n        const {_triangles: triangles, _halfedges: halfedges, coords} = this;\n\n        let i = 0;\n        let ar = 0;\n\n        // recursion eliminated with a fixed-size stack\n        while (true) {\n            const b = halfedges[a];\n\n            /* if the pair of triangles doesn't satisfy the Delaunay condition\n             * (p1 is inside the circumcircle of [p0, pl, pr]), flip them,\n             * then do the same check/flip recursively for the new pair of triangles\n             *\n             *           pl                    pl\n             *          /||\\                  /  \\\n             *       al/ || \\bl            al/    \\a\n             *        /  ||  \\              /      \\\n             *       /  a||b  \\    flip    /___ar___\\\n             *     p0\\   ||   /p1   =>   p0\\---bl---/p1\n             *        \\  ||  /              \\      /\n             *       ar\\ || /br             b\\    /br\n             *          \\||/                  \\  /\n             *           pr                    pr\n             */\n            const a0 = a - a % 3;\n            ar = a0 + (a + 2) % 3;\n\n            if (b === -1) { // convex hull edge\n                if (i === 0) break;\n                a = EDGE_STACK[--i];\n                continue;\n            }\n\n            const b0 = b - b % 3;\n            const al = a0 + (a + 1) % 3;\n            const bl = b0 + (b + 2) % 3;\n\n            const p0 = triangles[ar];\n            const pr = triangles[a];\n            const pl = triangles[al];\n            const p1 = triangles[bl];\n\n            const illegal = inCircle(\n                coords[2 * p0], coords[2 * p0 + 1],\n                coords[2 * pr], coords[2 * pr + 1],\n                coords[2 * pl], coords[2 * pl + 1],\n                coords[2 * p1], coords[2 * p1 + 1]);\n\n            if (illegal) {\n                triangles[a] = p1;\n                triangles[b] = p0;\n\n                const hbl = halfedges[bl];\n\n                // edge swapped on the other side of the hull (rare); fix the half-edge reference\n                if (hbl === -1) {\n                    let e = this._hullStart;\n                    do {\n                        if (this._hullTri[e] === bl) {\n                            this._hullTri[e] = a;\n                            break;\n                        }\n                        e = this._hullPrev[e];\n                    } while (e !== this._hullStart);\n                }\n                this._link(a, hbl);\n                this._link(b, halfedges[ar]);\n                this._link(ar, bl);\n\n                const br = b0 + (b + 1) % 3;\n\n                // don't worry about hitting the cap: it can only happen on extremely degenerate input\n                if (i < EDGE_STACK.length) {\n                    EDGE_STACK[i++] = br;\n                }\n            } else {\n                if (i === 0) break;\n                a = EDGE_STACK[--i];\n            }\n        }\n\n        return ar;\n    }\n\n    /**\n     * Link two half-edges to each other.\n     * @param {number} a\n     * @param {number} b\n     * @private\n     */\n    _link(a, b) {\n        this._halfedges[a] = b;\n        if (b !== -1) this._halfedges[b] = a;\n    }\n\n    /**\n     * Add a new triangle given vertex indices and adjacent half-edge ids.\n     *\n     * @param {number} i0\n     * @param {number} i1\n     * @param {number} i2\n     * @param {number} a\n     * @param {number} b\n     * @param {number} c\n     * @private\n     */\n    _addTriangle(i0, i1, i2, a, b, c) {\n        const t = this.trianglesLen;\n\n        this._triangles[t] = i0;\n        this._triangles[t + 1] = i1;\n        this._triangles[t + 2] = i2;\n\n        this._link(t, a);\n        this._link(t + 1, b);\n        this._link(t + 2, c);\n\n        this.trianglesLen += 3;\n\n        return t;\n    }\n}\n\n/**\n * Monotonically increases with real angle, but doesn't need expensive trigonometry.\n *\n * @param {number} dx\n * @param {number} dy\n */\nfunction pseudoAngle(dx, dy) {\n    const p = dx / (Math.abs(dx) + Math.abs(dy));\n    return (dy > 0 ? 3 - p : 1 + p) / 4; // [0..1]\n}\n\n/**\n * Squared distance between two points.\n *\n * @param {number} ax\n * @param {number} ay\n * @param {number} bx\n * @param {number} by\n */\nfunction dist(ax, ay, bx, by) {\n    const dx = ax - bx;\n    const dy = ay - by;\n    return dx * dx + dy * dy;\n}\n\n/**\n * Check whether point P is inside a circle formed by points A, B, C.\n *\n * @param {number} ax\n * @param {number} ay\n * @param {number} bx\n * @param {number} by\n * @param {number} cx\n * @param {number} cy\n * @param {number} px\n * @param {number} py\n */\nfunction inCircle(ax, ay, bx, by, cx, cy, px, py) {\n    const dx = ax - px;\n    const dy = ay - py;\n    const ex = bx - px;\n    const ey = by - py;\n    const fx = cx - px;\n    const fy = cy - py;\n\n    const ap = dx * dx + dy * dy;\n    const bp = ex * ex + ey * ey;\n    const cp = fx * fx + fy * fy;\n\n    return dx * (ey * cp - bp * fy) -\n           dy * (ex * cp - bp * fx) +\n           ap * (ex * fy - ey * fx) < 0;\n}\n\n/**\n * Squared radius of the circle formed by points A, B, C.\n *\n * @param {number} ax\n * @param {number} ay\n * @param {number} bx\n * @param {number} by\n * @param {number} cx\n * @param {number} cy\n */\nfunction circumradius(ax, ay, bx, by, cx, cy) {\n    const dx = bx - ax;\n    const dy = by - ay;\n    const ex = cx - ax;\n    const ey = cy - ay;\n\n    const bl = dx * dx + dy * dy;\n    const cl = ex * ex + ey * ey;\n    const d = 0.5 / (dx * ey - dy * ex);\n\n    const x = (ey * bl - dy * cl) * d;\n    const y = (dx * cl - ex * bl) * d;\n\n    return x * x + y * y;\n}\n\n/**\n * Get coordinates of a circumcenter for points A, B, C.\n *\n * @param {number} ax\n * @param {number} ay\n * @param {number} bx\n * @param {number} by\n * @param {number} cx\n * @param {number} cy\n */\nfunction circumcenter(ax, ay, bx, by, cx, cy) {\n    const dx = bx - ax;\n    const dy = by - ay;\n    const ex = cx - ax;\n    const ey = cy - ay;\n\n    const bl = dx * dx + dy * dy;\n    const cl = ex * ex + ey * ey;\n    const d = 0.5 / (dx * ey - dy * ex);\n\n    const x = ax + (ey * bl - dy * cl) * d;\n    const y = ay + (dx * cl - ex * bl) * d;\n\n    return {x, y};\n}\n\n/**\n * Sort points by distance via an array of point indices and an array of calculated distances.\n *\n * @param {Uint32Array} ids\n * @param {Float64Array} dists\n * @param {number} left\n * @param {number} right\n */\nfunction quicksort(ids, dists, left, right) {\n    if (right - left <= 20) {\n        for (let i = left + 1; i <= right; i++) {\n            const temp = ids[i];\n            const tempDist = dists[temp];\n            let j = i - 1;\n            while (j >= left && dists[ids[j]] > tempDist) ids[j + 1] = ids[j--];\n            ids[j + 1] = temp;\n        }\n    } else {\n        const median = (left + right) >> 1;\n        let i = left + 1;\n        let j = right;\n        swap(ids, median, i);\n        if (dists[ids[left]] > dists[ids[right]]) swap(ids, left, right);\n        if (dists[ids[i]] > dists[ids[right]]) swap(ids, i, right);\n        if (dists[ids[left]] > dists[ids[i]]) swap(ids, left, i);\n\n        const temp = ids[i];\n        const tempDist = dists[temp];\n        while (true) {\n            do i++; while (dists[ids[i]] < tempDist);\n            do j--; while (dists[ids[j]] > tempDist);\n            if (j < i) break;\n            swap(ids, i, j);\n        }\n        ids[left + 1] = ids[j];\n        ids[j] = temp;\n\n        if (right - i + 1 >= j - left) {\n            quicksort(ids, dists, i, right);\n            quicksort(ids, dists, left, j - 1);\n        } else {\n            quicksort(ids, dists, left, j - 1);\n            quicksort(ids, dists, i, right);\n        }\n    }\n}\n\n/**\n * @param {Uint32Array} arr\n * @param {number} i\n * @param {number} j\n */\nfunction swap(arr, i, j) {\n    const tmp = arr[i];\n    arr[i] = arr[j];\n    arr[j] = tmp;\n}\n\n/** @param {[number, number]} p */\nfunction defaultGetX(p) {\n    return p[0];\n}\n/** @param {[number, number]} p */\nfunction defaultGetY(p) {\n    return p[1];\n}\n"],"names":["EPSILON","EDGE_STACK","Delaunator","points","getX","defaultGetX","getY","defaultGetY","n","coords","i","p","maxTriangles","hullPrev","hullNext","hullTri","hullHash","minX","minY","maxX","maxY","x","y","cx","cy","i0","i1","i2","minDist","d","dist","i0x","i0y","i1x","i1y","minRadius","r","circumradius","i2x","i2y","quicksort","hull","j","d0","id","orient2d","center","circumcenter","hullSize","k","xp","yp","start","key","e","q","t","pseudoAngle","a","triangles","halfedges","ar","b","a0","b0","al","bl","p0","pr","pl","p1","inCircle","hbl","br","c","dx","dy","ax","ay","bx","by","px","py","ex","ey","fx","fy","ap","bp","cp","cl","ids","dists","left","right","temp","tempDist","median","swap","arr","tmp"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/index.cjs359.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const x=require("./index.cjs469.js"),M=require("./index.cjs470.js"),q=require("./index.cjs215.js"),p=require("./index.cjs275.js");function P(n,e,o=!0){const[t,s]=n,[[r,i],[c,l]]=e;return o&&(t===r&&s===i||t===c&&s===l)||(t-r)*(t-c)>0||(s-i)*(s-l)>0?!1:x.orient2d(r,i,c,l,t,s)===0}function y(n){const e=new M(n.length);for(const[o,t]of n)e.add(o,t);return e.finish(),{tree:e,points:n}}function m(n,{tree:e,points:o}){const t=[];for(let s=0;s<n.length;s++){const r=n[s],i=n[(s+1)%n.length],[c,l]=r,[a,g]=i;t.push(r);const d=e.range(Math.min(c,a),Math.min(l,g),Math.max(c,a),Math.max(l,g));if(d.length===0)continue;const f=[];for(const u of d){const[h,b]=o[u];P([h,b],[r,i])&&f.push(o[u])}f.length===1?t.push(f[0]):f.length>1&&(f.sort(([u,h],[b,L])=>(u-c)**2+(h-l)**2-((b-c)**2+(L-l)**2)),t.push(...f))}return t}function D(n,e,o=y(e)){return n.map(t=>m(t,o))}function k(n,e){const o=p.distance(...n),t=Math.ceil(o/e)-1,s=p.lineAngle(n);let r=n[0];const i=[r];for(let c=1;c<=t;c++)r=p.stepDistanceAngle(r,e,s),i.push(r);return i}function R(n,e){n=p.closeRing(n);let o=[];for(let t=0;t<n.length-1;t++)o=o.concat(k([n[t],n[t+1]],e));return o}function v(n,e){return n.map(o=>R(o,e))}function A(n,e){const o=[];for(let t=n[0]+e,s=0;t<=n[2];s++,t+=e)for(let r=n[1]+e,i=0;r<=n[3];i++,r+=e)o.push([t,r]);return o}function B(n){const e=n.map(t=>{const s=p.closeRing(t),r=s.length-1,i=new Float64Array(s.length*2);for(let c=0;c<s.length;c++)i[c*2]=s[c][0],i[c*2+1]=s[c][1];return{coords:i,length:r}}),o=q.computeBbox(n);return{closedRings:e,bbox:o}}function I(n,e,o){if(n<o.bbox[0]||e<o.bbox[1]||n>o.bbox[2]||e>o.bbox[3])return!1;let t=0;const s=o.closedRings;for(let r=0;r<s.length;r++){const i=s[r].coords,c=s[r].length;let l=i[0]-n,a=i[1]-e;for(let g=0;g<c;g++){const d=(g+1)*2,f=i[d]-n,u=i[d+1]-e;if(a===0&&u===0){if(f<=0&&l>=0||l<=0&&f>=0)return 0}else if(u>=0&&a<=0||u<=0&&a>=0){const h=x.orient2d(l,f,a,u,0,0);if(h===0)return 0;(h>0&&u>0&&a<=0||h<0&&u<=0&&a>0)&&t++}l=f,a=u}}return t%2!==0}function F(n,e,o){return o.some(t=>I(n,e,t))}exports.bboxToGridPoints=A;exports.buildKDBushPointIndex=y;exports.coordsInPolygonForInsidenessCheck=I;exports.coordsInPolygonsForInsidenessCheck=F;exports.interpolatePolygon=v;exports.interpolateRing=R;exports.pointOnLine=P;exports.preprocessPolygonForInsideCheck=B;exports.splitPolygonLines=D;exports.splitRingLines=m;
+//# sourceMappingURL=index.cjs359.js.map

package/dist/index.cjs359.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs359.js","sources":["../../../node_modules/@allmaps/triangulate/dist/shared.js"],"sourcesContent":["import { orient2d } from 'robust-predicates';\nimport KDBush from 'kdbush';\nimport { distance, stepDistanceAngle, lineAngle, closeRing, computeBbox } from '@allmaps/stdlib';\n// Split lines using points\nexport function pointOnLine(point, line, exclude = true) {\n    const [x, y] = point;\n    const [[x0, y0], [x1, y1]] = line;\n    if (exclude) {\n        if (x === x0 && y === y0)\n            return false;\n        if (x === x1 && y === y1)\n            return false;\n    }\n    if ((x - x0) * (x - x1) > 0)\n        return false;\n    if ((y - y0) * (y - y1) > 0)\n        return false;\n    return orient2d(x0, y0, x1, y1, x, y) === 0;\n}\nexport function buildKDBushPointIndex(points) {\n    const tree = new KDBush(points.length);\n    for (const [x, y] of points)\n        tree.add(x, y);\n    tree.finish();\n    return { tree, points };\n}\nexport function splitRingLines(ring, { tree, points }) {\n    const result = [];\n    for (let i = 0; i < ring.length; i++) {\n        const p0 = ring[i];\n        const p1 = ring[(i + 1) % ring.length];\n        const [x0, y0] = p0;\n        const [x1, y1] = p1;\n        result.push(p0);\n        const ids = tree.range(Math.min(x0, x1), Math.min(y0, y1), Math.max(x0, x1), Math.max(y0, y1));\n        if (ids.length === 0)\n            continue;\n        const hits = [];\n        for (const id of ids) {\n            const [x, y] = points[id];\n            if (pointOnLine([x, y], [p0, p1]))\n                hits.push(points[id]);\n        }\n        if (hits.length === 1) {\n            result.push(hits[0]);\n        }\n        else if (hits.length > 1) {\n            hits.sort(([ax, ay], [bx, by]) => (ax - x0) ** 2 + (ay - y0) ** 2 - ((bx - x0) ** 2 + (by - y0) ** 2));\n            result.push(...hits);\n        }\n    }\n    return result;\n}\nexport function splitPolygonLines(polygon, points, index = buildKDBushPointIndex(points)) {\n    return polygon.map((ring) => splitRingLines(ring, index));\n}\n// Interpolate line using distance\n// Return an array of points containing the first line point,\n// and betwen the first and last line point other points every `dist`\nfunction interpolateLine(line, dist) {\n    const lineDistance = distance(...line);\n    // Note: ciel - 1 instead of floor, such that for round numbers we don't include the last step\n    const steps = Math.ceil(lineDistance / dist) - 1;\n    const angle = lineAngle(line);\n    let currentPoint = line[0];\n    const result = [currentPoint];\n    for (let step = 1; step <= steps; step++) {\n        currentPoint = stepDistanceAngle(currentPoint, dist, angle);\n        result.push(currentPoint);\n    }\n    // Note: the last nextpoint, which is also line[1], is not pushed\n    return result;\n}\n// Return an array of points containing the ring points,\n// and between every pair of ring points other points every `dist`\nexport function interpolateRing(ring, dist) {\n    ring = closeRing(ring);\n    let result = [];\n    for (let i = 0; i < ring.length - 1; i++) {\n        result = result.concat(interpolateLine([ring[i], ring[i + 1]], dist));\n    }\n    return result;\n}\nexport function interpolatePolygon(polygon, dist) {\n    return polygon.map((ring) => interpolateRing(ring, dist));\n}\n// Grid\nexport function bboxToGridPoints(bbox, gridSize) {\n    const grid = [];\n    for (let x = bbox[0] + gridSize, i = 0; x <= bbox[2]; i++, x += gridSize) {\n        for (let y = bbox[1] + gridSize, j = 0; y <= bbox[3]; j++, y += gridSize) {\n            grid.push([x, y]);\n        }\n    }\n    return grid;\n}\n// Point inside triangle\nexport function preprocessPolygonForInsideCheck(polygon) {\n    const closedRings = polygon.map((ring) => {\n        const closedRing = closeRing(ring);\n        const ringLength = closedRing.length - 1;\n        // Flat typed array: [x0, y0, x1, y1, ...] — avoids nested array pointer chasing\n        const coords = new Float64Array(closedRing.length * 2);\n        for (let i = 0; i < closedRing.length; i++) {\n            coords[i * 2] = closedRing[i][0];\n            coords[i * 2 + 1] = closedRing[i][1];\n        }\n        return { coords, length: ringLength };\n    });\n    const bbox = computeBbox(polygon);\n    return { closedRings, bbox };\n}\n// Improved from point-in-polygon-hao package\n// https://github.com/rowanwins/point-in-polygon-hao/blob/938b2be31d326c52c8f6cffbbb1c59bae4d609bc/src/index.js\n// Returns true if point is inside of polygon with holes\n//\n// Speedups:\n// - Reuse preprocessed polygon\n// - Avoid point allocation (and it's garbage collection) and use coordinates\nexport function coordsInPolygonForInsidenessCheck(x, y, polygonForInsidenessCheck) {\n    if (x < polygonForInsidenessCheck.bbox[0] ||\n        y < polygonForInsidenessCheck.bbox[1] ||\n        x > polygonForInsidenessCheck.bbox[2] ||\n        y > polygonForInsidenessCheck.bbox[3])\n        return false;\n    let k = 0;\n    const closedRings = polygonForInsidenessCheck.closedRings;\n    for (let i = 0; i < closedRings.length; i++) {\n        const coords = closedRings[i].coords;\n        const length = closedRings[i].length;\n        let u1 = coords[0] - x;\n        let v1 = coords[1] - y;\n        for (let ii = 0; ii < length; ii++) {\n            const base = (ii + 1) * 2;\n            const u2 = coords[base] - x;\n            const v2 = coords[base + 1] - y;\n            if (v1 === 0 && v2 === 0) {\n                if ((u2 <= 0 && u1 >= 0) || (u1 <= 0 && u2 >= 0))\n                    return 0;\n            }\n            else if ((v2 >= 0 && v1 <= 0) || (v2 <= 0 && v1 >= 0)) {\n                const f = orient2d(u1, u2, v1, v2, 0, 0);\n                if (f === 0)\n                    return 0;\n                if ((f > 0 && v2 > 0 && v1 <= 0) || (f < 0 && v2 <= 0 && v1 > 0))\n                    k++;\n            }\n            u1 = u2;\n            v1 = v2;\n        }\n    }\n    return k % 2 !== 0;\n}\nexport function coordsInPolygonsForInsidenessCheck(x, y, polygonsForInsidenessChecks) {\n    return polygonsForInsidenessChecks.some((polygonForInsidenessChecks) => coordsInPolygonForInsidenessCheck(x, y, polygonForInsidenessChecks));\n}\n"],"names":["pointOnLine","point","line","exclude","x","y","x0","y0","x1","y1","orient2d","buildKDBushPointIndex","points","tree","KDBush","splitRingLines","ring","result","i","p0","p1","ids","hits","id","ax","ay","bx","by","splitPolygonLines","polygon","index","interpolateLine","dist","lineDistance","distance","steps","angle","lineAngle","currentPoint","step","stepDistanceAngle","interpolateRing","closeRing","interpolatePolygon","bboxToGridPoints","bbox","gridSize","grid","j","preprocessPolygonForInsideCheck","closedRings","closedRing","ringLength","coords","computeBbox","coordsInPolygonForInsidenessCheck","polygonForInsidenessCheck","k","length","u1","v1","ii","base","u2","v2","f","coordsInPolygonsForInsidenessCheck","polygonsForInsidenessChecks","polygonForInsidenessChecks"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/index.cjs360.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const h=require("./index.cjs215.js"),a=require("./index.cjs275.js"),f=require("./index.cjs217.js"),w=require("./index.cjs317.js"),g=require("./index.cjs373.js"),v=require("./index.cjs367.js"),k=require("./index.cjs368.js"),P=require("./index.cjs369.js"),O=require("./index.cjs370.js"),B=require("./index.cjs371.js"),c=require("./index.cjs372.js"),F=require("./index.cjs506.js"),I=require("./index.cjs507.js"),m=require("./index.cjs224.js"),p=require("./index.cjs374.js"),u=require("./index.cjs361.js");class y{generalGcpsInternal;sourcePointsInternal;destinationPointsInternal;type;transformerOptions;forwardTransformation;backwardTransformation;constructor(r,n="polynomial",e){if(this.transformerOptions=f.mergeOptions(m.defaultGeneralGcpTransformerOptions,e),r.length===0)throw new Error("No control points");this.generalGcpsInternal=r,this.sourcePointsInternal=this.generalGcpsInternal.map(t=>{const i=this.transformerOptions.differentHandedness?a.flipY(t.source):t.source;return this.transformerOptions.preForward(i)}),this.destinationPointsInternal=this.generalGcpsInternal.map(t=>this.transformerOptions.preBackward(t.destination)),this.type=n}getForwardTransformationInternal(){return this.forwardTransformation||(this.forwardTransformation=this.createTransformation(this.sourcePointsInternal,this.destinationPointsInternal)),this.forwardTransformation}getBackwardTransformationInternal(){return this.backwardTransformation||(this.backwardTransformation=this.createTransformation(this.destinationPointsInternal,this.sourcePointsInternal)),this.backwardTransformation}createTransformation(r,n){if(this.type==="straight")return new g.Straight(r,n);if(this.type==="helmert")return new v.Helmert(r,n);if(this.type==="polynomial1"||this.type==="polynomial")return new k.Polynomial1(r,n);if(this.type==="polynomial2")return new P.Polynomial2(r,n);if(this.type==="polynomial3")return new O.Polynomial3(r,n);if(this.type==="projective")return new B.Projective(r,n);if(this.type==="thinPlateSpline")return new c.RBF(r,n,F.thinPlateKernel,I.euclideanNorm,"thinPlateSpline");if(this.type==="linear")return new c.RBF(r,n,F.linearKernel,I.euclideanNorm,"linear");throw new Error(`Unsupported transformation type: ${this.type}`)}transformForwardInternal(r,n,e=u.generalGcpToPointForForward){let t=f.mergeOptions(this.transformerOptions,n);if(this.isNonWarping()&&(t=f.mergeOptions(t,{maxDepth:0})),t.isMultiGeometry){if(t&&(t=f.mergeOptions(t,{isMultiGeometry:!1})),a.isMultiPoint(r))return r.map(i=>this.transformPointForwardInternal(i,t,e));if(a.isMultiLineString(r))return r.map(i=>this.transformLineStringForwardInternal(i,t,e));if(a.isMultiPolygon(r))return r.map(i=>this.transformPolygonForwardInternal(i,t,e));throw new Error("Geometry type not supported")}else{if(a.isPoint(r))return this.transformPointForwardInternal(r,t,e);if(a.isLineString(r))return this.transformLineStringForwardInternal(r,t,e);if(a.isPolygon(r))return this.transformPolygonForwardInternal(r,t,e);throw new Error("Geometry type not supported")}}transformBackwardInternal(r,n,e=u.generalGcpToPointForBackward){let t=f.mergeOptions(this.transformerOptions,n);if(this.isNonWarping()&&(t=f.mergeOptions(t,{maxDepth:0})),t.isMultiGeometry){if(t&&(t=f.mergeOptions(t,{isMultiGeometry:!1})),a.isMultiPoint(r))return r.map(i=>this.transformPointBackwardInternal(i,t,e));if(a.isMultiLineString(r))return r.map(i=>this.transformLineStringBackwardInternal(i,t,e));if(a.isMultiPolygon(r))return r.map(i=>this.transformPolygonBackwardInternal(i,t,e));throw new Error("Geometry type not supported")}else{if(a.isPoint(r))return this.transformPointBackwardInternal(r,t,e);if(a.isLineString(r))return this.transformLineStringBackwardInternal(r,t,e);if(a.isPolygon(r))return this.transformPolygonBackwardInternal(r,t,e);throw new Error("Geometry type not supported")}}transformPointForwardInternal(r,n,e=u.generalGcpToPointForForward){const t=this.getForwardTransformationInternal();let i=this.transformerOptions.differentHandedness?a.flipY(r):r;i=n.preForward(i);let o=t.evaluateFunction(i);o=n.postForward(o);let s,l,d=new Map;return n.distortionMeasures.length>0&&(s=t.evaluatePartialDerivativeX(i),l=t.evaluatePartialDerivativeY(i),d=w.computeDistortionsFromPartialDerivatives(n.distortionMeasures,s,l,n.referenceScale)),e({source:r,destination:o,partialDerivativeX:s,partialDerivativeY:l,distortions:d})}transformPointBackwardInternal(r,n,e=u.generalGcpToPointForBackward){const t=this.getBackwardTransformationInternal(),i=n.preBackward(r);let o=t.evaluateFunction(i);o=n.postBackward(o),o=this.transformerOptions.differentHandedness?a.flipY(o):o;let s,l,d=new Map;return n.distortionMeasures.length>0&&(s=t.evaluatePartialDerivativeX(i),s=this.transformerOptions.differentHandedness?a.flipY(s):s,l=t.evaluatePartialDerivativeY(i),l=this.transformerOptions.differentHandedness?a.flipY(l):l,d=w.computeDistortionsFromPartialDerivatives(n.distortionMeasures,s,l,n.referenceScale)),e({source:o,destination:i,partialDerivativeX:s,partialDerivativeY:l,distortions:d})}transformLineStringForwardInternal(r,n,e){return p.refineLineString(r,t=>this.transformPointForwardInternal(t,n),m.refinementOptionsFromForwardTransformOptions(n)).map(t=>e(t))}transformLineStringBackwardInternal(r,n,e){return p.refineLineString(r,t=>this.transformPointBackwardInternal(t,n),m.refinementOptionsFromBackwardTransformOptions(n)).map(t=>e(u.invertGeneralGcp(t)))}transformRingForwardInternal(r,n,e){return p.refineRing(r,t=>this.transformPointForwardInternal(t,n),m.refinementOptionsFromForwardTransformOptions(n)).map(t=>e(t))}transformRingBackwardInternal(r,n,e){return p.refineRing(r,t=>this.transformPointBackwardInternal(t,n),m.refinementOptionsFromBackwardTransformOptions(n)).map(t=>e(u.invertGeneralGcp(t)))}transformPolygonForwardInternal(r,n,e){return r.map(t=>this.transformRingForwardInternal(t,n,e))}transformPolygonBackwardInternal(r,n,e){return r.map(t=>this.transformRingBackwardInternal(t,n,e))}isNonWarping(){return this.transformerOptions.postForward===this.transformerOptions.preBackward&&this.transformerOptions.postBackward===this.transformerOptions.preForward&&m.nonWarpingTransformationTypes.includes(this.type)}getForwardTransformationResolutionInternal(r,n){const e=f.mergeOptions(this.transformerOptions,n);return r=r??h.computeBbox(this.sourcePointsInternal),p.getSourceRefinementResolution(r,t=>this.transformPointForwardInternal(t,e),m.refinementOptionsFromForwardTransformOptions(e))}getBackwardTransformationResolutionInternal(r,n){const e=f.mergeOptions(this.transformerOptions,n);return r=r??h.computeBbox(this.destinationPointsInternal),p.getSourceRefinementResolution(r,t=>this.transformPointBackwardInternal(t,e),m.refinementOptionsFromBackwardTransformOptions(e))}}exports.BaseGcpTransformer=y;
+//# sourceMappingURL=index.cjs360.js.map

package/dist/index.cjs360.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs360.js","sources":["../../../node_modules/@allmaps/transform/dist/transformers/BaseGcpTransformer.js"],"sourcesContent":["import { isPoint, isLineString, isPolygon, isMultiPoint, isMultiLineString, isMultiPolygon, flipY, mergeOptions, computeBbox } from '@allmaps/stdlib';\nimport { computeDistortionsFromPartialDerivatives } from '../shared/distortion.js';\nimport { Straight } from '../transformation-types/Straight.js';\nimport { Helmert } from '../transformation-types/Helmert.js';\nimport { Polynomial1 } from '../transformation-types/Polynomial1.js';\nimport { Polynomial2 } from '../transformation-types/Polynomial2.js';\nimport { Polynomial3 } from '../transformation-types/Polynomial3.js';\nimport { Projective } from '../transformation-types/Projective.js';\nimport { RBF } from '../transformation-types/RBF.js';\nimport { linearKernel, thinPlateKernel } from '../shared/kernel-functions.js';\nimport { euclideanNorm } from '../shared/norm-functions.js';\nimport { defaultGeneralGcpTransformerOptions, nonWarpingTransformationTypes, refinementOptionsFromBackwardTransformOptions, refinementOptionsFromForwardTransformOptions } from '../shared/transform-functions.js';\nimport { refineLineString, refineRing, getSourceRefinementResolution } from '../shared/refinement-functions.js';\nimport { generalGcpToPointForForward, generalGcpToPointForBackward, invertGeneralGcp } from '../shared/conversion-functions.js';\n/**\n * Abstract class for Ground Control Point Transformers.\n *\n * This class contains all logic to transform geometries\n * made available trough the GeneralGcpTransform and GcpTransform classes.\n *\n * The extending GeneralGcpTransform class handles the general case where:\n * - We read in Ground Control Points using the GeneralGcp type, with `source` and `destination` fields.\n * - We use the terms 'forward' and 'backward' for the two transformations.\n * - Both source and destination space are exected to be 2D cartesian spaces with the same handedness (x- and y-axes have the same orientations).\n *\n * The extending GcpTransform class handles the typical Allmaps case where:\n * - We read in Ground Control Points using the Gcp type, with `resource` and `geo` fields.\n * - We use the terms 'toGeo' for the 'forward' transformation and 'toResource' for the 'backward' transformation.\n * - The `differentHandedness` setting is `true` by default, since we expect the resource coordinates to identify pixels on an image, with origin in the top left and the y-axis pointing down.\n * */\nexport class BaseGcpTransformer {\n    generalGcpsInternal;\n    sourcePointsInternal;\n    destinationPointsInternal;\n    type;\n    transformerOptions;\n    forwardTransformation;\n    backwardTransformation;\n    /**\n     * Create a BaseGcpTransformer\n     *\n     * @param generalGcps - An array of General Ground Control Points (GCPs)\n     * @param type - The transformation type\n     * @param partialGeneralGcpTransformerOptions - General GCP Transformer options\n     */ constructor(generalGcps, type = 'polynomial', partialGeneralGcpTransformerOptions) {\n        this.transformerOptions = mergeOptions(defaultGeneralGcpTransformerOptions, partialGeneralGcpTransformerOptions);\n        if (generalGcps.length === 0) {\n            throw new Error('No control points');\n        }\n        this.generalGcpsInternal = generalGcps;\n        this.sourcePointsInternal = this.generalGcpsInternal.map((generalGcp) => {\n            const source = this.transformerOptions.differentHandedness\n                ? flipY(generalGcp.source)\n                : generalGcp.source;\n            return this.transformerOptions.preForward(source);\n        });\n        this.destinationPointsInternal = this.generalGcpsInternal.map((generalGcp) => this.transformerOptions.preBackward(generalGcp.destination));\n        this.type = type;\n    }\n    /**\n     * Get the forward transformation. Create if it doesn't exist yet.\n     */\n    getForwardTransformationInternal() {\n        if (!this.forwardTransformation) {\n            this.forwardTransformation = this.createTransformation(this.sourcePointsInternal, this.destinationPointsInternal);\n        }\n        return this.forwardTransformation;\n    }\n    /**\n     * Get the backward transformation. Create if it doesn't exist yet.\n     */\n    getBackwardTransformationInternal() {\n        if (!this.backwardTransformation) {\n            this.backwardTransformation = this.createTransformation(this.destinationPointsInternal, this.sourcePointsInternal);\n        }\n        return this.backwardTransformation;\n    }\n    /**\n     * Create the (forward or backward) transformation.\n     *\n     * Results in forward transformation if source and destination points are entered as such.\n     * Results in backward if source points are entered for destination points and vice versa.\n     *\n     * Results in a transformation of this instance's transformation type.\n     *\n     * @param sourcePoints - source points\n     * @param destinationPoints - destination points\n     * @returns Transformation\n     */\n    createTransformation(sourcePoints, destinationPoints) {\n        if (this.type === 'straight') {\n            return new Straight(sourcePoints, destinationPoints);\n        }\n        else if (this.type === 'helmert') {\n            return new Helmert(sourcePoints, destinationPoints);\n        }\n        else if (this.type === 'polynomial1' || this.type === 'polynomial') {\n            return new Polynomial1(sourcePoints, destinationPoints);\n        }\n        else if (this.type === 'polynomial2') {\n            return new Polynomial2(sourcePoints, destinationPoints);\n        }\n        else if (this.type === 'polynomial3') {\n            return new Polynomial3(sourcePoints, destinationPoints);\n        }\n        else if (this.type === 'projective') {\n            return new Projective(sourcePoints, destinationPoints);\n        }\n        else if (this.type === 'thinPlateSpline') {\n            return new RBF(sourcePoints, destinationPoints, thinPlateKernel, euclideanNorm, 'thinPlateSpline');\n        }\n        else if (this.type === 'linear') {\n            return new RBF(sourcePoints, destinationPoints, linearKernel, euclideanNorm, 'linear');\n        }\n        else {\n            throw new Error(`Unsupported transformation type: ${this.type}`);\n        }\n    }\n    /**\n     * Transform a geometry forward from source space to destination space\n     *\n     * @param sourceGeometry - Geometry to transform\n     * @param partialGeneralGcpTransformOptions - General GCP Transform options\n     * @param generalGcpToP - Return type function\n     * @returns Forward transform of input geometry\n     */\n    transformForwardInternal(sourceGeometry, partialGeneralGcpTransformOptions, generalGcpToP = generalGcpToPointForForward) {\n        let transformOptions = mergeOptions(this.transformerOptions, partialGeneralGcpTransformOptions);\n        if (this.isNonWarping()) {\n            transformOptions = mergeOptions(transformOptions, { maxDepth: 0 });\n        }\n        if (!transformOptions.isMultiGeometry) {\n            if (isPoint(sourceGeometry)) {\n                return this.transformPointForwardInternal(sourceGeometry, transformOptions, generalGcpToP);\n            }\n            else if (isLineString(sourceGeometry)) {\n                return this.transformLineStringForwardInternal(sourceGeometry, transformOptions, generalGcpToP);\n            }\n            else if (isPolygon(sourceGeometry)) {\n                return this.transformPolygonForwardInternal(sourceGeometry, transformOptions, generalGcpToP);\n            }\n            else {\n                throw new Error('Geometry type not supported');\n            }\n        }\n        else {\n            if (transformOptions) {\n                transformOptions = mergeOptions(transformOptions, {\n                    isMultiGeometry: false\n                }); // false for piecewise single geometries\n            }\n            if (isMultiPoint(sourceGeometry)) {\n                return sourceGeometry.map((sourcePoint) => this.transformPointForwardInternal(sourcePoint, transformOptions, generalGcpToP));\n            }\n            else if (isMultiLineString(sourceGeometry)) {\n                return sourceGeometry.map((sourceLineString) => this.transformLineStringForwardInternal(sourceLineString, transformOptions, generalGcpToP));\n            }\n            else if (isMultiPolygon(sourceGeometry)) {\n                return sourceGeometry.map((sourcePolygon) => this.transformPolygonForwardInternal(sourcePolygon, transformOptions, generalGcpToP));\n            }\n            else {\n                throw new Error('Geometry type not supported');\n            }\n        }\n    }\n    /**\n     * Transform a geometry backward from destination space to source space\n     *\n     * @param destinationGeometry - Geometry to transform\n     * @param partialGeneralGcpTransformOptions - General GCP Transform options\n     * @param generalGcpToP - Return type function\n     * @returns Backward transform of input geometry\n     */\n    transformBackwardInternal(destinationGeometry, partialGeneralGcpTransformOptions, generalGcpToP = generalGcpToPointForBackward) {\n        let transformOptions = mergeOptions(this.transformerOptions, partialGeneralGcpTransformOptions);\n        if (this.isNonWarping()) {\n            transformOptions = mergeOptions(transformOptions, { maxDepth: 0 });\n        }\n        if (!transformOptions.isMultiGeometry) {\n            if (isPoint(destinationGeometry)) {\n                return this.transformPointBackwardInternal(destinationGeometry, transformOptions, generalGcpToP);\n            }\n            else if (isLineString(destinationGeometry)) {\n                return this.transformLineStringBackwardInternal(destinationGeometry, transformOptions, generalGcpToP);\n            }\n            else if (isPolygon(destinationGeometry)) {\n                return this.transformPolygonBackwardInternal(destinationGeometry, transformOptions, generalGcpToP);\n            }\n            else {\n                throw new Error('Geometry type not supported');\n            }\n        }\n        else {\n            if (transformOptions) {\n                transformOptions = mergeOptions(transformOptions, {\n                    isMultiGeometry: false\n                }); // false for piecewise single geometries\n            }\n            if (isMultiPoint(destinationGeometry)) {\n                return destinationGeometry.map((destinationPoint) => this.transformPointBackwardInternal(destinationPoint, transformOptions, generalGcpToP));\n            }\n            else if (isMultiLineString(destinationGeometry)) {\n                return destinationGeometry.map((destinationLineString) => this.transformLineStringBackwardInternal(destinationLineString, transformOptions, generalGcpToP));\n            }\n            else if (isMultiPolygon(destinationGeometry)) {\n                return destinationGeometry.map((destinationPolygon) => this.transformPolygonBackwardInternal(destinationPolygon, transformOptions, generalGcpToP));\n            }\n            else {\n                throw new Error('Geometry type not supported');\n            }\n        }\n    }\n    // Handle specific geometries\n    transformPointForwardInternal(point, generalGcpTransformOptions, generalGcpToP = generalGcpToPointForForward) {\n        const forwardTransformation = this.getForwardTransformationInternal();\n        let source = this.transformerOptions.differentHandedness\n            ? flipY(point)\n            : point;\n        source = generalGcpTransformOptions.preForward(source);\n        let destination = forwardTransformation.evaluateFunction(source);\n        destination = generalGcpTransformOptions.postForward(destination);\n        let partialDerivativeX = undefined;\n        let partialDerivativeY = undefined;\n        let distortions = new Map();\n        if (generalGcpTransformOptions.distortionMeasures.length > 0) {\n            partialDerivativeX =\n                forwardTransformation.evaluatePartialDerivativeX(source);\n            partialDerivativeY =\n                forwardTransformation.evaluatePartialDerivativeY(source);\n            distortions = computeDistortionsFromPartialDerivatives(generalGcpTransformOptions.distortionMeasures, partialDerivativeX, partialDerivativeY, generalGcpTransformOptions.referenceScale);\n        }\n        return generalGcpToP({\n            source: point, // don't apply differentHandedness here, this is only internally.\n            destination,\n            partialDerivativeX,\n            partialDerivativeY,\n            distortions\n        });\n    }\n    transformPointBackwardInternal(point, generalGcpTransformOptions, generalGcpToP = generalGcpToPointForBackward) {\n        const backwardTransformation = this.getBackwardTransformationInternal();\n        const destination = generalGcpTransformOptions.preBackward(point);\n        let source = backwardTransformation.evaluateFunction(destination);\n        // apply differentHandedness here again, so it has been applied twice in total and is undone now.\n        source = generalGcpTransformOptions.postBackward(source);\n        source = this.transformerOptions.differentHandedness\n            ? flipY(source)\n            : source;\n        let partialDerivativeX = undefined;\n        let partialDerivativeY = undefined;\n        let distortions = new Map();\n        if (generalGcpTransformOptions.distortionMeasures.length > 0) {\n            partialDerivativeX =\n                backwardTransformation.evaluatePartialDerivativeX(destination);\n            partialDerivativeX = this.transformerOptions.differentHandedness\n                ? flipY(partialDerivativeX)\n                : partialDerivativeX;\n            partialDerivativeY =\n                backwardTransformation.evaluatePartialDerivativeY(destination);\n            partialDerivativeY = this.transformerOptions.differentHandedness\n                ? flipY(partialDerivativeY)\n                : partialDerivativeY;\n            distortions = computeDistortionsFromPartialDerivatives(generalGcpTransformOptions.distortionMeasures, partialDerivativeX, partialDerivativeY, generalGcpTransformOptions.referenceScale);\n        }\n        return generalGcpToP({\n            source,\n            destination,\n            partialDerivativeX,\n            partialDerivativeY,\n            distortions\n        });\n    }\n    transformLineStringForwardInternal(lineString, generalGcpTransformOptions, generalGcpToP) {\n        return refineLineString(lineString, (p) => this.transformPointForwardInternal(p, generalGcpTransformOptions), refinementOptionsFromForwardTransformOptions(generalGcpTransformOptions)).map((generalGcp) => generalGcpToP(generalGcp));\n    }\n    transformLineStringBackwardInternal(lineString, generalGcpTransformOptions, generalGcpToP) {\n        return refineLineString(lineString, (p) => this.transformPointBackwardInternal(p, generalGcpTransformOptions), refinementOptionsFromBackwardTransformOptions(generalGcpTransformOptions)).map((generalGcp) => generalGcpToP(invertGeneralGcp(generalGcp)));\n    }\n    transformRingForwardInternal(ring, generalGcpTransformOptions, generalGcpToP) {\n        return refineRing(ring, (p) => this.transformPointForwardInternal(p, generalGcpTransformOptions), refinementOptionsFromForwardTransformOptions(generalGcpTransformOptions)).map((generalGcp) => generalGcpToP(generalGcp));\n    }\n    transformRingBackwardInternal(ring, generalGcpTransformOptions, generalGcpToP) {\n        return refineRing(ring, (p) => this.transformPointBackwardInternal(p, generalGcpTransformOptions), refinementOptionsFromBackwardTransformOptions(generalGcpTransformOptions)).map((generalGcp) => generalGcpToP(invertGeneralGcp(generalGcp)));\n    }\n    transformPolygonForwardInternal(polygon, generalGcpTransformOptions, generalGcpToP) {\n        return polygon.map((ring) => {\n            return this.transformRingForwardInternal(ring, generalGcpTransformOptions, generalGcpToP);\n        });\n    }\n    transformPolygonBackwardInternal(polygon, generalGcpTransformOptions, generalGcpToP) {\n        return polygon.map((ring) => {\n            return this.transformRingBackwardInternal(ring, generalGcpTransformOptions, generalGcpToP);\n        });\n    }\n    isNonWarping() {\n        return (this.transformerOptions.postForward ===\n            this.transformerOptions.preBackward &&\n            this.transformerOptions.postBackward ===\n                this.transformerOptions.preForward &&\n            nonWarpingTransformationTypes.includes(this.type));\n    }\n    getForwardTransformationResolutionInternal(sourceBbox, partialGeneralGcpTransformOptions) {\n        const transformOptions = mergeOptions(this.transformerOptions, partialGeneralGcpTransformOptions);\n        sourceBbox = sourceBbox ?? computeBbox(this.sourcePointsInternal);\n        return getSourceRefinementResolution(sourceBbox, (p) => this.transformPointForwardInternal(p, transformOptions), refinementOptionsFromForwardTransformOptions(transformOptions));\n    }\n    getBackwardTransformationResolutionInternal(destinationBbox, partialGeneralGcpTransformOptions) {\n        const transformOptions = mergeOptions(this.transformerOptions, partialGeneralGcpTransformOptions);\n        destinationBbox =\n            destinationBbox ?? computeBbox(this.destinationPointsInternal);\n        return getSourceRefinementResolution(destinationBbox, (p) => this.transformPointBackwardInternal(p, transformOptions), refinementOptionsFromBackwardTransformOptions(transformOptions));\n    }\n}\n"],"names":["BaseGcpTransformer","generalGcps","type","partialGeneralGcpTransformerOptions","mergeOptions","defaultGeneralGcpTransformerOptions","generalGcp","source","flipY","sourcePoints","destinationPoints","Straight","Helmert","Polynomial1","Polynomial2","Polynomial3","Projective","RBF","thinPlateKernel","euclideanNorm","linearKernel","sourceGeometry","partialGeneralGcpTransformOptions","generalGcpToP","generalGcpToPointForForward","transformOptions","isMultiPoint","sourcePoint","isMultiLineString","sourceLineString","isMultiPolygon","sourcePolygon","isPoint","isLineString","isPolygon","destinationGeometry","generalGcpToPointForBackward","destinationPoint","destinationLineString","destinationPolygon","point","generalGcpTransformOptions","forwardTransformation","destination","partialDerivativeX","partialDerivativeY","distortions","computeDistortionsFromPartialDerivatives","backwardTransformation","lineString","refineLineString","p","refinementOptionsFromForwardTransformOptions","refinementOptionsFromBackwardTransformOptions","invertGeneralGcp","ring","refineRing","polygon","nonWarpingTransformationTypes","sourceBbox","computeBbox","getSourceRefinementResolution","destinationBbox"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/index.cjs361.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function r(o){return{source:o.destination,destination:o.source}}function t(o){return o.destination}function i(o){return o.source}function e(o){return o.geo}function n(o){return o.resource}function a(o){return{resource:o.source,geo:o.destination,partialDerivativeX:o.partialDerivativeX,partialDerivativeY:o.partialDerivativeY,distortions:o.distortions,distortion:o.distortion}}function s(o){return{source:o.resource,destination:o.geo,partialDerivativeX:o.partialDerivativeX,partialDerivativeY:o.partialDerivativeY,distortions:o.distortions,distortion:o.distortion}}exports.gcpToGeneralGcp=s;exports.gcpToPointForToGeo=e;exports.gcpToPointForToResource=n;exports.generalGcpToGcp=a;exports.generalGcpToPointForBackward=i;exports.generalGcpToPointForForward=t;exports.invertGeneralGcp=r;
+//# sourceMappingURL=index.cjs361.js.map

package/dist/index.cjs361.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs361.js","sources":["../../../node_modules/@allmaps/transform/dist/shared/conversion-functions.js"],"sourcesContent":["// Invert\nexport function invertGeneralGcp(generalGcp) {\n    return { source: generalGcp.destination, destination: generalGcp.source };\n}\nexport function invertGcp(gcp) {\n    return { resource: gcp.geo, geo: gcp.resource };\n}\n// Select\nexport function generalGcpToPointForForward(generalGcp) {\n    return generalGcp.destination;\n}\nexport function generalGcpToPointForBackward(generalGcp) {\n    return generalGcp.source;\n}\nexport function gcpToPointForToGeo(gcp) {\n    return gcp.geo;\n}\nexport function gcpToPointForToResource(gcp) {\n    return gcp.resource;\n}\n// GeneralGcp <> G\nexport function generalGcpToGcp(generalGcp) {\n    return {\n        resource: generalGcp.source,\n        geo: generalGcp.destination,\n        partialDerivativeX: generalGcp.partialDerivativeX,\n        partialDerivativeY: generalGcp.partialDerivativeY,\n        distortions: generalGcp.distortions,\n        distortion: generalGcp.distortion\n    };\n}\nexport function gcpToGeneralGcp(gcp) {\n    return {\n        source: gcp.resource,\n        destination: gcp.geo,\n        partialDerivativeX: gcp.partialDerivativeX,\n        partialDerivativeY: gcp.partialDerivativeY,\n        distortions: gcp.distortions,\n        distortion: gcp.distortion\n    };\n}\n// TransformationType\n// TODO: implement this as a separate, callable function in @allmaps/annotation?\nexport function transformationTypeToTypeAndOrder(transformationType) {\n    if (transformationType === 'polynomial' ||\n        transformationType === 'polynomial1') {\n        return {\n            type: 'polynomial',\n            options: {\n                order: 1\n            }\n        };\n    }\n    else if (transformationType === 'polynomial2') {\n        return {\n            type: 'polynomial',\n            options: {\n                order: 2\n            }\n        };\n    }\n    else if (transformationType === 'polynomial3') {\n        return {\n            type: 'polynomial',\n            options: {\n                order: 3\n            }\n        };\n    }\n    else {\n        return {\n            type: transformationType\n        };\n    }\n}\nexport function typeAndOrderToTransformationType(transformation) {\n    const type = transformation.type;\n    const order = transformation.options?.order;\n    let transformationType;\n    if (type == 'polynomial1' || type === 'polynomial') {\n        transformationType = 'polynomial1';\n    }\n    else if (type == 'polynomial2' || (type === 'polynomial' && order === 2)) {\n        transformationType = 'polynomial2';\n    }\n    else if (type == 'polynomial3' || (type === 'polynomial' && order === 3)) {\n        transformationType = 'polynomial3';\n    }\n    else if (type === 'thinPlateSpline') {\n        transformationType = type;\n    }\n    else if (type === 'linear') {\n        transformationType = type;\n    }\n    else if (type === 'helmert') {\n        transformationType = type;\n    }\n    else if (type === 'projective') {\n        transformationType = type;\n    }\n    else {\n        throw new Error('Unrecognised transformationType.');\n    }\n    return transformationType;\n}\n"],"names":["invertGeneralGcp","generalGcp","generalGcpToPointForForward","generalGcpToPointForBackward","gcpToPointForToGeo","gcp","gcpToPointForToResource","generalGcpToGcp","gcpToGeneralGcp"],"mappings":"gFACO,SAASA,EAAiBC,EAAY,CACzC,MAAO,CAAE,OAAQA,EAAW,YAAa,YAAaA,EAAW,MAAA,CACrE,CAKO,SAASC,EAA4BD,EAAY,CACpD,OAAOA,EAAW,WACtB,CACO,SAASE,EAA6BF,EAAY,CACrD,OAAOA,EAAW,MACtB,CACO,SAASG,EAAmBC,EAAK,CACpC,OAAOA,EAAI,GACf,CACO,SAASC,EAAwBD,EAAK,CACzC,OAAOA,EAAI,QACf,CAEO,SAASE,EAAgBN,EAAY,CACxC,MAAO,CACH,SAAUA,EAAW,OACrB,IAAKA,EAAW,YAChB,mBAAoBA,EAAW,mBAC/B,mBAAoBA,EAAW,mBAC/B,YAAaA,EAAW,YACxB,WAAYA,EAAW,UAAA,CAE/B,CACO,SAASO,EAAgBH,EAAK,CACjC,MAAO,CACH,OAAQA,EAAI,SACZ,YAAaA,EAAI,IACjB,mBAAoBA,EAAI,mBACxB,mBAAoBA,EAAI,mBACxB,YAAaA,EAAI,YACjB,WAAYA,EAAI,UAAA,CAExB","x_google_ignoreList":[0]}

package/dist/index.cjs362.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const n=require("./index.cjs363.js");class o extends n.BaseLinearWeightsTransformation{constructor(e,r,t,s){super(e,r,t,s)}getCoefsArrayMatrices(){const e=this.getCoefsArrayMatrix();return[e,e]}getSourcePointCoefsArrays(e){const r=this.getSourcePointCoefsArray(e);return[r,r]}}exports.BaseIndependentLinearWeightsTransformation=o;
+//# sourceMappingURL=index.cjs362.js.map

package/dist/index.cjs362.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs362.js","sources":["../../../node_modules/@allmaps/transform/dist/transformation-types/BaseIndependentLinearWeightsTransformation.js"],"sourcesContent":["import { BaseLinearWeightsTransformation } from './BaseLinearWeightsTransformation.js';\n/**\n * Base class for transformation that are a linear combination of weights,\n * where the system of equations for x and y are independent and can hence be solved separately.\n */\nexport class BaseIndependentLinearWeightsTransformation extends BaseLinearWeightsTransformation {\n    constructor(sourcePoints, destinationPoints, type, pointCountMinimum) {\n        super(sourcePoints, destinationPoints, type, pointCountMinimum);\n    }\n    getCoefsArrayMatrices() {\n        const coefsArrayMatrix = this.getCoefsArrayMatrix();\n        return [coefsArrayMatrix, coefsArrayMatrix];\n    }\n    getSourcePointCoefsArrays(sourcePoint) {\n        const sourcePointCoefsArray = this.getSourcePointCoefsArray(sourcePoint);\n        return [sourcePointCoefsArray, sourcePointCoefsArray];\n    }\n}\n"],"names":["BaseIndependentLinearWeightsTransformation","BaseLinearWeightsTransformation","sourcePoints","destinationPoints","type","pointCountMinimum","coefsArrayMatrix","sourcePoint","sourcePointCoefsArray"],"mappings":"qHAKO,MAAMA,UAAmDC,EAAAA,+BAAgC,CAC5F,YAAYC,EAAcC,EAAmBC,EAAMC,EAAmB,CAClE,MAAMH,EAAcC,EAAmBC,EAAMC,CAAiB,CAClE,CACA,uBAAwB,CACpB,MAAMC,EAAmB,KAAK,oBAAA,EAC9B,MAAO,CAACA,EAAkBA,CAAgB,CAC9C,CACA,0BAA0BC,EAAa,CACnC,MAAMC,EAAwB,KAAK,yBAAyBD,CAAW,EACvE,MAAO,CAACC,EAAuBA,CAAqB,CACxD,CACJ","x_google_ignoreList":[0]}

package/dist/index.cjs363.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const n=require("./index.cjs364.js");class a extends n.BaseTransformation{destinationPointsArrays;constructor(s,t,r,e){super(s,t,r,e),this.destinationPointsArrays=this.getDestinationPointsArrays()}}exports.BaseLinearWeightsTransformation=a;
+//# sourceMappingURL=index.cjs363.js.map

package/dist/index.cjs363.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs363.js","sources":["../../../node_modules/@allmaps/transform/dist/transformation-types/BaseLinearWeightsTransformation.js"],"sourcesContent":["import { BaseTransformation } from './BaseTransformation.js';\n/**\n * Base class for transformation that are a linear combination of weights.\n *\n * In general, the system of equations for x and y are dependent on each other, and they are thus solved jointly.\n * For transformations where the system of equations for x and y are independent and can hence be solved separately, a dedicated class exists.\n */\nexport class BaseLinearWeightsTransformation extends BaseTransformation {\n    destinationPointsArrays;\n    constructor(sourcePoints, destinationPoints, type, pointCountMinimum) {\n        super(sourcePoints, destinationPoints, type, pointCountMinimum);\n        this.destinationPointsArrays = this.getDestinationPointsArrays();\n    }\n}\n"],"names":["BaseLinearWeightsTransformation","BaseTransformation","sourcePoints","destinationPoints","type","pointCountMinimum"],"mappings":"qHAOO,MAAMA,UAAwCC,EAAAA,kBAAmB,CACpE,wBACA,YAAYC,EAAcC,EAAmBC,EAAMC,EAAmB,CAClE,MAAMH,EAAcC,EAAmBC,EAAMC,CAAiB,EAC9D,KAAK,wBAA0B,KAAK,2BAAA,CACxC,CACJ","x_google_ignoreList":[0]}

package/dist/index.cjs364.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const n=require("./index.cjs275.js");class e{sourcePoints;destinationPoints;destinationTransformedSourcePoints;type;pointCount;pointCountMinimum;errors;destinationRmse;constructor(t,i,s,o){if(this.sourcePoints=t,this.destinationPoints=i,this.pointCount=this.sourcePoints.length,this.type=s,this.pointCountMinimum=o,this.pointCount<this.pointCountMinimum)throw new Error("Not enough control points. A "+this.type+" transformation requires a minimum of "+this.pointCountMinimum+" points, but "+this.pointCount+" are given.")}setWeightsArrays(t){this.weightsArrays=t,this.processWeightsArrays()}processWeightsArrays(){}getDestinationTransformedSourcePoints(){return this.destinationTransformedSourcePoints||(this.destinationTransformedSourcePoints=this.sourcePoints.map(t=>this.evaluateFunction(t))),this.destinationTransformedSourcePoints}getMeasures(){return{}}getErrors(){if(!this.errors){const t=this.getDestinationTransformedSourcePoints();this.errors=this.destinationPoints.map((i,s)=>n.distance(i,t[s]))}return this.errors}getDestinationRmse(){if(!this.destinationRmse){const t=this.getDestinationTransformedSourcePoints();this.destinationTransformedSourcePoints||this.getDestinationTransformedSourcePoints(),this.destinationRmse=n.rms(this.destinationPoints,t)}return this.destinationRmse}}exports.BaseTransformation=e;
+//# sourceMappingURL=index.cjs364.js.map

package/dist/index.cjs364.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs364.js","sources":["../../../node_modules/@allmaps/transform/dist/transformation-types/BaseTransformation.js"],"sourcesContent":["import { distance, rms } from '@allmaps/stdlib';\n/**\n * Base class for transformation.\n */\nexport class BaseTransformation {\n    sourcePoints;\n    destinationPoints;\n    destinationTransformedSourcePoints;\n    type;\n    pointCount;\n    pointCountMinimum;\n    errors;\n    destinationRmse;\n    /**\n     * Create a transformation\n     *\n     * @param sourcePoints - The source points\n     * @param destinationPoints - The destination points\n     * @param type - The transformation type\n     * @param pointCountMinimum - The minimum number of points for the transformation type\n     */\n    constructor(sourcePoints, destinationPoints, type, pointCountMinimum) {\n        this.sourcePoints = sourcePoints;\n        this.destinationPoints = destinationPoints;\n        this.pointCount = this.sourcePoints.length;\n        this.type = type;\n        this.pointCountMinimum = pointCountMinimum;\n        if (this.pointCount < this.pointCountMinimum) {\n            throw new Error('Not enough control points. A ' +\n                this.type +\n                ' transformation requires a minimum of ' +\n                this.pointCountMinimum +\n                ' points, but ' +\n                this.pointCount +\n                ' are given.');\n        }\n    }\n    /**\n     * Set weights.\n     *\n     * The weights might be obtained in other ways then through solving\n     * (e.g. through solving multiple transformation together when staping).\n     * This function can be used to set weights computed elsewhere.\n     */\n    setWeightsArrays(weightsArrays) {\n        this.weightsArrays = weightsArrays;\n        this.processWeightsArrays();\n    }\n    processWeightsArrays() {\n        return;\n    }\n    /**\n     * Get the destination-transformed source points.\n     *\n     * @returns source points, transformed to destination domain\n     */\n    getDestinationTransformedSourcePoints() {\n        if (!this.destinationTransformedSourcePoints) {\n            this.destinationTransformedSourcePoints = this.sourcePoints.map((sourcePoint) => this.evaluateFunction(sourcePoint));\n        }\n        return this.destinationTransformedSourcePoints;\n    }\n    getMeasures() {\n        return {};\n    }\n    getErrors() {\n        if (!this.errors) {\n            const destinationTransformedSourcePoints = this.getDestinationTransformedSourcePoints();\n            this.errors = this.destinationPoints.map((destinationPoint, index) => distance(destinationPoint, destinationTransformedSourcePoints[index]));\n        }\n        return this.errors;\n    }\n    getDestinationRmse() {\n        if (!this.destinationRmse) {\n            const destinationTransformedSourcePoints = this.getDestinationTransformedSourcePoints();\n            if (!this.destinationTransformedSourcePoints) {\n                this.getDestinationTransformedSourcePoints();\n            }\n            this.destinationRmse = rms(this.destinationPoints, destinationTransformedSourcePoints);\n        }\n        return this.destinationRmse;\n    }\n}\n"],"names":["BaseTransformation","sourcePoints","destinationPoints","type","pointCountMinimum","weightsArrays","sourcePoint","destinationTransformedSourcePoints","destinationPoint","index","distance","rms"],"mappings":"qHAIO,MAAMA,CAAmB,CAC5B,aACA,kBACA,mCACA,KACA,WACA,kBACA,OACA,gBASA,YAAYC,EAAcC,EAAmBC,EAAMC,EAAmB,CAMlE,GALA,KAAK,aAAeH,EACpB,KAAK,kBAAoBC,EACzB,KAAK,WAAa,KAAK,aAAa,OACpC,KAAK,KAAOC,EACZ,KAAK,kBAAoBC,EACrB,KAAK,WAAa,KAAK,kBACvB,MAAM,IAAI,MAAM,gCACZ,KAAK,KACL,yCACA,KAAK,kBACL,gBACA,KAAK,WACL,aAAa,CAEzB,CAQA,iBAAiBC,EAAe,CAC5B,KAAK,cAAgBA,EACrB,KAAK,qBAAA,CACT,CACA,sBAAuB,CAEvB,CAMA,uCAAwC,CACpC,OAAK,KAAK,qCACN,KAAK,mCAAqC,KAAK,aAAa,IAAKC,GAAgB,KAAK,iBAAiBA,CAAW,CAAC,GAEhH,KAAK,kCAChB,CACA,aAAc,CACV,MAAO,CAAA,CACX,CACA,WAAY,CACR,GAAI,CAAC,KAAK,OAAQ,CACd,MAAMC,EAAqC,KAAK,sCAAA,EAChD,KAAK,OAAS,KAAK,kBAAkB,IAAI,CAACC,EAAkBC,IAAUC,EAAAA,SAASF,EAAkBD,EAAmCE,CAAK,CAAC,CAAC,CAC/I,CACA,OAAO,KAAK,MAChB,CACA,oBAAqB,CACjB,GAAI,CAAC,KAAK,gBAAiB,CACvB,MAAMF,EAAqC,KAAK,sCAAA,EAC3C,KAAK,oCACN,KAAK,sCAAA,EAET,KAAK,gBAAkBI,EAAAA,IAAI,KAAK,kBAAmBJ,CAAkC,CACzF,CACA,OAAO,KAAK,eAChB,CACJ","x_google_ignoreList":[0]}

package/dist/index.cjs365.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const i=require("./index.cjs333.js"),o=require("./index.cjs362.js"),n=require("./index.cjs366.js");class y extends o.BaseIndependentLinearWeightsTransformation{coefsArrayMatrices;coefsArrayMatrix;coefsArrayMatricesSize;coefsArrayMatrixSize;order;weightsArrays;constructor(r,t,s){s=s||1;const e=(s+1)*(s+2)/2;if(super(r,t,"polynomial"+s,e),this.order=s,this.order<1||this.order>3)throw new Error("Only polynomial transformations of order 1, 2 or 3 are supported");this.coefsArrayMatrices=this.getCoefsArrayMatrices(),this.coefsArrayMatrix=this.coefsArrayMatrices[0],this.coefsArrayMatricesSize=this.coefsArrayMatrices.map(a=>i.arrayMatrixSize(a)),this.coefsArrayMatrixSize=i.arrayMatrixSize(this.coefsArrayMatrix)}getDestinationPointsArrays(){return[this.destinationPoints.map(r=>r[0]),this.destinationPoints.map(r=>r[1])]}getCoefsArrayMatrix(){let r=i.newArrayMatrix(this.pointCount,this.pointCountMinimum,0);for(let t=0;t<this.pointCount;t++)r=i.pasteArrayMatrix(r,t,0,[this.getSourcePointCoefsArray(this.sourcePoints[t])]);return r}solve(){this.weightsArrays=n.solveIndependentlyPseudoInverse(this.coefsArrayMatrix,this.destinationPointsArrays)}getTransformationDataAsFloat64Array(){if(this.weightsArrays||this.solve(),!this.weightsArrays)throw new Error("Polynomial transformation weights not computed");return{weights:new Float64Array([...this.weightsArrays[0],...this.weightsArrays[1]]),sourcePoints:new Float64Array(0)}}}exports.BasePolynomialTransformation=y;
+//# sourceMappingURL=index.cjs365.js.map

package/dist/index.cjs365.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs365.js","sources":["../../../node_modules/@allmaps/transform/dist/transformation-types/BasePolynomialTransformation.js"],"sourcesContent":["import { arrayMatrixSize, newArrayMatrix, pasteArrayMatrix } from '@allmaps/stdlib';\nimport { BaseIndependentLinearWeightsTransformation } from './BaseIndependentLinearWeightsTransformation.js';\nimport { solveIndependentlyPseudoInverse } from '../shared/solve-functions.js';\nexport class BasePolynomialTransformation extends BaseIndependentLinearWeightsTransformation {\n    coefsArrayMatrices;\n    coefsArrayMatrix;\n    coefsArrayMatricesSize;\n    coefsArrayMatrixSize;\n    order;\n    weightsArrays;\n    constructor(sourcePoints, destinationPoints, order) {\n        order = order || 1;\n        const pointsCountMinimum = ((order + 1) * (order + 2)) / 2;\n        // If there are less control points than there are coefficients to be determined (for each dimension),\n        // the system can not be solved\n        super(sourcePoints, destinationPoints, ('polynomial' + order), pointsCountMinimum);\n        this.order = order;\n        if (this.order < 1 || this.order > 3) {\n            throw new Error('Only polynomial transformations of order 1, 2 or 3 are supported');\n        }\n        this.coefsArrayMatrices = this.getCoefsArrayMatrices();\n        this.coefsArrayMatrix = this.coefsArrayMatrices[0];\n        this.coefsArrayMatricesSize = this.coefsArrayMatrices.map((coefsArrayMatrix) => arrayMatrixSize(coefsArrayMatrix));\n        this.coefsArrayMatrixSize = arrayMatrixSize(this.coefsArrayMatrix);\n    }\n    getDestinationPointsArrays() {\n        return [\n            this.destinationPoints.map((value) => value[0]),\n            this.destinationPoints.map((value) => value[1])\n        ];\n    }\n    getCoefsArrayMatrix() {\n        let coefsArrayArray = newArrayMatrix(this.pointCount, this.pointCountMinimum, 0);\n        for (let i = 0; i < this.pointCount; i++) {\n            coefsArrayArray = pasteArrayMatrix(coefsArrayArray, i, 0, [\n                this.getSourcePointCoefsArray(this.sourcePoints[i])\n            ]);\n        }\n        return coefsArrayArray;\n    }\n    solve() {\n        this.weightsArrays = solveIndependentlyPseudoInverse(this.coefsArrayMatrix, this.destinationPointsArrays);\n    }\n    getTransformationDataAsFloat64Array() {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.weightsArrays) {\n            throw new Error('Polynomial transformation weights not computed');\n        }\n        // Polynomial: [wx[0], wx[1], ..., wy[0], wy[1], ...]\n        return {\n            weights: new Float64Array([\n                ...this.weightsArrays[0],\n                ...this.weightsArrays[1]\n            ]),\n            sourcePoints: new Float64Array(0)\n        };\n    }\n}\n"],"names":["BasePolynomialTransformation","BaseIndependentLinearWeightsTransformation","sourcePoints","destinationPoints","order","pointsCountMinimum","coefsArrayMatrix","arrayMatrixSize","value","coefsArrayArray","newArrayMatrix","i","pasteArrayMatrix","solveIndependentlyPseudoInverse"],"mappings":"mLAGO,MAAMA,UAAqCC,EAAAA,0CAA2C,CACzF,mBACA,iBACA,uBACA,qBACA,MACA,cACA,YAAYC,EAAcC,EAAmBC,EAAO,CAChDA,EAAQA,GAAS,EACjB,MAAMC,GAAuBD,EAAQ,IAAMA,EAAQ,GAAM,EAKzD,GAFA,MAAMF,EAAcC,EAAoB,aAAeC,EAAQC,CAAkB,EACjF,KAAK,MAAQD,EACT,KAAK,MAAQ,GAAK,KAAK,MAAQ,EAC/B,MAAM,IAAI,MAAM,kEAAkE,EAEtF,KAAK,mBAAqB,KAAK,sBAAA,EAC/B,KAAK,iBAAmB,KAAK,mBAAmB,CAAC,EACjD,KAAK,uBAAyB,KAAK,mBAAmB,IAAKE,GAAqBC,kBAAgBD,CAAgB,CAAC,EACjH,KAAK,qBAAuBC,kBAAgB,KAAK,gBAAgB,CACrE,CACA,4BAA6B,CACzB,MAAO,CACH,KAAK,kBAAkB,IAAKC,GAAUA,EAAM,CAAC,CAAC,EAC9C,KAAK,kBAAkB,IAAKA,GAAUA,EAAM,CAAC,CAAC,CAAA,CAEtD,CACA,qBAAsB,CAClB,IAAIC,EAAkBC,EAAAA,eAAe,KAAK,WAAY,KAAK,kBAAmB,CAAC,EAC/E,QAASC,EAAI,EAAGA,EAAI,KAAK,WAAYA,IACjCF,EAAkBG,EAAAA,iBAAiBH,EAAiBE,EAAG,EAAG,CACtD,KAAK,yBAAyB,KAAK,aAAaA,CAAC,CAAC,CAAA,CACrD,EAEL,OAAOF,CACX,CACA,OAAQ,CACJ,KAAK,cAAgBI,EAAAA,gCAAgC,KAAK,iBAAkB,KAAK,uBAAuB,CAC5G,CACA,qCAAsC,CAIlC,GAHK,KAAK,eACN,KAAK,MAAA,EAEL,CAAC,KAAK,cACN,MAAM,IAAI,MAAM,gDAAgD,EAGpE,MAAO,CACH,QAAS,IAAI,aAAa,CACtB,GAAG,KAAK,cAAc,CAAC,EACvB,GAAG,KAAK,cAAc,CAAC,CAAA,CAC1B,EACD,aAAc,IAAI,aAAa,CAAC,CAAA,CAExC,CACJ","x_google_ignoreList":[0]}

package/dist/index.cjs366.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./index.cjs375.js");function c(s,t){const o=new e.default([...s[0],...s[1]]),n=e.default.columnVector([...t[0],...t[1]]);return e.pseudoInverse(o).mmul(n).to1DArray()}function l(s,t){const o=new e.default(s),n=[e.default.columnVector(t[0]),e.default.columnVector(t[1])],r=e.pseudoInverse(o);return[r.mmul(n[0]),r.mmul(n[1])].map(a=>a.to1DArray())}function d(s,t){const o=new e.default(s),n=[e.default.columnVector(t[0]),e.default.columnVector(t[1])],r=e.inverse(o);return[r.mmul(n[0]),r.mmul(n[1])].map(a=>a.to1DArray())}function v(s,t){const o=[];for(let i=0;i<t;i++)o.push(s[0][i]),o.push(s[1][i]);const n=new e.SingularValueDecomposition(o);return e.default.from1DArray(3,3,n.rightSingularVectors.getColumn(8)).transpose().to2DArray()}exports.solveIndependentlyInverse=d;exports.solveIndependentlyPseudoInverse=l;exports.solveJointlyPseudoInverse=c;exports.solveJointlySvd=v;
+//# sourceMappingURL=index.cjs366.js.map

package/dist/index.cjs366.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs366.js","sources":["../../../node_modules/@allmaps/transform/dist/shared/solve-functions.js"],"sourcesContent":["import Matrix, { inverse, pseudoInverse, SingularValueDecomposition } from 'ml-matrix';\n/**\n * Solve the x and y components jointly using PseudoInverse.\n *\n * This uses the 'Pseudo Inverse' to compute a 'best fit' (least squares) approximate solution\n * for the system of linear equations, which is (in general) over-defined and hence lacks an exact solution.\n * See https://en.wikipedia.org/wiki/Moore%E2%80%93Penrose_inverse\n *\n * This will result weightsArray shared by both components: [t_x, t_y, m, n]\n */\nexport function solveJointlyPseudoInverse(coefsArrayMatrices, destinationPointsArrays) {\n    const coefsMatrix = new Matrix([\n        ...coefsArrayMatrices[0],\n        ...coefsArrayMatrices[1]\n    ]);\n    const destinationPointsMatrix = Matrix.columnVector([\n        ...destinationPointsArrays[0],\n        ...destinationPointsArrays[1]\n    ]);\n    const pseudoInverseCoefsMatrix = pseudoInverse(coefsMatrix);\n    const weightsMatrix = pseudoInverseCoefsMatrix.mmul(destinationPointsMatrix);\n    const weightsArray = weightsMatrix.to1DArray();\n    return weightsArray;\n}\n/**\n * Solve the x and y components independently using PseudoInverse.\n *\n * This uses the 'Pseudo Inverse' to compute (for each component, using the same coefs for both)\n * a 'best fit' (least squares) approximate solution for the system of linear equations\n * which is (in general) over-defined and hence lacks an exact solution.\n *\n * See https://en.wikipedia.org/wiki/Moore%E2%80%93Penrose_inverse\n *\n * This wil result in a weights array for each component:\n * For order = 1: this.weight = [[a0_x, ax_x, ay_x], [a0_y, ax_y, ay_y]]\n * For order = 2: ... (similar, following the same order as in coefsArrayMatrix)\n * For order = 3: ... (similar, following the same order as in coefsArrayMatrix)\n */\nexport function solveIndependentlyPseudoInverse(coefsArrayMatrix, destinationPointsArrays) {\n    const coefsMatrix = new Matrix(coefsArrayMatrix);\n    const destinationPointsMatrices = [\n        Matrix.columnVector(destinationPointsArrays[0]),\n        Matrix.columnVector(destinationPointsArrays[1])\n    ];\n    const pseudoInverseCoefsMatrix = pseudoInverse(coefsMatrix);\n    const weightsMatrices = [\n        pseudoInverseCoefsMatrix.mmul(destinationPointsMatrices[0]),\n        pseudoInverseCoefsMatrix.mmul(destinationPointsMatrices[1])\n    ];\n    const weightsArrays = weightsMatrices.map((matrix) => matrix.to1DArray());\n    return weightsArrays;\n}\n/**\n * Solve the x and y components independently using exact inverse.\n *\n * This uses the exact inverse to compute (for each component, using the same coefs for both)\n * the exact solution for the system of linear equations\n * which is (in general) invertable to an exact solution.\n *\n * This wil result in a weights array for each component with rbf weights and affine weights.\n */\nexport function solveIndependentlyInverse(coefsArrayMatrix, destinationPointsArrays) {\n    const coefsMatrix = new Matrix(coefsArrayMatrix);\n    const destinationPointsMatrices = [\n        Matrix.columnVector(destinationPointsArrays[0]),\n        Matrix.columnVector(destinationPointsArrays[1])\n    ];\n    const inverseCoefsMatrix = inverse(coefsMatrix);\n    const weightsMatrices = [\n        inverseCoefsMatrix.mmul(destinationPointsMatrices[0]),\n        inverseCoefsMatrix.mmul(destinationPointsMatrices[1])\n    ];\n    const weightsArrays = weightsMatrices.map((matrix) => matrix.to1DArray());\n    return weightsArrays;\n}\n/**\n * Solve the x and y components jointly using singular value decomposition.\n *\n * This uses a singular value decomposition to compute the last (i.e. 9th) 'right singular vector',\n * i.e. the one with the smallest singular value, wich holds the weights for the solution.\n * Note that for a set of gcps that exactly follow a projective transformations,\n * the singular value is null and this vector spans the null-space.\n *\n * This wil result in a weights array for each component with rbf weights and affine weights.\n */\nexport function solveJointlySvd(coefsArrayMatrices, pointCount) {\n    // Joint coefs in the same order as in the paper\n    // (Otherwise the weights may differ in sign, even though this should not affect the result)\n    const coefsMatrix = [];\n    for (let i = 0; i < pointCount; i++) {\n        coefsMatrix.push(coefsArrayMatrices[0][i]);\n        coefsMatrix.push(coefsArrayMatrices[1][i]);\n    }\n    const svdCoefsMatrix = new SingularValueDecomposition(coefsMatrix);\n    const weightsMatrix = Matrix.from1DArray(3, 3, svdCoefsMatrix.rightSingularVectors.getColumn(8)).transpose();\n    const weightsArrays = weightsMatrix.to2DArray();\n    return weightsArrays;\n}\n"],"names":["solveJointlyPseudoInverse","coefsArrayMatrices","destinationPointsArrays","coefsMatrix","Matrix","destinationPointsMatrix","pseudoInverse","solveIndependentlyPseudoInverse","coefsArrayMatrix","destinationPointsMatrices","pseudoInverseCoefsMatrix","matrix","solveIndependentlyInverse","inverseCoefsMatrix","inverse","solveJointlySvd","pointCount","svdCoefsMatrix","SingularValueDecomposition"],"mappings":"qHAUO,SAASA,EAA0BC,EAAoBC,EAAyB,CACnF,MAAMC,EAAc,IAAIC,UAAO,CAC3B,GAAGH,EAAmB,CAAC,EACvB,GAAGA,EAAmB,CAAC,CAAA,CAC1B,EACKI,EAA0BD,EAAAA,QAAO,aAAa,CAChD,GAAGF,EAAwB,CAAC,EAC5B,GAAGA,EAAwB,CAAC,CAAA,CAC/B,EAID,OAHiCI,EAAAA,cAAcH,CAAW,EACX,KAAKE,CAAuB,EACxC,UAAA,CAEvC,CAeO,SAASE,EAAgCC,EAAkBN,EAAyB,CACvF,MAAMC,EAAc,IAAIC,EAAAA,QAAOI,CAAgB,EACzCC,EAA4B,CAC9BL,EAAAA,QAAO,aAAaF,EAAwB,CAAC,CAAC,EAC9CE,UAAO,aAAaF,EAAwB,CAAC,CAAC,CAAA,EAE5CQ,EAA2BJ,EAAAA,cAAcH,CAAW,EAM1D,MALwB,CACpBO,EAAyB,KAAKD,EAA0B,CAAC,CAAC,EAC1DC,EAAyB,KAAKD,EAA0B,CAAC,CAAC,CAAA,EAExB,IAAKE,GAAWA,EAAO,WAAW,CAE5E,CAUO,SAASC,EAA0BJ,EAAkBN,EAAyB,CACjF,MAAMC,EAAc,IAAIC,EAAAA,QAAOI,CAAgB,EACzCC,EAA4B,CAC9BL,EAAAA,QAAO,aAAaF,EAAwB,CAAC,CAAC,EAC9CE,UAAO,aAAaF,EAAwB,CAAC,CAAC,CAAA,EAE5CW,EAAqBC,EAAAA,QAAQX,CAAW,EAM9C,MALwB,CACpBU,EAAmB,KAAKJ,EAA0B,CAAC,CAAC,EACpDI,EAAmB,KAAKJ,EAA0B,CAAC,CAAC,CAAA,EAElB,IAAKE,GAAWA,EAAO,WAAW,CAE5E,CAWO,SAASI,EAAgBd,EAAoBe,EAAY,CAG5D,MAAMb,EAAc,CAAA,EACpB,QAAS,EAAI,EAAG,EAAIa,EAAY,IAC5Bb,EAAY,KAAKF,EAAmB,CAAC,EAAE,CAAC,CAAC,EACzCE,EAAY,KAAKF,EAAmB,CAAC,EAAE,CAAC,CAAC,EAE7C,MAAMgB,EAAiB,IAAIC,EAAAA,2BAA2Bf,CAAW,EAGjE,OAFsBC,EAAAA,QAAO,YAAY,EAAG,EAAGa,EAAe,qBAAqB,UAAU,CAAC,CAAC,EAAE,UAAA,EAC7D,UAAA,CAExC","x_google_ignoreList":[0]}

package/dist/index.cjs367.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const s=require("./index.cjs333.js"),a=require("./index.cjs363.js"),o=require("./index.cjs366.js");class h extends a.BaseLinearWeightsTransformation{coefsArrayMatrices;coefsArrayMatricesSize;weightsArray;weightsArrays;constructor(t,r){super(t,r,"helmert",2),this.coefsArrayMatrices=this.getCoefsArrayMatrices(),this.coefsArrayMatricesSize=this.coefsArrayMatrices.map(e=>s.arrayMatrixSize(e))}getDestinationPointsArrays(){return[this.destinationPoints.map(t=>t[0]),this.destinationPoints.map(t=>t[1])]}getCoefsArrayMatrices(){let t=s.newArrayMatrix(this.pointCount,4,0),r=s.newArrayMatrix(this.pointCount,4,0);for(let e=0;e<this.pointCount;e++){const i=this.getSourcePointCoefsArrays(this.sourcePoints[e]);t=s.pasteArrayMatrix(t,e,0,[i[0]]),r=s.pasteArrayMatrix(r,e,0,[i[1]])}return[t,r]}getSourcePointCoefsArrays(t){return[[1,0,t[0],-t[1]],[0,1,t[1],t[0]]]}solve(){this.weightsArray=o.solveJointlyPseudoInverse(this.coefsArrayMatrices,this.destinationPointsArrays),this.weightsArrays=[this.weightsArray,this.weightsArray]}getMeasures(){if(this.weightsArrays||this.solve(),!this.weightsArray)throw new Error("Helmert weights not computed");const t={};return t.scale=Math.sqrt(this.weightsArray[2]**2+this.weightsArray[3]**2),t.rotation=Math.atan2(this.weightsArray[3],this.weightsArray[2]),t.translation=[this.weightsArray[0],this.weightsArray[1]],t}evaluateFunction(t){if(this.weightsArrays||this.solve(),!this.weightsArray)throw new Error("Helmert weights not computed");return[this.weightsArray[0]+this.weightsArray[2]*t[0]-this.weightsArray[3]*t[1],this.weightsArray[1]+this.weightsArray[2]*t[1]+this.weightsArray[3]*t[0]]}evaluatePartialDerivativeX(t){if(this.weightsArrays||this.solve(),!this.weightsArray)throw new Error("Helmert weights not computed");return[this.weightsArray[2],this.weightsArray[3]]}evaluatePartialDerivativeY(t){if(this.weightsArrays||this.solve(),!this.weightsArray)throw new Error("Helmert weights not computed");return[-this.weightsArray[3],this.weightsArray[2]]}getTransformationDataAsFloat64Array(){if(this.weightsArray||this.solve(),!this.weightsArray)throw new Error("Helmert weights not computed");return{weights:new Float64Array(this.weightsArray),sourcePoints:new Float64Array(0)}}}exports.Helmert=h;
+//# sourceMappingURL=index.cjs367.js.map

package/dist/index.cjs367.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs367.js","sources":["../../../node_modules/@allmaps/transform/dist/transformation-types/Helmert.js"],"sourcesContent":["import { newArrayMatrix, pasteArrayMatrix, arrayMatrixSize } from '@allmaps/stdlib';\nimport { BaseLinearWeightsTransformation } from './BaseLinearWeightsTransformation.js';\nimport { solveJointlyPseudoInverse } from '../shared/solve-functions.js';\n/**\n * 2D Helmert transformation (= similarity transformation)\n *\n * This transformation is a composition of a translation, rotation and scaling. There is no shearing.\n *\n * For this transformations, the system of equations is solved for x and y jointly.\n */\nexport class Helmert extends BaseLinearWeightsTransformation {\n    coefsArrayMatrices;\n    coefsArrayMatricesSize;\n    weightsArray;\n    weightsArrays;\n    constructor(sourcePoints, destinationPoints) {\n        super(sourcePoints, destinationPoints, 'helmert', 2);\n        this.coefsArrayMatrices = this.getCoefsArrayMatrices();\n        this.coefsArrayMatricesSize = this.coefsArrayMatrices.map((coefsArrayMatrix) => arrayMatrixSize(coefsArrayMatrix));\n    }\n    getDestinationPointsArrays() {\n        return [\n            this.destinationPoints.map((value) => value[0]),\n            this.destinationPoints.map((value) => value[1])\n        ];\n    }\n    getCoefsArrayMatrices() {\n        let coefsArrayMatrix0 = newArrayMatrix(this.pointCount, 4, 0);\n        let coefsArrayMatrix1 = newArrayMatrix(this.pointCount, 4, 0);\n        for (let i = 0; i < this.pointCount; i++) {\n            const sourcePointCoefsArrays = this.getSourcePointCoefsArrays(this.sourcePoints[i]);\n            coefsArrayMatrix0 = pasteArrayMatrix(coefsArrayMatrix0, i, 0, [\n                sourcePointCoefsArrays[0]\n            ]);\n            coefsArrayMatrix1 = pasteArrayMatrix(coefsArrayMatrix1, i, 0, [\n                sourcePointCoefsArrays[1]\n            ]);\n        }\n        return [coefsArrayMatrix0, coefsArrayMatrix1];\n    }\n    /**\n     * Get two 1x4 coefsArrays, populating the 2Nx4 coefsArrayMatrices\n     * 1 0 x0 -y0\n     * 1 0 x1 -y1\n     * ...\n     * 0 1 y0 x0\n     * 0 1 y1 x1\n     * ...\n     *\n     * @param sourcePoint\n     */\n    getSourcePointCoefsArrays(sourcePoint) {\n        return [\n            [1, 0, sourcePoint[0], -sourcePoint[1]],\n            [0, 1, sourcePoint[1], sourcePoint[0]]\n        ];\n    }\n    solve() {\n        this.weightsArray = solveJointlyPseudoInverse(this.coefsArrayMatrices, this.destinationPointsArrays);\n        this.weightsArrays = [this.weightsArray, this.weightsArray];\n    }\n    getMeasures() {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.weightsArray) {\n            throw new Error('Helmert weights not computed');\n        }\n        const measures = {};\n        measures.scale = Math.sqrt(this.weightsArray[2] ** 2 + this.weightsArray[3] ** 2);\n        measures.rotation = Math.atan2(this.weightsArray[3], this.weightsArray[2]);\n        measures.translation = [this.weightsArray[0], this.weightsArray[1]];\n        return measures;\n    }\n    evaluateFunction(newSourcePoint) {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.weightsArray) {\n            throw new Error('Helmert weights not computed');\n        }\n        const newDestinationPoint = [\n            this.weightsArray[0] +\n                this.weightsArray[2] * newSourcePoint[0] -\n                this.weightsArray[3] * newSourcePoint[1],\n            this.weightsArray[1] +\n                this.weightsArray[2] * newSourcePoint[1] +\n                this.weightsArray[3] * newSourcePoint[0]\n        ];\n        // Alternatively, using derived helmert measures\n        // this.translation[0] +\n        //   this.scale * Math.cos(rotation) * newSourcePoint[0] -\n        //   this.scale * Math.sin(rotation) * newSourcePoint[1],\n        // this.translation[1] +\n        //   this.scale * Math.cos(rotation) * newSourcePoint[1] +\n        //   this.scale * Math.sin(rotation) * newSourcePoint[0]\n        return newDestinationPoint;\n    }\n    evaluatePartialDerivativeX(_newSourcePoint) {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.weightsArray) {\n            throw new Error('Helmert weights not computed');\n        }\n        const newDestinationPointPartDerX = [\n            this.weightsArray[2],\n            this.weightsArray[3]\n        ];\n        return newDestinationPointPartDerX;\n    }\n    evaluatePartialDerivativeY(_newSourcePoint) {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.weightsArray) {\n            throw new Error('Helmert weights not computed');\n        }\n        const newDestinationPointPartDerY = [\n            -this.weightsArray[3],\n            this.weightsArray[2]\n        ];\n        return newDestinationPointPartDerY;\n    }\n    getTransformationDataAsFloat64Array() {\n        if (!this.weightsArray) {\n            this.solve();\n        }\n        if (!this.weightsArray) {\n            throw new Error('Helmert weights not computed');\n        }\n        // Helmert: [w0, w1, w2, w3]\n        return {\n            weights: new Float64Array(this.weightsArray),\n            sourcePoints: new Float64Array(0)\n        };\n    }\n}\n"],"names":["Helmert","BaseLinearWeightsTransformation","sourcePoints","destinationPoints","coefsArrayMatrix","arrayMatrixSize","value","coefsArrayMatrix0","newArrayMatrix","coefsArrayMatrix1","i","sourcePointCoefsArrays","pasteArrayMatrix","sourcePoint","solveJointlyPseudoInverse","measures","newSourcePoint","_newSourcePoint"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/index.cjs368.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const n=require("./index.cjs365.js");class h extends n.BasePolynomialTransformation{constructor(t,r){super(t,r,1)}getSourcePointCoefsArray(t){return h.getPolynomial1SourcePointCoefsArray(t)}static getPolynomial1SourcePointCoefsArray(t){return[1,t[0],t[1]]}getHomogeneousTransform(){if(this.weightsArrays)return[this.weightsArrays[0][1],this.weightsArrays[1][1],this.weightsArrays[0][2],this.weightsArrays[1][2],this.weightsArrays[0][0],this.weightsArrays[1][0]]}setWeightsArraysFromHomogeneousTransform(t){this.weightsArrays=[[t[4],t[0],t[2]],[t[5],t[1],t[3]]]}getMeasures(){if(this.weightsArrays||this.solve(),!this.weightsArrays)throw new Error("Weights not computed");const t={};t.translation=[this.weightsArrays[0][0],this.weightsArrays[1][0]];const r=this.weightsArrays[0][1],s=this.weightsArrays[1][1],e=this.weightsArrays[0][2],a=this.weightsArrays[1][2],o=r*a-s*e;if(r!=0||s!=0){const i=Math.sqrt(r*r+s*s);t.rotation=s>0?Math.acos(r/i):-Math.acos(r/i),t.scales=[i,o/i],t.shears=[Math.atan((r*e+s*a)/(i*i)),0]}else if(e!=0||a!=0){const i=Math.sqrt(e*e+a*a);t.rotation=Math.PI/2-(a>0?Math.acos(-e/i):-Math.acos(e/i)),t.scales=[o/i,i],t.shears=[0,Math.atan((r*e+s*a)/(i*i))]}return t}evaluateFunction(t){if(this.weightsArrays||this.solve(),!this.weightsArrays)throw new Error("Weights not computed");const r=[0,0];for(let s=0;s<2;s++)r[s]+=this.weightsArrays[s][0]+this.weightsArrays[s][1]*t[0]+this.weightsArrays[s][2]*t[1];return r}evaluatePartialDerivativeX(t){if(this.weightsArrays||this.solve(),!this.weightsArrays)throw new Error("Weights not computed");const r=[0,0];for(let s=0;s<2;s++)r[s]+=this.weightsArrays[s][1];return r}evaluatePartialDerivativeY(t){if(this.weightsArrays||this.solve(),!this.weightsArrays)throw new Error("Weights not computed");const r=[0,0];for(let s=0;s<2;s++)r[s]+=this.weightsArrays[s][2];return r}}exports.Polynomial1=h;
+//# sourceMappingURL=index.cjs368.js.map

package/dist/index.cjs368.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs368.js","sources":["../../../node_modules/@allmaps/transform/dist/transformation-types/Polynomial1.js"],"sourcesContent":["import { BasePolynomialTransformation } from './BasePolynomialTransformation.js';\n/**\n * 2D First-order Polynomial transformation\n *\n * This transformation is a composition of a translation, rotation, scaling and shearing.\n */\nexport class Polynomial1 extends BasePolynomialTransformation {\n    constructor(sourcePoints, destinationPoints) {\n        super(sourcePoints, destinationPoints, 1);\n    }\n    getSourcePointCoefsArray(sourcePoint) {\n        return Polynomial1.getPolynomial1SourcePointCoefsArray(sourcePoint);\n    }\n    /**\n     * Get 1x3 coefsArray, populating the Nx3 coefsArrayMatrix\n     * 1 x0 y0\n     * 1 x1 y1\n     * 1 x2 y2\n     * ...\n     *\n     * @param sourcePoint\n     */\n    static getPolynomial1SourcePointCoefsArray(sourcePoint) {\n        return [1, sourcePoint[0], sourcePoint[1]];\n    }\n    getHomogeneousTransform() {\n        if (!this.weightsArrays) {\n            return undefined;\n        }\n        return [\n            this.weightsArrays[0][1],\n            this.weightsArrays[1][1],\n            this.weightsArrays[0][2],\n            this.weightsArrays[1][2],\n            this.weightsArrays[0][0],\n            this.weightsArrays[1][0]\n        ];\n    }\n    setWeightsArraysFromHomogeneousTransform(homogeneousTransform) {\n        this.weightsArrays = [\n            [\n                homogeneousTransform[4],\n                homogeneousTransform[0],\n                homogeneousTransform[2]\n            ],\n            [\n                homogeneousTransform[5],\n                homogeneousTransform[1],\n                homogeneousTransform[3]\n            ]\n        ];\n    }\n    getMeasures() {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.weightsArrays) {\n            throw new Error('Weights not computed');\n        }\n        const measures = {};\n        // From: https://stackoverflow.com/questions/12469770/get-skew-or-rotation-value-from-affine-transformation-matrix\n        measures.translation = [this.weightsArrays[0][0], this.weightsArrays[1][0]];\n        const a = this.weightsArrays[0][1];\n        const b = this.weightsArrays[1][1];\n        const c = this.weightsArrays[0][2];\n        const d = this.weightsArrays[1][2];\n        const delta = a * d - b * c;\n        // Apply the QR-like decomposition.\n        if (a != 0 || b != 0) {\n            const r = Math.sqrt(a * a + b * b);\n            measures.rotation = b > 0 ? Math.acos(a / r) : -Math.acos(a / r);\n            measures.scales = [r, delta / r];\n            measures.shears = [Math.atan((a * c + b * d) / (r * r)), 0];\n        }\n        else if (c != 0 || d != 0) {\n            const s = Math.sqrt(c * c + d * d);\n            measures.rotation =\n                Math.PI / 2 - (d > 0 ? Math.acos(-c / s) : -Math.acos(c / s));\n            measures.scales = [delta / s, s];\n            measures.shears = [0, Math.atan((a * c + b * d) / (s * s))];\n        }\n        else {\n            // a = b = c = d = 0\n        }\n        return measures;\n    }\n    evaluateFunction(newSourcePoint) {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.weightsArrays) {\n            throw new Error('Weights not computed');\n        }\n        const newDestinationPoint = [0, 0];\n        for (let i = 0; i < 2; i++) {\n            newDestinationPoint[i] +=\n                this.weightsArrays[i][0] +\n                    this.weightsArrays[i][1] * newSourcePoint[0] +\n                    this.weightsArrays[i][2] * newSourcePoint[1];\n        }\n        return newDestinationPoint;\n    }\n    evaluatePartialDerivativeX(_newSourcePoint) {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.weightsArrays) {\n            throw new Error('Weights not computed');\n        }\n        const newDestinationPointPartDerX = [0, 0];\n        for (let i = 0; i < 2; i++) {\n            newDestinationPointPartDerX[i] += this.weightsArrays[i][1];\n        }\n        return newDestinationPointPartDerX;\n    }\n    evaluatePartialDerivativeY(_newSourcePoint) {\n        if (!this.weightsArrays) {\n            this.solve();\n        }\n        if (!this.weightsArrays) {\n            throw new Error('Weights not computed');\n        }\n        const newDestinationPointPartDerY = [0, 0];\n        for (let i = 0; i < 2; i++) {\n            newDestinationPointPartDerY[i] += this.weightsArrays[i][2];\n        }\n        return newDestinationPointPartDerY;\n    }\n}\n"],"names":["Polynomial1","BasePolynomialTransformation","sourcePoints","destinationPoints","sourcePoint","homogeneousTransform","measures","a","b","c","d","delta","r","s","newSourcePoint","newDestinationPoint","i","_newSourcePoint","newDestinationPointPartDerX","newDestinationPointPartDerY"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/index.cjs369.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./index.cjs365.js");class i extends e.BasePolynomialTransformation{constructor(t,r){super(t,r,2)}getSourcePointCoefsArray(t){return i.getPolynomial2SourcePointCoefsArray(t)}static getPolynomial2SourcePointCoefsArray(t){return[1,t[0],t[1],t[0]**2,t[1]**2,t[0]*t[1]]}evaluateFunction(t){if(this.weightsArrays||this.solve(),!this.weightsArrays)throw new Error("Weights not computed");const r=[0,0];for(let s=0;s<2;s++)r[s]+=this.weightsArrays[s][0]+this.weightsArrays[s][1]*t[0]+this.weightsArrays[s][2]*t[1]+this.weightsArrays[s][3]*t[0]**2+this.weightsArrays[s][4]*t[1]**2+this.weightsArrays[s][5]*t[0]*t[1];return r}evaluatePartialDerivativeX(t){if(this.weightsArrays||this.solve(),!this.weightsArrays)throw new Error("Weights not computed");const r=[0,0];for(let s=0;s<2;s++)r[s]+=this.weightsArrays[s][1]+2*this.weightsArrays[s][3]*t[0]+this.weightsArrays[s][5]*t[1];return r}evaluatePartialDerivativeY(t){if(this.weightsArrays||this.solve(),!this.weightsArrays)throw new Error("Weights not computed");const r=[0,0];for(let s=0;s<2;s++)r[s]+=this.weightsArrays[s][2]+2*this.weightsArrays[s][4]*t[1]+this.weightsArrays[s][5]*t[0];return r}}exports.Polynomial2=i;
+//# sourceMappingURL=index.cjs369.js.map