@loaders.gl/gltf 4.0.0-beta.1 → 4.0.0-beta.3

package/dist/es5/lib/extensions/utils/3d-tiles-utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"3d-tiles-utils.js","names":["_gltfUtils","require","_images","_math","_createForOfIteratorHelper","o","allowArrayLike","it","Symbol","iterator","Array","isArray","_unsupportedIterableToArray","length","i","F","s","n","done","value","e","_e","f","TypeError","normalCompletion","didErr","err","call","step","next","_e2","return","minLen","_arrayLikeToArray","Object","prototype","toString","slice","constructor","name","from","test","arr","len","arr2","ATTRIBUTE_TYPE_TO_COMPONENTS","SCALAR","VEC2","VEC3","VEC4","MAT2","MAT3","MAT4","BOOLEAN","STRING","ENUM","ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY","INT8","Int8Array","UINT8","Uint8Array","INT16","Int16Array","UINT16","Uint16Array","INT32","Int32Array","UINT32","Uint32Array","INT64","BigInt64Array","UINT64","BigUint64Array","FLOAT32","Float32Array","FLOAT64","Float64Array","ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE","getArrayElementByteSize","attributeType","componentType","getOffsetsForProperty","scenegraph","bufferViewIndex","offsetType","numberOfElements","arrayOffsetsBytes","getTypedArrayForBufferView","arrayOffsets","convertRawBufferToMetadataArray","data","elementCount","arguments","undefined","numberOfComponents","ArrayType","size","byteLength","buffer","offset","byteOffset","bufferArray","getPrimitiveTextureData","textureInfo","primitive","_json$textures","_json$textures$textur","json","gltf","texCoordAccessorKey","concat","texCoord","texCoordAccessorIndex","attributes","textureCoordinates","getFloat32ArrayForAccessor","textureIndex","index","imageIndex","textures","source","_json$images","_json$images$imageInd","_scenegraph$gltf$imag","mimeType","images","parsedImage","width","textureData","getImageValueByCoordinates","channels","push","primitivePropertyDataToAttributes","attributeName","propertyData","featureTable","featureIndices","_iterator","_step","_loop","texelData","findIndex","item","typedArray","bufferIndex","buffers","arrayBuffer","addBufferView","accessorIndex","addAccessor","getComponentTypeFromArray","count","CHANNELS_MAP","r","shift","g","b","a","u","v","components","indexOf","coordinatesToOffset","_iterator2","_step2","c","map","values","imageOffset","imageData","getImageData","Error","imageValue","componentsCount","w","iX","emod","indX","Math","round","h","height","iY","indY","parseVariableLengthArrayNumeric","valuesData","valuesDataBytesLength","valueSize","attributeValueArray","arrayOffset","arrayByteSize","typedArrayOffset","parseFixedLengthArrayNumeric","arrayCount","elementOffset","getPropertyDataString","valuesDataBytes","stringOffsets","stringsArray","textDecoder","TextDecoder","stringOffset","stringByteSize","stringData","subarray","stringAttribute","decode"],"sources":["../../../../../src/lib/extensions/utils/3d-tiles-utils.ts"],"sourcesContent":["/**\n * loaders.gl, MIT license\n *\n * Shared code for 3DTiles extensions:\n * * EXT_feature_metadata\n * * EXT_mesh_features\n * * EXT_structural_metadata\n */\n\nimport type {GLTFTextureInfoMetadata, GLTFMeshPrimitive} from '../../types/gltf-json-schema';\nimport type {BigTypedArray, TypedArray} from '@loaders.gl/schema';\nimport type {ImageType} from '@loaders.gl/images';\n\nimport {GLTFScenegraph} from '../../api/gltf-scenegraph';\nimport {getComponentTypeFromArray, getFloat32ArrayForAccessor} from '../../gltf-utils/gltf-utils';\nimport {getImageData} from '@loaders.gl/images';\nimport {emod} from '@loaders.gl/math';\n\nexport type NumericComponentType =\n  | 'INT8'\n  | 'UINT8'\n  | 'INT16'\n  | 'UINT16'\n  | 'INT32'\n  | 'UINT32'\n  | 'INT64'\n  | 'UINT64'\n  | 'FLOAT32'\n  | 'FLOAT64';\n\nconst ATTRIBUTE_TYPE_TO_COMPONENTS = {\n  SCALAR: 1,\n  VEC2: 2,\n  VEC3: 3,\n  VEC4: 4,\n  MAT2: 4,\n  MAT3: 9,\n  MAT4: 16,\n  BOOLEAN: 1,\n  STRING: 1,\n  ENUM: 1\n};\n\nconst ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY = {\n  INT8: Int8Array,\n  UINT8: Uint8Array,\n  INT16: Int16Array,\n  UINT16: Uint16Array,\n  INT32: Int32Array,\n  UINT32: Uint32Array,\n  INT64: BigInt64Array,\n  UINT64: BigUint64Array,\n  FLOAT32: Float32Array,\n  FLOAT64: Float64Array\n};\n\nconst ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE = {\n  INT8: 1,\n  UINT8: 1,\n  INT16: 2,\n  UINT16: 2,\n  INT32: 4,\n  UINT32: 4,\n  INT64: 8,\n  UINT64: 8,\n  FLOAT32: 4,\n  FLOAT64: 8\n};\n\nexport function getArrayElementByteSize(attributeType, componentType): number {\n  return (\n    ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[componentType] *\n    ATTRIBUTE_TYPE_TO_COMPONENTS[attributeType]\n  );\n}\n\n/**\n * Gets offset array from `arrayOffsets` or `stringOffsets`.\n * @param scenegraph - Instance of the class for structured access to GLTF data.\n * @param bufferViewIndex - Buffer view index\n * @param offsetType - The type of values in `arrayOffsets` or `stringOffsets`.\n * @param numberOfElements - The number of elements in each property array.\n * @returns Array of values offsets. The number of offsets in the array is equal to `numberOfElements` plus one.\n */\nexport function getOffsetsForProperty(\n  scenegraph: GLTFScenegraph,\n  bufferViewIndex: number,\n  offsetType: 'UINT8' | 'UINT16' | 'UINT32' | 'UINT64' | string,\n  numberOfElements: number\n): TypedArray | null {\n  if (\n    offsetType !== 'UINT8' &&\n    offsetType !== 'UINT16' &&\n    offsetType !== 'UINT32' &&\n    offsetType !== 'UINT64'\n  ) {\n    return null;\n  }\n  const arrayOffsetsBytes = scenegraph.getTypedArrayForBufferView(bufferViewIndex);\n  const arrayOffsets = convertRawBufferToMetadataArray(\n    arrayOffsetsBytes,\n    'SCALAR', // offsets consist of ONE component\n    offsetType,\n    numberOfElements + 1 // The number of offsets is equal to the property table `count` plus one.\n  );\n\n  // We don't support BigInt offsets at the moment. It requires additional logic and potential issues in Safari\n  if (arrayOffsets instanceof BigInt64Array || arrayOffsets instanceof BigUint64Array) {\n    return null;\n  }\n  return arrayOffsets;\n}\n\n/**\n * Converts raw bytes that are in the buffer to an array of the type defined by the schema.\n * @param data - Raw bytes in the buffer.\n * @param attributeType - SCALAR, VECN, MATN.\n * @param componentType - Type of the component in elements, e.g. 'UINT8' or 'FLOAT32'.\n * @param elementCount - Number of elements in the array. Default value is 1.\n * @returns Data array\n */\nexport function convertRawBufferToMetadataArray(\n  data: Uint8Array,\n  attributeType: string,\n  componentType: NumericComponentType,\n  elementCount: number = 1\n): BigTypedArray {\n  const numberOfComponents = ATTRIBUTE_TYPE_TO_COMPONENTS[attributeType];\n  const ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY[componentType];\n  const size = ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[componentType];\n  const length = elementCount * numberOfComponents;\n  const byteLength = length * size;\n  let buffer = data.buffer;\n  let offset = data.byteOffset;\n  if (offset % size !== 0) {\n    const bufferArray = new Uint8Array(buffer);\n    buffer = bufferArray.slice(offset, offset + byteLength).buffer;\n    offset = 0;\n  }\n  return new ArrayType(buffer, offset, length);\n}\n\n/**\n * Processes data encoded in the texture associated with the primitive.\n * @param scenegraph - Instance of the class for structured access to GLTF data.\n * @param textureInfo - Reference to the texture where extension data are stored.\n * @param primitive - Primitive object in the mesh.\n * @returns Array of data taken. Null if data can't be taken from the texture.\n */\nexport function getPrimitiveTextureData(\n  scenegraph: GLTFScenegraph,\n  textureInfo: GLTFTextureInfoMetadata,\n  primitive: GLTFMeshPrimitive\n): number[] | null {\n  /*\n    texture.index is an index for the \"textures\" array.\n    The texture object referenced by this index looks like this:\n    {\n    \"sampler\": 0,\n    \"source\": 0\n    }\n    \"sampler\" is an index for the \"samplers\" array\n    \"source\" is an index for the \"images\" array that contains data. These data are stored in rgba channels of the image.\n\n    texture.texCoord is a number-suffix (like 1) for an attribute like \"TEXCOORD_1\" in meshes.primitives\n    The value of \"TEXCOORD_1\" is an accessor that is used to get coordinates. These coordinates are being used to get data from the image.\n  */\n  const json = scenegraph.gltf.json;\n\n  const texCoordAccessorKey = `TEXCOORD_${textureInfo.texCoord || 0}`;\n  const texCoordAccessorIndex = primitive.attributes[texCoordAccessorKey];\n\n  const textureCoordinates: Float32Array | null = getFloat32ArrayForAccessor(\n    scenegraph.gltf,\n    texCoordAccessorIndex\n  );\n  if (!textureCoordinates) {\n    return null;\n  }\n\n  const textureIndex: number = textureInfo.index;\n  const imageIndex = json.textures?.[textureIndex]?.source;\n  if (typeof imageIndex !== 'undefined') {\n    const mimeType = json.images?.[imageIndex]?.mimeType;\n    const parsedImage = scenegraph.gltf.images?.[imageIndex];\n    // Checking for width is to prevent handling Un-processed images (e.g. [analyze] stage, where loadImages option is set to false)\n    if (parsedImage && typeof parsedImage.width !== 'undefined') {\n      const textureData: number[] = [];\n      for (let index = 0; index < textureCoordinates.length; index += 2) {\n        const value = getImageValueByCoordinates(\n          parsedImage,\n          mimeType,\n          textureCoordinates,\n          index,\n          textureInfo.channels\n        );\n        textureData.push(value);\n      }\n      return textureData;\n    }\n  }\n  return null;\n}\n\n/**\n * Puts property data to attributes.\n * It creates corresponding buffer, bufferView and accessor\n * so the data can be accessed like regular data stored in buffers.\n * @param scenegraph - Scenegraph object.\n * @param attributeName - Name of the attribute.\n * @param propertyData - Property data to store.\n * @param featureTable - Array where unique data from the property data are being stored.\n * @param primitive - Primitive object.\n */\nexport function primitivePropertyDataToAttributes(\n  scenegraph: GLTFScenegraph,\n  attributeName: string,\n  propertyData: number[],\n  featureTable: number[],\n  primitive: GLTFMeshPrimitive\n): void {\n  // No reason to create an empty buffer if there is no property data to store.\n  if (!propertyData?.length) {\n    return;\n  }\n  /*\n    featureTable will contain unique values, e.g.\n    propertyData = [24, 35, 28, 24]\n    featureTable = [24, 35, 28]\n    featureIndices will contain indices that refer featureTextureTable, e.g.\n    featureIndices = [0, 1, 2, 0]\n  */\n  const featureIndices: number[] = [];\n  for (const texelData of propertyData) {\n    let index = featureTable.findIndex((item) => item === texelData);\n    if (index === -1) {\n      index = featureTable.push(texelData) - 1;\n    }\n    featureIndices.push(index);\n  }\n  const typedArray = new Uint32Array(featureIndices);\n  const bufferIndex =\n    scenegraph.gltf.buffers.push({\n      arrayBuffer: typedArray.buffer,\n      byteOffset: typedArray.byteOffset,\n      byteLength: typedArray.byteLength\n    }) - 1;\n  const bufferViewIndex = scenegraph.addBufferView(typedArray, bufferIndex, 0);\n  const accessorIndex = scenegraph.addAccessor(bufferViewIndex, {\n    size: 1,\n    componentType: getComponentTypeFromArray(typedArray),\n    count: typedArray.length\n  });\n  primitive.attributes[attributeName] = accessorIndex;\n}\n\n/**\n * Gets the value from the texture by coordinates provided.\n * @param parsedImage - Image where the data are stored.\n * @param mimeType - MIME type.\n * @param textureCoordinates - uv coordinates to access data in the image.\n * @param index - Index of uv coordinates in the array textureCoordinates.\n * @param channels - Image channels where data are stored. Channels of an RGBA texture are numbered 0..3 respectively.\n * @returns Value taken from the image.\n */\nfunction getImageValueByCoordinates(\n  parsedImage: ImageType,\n  mimeType: string | undefined,\n  textureCoordinates: Float32Array,\n  index: number,\n  channels: number[] | string = [0]\n) {\n  const CHANNELS_MAP = {\n    r: {offset: 0, shift: 0},\n    g: {offset: 1, shift: 8},\n    b: {offset: 2, shift: 16},\n    a: {offset: 3, shift: 24}\n  };\n\n  const u = textureCoordinates[index];\n  const v = textureCoordinates[index + 1];\n\n  let components = 1;\n  if (mimeType && (mimeType.indexOf('image/jpeg') !== -1 || mimeType.indexOf('image/png') !== -1))\n    components = 4;\n  const offset = coordinatesToOffset(u, v, parsedImage, components);\n  let value: number = 0;\n  for (const c of channels) {\n    /*\n    According to the EXT_feature_metadata extension specification:\n      Channels are labeled by rgba and are swizzled with a string of 1-4 characters.\n    According to the EXT_mesh_features extension specification:\n      The channels array contains non-negative integer values corresponding to channels of the source texture that the feature ID consists of.\n      Channels of an RGBA texture are numbered 0–3 respectively.\n    Function getImageValueByCoordinates is used to process both extensions. \n    So, there should be possible to get the element of CHANNELS_MAP by either index (0, 1, 2, 3) or key (r, g, b, a).\n    */\n    const map = typeof c === 'number' ? Object.values(CHANNELS_MAP)[c] : CHANNELS_MAP[c];\n    const imageOffset = offset + map.offset;\n    const imageData = getImageData(parsedImage);\n    if (imageData.data.length <= imageOffset) {\n      throw new Error(`${imageData.data.length} <= ${imageOffset}`);\n    }\n    const imageValue = imageData.data[imageOffset];\n    value |= imageValue << map.shift;\n  }\n  return value;\n}\n\n/**\n * Retrieves the offset in the image where the data are stored.\n * @param u - u-coordinate.\n * @param v - v-coordinate.\n * @param parsedImage - Image where the data are stored.\n * @param componentsCount - Number of components the data consists of.\n * @returns Offset in the image where the data are stored.\n */\nfunction coordinatesToOffset(\n  u: number,\n  v: number,\n  parsedImage: any,\n  componentsCount: number = 1\n): number {\n  const w = parsedImage.width;\n  const iX = emod(u) * (w - 1);\n  const indX = Math.round(iX);\n\n  const h = parsedImage.height;\n  const iY = emod(v) * (h - 1);\n  const indY = Math.round(iY);\n  const components = parsedImage.components ? parsedImage.components : componentsCount;\n  // components is a number of channels in the image\n  const offset = (indY * w + indX) * components;\n  return offset;\n}\n\n/**\n * Parses variable-length array data.\n * In this case every value of the property in the table will be an array\n * of arbitrary length.\n * @param valuesData - Values in a flat typed array.\n * @param numberOfElements - Number of rows in the property table.\n * @param arrayOffsets - Offsets of nested arrays in the flat values array.\n * @param valuesDataBytesLength - Data byte length.\n * @param valueSize - Value size in bytes.\n * @returns Array of typed arrays.\n */\nexport function parseVariableLengthArrayNumeric(\n  valuesData: BigTypedArray,\n  numberOfElements: number,\n  arrayOffsets: TypedArray,\n  valuesDataBytesLength: number,\n  valueSize: number\n): BigTypedArray[] {\n  const attributeValueArray: BigTypedArray[] = [];\n  for (let index = 0; index < numberOfElements; index++) {\n    const arrayOffset = arrayOffsets[index];\n    const arrayByteSize = arrayOffsets[index + 1] - arrayOffsets[index];\n    if (arrayByteSize + arrayOffset > valuesDataBytesLength) {\n      break;\n    }\n    const typedArrayOffset = arrayOffset / valueSize;\n    const elementCount = arrayByteSize / valueSize;\n    attributeValueArray.push(valuesData.slice(typedArrayOffset, typedArrayOffset + elementCount));\n  }\n  return attributeValueArray;\n}\n\n/**\n * Parses fixed-length array data.\n * In this case every value of the property in the table will be an array\n * of constant length equal to `arrayCount`.\n * @param valuesData - Values in a flat typed array.\n * @param numberOfElements - Number of rows in the property table.\n * @param arrayCount - Nested arrays length.\n * @returns Array of typed arrays.\n */\nexport function parseFixedLengthArrayNumeric(\n  valuesData: BigTypedArray,\n  numberOfElements: number,\n  arrayCount: number\n): BigTypedArray[] {\n  const attributeValueArray: BigTypedArray[] = [];\n  for (let index = 0; index < numberOfElements; index++) {\n    const elementOffset = index * arrayCount;\n    attributeValueArray.push(valuesData.slice(elementOffset, elementOffset + arrayCount));\n  }\n  return attributeValueArray;\n}\n\n/**\n * Decodes properties of string type from binary source.\n * @param numberOfElements - The number of elements in each property array that propertyTableProperty contains. It's a number of rows in the table.\n * @param valuesDataBytes - Data taken from values property of the property table property.\n * @param arrayOffsets - Offsets for variable-length arrays. It's null for fixed-length arrays or scalar types.\n * @param stringOffsets - Index of the buffer view containing offsets for strings. It should be available for string type.\n * @returns String property values\n */\nexport function getPropertyDataString(\n  numberOfElements: number,\n  valuesDataBytes: Uint8Array,\n  arrayOffsets: TypedArray | null,\n  stringOffsets: TypedArray | null\n): string[] | string[][] {\n  if (arrayOffsets) {\n    // TODO: implement it as soon as we have the corresponding tileset\n    throw new Error('Not implemented - arrayOffsets for strings is specified');\n  }\n\n  if (stringOffsets) {\n    const stringsArray: string[] = [];\n    const textDecoder = new TextDecoder('utf8');\n\n    let stringOffset = 0;\n    for (let index = 0; index < numberOfElements; index++) {\n      const stringByteSize = stringOffsets[index + 1] - stringOffsets[index];\n\n      if (stringByteSize + stringOffset <= valuesDataBytes.length) {\n        const stringData = valuesDataBytes.subarray(stringOffset, stringByteSize + stringOffset);\n        const stringAttribute = textDecoder.decode(stringData);\n\n        stringsArray.push(stringAttribute);\n        stringOffset += stringByteSize;\n      }\n    }\n\n    return stringsArray;\n  }\n  return [];\n}\n"],"mappings":"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"}

package/dist/es5/lib/gltf-utils/get-typed-array.js

@@ -1,23 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getTypedArrayForBufferView = getTypedArrayForBufferView;
-exports.getTypedArrayForImageData = getTypedArrayForImageData;
-var _assert = require("../utils/assert");
-function getTypedArrayForBufferView(json, buffers, bufferViewIndex) {
-  var bufferView = json.bufferViews[bufferViewIndex];
-  (0, _assert.assert)(bufferView);
-  var bufferIndex = bufferView.buffer;
-  var binChunk = buffers[bufferIndex];
-  (0, _assert.assert)(binChunk);
-  var byteOffset = (bufferView.byteOffset || 0) + binChunk.byteOffset;
-  return new Uint8Array(binChunk.arrayBuffer, byteOffset, bufferView.byteLength);
-}
-function getTypedArrayForImageData(json, buffers, imageIndex) {
-  var image = json.images[imageIndex];
-  var bufferViewIndex = json.bufferViews[image.bufferView];
-  return getTypedArrayForBufferView(json, buffers, bufferViewIndex);
-}
-//# sourceMappingURL=get-typed-array.js.map

package/dist/es5/lib/gltf-utils/get-typed-array.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-typed-array.js","names":["_assert","require","getTypedArrayForBufferView","json","buffers","bufferViewIndex","bufferView","bufferViews","assert","bufferIndex","buffer","binChunk","byteOffset","Uint8Array","arrayBuffer","byteLength","getTypedArrayForImageData","imageIndex","image","images"],"sources":["../../../../src/lib/gltf-utils/get-typed-array.ts"],"sourcesContent":["// TODO - GLTFScenegraph should use these\nimport {assert} from '../utils/assert';\n\n// accepts buffer view index or buffer view object\n// returns a `Uint8Array`\nexport function getTypedArrayForBufferView(json, buffers, bufferViewIndex) {\n  const bufferView = json.bufferViews[bufferViewIndex];\n  assert(bufferView);\n\n  // Get hold of the arrayBuffer\n  const bufferIndex = bufferView.buffer;\n  const binChunk = buffers[bufferIndex];\n  assert(binChunk);\n\n  const byteOffset = (bufferView.byteOffset || 0) + binChunk.byteOffset;\n  return new Uint8Array(binChunk.arrayBuffer, byteOffset, bufferView.byteLength);\n}\n\n// accepts accessor index or accessor object\n// returns a `Uint8Array`\nexport function getTypedArrayForImageData(json, buffers, imageIndex) {\n  const image = json.images[imageIndex];\n  const bufferViewIndex = json.bufferViews[image.bufferView];\n  return getTypedArrayForBufferView(json, buffers, bufferViewIndex);\n}\n\n/*\n// accepts accessor index or accessor object\n// returns a typed array with type that matches the types\nexport function getTypedArrayForAccessor(accessor) {\n  accessor = this.getAccessor(accessor);\n  const bufferView = this.getBufferView(accessor.bufferView);\n  const buffer = this.getBuffer(bufferView.buffer);\n  const arrayBuffer = buffer.data;\n\n  // Create a new typed array as a view into the combined buffer\n  const {ArrayType, length} = getAccessorArrayTypeAndLength(accessor, bufferView);\n  const byteOffset = bufferView.byteOffset + accessor.byteOffset;\n  return new ArrayType(arrayBuffer, byteOffset, length);\n}\n*/\n"],"mappings":";;;;;;;AACA,IAAAA,OAAA,GAAAC,OAAA;AAIO,SAASC,0BAA0BA,CAACC,IAAI,EAAEC,OAAO,EAAEC,eAAe,EAAE;EACzE,IAAMC,UAAU,GAAGH,IAAI,CAACI,WAAW,CAACF,eAAe,CAAC;EACpD,IAAAG,cAAM,EAACF,UAAU,CAAC;EAGlB,IAAMG,WAAW,GAAGH,UAAU,CAACI,MAAM;EACrC,IAAMC,QAAQ,GAAGP,OAAO,CAACK,WAAW,CAAC;EACrC,IAAAD,cAAM,EAACG,QAAQ,CAAC;EAEhB,IAAMC,UAAU,GAAG,CAACN,UAAU,CAACM,UAAU,IAAI,CAAC,IAAID,QAAQ,CAACC,UAAU;EACrE,OAAO,IAAIC,UAAU,CAACF,QAAQ,CAACG,WAAW,EAAEF,UAAU,EAAEN,UAAU,CAACS,UAAU,CAAC;AAChF;AAIO,SAASC,yBAAyBA,CAACb,IAAI,EAAEC,OAAO,EAAEa,UAAU,EAAE;EACnE,IAAMC,KAAK,GAAGf,IAAI,CAACgB,MAAM,CAACF,UAAU,CAAC;EACrC,IAAMZ,eAAe,GAAGF,IAAI,CAACI,WAAW,CAACW,KAAK,CAACZ,UAAU,CAAC;EAC1D,OAAOJ,0BAA0B,CAACC,IAAI,EAAEC,OAAO,EAAEC,eAAe,CAAC;AACnE"}

package/dist/es5/lib/gltf-utils/gltf-attribute-utils.js

@@ -1,68 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getGLTFAccessor = getGLTFAccessor;
-exports.getGLTFAccessors = getGLTFAccessors;
-var _gltfUtils = require("./gltf-utils");
-function getGLTFAccessors(attributes) {
-  var accessors = {};
-  for (var name in attributes) {
-    var attribute = attributes[name];
-    if (name !== 'indices') {
-      var glTFAccessor = getGLTFAccessor(attribute);
-      accessors[name] = glTFAccessor;
-    }
-  }
-  return accessors;
-}
-function getGLTFAccessor(attribute) {
-  var _getAccessorData = getAccessorData(attribute),
-    buffer = _getAccessorData.buffer,
-    size = _getAccessorData.size,
-    count = _getAccessorData.count;
-  var glTFAccessor = {
-    value: buffer,
-    size: size,
-    byteOffset: 0,
-    count: count,
-    type: (0, _gltfUtils.getAccessorTypeFromSize)(size),
-    componentType: (0, _gltfUtils.getComponentTypeFromArray)(buffer)
-  };
-  return glTFAccessor;
-}
-function getAccessorData(attribute) {
-  var buffer = attribute;
-  var size = 1;
-  var count = 0;
-  if (attribute && attribute.value) {
-    buffer = attribute.value;
-    size = attribute.size || 1;
-  }
-  if (buffer) {
-    if (!ArrayBuffer.isView(buffer)) {
-      buffer = toTypedArray(buffer, Float32Array);
-    }
-    count = buffer.length / size;
-  }
-  return {
-    buffer: buffer,
-    size: size,
-    count: count
-  };
-}
-function toTypedArray(array, ArrayType) {
-  var convertTypedArrays = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-  if (!array) {
-    return null;
-  }
-  if (Array.isArray(array)) {
-    return new ArrayType(array);
-  }
-  if (convertTypedArrays && !(array instanceof ArrayType)) {
-    return new ArrayType(array);
-  }
-  return array;
-}
-//# sourceMappingURL=gltf-attribute-utils.js.map

package/dist/es5/lib/gltf-utils/gltf-attribute-utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"gltf-attribute-utils.js","names":["_gltfUtils","require","getGLTFAccessors","attributes","accessors","name","attribute","glTFAccessor","getGLTFAccessor","_getAccessorData","getAccessorData","buffer","size","count","value","byteOffset","type","getAccessorTypeFromSize","componentType","getComponentTypeFromArray","ArrayBuffer","isView","toTypedArray","Float32Array","length","array","ArrayType","convertTypedArrays","arguments","undefined","Array","isArray"],"sources":["../../../../src/lib/gltf-utils/gltf-attribute-utils.ts"],"sourcesContent":["// import type {TypedArray} from '../types/loader-utils';\nimport type {GLTFAccessor} from '../types/gltf-json-schema';\n// TODO - remove\nimport {getAccessorTypeFromSize, getComponentTypeFromArray} from './gltf-utils';\n\n// Returns a fresh attributes object with glTF-standardized attributes names\n// Attributes that cannot be identified will not be included\n// Removes `indices` if present, as it should be stored separately from the attributes\nexport function getGLTFAccessors(attributes): {[key: string]: GLTFAccessor} {\n  const accessors = {};\n  for (const name in attributes) {\n    const attribute = attributes[name];\n    if (name !== 'indices') {\n      const glTFAccessor = getGLTFAccessor(attribute);\n      accessors[name] = glTFAccessor;\n    }\n  }\n  return accessors;\n}\n\n// Fix up a single accessor.\n// Input: typed array or a partial accessor object\n// Return: accessor object\nexport function getGLTFAccessor(attribute) {\n  const {buffer, size, count} = getAccessorData(attribute);\n\n  const glTFAccessor: GLTFAccessor = {\n    // glTF Accessor values\n    // TODO: Instead of a bufferView index we could have an actual buffer (typed array)\n    // bufferView: null,\n    // TODO: Deprecate `value` in favor of bufferView?\n    // @ts-ignore\n    value: buffer,\n    size, // Decoded `type` (e.g. SCALAR)\n\n    byteOffset: 0,\n    count,\n    type: getAccessorTypeFromSize(size),\n    componentType: getComponentTypeFromArray(buffer)\n  };\n\n  return glTFAccessor;\n}\n\n// export function getGLTFAttribute(data, gltfAttributeName): GLTFAccessor {\n//   return data.attributes[data.glTFAttributeMap[gltfAttributeName]];\n// }\n\nfunction getAccessorData(attribute) {\n  let buffer = attribute;\n  let size = 1;\n  let count = 0;\n\n  if (attribute && attribute.value) {\n    buffer = attribute.value;\n    size = attribute.size || 1;\n  }\n\n  if (buffer) {\n    if (!ArrayBuffer.isView(buffer)) {\n      buffer = toTypedArray(buffer, Float32Array);\n    }\n    count = buffer.length / size;\n  }\n\n  return {buffer, size, count};\n}\n\n// Convert non-typed arrays to arrays of specified format\nfunction toTypedArray(array, ArrayType, convertTypedArrays = false) {\n  if (!array) {\n    return null;\n  }\n  if (Array.isArray(array)) {\n    return new ArrayType(array);\n  }\n  if (convertTypedArrays && !(array instanceof ArrayType)) {\n    return new ArrayType(array);\n  }\n  return array;\n}\n"],"mappings":";;;;;;;AAGA,IAAAA,UAAA,GAAAC,OAAA;AAKO,SAASC,gBAAgBA,CAACC,UAAU,EAAiC;EAC1E,IAAMC,SAAS,GAAG,CAAC,CAAC;EACpB,KAAK,IAAMC,IAAI,IAAIF,UAAU,EAAE;IAC7B,IAAMG,SAAS,GAAGH,UAAU,CAACE,IAAI,CAAC;IAClC,IAAIA,IAAI,KAAK,SAAS,EAAE;MACtB,IAAME,YAAY,GAAGC,eAAe,CAACF,SAAS,CAAC;MAC/CF,SAAS,CAACC,IAAI,CAAC,GAAGE,YAAY;IAChC;EACF;EACA,OAAOH,SAAS;AAClB;AAKO,SAASI,eAAeA,CAACF,SAAS,EAAE;EACzC,IAAAG,gBAAA,GAA8BC,eAAe,CAACJ,SAAS,CAAC;IAAjDK,MAAM,GAAAF,gBAAA,CAANE,MAAM;IAAEC,IAAI,GAAAH,gBAAA,CAAJG,IAAI;IAAEC,KAAK,GAAAJ,gBAAA,CAALI,KAAK;EAE1B,IAAMN,YAA0B,GAAG;IAMjCO,KAAK,EAAEH,MAAM;IACbC,IAAI,EAAJA,IAAI;IAEJG,UAAU,EAAE,CAAC;IACbF,KAAK,EAALA,KAAK;IACLG,IAAI,EAAE,IAAAC,kCAAuB,EAACL,IAAI,CAAC;IACnCM,aAAa,EAAE,IAAAC,oCAAyB,EAACR,MAAM;EACjD,CAAC;EAED,OAAOJ,YAAY;AACrB;AAMA,SAASG,eAAeA,CAACJ,SAAS,EAAE;EAClC,IAAIK,MAAM,GAAGL,SAAS;EACtB,IAAIM,IAAI,GAAG,CAAC;EACZ,IAAIC,KAAK,GAAG,CAAC;EAEb,IAAIP,SAAS,IAAIA,SAAS,CAACQ,KAAK,EAAE;IAChCH,MAAM,GAAGL,SAAS,CAACQ,KAAK;IACxBF,IAAI,GAAGN,SAAS,CAACM,IAAI,IAAI,CAAC;EAC5B;EAEA,IAAID,MAAM,EAAE;IACV,IAAI,CAACS,WAAW,CAACC,MAAM,CAACV,MAAM,CAAC,EAAE;MAC/BA,MAAM,GAAGW,YAAY,CAACX,MAAM,EAAEY,YAAY,CAAC;IAC7C;IACAV,KAAK,GAAGF,MAAM,CAACa,MAAM,GAAGZ,IAAI;EAC9B;EAEA,OAAO;IAACD,MAAM,EAANA,MAAM;IAAEC,IAAI,EAAJA,IAAI;IAAEC,KAAK,EAALA;EAAK,CAAC;AAC9B;AAGA,SAASS,YAAYA,CAACG,KAAK,EAAEC,SAAS,EAA8B;EAAA,IAA5BC,kBAAkB,GAAAC,SAAA,CAAAJ,MAAA,QAAAI,SAAA,QAAAC,SAAA,GAAAD,SAAA,MAAG,KAAK;EAChE,IAAI,CAACH,KAAK,EAAE;IACV,OAAO,IAAI;EACb;EACA,IAAIK,KAAK,CAACC,OAAO,CAACN,KAAK,CAAC,EAAE;IACxB,OAAO,IAAIC,SAAS,CAACD,KAAK,CAAC;EAC7B;EACA,IAAIE,kBAAkB,IAAI,EAAEF,KAAK,YAAYC,SAAS,CAAC,EAAE;IACvD,OAAO,IAAIA,SAAS,CAACD,KAAK,CAAC;EAC7B;EACA,OAAOA,KAAK;AACd"}

package/dist/es5/lib/gltf-utils/gltf-constants.js

@@ -1,48 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.COMPONENTS = exports.BYTES = void 0;
-exports.getBytesFromComponentType = getBytesFromComponentType;
-exports.getGLEnumFromSamplerParameter = getGLEnumFromSamplerParameter;
-exports.getSizeFromAccessorType = getSizeFromAccessorType;
-var COMPONENTS = {
-  SCALAR: 1,
-  VEC2: 2,
-  VEC3: 3,
-  VEC4: 4,
-  MAT2: 4,
-  MAT3: 9,
-  MAT4: 16
-};
-exports.COMPONENTS = COMPONENTS;
-var BYTES = {
-  5120: 1,
-  5121: 1,
-  5122: 2,
-  5123: 2,
-  5125: 4,
-  5126: 4
-};
-exports.BYTES = BYTES;
-function getBytesFromComponentType(componentType) {
-  return BYTES[componentType];
-}
-function getSizeFromAccessorType(type) {
-  return COMPONENTS[type];
-}
-function getGLEnumFromSamplerParameter(parameter) {
-  var GL_TEXTURE_MAG_FILTER = 0x2800;
-  var GL_TEXTURE_MIN_FILTER = 0x2801;
-  var GL_TEXTURE_WRAP_S = 0x2802;
-  var GL_TEXTURE_WRAP_T = 0x2803;
-  var PARAMETER_MAP = {
-    magFilter: GL_TEXTURE_MAG_FILTER,
-    minFilter: GL_TEXTURE_MIN_FILTER,
-    wrapS: GL_TEXTURE_WRAP_S,
-    wrapT: GL_TEXTURE_WRAP_T
-  };
-  return PARAMETER_MAP[parameter];
-}
-//# sourceMappingURL=gltf-constants.js.map

package/dist/es5/lib/gltf-utils/gltf-constants.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"gltf-constants.js","names":["COMPONENTS","SCALAR","VEC2","VEC3","VEC4","MAT2","MAT3","MAT4","exports","BYTES","getBytesFromComponentType","componentType","getSizeFromAccessorType","type","getGLEnumFromSamplerParameter","parameter","GL_TEXTURE_MAG_FILTER","GL_TEXTURE_MIN_FILTER","GL_TEXTURE_WRAP_S","GL_TEXTURE_WRAP_T","PARAMETER_MAP","magFilter","minFilter","wrapS","wrapT"],"sources":["../../../../src/lib/gltf-utils/gltf-constants.ts"],"sourcesContent":["export const COMPONENTS = {\n  SCALAR: 1,\n  VEC2: 2,\n  VEC3: 3,\n  VEC4: 4,\n  MAT2: 4,\n  MAT3: 9,\n  MAT4: 16\n};\n\nexport const BYTES = {\n  5120: 1, // BYTE\n  5121: 1, // UNSIGNED_BYTE\n  5122: 2, // SHORT\n  5123: 2, // UNSIGNED_SHORT\n  5125: 4, // UNSIGNED_INT\n  5126: 4 // FLOAT\n};\n\n// ENUM LOOKUP\n\nexport function getBytesFromComponentType(componentType) {\n  return BYTES[componentType];\n}\n\nexport function getSizeFromAccessorType(type) {\n  return COMPONENTS[type];\n}\n\nexport function getGLEnumFromSamplerParameter(parameter) {\n  const GL_TEXTURE_MAG_FILTER = 0x2800;\n  const GL_TEXTURE_MIN_FILTER = 0x2801;\n  const GL_TEXTURE_WRAP_S = 0x2802;\n  const GL_TEXTURE_WRAP_T = 0x2803;\n\n  const PARAMETER_MAP = {\n    magFilter: GL_TEXTURE_MAG_FILTER,\n    minFilter: GL_TEXTURE_MIN_FILTER,\n    wrapS: GL_TEXTURE_WRAP_S,\n    wrapT: GL_TEXTURE_WRAP_T\n  };\n\n  return PARAMETER_MAP[parameter];\n}\n"],"mappings":";;;;;;;;;AAAO,IAAMA,UAAU,GAAG;EACxBC,MAAM,EAAE,CAAC;EACTC,IAAI,EAAE,CAAC;EACPC,IAAI,EAAE,CAAC;EACPC,IAAI,EAAE,CAAC;EACPC,IAAI,EAAE,CAAC;EACPC,IAAI,EAAE,CAAC;EACPC,IAAI,EAAE;AACR,CAAC;AAACC,OAAA,CAAAR,UAAA,GAAAA,UAAA;AAEK,IAAMS,KAAK,GAAG;EACnB,IAAI,EAAE,CAAC;EACP,IAAI,EAAE,CAAC;EACP,IAAI,EAAE,CAAC;EACP,IAAI,EAAE,CAAC;EACP,IAAI,EAAE,CAAC;EACP,IAAI,EAAE;AACR,CAAC;AAACD,OAAA,CAAAC,KAAA,GAAAA,KAAA;AAIK,SAASC,yBAAyBA,CAACC,aAAa,EAAE;EACvD,OAAOF,KAAK,CAACE,aAAa,CAAC;AAC7B;AAEO,SAASC,uBAAuBA,CAACC,IAAI,EAAE;EAC5C,OAAOb,UAAU,CAACa,IAAI,CAAC;AACzB;AAEO,SAASC,6BAA6BA,CAACC,SAAS,EAAE;EACvD,IAAMC,qBAAqB,GAAG,MAAM;EACpC,IAAMC,qBAAqB,GAAG,MAAM;EACpC,IAAMC,iBAAiB,GAAG,MAAM;EAChC,IAAMC,iBAAiB,GAAG,MAAM;EAEhC,IAAMC,aAAa,GAAG;IACpBC,SAAS,EAAEL,qBAAqB;IAChCM,SAAS,EAAEL,qBAAqB;IAChCM,KAAK,EAAEL,iBAAiB;IACxBM,KAAK,EAAEL;EACT,CAAC;EAED,OAAOC,aAAa,CAACL,SAAS,CAAC;AACjC"}

package/dist/es5/lib/gltf-utils/gltf-utils.js

@@ -1,115 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getAccessorArrayTypeAndLength = getAccessorArrayTypeAndLength;
-exports.getAccessorTypeFromSize = getAccessorTypeFromSize;
-exports.getComponentTypeFromArray = getComponentTypeFromArray;
-exports.getFloat32ArrayForAccessor = getFloat32ArrayForAccessor;
-exports.getMemoryUsageGLTF = getMemoryUsageGLTF;
-var _assert = require("../utils/assert");
-var _gltfConstants = require("../gltf-utils/gltf-constants");
-var MIPMAP_FACTOR = 1.33;
-var TYPES = ['SCALAR', 'VEC2', 'VEC3', 'VEC4'];
-var ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT = [[Int8Array, 5120], [Uint8Array, 5121], [Int16Array, 5122], [Uint16Array, 5123], [Uint32Array, 5125], [Float32Array, 5126], [Float64Array, 5130]];
-var ARRAY_TO_COMPONENT_TYPE = new Map(ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT);
-var ATTRIBUTE_TYPE_TO_COMPONENTS = {
-  SCALAR: 1,
-  VEC2: 2,
-  VEC3: 3,
-  VEC4: 4,
-  MAT2: 4,
-  MAT3: 9,
-  MAT4: 16
-};
-var ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE = {
-  5120: 1,
-  5121: 1,
-  5122: 2,
-  5123: 2,
-  5125: 4,
-  5126: 4
-};
-var ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY = {
-  5120: Int8Array,
-  5121: Uint8Array,
-  5122: Int16Array,
-  5123: Uint16Array,
-  5125: Uint32Array,
-  5126: Float32Array
-};
-function getAccessorTypeFromSize(size) {
-  var type = TYPES[size - 1];
-  return type || TYPES[0];
-}
-function getComponentTypeFromArray(typedArray) {
-  var componentType = ARRAY_TO_COMPONENT_TYPE.get(typedArray.constructor);
-  if (!componentType) {
-    throw new Error('Illegal typed array');
-  }
-  return componentType;
-}
-function getAccessorArrayTypeAndLength(accessor, bufferView) {
-  var ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY[accessor.componentType];
-  var components = ATTRIBUTE_TYPE_TO_COMPONENTS[accessor.type];
-  var bytesPerComponent = ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[accessor.componentType];
-  var length = accessor.count * components;
-  var byteLength = accessor.count * components * bytesPerComponent;
-  (0, _assert.assert)(byteLength >= 0 && byteLength <= bufferView.byteLength);
-  return {
-    ArrayType: ArrayType,
-    length: length,
-    byteLength: byteLength
-  };
-}
-function getFloat32ArrayForAccessor(gltfData, texCoordAccessor) {
-  var _gltfData$json$access;
-  var accessor = (_gltfData$json$access = gltfData.json.accessors) === null || _gltfData$json$access === void 0 ? void 0 : _gltfData$json$access[texCoordAccessor];
-  if (accessor && typeof accessor.bufferView !== 'undefined') {
-    var _gltfData$json$buffer;
-    var bufferView = (_gltfData$json$buffer = gltfData.json.bufferViews) === null || _gltfData$json$buffer === void 0 ? void 0 : _gltfData$json$buffer[accessor.bufferView];
-    if (bufferView) {
-      var _gltfData$buffers$buf = gltfData.buffers[bufferView.buffer],
-        arrayBuffer = _gltfData$buffers$buf.arrayBuffer,
-        bufferByteOffset = _gltfData$buffers$buf.byteOffset;
-      var byteOffset = (bufferByteOffset || 0) + (accessor.byteOffset || 0) + (bufferView.byteOffset || 0);
-      var _getAccessorArrayType = getAccessorArrayTypeAndLength(accessor, bufferView),
-        ArrayType = _getAccessorArrayType.ArrayType,
-        length = _getAccessorArrayType.length;
-      var bytes = _gltfConstants.BYTES[accessor.componentType];
-      var components = _gltfConstants.COMPONENTS[accessor.type];
-      var elementAddressScale = bufferView.byteStride || bytes * components;
-      var result = new Float32Array(length);
-      for (var i = 0; i < accessor.count; i++) {
-        var uv = new ArrayType(arrayBuffer, byteOffset + i * elementAddressScale, 2);
-        result.set(uv, i * components);
-      }
-      return result;
-    }
-  }
-  return null;
-}
-function getMemoryUsageGLTF(gltf) {
-  var images = gltf.images,
-    bufferViews = gltf.bufferViews;
-  images = images || [];
-  bufferViews = bufferViews || [];
-  var imageBufferViews = images.map(function (i) {
-    return i.bufferView;
-  });
-  bufferViews = bufferViews.filter(function (view) {
-    return !imageBufferViews.includes(view);
-  });
-  var bufferMemory = bufferViews.reduce(function (acc, view) {
-    return acc + view.byteLength;
-  }, 0);
-  var pixelCount = images.reduce(function (acc, image) {
-    var _image = image.image,
-      width = _image.width,
-      height = _image.height;
-    return acc + width * height;
-  }, 0);
-  return bufferMemory + Math.ceil(4 * pixelCount * MIPMAP_FACTOR);
-}
-//# sourceMappingURL=gltf-utils.js.map

package/dist/es5/lib/gltf-utils/gltf-utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"gltf-utils.js","names":["_assert","require","_gltfConstants","MIPMAP_FACTOR","TYPES","ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT","Int8Array","Uint8Array","Int16Array","Uint16Array","Uint32Array","Float32Array","Float64Array","ARRAY_TO_COMPONENT_TYPE","Map","ATTRIBUTE_TYPE_TO_COMPONENTS","SCALAR","VEC2","VEC3","VEC4","MAT2","MAT3","MAT4","ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE","ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY","getAccessorTypeFromSize","size","type","getComponentTypeFromArray","typedArray","componentType","get","constructor","Error","getAccessorArrayTypeAndLength","accessor","bufferView","ArrayType","components","bytesPerComponent","length","count","byteLength","assert","getFloat32ArrayForAccessor","gltfData","texCoordAccessor","_gltfData$json$access","json","accessors","_gltfData$json$buffer","bufferViews","_gltfData$buffers$buf","buffers","buffer","arrayBuffer","bufferByteOffset","byteOffset","_getAccessorArrayType","bytes","BYTES","COMPONENTS","elementAddressScale","byteStride","result","i","uv","set","getMemoryUsageGLTF","gltf","images","imageBufferViews","map","filter","view","includes","bufferMemory","reduce","acc","pixelCount","image","_image","width","height","Math","ceil"],"sources":["../../../../src/lib/gltf-utils/gltf-utils.ts"],"sourcesContent":["import {assert} from '../utils/assert';\n\nimport type {GLTFWithBuffers} from '../types/gltf-types';\nimport type {GLTFPostprocessed} from '../types/gltf-postprocessed-schema';\nimport {BYTES, COMPONENTS} from '../gltf-utils/gltf-constants';\n\n/**\n * Memory needed to store texture and all mipmap levels 1 + 1/4 + 1/16 + 1/64 + ...\n * Minimum 1.33, but due to GPU layout may be 1.5\n */\nconst MIPMAP_FACTOR = 1.33;\n\nconst TYPES = ['SCALAR', 'VEC2', 'VEC3', 'VEC4'];\n\ntype TypedArrayConstructor =\n  | Int8ArrayConstructor\n  | Uint8ArrayConstructor\n  | Int16ArrayConstructor\n  | Uint16ArrayConstructor\n  | Int32ArrayConstructor\n  | Uint32ArrayConstructor\n  | Int32ArrayConstructor\n  | Uint32ArrayConstructor\n  | Float32ArrayConstructor\n  | Float64ArrayConstructor;\n\nconst ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT: [TypedArrayConstructor, number][] = [\n  [Int8Array, 5120],\n  [Uint8Array, 5121],\n  [Int16Array, 5122],\n  [Uint16Array, 5123],\n  [Uint32Array, 5125],\n  [Float32Array, 5126],\n  [Float64Array, 5130]\n];\nconst ARRAY_TO_COMPONENT_TYPE = new Map<TypedArrayConstructor, number>(\n  ARRAY_CONSTRUCTOR_TO_WEBGL_CONSTANT\n);\n\nconst ATTRIBUTE_TYPE_TO_COMPONENTS = {\n  SCALAR: 1,\n  VEC2: 2,\n  VEC3: 3,\n  VEC4: 4,\n  MAT2: 4,\n  MAT3: 9,\n  MAT4: 16\n};\n\nconst ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE = {\n  5120: 1,\n  5121: 1,\n  5122: 2,\n  5123: 2,\n  5125: 4,\n  5126: 4\n};\n\nconst ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY = {\n  5120: Int8Array,\n  5121: Uint8Array,\n  5122: Int16Array,\n  5123: Uint16Array,\n  5125: Uint32Array,\n  5126: Float32Array\n};\n\nexport function getAccessorTypeFromSize(size) {\n  const type = TYPES[size - 1];\n  return type || TYPES[0];\n}\n\nexport function getComponentTypeFromArray(typedArray) {\n  const componentType = ARRAY_TO_COMPONENT_TYPE.get(typedArray.constructor);\n  if (!componentType) {\n    throw new Error('Illegal typed array');\n  }\n  return componentType;\n}\n\nexport function getAccessorArrayTypeAndLength(accessor, bufferView) {\n  const ArrayType = ATTRIBUTE_COMPONENT_TYPE_TO_ARRAY[accessor.componentType];\n  const components = ATTRIBUTE_TYPE_TO_COMPONENTS[accessor.type];\n  const bytesPerComponent = ATTRIBUTE_COMPONENT_TYPE_TO_BYTE_SIZE[accessor.componentType];\n  const length = accessor.count * components;\n  const byteLength = accessor.count * components * bytesPerComponent;\n  assert(byteLength >= 0 && byteLength <= bufferView.byteLength);\n  return {ArrayType, length, byteLength};\n}\n\nexport function getFloat32ArrayForAccessor(\n  gltfData: GLTFWithBuffers,\n  texCoordAccessor: number\n): Float32Array | null {\n  const accessor = gltfData.json.accessors?.[texCoordAccessor];\n  if (accessor && typeof accessor.bufferView !== 'undefined') {\n    // Get `bufferView` of the `accessor`\n    const bufferView = gltfData.json.bufferViews?.[accessor.bufferView];\n    if (bufferView) {\n      // Get `arrayBuffer` the `bufferView` look at\n      const {arrayBuffer, byteOffset: bufferByteOffset} = gltfData.buffers[bufferView.buffer];\n      // Resulting byteOffset is sum of the buffer, accessor and bufferView byte offsets\n      const byteOffset =\n        (bufferByteOffset || 0) + (accessor.byteOffset || 0) + (bufferView.byteOffset || 0);\n      // Deduce TypedArray type and its length from `accessor` and `bufferView` data\n      const {ArrayType, length} = getAccessorArrayTypeAndLength(accessor, bufferView);\n      // Number of bytes each component occupies\n      const bytes = BYTES[accessor.componentType];\n      // Number of components. For the `TEXCOORD_0` with `VEC2` type, it must return 2\n      const components = COMPONENTS[accessor.type];\n      // Multiplier to calculate the address of the `TEXCOORD_0` element in the arrayBuffer\n      const elementAddressScale = bufferView.byteStride || bytes * components;\n      // Data transform to Float32Array\n      const result = new Float32Array(length);\n      for (let i = 0; i < accessor.count; i++) {\n        // Take [u, v] couple from the arrayBuffer\n        const uv = new ArrayType(arrayBuffer, byteOffset + i * elementAddressScale, 2);\n        result.set(uv, i * components);\n      }\n      return result;\n    }\n  }\n  return null;\n}\n\n/**\n * Calculate the GPU memory used by a GLTF tile, for both buffer and texture memory\n * @param gltf - the gltf content of a GLTF tile\n * @returns - total memory usage in bytes\n */\nexport function getMemoryUsageGLTF(gltf: GLTFPostprocessed): number {\n  let {images, bufferViews} = gltf;\n  images = images || [];\n  bufferViews = bufferViews || [];\n  const imageBufferViews = images.map((i) => i.bufferView);\n  bufferViews = bufferViews.filter((view) => !imageBufferViews.includes(view as any));\n\n  const bufferMemory = bufferViews.reduce((acc, view) => acc + view.byteLength, 0);\n\n  // Assume each pixel of the texture is 4 channel with mimmaps (which add 33%)\n  // TODO correctly handle compressed textures\n  const pixelCount = images.reduce((acc, image) => {\n    // @ts-ignore\n    const {width, height} = (image as any).image;\n    return acc + width * height;\n  }, 0);\n  return bufferMemory + Math.ceil(4 * pixelCount * MIPMAP_FACTOR);\n}\n"],"mappings":"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"}

package/dist/es5/lib/gltf-utils/resolve-url.js

@@ -1,18 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.resolveUrl = resolveUrl;
-function resolveUrl(url, options) {
-  var absolute = url.startsWith('data:') || url.startsWith('http:') || url.startsWith('https:');
-  if (absolute) {
-    return url;
-  }
-  var baseUrl = options.baseUri || options.uri;
-  if (!baseUrl) {
-    throw new Error("'baseUri' must be provided to resolve relative url ".concat(url));
-  }
-  return baseUrl.substr(0, baseUrl.lastIndexOf('/') + 1) + url;
-}
-//# sourceMappingURL=resolve-url.js.map

package/dist/es5/lib/gltf-utils/resolve-url.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolve-url.js","names":["resolveUrl","url","options","absolute","startsWith","baseUrl","baseUri","uri","Error","concat","substr","lastIndexOf"],"sources":["../../../../src/lib/gltf-utils/resolve-url.ts"],"sourcesContent":["// Resolves a relative url against a baseUrl\n// If url is absolute, return it unchanged\nexport function resolveUrl(url, options) {\n  // TODO: Use better logic to handle all protocols plus not delay on data\n  const absolute = url.startsWith('data:') || url.startsWith('http:') || url.startsWith('https:');\n  if (absolute) {\n    return url;\n  }\n  const baseUrl = options.baseUri || options.uri;\n  if (!baseUrl) {\n    throw new Error(`'baseUri' must be provided to resolve relative url ${url}`);\n  }\n  return baseUrl.substr(0, baseUrl.lastIndexOf('/') + 1) + url;\n}\n"],"mappings":";;;;;;AAEO,SAASA,UAAUA,CAACC,GAAG,EAAEC,OAAO,EAAE;EAEvC,IAAMC,QAAQ,GAAGF,GAAG,CAACG,UAAU,CAAC,OAAO,CAAC,IAAIH,GAAG,CAACG,UAAU,CAAC,OAAO,CAAC,IAAIH,GAAG,CAACG,UAAU,CAAC,QAAQ,CAAC;EAC/F,IAAID,QAAQ,EAAE;IACZ,OAAOF,GAAG;EACZ;EACA,IAAMI,OAAO,GAAGH,OAAO,CAACI,OAAO,IAAIJ,OAAO,CAACK,GAAG;EAC9C,IAAI,CAACF,OAAO,EAAE;IACZ,MAAM,IAAIG,KAAK,uDAAAC,MAAA,CAAuDR,GAAG,CAAE,CAAC;EAC9E;EACA,OAAOI,OAAO,CAACK,MAAM,CAAC,CAAC,EAAEL,OAAO,CAACM,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAGV,GAAG;AAC9D"}

package/dist/es5/lib/parsers/parse-glb.js

@@ -1,120 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.isGLB = isGLB;
-exports.parseGLBSync = parseGLBSync;
-var _loaderUtils = require("@loaders.gl/loader-utils");
-var LITTLE_ENDIAN = true;
-var MAGIC_glTF = 0x676c5446;
-var GLB_FILE_HEADER_SIZE = 12;
-var GLB_CHUNK_HEADER_SIZE = 8;
-var GLB_CHUNK_TYPE_JSON = 0x4e4f534a;
-var GLB_CHUNK_TYPE_BIN = 0x004e4942;
-var GLB_V1_CONTENT_FORMAT_JSON = 0x0;
-var GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED = 0;
-var GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED = 1;
-function getMagicString(dataView) {
-  var byteOffset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-  return "".concat(String.fromCharCode(dataView.getUint8(byteOffset + 0))).concat(String.fromCharCode(dataView.getUint8(byteOffset + 1))).concat(String.fromCharCode(dataView.getUint8(byteOffset + 2))).concat(String.fromCharCode(dataView.getUint8(byteOffset + 3)));
-}
-function isGLB(arrayBuffer) {
-  var byteOffset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  var dataView = new DataView(arrayBuffer);
-  var _options$magic = options.magic,
-    magic = _options$magic === void 0 ? MAGIC_glTF : _options$magic;
-  var magic1 = dataView.getUint32(byteOffset, false);
-  return magic1 === magic || magic1 === MAGIC_glTF;
-}
-function parseGLBSync(glb, arrayBuffer) {
-  var byteOffset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-  var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
-  var dataView = new DataView(arrayBuffer);
-  var type = getMagicString(dataView, byteOffset + 0);
-  var version = dataView.getUint32(byteOffset + 4, LITTLE_ENDIAN);
-  var byteLength = dataView.getUint32(byteOffset + 8, LITTLE_ENDIAN);
-  Object.assign(glb, {
-    header: {
-      byteOffset: byteOffset,
-      byteLength: byteLength,
-      hasBinChunk: false
-    },
-    type: type,
-    version: version,
-    json: {},
-    binChunks: []
-  });
-  byteOffset += GLB_FILE_HEADER_SIZE;
-  switch (glb.version) {
-    case 1:
-      return parseGLBV1(glb, dataView, byteOffset);
-    case 2:
-      return parseGLBV2(glb, dataView, byteOffset, options = {});
-    default:
-      throw new Error("Invalid GLB version ".concat(glb.version, ". Only supports version 1 and 2."));
-  }
-}
-function parseGLBV1(glb, dataView, byteOffset) {
-  (0, _loaderUtils.assert)(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);
-  var contentLength = dataView.getUint32(byteOffset + 0, LITTLE_ENDIAN);
-  var contentFormat = dataView.getUint32(byteOffset + 4, LITTLE_ENDIAN);
-  byteOffset += GLB_CHUNK_HEADER_SIZE;
-  (0, _loaderUtils.assert)(contentFormat === GLB_V1_CONTENT_FORMAT_JSON);
-  parseJSONChunk(glb, dataView, byteOffset, contentLength);
-  byteOffset += contentLength;
-  byteOffset += parseBINChunk(glb, dataView, byteOffset, glb.header.byteLength);
-  return byteOffset;
-}
-function parseGLBV2(glb, dataView, byteOffset, options) {
-  (0, _loaderUtils.assert)(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);
-  parseGLBChunksSync(glb, dataView, byteOffset, options);
-  return byteOffset + glb.header.byteLength;
-}
-function parseGLBChunksSync(glb, dataView, byteOffset, options) {
-  while (byteOffset + 8 <= glb.header.byteLength) {
-    var chunkLength = dataView.getUint32(byteOffset + 0, LITTLE_ENDIAN);
-    var chunkFormat = dataView.getUint32(byteOffset + 4, LITTLE_ENDIAN);
-    byteOffset += GLB_CHUNK_HEADER_SIZE;
-    switch (chunkFormat) {
-      case GLB_CHUNK_TYPE_JSON:
-        parseJSONChunk(glb, dataView, byteOffset, chunkLength);
-        break;
-      case GLB_CHUNK_TYPE_BIN:
-        parseBINChunk(glb, dataView, byteOffset, chunkLength);
-        break;
-      case GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED:
-        if (!options.strict) {
-          parseJSONChunk(glb, dataView, byteOffset, chunkLength);
-        }
-        break;
-      case GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED:
-        if (!options.strict) {
-          parseBINChunk(glb, dataView, byteOffset, chunkLength);
-        }
-        break;
-      default:
-        break;
-    }
-    byteOffset += (0, _loaderUtils.padToNBytes)(chunkLength, 4);
-  }
-  return byteOffset;
-}
-function parseJSONChunk(glb, dataView, byteOffset, chunkLength) {
-  var jsonChunk = new Uint8Array(dataView.buffer, byteOffset, chunkLength);
-  var textDecoder = new TextDecoder('utf8');
-  var jsonText = textDecoder.decode(jsonChunk);
-  glb.json = JSON.parse(jsonText);
-  return (0, _loaderUtils.padToNBytes)(chunkLength, 4);
-}
-function parseBINChunk(glb, dataView, byteOffset, chunkLength) {
-  glb.header.hasBinChunk = true;
-  glb.binChunks.push({
-    byteOffset: byteOffset,
-    byteLength: chunkLength,
-    arrayBuffer: dataView.buffer
-  });
-  return (0, _loaderUtils.padToNBytes)(chunkLength, 4);
-}
-//# sourceMappingURL=parse-glb.js.map

package/dist/es5/lib/parsers/parse-glb.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"parse-glb.js","names":["_loaderUtils","require","LITTLE_ENDIAN","MAGIC_glTF","GLB_FILE_HEADER_SIZE","GLB_CHUNK_HEADER_SIZE","GLB_CHUNK_TYPE_JSON","GLB_CHUNK_TYPE_BIN","GLB_V1_CONTENT_FORMAT_JSON","GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED","GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED","getMagicString","dataView","byteOffset","arguments","length","undefined","concat","String","fromCharCode","getUint8","isGLB","arrayBuffer","options","DataView","_options$magic","magic","magic1","getUint32","parseGLBSync","glb","type","version","byteLength","Object","assign","header","hasBinChunk","json","binChunks","parseGLBV1","parseGLBV2","Error","assert","contentLength","contentFormat","parseJSONChunk","parseBINChunk","parseGLBChunksSync","chunkLength","chunkFormat","strict","padToNBytes","jsonChunk","Uint8Array","buffer","textDecoder","TextDecoder","jsonText","decode","JSON","parse","push"],"sources":["../../../../src/lib/parsers/parse-glb.ts"],"sourcesContent":["/* eslint-disable camelcase, max-statements */\n// https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#glb-file-format-specification\n// https://github.com/KhronosGroup/glTF/tree/master/extensions/1.0/Khronos/KHR_binary_glTF\nimport type {GLB} from '../types/glb-types';\nimport {padToNBytes, assert} from '@loaders.gl/loader-utils';\n\n/** Options for parsing a GLB */\nexport type ParseGLBOptions = {\n  /** @deprecated This option was used by XVIZ protocol to define a non-standard magic number */\n  magic?: number;\n  /** @deprecated This option was used by XVIZ protocol to embed non-standard chunks */\n  strict?: boolean;\n};\n\n/** Binary GLTF is little endian. */\nconst LITTLE_ENDIAN = true;\n\n/** 'glTF' in Big-Endian ASCII */\nconst MAGIC_glTF = 0x676c5446;\nconst GLB_FILE_HEADER_SIZE = 12;\nconst GLB_CHUNK_HEADER_SIZE = 8;\nconst GLB_CHUNK_TYPE_JSON = 0x4e4f534a;\nconst GLB_CHUNK_TYPE_BIN = 0x004e4942;\nconst GLB_V1_CONTENT_FORMAT_JSON = 0x0;\n\n/** @deprecated - Backward compatibility for old xviz files */\nconst GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED = 0;\n/** @deprecated - Backward compatibility for old xviz files */\nconst GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED = 1;\n\nfunction getMagicString(dataView, byteOffset = 0) {\n  return `\\\n${String.fromCharCode(dataView.getUint8(byteOffset + 0))}\\\n${String.fromCharCode(dataView.getUint8(byteOffset + 1))}\\\n${String.fromCharCode(dataView.getUint8(byteOffset + 2))}\\\n${String.fromCharCode(dataView.getUint8(byteOffset + 3))}`;\n}\n\n/** Check if the contents of an array buffer contains GLB byte markers */\nexport function isGLB(\n  arrayBuffer: ArrayBuffer,\n  byteOffset: number = 0,\n  options: ParseGLBOptions = {}\n): boolean {\n  const dataView = new DataView(arrayBuffer);\n  // Check that GLB Header starts with the magic number\n  const {magic = MAGIC_glTF} = options;\n  const magic1 = dataView.getUint32(byteOffset, false);\n  return magic1 === magic || magic1 === MAGIC_glTF;\n}\n\n/**\n * Synchronously parse a GLB\n * @param glb - Target, Output is stored there\n * @param arrayBuffer - Input data\n * @param byteOffset - Offset into arrayBuffer to start parsing from (for \"embedded\" GLBs, e.g. in 3D tiles)\n * @param options\n * @returns\n */\nexport function parseGLBSync(\n  glb: GLB,\n  arrayBuffer: ArrayBuffer,\n  byteOffset: number = 0,\n  options: ParseGLBOptions = {}\n) {\n  // Check that GLB Header starts with the magic number\n  const dataView = new DataView(arrayBuffer);\n\n  // Compare format with GLBLoader documentation\n  const type = getMagicString(dataView, byteOffset + 0);\n  const version = dataView.getUint32(byteOffset + 4, LITTLE_ENDIAN); // Version 2 of binary glTF container format\n  const byteLength = dataView.getUint32(byteOffset + 8, LITTLE_ENDIAN); // Total byte length of binary file\n\n  Object.assign(glb, {\n    // Put less important stuff in a header, to avoid clutter\n    header: {\n      byteOffset, // Byte offset into the initial arrayBuffer\n      byteLength,\n      hasBinChunk: false\n    },\n\n    type,\n    version,\n\n    json: {},\n    binChunks: []\n  } as GLB);\n\n  byteOffset += GLB_FILE_HEADER_SIZE;\n\n  switch (glb.version) {\n    case 1:\n      return parseGLBV1(glb, dataView, byteOffset);\n    case 2:\n      return parseGLBV2(glb, dataView, byteOffset, (options = {}));\n    default:\n      throw new Error(`Invalid GLB version ${glb.version}. Only supports version 1 and 2.`);\n  }\n}\n\n/**\n * Parse a V1 GLB\n * @param glb - target, output is stored in this object\n * @param dataView - Input, memory to be parsed\n * @param byteOffset - Offset of first byte of GLB data in the data view\n * @returns Number of bytes parsed (there could be additional non-GLB data after the GLB)\n */\nfunction parseGLBV1(glb: GLB, dataView: DataView, byteOffset: number): number {\n  // Sanity: ensure file is big enough to hold at least the headers\n  assert(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);\n\n  // Explanation of GLB structure:\n  // https://cloud.githubusercontent.com/assets/3479527/22600725/36b87122-ea55-11e6-9d40-6fd42819fcab.png\n  const contentLength = dataView.getUint32(byteOffset + 0, LITTLE_ENDIAN); // Byte length of chunk\n  const contentFormat = dataView.getUint32(byteOffset + 4, LITTLE_ENDIAN); // Chunk format as uint32\n  byteOffset += GLB_CHUNK_HEADER_SIZE;\n\n  // GLB v1 only supports a single chunk type\n  assert(contentFormat === GLB_V1_CONTENT_FORMAT_JSON);\n\n  parseJSONChunk(glb, dataView, byteOffset, contentLength);\n  // No need to call the function padToBytes() from parseJSONChunk()\n  byteOffset += contentLength;\n  byteOffset += parseBINChunk(glb, dataView, byteOffset, glb.header.byteLength);\n\n  return byteOffset;\n}\n\n/**\n * Parse a V2 GLB\n * @param glb - target, output is stored in this object\n * @param dataView - Input, memory to be parsed\n * @param byteOffset - Offset of first byte of GLB data in the data view\n * @returns Number of bytes parsed (there could be additional non-GLB data after the GLB)\n */\nfunction parseGLBV2(\n  glb: GLB,\n  dataView: DataView,\n  byteOffset: number,\n  options: ParseGLBOptions\n): number {\n  // Sanity: ensure file is big enough to hold at least the first chunk header\n  assert(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);\n\n  parseGLBChunksSync(glb, dataView, byteOffset, options);\n\n  return byteOffset + glb.header.byteLength;\n}\n\n/** Iterate over GLB chunks and parse them */\nfunction parseGLBChunksSync(\n  glb: GLB,\n  dataView: DataView,\n  byteOffset: number,\n  options: ParseGLBOptions\n) {\n  // Per spec we must iterate over chunks, ignoring all except JSON and BIN\n  // Iterate as long as there is space left for another chunk header\n  while (byteOffset + 8 <= glb.header.byteLength) {\n    const chunkLength = dataView.getUint32(byteOffset + 0, LITTLE_ENDIAN); // Byte length of chunk\n    const chunkFormat = dataView.getUint32(byteOffset + 4, LITTLE_ENDIAN); // Chunk format as uint32\n    byteOffset += GLB_CHUNK_HEADER_SIZE;\n\n    // Per spec we must iterate over chunks, ignoring all except JSON and BIN\n    switch (chunkFormat) {\n      case GLB_CHUNK_TYPE_JSON:\n        parseJSONChunk(glb, dataView, byteOffset, chunkLength);\n        break;\n      case GLB_CHUNK_TYPE_BIN:\n        parseBINChunk(glb, dataView, byteOffset, chunkLength);\n        break;\n\n      // Backward compatibility for very old xviz files\n      case GLB_CHUNK_TYPE_JSON_XVIZ_DEPRECATED:\n        if (!options.strict) {\n          parseJSONChunk(glb, dataView, byteOffset, chunkLength);\n        }\n        break;\n      case GLB_CHUNK_TYPE_BIX_XVIZ_DEPRECATED:\n        if (!options.strict) {\n          parseBINChunk(glb, dataView, byteOffset, chunkLength);\n        }\n        break;\n\n      default:\n        // Ignore, per spec\n        // console.warn(`Unknown GLB chunk type`); // eslint-disable-line\n        break;\n    }\n\n    byteOffset += padToNBytes(chunkLength, 4);\n  }\n\n  return byteOffset;\n}\n\n/* Parse a GLB JSON chunk */\nfunction parseJSONChunk(glb: GLB, dataView: DataView, byteOffset: number, chunkLength: number) {\n  // 1. Create a \"view\" of the binary encoded JSON data inside the GLB\n  const jsonChunk = new Uint8Array(dataView.buffer, byteOffset, chunkLength);\n\n  // 2. Decode the JSON binary array into clear text\n  const textDecoder = new TextDecoder('utf8');\n  const jsonText = textDecoder.decode(jsonChunk);\n\n  // 3. Parse the JSON text into a JavaScript data structure\n  glb.json = JSON.parse(jsonText);\n\n  return padToNBytes(chunkLength, 4);\n}\n\n/** Parse a GLB BIN chunk */\nfunction parseBINChunk(glb: GLB, dataView, byteOffset, chunkLength) {\n  // Note: BIN chunk can be optional\n  glb.header.hasBinChunk = true;\n  glb.binChunks.push({\n    byteOffset,\n    byteLength: chunkLength,\n    arrayBuffer: dataView.buffer\n    // TODO - copy, or create typed array view?\n  });\n\n  return padToNBytes(chunkLength, 4);\n}\n"],"mappings":"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"}