@loaders.gl/raster 0.0.0-stage → 5.0.0-alpha.13

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (379) hide show
  1. package/README.md +60 -2
  2. package/dist/geotiff/advanced.cjs +1955 -0
  3. package/dist/geotiff/advanced.cjs.map +7 -0
  4. package/dist/geotiff/advanced.d.ts +13 -0
  5. package/dist/geotiff/advanced.d.ts.map +1 -0
  6. package/dist/geotiff/advanced.js +12 -0
  7. package/dist/geotiff/advanced.js.map +1 -0
  8. package/dist/geotiff/bundled.d.ts +3 -0
  9. package/dist/geotiff/bundled.d.ts.map +1 -0
  10. package/dist/geotiff/bundled.js +5 -0
  11. package/dist/geotiff/bundled.js.map +1 -0
  12. package/dist/geotiff/discover-geotiff.d.ts +14 -0
  13. package/dist/geotiff/discover-geotiff.d.ts.map +1 -0
  14. package/dist/geotiff/discover-geotiff.js +63 -0
  15. package/dist/geotiff/discover-geotiff.js.map +1 -0
  16. package/dist/geotiff/geotiff-format.d.ts +21 -0
  17. package/dist/geotiff/geotiff-format.d.ts.map +1 -0
  18. package/dist/geotiff/geotiff-format.js +24 -0
  19. package/dist/geotiff/geotiff-format.js.map +1 -0
  20. package/dist/geotiff/geotiff-loader-types.d.ts +63 -0
  21. package/dist/geotiff/geotiff-loader-types.d.ts.map +1 -0
  22. package/dist/geotiff/geotiff-loader-types.js +26 -0
  23. package/dist/geotiff/geotiff-loader-types.js.map +1 -0
  24. package/dist/geotiff/geotiff-loader.d.ts +49 -0
  25. package/dist/geotiff/geotiff-loader.d.ts.map +1 -0
  26. package/dist/geotiff/geotiff-loader.js +70 -0
  27. package/dist/geotiff/geotiff-loader.js.map +1 -0
  28. package/dist/geotiff/geotiff-raster-loader-types.d.ts +37 -0
  29. package/dist/geotiff/geotiff-raster-loader-types.d.ts.map +1 -0
  30. package/dist/geotiff/geotiff-raster-loader-types.js +24 -0
  31. package/dist/geotiff/geotiff-raster-loader-types.js.map +1 -0
  32. package/dist/geotiff/geotiff-raster-loader.d.ts +22 -0
  33. package/dist/geotiff/geotiff-raster-loader.d.ts.map +1 -0
  34. package/dist/geotiff/geotiff-raster-loader.js +65 -0
  35. package/dist/geotiff/geotiff-raster-loader.js.map +1 -0
  36. package/dist/geotiff/geotiff-raster-types.d.ts +65 -0
  37. package/dist/geotiff/geotiff-raster-types.d.ts.map +1 -0
  38. package/dist/geotiff/geotiff-raster-types.js +5 -0
  39. package/dist/geotiff/geotiff-raster-types.js.map +1 -0
  40. package/dist/geotiff/geotiff-source-loader-types.d.ts +67 -0
  41. package/dist/geotiff/geotiff-source-loader-types.d.ts.map +1 -0
  42. package/dist/geotiff/geotiff-source-loader-types.js +43 -0
  43. package/dist/geotiff/geotiff-source-loader-types.js.map +1 -0
  44. package/dist/geotiff/geotiff-source-loader.d.ts +132 -0
  45. package/dist/geotiff/geotiff-source-loader.d.ts.map +1 -0
  46. package/dist/geotiff/geotiff-source-loader.js +1322 -0
  47. package/dist/geotiff/geotiff-source-loader.js.map +1 -0
  48. package/dist/geotiff/index.d.ts +3 -0
  49. package/dist/geotiff/index.d.ts.map +1 -0
  50. package/dist/geotiff/index.js +6 -0
  51. package/dist/geotiff/index.js.map +1 -0
  52. package/dist/geotiff/lib/load-geotiff.d.ts +28 -0
  53. package/dist/geotiff/lib/load-geotiff.d.ts.map +1 -0
  54. package/dist/geotiff/lib/load-geotiff.js +61 -0
  55. package/dist/geotiff/lib/load-geotiff.js.map +1 -0
  56. package/dist/geotiff/lib/ome/load-ome-tiff.d.ts +50 -0
  57. package/dist/geotiff/lib/ome/load-ome-tiff.d.ts.map +1 -0
  58. package/dist/geotiff/lib/ome/load-ome-tiff.js +42 -0
  59. package/dist/geotiff/lib/ome/load-ome-tiff.js.map +1 -0
  60. package/dist/geotiff/lib/ome/ome-indexers.d.ts +12 -0
  61. package/dist/geotiff/lib/ome/ome-indexers.d.ts.map +1 -0
  62. package/dist/geotiff/lib/ome/ome-indexers.js +109 -0
  63. package/dist/geotiff/lib/ome/ome-indexers.js.map +1 -0
  64. package/dist/geotiff/lib/ome/ome-utils.d.ts +32 -0
  65. package/dist/geotiff/lib/ome/ome-utils.d.ts.map +1 -0
  66. package/dist/geotiff/lib/ome/ome-utils.js +67 -0
  67. package/dist/geotiff/lib/ome/ome-utils.js.map +1 -0
  68. package/dist/geotiff/lib/ome/omexml.d.ts +49 -0
  69. package/dist/geotiff/lib/ome/omexml.d.ts.map +1 -0
  70. package/dist/geotiff/lib/ome/omexml.js +63 -0
  71. package/dist/geotiff/lib/ome/omexml.js.map +1 -0
  72. package/dist/geotiff/lib/ome/utils.d.ts +7 -0
  73. package/dist/geotiff/lib/ome/utils.d.ts.map +1 -0
  74. package/dist/geotiff/lib/ome/utils.js +29 -0
  75. package/dist/geotiff/lib/ome/utils.js.map +1 -0
  76. package/dist/geotiff/lib/tiff/decode-tiff-samples.d.ts +34 -0
  77. package/dist/geotiff/lib/tiff/decode-tiff-samples.d.ts.map +1 -0
  78. package/dist/geotiff/lib/tiff/decode-tiff-samples.js +150 -0
  79. package/dist/geotiff/lib/tiff/decode-tiff-samples.js.map +1 -0
  80. package/dist/geotiff/lib/tiff/geotiff-decoder-adapter.d.ts +4 -0
  81. package/dist/geotiff/lib/tiff/geotiff-decoder-adapter.d.ts.map +1 -0
  82. package/dist/geotiff/lib/tiff/geotiff-decoder-adapter.js +88 -0
  83. package/dist/geotiff/lib/tiff/geotiff-decoder-adapter.js.map +1 -0
  84. package/dist/geotiff/lib/tiff/geotiff-source-adapter.d.ts +4 -0
  85. package/dist/geotiff/lib/tiff/geotiff-source-adapter.d.ts.map +1 -0
  86. package/dist/geotiff/lib/tiff/geotiff-source-adapter.js +51 -0
  87. package/dist/geotiff/lib/tiff/geotiff-source-adapter.js.map +1 -0
  88. package/dist/geotiff/lib/tiff/plan-tiff-blocks.d.ts +10 -0
  89. package/dist/geotiff/lib/tiff/plan-tiff-blocks.d.ts.map +1 -0
  90. package/dist/geotiff/lib/tiff/plan-tiff-blocks.js +101 -0
  91. package/dist/geotiff/lib/tiff/plan-tiff-blocks.js.map +1 -0
  92. package/dist/geotiff/lib/tiff/read-tiff-directory.d.ts +8 -0
  93. package/dist/geotiff/lib/tiff/read-tiff-directory.d.ts.map +1 -0
  94. package/dist/geotiff/lib/tiff/read-tiff-directory.js +219 -0
  95. package/dist/geotiff/lib/tiff/read-tiff-directory.js.map +1 -0
  96. package/dist/geotiff/lib/tiff/tiff-gdal-metadata.d.ts +8 -0
  97. package/dist/geotiff/lib/tiff/tiff-gdal-metadata.d.ts.map +1 -0
  98. package/dist/geotiff/lib/tiff/tiff-gdal-metadata.js +50 -0
  99. package/dist/geotiff/lib/tiff/tiff-gdal-metadata.js.map +1 -0
  100. package/dist/geotiff/lib/tiff/tiff-metadata.d.ts +5 -0
  101. package/dist/geotiff/lib/tiff/tiff-metadata.d.ts.map +1 -0
  102. package/dist/geotiff/lib/tiff/tiff-metadata.js +188 -0
  103. package/dist/geotiff/lib/tiff/tiff-metadata.js.map +1 -0
  104. package/dist/geotiff/lib/tiff/tiff-numeric-decoder.d.ts +40 -0
  105. package/dist/geotiff/lib/tiff/tiff-numeric-decoder.d.ts.map +1 -0
  106. package/dist/geotiff/lib/tiff/tiff-numeric-decoder.js +40 -0
  107. package/dist/geotiff/lib/tiff/tiff-numeric-decoder.js.map +1 -0
  108. package/dist/geotiff/lib/tiff/tiff-source-decoder.d.ts +103 -0
  109. package/dist/geotiff/lib/tiff/tiff-source-decoder.d.ts.map +1 -0
  110. package/dist/geotiff/lib/tiff/tiff-source-decoder.js +5 -0
  111. package/dist/geotiff/lib/tiff/tiff-source-decoder.js.map +1 -0
  112. package/dist/geotiff/lib/tiff/tiff-types.d.ts +49 -0
  113. package/dist/geotiff/lib/tiff/tiff-types.d.ts.map +1 -0
  114. package/dist/geotiff/lib/tiff/tiff-types.js +5 -0
  115. package/dist/geotiff/lib/tiff/tiff-types.js.map +1 -0
  116. package/dist/geotiff/lib/tiff-pixel-source.d.ts +17 -0
  117. package/dist/geotiff/lib/tiff-pixel-source.d.ts.map +1 -0
  118. package/dist/geotiff/lib/tiff-pixel-source.js +71 -0
  119. package/dist/geotiff/lib/tiff-pixel-source.js.map +1 -0
  120. package/dist/geotiff/lib/utils/tiff-utils.d.ts +10 -0
  121. package/dist/geotiff/lib/utils/tiff-utils.d.ts.map +1 -0
  122. package/dist/geotiff/lib/utils/tiff-utils.js +41 -0
  123. package/dist/geotiff/lib/utils/tiff-utils.js.map +1 -0
  124. package/dist/geotiff/loaders.d.ts +30 -0
  125. package/dist/geotiff/loaders.d.ts.map +1 -0
  126. package/dist/geotiff/loaders.js +53 -0
  127. package/dist/geotiff/loaders.js.map +1 -0
  128. package/dist/geotiff/ometiff-source-loader-types.d.ts +67 -0
  129. package/dist/geotiff/ometiff-source-loader-types.d.ts.map +1 -0
  130. package/dist/geotiff/ometiff-source-loader-types.js +38 -0
  131. package/dist/geotiff/ometiff-source-loader-types.js.map +1 -0
  132. package/dist/geotiff/ometiff-source-loader.d.ts +152 -0
  133. package/dist/geotiff/ometiff-source-loader.d.ts.map +1 -0
  134. package/dist/geotiff/ometiff-source-loader.js +256 -0
  135. package/dist/geotiff/ometiff-source-loader.js.map +1 -0
  136. package/dist/geotiff/types.d.ts +75 -0
  137. package/dist/geotiff/types.d.ts.map +1 -0
  138. package/dist/geotiff/types.js +5 -0
  139. package/dist/geotiff/types.js.map +1 -0
  140. package/dist/geotiff/unbundled.d.ts +3 -0
  141. package/dist/geotiff/unbundled.d.ts.map +1 -0
  142. package/dist/geotiff/unbundled.js +5 -0
  143. package/dist/geotiff/unbundled.js.map +1 -0
  144. package/dist/index.cjs +523 -0
  145. package/dist/index.cjs.map +7 -0
  146. package/dist/index.d.ts +29 -0
  147. package/dist/index.d.ts.map +1 -0
  148. package/dist/index.js +19 -0
  149. package/dist/index.js.map +1 -0
  150. package/dist/lerc/bundled.d.ts +3 -0
  151. package/dist/lerc/bundled.d.ts.map +1 -0
  152. package/dist/lerc/bundled.js +5 -0
  153. package/dist/lerc/bundled.js.map +1 -0
  154. package/dist/lerc/index.d.ts +6 -0
  155. package/dist/lerc/index.d.ts.map +1 -0
  156. package/dist/lerc/index.js +9 -0
  157. package/dist/lerc/index.js.map +1 -0
  158. package/dist/lerc/lerc-format.d.ts +11 -0
  159. package/dist/lerc/lerc-format.d.ts.map +1 -0
  160. package/dist/lerc/lerc-format.js +14 -0
  161. package/dist/lerc/lerc-format.js.map +1 -0
  162. package/dist/lerc/lerc-loader-types.d.ts +54 -0
  163. package/dist/lerc/lerc-loader-types.d.ts.map +1 -0
  164. package/dist/lerc/lerc-loader-types.js +31 -0
  165. package/dist/lerc/lerc-loader-types.js.map +1 -0
  166. package/dist/lerc/lerc-loader.d.ts +36 -0
  167. package/dist/lerc/lerc-loader.d.ts.map +1 -0
  168. package/dist/lerc/lerc-loader.js +22 -0
  169. package/dist/lerc/lerc-loader.js.map +1 -0
  170. package/dist/lerc/lerc-wasm-url.d.ts +3 -0
  171. package/dist/lerc/lerc-wasm-url.d.ts.map +1 -0
  172. package/dist/lerc/lerc-wasm-url.js +8 -0
  173. package/dist/lerc/lerc-wasm-url.js.map +1 -0
  174. package/dist/lerc/lib/parsers/lerc/lerc-types.d.ts +30 -0
  175. package/dist/lerc/lib/parsers/lerc/lerc-types.d.ts.map +1 -0
  176. package/dist/lerc/lib/parsers/lerc/lerc-types.js +5 -0
  177. package/dist/lerc/lib/parsers/lerc/lerc-types.js.map +1 -0
  178. package/dist/lerc/libs/lerc/LICENSE +101 -0
  179. package/dist/lerc/libs/lerc/NOTICE +23 -0
  180. package/dist/lerc/libs/lerc/lerc-wasm.wasm +0 -0
  181. package/dist/lerc/unbundled.d.ts +3 -0
  182. package/dist/lerc/unbundled.d.ts.map +1 -0
  183. package/dist/lerc/unbundled.js +5 -0
  184. package/dist/lerc/unbundled.js.map +1 -0
  185. package/dist/lerc/workers/lerc-worker.d.ts +2 -0
  186. package/dist/lerc/workers/lerc-worker.d.ts.map +1 -0
  187. package/dist/lerc/workers/lerc-worker.js +7 -0
  188. package/dist/lerc/workers/lerc-worker.js.map +1 -0
  189. package/dist/quantized-mesh-worker.js +17271 -0
  190. package/dist/quantized-mesh.d.ts +2 -0
  191. package/dist/quantized-mesh.d.ts.map +1 -0
  192. package/dist/quantized-mesh.js +5 -0
  193. package/dist/quantized-mesh.js.map +1 -0
  194. package/dist/terrain/bundled.d.ts +5 -0
  195. package/dist/terrain/bundled.d.ts.map +1 -0
  196. package/dist/terrain/bundled.js +6 -0
  197. package/dist/terrain/bundled.js.map +1 -0
  198. package/dist/terrain/heightmap.cjs +397 -0
  199. package/dist/terrain/heightmap.cjs.map +7 -0
  200. package/dist/terrain/heightmap.d.ts +8 -0
  201. package/dist/terrain/heightmap.d.ts.map +1 -0
  202. package/dist/terrain/heightmap.js +8 -0
  203. package/dist/terrain/heightmap.js.map +1 -0
  204. package/dist/terrain/index.cjs +1406 -0
  205. package/dist/terrain/index.cjs.map +7 -0
  206. package/dist/terrain/index.d.ts +18 -0
  207. package/dist/terrain/index.d.ts.map +1 -0
  208. package/dist/terrain/index.js +16 -0
  209. package/dist/terrain/index.js.map +1 -0
  210. package/dist/terrain/lib/decode-quantized-mesh.d.ts +59 -0
  211. package/dist/terrain/lib/decode-quantized-mesh.d.ts.map +1 -0
  212. package/dist/terrain/lib/decode-quantized-mesh.js +227 -0
  213. package/dist/terrain/lib/decode-quantized-mesh.js.map +1 -0
  214. package/dist/terrain/lib/decode-terrain-heightmap.d.ts +16 -0
  215. package/dist/terrain/lib/decode-terrain-heightmap.d.ts.map +1 -0
  216. package/dist/terrain/lib/decode-terrain-heightmap.js +52 -0
  217. package/dist/terrain/lib/decode-terrain-heightmap.js.map +1 -0
  218. package/dist/terrain/lib/delatin/index.d.ts +24 -0
  219. package/dist/terrain/lib/delatin/index.d.ts.map +1 -0
  220. package/dist/terrain/lib/delatin/index.js +409 -0
  221. package/dist/terrain/lib/delatin/index.js.map +1 -0
  222. package/dist/terrain/lib/helpers/skirt.d.ts +19 -0
  223. package/dist/terrain/lib/helpers/skirt.d.ts.map +1 -0
  224. package/dist/terrain/lib/helpers/skirt.js +127 -0
  225. package/dist/terrain/lib/helpers/skirt.js.map +1 -0
  226. package/dist/terrain/lib/parse-quantized-mesh.d.ts +15 -0
  227. package/dist/terrain/lib/parse-quantized-mesh.d.ts.map +1 -0
  228. package/dist/terrain/lib/parse-quantized-mesh.js +86 -0
  229. package/dist/terrain/lib/parse-quantized-mesh.js.map +1 -0
  230. package/dist/terrain/lib/parse-terrain.d.ts +32 -0
  231. package/dist/terrain/lib/parse-terrain.d.ts.map +1 -0
  232. package/dist/terrain/lib/parse-terrain.js +150 -0
  233. package/dist/terrain/lib/parse-terrain.js.map +1 -0
  234. package/dist/terrain/lib/terrain-contracts.d.ts +58 -0
  235. package/dist/terrain/lib/terrain-contracts.d.ts.map +1 -0
  236. package/dist/terrain/lib/terrain-contracts.js +5 -0
  237. package/dist/terrain/lib/terrain-contracts.js.map +1 -0
  238. package/dist/terrain/lib/terrain-height-field.d.ts +51 -0
  239. package/dist/terrain/lib/terrain-height-field.d.ts.map +1 -0
  240. package/dist/terrain/lib/terrain-height-field.js +260 -0
  241. package/dist/terrain/lib/terrain-height-field.js.map +1 -0
  242. package/dist/terrain/lib/terrain-height-grid.d.ts +14 -0
  243. package/dist/terrain/lib/terrain-height-grid.d.ts.map +1 -0
  244. package/dist/terrain/lib/terrain-height-grid.js +104 -0
  245. package/dist/terrain/lib/terrain-height-grid.js.map +1 -0
  246. package/dist/terrain/lib/terrain-heightmap-types.d.ts +30 -0
  247. package/dist/terrain/lib/terrain-heightmap-types.d.ts.map +1 -0
  248. package/dist/terrain/lib/terrain-heightmap-types.js +5 -0
  249. package/dist/terrain/lib/terrain-heightmap-types.js.map +1 -0
  250. package/dist/terrain/lib/terrain-neighborhood.d.ts +15 -0
  251. package/dist/terrain/lib/terrain-neighborhood.d.ts.map +1 -0
  252. package/dist/terrain/lib/terrain-neighborhood.js +58 -0
  253. package/dist/terrain/lib/terrain-neighborhood.js.map +1 -0
  254. package/dist/terrain/lib/utils/version.d.ts +2 -0
  255. package/dist/terrain/lib/utils/version.d.ts.map +1 -0
  256. package/dist/terrain/lib/utils/version.js +8 -0
  257. package/dist/terrain/lib/utils/version.js.map +1 -0
  258. package/dist/terrain/libs/README.md +10 -0
  259. package/dist/terrain/libs/martini-LICENSE +15 -0
  260. package/dist/terrain/libs/martini.d.mts +19 -0
  261. package/dist/terrain/libs/martini.mjs +164 -0
  262. package/dist/terrain/quantized-mesh-loader-types.d.ts +18 -0
  263. package/dist/terrain/quantized-mesh-loader-types.d.ts.map +1 -0
  264. package/dist/terrain/quantized-mesh-loader-types.js +26 -0
  265. package/dist/terrain/quantized-mesh-loader-types.js.map +1 -0
  266. package/dist/terrain/quantized-mesh-loader.d.ts +5 -0
  267. package/dist/terrain/quantized-mesh-loader.d.ts.map +1 -0
  268. package/dist/terrain/quantized-mesh-loader.js +31 -0
  269. package/dist/terrain/quantized-mesh-loader.js.map +1 -0
  270. package/dist/terrain/quantized-mesh-writer.d.ts +35 -0
  271. package/dist/terrain/quantized-mesh-writer.d.ts.map +1 -0
  272. package/dist/terrain/quantized-mesh-writer.js +251 -0
  273. package/dist/terrain/quantized-mesh-writer.js.map +1 -0
  274. package/dist/terrain/terrain-format.d.ts +22 -0
  275. package/dist/terrain/terrain-format.d.ts.map +1 -0
  276. package/dist/terrain/terrain-format.js +25 -0
  277. package/dist/terrain/terrain-format.js.map +1 -0
  278. package/dist/terrain/terrain-loader-types.d.ts +17 -0
  279. package/dist/terrain/terrain-loader-types.d.ts.map +1 -0
  280. package/dist/terrain/terrain-loader-types.js +33 -0
  281. package/dist/terrain/terrain-loader-types.js.map +1 -0
  282. package/dist/terrain/terrain-loader.d.ts +16 -0
  283. package/dist/terrain/terrain-loader.d.ts.map +1 -0
  284. package/dist/terrain/terrain-loader.js +58 -0
  285. package/dist/terrain/terrain-loader.js.map +1 -0
  286. package/dist/terrain/unbundled.d.ts +5 -0
  287. package/dist/terrain/unbundled.d.ts.map +1 -0
  288. package/dist/terrain/unbundled.js +6 -0
  289. package/dist/terrain/unbundled.js.map +1 -0
  290. package/dist/terrain/workers/quantized-mesh-worker.d.ts +2 -0
  291. package/dist/terrain/workers/quantized-mesh-worker.d.ts.map +1 -0
  292. package/dist/terrain/workers/quantized-mesh-worker.js +7 -0
  293. package/dist/terrain/workers/quantized-mesh-worker.js.map +1 -0
  294. package/dist/terrain/workers/terrain-worker.d.ts +2 -0
  295. package/dist/terrain/workers/terrain-worker.d.ts.map +1 -0
  296. package/dist/terrain/workers/terrain-worker.js +7 -0
  297. package/dist/terrain/workers/terrain-worker.js.map +1 -0
  298. package/dist/terrain-worker.js +18238 -0
  299. package/package.json +344 -4
  300. package/src/geotiff/advanced.ts +29 -0
  301. package/src/geotiff/bundled.ts +6 -0
  302. package/src/geotiff/discover-geotiff.ts +70 -0
  303. package/src/geotiff/geotiff-format.ts +27 -0
  304. package/src/geotiff/geotiff-loader-types.ts +50 -0
  305. package/src/geotiff/geotiff-loader.ts +107 -0
  306. package/src/geotiff/geotiff-raster-loader-types.ts +31 -0
  307. package/src/geotiff/geotiff-raster-loader.ts +85 -0
  308. package/src/geotiff/geotiff-raster-types.ts +72 -0
  309. package/src/geotiff/geotiff-source-loader-types.ts +55 -0
  310. package/src/geotiff/geotiff-source-loader.ts +1738 -0
  311. package/src/geotiff/index.ts +6 -0
  312. package/src/geotiff/lib/load-geotiff.ts +88 -0
  313. package/src/geotiff/lib/ome/load-ome-tiff.ts +55 -0
  314. package/src/geotiff/lib/ome/ome-indexers.ts +132 -0
  315. package/src/geotiff/lib/ome/ome-utils.ts +78 -0
  316. package/src/geotiff/lib/ome/omexml.ts +183 -0
  317. package/src/geotiff/lib/ome/utils.ts +43 -0
  318. package/src/geotiff/lib/tiff/decode-tiff-samples.ts +214 -0
  319. package/src/geotiff/lib/tiff/geotiff-decoder-adapter.ts +114 -0
  320. package/src/geotiff/lib/tiff/geotiff-source-adapter.ts +65 -0
  321. package/src/geotiff/lib/tiff/plan-tiff-blocks.ts +130 -0
  322. package/src/geotiff/lib/tiff/read-tiff-directory.ts +243 -0
  323. package/src/geotiff/lib/tiff/tiff-gdal-metadata.ts +59 -0
  324. package/src/geotiff/lib/tiff/tiff-metadata.ts +204 -0
  325. package/src/geotiff/lib/tiff/tiff-numeric-decoder.ts +87 -0
  326. package/src/geotiff/lib/tiff/tiff-source-decoder.ts +112 -0
  327. package/src/geotiff/lib/tiff/tiff-types.ts +56 -0
  328. package/src/geotiff/lib/tiff-pixel-source.ts +103 -0
  329. package/src/geotiff/lib/utils/Pool.ts.disabled +99 -0
  330. package/src/geotiff/lib/utils/decoder.worker.ts.disabled +21 -0
  331. package/src/geotiff/lib/utils/proxies.ts.disabled +96 -0
  332. package/src/geotiff/lib/utils/tiff-utils.ts +49 -0
  333. package/src/geotiff/loaders.ts +79 -0
  334. package/src/geotiff/ometiff-source-loader-types.ts +47 -0
  335. package/src/geotiff/ometiff-source-loader.ts +420 -0
  336. package/src/geotiff/types.ts +87 -0
  337. package/src/geotiff/unbundled.ts +6 -0
  338. package/src/index.ts +57 -0
  339. package/src/lerc/bundled.ts +6 -0
  340. package/src/lerc/index.ts +10 -0
  341. package/src/lerc/lerc-format.ts +16 -0
  342. package/src/lerc/lerc-loader-types.ts +51 -0
  343. package/src/lerc/lerc-loader.ts +41 -0
  344. package/src/lerc/lerc-wasm-url.ts +9 -0
  345. package/src/lerc/lib/parsers/lerc/lerc-types.ts +45 -0
  346. package/src/lerc/libs/lerc/LICENSE +101 -0
  347. package/src/lerc/libs/lerc/NOTICE +23 -0
  348. package/src/lerc/libs/lerc/lerc-wasm.wasm +0 -0
  349. package/src/lerc/unbundled.ts +6 -0
  350. package/src/lerc/workers/lerc-worker.ts +8 -0
  351. package/src/quantized-mesh.ts +5 -0
  352. package/src/terrain/bundled.ts +8 -0
  353. package/src/terrain/heightmap.ts +30 -0
  354. package/src/terrain/index.ts +41 -0
  355. package/src/terrain/lib/decode-quantized-mesh.ts +329 -0
  356. package/src/terrain/lib/decode-terrain-heightmap.ts +68 -0
  357. package/src/terrain/lib/delatin/index.ts +495 -0
  358. package/src/terrain/lib/helpers/skirt.ts +172 -0
  359. package/src/terrain/lib/parse-quantized-mesh.ts +122 -0
  360. package/src/terrain/lib/parse-terrain.ts +217 -0
  361. package/src/terrain/lib/terrain-contracts.ts +68 -0
  362. package/src/terrain/lib/terrain-height-field.ts +355 -0
  363. package/src/terrain/lib/terrain-height-grid.ts +157 -0
  364. package/src/terrain/lib/terrain-heightmap-types.ts +35 -0
  365. package/src/terrain/lib/terrain-neighborhood.ts +69 -0
  366. package/src/terrain/lib/utils/version.ts +8 -0
  367. package/src/terrain/libs/README.md +10 -0
  368. package/src/terrain/libs/martini-LICENSE +15 -0
  369. package/src/terrain/libs/martini.d.mts +19 -0
  370. package/src/terrain/libs/martini.mjs +164 -0
  371. package/src/terrain/quantized-mesh-loader-types.ts +44 -0
  372. package/src/terrain/quantized-mesh-loader.ts +46 -0
  373. package/src/terrain/quantized-mesh-writer.ts +380 -0
  374. package/src/terrain/terrain-format.ts +28 -0
  375. package/src/terrain/terrain-loader-types.ts +52 -0
  376. package/src/terrain/terrain-loader.ts +79 -0
  377. package/src/terrain/unbundled.ts +8 -0
  378. package/src/terrain/workers/quantized-mesh-worker.ts +8 -0
  379. package/src/terrain/workers/terrain-worker.ts +8 -0
@@ -0,0 +1,1406 @@
1
+ var __create = Object.create;
2
+ var __defProp = Object.defineProperty;
3
+ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
4
+ var __getOwnPropNames = Object.getOwnPropertyNames;
5
+ var __getProtoOf = Object.getPrototypeOf;
6
+ var __hasOwnProp = Object.prototype.hasOwnProperty;
7
+ var __export = (target, all) => {
8
+ for (var name in all)
9
+ __defProp(target, name, { get: all[name], enumerable: true });
10
+ };
11
+ var __copyProps = (to, from, except, desc) => {
12
+ if (from && typeof from === "object" || typeof from === "function") {
13
+ for (let key of __getOwnPropNames(from))
14
+ if (!__hasOwnProp.call(to, key) && key !== except)
15
+ __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
16
+ }
17
+ return to;
18
+ };
19
+ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
20
+ // If the importer is in node compatibility mode or this is not an ESM
21
+ // file that has been converted to a CommonJS file using a Babel-
22
+ // compatible transform (i.e. "__esModule" has not been set), then set
23
+ // "default" to the CommonJS "module.exports" for node compatibility.
24
+ isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
25
+ mod
26
+ ));
27
+ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
28
+
29
+ // dist/terrain/index.js
30
+ var index_exports = {};
31
+ __export(index_exports, {
32
+ QuantizedMeshFormat: () => QuantizedMeshFormat,
33
+ QuantizedMeshLoader: () => QuantizedMeshLoader,
34
+ QuantizedMeshLoaderWithParser: () => QuantizedMeshLoaderWithParser,
35
+ QuantizedMeshWorkerLoader: () => QuantizedMeshLoader,
36
+ QuantizedMeshWriter: () => QuantizedMeshWriter,
37
+ TerrainFormat: () => TerrainFormat,
38
+ TerrainLoader: () => TerrainLoader,
39
+ TerrainLoaderWithParser: () => TerrainLoaderWithParser,
40
+ TerrainWorkerLoader: () => TerrainLoader,
41
+ parseTerrain: () => parseTerrain
42
+ });
43
+ module.exports = __toCommonJS(index_exports);
44
+
45
+ // dist/terrain/terrain-format.js
46
+ var TerrainFormat = {
47
+ name: "Terrain",
48
+ id: "terrain",
49
+ module: "raster",
50
+ encoding: "image",
51
+ format: "terrain",
52
+ extensions: ["png", "pngraw", "jpg", "jpeg", "gif", "webp", "bmp"],
53
+ mimeTypes: ["image/png", "image/jpeg", "image/gif", "image/webp", "image/bmp"]
54
+ };
55
+ var QuantizedMeshFormat = {
56
+ name: "Quantized Mesh",
57
+ id: "quantized-mesh",
58
+ module: "raster",
59
+ encoding: "binary",
60
+ format: "quantized-mesh",
61
+ extensions: ["terrain"],
62
+ mimeTypes: ["application/vnd.quantized-mesh"],
63
+ binary: true
64
+ };
65
+
66
+ // dist/terrain/lib/utils/version.js
67
+ var VERSION = true ? "5.0.0-alpha.13" : "latest";
68
+
69
+ // dist/terrain/terrain-loader-types.js
70
+ var TerrainLoader = {
71
+ dataType: null,
72
+ batchType: null,
73
+ ...TerrainFormat,
74
+ version: VERSION,
75
+ worker: true,
76
+ /** Loads the parser-bearing terrain loader implementation. */
77
+ preload: async () => (await import("@loaders.gl/raster/terrain/terrain-loader")).TerrainLoaderWithParser,
78
+ options: {
79
+ terrain: {
80
+ tesselator: "auto",
81
+ shape: "arrow-table",
82
+ bounds: void 0,
83
+ meshMaxError: 10,
84
+ elevationDecoder: {
85
+ rScaler: 1,
86
+ gScaler: 0,
87
+ bScaler: 0,
88
+ offset: 0
89
+ },
90
+ skirtHeight: void 0
91
+ }
92
+ }
93
+ };
94
+
95
+ // dist/terrain/terrain-loader.js
96
+ var import_arrow_transport = require("@loaders.gl/core/schema-utils/arrow-transport");
97
+ var import_loader_utils2 = require("@loaders.gl/core/loader-utils");
98
+ var import_schema_utils2 = require("@loaders.gl/core/schema-utils");
99
+ var import_images = require("@loaders.gl/images");
100
+
101
+ // dist/terrain/lib/parse-terrain.js
102
+ var import_schema_utils = require("@loaders.gl/core/schema-utils");
103
+
104
+ // dist/terrain/libs/martini.mjs
105
+ var Martini = class {
106
+ constructor(gridSize = 257) {
107
+ this.gridSize = gridSize;
108
+ const tileSize = gridSize - 1;
109
+ if (tileSize & tileSize - 1) throw new Error(
110
+ `Expected grid size to be 2^n+1, got ${gridSize}.`
111
+ );
112
+ this.numTriangles = tileSize * tileSize * 2 - 2;
113
+ this.numParentTriangles = this.numTriangles - tileSize * tileSize;
114
+ this.indices = new Uint32Array(this.gridSize * this.gridSize);
115
+ this.coords = new Uint16Array(this.numTriangles * 4);
116
+ for (let i = 0; i < this.numTriangles; i++) {
117
+ let id = i + 2;
118
+ let ax = 0, ay = 0, bx = 0, by = 0, cx = 0, cy = 0;
119
+ if (id & 1) {
120
+ bx = by = cx = tileSize;
121
+ } else {
122
+ ax = ay = cy = tileSize;
123
+ }
124
+ while ((id >>= 1) > 1) {
125
+ const mx = ax + bx >> 1;
126
+ const my = ay + by >> 1;
127
+ if (id & 1) {
128
+ bx = ax;
129
+ by = ay;
130
+ ax = cx;
131
+ ay = cy;
132
+ } else {
133
+ ax = bx;
134
+ ay = by;
135
+ bx = cx;
136
+ by = cy;
137
+ }
138
+ cx = mx;
139
+ cy = my;
140
+ }
141
+ const k = i * 4;
142
+ this.coords[k + 0] = ax;
143
+ this.coords[k + 1] = ay;
144
+ this.coords[k + 2] = bx;
145
+ this.coords[k + 3] = by;
146
+ }
147
+ }
148
+ createTile(terrain) {
149
+ return new Tile(terrain, this);
150
+ }
151
+ };
152
+ var Tile = class {
153
+ constructor(terrain, martini) {
154
+ const size = martini.gridSize;
155
+ if (terrain.length !== size * size) throw new Error(
156
+ `Expected terrain data of length ${size * size} (${size} x ${size}), got ${terrain.length}.`
157
+ );
158
+ this.terrain = terrain;
159
+ this.martini = martini;
160
+ this.errors = new Float32Array(terrain.length);
161
+ this.update();
162
+ }
163
+ update() {
164
+ const { numTriangles, numParentTriangles, coords, gridSize: size } = this.martini;
165
+ const { terrain, errors } = this;
166
+ for (let i = numTriangles - 1; i >= 0; i--) {
167
+ const k = i * 4;
168
+ const ax = coords[k + 0];
169
+ const ay = coords[k + 1];
170
+ const bx = coords[k + 2];
171
+ const by = coords[k + 3];
172
+ const mx = ax + bx >> 1;
173
+ const my = ay + by >> 1;
174
+ const cx = mx + my - ay;
175
+ const cy = my + ax - mx;
176
+ const interpolatedHeight = (terrain[ay * size + ax] + terrain[by * size + bx]) / 2;
177
+ const middleIndex = my * size + mx;
178
+ const middleError = Math.abs(interpolatedHeight - terrain[middleIndex]);
179
+ errors[middleIndex] = Math.max(errors[middleIndex], middleError);
180
+ if (i < numParentTriangles) {
181
+ const leftChildIndex = (ay + cy >> 1) * size + (ax + cx >> 1);
182
+ const rightChildIndex = (by + cy >> 1) * size + (bx + cx >> 1);
183
+ errors[middleIndex] = Math.max(errors[middleIndex], errors[leftChildIndex], errors[rightChildIndex]);
184
+ }
185
+ }
186
+ }
187
+ getMesh(maxError = 0) {
188
+ const { gridSize: size, indices } = this.martini;
189
+ const { errors } = this;
190
+ let numVertices = 0;
191
+ let numTriangles = 0;
192
+ const max = size - 1;
193
+ indices.fill(0);
194
+ function countElements(ax, ay, bx, by, cx, cy) {
195
+ const mx = ax + bx >> 1;
196
+ const my = ay + by >> 1;
197
+ if (Math.abs(ax - cx) + Math.abs(ay - cy) > 1 && errors[my * size + mx] > maxError) {
198
+ countElements(cx, cy, ax, ay, mx, my);
199
+ countElements(bx, by, cx, cy, mx, my);
200
+ } else {
201
+ indices[ay * size + ax] = indices[ay * size + ax] || ++numVertices;
202
+ indices[by * size + bx] = indices[by * size + bx] || ++numVertices;
203
+ indices[cy * size + cx] = indices[cy * size + cx] || ++numVertices;
204
+ numTriangles++;
205
+ }
206
+ }
207
+ countElements(0, 0, max, max, max, 0);
208
+ countElements(max, max, 0, 0, 0, max);
209
+ const vertices = new Uint16Array(numVertices * 2);
210
+ const triangles = new Uint32Array(numTriangles * 3);
211
+ let triIndex = 0;
212
+ function processTriangle(ax, ay, bx, by, cx, cy) {
213
+ const mx = ax + bx >> 1;
214
+ const my = ay + by >> 1;
215
+ if (Math.abs(ax - cx) + Math.abs(ay - cy) > 1 && errors[my * size + mx] > maxError) {
216
+ processTriangle(cx, cy, ax, ay, mx, my);
217
+ processTriangle(bx, by, cx, cy, mx, my);
218
+ } else {
219
+ const a = indices[ay * size + ax] - 1;
220
+ const b = indices[by * size + bx] - 1;
221
+ const c = indices[cy * size + cx] - 1;
222
+ vertices[2 * a] = ax;
223
+ vertices[2 * a + 1] = ay;
224
+ vertices[2 * b] = bx;
225
+ vertices[2 * b + 1] = by;
226
+ vertices[2 * c] = cx;
227
+ vertices[2 * c + 1] = cy;
228
+ triangles[triIndex++] = a;
229
+ triangles[triIndex++] = b;
230
+ triangles[triIndex++] = c;
231
+ }
232
+ }
233
+ processTriangle(0, 0, max, max, max, 0);
234
+ processTriangle(max, max, 0, 0, 0, max);
235
+ return { vertices, triangles };
236
+ }
237
+ };
238
+
239
+ // dist/terrain/lib/delatin/index.js
240
+ var Delatin = class {
241
+ constructor(data, width, height = width) {
242
+ this.data = data;
243
+ this.width = width;
244
+ this.height = height;
245
+ this.coords = [];
246
+ this.triangles = [];
247
+ this._halfedges = [];
248
+ this._candidates = [];
249
+ this._queueIndices = [];
250
+ this._queue = [];
251
+ this._errors = [];
252
+ this._rms = [];
253
+ this._pending = [];
254
+ this._pendingLen = 0;
255
+ this._rmsSum = 0;
256
+ const x1 = width - 1;
257
+ const y1 = height - 1;
258
+ const p0 = this._addPoint(0, 0);
259
+ const p1 = this._addPoint(x1, 0);
260
+ const p2 = this._addPoint(0, y1);
261
+ const p3 = this._addPoint(x1, y1);
262
+ const t0 = this._addTriangle(p3, p0, p2, -1, -1, -1);
263
+ this._addTriangle(p0, p3, p1, t0, -1, -1);
264
+ this._flush();
265
+ }
266
+ // refine the mesh until its maximum error gets below the given one
267
+ run(maxError = 1) {
268
+ while (this.getMaxError() > maxError) {
269
+ this.refine();
270
+ }
271
+ }
272
+ // refine the mesh with a single point
273
+ refine() {
274
+ this._step();
275
+ this._flush();
276
+ }
277
+ // max error of the current mesh
278
+ getMaxError() {
279
+ return this._errors[0];
280
+ }
281
+ // root-mean-square deviation of the current mesh
282
+ getRMSD() {
283
+ return this._rmsSum > 0 ? Math.sqrt(this._rmsSum / (this.width * this.height)) : 0;
284
+ }
285
+ // height value at a given position
286
+ heightAt(x, y) {
287
+ return this.data[this.width * y + x];
288
+ }
289
+ // rasterize and queue all triangles that got added or updated in _step
290
+ _flush() {
291
+ const coords = this.coords;
292
+ for (let i = 0; i < this._pendingLen; i++) {
293
+ const t = this._pending[i];
294
+ const a = 2 * this.triangles[t * 3 + 0];
295
+ const b = 2 * this.triangles[t * 3 + 1];
296
+ const c = 2 * this.triangles[t * 3 + 2];
297
+ this._findCandidate(coords[a], coords[a + 1], coords[b], coords[b + 1], coords[c], coords[c + 1], t);
298
+ }
299
+ this._pendingLen = 0;
300
+ }
301
+ // rasterize a triangle, find its max error, and queue it for processing
302
+ _findCandidate(p0x, p0y, p1x, p1y, p2x, p2y, t) {
303
+ const minX = Math.min(p0x, p1x, p2x);
304
+ const minY = Math.min(p0y, p1y, p2y);
305
+ const maxX = Math.max(p0x, p1x, p2x);
306
+ const maxY = Math.max(p0y, p1y, p2y);
307
+ let w00 = orient(p1x, p1y, p2x, p2y, minX, minY);
308
+ let w01 = orient(p2x, p2y, p0x, p0y, minX, minY);
309
+ let w02 = orient(p0x, p0y, p1x, p1y, minX, minY);
310
+ const a01 = p1y - p0y;
311
+ const b01 = p0x - p1x;
312
+ const a12 = p2y - p1y;
313
+ const b12 = p1x - p2x;
314
+ const a20 = p0y - p2y;
315
+ const b20 = p2x - p0x;
316
+ const a = orient(p0x, p0y, p1x, p1y, p2x, p2y);
317
+ const z0 = this.heightAt(p0x, p0y) / a;
318
+ const z1 = this.heightAt(p1x, p1y) / a;
319
+ const z2 = this.heightAt(p2x, p2y) / a;
320
+ let maxError = 0;
321
+ let mx = 0;
322
+ let my = 0;
323
+ let rms = 0;
324
+ for (let y = minY; y <= maxY; y++) {
325
+ let dx = 0;
326
+ if (w00 < 0 && a12 !== 0) {
327
+ dx = Math.max(dx, Math.floor(-w00 / a12));
328
+ }
329
+ if (w01 < 0 && a20 !== 0) {
330
+ dx = Math.max(dx, Math.floor(-w01 / a20));
331
+ }
332
+ if (w02 < 0 && a01 !== 0) {
333
+ dx = Math.max(dx, Math.floor(-w02 / a01));
334
+ }
335
+ let w0 = w00 + a12 * dx;
336
+ let w1 = w01 + a20 * dx;
337
+ let w2 = w02 + a01 * dx;
338
+ let wasInside = false;
339
+ for (let x = minX + dx; x <= maxX; x++) {
340
+ if (w0 >= 0 && w1 >= 0 && w2 >= 0) {
341
+ wasInside = true;
342
+ const z = z0 * w0 + z1 * w1 + z2 * w2;
343
+ const dz = Math.abs(z - this.heightAt(x, y));
344
+ rms += dz * dz;
345
+ if (dz > maxError) {
346
+ maxError = dz;
347
+ mx = x;
348
+ my = y;
349
+ }
350
+ } else if (wasInside) {
351
+ break;
352
+ }
353
+ w0 += a12;
354
+ w1 += a20;
355
+ w2 += a01;
356
+ }
357
+ w00 += b12;
358
+ w01 += b20;
359
+ w02 += b01;
360
+ }
361
+ if (mx === p0x && my === p0y || mx === p1x && my === p1y || mx === p2x && my === p2y) {
362
+ maxError = 0;
363
+ }
364
+ this._candidates[2 * t] = mx;
365
+ this._candidates[2 * t + 1] = my;
366
+ this._rms[t] = rms;
367
+ this._queuePush(t, maxError, rms);
368
+ }
369
+ // process the next triangle in the queue, splitting it with a new point
370
+ _step() {
371
+ const t = this._queuePop();
372
+ const e0 = t * 3 + 0;
373
+ const e1 = t * 3 + 1;
374
+ const e2 = t * 3 + 2;
375
+ const p0 = this.triangles[e0];
376
+ const p1 = this.triangles[e1];
377
+ const p2 = this.triangles[e2];
378
+ const ax = this.coords[2 * p0];
379
+ const ay = this.coords[2 * p0 + 1];
380
+ const bx = this.coords[2 * p1];
381
+ const by = this.coords[2 * p1 + 1];
382
+ const cx = this.coords[2 * p2];
383
+ const cy = this.coords[2 * p2 + 1];
384
+ const px = this._candidates[2 * t];
385
+ const py = this._candidates[2 * t + 1];
386
+ const pn = this._addPoint(px, py);
387
+ if (orient(ax, ay, bx, by, px, py) === 0) {
388
+ this._handleCollinear(pn, e0);
389
+ } else if (orient(bx, by, cx, cy, px, py) === 0) {
390
+ this._handleCollinear(pn, e1);
391
+ } else if (orient(cx, cy, ax, ay, px, py) === 0) {
392
+ this._handleCollinear(pn, e2);
393
+ } else {
394
+ const h0 = this._halfedges[e0];
395
+ const h1 = this._halfedges[e1];
396
+ const h2 = this._halfedges[e2];
397
+ const t0 = this._addTriangle(p0, p1, pn, h0, -1, -1, e0);
398
+ const t1 = this._addTriangle(p1, p2, pn, h1, -1, t0 + 1);
399
+ const t2 = this._addTriangle(p2, p0, pn, h2, t0 + 2, t1 + 1);
400
+ this._legalize(t0);
401
+ this._legalize(t1);
402
+ this._legalize(t2);
403
+ }
404
+ }
405
+ // add coordinates for a new vertex
406
+ _addPoint(x, y) {
407
+ const i = this.coords.length >> 1;
408
+ this.coords.push(x, y);
409
+ return i;
410
+ }
411
+ // add or update a triangle in the mesh
412
+ _addTriangle(a, b, c, ab, bc, ca, e = this.triangles.length) {
413
+ const t = e / 3;
414
+ this.triangles[e + 0] = a;
415
+ this.triangles[e + 1] = b;
416
+ this.triangles[e + 2] = c;
417
+ this._halfedges[e + 0] = ab;
418
+ this._halfedges[e + 1] = bc;
419
+ this._halfedges[e + 2] = ca;
420
+ if (ab >= 0) {
421
+ this._halfedges[ab] = e + 0;
422
+ }
423
+ if (bc >= 0) {
424
+ this._halfedges[bc] = e + 1;
425
+ }
426
+ if (ca >= 0) {
427
+ this._halfedges[ca] = e + 2;
428
+ }
429
+ this._candidates[2 * t + 0] = 0;
430
+ this._candidates[2 * t + 1] = 0;
431
+ this._queueIndices[t] = -1;
432
+ this._rms[t] = 0;
433
+ this._pending[this._pendingLen++] = t;
434
+ return e;
435
+ }
436
+ _legalize(a) {
437
+ const b = this._halfedges[a];
438
+ if (b < 0) {
439
+ return;
440
+ }
441
+ const a0 = a - a % 3;
442
+ const b0 = b - b % 3;
443
+ const al = a0 + (a + 1) % 3;
444
+ const ar = a0 + (a + 2) % 3;
445
+ const bl = b0 + (b + 2) % 3;
446
+ const br = b0 + (b + 1) % 3;
447
+ const p0 = this.triangles[ar];
448
+ const pr = this.triangles[a];
449
+ const pl = this.triangles[al];
450
+ const p1 = this.triangles[bl];
451
+ const coords = this.coords;
452
+ if (!inCircle(coords[2 * p0], coords[2 * p0 + 1], coords[2 * pr], coords[2 * pr + 1], coords[2 * pl], coords[2 * pl + 1], coords[2 * p1], coords[2 * p1 + 1])) {
453
+ return;
454
+ }
455
+ const hal = this._halfedges[al];
456
+ const har = this._halfedges[ar];
457
+ const hbl = this._halfedges[bl];
458
+ const hbr = this._halfedges[br];
459
+ this._queueRemove(a0 / 3);
460
+ this._queueRemove(b0 / 3);
461
+ const t0 = this._addTriangle(p0, p1, pl, -1, hbl, hal, a0);
462
+ const t1 = this._addTriangle(p1, p0, pr, t0, har, hbr, b0);
463
+ this._legalize(t0 + 1);
464
+ this._legalize(t1 + 2);
465
+ }
466
+ // handle a case where new vertex is on the edge of a triangle
467
+ _handleCollinear(pn, a) {
468
+ const a0 = a - a % 3;
469
+ const al = a0 + (a + 1) % 3;
470
+ const ar = a0 + (a + 2) % 3;
471
+ const p0 = this.triangles[ar];
472
+ const pr = this.triangles[a];
473
+ const pl = this.triangles[al];
474
+ const hal = this._halfedges[al];
475
+ const har = this._halfedges[ar];
476
+ const b = this._halfedges[a];
477
+ if (b < 0) {
478
+ const t02 = this._addTriangle(pn, p0, pr, -1, har, -1, a0);
479
+ const t12 = this._addTriangle(p0, pn, pl, t02, -1, hal);
480
+ this._legalize(t02 + 1);
481
+ this._legalize(t12 + 2);
482
+ return;
483
+ }
484
+ const b0 = b - b % 3;
485
+ const bl = b0 + (b + 2) % 3;
486
+ const br = b0 + (b + 1) % 3;
487
+ const p1 = this.triangles[bl];
488
+ const hbl = this._halfedges[bl];
489
+ const hbr = this._halfedges[br];
490
+ this._queueRemove(b0 / 3);
491
+ const t0 = this._addTriangle(p0, pr, pn, har, -1, -1, a0);
492
+ const t1 = this._addTriangle(pr, p1, pn, hbr, -1, t0 + 1, b0);
493
+ const t2 = this._addTriangle(p1, pl, pn, hbl, -1, t1 + 1);
494
+ const t3 = this._addTriangle(pl, p0, pn, hal, t0 + 2, t2 + 1);
495
+ this._legalize(t0);
496
+ this._legalize(t1);
497
+ this._legalize(t2);
498
+ this._legalize(t3);
499
+ }
500
+ // priority queue methods
501
+ _queuePush(t, error, rms) {
502
+ const i = this._queue.length;
503
+ this._queueIndices[t] = i;
504
+ this._queue.push(t);
505
+ this._errors.push(error);
506
+ this._rmsSum += rms;
507
+ this._queueUp(i);
508
+ }
509
+ _queuePop() {
510
+ const n = this._queue.length - 1;
511
+ this._queueSwap(0, n);
512
+ this._queueDown(0, n);
513
+ return this._queuePopBack();
514
+ }
515
+ _queuePopBack() {
516
+ const t = this._queue.pop();
517
+ this._errors.pop();
518
+ this._rmsSum -= this._rms[t];
519
+ this._queueIndices[t] = -1;
520
+ return t;
521
+ }
522
+ _queueRemove(t) {
523
+ const i = this._queueIndices[t];
524
+ if (i < 0) {
525
+ const it = this._pending.indexOf(t);
526
+ if (it !== -1) {
527
+ this._pending[it] = this._pending[--this._pendingLen];
528
+ } else {
529
+ throw new Error("Broken triangulation (something went wrong).");
530
+ }
531
+ return;
532
+ }
533
+ const n = this._queue.length - 1;
534
+ if (n !== i) {
535
+ this._queueSwap(i, n);
536
+ if (!this._queueDown(i, n)) {
537
+ this._queueUp(i);
538
+ }
539
+ }
540
+ this._queuePopBack();
541
+ }
542
+ _queueLess(i, j) {
543
+ return this._errors[i] > this._errors[j];
544
+ }
545
+ _queueSwap(i, j) {
546
+ const pi = this._queue[i];
547
+ const pj = this._queue[j];
548
+ this._queue[i] = pj;
549
+ this._queue[j] = pi;
550
+ this._queueIndices[pi] = j;
551
+ this._queueIndices[pj] = i;
552
+ const e = this._errors[i];
553
+ this._errors[i] = this._errors[j];
554
+ this._errors[j] = e;
555
+ }
556
+ _queueUp(j0) {
557
+ let j = j0;
558
+ while (true) {
559
+ const i = j - 1 >> 1;
560
+ if (i === j || !this._queueLess(j, i)) {
561
+ break;
562
+ }
563
+ this._queueSwap(i, j);
564
+ j = i;
565
+ }
566
+ }
567
+ _queueDown(i0, n) {
568
+ let i = i0;
569
+ while (true) {
570
+ const j1 = 2 * i + 1;
571
+ if (j1 >= n || j1 < 0) {
572
+ break;
573
+ }
574
+ const j2 = j1 + 1;
575
+ let j = j1;
576
+ if (j2 < n && this._queueLess(j2, j1)) {
577
+ j = j2;
578
+ }
579
+ if (!this._queueLess(j, i)) {
580
+ break;
581
+ }
582
+ this._queueSwap(i, j);
583
+ i = j;
584
+ }
585
+ return i > i0;
586
+ }
587
+ };
588
+ function orient(ax, ay, bx, by, cx, cy) {
589
+ return (bx - cx) * (ay - cy) - (by - cy) * (ax - cx);
590
+ }
591
+ function inCircle(ax, ay, bx, by, cx, cy, px, py) {
592
+ const dx = ax - px;
593
+ const dy = ay - py;
594
+ const ex = bx - px;
595
+ const ey = by - py;
596
+ const fx = cx - px;
597
+ const fy = cy - py;
598
+ const ap = dx * dx + dy * dy;
599
+ const bp = ex * ex + ey * ey;
600
+ const cp = fx * fx + fy * fy;
601
+ return dx * (ey * cp - bp * fy) - dy * (ex * cp - bp * fx) + ap * (ex * fy - ey * fx) < 0;
602
+ }
603
+
604
+ // dist/terrain/lib/helpers/skirt.js
605
+ var import_loader_utils = require("@loaders.gl/core/loader-utils");
606
+ function addSkirt(attributes, triangles, skirtHeight, outsideIndices) {
607
+ const outsideEdges = outsideIndices ? getOutsideEdgesFromIndices(outsideIndices, attributes.POSITION.value) : getOutsideEdgesFromTriangles(triangles);
608
+ const newPosition = new attributes.POSITION.value.constructor(outsideEdges.length * 6);
609
+ const newTexcoord0 = new attributes.TEXCOORD_0.value.constructor(outsideEdges.length * 4);
610
+ const newTriangles = new triangles.constructor(outsideEdges.length * 6);
611
+ for (let i = 0; i < outsideEdges.length; i++) {
612
+ const edge = outsideEdges[i];
613
+ updateAttributesForNewEdge({
614
+ edge,
615
+ edgeIndex: i,
616
+ attributes,
617
+ skirtHeight,
618
+ newPosition,
619
+ newTexcoord0,
620
+ newTriangles
621
+ });
622
+ }
623
+ attributes.POSITION.value = (0, import_loader_utils.concatenateTypedArrays)(attributes.POSITION.value, newPosition);
624
+ attributes.TEXCOORD_0.value = (0, import_loader_utils.concatenateTypedArrays)(attributes.TEXCOORD_0.value, newTexcoord0);
625
+ const resultTriangles = triangles instanceof Array ? triangles.concat(newTriangles) : (0, import_loader_utils.concatenateTypedArrays)(triangles, newTriangles);
626
+ return {
627
+ attributes,
628
+ triangles: resultTriangles
629
+ };
630
+ }
631
+ function getOutsideEdgesFromTriangles(triangles) {
632
+ const edges = [];
633
+ for (let i = 0; i < triangles.length; i += 3) {
634
+ edges.push([triangles[i], triangles[i + 1]]);
635
+ edges.push([triangles[i + 1], triangles[i + 2]]);
636
+ edges.push([triangles[i + 2], triangles[i]]);
637
+ }
638
+ edges.sort((a, b) => Math.min(...a) - Math.min(...b) || Math.max(...a) - Math.max(...b));
639
+ const outsideEdges = [];
640
+ let index = 0;
641
+ while (index < edges.length) {
642
+ if (edges[index][0] === edges[index + 1]?.[1] && edges[index][1] === edges[index + 1]?.[0]) {
643
+ index += 2;
644
+ } else {
645
+ outsideEdges.push(edges[index]);
646
+ index++;
647
+ }
648
+ }
649
+ return outsideEdges;
650
+ }
651
+ function getOutsideEdgesFromIndices(indices, position) {
652
+ indices.westIndices.sort((a, b) => position[3 * a + 1] - position[3 * b + 1]);
653
+ indices.eastIndices.sort((a, b) => position[3 * b + 1] - position[3 * a + 1]);
654
+ indices.southIndices.sort((a, b) => position[3 * b] - position[3 * a]);
655
+ indices.northIndices.sort((a, b) => position[3 * a] - position[3 * b]);
656
+ const edges = [];
657
+ for (const index in indices) {
658
+ const indexGroup = indices[index];
659
+ for (let i = 0; i < indexGroup.length - 1; i++) {
660
+ edges.push([indexGroup[i], indexGroup[i + 1]]);
661
+ }
662
+ }
663
+ return edges;
664
+ }
665
+ function updateAttributesForNewEdge({ edge, edgeIndex, attributes, skirtHeight, newPosition, newTexcoord0, newTriangles }) {
666
+ const positionsLength = attributes.POSITION.value.length;
667
+ const vertex1Offset = edgeIndex * 2;
668
+ const vertex2Offset = edgeIndex * 2 + 1;
669
+ newPosition.set(attributes.POSITION.value.subarray(edge[0] * 3, edge[0] * 3 + 3), vertex1Offset * 3);
670
+ newPosition[vertex1Offset * 3 + 2] = newPosition[vertex1Offset * 3 + 2] - skirtHeight;
671
+ newPosition.set(attributes.POSITION.value.subarray(edge[1] * 3, edge[1] * 3 + 3), vertex2Offset * 3);
672
+ newPosition[vertex2Offset * 3 + 2] = newPosition[vertex2Offset * 3 + 2] - skirtHeight;
673
+ newTexcoord0.set(attributes.TEXCOORD_0.value.subarray(edge[0] * 2, edge[0] * 2 + 2), vertex1Offset * 2);
674
+ newTexcoord0.set(attributes.TEXCOORD_0.value.subarray(edge[1] * 2, edge[1] * 2 + 2), vertex2Offset * 2);
675
+ const triangle1Offset = edgeIndex * 2 * 3;
676
+ newTriangles[triangle1Offset] = edge[0];
677
+ newTriangles[triangle1Offset + 1] = positionsLength / 3 + vertex2Offset;
678
+ newTriangles[triangle1Offset + 2] = edge[1];
679
+ newTriangles[triangle1Offset + 3] = positionsLength / 3 + vertex2Offset;
680
+ newTriangles[triangle1Offset + 4] = edge[0];
681
+ newTriangles[triangle1Offset + 5] = positionsLength / 3 + vertex1Offset;
682
+ }
683
+
684
+ // dist/terrain/lib/decode-terrain-heightmap.js
685
+ var TERRARIUM_ELEVATION_DECODER = Object.freeze({
686
+ rScaler: 256,
687
+ gScaler: 1,
688
+ bScaler: 1 / 256,
689
+ offset: -32768
690
+ });
691
+ function decodeTerrainHeightmapInto(image, elevationDecoder, heights, rowStride) {
692
+ const { data, width, height } = image;
693
+ const { rScaler, gScaler, bScaler, offset } = elevationDecoder;
694
+ for (let row = 0; row < height; row++) {
695
+ for (let column = 0; column < width; column++) {
696
+ const pixelOffset = (row * width + column) * 4;
697
+ heights[row * rowStride + column] = data[pixelOffset] * rScaler + data[pixelOffset + 1] * gScaler + data[pixelOffset + 2] * bScaler + offset;
698
+ }
699
+ }
700
+ }
701
+
702
+ // dist/terrain/lib/parse-terrain.js
703
+ function makeTerrainMeshFromImage(terrainImage, terrainOptions) {
704
+ const { meshMaxError, bounds, elevationDecoder } = terrainOptions;
705
+ const { data, width, height } = terrainImage;
706
+ let terrain;
707
+ let mesh;
708
+ switch (terrainOptions.tesselator) {
709
+ case "martini":
710
+ terrain = getTerrain(data, width, height, elevationDecoder, terrainOptions.tesselator);
711
+ mesh = getMartiniTileMesh(meshMaxError, width, terrain);
712
+ break;
713
+ case "delatin":
714
+ terrain = getTerrain(data, width, height, elevationDecoder, terrainOptions.tesselator);
715
+ mesh = getDelatinTileMesh(meshMaxError, width, height, terrain);
716
+ break;
717
+ // auto
718
+ default:
719
+ if (width === height && !(height & width - 1)) {
720
+ terrain = getTerrain(data, width, height, elevationDecoder, "martini");
721
+ mesh = getMartiniTileMesh(meshMaxError, width, terrain);
722
+ } else {
723
+ terrain = getTerrain(data, width, height, elevationDecoder, "delatin");
724
+ mesh = getDelatinTileMesh(meshMaxError, width, height, terrain);
725
+ }
726
+ break;
727
+ }
728
+ const { vertices } = mesh;
729
+ let { triangles } = mesh;
730
+ let attributes = getMeshAttributes(vertices, terrain, width, height, bounds);
731
+ const boundingBox = (0, import_schema_utils.getMeshBoundingBox)(attributes);
732
+ if (terrainOptions.skirtHeight) {
733
+ const { attributes: newAttributes, triangles: newTriangles } = addSkirt(attributes, triangles, terrainOptions.skirtHeight);
734
+ attributes = newAttributes;
735
+ triangles = newTriangles;
736
+ }
737
+ const topology = "triangle-list";
738
+ const mode = 4;
739
+ const schema = (0, import_schema_utils.deduceMeshSchema)(attributes, {
740
+ topology,
741
+ mode: String(mode),
742
+ boundingBox: JSON.stringify(boundingBox)
743
+ });
744
+ return {
745
+ // Data return by this loader implementation
746
+ loaderData: {
747
+ header: {}
748
+ },
749
+ header: {
750
+ vertexCount: triangles.length,
751
+ boundingBox: boundingBox ?? void 0
752
+ },
753
+ schema,
754
+ topology,
755
+ mode,
756
+ indices: { value: Uint32Array.from(triangles), size: 1 },
757
+ attributes
758
+ };
759
+ }
760
+ function getMartiniTileMesh(meshMaxError, width, terrain) {
761
+ const gridSize = width + 1;
762
+ const martini = new Martini(gridSize);
763
+ const tile = martini.createTile(terrain);
764
+ const { vertices, triangles } = tile.getMesh(meshMaxError);
765
+ return { vertices, triangles };
766
+ }
767
+ function getDelatinTileMesh(meshMaxError, width, height, terrain) {
768
+ const tin = new Delatin(terrain, width + 1, height + 1);
769
+ tin.run(meshMaxError);
770
+ const { coords, triangles } = tin;
771
+ const vertices = coords;
772
+ return { vertices, triangles };
773
+ }
774
+ function getTerrain(imageData, width, height, elevationDecoder, tesselator) {
775
+ const terrain = new Float32Array((width + 1) * (height + 1));
776
+ decodeTerrainHeightmapInto({ data: imageData, width, height }, elevationDecoder, terrain, width + 1);
777
+ if (tesselator === "martini") {
778
+ for (let i = (width + 1) * width, x = 0; x < width; x++, i++) {
779
+ terrain[i] = terrain[i - width - 1];
780
+ }
781
+ for (let i = height, y = 0; y < height + 1; y++, i += height + 1) {
782
+ terrain[i] = terrain[i - 1];
783
+ }
784
+ }
785
+ return terrain;
786
+ }
787
+ function getMeshAttributes(vertices, terrain, width, height, bounds) {
788
+ const gridSize = width + 1;
789
+ const numOfVerticies = vertices.length / 2;
790
+ const positions = new Float32Array(numOfVerticies * 3);
791
+ const texCoords = new Float32Array(numOfVerticies * 2);
792
+ const [minX, minY, maxX, maxY] = bounds || [0, 0, width, height];
793
+ const xScale = (maxX - minX) / width;
794
+ const yScale = (maxY - minY) / height;
795
+ for (let i = 0; i < numOfVerticies; i++) {
796
+ const x = vertices[i * 2];
797
+ const y = vertices[i * 2 + 1];
798
+ const pixelIdx = y * gridSize + x;
799
+ positions[3 * i + 0] = x * xScale + minX;
800
+ positions[3 * i + 1] = -y * yScale + maxY;
801
+ positions[3 * i + 2] = terrain[pixelIdx];
802
+ texCoords[2 * i + 0] = x / width;
803
+ texCoords[2 * i + 1] = y / height;
804
+ }
805
+ return {
806
+ POSITION: { value: positions, size: 3 },
807
+ TEXCOORD_0: { value: texCoords, size: 2 }
808
+ // NORMAL: {}, - optional, but creates the high poly look with lighting
809
+ };
810
+ }
811
+
812
+ // dist/terrain/terrain-loader.js
813
+ var { preload: _TerrainLoaderPreload, ...TerrainLoaderMetadataWithoutPreload } = TerrainLoader;
814
+ var TerrainLoaderWithParser = {
815
+ ...TerrainLoaderMetadataWithoutPreload,
816
+ serializeWorkerResult: import_arrow_transport.serializeArrowWorkerResult,
817
+ deserializeWorkerResult: import_arrow_transport.deserializeArrowWorkerResult,
818
+ /** Image decoder requested by terrain workers through the nested parse bridge. */
819
+ subloaders: { ImageBitmapLoader: import_images.ImageBitmapLoader },
820
+ parse: parseTerrain
821
+ };
822
+ async function parseTerrain(arrayBuffer, options, context) {
823
+ const loadImageOptions = {
824
+ ...options,
825
+ core: { ...options?.core, mimeType: "application/x.image" }
826
+ };
827
+ const image = await (0, import_loader_utils2.parseFromContext)(arrayBuffer, import_images.ImageBitmapLoader, loadImageOptions, context);
828
+ const imageData = (0, import_images.getImageData)(image);
829
+ const terrainImage = {
830
+ width: imageData.width,
831
+ height: imageData.height,
832
+ data: imageData.data instanceof Uint8ClampedArray ? new Uint8Array(imageData.data.buffer, imageData.data.byteOffset, imageData.data.byteLength) : imageData.data
833
+ };
834
+ const terrainOptions = {
835
+ ...TerrainLoaderWithParser.options.terrain,
836
+ ...options?.terrain
837
+ };
838
+ const mesh = makeTerrainMeshFromImage(terrainImage, terrainOptions);
839
+ const table = (0, import_schema_utils2.convertMeshToTable)(mesh, "arrow-table");
840
+ if (options?.terrain?.shape === "arrow-table") {
841
+ return table;
842
+ }
843
+ return {
844
+ ...(0, import_schema_utils2.convertTableToMesh)(table),
845
+ loader: mesh.loader,
846
+ loaderData: mesh.loaderData
847
+ };
848
+ }
849
+
850
+ // dist/terrain/quantized-mesh-loader-types.js
851
+ var QuantizedMeshLoader = {
852
+ dataType: null,
853
+ batchType: null,
854
+ ...QuantizedMeshFormat,
855
+ version: VERSION,
856
+ worker: true,
857
+ /** Loads the parser-bearing quantized mesh loader implementation. */
858
+ preload: async () => (await import("@loaders.gl/raster/terrain/quantized-mesh-loader")).QuantizedMeshLoaderWithParser,
859
+ options: {
860
+ "quantized-mesh": {
861
+ shape: "arrow-table",
862
+ bounds: [0, 0, 1, 1],
863
+ skirtHeight: null
864
+ }
865
+ }
866
+ };
867
+
868
+ // dist/terrain/quantized-mesh-loader.js
869
+ var import_arrow_transport2 = require("@loaders.gl/core/schema-utils/arrow-transport");
870
+ var import_schema_utils4 = require("@loaders.gl/core/schema-utils");
871
+
872
+ // dist/terrain/lib/parse-quantized-mesh.js
873
+ var import_schema_utils3 = require("@loaders.gl/core/schema-utils");
874
+
875
+ // dist/terrain/lib/decode-quantized-mesh.js
876
+ var QUANTIZED_MESH_HEADER = /* @__PURE__ */ new Map([
877
+ ["centerX", Float64Array.BYTES_PER_ELEMENT],
878
+ ["centerY", Float64Array.BYTES_PER_ELEMENT],
879
+ ["centerZ", Float64Array.BYTES_PER_ELEMENT],
880
+ ["minHeight", Float32Array.BYTES_PER_ELEMENT],
881
+ ["maxHeight", Float32Array.BYTES_PER_ELEMENT],
882
+ ["boundingSphereCenterX", Float64Array.BYTES_PER_ELEMENT],
883
+ ["boundingSphereCenterY", Float64Array.BYTES_PER_ELEMENT],
884
+ ["boundingSphereCenterZ", Float64Array.BYTES_PER_ELEMENT],
885
+ ["boundingSphereRadius", Float64Array.BYTES_PER_ELEMENT],
886
+ ["horizonOcclusionPointX", Float64Array.BYTES_PER_ELEMENT],
887
+ ["horizonOcclusionPointY", Float64Array.BYTES_PER_ELEMENT],
888
+ ["horizonOcclusionPointZ", Float64Array.BYTES_PER_ELEMENT]
889
+ ]);
890
+ function decodeZigZag(value) {
891
+ return value >> 1 ^ -(value & 1);
892
+ }
893
+ function decodeHeader(dataView) {
894
+ let position = 0;
895
+ const header = {};
896
+ for (const [key, bytesCount] of QUANTIZED_MESH_HEADER) {
897
+ const getter = bytesCount === 8 ? dataView.getFloat64 : dataView.getFloat32;
898
+ header[key] = getter.call(dataView, position, true);
899
+ position += bytesCount;
900
+ }
901
+ return { header, headerEndPosition: position };
902
+ }
903
+ function decodeVertexData(dataView, headerEndPosition) {
904
+ let position = headerEndPosition;
905
+ const elementsPerVertex = 3;
906
+ const vertexCount = dataView.getUint32(position, true);
907
+ const vertexData = new Uint16Array(vertexCount * elementsPerVertex);
908
+ position += Uint32Array.BYTES_PER_ELEMENT;
909
+ const bytesPerArrayElement = Uint16Array.BYTES_PER_ELEMENT;
910
+ const elementArrayLength = vertexCount * bytesPerArrayElement;
911
+ const uArrayStartPosition = position;
912
+ const vArrayStartPosition = uArrayStartPosition + elementArrayLength;
913
+ const heightArrayStartPosition = vArrayStartPosition + elementArrayLength;
914
+ let u = 0;
915
+ let v = 0;
916
+ let height = 0;
917
+ for (let i = 0; i < vertexCount; i++) {
918
+ u += decodeZigZag(dataView.getUint16(uArrayStartPosition + bytesPerArrayElement * i, true));
919
+ v += decodeZigZag(dataView.getUint16(vArrayStartPosition + bytesPerArrayElement * i, true));
920
+ height += decodeZigZag(dataView.getUint16(heightArrayStartPosition + bytesPerArrayElement * i, true));
921
+ vertexData[i] = u;
922
+ vertexData[i + vertexCount] = v;
923
+ vertexData[i + vertexCount * 2] = height;
924
+ }
925
+ position += elementArrayLength * 3;
926
+ return { vertexData, vertexDataEndPosition: position };
927
+ }
928
+ function decodeIndex(buffer, position, indicesCount, bytesPerIndex, encoded = true) {
929
+ let indices;
930
+ if (bytesPerIndex === 2) {
931
+ indices = new Uint16Array(buffer, position, indicesCount);
932
+ } else {
933
+ indices = new Uint32Array(buffer, position, indicesCount);
934
+ }
935
+ if (!encoded) {
936
+ return indices;
937
+ }
938
+ let highest = 0;
939
+ for (let i = 0; i < indices.length; ++i) {
940
+ const code = indices[i];
941
+ indices[i] = highest - code;
942
+ if (code === 0) {
943
+ ++highest;
944
+ }
945
+ }
946
+ return indices;
947
+ }
948
+ function decodeTriangleIndices(dataView, vertexData, vertexDataEndPosition) {
949
+ let position = vertexDataEndPosition;
950
+ const elementsPerVertex = 3;
951
+ const vertexCount = vertexData.length / elementsPerVertex;
952
+ const bytesPerIndex = vertexCount > 65536 ? Uint32Array.BYTES_PER_ELEMENT : Uint16Array.BYTES_PER_ELEMENT;
953
+ if (position % bytesPerIndex !== 0) {
954
+ position += bytesPerIndex - position % bytesPerIndex;
955
+ }
956
+ const triangleCount = dataView.getUint32(position, true);
957
+ position += Uint32Array.BYTES_PER_ELEMENT;
958
+ const triangleIndicesCount = triangleCount * 3;
959
+ const triangleIndices = decodeIndex(dataView.buffer, position, triangleIndicesCount, bytesPerIndex);
960
+ position += triangleIndicesCount * bytesPerIndex;
961
+ return {
962
+ triangleIndicesEndPosition: position,
963
+ triangleIndices
964
+ };
965
+ }
966
+ function decodeEdgeIndices(dataView, vertexData, triangleIndicesEndPosition) {
967
+ let position = triangleIndicesEndPosition;
968
+ const elementsPerVertex = 3;
969
+ const vertexCount = vertexData.length / elementsPerVertex;
970
+ const bytesPerIndex = vertexCount > 65536 ? Uint32Array.BYTES_PER_ELEMENT : Uint16Array.BYTES_PER_ELEMENT;
971
+ const westVertexCount = dataView.getUint32(position, true);
972
+ position += Uint32Array.BYTES_PER_ELEMENT;
973
+ const westIndices = decodeIndex(dataView.buffer, position, westVertexCount, bytesPerIndex, false);
974
+ position += westVertexCount * bytesPerIndex;
975
+ const southVertexCount = dataView.getUint32(position, true);
976
+ position += Uint32Array.BYTES_PER_ELEMENT;
977
+ const southIndices = decodeIndex(dataView.buffer, position, southVertexCount, bytesPerIndex, false);
978
+ position += southVertexCount * bytesPerIndex;
979
+ const eastVertexCount = dataView.getUint32(position, true);
980
+ position += Uint32Array.BYTES_PER_ELEMENT;
981
+ const eastIndices = decodeIndex(dataView.buffer, position, eastVertexCount, bytesPerIndex, false);
982
+ position += eastVertexCount * bytesPerIndex;
983
+ const northVertexCount = dataView.getUint32(position, true);
984
+ position += Uint32Array.BYTES_PER_ELEMENT;
985
+ const northIndices = decodeIndex(dataView.buffer, position, northVertexCount, bytesPerIndex, false);
986
+ position += northVertexCount * bytesPerIndex;
987
+ return {
988
+ edgeIndicesEndPosition: position,
989
+ westIndices,
990
+ southIndices,
991
+ eastIndices,
992
+ northIndices
993
+ };
994
+ }
995
+ function decodeVertexNormalsExtension(extensionDataView) {
996
+ return new Uint8Array(extensionDataView.buffer, extensionDataView.byteOffset, extensionDataView.byteLength);
997
+ }
998
+ function decodeWaterMaskExtension(extensionDataView) {
999
+ return extensionDataView.buffer.slice(extensionDataView.byteOffset, extensionDataView.byteOffset + extensionDataView.byteLength);
1000
+ }
1001
+ function decodeExtensions(dataView, indicesEndPosition) {
1002
+ const extensions = {};
1003
+ if (dataView.byteLength <= indicesEndPosition) {
1004
+ return { extensions, extensionsEndPosition: indicesEndPosition };
1005
+ }
1006
+ let position = indicesEndPosition;
1007
+ while (position < dataView.byteLength) {
1008
+ const extensionId = dataView.getUint8(position, true);
1009
+ position += Uint8Array.BYTES_PER_ELEMENT;
1010
+ const extensionLength = dataView.getUint32(position, true);
1011
+ position += Uint32Array.BYTES_PER_ELEMENT;
1012
+ const extensionView = new DataView(dataView.buffer, position, extensionLength);
1013
+ switch (extensionId) {
1014
+ case 1: {
1015
+ extensions.vertexNormals = decodeVertexNormalsExtension(extensionView);
1016
+ break;
1017
+ }
1018
+ case 2: {
1019
+ extensions.waterMask = decodeWaterMaskExtension(extensionView);
1020
+ break;
1021
+ }
1022
+ default: {
1023
+ }
1024
+ }
1025
+ position += extensionLength;
1026
+ }
1027
+ return { extensions, extensionsEndPosition: position };
1028
+ }
1029
+ var DECODING_STEPS = {
1030
+ header: 0,
1031
+ vertices: 1,
1032
+ triangleIndices: 2,
1033
+ edgeIndices: 3,
1034
+ extensions: 4
1035
+ };
1036
+ var DEFAULT_OPTIONS = {
1037
+ maxDecodingStep: DECODING_STEPS.extensions
1038
+ };
1039
+ function decode(data, userOptions) {
1040
+ const options = Object.assign({}, DEFAULT_OPTIONS, userOptions);
1041
+ const view = new DataView(data);
1042
+ const { header, headerEndPosition } = decodeHeader(view);
1043
+ if (options.maxDecodingStep < DECODING_STEPS.vertices) {
1044
+ return { header };
1045
+ }
1046
+ const { vertexData, vertexDataEndPosition } = decodeVertexData(view, headerEndPosition);
1047
+ if (options.maxDecodingStep < DECODING_STEPS.triangleIndices) {
1048
+ return { header, vertexData };
1049
+ }
1050
+ const { triangleIndices, triangleIndicesEndPosition } = decodeTriangleIndices(view, vertexData, vertexDataEndPosition);
1051
+ if (options.maxDecodingStep < DECODING_STEPS.edgeIndices) {
1052
+ return { header, vertexData, triangleIndices };
1053
+ }
1054
+ const { westIndices, southIndices, eastIndices, northIndices, edgeIndicesEndPosition } = decodeEdgeIndices(view, vertexData, triangleIndicesEndPosition);
1055
+ if (options.maxDecodingStep < DECODING_STEPS.extensions) {
1056
+ return {
1057
+ header,
1058
+ vertexData,
1059
+ triangleIndices,
1060
+ westIndices,
1061
+ northIndices,
1062
+ eastIndices,
1063
+ southIndices
1064
+ };
1065
+ }
1066
+ const { extensions } = decodeExtensions(view, edgeIndicesEndPosition);
1067
+ return {
1068
+ header,
1069
+ vertexData,
1070
+ triangleIndices,
1071
+ westIndices,
1072
+ northIndices,
1073
+ eastIndices,
1074
+ southIndices,
1075
+ extensions
1076
+ };
1077
+ }
1078
+
1079
+ // dist/terrain/lib/parse-quantized-mesh.js
1080
+ function parseQuantizedMesh(arrayBuffer, options = {}) {
1081
+ const { bounds } = options;
1082
+ const { header, vertexData, triangleIndices: originalTriangleIndices, westIndices, northIndices, eastIndices, southIndices } = decode(arrayBuffer, DECODING_STEPS.triangleIndices);
1083
+ let triangleIndices = originalTriangleIndices;
1084
+ let attributes = getMeshAttributes2(vertexData, header, bounds);
1085
+ const boundingBox = (0, import_schema_utils3.getMeshBoundingBox)(attributes);
1086
+ if (options?.skirtHeight) {
1087
+ const { attributes: newAttributes, triangles: newTriangles } = addSkirt(attributes, triangleIndices, options.skirtHeight, {
1088
+ westIndices,
1089
+ northIndices,
1090
+ eastIndices,
1091
+ southIndices
1092
+ });
1093
+ attributes = newAttributes;
1094
+ triangleIndices = newTriangles;
1095
+ }
1096
+ const topology = "triangle-list";
1097
+ const mode = 4;
1098
+ const schema = (0, import_schema_utils3.deduceMeshSchema)(attributes, {
1099
+ topology,
1100
+ mode: String(mode),
1101
+ boundingBox: JSON.stringify(boundingBox)
1102
+ });
1103
+ return {
1104
+ // Data return by this loader implementation
1105
+ loaderData: {
1106
+ header: {}
1107
+ },
1108
+ header: {
1109
+ // @ts-ignore
1110
+ vertexCount: triangleIndices.length,
1111
+ boundingBox: boundingBox ?? void 0
1112
+ },
1113
+ schema,
1114
+ topology,
1115
+ mode,
1116
+ indices: { value: triangleIndices, size: 1 },
1117
+ attributes
1118
+ };
1119
+ }
1120
+ function getMeshAttributes2(vertexData, header, bounds) {
1121
+ const { minHeight, maxHeight } = header;
1122
+ const [minX, minY, maxX, maxY] = bounds || [0, 0, 1, 1];
1123
+ const xScale = maxX - minX;
1124
+ const yScale = maxY - minY;
1125
+ const zScale = maxHeight - minHeight;
1126
+ const nCoords = vertexData.length / 3;
1127
+ const positions = new Float32Array(nCoords * 3);
1128
+ const texCoords = new Float32Array(nCoords * 2);
1129
+ for (let i = 0; i < nCoords; i++) {
1130
+ const x = vertexData[i] / 32767;
1131
+ const y = vertexData[i + nCoords] / 32767;
1132
+ const z = vertexData[i + nCoords * 2] / 32767;
1133
+ positions[3 * i + 0] = x * xScale + minX;
1134
+ positions[3 * i + 1] = y * yScale + minY;
1135
+ positions[3 * i + 2] = z * zScale + minHeight;
1136
+ texCoords[2 * i + 0] = x;
1137
+ texCoords[2 * i + 1] = y;
1138
+ }
1139
+ return {
1140
+ POSITION: { value: positions, size: 3 },
1141
+ TEXCOORD_0: { value: texCoords, size: 2 }
1142
+ // TODO: Parse normals if they exist in the file
1143
+ // NORMAL: {}, - optional, but creates the high poly look with lighting
1144
+ };
1145
+ }
1146
+
1147
+ // dist/terrain/quantized-mesh-loader.js
1148
+ var { preload: _QuantizedMeshLoaderPreload, ...QuantizedMeshLoaderMetadataWithoutPreload } = QuantizedMeshLoader;
1149
+ var QuantizedMeshLoaderWithParser = {
1150
+ ...QuantizedMeshLoaderMetadataWithoutPreload,
1151
+ serializeWorkerResult: import_arrow_transport2.serializeArrowWorkerResult,
1152
+ deserializeWorkerResult: import_arrow_transport2.deserializeArrowWorkerResult,
1153
+ parseSync: parseQuantizedMeshInRequestedShape,
1154
+ parse: async (arrayBuffer, options) => parseQuantizedMeshInRequestedShape(arrayBuffer, options)
1155
+ };
1156
+ function parseQuantizedMeshInRequestedShape(arrayBuffer, options) {
1157
+ const mesh = parseQuantizedMesh(arrayBuffer, options?.["quantized-mesh"]);
1158
+ const table = (0, import_schema_utils4.convertMeshToTable)(mesh, "arrow-table");
1159
+ if (options?.["quantized-mesh"]?.shape === "arrow-table") {
1160
+ return table;
1161
+ }
1162
+ return {
1163
+ ...(0, import_schema_utils4.convertTableToMesh)(table),
1164
+ loader: mesh.loader,
1165
+ loaderData: mesh.loaderData
1166
+ };
1167
+ }
1168
+
1169
+ // dist/terrain/quantized-mesh-writer.js
1170
+ var import_schema_utils5 = require("@loaders.gl/core/schema-utils");
1171
+ var QUANTIZED_MESH_HEADER_LENGTH = 88;
1172
+ var QUANTIZED_COORDINATE_RANGE = 32767;
1173
+ var EMPTY_EDGE_INDICES_LENGTH = Uint32Array.BYTES_PER_ELEMENT * 4;
1174
+ var QuantizedMeshWriter = {
1175
+ ...QuantizedMeshFormat,
1176
+ version: VERSION,
1177
+ dataType: null,
1178
+ batchType: null,
1179
+ options: {
1180
+ "quantized-mesh": {}
1181
+ },
1182
+ encode: async (data, options) => encodeQuantizedMeshSync(data, options),
1183
+ encodeSync: encodeQuantizedMeshSync
1184
+ };
1185
+ function encodeQuantizedMeshSync(data, options = {}) {
1186
+ const mesh = (0, import_schema_utils5.convertTableToMesh)(normalizeMeshArrowTable(data));
1187
+ const positionAttribute = getRequiredAttribute(mesh, "POSITION");
1188
+ const vertexCount = positionAttribute.value.length / positionAttribute.size;
1189
+ const boundingBox = getBoundingBox(positionAttribute, vertexCount);
1190
+ const bounds = options["quantized-mesh"]?.bounds || [
1191
+ boundingBox[0][0],
1192
+ boundingBox[0][1],
1193
+ boundingBox[1][0],
1194
+ boundingBox[1][1]
1195
+ ];
1196
+ const triangleIndices = getTriangleIndices(mesh, vertexCount);
1197
+ const highWatermarkMesh = reorderMeshForHighWatermark(triangleIndices, vertexCount);
1198
+ const bytesPerIndex = vertexCount > 65536 ? Uint32Array.BYTES_PER_ELEMENT : Uint16Array.BYTES_PER_ELEMENT;
1199
+ const vertexDataLength = Uint32Array.BYTES_PER_ELEMENT + vertexCount * 3 * Uint16Array.BYTES_PER_ELEMENT;
1200
+ const triangleDataOffset = getAlignedOffset(QUANTIZED_MESH_HEADER_LENGTH + vertexDataLength, bytesPerIndex);
1201
+ const triangleDataLength = Uint32Array.BYTES_PER_ELEMENT + triangleIndices.length * bytesPerIndex;
1202
+ const arrayBuffer = new ArrayBuffer(triangleDataOffset + triangleDataLength + EMPTY_EDGE_INDICES_LENGTH);
1203
+ const dataView = new DataView(arrayBuffer);
1204
+ writeHeader(dataView, boundingBox);
1205
+ dataView.setUint32(QUANTIZED_MESH_HEADER_LENGTH, vertexCount, true);
1206
+ writeVertexData(dataView, QUANTIZED_MESH_HEADER_LENGTH + Uint32Array.BYTES_PER_ELEMENT, {
1207
+ positionAttribute,
1208
+ vertexCount,
1209
+ boundingBox,
1210
+ bounds,
1211
+ sourceVertexIndices: highWatermarkMesh.sourceVertexIndices
1212
+ });
1213
+ writeTriangleIndices(dataView, triangleDataOffset, highWatermarkMesh.triangleIndices, bytesPerIndex);
1214
+ writeEmptyEdgeIndices(dataView, triangleDataOffset + triangleDataLength);
1215
+ return arrayBuffer;
1216
+ }
1217
+ function normalizeMeshArrowTable(data) {
1218
+ if ("shape" in data && data.shape === "arrow-table") {
1219
+ return data;
1220
+ }
1221
+ return (0, import_schema_utils5.convertMeshToTable)(data, "arrow-table");
1222
+ }
1223
+ function getRequiredAttribute(mesh, attributeName) {
1224
+ const attribute = mesh.attributes[attributeName];
1225
+ if (!attribute) {
1226
+ throw new Error(`QuantizedMeshWriter: ${attributeName} attribute is required`);
1227
+ }
1228
+ return attribute;
1229
+ }
1230
+ function writeHeader(dataView, boundingBox) {
1231
+ const center = getCenter(boundingBox);
1232
+ const radius = getRadius(boundingBox, center);
1233
+ let byteOffset = 0;
1234
+ for (const value of center) {
1235
+ dataView.setFloat64(byteOffset, value, true);
1236
+ byteOffset += Float64Array.BYTES_PER_ELEMENT;
1237
+ }
1238
+ dataView.setFloat32(byteOffset, boundingBox[0][2], true);
1239
+ byteOffset += Float32Array.BYTES_PER_ELEMENT;
1240
+ dataView.setFloat32(byteOffset, boundingBox[1][2], true);
1241
+ byteOffset += Float32Array.BYTES_PER_ELEMENT;
1242
+ for (const value of center) {
1243
+ dataView.setFloat64(byteOffset, value, true);
1244
+ byteOffset += Float64Array.BYTES_PER_ELEMENT;
1245
+ }
1246
+ dataView.setFloat64(byteOffset, radius, true);
1247
+ byteOffset += Float64Array.BYTES_PER_ELEMENT;
1248
+ dataView.setFloat64(byteOffset, 0, true);
1249
+ dataView.setFloat64(byteOffset + 8, 0, true);
1250
+ dataView.setFloat64(byteOffset + 16, 0, true);
1251
+ }
1252
+ function writeVertexData(dataView, byteOffset, parameters) {
1253
+ const quantizedCoordinates = getQuantizedCoordinates(parameters);
1254
+ const arrayByteLength = parameters.vertexCount * Uint16Array.BYTES_PER_ELEMENT;
1255
+ writeDeltaEncodedArray(dataView, byteOffset, quantizedCoordinates.u);
1256
+ writeDeltaEncodedArray(dataView, byteOffset + arrayByteLength, quantizedCoordinates.v);
1257
+ writeDeltaEncodedArray(dataView, byteOffset + arrayByteLength * 2, quantizedCoordinates.height);
1258
+ }
1259
+ function getQuantizedCoordinates(parameters) {
1260
+ const [minimumX, minimumY, maximumX, maximumY] = parameters.bounds;
1261
+ const heightMinimum = parameters.boundingBox[0][2];
1262
+ const heightMaximum = parameters.boundingBox[1][2];
1263
+ const u = new Uint16Array(parameters.vertexCount);
1264
+ const v = new Uint16Array(parameters.vertexCount);
1265
+ const height = new Uint16Array(parameters.vertexCount);
1266
+ for (let vertexIndex = 0; vertexIndex < parameters.vertexCount; vertexIndex++) {
1267
+ const sourceVertexIndex = parameters.sourceVertexIndices[vertexIndex];
1268
+ u[vertexIndex] = quantize(getComponent(parameters.positionAttribute, sourceVertexIndex, 0), minimumX, maximumX);
1269
+ v[vertexIndex] = quantize(getComponent(parameters.positionAttribute, sourceVertexIndex, 1), minimumY, maximumY);
1270
+ height[vertexIndex] = quantize(getComponent(parameters.positionAttribute, sourceVertexIndex, 2), heightMinimum, heightMaximum);
1271
+ }
1272
+ return { u, v, height };
1273
+ }
1274
+ function writeDeltaEncodedArray(dataView, byteOffset, values) {
1275
+ let previousValue = 0;
1276
+ for (let valueIndex = 0; valueIndex < values.length; valueIndex++) {
1277
+ const value = values[valueIndex];
1278
+ const delta = value - previousValue;
1279
+ dataView.setUint16(byteOffset + valueIndex * Uint16Array.BYTES_PER_ELEMENT, encodeZigZag(delta), true);
1280
+ previousValue = value;
1281
+ }
1282
+ }
1283
+ function writeTriangleIndices(dataView, byteOffset, triangleIndices, bytesPerIndex) {
1284
+ dataView.setUint32(byteOffset, triangleIndices.length / 3, true);
1285
+ let highestIndex = 0;
1286
+ let indexByteOffset = byteOffset + Uint32Array.BYTES_PER_ELEMENT;
1287
+ for (const triangleIndex of triangleIndices) {
1288
+ const code = highestIndex - triangleIndex;
1289
+ if (code < 0) {
1290
+ throw new Error("QuantizedMeshWriter: triangle indices must be high-watermark encodable");
1291
+ }
1292
+ if (bytesPerIndex === Uint16Array.BYTES_PER_ELEMENT) {
1293
+ dataView.setUint16(indexByteOffset, code, true);
1294
+ } else {
1295
+ dataView.setUint32(indexByteOffset, code, true);
1296
+ }
1297
+ if (code === 0) {
1298
+ highestIndex++;
1299
+ }
1300
+ indexByteOffset += bytesPerIndex;
1301
+ }
1302
+ }
1303
+ function writeEmptyEdgeIndices(dataView, byteOffset) {
1304
+ dataView.setUint32(byteOffset, 0, true);
1305
+ dataView.setUint32(byteOffset + 4, 0, true);
1306
+ dataView.setUint32(byteOffset + 8, 0, true);
1307
+ dataView.setUint32(byteOffset + 12, 0, true);
1308
+ }
1309
+ function getTriangleIndices(mesh, vertexCount) {
1310
+ if (mesh.indices?.value?.length) {
1311
+ return Array.from(mesh.indices.value);
1312
+ }
1313
+ if (mesh.mode !== 4 && mesh.topology !== "triangle-list") {
1314
+ throw new Error("QuantizedMeshWriter: triangle-list mesh data is required");
1315
+ }
1316
+ const triangleIndices = [];
1317
+ for (let vertexIndex = 0; vertexIndex + 2 < vertexCount; vertexIndex += 3) {
1318
+ triangleIndices.push(vertexIndex, vertexIndex + 1, vertexIndex + 2);
1319
+ }
1320
+ return triangleIndices;
1321
+ }
1322
+ function reorderMeshForHighWatermark(triangleIndices, vertexCount) {
1323
+ const remappedVertexIndices = /* @__PURE__ */ new Map();
1324
+ const sourceVertexIndices = [];
1325
+ const remappedTriangleIndices = triangleIndices.map((triangleIndex) => {
1326
+ if (!Number.isInteger(triangleIndex) || triangleIndex < 0 || triangleIndex >= vertexCount) {
1327
+ throw new Error("QuantizedMeshWriter: triangle index is out of range");
1328
+ }
1329
+ const existingIndex = remappedVertexIndices.get(triangleIndex);
1330
+ if (existingIndex !== void 0) {
1331
+ return existingIndex;
1332
+ }
1333
+ const nextIndex = sourceVertexIndices.length;
1334
+ remappedVertexIndices.set(triangleIndex, nextIndex);
1335
+ sourceVertexIndices.push(triangleIndex);
1336
+ return nextIndex;
1337
+ });
1338
+ for (let vertexIndex = 0; vertexIndex < vertexCount; vertexIndex++) {
1339
+ if (!remappedVertexIndices.has(vertexIndex)) {
1340
+ sourceVertexIndices.push(vertexIndex);
1341
+ }
1342
+ }
1343
+ return { triangleIndices: remappedTriangleIndices, sourceVertexIndices };
1344
+ }
1345
+ function getAlignedOffset(byteOffset, byteAlignment) {
1346
+ const remainder = byteOffset % byteAlignment;
1347
+ return remainder === 0 ? byteOffset : byteOffset + byteAlignment - remainder;
1348
+ }
1349
+ function getComponent(attribute, vertexIndex, componentIndex) {
1350
+ return attribute.value[vertexIndex * attribute.size + componentIndex] || 0;
1351
+ }
1352
+ function getBoundingBox(positionAttribute, vertexCount) {
1353
+ const minimum = [
1354
+ Number.POSITIVE_INFINITY,
1355
+ Number.POSITIVE_INFINITY,
1356
+ Number.POSITIVE_INFINITY
1357
+ ];
1358
+ const maximum = [
1359
+ Number.NEGATIVE_INFINITY,
1360
+ Number.NEGATIVE_INFINITY,
1361
+ Number.NEGATIVE_INFINITY
1362
+ ];
1363
+ for (let vertexIndex = 0; vertexIndex < vertexCount; vertexIndex++) {
1364
+ for (let componentIndex = 0; componentIndex < 3; componentIndex++) {
1365
+ const value = getComponent(positionAttribute, vertexIndex, componentIndex);
1366
+ minimum[componentIndex] = Math.min(minimum[componentIndex], value);
1367
+ maximum[componentIndex] = Math.max(maximum[componentIndex], value);
1368
+ }
1369
+ }
1370
+ return [minimum, maximum];
1371
+ }
1372
+ function getCenter(boundingBox) {
1373
+ return [
1374
+ (boundingBox[0][0] + boundingBox[1][0]) / 2,
1375
+ (boundingBox[0][1] + boundingBox[1][1]) / 2,
1376
+ (boundingBox[0][2] + boundingBox[1][2]) / 2
1377
+ ];
1378
+ }
1379
+ function getRadius(boundingBox, center) {
1380
+ const xDistance = Math.max(Math.abs(boundingBox[0][0] - center[0]), Math.abs(boundingBox[1][0] - center[0]));
1381
+ const yDistance = Math.max(Math.abs(boundingBox[0][1] - center[1]), Math.abs(boundingBox[1][1] - center[1]));
1382
+ const zDistance = Math.max(Math.abs(boundingBox[0][2] - center[2]), Math.abs(boundingBox[1][2] - center[2]));
1383
+ return Math.hypot(xDistance, yDistance, zDistance);
1384
+ }
1385
+ function quantize(value, minimum, maximum) {
1386
+ const range = maximum - minimum || 1;
1387
+ const quantizedValue = Math.round((value - minimum) / range * QUANTIZED_COORDINATE_RANGE);
1388
+ return Math.max(0, Math.min(QUANTIZED_COORDINATE_RANGE, quantizedValue));
1389
+ }
1390
+ function encodeZigZag(value) {
1391
+ return value << 1 ^ value >> 31;
1392
+ }
1393
+ // Annotate the CommonJS export names for ESM import in node:
1394
+ 0 && (module.exports = {
1395
+ QuantizedMeshFormat,
1396
+ QuantizedMeshLoader,
1397
+ QuantizedMeshLoaderWithParser,
1398
+ QuantizedMeshWorkerLoader,
1399
+ QuantizedMeshWriter,
1400
+ TerrainFormat,
1401
+ TerrainLoader,
1402
+ TerrainLoaderWithParser,
1403
+ TerrainWorkerLoader,
1404
+ parseTerrain
1405
+ });
1406
+ //# sourceMappingURL=index.cjs.map