@loaders.gl/3d-tiles 3.1.3 → 4.0.0-alpha.5

package/dist/lib/encoders/encode-3d-tile.js

@@ -1,33 +1,35 @@
-"use strict";
-// This file is derived from the Cesium code base under Apache 2 license
-// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
-Object.defineProperty(exports, "__esModule", { value: true });
-const constants_1 = require("../constants");
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-const encode_3d_tile_composite_1 = require("./encode-3d-tile-composite");
-const encode_3d_tile_batched_model_1 = require("./encode-3d-tile-batched-model");
-const encode_3d_tile_instanced_model_1 = require("./encode-3d-tile-instanced-model");
-const encode_3d_tile_point_cloud_1 = require("./encode-3d-tile-point-cloud");
-function encode3DTile(tile, options) {
-    const byteLength = encode3DTileToDataView(tile, null, 0, options);
-    const arrayBuffer = new ArrayBuffer(byteLength);
-    const dataView = new DataView(arrayBuffer);
-    encode3DTileToDataView(tile, dataView, 0, options);
-    return arrayBuffer;
+import { TILE3D_TYPE } from '../constants';
+import { assert } from '@loaders.gl/loader-utils';
+import { encodeComposite3DTile } from './encode-3d-tile-composite';
+import { encodeBatchedModel3DTile } from './encode-3d-tile-batched-model';
+import { encodeInstancedModel3DTile } from './encode-3d-tile-instanced-model';
+import { encodePointCloud3DTile } from './encode-3d-tile-point-cloud';
+export default function encode3DTile(tile, options) {
+  const byteLength = encode3DTileToDataView(tile, null, 0, options);
+  const arrayBuffer = new ArrayBuffer(byteLength);
+  const dataView = new DataView(arrayBuffer);
+  encode3DTileToDataView(tile, dataView, 0, options);
+  return arrayBuffer;
 }
-exports.default = encode3DTile;
+
 function encode3DTileToDataView(tile, dataView, byteOffset, options) {
-    (0, loader_utils_1.assert)(typeof tile.type === 'string');
-    switch (tile.type) {
-        case constants_1.TILE3D_TYPE.COMPOSITE:
-            return (0, encode_3d_tile_composite_1.encodeComposite3DTile)(tile, dataView, byteOffset, options, encode3DTileToDataView);
-        case constants_1.TILE3D_TYPE.POINT_CLOUD:
-            return (0, encode_3d_tile_point_cloud_1.encodePointCloud3DTile)(tile, dataView, byteOffset, options);
-        case constants_1.TILE3D_TYPE.BATCHED_3D_MODEL:
-            return (0, encode_3d_tile_batched_model_1.encodeBatchedModel3DTile)(tile, dataView, byteOffset, options);
-        case constants_1.TILE3D_TYPE.INSTANCED_3D_MODEL:
-            return (0, encode_3d_tile_instanced_model_1.encodeInstancedModel3DTile)(tile, dataView, byteOffset, options);
-        default:
-            throw new Error('3D Tiles: unknown tile type');
-    }
+  assert(typeof tile.type === 'string');
+
+  switch (tile.type) {
+    case TILE3D_TYPE.COMPOSITE:
+      return encodeComposite3DTile(tile, dataView, byteOffset, options, encode3DTileToDataView);
+
+    case TILE3D_TYPE.POINT_CLOUD:
+      return encodePointCloud3DTile(tile, dataView, byteOffset, options);
+
+    case TILE3D_TYPE.BATCHED_3D_MODEL:
+      return encodeBatchedModel3DTile(tile, dataView, byteOffset, options);
+
+    case TILE3D_TYPE.INSTANCED_3D_MODEL:
+      return encodeInstancedModel3DTile(tile, dataView, byteOffset, options);
+
+    default:
+      throw new Error('3D Tiles: unknown tile type');
+  }
 }
+//# sourceMappingURL=encode-3d-tile.js.map

package/dist/lib/encoders/encode-3d-tile.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/encoders/encode-3d-tile.ts"],"names":["TILE3D_TYPE","assert","encodeComposite3DTile","encodeBatchedModel3DTile","encodeInstancedModel3DTile","encodePointCloud3DTile","encode3DTile","tile","options","byteLength","encode3DTileToDataView","arrayBuffer","ArrayBuffer","dataView","DataView","byteOffset","type","COMPOSITE","POINT_CLOUD","BATCHED_3D_MODEL","INSTANCED_3D_MODEL","Error"],"mappings":"AAGA,SAAQA,WAAR,QAA0B,cAA1B;AACA,SAAQC,MAAR,QAAqB,0BAArB;AAEA,SAAQC,qBAAR,QAAoC,4BAApC;AACA,SAAQC,wBAAR,QAAuC,gCAAvC;AACA,SAAQC,0BAAR,QAAyC,kCAAzC;AACA,SAAQC,sBAAR,QAAqC,8BAArC;AAEA,eAAe,SAASC,YAAT,CAAsBC,IAAtB,EAA4BC,OAA5B,EAAqC;AAClD,QAAMC,UAAU,GAAGC,sBAAsB,CAACH,IAAD,EAAO,IAAP,EAAa,CAAb,EAAgBC,OAAhB,CAAzC;AACA,QAAMG,WAAW,GAAG,IAAIC,WAAJ,CAAgBH,UAAhB,CAApB;AACA,QAAMI,QAAQ,GAAG,IAAIC,QAAJ,CAAaH,WAAb,CAAjB;AACAD,EAAAA,sBAAsB,CAACH,IAAD,EAAOM,QAAP,EAAiB,CAAjB,EAAoBL,OAApB,CAAtB;AACA,SAAOG,WAAP;AACD;;AAED,SAASD,sBAAT,CAAgCH,IAAhC,EAAsCM,QAAtC,EAAgDE,UAAhD,EAA4DP,OAA5D,EAAqE;AACnEP,EAAAA,MAAM,CAAC,OAAOM,IAAI,CAACS,IAAZ,KAAqB,QAAtB,CAAN;;AAEA,UAAQT,IAAI,CAACS,IAAb;AACE,SAAKhB,WAAW,CAACiB,SAAjB;AACE,aAAOf,qBAAqB,CAACK,IAAD,EAAOM,QAAP,EAAiBE,UAAjB,EAA6BP,OAA7B,EAAsCE,sBAAtC,CAA5B;;AACF,SAAKV,WAAW,CAACkB,WAAjB;AACE,aAAOb,sBAAsB,CAACE,IAAD,EAAOM,QAAP,EAAiBE,UAAjB,EAA6BP,OAA7B,CAA7B;;AACF,SAAKR,WAAW,CAACmB,gBAAjB;AACE,aAAOhB,wBAAwB,CAACI,IAAD,EAAOM,QAAP,EAAiBE,UAAjB,EAA6BP,OAA7B,CAA/B;;AACF,SAAKR,WAAW,CAACoB,kBAAjB;AACE,aAAOhB,0BAA0B,CAACG,IAAD,EAAOM,QAAP,EAAiBE,UAAjB,EAA6BP,OAA7B,CAAjC;;AACF;AACE,YAAM,IAAIa,KAAJ,CAAU,6BAAV,CAAN;AAVJ;AAYD","sourcesContent":["// This file is derived from the Cesium code base under Apache 2 license\n// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md\n\nimport {TILE3D_TYPE} from '../constants';\nimport {assert} from '@loaders.gl/loader-utils';\n\nimport {encodeComposite3DTile} from './encode-3d-tile-composite';\nimport {encodeBatchedModel3DTile} from './encode-3d-tile-batched-model';\nimport {encodeInstancedModel3DTile} from './encode-3d-tile-instanced-model';\nimport {encodePointCloud3DTile} from './encode-3d-tile-point-cloud';\n\nexport default function encode3DTile(tile, options) {\n  const byteLength = encode3DTileToDataView(tile, null, 0, options);\n  const arrayBuffer = new ArrayBuffer(byteLength);\n  const dataView = new DataView(arrayBuffer);\n  encode3DTileToDataView(tile, dataView, 0, options);\n  return arrayBuffer;\n}\n\nfunction encode3DTileToDataView(tile, dataView, byteOffset, options) {\n  assert(typeof tile.type === 'string');\n\n  switch (tile.type) {\n    case TILE3D_TYPE.COMPOSITE:\n      return encodeComposite3DTile(tile, dataView, byteOffset, options, encode3DTileToDataView);\n    case TILE3D_TYPE.POINT_CLOUD:\n      return encodePointCloud3DTile(tile, dataView, byteOffset, options);\n    case TILE3D_TYPE.BATCHED_3D_MODEL:\n      return encodeBatchedModel3DTile(tile, dataView, byteOffset, options);\n    case TILE3D_TYPE.INSTANCED_3D_MODEL:\n      return encodeInstancedModel3DTile(tile, dataView, byteOffset, options);\n    default:\n      throw new Error('3D Tiles: unknown tile type');\n  }\n}\n"],"file":"encode-3d-tile.js"}

package/dist/lib/encoders/helpers/encode-3d-tile-header.js

@@ -1,30 +1,31 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.encode3DTileByteLength = exports.encode3DTileHeader = void 0;
-// HELPER ENCODERS
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-function encode3DTileHeader(tile, dataView, byteOffset) {
-    const HEADER_SIZE = 12;
-    if (!dataView) {
-        return byteOffset + HEADER_SIZE;
-    }
-    const { magic, version = 1, byteLength = 12 } = tile;
-    (0, loader_utils_1.assert)(Array.isArray(magic) && Number.isFinite(version) && Number.isFinite(byteLength));
-    dataView.setUint8(byteOffset + 0, magic[0]);
-    dataView.setUint8(byteOffset + 1, magic[1]);
-    dataView.setUint8(byteOffset + 2, magic[2]);
-    dataView.setUint8(byteOffset + 3, magic[3]);
-    dataView.setUint32(byteOffset + 4, version, true); // version
-    dataView.setUint32(byteOffset + 8, byteLength, true); // byteLength
-    byteOffset += HEADER_SIZE;
-    return byteOffset;
+import { assert } from '@loaders.gl/loader-utils';
+export function encode3DTileHeader(tile, dataView, byteOffset) {
+  const HEADER_SIZE = 12;
+
+  if (!dataView) {
+    return byteOffset + HEADER_SIZE;
+  }
+
+  const {
+    magic,
+    version = 1,
+    byteLength = 12
+  } = tile;
+  assert(Array.isArray(magic) && Number.isFinite(version) && Number.isFinite(byteLength));
+  dataView.setUint8(byteOffset + 0, magic[0]);
+  dataView.setUint8(byteOffset + 1, magic[1]);
+  dataView.setUint8(byteOffset + 2, magic[2]);
+  dataView.setUint8(byteOffset + 3, magic[3]);
+  dataView.setUint32(byteOffset + 4, version, true);
+  dataView.setUint32(byteOffset + 8, byteLength, true);
+  byteOffset += HEADER_SIZE;
+  return byteOffset;
 }
-exports.encode3DTileHeader = encode3DTileHeader;
-// Bytelength is sometimes only known at the end of writing a tile
-function encode3DTileByteLength(dataView, byteOffsetTileStart, byteLength) {
-    if (!dataView) {
-        return;
-    }
-    dataView.setUint32(byteOffsetTileStart + 8, byteLength, true); // byteLength
+export function encode3DTileByteLength(dataView, byteOffsetTileStart, byteLength) {
+  if (!dataView) {
+    return;
+  }
+
+  dataView.setUint32(byteOffsetTileStart + 8, byteLength, true);
 }
-exports.encode3DTileByteLength = encode3DTileByteLength;
+//# sourceMappingURL=encode-3d-tile-header.js.map

package/dist/lib/encoders/helpers/encode-3d-tile-header.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/encoders/helpers/encode-3d-tile-header.ts"],"names":["assert","encode3DTileHeader","tile","dataView","byteOffset","HEADER_SIZE","magic","version","byteLength","Array","isArray","Number","isFinite","setUint8","setUint32","encode3DTileByteLength","byteOffsetTileStart"],"mappings":"AACA,SAAQA,MAAR,QAAqB,0BAArB;AAEA,OAAO,SAASC,kBAAT,CAA4BC,IAA5B,EAAkCC,QAAlC,EAA4CC,UAA5C,EAAwD;AAC7D,QAAMC,WAAW,GAAG,EAApB;;AAEA,MAAI,CAACF,QAAL,EAAe;AACb,WAAOC,UAAU,GAAGC,WAApB;AACD;;AAED,QAAM;AAACC,IAAAA,KAAD;AAAQC,IAAAA,OAAO,GAAG,CAAlB;AAAqBC,IAAAA,UAAU,GAAG;AAAlC,MAAwCN,IAA9C;AAEAF,EAAAA,MAAM,CAACS,KAAK,CAACC,OAAN,CAAcJ,KAAd,KAAwBK,MAAM,CAACC,QAAP,CAAgBL,OAAhB,CAAxB,IAAoDI,MAAM,CAACC,QAAP,CAAgBJ,UAAhB,CAArD,CAAN;AAEAL,EAAAA,QAAQ,CAACU,QAAT,CAAkBT,UAAU,GAAG,CAA/B,EAAkCE,KAAK,CAAC,CAAD,CAAvC;AACAH,EAAAA,QAAQ,CAACU,QAAT,CAAkBT,UAAU,GAAG,CAA/B,EAAkCE,KAAK,CAAC,CAAD,CAAvC;AACAH,EAAAA,QAAQ,CAACU,QAAT,CAAkBT,UAAU,GAAG,CAA/B,EAAkCE,KAAK,CAAC,CAAD,CAAvC;AACAH,EAAAA,QAAQ,CAACU,QAAT,CAAkBT,UAAU,GAAG,CAA/B,EAAkCE,KAAK,CAAC,CAAD,CAAvC;AACAH,EAAAA,QAAQ,CAACW,SAAT,CAAmBV,UAAU,GAAG,CAAhC,EAAmCG,OAAnC,EAA4C,IAA5C;AACAJ,EAAAA,QAAQ,CAACW,SAAT,CAAmBV,UAAU,GAAG,CAAhC,EAAmCI,UAAnC,EAA+C,IAA/C;AAEAJ,EAAAA,UAAU,IAAIC,WAAd;AAEA,SAAOD,UAAP;AACD;AAGD,OAAO,SAASW,sBAAT,CAAgCZ,QAAhC,EAA0Ca,mBAA1C,EAA+DR,UAA/D,EAA2E;AAChF,MAAI,CAACL,QAAL,EAAe;AACb;AACD;;AAEDA,EAAAA,QAAQ,CAACW,SAAT,CAAmBE,mBAAmB,GAAG,CAAzC,EAA4CR,UAA5C,EAAwD,IAAxD;AACD","sourcesContent":["// HELPER ENCODERS\nimport {assert} from '@loaders.gl/loader-utils';\n\nexport function encode3DTileHeader(tile, dataView, byteOffset) {\n  const HEADER_SIZE = 12;\n\n  if (!dataView) {\n    return byteOffset + HEADER_SIZE;\n  }\n\n  const {magic, version = 1, byteLength = 12} = tile;\n\n  assert(Array.isArray(magic) && Number.isFinite(version) && Number.isFinite(byteLength));\n\n  dataView.setUint8(byteOffset + 0, magic[0]);\n  dataView.setUint8(byteOffset + 1, magic[1]);\n  dataView.setUint8(byteOffset + 2, magic[2]);\n  dataView.setUint8(byteOffset + 3, magic[3]);\n  dataView.setUint32(byteOffset + 4, version, true); // version\n  dataView.setUint32(byteOffset + 8, byteLength, true); // byteLength\n\n  byteOffset += HEADER_SIZE;\n\n  return byteOffset;\n}\n\n// Bytelength is sometimes only known at the end of writing a tile\nexport function encode3DTileByteLength(dataView, byteOffsetTileStart, byteLength) {\n  if (!dataView) {\n    return;\n  }\n\n  dataView.setUint32(byteOffsetTileStart + 8, byteLength, true); // byteLength\n}\n"],"file":"encode-3d-tile-header.js"}

package/dist/lib/ion/ion.js

@@ -1,68 +1,77 @@
-"use strict";
-// Minimal support to load tilsets from the Cesium ION services
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getIonAssetMetadata = exports.getIonAssets = exports.getIonTilesetMetadata = void 0;
-const core_1 = require("@loaders.gl/core");
-const loader_utils_1 = require("@loaders.gl/loader-utils");
+import { fetchFile } from '@loaders.gl/core';
+import { assert } from '@loaders.gl/loader-utils';
 const CESIUM_ION_URL = 'https://api.cesium.com/v1/assets';
-// Returns `{url, headers, type, attributions}` for an ion tileset
-async function getIonTilesetMetadata(accessToken, assetId) {
-    // Step 1, if no asset id, look for first 3DTILES asset associated with this token.
-    if (!assetId) {
-        const assets = await getIonAssets(accessToken);
-        for (const item of assets.items) {
-            if (item.type === '3DTILES') {
-                assetId = item.id;
-            }
-        }
+export async function getIonTilesetMetadata(accessToken, assetId) {
+  if (!assetId) {
+    const assets = await getIonAssets(accessToken);
+
+    for (const item of assets.items) {
+      if (item.type === '3DTILES') {
+        assetId = item.id;
+      }
     }
-    // Step 2: Query metdatadata for this asset.
-    const ionAssetMetadata = await getIonAssetMetadata(accessToken, assetId);
-    const { type, url } = ionAssetMetadata;
-    (0, loader_utils_1.assert)(type === '3DTILES' && url);
-    // Prepare a headers object for fetch
-    ionAssetMetadata.headers = {
-        Authorization: `Bearer ${ionAssetMetadata.accessToken}`
-    };
-    return ionAssetMetadata;
+  }
+
+  const ionAssetMetadata = await getIonAssetMetadata(accessToken, assetId);
+  const {
+    type,
+    url
+  } = ionAssetMetadata;
+  assert(type === '3DTILES' && url);
+  ionAssetMetadata.headers = {
+    Authorization: "Bearer ".concat(ionAssetMetadata.accessToken)
+  };
+  return ionAssetMetadata;
 }
-exports.getIonTilesetMetadata = getIonTilesetMetadata;
-// Return a list of all assets associated with accessToken
-async function getIonAssets(accessToken) {
-    (0, loader_utils_1.assert)(accessToken);
-    const url = CESIUM_ION_URL;
-    const headers = { Authorization: `Bearer ${accessToken}` };
-    const response = await (0, core_1.fetchFile)(url, { fetch: { headers } });
-    if (!response.ok) {
-        throw new Error(response.statusText);
+export async function getIonAssets(accessToken) {
+  assert(accessToken);
+  const url = CESIUM_ION_URL;
+  const headers = {
+    Authorization: "Bearer ".concat(accessToken)
+  };
+  const response = await fetchFile(url, {
+    fetch: {
+      headers
     }
-    return await response.json();
+  });
+
+  if (!response.ok) {
+    throw new Error(response.statusText);
+  }
+
+  return await response.json();
 }
-exports.getIonAssets = getIonAssets;
-// Return metadata for a specific asset associated with token
-async function getIonAssetMetadata(accessToken, assetId) {
-    (0, loader_utils_1.assert)(accessToken, assetId);
-    const headers = { Authorization: `Bearer ${accessToken}` };
-    const url = `${CESIUM_ION_URL}/${assetId}`;
-    // https://cesium.com/docs/rest-api/#operation/getAsset
-    // Retrieves metadata information about a specific asset.
-    let response = await (0, core_1.fetchFile)(`${url}`, { fetch: { headers } });
-    if (!response.ok) {
-        throw new Error(response.statusText);
+export async function getIonAssetMetadata(accessToken, assetId) {
+  assert(accessToken, assetId);
+  const headers = {
+    Authorization: "Bearer ".concat(accessToken)
+  };
+  const url = "".concat(CESIUM_ION_URL, "/").concat(assetId);
+  let response = await fetchFile("".concat(url), {
+    fetch: {
+      headers
     }
-    let metadata = await response.json();
-    // https://cesium.com/docs/rest-api/#operation/getAssetEndpoint
-    // Retrieves information and credentials that allow you to access the tiled asset data for visualization and analysis.
-    response = await (0, core_1.fetchFile)(`${url}/endpoint`, { fetch: { headers } });
-    if (!response.ok) {
-        throw new Error(response.statusText);
+  });
+
+  if (!response.ok) {
+    throw new Error(response.statusText);
+  }
+
+  let metadata = await response.json();
+  response = await fetchFile("".concat(url, "/endpoint"), {
+    fetch: {
+      headers
     }
-    const tilesetInfo = await response.json();
-    // extract dataset description
-    metadata = {
-        ...metadata,
-        ...tilesetInfo
-    };
-    return metadata;
+  });
+
+  if (!response.ok) {
+    throw new Error(response.statusText);
+  }
+
+  const tilesetInfo = await response.json();
+  metadata = { ...metadata,
+    ...tilesetInfo
+  };
+  return metadata;
 }
-exports.getIonAssetMetadata = getIonAssetMetadata;
+//# sourceMappingURL=ion.js.map

package/dist/lib/ion/ion.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/ion/ion.ts"],"names":["fetchFile","assert","CESIUM_ION_URL","getIonTilesetMetadata","accessToken","assetId","assets","getIonAssets","item","items","type","id","ionAssetMetadata","getIonAssetMetadata","url","headers","Authorization","response","fetch","ok","Error","statusText","json","metadata","tilesetInfo"],"mappings":"AAEA,SAAQA,SAAR,QAAwB,kBAAxB;AACA,SAAQC,MAAR,QAAqB,0BAArB;AAEA,MAAMC,cAAc,GAAG,kCAAvB;AAGA,OAAO,eAAeC,qBAAf,CAAqCC,WAArC,EAAkDC,OAAlD,EAA2D;AAEhE,MAAI,CAACA,OAAL,EAAc;AACZ,UAAMC,MAAM,GAAG,MAAMC,YAAY,CAACH,WAAD,CAAjC;;AACA,SAAK,MAAMI,IAAX,IAAmBF,MAAM,CAACG,KAA1B,EAAiC;AAC/B,UAAID,IAAI,CAACE,IAAL,KAAc,SAAlB,EAA6B;AAC3BL,QAAAA,OAAO,GAAGG,IAAI,CAACG,EAAf;AACD;AACF;AACF;;AAGD,QAAMC,gBAAgB,GAAG,MAAMC,mBAAmB,CAACT,WAAD,EAAcC,OAAd,CAAlD;AACA,QAAM;AAACK,IAAAA,IAAD;AAAOI,IAAAA;AAAP,MAAcF,gBAApB;AACAX,EAAAA,MAAM,CAACS,IAAI,KAAK,SAAT,IAAsBI,GAAvB,CAAN;AAGAF,EAAAA,gBAAgB,CAACG,OAAjB,GAA2B;AACzBC,IAAAA,aAAa,mBAAYJ,gBAAgB,CAACR,WAA7B;AADY,GAA3B;AAGA,SAAOQ,gBAAP;AACD;AAGD,OAAO,eAAeL,YAAf,CAA4BH,WAA5B,EAAyC;AAC9CH,EAAAA,MAAM,CAACG,WAAD,CAAN;AACA,QAAMU,GAAG,GAAGZ,cAAZ;AACA,QAAMa,OAAO,GAAG;AAACC,IAAAA,aAAa,mBAAYZ,WAAZ;AAAd,GAAhB;AACA,QAAMa,QAAQ,GAAG,MAAMjB,SAAS,CAACc,GAAD,EAAM;AAACI,IAAAA,KAAK,EAAE;AAACH,MAAAA;AAAD;AAAR,GAAN,CAAhC;;AACA,MAAI,CAACE,QAAQ,CAACE,EAAd,EAAkB;AAChB,UAAM,IAAIC,KAAJ,CAAUH,QAAQ,CAACI,UAAnB,CAAN;AACD;;AACD,SAAO,MAAMJ,QAAQ,CAACK,IAAT,EAAb;AACD;AAGD,OAAO,eAAeT,mBAAf,CAAmCT,WAAnC,EAAgDC,OAAhD,EAAyD;AAC9DJ,EAAAA,MAAM,CAACG,WAAD,EAAcC,OAAd,CAAN;AACA,QAAMU,OAAO,GAAG;AAACC,IAAAA,aAAa,mBAAYZ,WAAZ;AAAd,GAAhB;AAEA,QAAMU,GAAG,aAAMZ,cAAN,cAAwBG,OAAxB,CAAT;AAGA,MAAIY,QAAQ,GAAG,MAAMjB,SAAS,WAAIc,GAAJ,GAAW;AAACI,IAAAA,KAAK,EAAE;AAACH,MAAAA;AAAD;AAAR,GAAX,CAA9B;;AACA,MAAI,CAACE,QAAQ,CAACE,EAAd,EAAkB;AAChB,UAAM,IAAIC,KAAJ,CAAUH,QAAQ,CAACI,UAAnB,CAAN;AACD;;AACD,MAAIE,QAAQ,GAAG,MAAMN,QAAQ,CAACK,IAAT,EAArB;AAIAL,EAAAA,QAAQ,GAAG,MAAMjB,SAAS,WAAIc,GAAJ,gBAAoB;AAACI,IAAAA,KAAK,EAAE;AAACH,MAAAA;AAAD;AAAR,GAApB,CAA1B;;AACA,MAAI,CAACE,QAAQ,CAACE,EAAd,EAAkB;AAChB,UAAM,IAAIC,KAAJ,CAAUH,QAAQ,CAACI,UAAnB,CAAN;AACD;;AACD,QAAMG,WAAW,GAAG,MAAMP,QAAQ,CAACK,IAAT,EAA1B;AAGAC,EAAAA,QAAQ,GAAG,EACT,GAAGA,QADM;AAET,OAAGC;AAFM,GAAX;AAKA,SAAOD,QAAP;AACD","sourcesContent":["// Minimal support to load tilsets from the Cesium ION services\n\nimport {fetchFile} from '@loaders.gl/core';\nimport {assert} from '@loaders.gl/loader-utils';\n\nconst CESIUM_ION_URL = 'https://api.cesium.com/v1/assets';\n\n// Returns `{url, headers, type, attributions}` for an ion tileset\nexport async function getIonTilesetMetadata(accessToken, assetId) {\n  // Step 1, if no asset id, look for first 3DTILES asset associated with this token.\n  if (!assetId) {\n    const assets = await getIonAssets(accessToken);\n    for (const item of assets.items) {\n      if (item.type === '3DTILES') {\n        assetId = item.id;\n      }\n    }\n  }\n\n  // Step 2: Query metdatadata for this asset.\n  const ionAssetMetadata = await getIonAssetMetadata(accessToken, assetId);\n  const {type, url} = ionAssetMetadata;\n  assert(type === '3DTILES' && url);\n\n  // Prepare a headers object for fetch\n  ionAssetMetadata.headers = {\n    Authorization: `Bearer ${ionAssetMetadata.accessToken}`\n  };\n  return ionAssetMetadata;\n}\n\n// Return a list of all assets associated with accessToken\nexport async function getIonAssets(accessToken) {\n  assert(accessToken);\n  const url = CESIUM_ION_URL;\n  const headers = {Authorization: `Bearer ${accessToken}`};\n  const response = await fetchFile(url, {fetch: {headers}});\n  if (!response.ok) {\n    throw new Error(response.statusText);\n  }\n  return await response.json();\n}\n\n// Return metadata for a specific asset associated with token\nexport async function getIonAssetMetadata(accessToken, assetId) {\n  assert(accessToken, assetId);\n  const headers = {Authorization: `Bearer ${accessToken}`};\n\n  const url = `${CESIUM_ION_URL}/${assetId}`;\n  // https://cesium.com/docs/rest-api/#operation/getAsset\n  // Retrieves metadata information about a specific asset.\n  let response = await fetchFile(`${url}`, {fetch: {headers}});\n  if (!response.ok) {\n    throw new Error(response.statusText);\n  }\n  let metadata = await response.json();\n\n  // https://cesium.com/docs/rest-api/#operation/getAssetEndpoint\n  // Retrieves information and credentials that allow you to access the tiled asset data for visualization and analysis.\n  response = await fetchFile(`${url}/endpoint`, {fetch: {headers}});\n  if (!response.ok) {\n    throw new Error(response.statusText);\n  }\n  const tilesetInfo = await response.json();\n\n  // extract dataset description\n  metadata = {\n    ...metadata,\n    ...tilesetInfo\n  };\n\n  return metadata;\n}\n"],"file":"ion.js"}

package/dist/lib/parsers/helpers/normalize-3d-tile-colors.js

@@ -1,65 +1,67 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalize3DTileColorAttribute = void 0;
-const math_1 = require("@loaders.gl/math");
-/* eslint-disable complexity*/
-function normalize3DTileColorAttribute(tile, colors, batchTable) {
-    // no colors defined
-    if (!colors && (!tile || !tile.batchIds || !batchTable)) {
-        return null;
+import { decodeRGB565, GL } from '@loaders.gl/math';
+export function normalize3DTileColorAttribute(tile, colors, batchTable) {
+  if (!colors && (!tile || !tile.batchIds || !batchTable)) {
+    return null;
+  }
+
+  const {
+    batchIds,
+    isRGB565,
+    pointCount
+  } = tile;
+
+  if (batchIds && batchTable) {
+    const colorArray = new Uint8ClampedArray(pointCount * 3);
+
+    for (let i = 0; i < pointCount; i++) {
+      const batchId = batchIds[i];
+      const dimensions = batchTable.getProperty(batchId, 'dimensions');
+      const color = dimensions.map(d => d * 255);
+      colorArray[i * 3] = color[0];
+      colorArray[i * 3 + 1] = color[1];
+      colorArray[i * 3 + 2] = color[2];
     }
-    const { batchIds, isRGB565, pointCount } = tile;
-    // Batch table, look up colors in table
-    if (batchIds && batchTable) {
-        const colorArray = new Uint8ClampedArray(pointCount * 3);
-        for (let i = 0; i < pointCount; i++) {
-            const batchId = batchIds[i];
-            // TODO figure out what is `dimensions` used for
-            const dimensions = batchTable.getProperty(batchId, 'dimensions');
-            const color = dimensions.map((d) => d * 255);
-            colorArray[i * 3] = color[0];
-            colorArray[i * 3 + 1] = color[1];
-            colorArray[i * 3 + 2] = color[2];
-        }
-        return {
-            type: math_1.GL.UNSIGNED_BYTE,
-            value: colorArray,
-            size: 3,
-            normalized: true
-        };
-    }
-    // RGB565 case, convert to RGB
-    if (isRGB565) {
-        const colorArray = new Uint8ClampedArray(pointCount * 3);
-        for (let i = 0; i < pointCount; i++) {
-            const color = (0, math_1.decodeRGB565)(colors[i]);
-            colorArray[i * 3] = color[0];
-            colorArray[i * 3 + 1] = color[1];
-            colorArray[i * 3 + 2] = color[2];
-        }
-        return {
-            type: math_1.GL.UNSIGNED_BYTE,
-            value: colorArray,
-            size: 3,
-            normalized: true
-        };
-    }
-    // RGB case (tile.isTranslucent)
-    if (colors && colors.length === pointCount * 3) {
-        return {
-            type: math_1.GL.UNSIGNED_BYTE,
-            value: colors,
-            size: 3,
-            normalized: true
-        };
+
+    return {
+      type: GL.UNSIGNED_BYTE,
+      value: colorArray,
+      size: 3,
+      normalized: true
+    };
+  }
+
+  if (isRGB565) {
+    const colorArray = new Uint8ClampedArray(pointCount * 3);
+
+    for (let i = 0; i < pointCount; i++) {
+      const color = decodeRGB565(colors[i]);
+      colorArray[i * 3] = color[0];
+      colorArray[i * 3 + 1] = color[1];
+      colorArray[i * 3 + 2] = color[2];
     }
-    // DEFAULT: RGBA case
+
+    return {
+      type: GL.UNSIGNED_BYTE,
+      value: colorArray,
+      size: 3,
+      normalized: true
+    };
+  }
+
+  if (colors && colors.length === pointCount * 3) {
     return {
-        type: math_1.GL.UNSIGNED_BYTE,
-        value: colors,
-        size: 4,
-        normalized: true
+      type: GL.UNSIGNED_BYTE,
+      value: colors,
+      size: 3,
+      normalized: true
     };
+  }
+
+  return {
+    type: GL.UNSIGNED_BYTE,
+    value: colors,
+    size: 4,
+    normalized: true
+  };
 }
-exports.normalize3DTileColorAttribute = normalize3DTileColorAttribute;
-/* eslint-enable complexity*/
+//# sourceMappingURL=normalize-3d-tile-colors.js.map

package/dist/lib/parsers/helpers/normalize-3d-tile-colors.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/parsers/helpers/normalize-3d-tile-colors.ts"],"names":["decodeRGB565","GL","normalize3DTileColorAttribute","tile","colors","batchTable","batchIds","isRGB565","pointCount","colorArray","Uint8ClampedArray","i","batchId","dimensions","getProperty","color","map","d","type","UNSIGNED_BYTE","value","size","normalized","length"],"mappings":"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","sourcesContent":["import {decodeRGB565, GL} from '@loaders.gl/math';\n\n/* eslint-disable complexity*/\nexport function normalize3DTileColorAttribute(tile, colors, batchTable?) {\n  // no colors defined\n  if (!colors && (!tile || !tile.batchIds || !batchTable)) {\n    return null;\n  }\n\n  const {batchIds, isRGB565, pointCount} = tile;\n  // Batch table, look up colors in table\n  if (batchIds && batchTable) {\n    const colorArray = new Uint8ClampedArray(pointCount * 3);\n    for (let i = 0; i < pointCount; i++) {\n      const batchId = batchIds[i];\n      // TODO figure out what is `dimensions` used for\n      const dimensions = batchTable.getProperty(batchId, 'dimensions');\n      const color = dimensions.map((d) => d * 255);\n      colorArray[i * 3] = color[0];\n      colorArray[i * 3 + 1] = color[1];\n      colorArray[i * 3 + 2] = color[2];\n    }\n    return {\n      type: GL.UNSIGNED_BYTE,\n      value: colorArray,\n      size: 3,\n      normalized: true\n    };\n  }\n\n  // RGB565 case, convert to RGB\n  if (isRGB565) {\n    const colorArray = new Uint8ClampedArray(pointCount * 3);\n    for (let i = 0; i < pointCount; i++) {\n      const color = decodeRGB565(colors[i]);\n      colorArray[i * 3] = color[0];\n      colorArray[i * 3 + 1] = color[1];\n      colorArray[i * 3 + 2] = color[2];\n    }\n    return {\n      type: GL.UNSIGNED_BYTE,\n      value: colorArray,\n      size: 3,\n      normalized: true\n    };\n  }\n\n  // RGB case (tile.isTranslucent)\n  if (colors && colors.length === pointCount * 3) {\n    return {\n      type: GL.UNSIGNED_BYTE,\n      value: colors,\n      size: 3,\n      normalized: true\n    };\n  }\n\n  // DEFAULT: RGBA case\n  return {\n    type: GL.UNSIGNED_BYTE,\n    value: colors,\n    size: 4,\n    normalized: true\n  };\n}\n/* eslint-enable complexity*/\n"],"file":"normalize-3d-tile-colors.js"}

package/dist/lib/parsers/helpers/normalize-3d-tile-normals.js

@@ -1,30 +1,30 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalize3DTileNormalAttribute = void 0;
-const core_1 = require("@math.gl/core");
-const math_1 = require("@loaders.gl/math");
-const scratchNormal = new core_1.Vector3();
-function normalize3DTileNormalAttribute(tile, normals) {
-    if (!normals) {
-        return null;
-    }
-    if (tile.isOctEncoded16P) {
-        const decodedArray = new Float32Array(tile.pointsLength * 3);
-        for (let i = 0; i < tile.pointsLength; i++) {
-            (0, math_1.octDecode)(normals[i * 2], normals[i * 2 + 1], scratchNormal);
-            // @ts-ignore
-            scratchNormal.toArray(decodedArray, i * 3);
-        }
-        return {
-            type: math_1.GL.FLOAT,
-            size: 2,
-            value: decodedArray
-        };
+import { Vector3 } from '@math.gl/core';
+import { GL, octDecode } from '@loaders.gl/math';
+const scratchNormal = new Vector3();
+export function normalize3DTileNormalAttribute(tile, normals) {
+  if (!normals) {
+    return null;
+  }
+
+  if (tile.isOctEncoded16P) {
+    const decodedArray = new Float32Array(tile.pointsLength * 3);
+
+    for (let i = 0; i < tile.pointsLength; i++) {
+      octDecode(normals[i * 2], normals[i * 2 + 1], scratchNormal);
+      scratchNormal.toArray(decodedArray, i * 3);
     }
+
     return {
-        type: math_1.GL.FLOAT,
-        size: 2,
-        value: normals
+      type: GL.FLOAT,
+      size: 2,
+      value: decodedArray
     };
+  }
+
+  return {
+    type: GL.FLOAT,
+    size: 2,
+    value: normals
+  };
 }
-exports.normalize3DTileNormalAttribute = normalize3DTileNormalAttribute;
+//# sourceMappingURL=normalize-3d-tile-normals.js.map

package/dist/lib/parsers/helpers/normalize-3d-tile-normals.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/parsers/helpers/normalize-3d-tile-normals.ts"],"names":["Vector3","GL","octDecode","scratchNormal","normalize3DTileNormalAttribute","tile","normals","isOctEncoded16P","decodedArray","Float32Array","pointsLength","i","toArray","type","FLOAT","size","value"],"mappings":"AAAA,SAAQA,OAAR,QAAsB,eAAtB;AACA,SAAQC,EAAR,EAAYC,SAAZ,QAA4B,kBAA5B;AAEA,MAAMC,aAAa,GAAG,IAAIH,OAAJ,EAAtB;AAEA,OAAO,SAASI,8BAAT,CAAwCC,IAAxC,EAA8CC,OAA9C,EAAuD;AAC5D,MAAI,CAACA,OAAL,EAAc;AACZ,WAAO,IAAP;AACD;;AAED,MAAID,IAAI,CAACE,eAAT,EAA0B;AACxB,UAAMC,YAAY,GAAG,IAAIC,YAAJ,CAAiBJ,IAAI,CAACK,YAAL,GAAoB,CAArC,CAArB;;AACA,SAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGN,IAAI,CAACK,YAAzB,EAAuCC,CAAC,EAAxC,EAA4C;AAC1CT,MAAAA,SAAS,CAACI,OAAO,CAACK,CAAC,GAAG,CAAL,CAAR,EAAiBL,OAAO,CAACK,CAAC,GAAG,CAAJ,GAAQ,CAAT,CAAxB,EAAqCR,aAArC,CAAT;AAEAA,MAAAA,aAAa,CAACS,OAAd,CAAsBJ,YAAtB,EAAoCG,CAAC,GAAG,CAAxC;AACD;;AAED,WAAO;AACLE,MAAAA,IAAI,EAAEZ,EAAE,CAACa,KADJ;AAELC,MAAAA,IAAI,EAAE,CAFD;AAGLC,MAAAA,KAAK,EAAER;AAHF,KAAP;AAKD;;AAED,SAAO;AACLK,IAAAA,IAAI,EAAEZ,EAAE,CAACa,KADJ;AAELC,IAAAA,IAAI,EAAE,CAFD;AAGLC,IAAAA,KAAK,EAAEV;AAHF,GAAP;AAKD","sourcesContent":["import {Vector3} from '@math.gl/core';\nimport {GL, octDecode} from '@loaders.gl/math';\n\nconst scratchNormal = new Vector3();\n\nexport function normalize3DTileNormalAttribute(tile, normals) {\n  if (!normals) {\n    return null;\n  }\n\n  if (tile.isOctEncoded16P) {\n    const decodedArray = new Float32Array(tile.pointsLength * 3);\n    for (let i = 0; i < tile.pointsLength; i++) {\n      octDecode(normals[i * 2], normals[i * 2 + 1], scratchNormal);\n      // @ts-ignore\n      scratchNormal.toArray(decodedArray, i * 3);\n    }\n\n    return {\n      type: GL.FLOAT,\n      size: 2,\n      value: decodedArray\n    };\n  }\n\n  return {\n    type: GL.FLOAT,\n    size: 2,\n    value: normals\n  };\n}\n"],"file":"normalize-3d-tile-normals.js"}

package/dist/lib/parsers/helpers/normalize-3d-tile-positions.js

@@ -1,42 +1,31 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalize3DTilePositionAttribute = void 0;
-const core_1 = require("@math.gl/core");
-const math_1 = require("@loaders.gl/math");
-// Prepare attribute for positions
-function normalize3DTilePositionAttribute(tile, positions, options) {
-    if (!tile.isQuantized) {
-        return positions;
-    }
-    // For quantized posititions, either expand to Float32Array or return custom accessor
-    // https://github.com/AnalyticalGraphicsInc/3d-tiles/blob/master/specification/TileFormats/Instanced3DModel/README.md#quantized-positions
-    // Optionally decodes quantized positions on GPU, for simpler renderers that don't accept normalized attributes
-    if (options['3d-tiles'] && options['3d-tiles'].decodeQuantizedPositions) {
-        tile.isQuantized = false;
-        return decodeQuantizedPositions(tile, positions);
-    }
-    // Default: Use normalized shorts directly, no copying/processing.
-    // NOTE: The "missing" offset/scaling operations are automatically added to modelMatrix if `tile.isQuantized === true`
-    return {
-        type: math_1.GL.UNSIGNED_SHORT,
-        value: positions,
-        size: 3,
-        normalized: true
-    };
+import { Vector3 } from '@math.gl/core';
+import { GL } from '@loaders.gl/math';
+export function normalize3DTilePositionAttribute(tile, positions, options) {
+  if (!tile.isQuantized) {
+    return positions;
+  }
+
+  if (options['3d-tiles'] && options['3d-tiles'].decodeQuantizedPositions) {
+    tile.isQuantized = false;
+    return decodeQuantizedPositions(tile, positions);
+  }
+
+  return {
+    type: GL.UNSIGNED_SHORT,
+    value: positions,
+    size: 3,
+    normalized: true
+  };
 }
-exports.normalize3DTilePositionAttribute = normalize3DTilePositionAttribute;
-// Pre-scale quantized positions on CPU
+
 function decodeQuantizedPositions(tile, positions) {
-    const scratchPosition = new core_1.Vector3();
-    const decodedArray = new Float32Array(tile.pointCount * 3);
-    for (let i = 0; i < tile.pointCount; i++) {
-        // POSITION = POSITION_QUANTIZED / 65535.0 * QUANTIZED_VOLUME_SCALE + QUANTIZED_VOLUME_OFFSET
-        scratchPosition
-            .set(positions[i * 3], positions[i * 3 + 1], positions[i * 3 + 2])
-            .scale(1 / tile.quantizedRange)
-            .multiply(tile.quantizedVolumeScale)
-            .add(tile.quantizedVolumeOffset)
-            .toArray(decodedArray, i * 3);
-    }
-    return decodedArray;
+  const scratchPosition = new Vector3();
+  const decodedArray = new Float32Array(tile.pointCount * 3);
+
+  for (let i = 0; i < tile.pointCount; i++) {
+    scratchPosition.set(positions[i * 3], positions[i * 3 + 1], positions[i * 3 + 2]).scale(1 / tile.quantizedRange).multiply(tile.quantizedVolumeScale).add(tile.quantizedVolumeOffset).toArray(decodedArray, i * 3);
+  }
+
+  return decodedArray;
 }
+//# sourceMappingURL=normalize-3d-tile-positions.js.map

package/dist/lib/parsers/helpers/normalize-3d-tile-positions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/parsers/helpers/normalize-3d-tile-positions.ts"],"names":["Vector3","GL","normalize3DTilePositionAttribute","tile","positions","options","isQuantized","decodeQuantizedPositions","type","UNSIGNED_SHORT","value","size","normalized","scratchPosition","decodedArray","Float32Array","pointCount","i","set","scale","quantizedRange","multiply","quantizedVolumeScale","add","quantizedVolumeOffset","toArray"],"mappings":"AAAA,SAAQA,OAAR,QAAsB,eAAtB;AACA,SAAQC,EAAR,QAAiB,kBAAjB;AAGA,OAAO,SAASC,gCAAT,CAA0CC,IAA1C,EAAgDC,SAAhD,EAA2DC,OAA3D,EAAoE;AACzE,MAAI,CAACF,IAAI,CAACG,WAAV,EAAuB;AACrB,WAAOF,SAAP;AACD;;AAMD,MAAIC,OAAO,CAAC,UAAD,CAAP,IAAuBA,OAAO,CAAC,UAAD,CAAP,CAAoBE,wBAA/C,EAAyE;AACvEJ,IAAAA,IAAI,CAACG,WAAL,GAAmB,KAAnB;AACA,WAAOC,wBAAwB,CAACJ,IAAD,EAAOC,SAAP,CAA/B;AACD;;AAID,SAAO;AACLI,IAAAA,IAAI,EAAEP,EAAE,CAACQ,cADJ;AAELC,IAAAA,KAAK,EAAEN,SAFF;AAGLO,IAAAA,IAAI,EAAE,CAHD;AAILC,IAAAA,UAAU,EAAE;AAJP,GAAP;AAMD;;AAGD,SAASL,wBAAT,CAAkCJ,IAAlC,EAAwCC,SAAxC,EAAmD;AACjD,QAAMS,eAAe,GAAG,IAAIb,OAAJ,EAAxB;AACA,QAAMc,YAAY,GAAG,IAAIC,YAAJ,CAAiBZ,IAAI,CAACa,UAAL,GAAkB,CAAnC,CAArB;;AAEA,OAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGd,IAAI,CAACa,UAAzB,EAAqCC,CAAC,EAAtC,EAA0C;AAExCJ,IAAAA,eAAe,CACZK,GADH,CACOd,SAAS,CAACa,CAAC,GAAG,CAAL,CADhB,EACyBb,SAAS,CAACa,CAAC,GAAG,CAAJ,GAAQ,CAAT,CADlC,EAC+Cb,SAAS,CAACa,CAAC,GAAG,CAAJ,GAAQ,CAAT,CADxD,EAEGE,KAFH,CAES,IAAIhB,IAAI,CAACiB,cAFlB,EAGGC,QAHH,CAGYlB,IAAI,CAACmB,oBAHjB,EAIGC,GAJH,CAIOpB,IAAI,CAACqB,qBAJZ,EAKGC,OALH,CAKWX,YALX,EAKyBG,CAAC,GAAG,CAL7B;AAMD;;AAED,SAAOH,YAAP;AACD","sourcesContent":["import {Vector3} from '@math.gl/core';\nimport {GL} from '@loaders.gl/math';\n\n// Prepare attribute for positions\nexport function normalize3DTilePositionAttribute(tile, positions, options) {\n  if (!tile.isQuantized) {\n    return positions;\n  }\n\n  // For quantized posititions, either expand to Float32Array or return custom accessor\n  // https://github.com/AnalyticalGraphicsInc/3d-tiles/blob/master/specification/TileFormats/Instanced3DModel/README.md#quantized-positions\n\n  // Optionally decodes quantized positions on GPU, for simpler renderers that don't accept normalized attributes\n  if (options['3d-tiles'] && options['3d-tiles'].decodeQuantizedPositions) {\n    tile.isQuantized = false;\n    return decodeQuantizedPositions(tile, positions);\n  }\n\n  // Default: Use normalized shorts directly, no copying/processing.\n  // NOTE: The \"missing\" offset/scaling operations are automatically added to modelMatrix if `tile.isQuantized === true`\n  return {\n    type: GL.UNSIGNED_SHORT,\n    value: positions,\n    size: 3,\n    normalized: true\n  };\n}\n\n// Pre-scale quantized positions on CPU\nfunction decodeQuantizedPositions(tile, positions) {\n  const scratchPosition = new Vector3();\n  const decodedArray = new Float32Array(tile.pointCount * 3);\n\n  for (let i = 0; i < tile.pointCount; i++) {\n    // POSITION = POSITION_QUANTIZED / 65535.0 * QUANTIZED_VOLUME_SCALE + QUANTIZED_VOLUME_OFFSET\n    scratchPosition\n      .set(positions[i * 3], positions[i * 3 + 1], positions[i * 3 + 2])\n      .scale(1 / tile.quantizedRange)\n      .multiply(tile.quantizedVolumeScale)\n      .add(tile.quantizedVolumeOffset)\n      .toArray(decodedArray, i * 3);\n  }\n\n  return decodedArray;\n}\n"],"file":"normalize-3d-tile-positions.js"}

package/dist/lib/parsers/helpers/parse-3d-implicit-tiles.d.ts

@@ -11,17 +11,24 @@ import type { Subtree } from '../../../types';
  * @param level
  * @param globalData
  */
-export declare function parseImplicitTiles(subtree: Subtree, options: any, parentData?: {
-    mortonIndex: number;
-    x: number;
-    y: number;
-    z: number;
-}, childIndex?: number, level?: number, globalData?: {
-    level: number;
-    mortonIndex: number;
-    x: number;
-    y: number;
-    z: number;
+export declare function parseImplicitTiles(params: {
+    subtree: Subtree;
+    options: any;
+    parentData?: {
+        mortonIndex: number;
+        x: number;
+        y: number;
+        z: number;
+    };
+    childIndex?: number;
+    level?: number;
+    globalData?: {
+        level: number;
+        mortonIndex: number;
+        x: number;
+        y: number;
+        z: number;
+    };
 }): Promise<{
     children: never[];
     lodMetricValue: number;