@loaders.gl/3d-tiles 4.2.0-alpha.4 → 4.2.0-alpha.5

package/dist/lib/utils/s2/s2geometry/s2-geometry.js

@@ -1,186 +1,247 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT AND ISC
+// Copyright vis.gl contributors
+/*
+Adapted from s2-geometry under ISC License (ISC)
+Copyright (c) 2012-2016, Jon Atkins <github@jonatkins.com>
+Copyright (c) 2016, AJ ONeal <aj@daplie.com>
+Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
 import Long from 'long';
+//
+// Functional Style
+//
 const FACE_BITS = 3;
 const MAX_LEVEL = 30;
-const POS_BITS = 2 * MAX_LEVEL + 1;
+const POS_BITS = 2 * MAX_LEVEL + 1; // 61 (60 bits of data, 1 bit lsb marker)
 const RADIAN_TO_DEGREE = 180 / Math.PI;
+/**
+ * Return the S2Cell
+ * @param hilbertQuadkey {string} A string that is the Hilbert quad key (containing /)
+ * @returns {@link S2Cell}
+ */
+// eslint-disable-next-line max-statements
 export function getS2CellFromQuadKey(hilbertQuadkey) {
-  if (hilbertQuadkey.length === 0) {
-    throw new Error(`Invalid Hilbert quad key ${hilbertQuadkey}`);
-  }
-  const parts = hilbertQuadkey.split('/');
-  const face = parseInt(parts[0], 10);
-  const position = parts[1];
-  const maxLevel = position.length;
-  let level = 0;
-  const point = [0, 0];
-  for (let i = maxLevel - 1; i >= 0; i--) {
-    level = maxLevel - i;
-    const bit = position[i];
-    let rx = 0;
-    let ry = 0;
-    if (bit === '1') {
-      ry = 1;
-    } else if (bit === '2') {
-      rx = 1;
-      ry = 1;
-    } else if (bit === '3') {
-      rx = 1;
+    if (hilbertQuadkey.length === 0) {
+        throw new Error(`Invalid Hilbert quad key ${hilbertQuadkey}`);
+    }
+    const parts = hilbertQuadkey.split('/');
+    const face = parseInt(parts[0], 10); // face is in the range [0..5]
+    const position = parts[1]; // position is in the range [0..4**30-1]
+    const maxLevel = position.length;
+    let level = 0;
+    const point = [0, 0];
+    for (let i = maxLevel - 1; i >= 0; i--) {
+        level = maxLevel - i;
+        const bit = position[i];
+        let rx = 0;
+        let ry = 0;
+        if (bit === '1') {
+            ry = 1;
+        }
+        else if (bit === '2') {
+            rx = 1;
+            ry = 1;
+        }
+        else if (bit === '3') {
+            rx = 1;
+        }
+        const val = Math.pow(2, level - 1);
+        rotateAndFlipQuadrant(val, point, rx, ry);
+        point[0] += val * rx;
+        point[1] += val * ry;
     }
-    const val = Math.pow(2, level - 1);
-    rotateAndFlipQuadrant(val, point, rx, ry);
-    point[0] += val * rx;
-    point[1] += val * ry;
-  }
-  if (face % 2 === 1) {
-    const t = point[0];
-    point[0] = point[1];
-    point[1] = t;
-  }
-  return {
-    face,
-    ij: point,
-    level
-  };
+    if (face % 2 === 1) {
+        const t = point[0];
+        point[0] = point[1];
+        point[1] = t;
+    }
+    return { face, ij: point, level };
 }
+/**
+ * Convets S2 cell ID to the Hilbert quad key
+ * @param cellId {Long} Cell id that is a 64-bit encoding of a face and a Hilbert curve parameter on that face
+ * @returns {string} the Hilbert quad key (containing /) as a string in the format 'face/pos', where
+ *  - face is a 10-base representation of the face number
+ *  - pos is a 4-base representation of the position along the Hilbert curve. For example,
+ *    pos == '13' means the following:
+ *       The face is divided two times. After the first time the child cell with position 1 will be selected.
+ *       Then, this cell will be divided the second time, and the child cell with position 3 will be selected.
+ */
 export function getS2QuadkeyFromCellId(cellId) {
-  if (cellId.isZero()) {
-    return '';
-  }
-  let bin = cellId.toString(2);
-  while (bin.length < FACE_BITS + POS_BITS) {
-    bin = '0' + bin;
-  }
-  const lsbIndex = bin.lastIndexOf('1');
-  const faceB = bin.substring(0, 3);
-  const posB = bin.substring(3, lsbIndex);
-  const levelN = posB.length / 2;
-  const faceS = Long.fromString(faceB, true, 2).toString(10);
-  let posS = '';
-  if (levelN !== 0) {
-    posS = Long.fromString(posB, true, 2).toString(4);
-    while (posS.length < levelN) {
-      posS = '0' + posS;
+    if (cellId.isZero()) {
+        // Invalid token
+        return '';
+    }
+    let bin = cellId.toString(2);
+    while (bin.length < FACE_BITS + POS_BITS) {
+        // eslint-disable-next-line prefer-template
+        bin = '0' + bin;
     }
-  }
-  return `${faceS}/${posS}`;
+    // MUST come AFTER binstr has been left-padded with '0's
+    const lsbIndex = bin.lastIndexOf('1');
+    // substring(start, end) // includes start, does not include end
+    const faceB = bin.substring(0, 3);
+    // posB will always be a multiple of 2 (or it's invalid)
+    const posB = bin.substring(3, lsbIndex);
+    const levelN = posB.length / 2;
+    const faceS = Long.fromString(faceB, true, 2).toString(10);
+    /*
+      Here is a fix for the case when posB is an empty string that causes an exception in Long.fromString
+    */
+    let posS = '';
+    if (levelN !== 0) {
+        // posB is not an empty string, because levelN !== 0
+        posS = Long.fromString(posB, true, 2).toString(4);
+        while (posS.length < levelN) {
+            // eslint-disable-next-line prefer-template
+            posS = '0' + posS;
+        }
+    }
+    // Note, posS will be "" for the level==0, which corresponds to the full face.
+    // Example: Full face 0 (No subdivision, so level==0): Returns "0/"
+    // TODO: Is it ok?
+    return `${faceS}/${posS}`;
 }
+/**
+ * Convets S2 the Hilbert quad key to cell ID.
+ * @param quadkey {string} The Hilbert quad key (containing /) as a string in the format 'face/pos'
+ * @returns {Long} Cell id that is a 64-bit encoding of a face and a Hilbert curve parameter on that face
+ */
+/* eslint complexity: ["error", { "max": 14 }] */
 export function getS2CellIdFromQuadkey(hilbertQuadkey) {
-  if (hilbertQuadkey.length === 0 || hilbertQuadkey.indexOf('/') !== 1) {
-    throw new Error(`Invalid Hilbert quad key ${hilbertQuadkey}`);
-  }
-  let idS = '';
-  const faceS = hilbertQuadkey[0];
-  switch (faceS) {
-    case '0':
-      idS += '000';
-      break;
-    case '1':
-      idS += '001';
-      break;
-    case '2':
-      idS += '010';
-      break;
-    case '3':
-      idS += '011';
-      break;
-    case '4':
-      idS += '100';
-      break;
-    case '5':
-      idS += '101';
-      break;
-    default:
-      throw new Error(`Invalid Hilbert quad key ${hilbertQuadkey}`);
-  }
-  const maxLevel = hilbertQuadkey.length;
-  for (let i = 2; i < maxLevel; i++) {
-    const p = hilbertQuadkey[i];
-    switch (p) {
-      case '0':
-        idS += '00';
-        break;
-      case '1':
-        idS += '01';
-        break;
-      case '2':
-        idS += '10';
-        break;
-      case '3':
-        idS += '11';
-        break;
-      default:
+    if (hilbertQuadkey.length === 0 || hilbertQuadkey.indexOf('/') !== 1) {
         throw new Error(`Invalid Hilbert quad key ${hilbertQuadkey}`);
     }
-  }
-  idS += '1';
-  const paddedId = idS.padEnd(64, '0');
-  const id = Long.fromString(paddedId, true, 2);
-  return id;
+    let idS = '';
+    const faceS = hilbertQuadkey[0];
+    switch (faceS) {
+        case '0':
+            idS += '000';
+            break;
+        case '1':
+            idS += '001';
+            break;
+        case '2':
+            idS += '010';
+            break;
+        case '3':
+            idS += '011';
+            break;
+        case '4':
+            idS += '100';
+            break;
+        case '5':
+            idS += '101';
+            break;
+        default:
+            throw new Error(`Invalid Hilbert quad key ${hilbertQuadkey}`);
+    }
+    const maxLevel = hilbertQuadkey.length;
+    // Don't convert position to Long, because it can contain leading zeros, which makes you handle it later.
+    for (let i = 2; i < maxLevel; i++) {
+        // The first char is a face, the second char is '/'
+        const p = hilbertQuadkey[i];
+        switch (p) {
+            case '0':
+                idS += '00';
+                break;
+            case '1':
+                idS += '01';
+                break;
+            case '2':
+                idS += '10';
+                break;
+            case '3':
+                idS += '11';
+                break;
+            default:
+                throw new Error(`Invalid Hilbert quad key ${hilbertQuadkey}`);
+        }
+    }
+    // Append the sentinel bit
+    idS += '1';
+    const paddedId = idS.padEnd(64, '0');
+    const id = Long.fromString(paddedId, true, 2);
+    return id;
 }
 export function IJToST(ij, level, offsets) {
-  const maxSize = 1 << level;
-  return [(ij[0] + offsets[0]) / maxSize, (ij[1] + offsets[1]) / maxSize];
+    const maxSize = 1 << level;
+    return [(ij[0] + offsets[0]) / maxSize, (ij[1] + offsets[1]) / maxSize];
 }
 function singleSTtoUV(st) {
-  if (st >= 0.5) {
-    return 1 / 3.0 * (4 * st * st - 1);
-  }
-  return 1 / 3.0 * (1 - 4 * (1 - st) * (1 - st));
+    if (st >= 0.5) {
+        return (1 / 3.0) * (4 * st * st - 1);
+    }
+    return (1 / 3.0) * (1 - 4 * (1 - st) * (1 - st));
 }
 export function STToUV(st) {
-  return [singleSTtoUV(st[0]), singleSTtoUV(st[1])];
+    return [singleSTtoUV(st[0]), singleSTtoUV(st[1])];
 }
-export function FaceUVToXYZ(face, _ref) {
-  let [u, v] = _ref;
-  switch (face) {
-    case 0:
-      return [1, u, v];
-    case 1:
-      return [-u, 1, v];
-    case 2:
-      return [-u, -v, 1];
-    case 3:
-      return [-1, -v, -u];
-    case 4:
-      return [v, -1, -u];
-    case 5:
-      return [v, u, -1];
-    default:
-      throw new Error('Invalid face');
-  }
+export function FaceUVToXYZ(face, [u, v]) {
+    switch (face) {
+        case 0:
+            return [1, u, v];
+        case 1:
+            return [-u, 1, v];
+        case 2:
+            return [-u, -v, 1];
+        case 3:
+            return [-1, -v, -u];
+        case 4:
+            return [v, -1, -u];
+        case 5:
+            return [v, u, -1];
+        default:
+            throw new Error('Invalid face');
+    }
 }
-export function XYZToLngLat(_ref2) {
-  let [x, y, z] = _ref2;
-  const lat = Math.atan2(z, Math.sqrt(x * x + y * y));
-  const lng = Math.atan2(y, x);
-  return [lng * RADIAN_TO_DEGREE, lat * RADIAN_TO_DEGREE];
+export function XYZToLngLat([x, y, z]) {
+    const lat = Math.atan2(z, Math.sqrt(x * x + y * y));
+    const lng = Math.atan2(y, x);
+    return [lng * RADIAN_TO_DEGREE, lat * RADIAN_TO_DEGREE];
 }
 function rotateAndFlipQuadrant(n, point, rx, ry) {
-  if (ry === 0) {
-    if (rx === 1) {
-      point[0] = n - 1 - point[0];
-      point[1] = n - 1 - point[1];
+    if (ry === 0) {
+        if (rx === 1) {
+            point[0] = n - 1 - point[0];
+            point[1] = n - 1 - point[1];
+        }
+        const x = point[0];
+        point[0] = point[1];
+        point[1] = x;
     }
-    const x = point[0];
-    point[0] = point[1];
-    point[1] = x;
-  }
 }
+/**
+ * Retrieve S2 geometry center
+ * @param s2cell {S2Cell} S2 cell
+ * @returns {[number, number]} Longitude and Latitude coordinates of the S2 cell's center
+ */
 export function getS2LngLatFromS2Cell(s2Cell) {
-  const st = IJToST(s2Cell.ij, s2Cell.level, [0.5, 0.5]);
-  const uv = STToUV(st);
-  const xyz = FaceUVToXYZ(s2Cell.face, uv);
-  return XYZToLngLat(xyz);
-}
-export function getCornerLngLats(s2Cell) {
-  const result = [];
-  const offsets = [[0.0, 0.0], [0.0, 1.0], [1.0, 1.0], [1.0, 0.0]];
-  for (let i = 0; i < 4; i++) {
-    const st = IJToST(s2Cell.ij, s2Cell.level, offsets[i]);
+    const st = IJToST(s2Cell.ij, s2Cell.level, [0.5, 0.5]);
     const uv = STToUV(st);
     const xyz = FaceUVToXYZ(s2Cell.face, uv);
-    result.push(XYZToLngLat(xyz));
-  }
-  return result;
+    return XYZToLngLat(xyz);
+}
+/**
+ * Return longitude and latitude of four corners of the cell.
+ * @param s2Cell {S2Cell} S2 cell
+ * @returns {Array<[number, number]>} Array of longitude and latitude pairs (in degrees) for four corners of the cell.
+ */
+export function getCornerLngLats(s2Cell) {
+    const result = [];
+    const offsets = [
+        [0.0, 0.0],
+        [0.0, 1.0],
+        [1.0, 1.0],
+        [1.0, 0.0]
+    ];
+    for (let i = 0; i < 4; i++) {
+        const st = IJToST(s2Cell.ij, s2Cell.level, offsets[i]);
+        const uv = STToUV(st);
+        const xyz = FaceUVToXYZ(s2Cell.face, uv);
+        result.push(XYZToLngLat(xyz));
+    }
+    return result;
 }
-//# sourceMappingURL=s2-geometry.js.map

package/dist/lib/utils/version.js

@@ -1,2 +1,4 @@
+// Version constant cannot be imported, it needs to correspond to the build version of **this** module.
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
 export const VERSION = typeof "4.2.0-alpha.4" !== 'undefined' ? "4.2.0-alpha.4" : 'latest';
-//# sourceMappingURL=version.js.map

package/dist/tile-3d-subtree-loader.d.ts

@@ -1,5 +1,5 @@
 import type { LoaderOptions, LoaderWithParser } from '@loaders.gl/loader-utils';
-import type { Subtree } from './types';
+import type { Subtree } from "./types.js";
 /**
  * Loader for 3D Tiles Subtree
  */

package/dist/tile-3d-subtree-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tile-3d-subtree-loader.d.ts","sourceRoot":"","sources":["../src/tile-3d-subtree-loader.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,aAAa,EAAE,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAC9E,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,SAAS,CAAC;AAIrC;;GAEG;AACH,eAAO,MAAM,mBAAmB,EAAE,gBAAgB,CAAC,OAAO,EAAE,KAAK,EAAE,aAAa,CAU/E,CAAC"}
+{"version":3,"file":"tile-3d-subtree-loader.d.ts","sourceRoot":"","sources":["../src/tile-3d-subtree-loader.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,aAAa,EAAE,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAC9E,OAAO,KAAK,EAAC,OAAO,EAAC,mBAAgB;AAIrC;;GAEG;AACH,eAAO,MAAM,mBAAmB,EAAE,gBAAgB,CAAC,OAAO,EAAE,KAAK,EAAE,aAAa,CAU/E,CAAC"}

package/dist/tile-3d-subtree-loader.js

@@ -1,14 +1,19 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright vis.gl contributors
 import parse3DTilesSubtree from "./lib/parsers/helpers/parse-3d-tile-subtree.js";
 import { VERSION } from "./lib/utils/version.js";
+/**
+ * Loader for 3D Tiles Subtree
+ */
 export const Tile3DSubtreeLoader = {
-  id: '3d-tiles-subtree',
-  name: '3D Tiles Subtree',
-  module: '3d-tiles',
-  version: VERSION,
-  extensions: ['subtree'],
-  mimeTypes: ['application/octet-stream'],
-  tests: ['subtree'],
-  parse: parse3DTilesSubtree,
-  options: {}
+    id: '3d-tiles-subtree',
+    name: '3D Tiles Subtree',
+    module: '3d-tiles',
+    version: VERSION,
+    extensions: ['subtree'],
+    mimeTypes: ['application/octet-stream'],
+    tests: ['subtree'],
+    parse: parse3DTilesSubtree,
+    options: {}
 };
-//# sourceMappingURL=tile-3d-subtree-loader.js.map

package/dist/tile-3d-writer.js

@@ -1,20 +1,25 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright vis.gl contributors
 import { VERSION } from "./lib/utils/version.js";
 import encode3DTile from "./lib/encoders/encode-3d-tile.js";
+/**
+ * Exporter for 3D Tiles
+ */
 export const Tile3DWriter = {
-  name: '3D Tile',
-  id: '3d-tiles',
-  module: '3d-tiles',
-  version: VERSION,
-  extensions: ['cmpt', 'pnts', 'b3dm', 'i3dm'],
-  mimeTypes: ['application/octet-stream'],
-  binary: true,
-  options: {
-    ['3d-tiles']: {}
-  },
-  encode: async (tile, options) => encodeSync(tile, options),
-  encodeSync
+    name: '3D Tile',
+    id: '3d-tiles',
+    module: '3d-tiles',
+    version: VERSION,
+    extensions: ['cmpt', 'pnts', 'b3dm', 'i3dm'],
+    mimeTypes: ['application/octet-stream'],
+    binary: true,
+    options: {
+        ['3d-tiles']: {}
+    },
+    encode: async (tile, options) => encodeSync(tile, options),
+    encodeSync
 };
 function encodeSync(tile, options) {
-  return encode3DTile(tile, options);
+    return encode3DTile(tile, options);
 }
-//# sourceMappingURL=tile-3d-writer.js.map

package/dist/tiles-3d-loader.js

@@ -1,70 +1,80 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright vis.gl contributors
 import { path } from '@loaders.gl/loader-utils';
 import { TILESET_TYPE, LOD_METRIC_TYPE } from '@loaders.gl/tiles';
 import { VERSION } from "./lib/utils/version.js";
 import { parse3DTile } from "./lib/parsers/parse-3d-tile.js";
 import { normalizeTileHeaders } from "./lib/parsers/parse-3d-tile-header.js";
+/**
+ * Loader for 3D Tiles
+ */
 export const Tiles3DLoader = {
-  id: '3d-tiles',
-  name: '3D Tiles',
-  module: '3d-tiles',
-  version: VERSION,
-  extensions: ['cmpt', 'pnts', 'b3dm', 'i3dm'],
-  mimeTypes: ['application/octet-stream'],
-  tests: ['cmpt', 'pnts', 'b3dm', 'i3dm'],
-  parse,
-  options: {
-    '3d-tiles': {
-      loadGLTF: true,
-      decodeQuantizedPositions: false,
-      isTileset: 'auto',
-      assetGltfUpAxis: null
+    id: '3d-tiles',
+    name: '3D Tiles',
+    module: '3d-tiles',
+    version: VERSION,
+    extensions: ['cmpt', 'pnts', 'b3dm', 'i3dm'],
+    mimeTypes: ['application/octet-stream'],
+    tests: ['cmpt', 'pnts', 'b3dm', 'i3dm'],
+    parse,
+    options: {
+        '3d-tiles': {
+            loadGLTF: true,
+            decodeQuantizedPositions: false,
+            isTileset: 'auto',
+            assetGltfUpAxis: null
+        }
     }
-  }
 };
-async function parse(data) {
-  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  let context = arguments.length > 2 ? arguments[2] : undefined;
-  const loaderOptions = options['3d-tiles'] || {};
-  let isTileset;
-  if (loaderOptions.isTileset === 'auto') {
-    isTileset = (context === null || context === void 0 ? void 0 : context.url) && context.url.indexOf('.json') !== -1;
-  } else {
-    isTileset = loaderOptions.isTileset;
-  }
-  return isTileset ? parseTileset(data, options, context) : parseTile(data, options, context);
+/** Parses a tileset or tile */
+async function parse(data, options = {}, context) {
+    // auto detect file type
+    const loaderOptions = options['3d-tiles'] || {};
+    let isTileset;
+    if (loaderOptions.isTileset === 'auto') {
+        isTileset = context?.url && context.url.indexOf('.json') !== -1;
+    }
+    else {
+        isTileset = loaderOptions.isTileset;
+    }
+    return isTileset ? parseTileset(data, options, context) : parseTile(data, options, context);
 }
+/** Parse a tileset */
 async function parseTileset(data, options, context) {
-  var _tilesetJson$root;
-  const tilesetJson = JSON.parse(new TextDecoder().decode(data));
-  const tilesetUrl = (context === null || context === void 0 ? void 0 : context.url) || '';
-  const basePath = getBaseUri(tilesetUrl);
-  const normalizedRoot = await normalizeTileHeaders(tilesetJson, basePath, options || {});
-  const tilesetJsonPostprocessed = {
-    ...tilesetJson,
-    shape: 'tileset3d',
-    loader: Tiles3DLoader,
-    url: tilesetUrl,
-    queryString: (context === null || context === void 0 ? void 0 : context.queryString) || '',
-    basePath,
-    root: normalizedRoot || tilesetJson.root,
-    type: TILESET_TYPE.TILES3D,
-    lodMetricType: LOD_METRIC_TYPE.GEOMETRIC_ERROR,
-    lodMetricValue: ((_tilesetJson$root = tilesetJson.root) === null || _tilesetJson$root === void 0 ? void 0 : _tilesetJson$root.geometricError) || 0
-  };
-  return tilesetJsonPostprocessed;
+    const tilesetJson = JSON.parse(new TextDecoder().decode(data));
+    const tilesetUrl = context?.url || '';
+    const basePath = getBaseUri(tilesetUrl);
+    const normalizedRoot = await normalizeTileHeaders(tilesetJson, basePath, options || {});
+    const tilesetJsonPostprocessed = {
+        ...tilesetJson,
+        shape: 'tileset3d',
+        loader: Tiles3DLoader,
+        url: tilesetUrl,
+        queryString: context?.queryString || '',
+        basePath,
+        root: normalizedRoot || tilesetJson.root,
+        type: TILESET_TYPE.TILES3D,
+        lodMetricType: LOD_METRIC_TYPE.GEOMETRIC_ERROR,
+        lodMetricValue: tilesetJson.root?.geometricError || 0
+    };
+    return tilesetJsonPostprocessed;
 }
+/** Parse a tile */
 async function parseTile(arrayBuffer, options, context) {
-  const tile = {
-    content: {
-      shape: 'tile3d',
-      featureIds: null
-    }
-  };
-  const byteOffset = 0;
-  await parse3DTile(arrayBuffer, byteOffset, options, context, tile.content);
-  return tile.content;
+    const tile = {
+        content: {
+            shape: 'tile3d',
+            featureIds: null
+        }
+    };
+    const byteOffset = 0;
+    // @ts-expect-error
+    await parse3DTile(arrayBuffer, byteOffset, options, context, tile.content);
+    // @ts-expect-error
+    return tile.content;
 }
+/** Get base name */
 function getBaseUri(tilesetUrl) {
-  return path.dirname(tilesetUrl);
+    return path.dirname(tilesetUrl);
 }
-//# sourceMappingURL=tiles-3d-loader.js.map

package/dist/types.js

@@ -1,2 +1,4 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright vis.gl contributors
 export {};
-//# sourceMappingURL=types.js.map