@xeokit/xeokit-sdk 2.6.87-renderers-refactor-v4 → 2.6.88-renderers-refactor-v5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,7 +1,7 @@
1
1
  /**
2
- * xeokit-sdk v2.6.87-renderers-refactor-v4
3
- * Commit: 5caed07165a5e87253766624958029a6267642df
4
- * Built: 2025-08-04T16:35:27.323Z
2
+ * xeokit-sdk v2.6.88-renderers-refactor-v5
3
+ * Commit: af6f3533e008fdfb8e2572162267dea616cfc1ab
4
+ * Built: 2025-08-12T16:41:09.569Z
5
5
  */
6
6
 
7
7
  /** @private */
@@ -81894,13 +81894,13 @@ function getTableHeader(table) {
81894
81894
  // __VERSION__ is injected by babel-plugin-version-inline
81895
81895
  // @ts-ignore TS2304: Cannot find name '__VERSION__'.
81896
81896
  const VERSION$6 = "4.3.2" ;
81897
- const version$1 = VERSION$6[0] >= '0' && VERSION$6[0] <= '9' ? `v${VERSION$6}` : '';
81897
+ const version = VERSION$6[0] >= '0' && VERSION$6[0] <= '9' ? `v${VERSION$6}` : '';
81898
81898
  // Make sure we set the global variable
81899
81899
  function createLog() {
81900
81900
  const log = new Log({ id: 'loaders.gl' });
81901
81901
  globalThis.loaders = globalThis.loaders || {};
81902
81902
  globalThis.loaders.log = log;
81903
- globalThis.loaders.version = version$1;
81903
+ globalThis.loaders.version = version;
81904
81904
  globalThis.probe = globalThis.probe || {};
81905
81905
  globalThis.probe.loaders = log;
81906
81906
  return log;
@@ -86207,7 +86207,7 @@ function getPropertyDataString(numberOfElements, valuesDataBytes, arrayOffsets,
86207
86207
  }
86208
86208
 
86209
86209
  const EXT_MESH_FEATURES_NAME = 'EXT_mesh_features';
86210
- const name$b = EXT_MESH_FEATURES_NAME;
86210
+ const name$a = EXT_MESH_FEATURES_NAME;
86211
86211
  async function decode$9(gltfData, options) {
86212
86212
  const scenegraph = new GLTFScenegraph(gltfData);
86213
86213
  decodeExtMeshFeatures(scenegraph, options);
@@ -86382,14 +86382,14 @@ function createAccessorKey(attributes) {
86382
86382
 
86383
86383
  var EXT_mesh_features = /*#__PURE__*/Object.freeze({
86384
86384
  __proto__: null,
86385
- name: name$b,
86385
+ name: name$a,
86386
86386
  decode: decode$9,
86387
86387
  encode: encode$5,
86388
86388
  createExtMeshFeatures: createExtMeshFeatures
86389
86389
  });
86390
86390
 
86391
86391
  const EXT_STRUCTURAL_METADATA_NAME = 'EXT_structural_metadata';
86392
- const name$a = EXT_STRUCTURAL_METADATA_NAME;
86392
+ const name$9 = EXT_STRUCTURAL_METADATA_NAME;
86393
86393
  async function decode$8(gltfData, options) {
86394
86394
  const scenegraph = new GLTFScenegraph(gltfData);
86395
86395
  decodeExtStructuralMetadata(scenegraph, options);
@@ -87043,7 +87043,7 @@ function createBufferView(typedArray, scenegraph) {
87043
87043
 
87044
87044
  var EXT_structural_metadata = /*#__PURE__*/Object.freeze({
87045
87045
  __proto__: null,
87046
- name: name$a,
87046
+ name: name$9,
87047
87047
  decode: decode$8,
87048
87048
  encode: encode$4,
87049
87049
  createExtStructuralMetadata: createExtStructuralMetadata
@@ -87051,7 +87051,7 @@ var EXT_structural_metadata = /*#__PURE__*/Object.freeze({
87051
87051
 
87052
87052
  /** Extension name */
87053
87053
  const EXT_FEATURE_METADATA_NAME = 'EXT_feature_metadata';
87054
- const name$9 = EXT_FEATURE_METADATA_NAME;
87054
+ const name$8 = EXT_FEATURE_METADATA_NAME;
87055
87055
  async function decode$7(gltfData, options) {
87056
87056
  const scenegraph = new GLTFScenegraph(gltfData);
87057
87057
  decodeExtFeatureMetadata(scenegraph, options);
@@ -87349,7 +87349,7 @@ function processPrimitiveTextures(scenegraph, attributeName, featureTexturePrope
87349
87349
 
87350
87350
  var EXT_feature_metadata = /*#__PURE__*/Object.freeze({
87351
87351
  __proto__: null,
87352
- name: name$9,
87352
+ name: name$8,
87353
87353
  decode: decode$7
87354
87354
  });
87355
87355
 
@@ -88167,7 +88167,7 @@ function decode$6(instance, fun, target, count, size, source, filter) {
88167
88167
 
88168
88168
  /** Extension name */
88169
88169
  const EXT_MESHOPT_COMPRESSION = 'EXT_meshopt_compression';
88170
- const name$8 = EXT_MESHOPT_COMPRESSION;
88170
+ const name$7 = EXT_MESHOPT_COMPRESSION;
88171
88171
  async function decode$5(gltfData, options) {
88172
88172
  const scenegraph = new GLTFScenegraph(gltfData);
88173
88173
  if (!options?.gltf?.decompressMeshes || !options.gltf?.loadBuffers) {
@@ -88197,14 +88197,14 @@ async function decodeMeshoptBufferView(scenegraph, bufferView) {
88197
88197
 
88198
88198
  var EXT_meshopt_compression = /*#__PURE__*/Object.freeze({
88199
88199
  __proto__: null,
88200
- name: name$8,
88200
+ name: name$7,
88201
88201
  decode: decode$5
88202
88202
  });
88203
88203
 
88204
88204
  // GLTF EXTENSION: EXT_TEXTURE_WEBP
88205
88205
  const EXT_TEXTURE_WEBP = 'EXT_texture_webp';
88206
88206
  /** Extension name */
88207
- const name$7 = EXT_TEXTURE_WEBP;
88207
+ const name$6 = EXT_TEXTURE_WEBP;
88208
88208
  /**
88209
88209
  * Replaces a texture source reference with the extension texture
88210
88210
  * Done in preprocess() to prevent load of default image
@@ -88232,14 +88232,14 @@ function preprocess$3(gltfData, options) {
88232
88232
 
88233
88233
  var EXT_texture_webp = /*#__PURE__*/Object.freeze({
88234
88234
  __proto__: null,
88235
- name: name$7,
88235
+ name: name$6,
88236
88236
  preprocess: preprocess$3
88237
88237
  });
88238
88238
 
88239
88239
  // GLTF EXTENSION: KHR_texture_basisu
88240
88240
  const KHR_TEXTURE_BASISU = 'KHR_texture_basisu';
88241
88241
  /** Extension name */
88242
- const name$6 = KHR_TEXTURE_BASISU;
88242
+ const name$5 = KHR_TEXTURE_BASISU;
88243
88243
  /**
88244
88244
  * Replaces a texture source reference with the extension texture
88245
88245
  * Done in preprocess() to prevent load of default image
@@ -88261,7 +88261,7 @@ function preprocess$2(gltfData, options) {
88261
88261
 
88262
88262
  var KHR_texture_basisu = /*#__PURE__*/Object.freeze({
88263
88263
  __proto__: null,
88264
- name: name$6,
88264
+ name: name$5,
88265
88265
  preprocess: preprocess$2
88266
88266
  });
88267
88267
 
@@ -88987,7 +88987,7 @@ function toTypedArray(array, ArrayType, convertTypedArrays = false) {
88987
88987
  // https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_draco_mesh_compression
88988
88988
  const KHR_DRACO_MESH_COMPRESSION = 'KHR_draco_mesh_compression';
88989
88989
  /** Extension name */
88990
- const name$5 = KHR_DRACO_MESH_COMPRESSION;
88990
+ const name$4 = KHR_DRACO_MESH_COMPRESSION;
88991
88991
  function preprocess$1(gltfData, options, context) {
88992
88992
  const scenegraph = new GLTFScenegraph(gltfData);
88993
88993
  for (const primitive of makeMeshPrimitiveIterator(scenegraph)) {
@@ -89110,7 +89110,7 @@ function* makeMeshPrimitiveIterator(scenegraph) {
89110
89110
 
89111
89111
  var KHR_draco_mesh_compression = /*#__PURE__*/Object.freeze({
89112
89112
  __proto__: null,
89113
- name: name$5,
89113
+ name: name$4,
89114
89114
  preprocess: preprocess$1,
89115
89115
  decode: decode$4,
89116
89116
  encode: encode$3
@@ -90597,7 +90597,7 @@ function getIdentityMatrix() {
90597
90597
  */
90598
90598
  /** Extension name */
90599
90599
  const KHR_TEXTURE_TRANSFORM = 'KHR_texture_transform';
90600
- const name$4 = KHR_TEXTURE_TRANSFORM;
90600
+ const name$3 = KHR_TEXTURE_TRANSFORM;
90601
90601
  const scratchVector = new Vector3();
90602
90602
  const scratchRotationMatrix = new Matrix3();
90603
90603
  const scratchScaleMatrix = new Matrix3();
@@ -90806,13 +90806,13 @@ function makeTransformationMatrix(extensionData) {
90806
90806
 
90807
90807
  var KHR_texture_transform = /*#__PURE__*/Object.freeze({
90808
90808
  __proto__: null,
90809
- name: name$4,
90809
+ name: name$3,
90810
90810
  decode: decode$3
90811
90811
  });
90812
90812
 
90813
90813
  // GLTF EXTENSION: KHR_lights_punctual
90814
90814
  const KHR_LIGHTS_PUNCTUAL = 'KHR_lights_punctual';
90815
- const name$3 = KHR_LIGHTS_PUNCTUAL;
90815
+ const name$2 = KHR_LIGHTS_PUNCTUAL;
90816
90816
  async function decode$2(gltfData) {
90817
90817
  const gltfScenegraph = new GLTFScenegraph(gltfData);
90818
90818
  const { json } = gltfScenegraph;
@@ -90864,14 +90864,14 @@ async function encode$2(gltfData) {
90864
90864
 
90865
90865
  var KHR_lights_punctual = /*#__PURE__*/Object.freeze({
90866
90866
  __proto__: null,
90867
- name: name$3,
90867
+ name: name$2,
90868
90868
  decode: decode$2,
90869
90869
  encode: encode$2
90870
90870
  });
90871
90871
 
90872
90872
  // GLTF EXTENSION: KHR_materials_unlit
90873
90873
  const KHR_MATERIALS_UNLIT = 'KHR_materials_unlit';
90874
- const name$2 = KHR_MATERIALS_UNLIT;
90874
+ const name$1 = KHR_MATERIALS_UNLIT;
90875
90875
  async function decode$1(gltfData) {
90876
90876
  const gltfScenegraph = new GLTFScenegraph(gltfData);
90877
90877
  const { json } = gltfScenegraph;
@@ -90909,14 +90909,14 @@ function encode$1(gltfData) {
90909
90909
 
90910
90910
  var KHR_materials_unlit = /*#__PURE__*/Object.freeze({
90911
90911
  __proto__: null,
90912
- name: name$2,
90912
+ name: name$1,
90913
90913
  decode: decode$1,
90914
90914
  encode: encode$1
90915
90915
  });
90916
90916
 
90917
90917
  // GLTF EXTENSION: KHR_techniques_webgl
90918
90918
  const KHR_TECHNIQUES_WEBGL = 'KHR_techniques_webgl';
90919
- const name$1 = KHR_TECHNIQUES_WEBGL;
90919
+ const name = KHR_TECHNIQUES_WEBGL;
90920
90920
  async function decode(gltfData) {
90921
90921
  const gltfScenegraph = new GLTFScenegraph(gltfData);
90922
90922
  const { json } = gltfScenegraph;
@@ -90989,7 +90989,7 @@ function resolveValues(technique, gltfScenegraph) {
90989
90989
 
90990
90990
  var KHR_techniques_webgl = /*#__PURE__*/Object.freeze({
90991
90991
  __proto__: null,
90992
- name: name$1,
90992
+ name: name,
90993
90993
  decode: decode,
90994
90994
  encode: encode
90995
90995
  });
@@ -93507,25 +93507,9 @@ class NavCubePlugin extends Plugin {
93507
93507
  lastY = posY;
93508
93508
  }
93509
93509
 
93510
- function getCoordsWithinElement(event) {
93511
- var coords = [0, 0];
93512
- if (!event) {
93513
- event = window.event;
93514
- coords[0] = event.x;
93515
- coords[1] = event.y;
93516
- } else {
93517
- var element = event.target;
93518
- var totalOffsetLeft = 0;
93519
- var totalOffsetTop = 0;
93520
- while (element.offsetParent) {
93521
- totalOffsetLeft += element.offsetLeft;
93522
- totalOffsetTop += element.offsetTop;
93523
- element = element.offsetParent;
93524
- }
93525
- coords[0] = event.pageX - totalOffsetLeft;
93526
- coords[1] = event.pageY - totalOffsetTop;
93527
- }
93528
- return coords;
93510
+ function getCoordsWithinElement(clientCoords) {
93511
+ const { left, top } = self._navCubeCanvas.getBoundingClientRect();
93512
+ return [clientCoords.clientX - left, clientCoords.clientY - top];
93529
93513
  }
93530
93514
 
93531
93515
  {
@@ -93556,7 +93540,7 @@ class NavCubePlugin extends Plugin {
93556
93540
  downY = e.y;
93557
93541
  lastX = e.clientX;
93558
93542
  lastY = e.clientY;
93559
- var canvasPos = getCoordsWithinElement(e);
93543
+ var canvasPos = getCoordsWithinElement({clientX: e.clientX, clientY: e.clientY});
93560
93544
  var hit = navCubeScene.pick({
93561
93545
  canvasPos: canvasPos
93562
93546
  });
@@ -93576,7 +93560,7 @@ class NavCubePlugin extends Plugin {
93576
93560
  if (downX === null) {
93577
93561
  return;
93578
93562
  }
93579
- var canvasPos = getCoordsWithinElement(e);
93563
+ var canvasPos = getCoordsWithinElement({clientX: e.clientX, clientY: e.clientY});
93580
93564
  var hit = navCubeScene.pick({
93581
93565
  canvasPos: canvasPos,
93582
93566
  pickSurface: true
@@ -93649,7 +93633,7 @@ class NavCubePlugin extends Plugin {
93649
93633
  if (!over) {
93650
93634
  return;
93651
93635
  }
93652
- var canvasPos = getCoordsWithinElement(e);
93636
+ var canvasPos = getCoordsWithinElement({clientX: e.clientX, clientY: e.clientY});
93653
93637
  var hit = navCubeScene.pick({
93654
93638
  canvasPos: canvasPos,
93655
93639
  pickSurface: true
@@ -93679,6 +93663,55 @@ class NavCubePlugin extends Plugin {
93679
93663
  }
93680
93664
  }
93681
93665
  });
93666
+
93667
+ self._navCubeCanvas.addEventListener("touchstart", self._onTouchStart = function (e) {
93668
+ if (e.touches.length > 0) {
93669
+ downX = e.touches[0].clientX;
93670
+ downY = e.touches[0].clientY;
93671
+ lastX = e.touches[0].clientX;
93672
+ lastY = e.touches[0].clientY;
93673
+ var canvasPos = getCoordsWithinElement({clientX: e.touches[0].clientX, clientY: e.touches[0].clientY});
93674
+ var hit = navCubeScene.pick({
93675
+ canvasPos: canvasPos
93676
+ });
93677
+ if (hit) {
93678
+ down = true;
93679
+ } else {
93680
+ down = false;
93681
+ }
93682
+ }
93683
+ },
93684
+ {
93685
+ passive: false
93686
+ });
93687
+
93688
+ self._navCubeCanvas.addEventListener("touchmove", self._onTouchMove = function (e) {
93689
+ e.preventDefault();
93690
+ var touch = e.touches[0];
93691
+ var posX = touch.clientX;
93692
+ var posY = touch.clientY;
93693
+
93694
+ var currentElement = document.elementFromPoint(posX, posY);
93695
+ over = (self._navCubeCanvas === currentElement);
93696
+
93697
+ if (!over) {
93698
+ return;
93699
+ }
93700
+ if (down) {
93701
+ actionMove(posX, posY);
93702
+ return;
93703
+ }
93704
+ },
93705
+ {
93706
+ passive: false
93707
+ });
93708
+
93709
+ self._navCubeCanvas.addEventListener("touchend", self._onTouchEnd = function (e) {
93710
+ down = false;
93711
+ if (downX === null) {
93712
+ return;
93713
+ }
93714
+ });
93682
93715
 
93683
93716
  var flyTo = (function () {
93684
93717
  var center = math.vec3();
@@ -93937,6 +93970,10 @@ class NavCubePlugin extends Plugin {
93937
93970
  this._navCubeCanvas.removeEventListener("mousemove", this._onMouseMove);
93938
93971
  this._navCubeCanvas.removeEventListener("mouseup", this._onMouseUp);
93939
93972
 
93973
+ this._navCubeCanvas.removeEventListener("touchstart", this._onTouchStart);
93974
+ this._navCubeCanvas.removeEventListener("touchmove", this._onTouchMove);
93975
+ this._navCubeCanvas.removeEventListener("touchend", this._onTouchEnd);
93976
+
93940
93977
  this._navCubeCanvas = null;
93941
93978
  this._cubeTextureCanvas.destroy();
93942
93979
  this._cubeTextureCanvas = null;
@@ -93946,6 +93983,10 @@ class NavCubePlugin extends Plugin {
93946
93983
  this._onMouseDown = null;
93947
93984
  this._onMouseMove = null;
93948
93985
  this._onMouseUp = null;
93986
+
93987
+ this._onTouchStart = null;
93988
+ this._onTouchMove = null;
93989
+ this._onTouchEnd = null;
93949
93990
  }
93950
93991
 
93951
93992
  this._navCubeScene.destroy();
@@ -96157,7 +96198,8 @@ class SectionPlanesPlugin extends Plugin {
96157
96198
  })(),
96158
96199
  setQuaternion: q => { rootNode.quaternion = q; },
96159
96200
  setScale: s => { rootNode.scale = s; },
96160
- setVisible: v => { rootNode.visible = v; }
96201
+ setVisible: v => { rootNode.visible = v; },
96202
+ destroy: () => { rootNode.destroy(); }
96161
96203
  };
96162
96204
  })();
96163
96205
  let unbindSectionPlane = () => { };
@@ -96176,6 +96218,7 @@ class SectionPlanesPlugin extends Plugin {
96176
96218
  _destroy: () => {
96177
96219
  unbindSectionPlane();
96178
96220
  ctrl.destroy();
96221
+ planeRoot.destroy();
96179
96222
  },
96180
96223
  setCulled: c => { culled = c; updateVisible(); },
96181
96224
  setVisible: v => { visible = v; updateVisible(); },
@@ -111658,3997 +111701,6 @@ class WebIFCLoaderPlugin extends Plugin {
111658
111701
  }
111659
111702
  }
111660
111703
 
111661
- const name = "@creooxag/cxconverter";
111662
- const version = "0.0.3-alpha";
111663
- const description = "";
111664
- const exports$1 = {
111665
- ".": {
111666
- types: "./dist/index.d.ts",
111667
- "import": "./dist/index.mjs",
111668
- require: "./dist/index.cjs"
111669
- }
111670
- };
111671
- const main = "./dist/index.mjs";
111672
- const module$1 = "./dist/index.mjs";
111673
- const types = "./dist/index.d.ts";
111674
- const typesVersions = {
111675
- "*": {
111676
- "*": [
111677
- "./dist/*",
111678
- "./dist/index.d.ts"
111679
- ]
111680
- }
111681
- };
111682
- const files = [
111683
- "dist/"
111684
- ];
111685
- const scripts = {
111686
- "clean-dist": "rm -rf ./dist",
111687
- "clean-cmake": "rm -rf ./cmake-build",
111688
- "build-wasm-release": "emcmake cmake -S . -B ../cmake-build -DCMAKE_BUILD_TYPE=Release && cmake --build ../cmake-build",
111689
- "publish-npm": "npm publish --access public",
111690
- build: "unbuild",
111691
- dev: "unbuild --stub",
111692
- lint: "eslint .",
111693
- start: "esno examples/node/nodeExport.ts",
111694
- "example-html": "http-server -c-1 -p8237 --cors"
111695
- };
111696
- const keywords = [
111697
- ];
111698
- const devDependencies = {
111699
- "@types/node": "^22.10.2",
111700
- esno: "^4.8.0",
111701
- "fast-glob": "^3.3.2",
111702
- globals: "^15.8.0",
111703
- "http-server": "^14.1.1",
111704
- prettier: "^3.3.3",
111705
- "prettier-eslint": "^16.3.0",
111706
- typescript: "^5.7.2",
111707
- unbuild: "^2.0.0",
111708
- "@eslint/eslintrc": "^3.2.0",
111709
- "@eslint/js": "^9.20.0",
111710
- "@typescript-eslint/eslint-plugin": "^8.24.0",
111711
- "@typescript-eslint/parser": "^8.24.0",
111712
- eslint: "^9.20.1",
111713
- "eslint-config-prettier": "^10.0.1",
111714
- "eslint-plugin-import": "^2.31.0",
111715
- "eslint-plugin-prettier": "^5.2.3"
111716
- };
111717
- const packageJSON = {
111718
- name: name,
111719
- version: version,
111720
- description: description,
111721
- exports: exports$1,
111722
- main: main,
111723
- module: module$1,
111724
- types: types,
111725
- typesVersions: typesVersions,
111726
- files: files,
111727
- scripts: scripts,
111728
- keywords: keywords,
111729
- devDependencies: devDependencies
111730
- };
111731
-
111732
- var __defProp$2 = Object.defineProperty;
111733
- var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
111734
- var __publicField$2 = (obj, key, value) => {
111735
- __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
111736
- return value;
111737
- };
111738
- var IfcDbWasm = /* @__PURE__ */ (() => {
111739
- return async function(moduleArg = {}) {
111740
- var moduleRtn;
111741
- var Module = moduleArg;
111742
- var readyPromiseResolve, readyPromiseReject;
111743
- var readyPromise = new Promise((resolve, reject) => {
111744
- readyPromiseResolve = resolve;
111745
- readyPromiseReject = reject;
111746
- });
111747
- var arguments_ = [];
111748
- var thisProgram = "./this.program";
111749
- var quit_ = (status, toThrow) => {
111750
- throw toThrow;
111751
- };
111752
- var _scriptName = import.meta.url;
111753
- var scriptDirectory = "";
111754
- function locateFile(path) {
111755
- if (Module["locateFile"]) {
111756
- return Module["locateFile"](path, scriptDirectory);
111757
- }
111758
- return scriptDirectory + path;
111759
- }
111760
- var readAsync, readBinary;
111761
- {
111762
- try {
111763
- scriptDirectory = new URL(".", _scriptName).href;
111764
- } catch {
111765
- }
111766
- {
111767
- readAsync = async (url) => {
111768
- var response = await fetch(url, { credentials: "same-origin" });
111769
- if (response.ok) {
111770
- return response.arrayBuffer();
111771
- }
111772
- throw new Error(response.status + " : " + response.url);
111773
- };
111774
- }
111775
- }
111776
- var out = console.log.bind(console);
111777
- var err = console.error.bind(console);
111778
- var wasmBinary;
111779
- var wasmMemory;
111780
- var ABORT = false;
111781
- var EXITSTATUS;
111782
- var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAP64, HEAPU64, HEAPF64;
111783
- function updateMemoryViews() {
111784
- var b = wasmMemory.buffer;
111785
- HEAP8 = new Int8Array(b);
111786
- HEAP16 = new Int16Array(b);
111787
- HEAPU8 = new Uint8Array(b);
111788
- HEAPU16 = new Uint16Array(b);
111789
- HEAP32 = new Int32Array(b);
111790
- HEAPU32 = new Uint32Array(b);
111791
- HEAPF32 = new Float32Array(b);
111792
- HEAPF64 = new Float64Array(b);
111793
- HEAP64 = new BigInt64Array(b);
111794
- HEAPU64 = new BigUint64Array(b);
111795
- }
111796
- function preRun() {
111797
- if (Module["preRun"]) {
111798
- if (typeof Module["preRun"] == "function")
111799
- Module["preRun"] = [Module["preRun"]];
111800
- while (Module["preRun"].length) {
111801
- addOnPreRun(Module["preRun"].shift());
111802
- }
111803
- }
111804
- callRuntimeCallbacks(onPreRuns);
111805
- }
111806
- function initRuntime() {
111807
- if (!Module["noFSInit"] && !FS.initialized)
111808
- FS.init();
111809
- wasmExports["V"]();
111810
- FS.ignorePermissions = false;
111811
- }
111812
- function postRun() {
111813
- if (Module["postRun"]) {
111814
- if (typeof Module["postRun"] == "function")
111815
- Module["postRun"] = [Module["postRun"]];
111816
- while (Module["postRun"].length) {
111817
- addOnPostRun(Module["postRun"].shift());
111818
- }
111819
- }
111820
- callRuntimeCallbacks(onPostRuns);
111821
- }
111822
- var runDependencies = 0;
111823
- var dependenciesFulfilled = null;
111824
- function addRunDependency(id) {
111825
- runDependencies++;
111826
- Module["monitorRunDependencies"]?.(runDependencies);
111827
- }
111828
- function removeRunDependency(id) {
111829
- runDependencies--;
111830
- Module["monitorRunDependencies"]?.(runDependencies);
111831
- if (runDependencies == 0) {
111832
- if (dependenciesFulfilled) {
111833
- var callback = dependenciesFulfilled;
111834
- dependenciesFulfilled = null;
111835
- callback();
111836
- }
111837
- }
111838
- }
111839
- function abort(what) {
111840
- Module["onAbort"]?.(what);
111841
- what = "Aborted(" + what + ")";
111842
- err(what);
111843
- ABORT = true;
111844
- what += ". Build with -sASSERTIONS for more info.";
111845
- var e = new WebAssembly.RuntimeError(what);
111846
- readyPromiseReject(e);
111847
- throw e;
111848
- }
111849
- var wasmBinaryFile;
111850
- function findWasmBinary() {
111851
- if (Module["locateFile"]) {
111852
- return locateFile("ifcdb.wasm");
111853
- }
111854
- return new URL("ifcdb.wasm", import.meta.url).href;
111855
- }
111856
- function getBinarySync(file) {
111857
- if (file == wasmBinaryFile && wasmBinary) {
111858
- return new Uint8Array(wasmBinary);
111859
- }
111860
- throw "both async and sync fetching of the wasm failed";
111861
- }
111862
- async function getWasmBinary(binaryFile) {
111863
- if (!wasmBinary) {
111864
- try {
111865
- var response = await readAsync(binaryFile);
111866
- return new Uint8Array(response);
111867
- } catch {
111868
- }
111869
- }
111870
- return getBinarySync(binaryFile);
111871
- }
111872
- async function instantiateArrayBuffer(binaryFile, imports) {
111873
- try {
111874
- var binary = await getWasmBinary(binaryFile);
111875
- var instance = await WebAssembly.instantiate(binary, imports);
111876
- return instance;
111877
- } catch (reason) {
111878
- err(`failed to asynchronously prepare wasm: ${reason}`);
111879
- abort(reason);
111880
- }
111881
- }
111882
- async function instantiateAsync(binary, binaryFile, imports) {
111883
- if (!binary && typeof WebAssembly.instantiateStreaming == "function") {
111884
- try {
111885
- var response = fetch(binaryFile, { credentials: "same-origin" });
111886
- var instantiationResult = await WebAssembly.instantiateStreaming(response, imports);
111887
- return instantiationResult;
111888
- } catch (reason) {
111889
- err(`wasm streaming compile failed: ${reason}`);
111890
- err("falling back to ArrayBuffer instantiation");
111891
- }
111892
- }
111893
- return instantiateArrayBuffer(binaryFile, imports);
111894
- }
111895
- function getWasmImports() {
111896
- return { a: wasmImports };
111897
- }
111898
- async function createWasm() {
111899
- function receiveInstance(instance, module) {
111900
- wasmExports = instance.exports;
111901
- wasmExports = Asyncify.instrumentWasmExports(wasmExports);
111902
- wasmMemory = wasmExports["U"];
111903
- updateMemoryViews();
111904
- removeRunDependency();
111905
- return wasmExports;
111906
- }
111907
- addRunDependency();
111908
- function receiveInstantiationResult(result2) {
111909
- return receiveInstance(result2["instance"]);
111910
- }
111911
- var info = getWasmImports();
111912
- if (Module["instantiateWasm"]) {
111913
- return new Promise((resolve, reject) => {
111914
- Module["instantiateWasm"](info, (mod, inst) => {
111915
- resolve(receiveInstance(mod));
111916
- });
111917
- });
111918
- }
111919
- wasmBinaryFile ?? (wasmBinaryFile = findWasmBinary());
111920
- try {
111921
- var result = await instantiateAsync(wasmBinary, wasmBinaryFile, info);
111922
- var exports = receiveInstantiationResult(result);
111923
- return exports;
111924
- } catch (e) {
111925
- readyPromiseReject(e);
111926
- return Promise.reject(e);
111927
- }
111928
- }
111929
- class ExitStatus {
111930
- constructor(status) {
111931
- __publicField$2(this, "name", "ExitStatus");
111932
- this.message = `Program terminated with exit(${status})`;
111933
- this.status = status;
111934
- }
111935
- }
111936
- var callRuntimeCallbacks = (callbacks) => {
111937
- while (callbacks.length > 0) {
111938
- callbacks.shift()(Module);
111939
- }
111940
- };
111941
- var onPostRuns = [];
111942
- var addOnPostRun = (cb) => onPostRuns.push(cb);
111943
- var onPreRuns = [];
111944
- var addOnPreRun = (cb) => onPreRuns.push(cb);
111945
- var dynCallLegacy = (sig, ptr, args) => {
111946
- sig = sig.replace(/p/g, "i");
111947
- var f = Module["dynCall_" + sig];
111948
- return f(ptr, ...args);
111949
- };
111950
- var dynCall = (sig, ptr, args = [], promising = false) => {
111951
- var rtn = dynCallLegacy(sig, ptr, args);
111952
- function convert(rtn2) {
111953
- return rtn2;
111954
- }
111955
- return convert(rtn);
111956
- };
111957
- var noExitRuntime = true;
111958
- class ExceptionInfo {
111959
- constructor(excPtr) {
111960
- this.excPtr = excPtr;
111961
- this.ptr = excPtr - 24;
111962
- }
111963
- set_type(type) {
111964
- HEAPU32[this.ptr + 4 >> 2] = type;
111965
- }
111966
- get_type() {
111967
- return HEAPU32[this.ptr + 4 >> 2];
111968
- }
111969
- set_destructor(destructor) {
111970
- HEAPU32[this.ptr + 8 >> 2] = destructor;
111971
- }
111972
- get_destructor() {
111973
- return HEAPU32[this.ptr + 8 >> 2];
111974
- }
111975
- set_caught(caught) {
111976
- caught = caught ? 1 : 0;
111977
- HEAP8[this.ptr + 12] = caught;
111978
- }
111979
- get_caught() {
111980
- return HEAP8[this.ptr + 12] != 0;
111981
- }
111982
- set_rethrown(rethrown) {
111983
- rethrown = rethrown ? 1 : 0;
111984
- HEAP8[this.ptr + 13] = rethrown;
111985
- }
111986
- get_rethrown() {
111987
- return HEAP8[this.ptr + 13] != 0;
111988
- }
111989
- init(type, destructor) {
111990
- this.set_adjusted_ptr(0);
111991
- this.set_type(type);
111992
- this.set_destructor(destructor);
111993
- }
111994
- set_adjusted_ptr(adjustedPtr) {
111995
- HEAPU32[this.ptr + 16 >> 2] = adjustedPtr;
111996
- }
111997
- get_adjusted_ptr() {
111998
- return HEAPU32[this.ptr + 16 >> 2];
111999
- }
112000
- }
112001
- var exceptionLast = 0;
112002
- var ___cxa_throw = (ptr, type, destructor) => {
112003
- var info = new ExceptionInfo(ptr);
112004
- info.init(type, destructor);
112005
- exceptionLast = ptr;
112006
- throw exceptionLast;
112007
- };
112008
- var syscallGetVarargI = () => {
112009
- var ret = HEAP32[+SYSCALLS.varargs >> 2];
112010
- SYSCALLS.varargs += 4;
112011
- return ret;
112012
- };
112013
- var syscallGetVarargP = syscallGetVarargI;
112014
- var PATH = { isAbs: (path) => path.charAt(0) === "/", splitPath: (filename) => {
112015
- var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
112016
- return splitPathRe.exec(filename).slice(1);
112017
- }, normalizeArray: (parts, allowAboveRoot) => {
112018
- var up = 0;
112019
- for (var i = parts.length - 1; i >= 0; i--) {
112020
- var last = parts[i];
112021
- if (last === ".") {
112022
- parts.splice(i, 1);
112023
- } else if (last === "..") {
112024
- parts.splice(i, 1);
112025
- up++;
112026
- } else if (up) {
112027
- parts.splice(i, 1);
112028
- up--;
112029
- }
112030
- }
112031
- if (allowAboveRoot) {
112032
- for (; up; up--) {
112033
- parts.unshift("..");
112034
- }
112035
- }
112036
- return parts;
112037
- }, normalize: (path) => {
112038
- var isAbsolute = PATH.isAbs(path), trailingSlash = path.slice(-1) === "/";
112039
- path = PATH.normalizeArray(path.split("/").filter((p) => !!p), !isAbsolute).join("/");
112040
- if (!path && !isAbsolute) {
112041
- path = ".";
112042
- }
112043
- if (path && trailingSlash) {
112044
- path += "/";
112045
- }
112046
- return (isAbsolute ? "/" : "") + path;
112047
- }, dirname: (path) => {
112048
- var result = PATH.splitPath(path), root = result[0], dir = result[1];
112049
- if (!root && !dir) {
112050
- return ".";
112051
- }
112052
- if (dir) {
112053
- dir = dir.slice(0, -1);
112054
- }
112055
- return root + dir;
112056
- }, basename: (path) => path && path.match(/([^\/]+|\/)\/*$/)[1], join: (...paths) => PATH.normalize(paths.join("/")), join2: (l, r) => PATH.normalize(l + "/" + r) };
112057
- var initRandomFill = () => (view) => crypto.getRandomValues(view);
112058
- var randomFill = (view) => {
112059
- (randomFill = initRandomFill())(view);
112060
- };
112061
- var PATH_FS = { resolve: (...args) => {
112062
- var resolvedPath = "", resolvedAbsolute = false;
112063
- for (var i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {
112064
- var path = i >= 0 ? args[i] : FS.cwd();
112065
- if (typeof path != "string") {
112066
- throw new TypeError("Arguments to path.resolve must be strings");
112067
- } else if (!path) {
112068
- return "";
112069
- }
112070
- resolvedPath = path + "/" + resolvedPath;
112071
- resolvedAbsolute = PATH.isAbs(path);
112072
- }
112073
- resolvedPath = PATH.normalizeArray(resolvedPath.split("/").filter((p) => !!p), !resolvedAbsolute).join("/");
112074
- return (resolvedAbsolute ? "/" : "") + resolvedPath || ".";
112075
- }, relative: (from, to) => {
112076
- from = PATH_FS.resolve(from).slice(1);
112077
- to = PATH_FS.resolve(to).slice(1);
112078
- function trim(arr) {
112079
- var start = 0;
112080
- for (; start < arr.length; start++) {
112081
- if (arr[start] !== "")
112082
- break;
112083
- }
112084
- var end = arr.length - 1;
112085
- for (; end >= 0; end--) {
112086
- if (arr[end] !== "")
112087
- break;
112088
- }
112089
- if (start > end)
112090
- return [];
112091
- return arr.slice(start, end - start + 1);
112092
- }
112093
- var fromParts = trim(from.split("/"));
112094
- var toParts = trim(to.split("/"));
112095
- var length = Math.min(fromParts.length, toParts.length);
112096
- var samePartsLength = length;
112097
- for (var i = 0; i < length; i++) {
112098
- if (fromParts[i] !== toParts[i]) {
112099
- samePartsLength = i;
112100
- break;
112101
- }
112102
- }
112103
- var outputParts = [];
112104
- for (var i = samePartsLength; i < fromParts.length; i++) {
112105
- outputParts.push("..");
112106
- }
112107
- outputParts = outputParts.concat(toParts.slice(samePartsLength));
112108
- return outputParts.join("/");
112109
- } };
112110
- var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder() : void 0;
112111
- var UTF8ArrayToString = (heapOrArray, idx = 0, maxBytesToRead = NaN) => {
112112
- var endIdx = idx + maxBytesToRead;
112113
- var endPtr = idx;
112114
- while (heapOrArray[endPtr] && !(endPtr >= endIdx))
112115
- ++endPtr;
112116
- if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
112117
- return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
112118
- }
112119
- var str = "";
112120
- while (idx < endPtr) {
112121
- var u0 = heapOrArray[idx++];
112122
- if (!(u0 & 128)) {
112123
- str += String.fromCharCode(u0);
112124
- continue;
112125
- }
112126
- var u1 = heapOrArray[idx++] & 63;
112127
- if ((u0 & 224) == 192) {
112128
- str += String.fromCharCode((u0 & 31) << 6 | u1);
112129
- continue;
112130
- }
112131
- var u2 = heapOrArray[idx++] & 63;
112132
- if ((u0 & 240) == 224) {
112133
- u0 = (u0 & 15) << 12 | u1 << 6 | u2;
112134
- } else {
112135
- u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heapOrArray[idx++] & 63;
112136
- }
112137
- if (u0 < 65536) {
112138
- str += String.fromCharCode(u0);
112139
- } else {
112140
- var ch = u0 - 65536;
112141
- str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
112142
- }
112143
- }
112144
- return str;
112145
- };
112146
- var FS_stdin_getChar_buffer = [];
112147
- var lengthBytesUTF8 = (str) => {
112148
- var len = 0;
112149
- for (var i = 0; i < str.length; ++i) {
112150
- var c = str.charCodeAt(i);
112151
- if (c <= 127) {
112152
- len++;
112153
- } else if (c <= 2047) {
112154
- len += 2;
112155
- } else if (c >= 55296 && c <= 57343) {
112156
- len += 4;
112157
- ++i;
112158
- } else {
112159
- len += 3;
112160
- }
112161
- }
112162
- return len;
112163
- };
112164
- var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => {
112165
- if (!(maxBytesToWrite > 0))
112166
- return 0;
112167
- var startIdx = outIdx;
112168
- var endIdx = outIdx + maxBytesToWrite - 1;
112169
- for (var i = 0; i < str.length; ++i) {
112170
- var u = str.charCodeAt(i);
112171
- if (u >= 55296 && u <= 57343) {
112172
- var u1 = str.charCodeAt(++i);
112173
- u = 65536 + ((u & 1023) << 10) | u1 & 1023;
112174
- }
112175
- if (u <= 127) {
112176
- if (outIdx >= endIdx)
112177
- break;
112178
- heap[outIdx++] = u;
112179
- } else if (u <= 2047) {
112180
- if (outIdx + 1 >= endIdx)
112181
- break;
112182
- heap[outIdx++] = 192 | u >> 6;
112183
- heap[outIdx++] = 128 | u & 63;
112184
- } else if (u <= 65535) {
112185
- if (outIdx + 2 >= endIdx)
112186
- break;
112187
- heap[outIdx++] = 224 | u >> 12;
112188
- heap[outIdx++] = 128 | u >> 6 & 63;
112189
- heap[outIdx++] = 128 | u & 63;
112190
- } else {
112191
- if (outIdx + 3 >= endIdx)
112192
- break;
112193
- heap[outIdx++] = 240 | u >> 18;
112194
- heap[outIdx++] = 128 | u >> 12 & 63;
112195
- heap[outIdx++] = 128 | u >> 6 & 63;
112196
- heap[outIdx++] = 128 | u & 63;
112197
- }
112198
- }
112199
- heap[outIdx] = 0;
112200
- return outIdx - startIdx;
112201
- };
112202
- var intArrayFromString = (stringy, dontAddNull, length) => {
112203
- var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1;
112204
- var u8array = new Array(len);
112205
- var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length);
112206
- if (dontAddNull)
112207
- u8array.length = numBytesWritten;
112208
- return u8array;
112209
- };
112210
- var FS_stdin_getChar = () => {
112211
- if (!FS_stdin_getChar_buffer.length) {
112212
- var result = null;
112213
- if (typeof window != "undefined" && typeof window.prompt == "function") {
112214
- result = window.prompt("Input: ");
112215
- if (result !== null) {
112216
- result += "\n";
112217
- }
112218
- }
112219
- if (!result) {
112220
- return null;
112221
- }
112222
- FS_stdin_getChar_buffer = intArrayFromString(result, true);
112223
- }
112224
- return FS_stdin_getChar_buffer.shift();
112225
- };
112226
- var TTY = { ttys: [], init() {
112227
- }, shutdown() {
112228
- }, register(dev, ops) {
112229
- TTY.ttys[dev] = { input: [], output: [], ops };
112230
- FS.registerDevice(dev, TTY.stream_ops);
112231
- }, stream_ops: { open(stream) {
112232
- var tty = TTY.ttys[stream.node.rdev];
112233
- if (!tty) {
112234
- throw new FS.ErrnoError(43);
112235
- }
112236
- stream.tty = tty;
112237
- stream.seekable = false;
112238
- }, close(stream) {
112239
- stream.tty.ops.fsync(stream.tty);
112240
- }, fsync(stream) {
112241
- stream.tty.ops.fsync(stream.tty);
112242
- }, read(stream, buffer, offset, length, pos) {
112243
- if (!stream.tty || !stream.tty.ops.get_char) {
112244
- throw new FS.ErrnoError(60);
112245
- }
112246
- var bytesRead = 0;
112247
- for (var i = 0; i < length; i++) {
112248
- var result;
112249
- try {
112250
- result = stream.tty.ops.get_char(stream.tty);
112251
- } catch (e) {
112252
- throw new FS.ErrnoError(29);
112253
- }
112254
- if (result === void 0 && bytesRead === 0) {
112255
- throw new FS.ErrnoError(6);
112256
- }
112257
- if (result === null || result === void 0)
112258
- break;
112259
- bytesRead++;
112260
- buffer[offset + i] = result;
112261
- }
112262
- if (bytesRead) {
112263
- stream.node.atime = Date.now();
112264
- }
112265
- return bytesRead;
112266
- }, write(stream, buffer, offset, length, pos) {
112267
- if (!stream.tty || !stream.tty.ops.put_char) {
112268
- throw new FS.ErrnoError(60);
112269
- }
112270
- try {
112271
- for (var i = 0; i < length; i++) {
112272
- stream.tty.ops.put_char(stream.tty, buffer[offset + i]);
112273
- }
112274
- } catch (e) {
112275
- throw new FS.ErrnoError(29);
112276
- }
112277
- if (length) {
112278
- stream.node.mtime = stream.node.ctime = Date.now();
112279
- }
112280
- return i;
112281
- } }, default_tty_ops: { get_char(tty) {
112282
- return FS_stdin_getChar();
112283
- }, put_char(tty, val) {
112284
- if (val === null || val === 10) {
112285
- out(UTF8ArrayToString(tty.output));
112286
- tty.output = [];
112287
- } else {
112288
- if (val != 0)
112289
- tty.output.push(val);
112290
- }
112291
- }, fsync(tty) {
112292
- if (tty.output?.length > 0) {
112293
- out(UTF8ArrayToString(tty.output));
112294
- tty.output = [];
112295
- }
112296
- }, ioctl_tcgets(tty) {
112297
- return { c_iflag: 25856, c_oflag: 5, c_cflag: 191, c_lflag: 35387, c_cc: [3, 28, 127, 21, 4, 0, 1, 0, 17, 19, 26, 0, 18, 15, 23, 22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] };
112298
- }, ioctl_tcsets(tty, optional_actions, data) {
112299
- return 0;
112300
- }, ioctl_tiocgwinsz(tty) {
112301
- return [24, 80];
112302
- } }, default_tty1_ops: { put_char(tty, val) {
112303
- if (val === null || val === 10) {
112304
- err(UTF8ArrayToString(tty.output));
112305
- tty.output = [];
112306
- } else {
112307
- if (val != 0)
112308
- tty.output.push(val);
112309
- }
112310
- }, fsync(tty) {
112311
- if (tty.output?.length > 0) {
112312
- err(UTF8ArrayToString(tty.output));
112313
- tty.output = [];
112314
- }
112315
- } } };
112316
- var mmapAlloc = (size) => {
112317
- abort();
112318
- };
112319
- var MEMFS = { ops_table: null, mount(mount) {
112320
- return MEMFS.createNode(null, "/", 16895, 0);
112321
- }, createNode(parent, name, mode, dev) {
112322
- if (FS.isBlkdev(mode) || FS.isFIFO(mode)) {
112323
- throw new FS.ErrnoError(63);
112324
- }
112325
- MEMFS.ops_table || (MEMFS.ops_table = { dir: { node: { getattr: MEMFS.node_ops.getattr, setattr: MEMFS.node_ops.setattr, lookup: MEMFS.node_ops.lookup, mknod: MEMFS.node_ops.mknod, rename: MEMFS.node_ops.rename, unlink: MEMFS.node_ops.unlink, rmdir: MEMFS.node_ops.rmdir, readdir: MEMFS.node_ops.readdir, symlink: MEMFS.node_ops.symlink }, stream: { llseek: MEMFS.stream_ops.llseek } }, file: { node: { getattr: MEMFS.node_ops.getattr, setattr: MEMFS.node_ops.setattr }, stream: { llseek: MEMFS.stream_ops.llseek, read: MEMFS.stream_ops.read, write: MEMFS.stream_ops.write, mmap: MEMFS.stream_ops.mmap, msync: MEMFS.stream_ops.msync } }, link: { node: { getattr: MEMFS.node_ops.getattr, setattr: MEMFS.node_ops.setattr, readlink: MEMFS.node_ops.readlink }, stream: {} }, chrdev: { node: { getattr: MEMFS.node_ops.getattr, setattr: MEMFS.node_ops.setattr }, stream: FS.chrdev_stream_ops } });
112326
- var node = FS.createNode(parent, name, mode, dev);
112327
- if (FS.isDir(node.mode)) {
112328
- node.node_ops = MEMFS.ops_table.dir.node;
112329
- node.stream_ops = MEMFS.ops_table.dir.stream;
112330
- node.contents = {};
112331
- } else if (FS.isFile(node.mode)) {
112332
- node.node_ops = MEMFS.ops_table.file.node;
112333
- node.stream_ops = MEMFS.ops_table.file.stream;
112334
- node.usedBytes = 0;
112335
- node.contents = null;
112336
- } else if (FS.isLink(node.mode)) {
112337
- node.node_ops = MEMFS.ops_table.link.node;
112338
- node.stream_ops = MEMFS.ops_table.link.stream;
112339
- } else if (FS.isChrdev(node.mode)) {
112340
- node.node_ops = MEMFS.ops_table.chrdev.node;
112341
- node.stream_ops = MEMFS.ops_table.chrdev.stream;
112342
- }
112343
- node.atime = node.mtime = node.ctime = Date.now();
112344
- if (parent) {
112345
- parent.contents[name] = node;
112346
- parent.atime = parent.mtime = parent.ctime = node.atime;
112347
- }
112348
- return node;
112349
- }, getFileDataAsTypedArray(node) {
112350
- if (!node.contents)
112351
- return new Uint8Array(0);
112352
- if (node.contents.subarray)
112353
- return node.contents.subarray(0, node.usedBytes);
112354
- return new Uint8Array(node.contents);
112355
- }, expandFileStorage(node, newCapacity) {
112356
- var prevCapacity = node.contents ? node.contents.length : 0;
112357
- if (prevCapacity >= newCapacity)
112358
- return;
112359
- var CAPACITY_DOUBLING_MAX = 1024 * 1024;
112360
- newCapacity = Math.max(newCapacity, prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2 : 1.125) >>> 0);
112361
- if (prevCapacity != 0)
112362
- newCapacity = Math.max(newCapacity, 256);
112363
- var oldContents = node.contents;
112364
- node.contents = new Uint8Array(newCapacity);
112365
- if (node.usedBytes > 0)
112366
- node.contents.set(oldContents.subarray(0, node.usedBytes), 0);
112367
- }, resizeFileStorage(node, newSize) {
112368
- if (node.usedBytes == newSize)
112369
- return;
112370
- if (newSize == 0) {
112371
- node.contents = null;
112372
- node.usedBytes = 0;
112373
- } else {
112374
- var oldContents = node.contents;
112375
- node.contents = new Uint8Array(newSize);
112376
- if (oldContents) {
112377
- node.contents.set(oldContents.subarray(0, Math.min(newSize, node.usedBytes)));
112378
- }
112379
- node.usedBytes = newSize;
112380
- }
112381
- }, node_ops: { getattr(node) {
112382
- var attr = {};
112383
- attr.dev = FS.isChrdev(node.mode) ? node.id : 1;
112384
- attr.ino = node.id;
112385
- attr.mode = node.mode;
112386
- attr.nlink = 1;
112387
- attr.uid = 0;
112388
- attr.gid = 0;
112389
- attr.rdev = node.rdev;
112390
- if (FS.isDir(node.mode)) {
112391
- attr.size = 4096;
112392
- } else if (FS.isFile(node.mode)) {
112393
- attr.size = node.usedBytes;
112394
- } else if (FS.isLink(node.mode)) {
112395
- attr.size = node.link.length;
112396
- } else {
112397
- attr.size = 0;
112398
- }
112399
- attr.atime = new Date(node.atime);
112400
- attr.mtime = new Date(node.mtime);
112401
- attr.ctime = new Date(node.ctime);
112402
- attr.blksize = 4096;
112403
- attr.blocks = Math.ceil(attr.size / attr.blksize);
112404
- return attr;
112405
- }, setattr(node, attr) {
112406
- for (const key of ["mode", "atime", "mtime", "ctime"]) {
112407
- if (attr[key] != null) {
112408
- node[key] = attr[key];
112409
- }
112410
- }
112411
- if (attr.size !== void 0) {
112412
- MEMFS.resizeFileStorage(node, attr.size);
112413
- }
112414
- }, lookup(parent, name) {
112415
- throw MEMFS.doesNotExistError;
112416
- }, mknod(parent, name, mode, dev) {
112417
- return MEMFS.createNode(parent, name, mode, dev);
112418
- }, rename(old_node, new_dir, new_name) {
112419
- var new_node;
112420
- try {
112421
- new_node = FS.lookupNode(new_dir, new_name);
112422
- } catch (e) {
112423
- }
112424
- if (new_node) {
112425
- if (FS.isDir(old_node.mode)) {
112426
- for (var i in new_node.contents) {
112427
- throw new FS.ErrnoError(55);
112428
- }
112429
- }
112430
- FS.hashRemoveNode(new_node);
112431
- }
112432
- delete old_node.parent.contents[old_node.name];
112433
- new_dir.contents[new_name] = old_node;
112434
- old_node.name = new_name;
112435
- new_dir.ctime = new_dir.mtime = old_node.parent.ctime = old_node.parent.mtime = Date.now();
112436
- }, unlink(parent, name) {
112437
- delete parent.contents[name];
112438
- parent.ctime = parent.mtime = Date.now();
112439
- }, rmdir(parent, name) {
112440
- var node = FS.lookupNode(parent, name);
112441
- for (var i in node.contents) {
112442
- throw new FS.ErrnoError(55);
112443
- }
112444
- delete parent.contents[name];
112445
- parent.ctime = parent.mtime = Date.now();
112446
- }, readdir(node) {
112447
- return [".", "..", ...Object.keys(node.contents)];
112448
- }, symlink(parent, newname, oldpath) {
112449
- var node = MEMFS.createNode(parent, newname, 511 | 40960, 0);
112450
- node.link = oldpath;
112451
- return node;
112452
- }, readlink(node) {
112453
- if (!FS.isLink(node.mode)) {
112454
- throw new FS.ErrnoError(28);
112455
- }
112456
- return node.link;
112457
- } }, stream_ops: { read(stream, buffer, offset, length, position) {
112458
- var contents = stream.node.contents;
112459
- if (position >= stream.node.usedBytes)
112460
- return 0;
112461
- var size = Math.min(stream.node.usedBytes - position, length);
112462
- if (size > 8 && contents.subarray) {
112463
- buffer.set(contents.subarray(position, position + size), offset);
112464
- } else {
112465
- for (var i = 0; i < size; i++)
112466
- buffer[offset + i] = contents[position + i];
112467
- }
112468
- return size;
112469
- }, write(stream, buffer, offset, length, position, canOwn) {
112470
- if (buffer.buffer === HEAP8.buffer) {
112471
- canOwn = false;
112472
- }
112473
- if (!length)
112474
- return 0;
112475
- var node = stream.node;
112476
- node.mtime = node.ctime = Date.now();
112477
- if (buffer.subarray && (!node.contents || node.contents.subarray)) {
112478
- if (canOwn) {
112479
- node.contents = buffer.subarray(offset, offset + length);
112480
- node.usedBytes = length;
112481
- return length;
112482
- } else if (node.usedBytes === 0 && position === 0) {
112483
- node.contents = buffer.slice(offset, offset + length);
112484
- node.usedBytes = length;
112485
- return length;
112486
- } else if (position + length <= node.usedBytes) {
112487
- node.contents.set(buffer.subarray(offset, offset + length), position);
112488
- return length;
112489
- }
112490
- }
112491
- MEMFS.expandFileStorage(node, position + length);
112492
- if (node.contents.subarray && buffer.subarray) {
112493
- node.contents.set(buffer.subarray(offset, offset + length), position);
112494
- } else {
112495
- for (var i = 0; i < length; i++) {
112496
- node.contents[position + i] = buffer[offset + i];
112497
- }
112498
- }
112499
- node.usedBytes = Math.max(node.usedBytes, position + length);
112500
- return length;
112501
- }, llseek(stream, offset, whence) {
112502
- var position = offset;
112503
- if (whence === 1) {
112504
- position += stream.position;
112505
- } else if (whence === 2) {
112506
- if (FS.isFile(stream.node.mode)) {
112507
- position += stream.node.usedBytes;
112508
- }
112509
- }
112510
- if (position < 0) {
112511
- throw new FS.ErrnoError(28);
112512
- }
112513
- return position;
112514
- }, mmap(stream, length, position, prot, flags) {
112515
- if (!FS.isFile(stream.node.mode)) {
112516
- throw new FS.ErrnoError(43);
112517
- }
112518
- var ptr;
112519
- var allocated;
112520
- var contents = stream.node.contents;
112521
- if (!(flags & 2) && contents && contents.buffer === HEAP8.buffer) {
112522
- allocated = false;
112523
- ptr = contents.byteOffset;
112524
- } else {
112525
- allocated = true;
112526
- ptr = mmapAlloc();
112527
- if (!ptr) {
112528
- throw new FS.ErrnoError(48);
112529
- }
112530
- if (contents) {
112531
- if (position > 0 || position + length < contents.length) {
112532
- if (contents.subarray) {
112533
- contents = contents.subarray(position, position + length);
112534
- } else {
112535
- contents = Array.prototype.slice.call(contents, position, position + length);
112536
- }
112537
- }
112538
- HEAP8.set(contents, ptr);
112539
- }
112540
- }
112541
- return { ptr, allocated };
112542
- }, msync(stream, buffer, offset, length, mmapFlags) {
112543
- MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false);
112544
- return 0;
112545
- } } };
112546
- var asyncLoad = async (url) => {
112547
- var arrayBuffer = await readAsync(url);
112548
- return new Uint8Array(arrayBuffer);
112549
- };
112550
- asyncLoad.isAsync = true;
112551
- var FS_createDataFile = (...args) => FS.createDataFile(...args);
112552
- var preloadPlugins = [];
112553
- var FS_handledByPreloadPlugin = (byteArray, fullname, finish, onerror) => {
112554
- if (typeof Browser != "undefined")
112555
- Browser.init();
112556
- var handled = false;
112557
- preloadPlugins.forEach((plugin) => {
112558
- if (handled)
112559
- return;
112560
- if (plugin["canHandle"](fullname)) {
112561
- plugin["handle"](byteArray, fullname, finish, onerror);
112562
- handled = true;
112563
- }
112564
- });
112565
- return handled;
112566
- };
112567
- var FS_createPreloadedFile = (parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn, preFinish) => {
112568
- var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent;
112569
- function processData(byteArray) {
112570
- function finish(byteArray2) {
112571
- preFinish?.();
112572
- if (!dontCreateFile) {
112573
- FS_createDataFile(parent, name, byteArray2, canRead, canWrite, canOwn);
112574
- }
112575
- onload?.();
112576
- removeRunDependency();
112577
- }
112578
- if (FS_handledByPreloadPlugin(byteArray, fullname, finish, () => {
112579
- onerror?.();
112580
- removeRunDependency();
112581
- })) {
112582
- return;
112583
- }
112584
- finish(byteArray);
112585
- }
112586
- addRunDependency();
112587
- if (typeof url == "string") {
112588
- asyncLoad(url).then(processData, onerror);
112589
- } else {
112590
- processData(url);
112591
- }
112592
- };
112593
- var FS_modeStringToFlags = (str) => {
112594
- var flagModes = { r: 0, "r+": 2, w: 512 | 64 | 1, "w+": 512 | 64 | 2, a: 1024 | 64 | 1, "a+": 1024 | 64 | 2 };
112595
- var flags = flagModes[str];
112596
- if (typeof flags == "undefined") {
112597
- throw new Error(`Unknown file open mode: ${str}`);
112598
- }
112599
- return flags;
112600
- };
112601
- var FS_getMode = (canRead, canWrite) => {
112602
- var mode = 0;
112603
- if (canRead)
112604
- mode |= 292 | 73;
112605
- if (canWrite)
112606
- mode |= 146;
112607
- return mode;
112608
- };
112609
- var FS = { root: null, mounts: [], devices: {}, streams: [], nextInode: 1, nameTable: null, currentPath: "/", initialized: false, ignorePermissions: true, filesystems: null, syncFSRequests: 0, readFiles: {}, ErrnoError: class {
112610
- constructor(errno) {
112611
- __publicField$2(this, "name", "ErrnoError");
112612
- this.errno = errno;
112613
- }
112614
- }, FSStream: class {
112615
- constructor() {
112616
- __publicField$2(this, "shared", {});
112617
- }
112618
- get object() {
112619
- return this.node;
112620
- }
112621
- set object(val) {
112622
- this.node = val;
112623
- }
112624
- get isRead() {
112625
- return (this.flags & 2097155) !== 1;
112626
- }
112627
- get isWrite() {
112628
- return (this.flags & 2097155) !== 0;
112629
- }
112630
- get isAppend() {
112631
- return this.flags & 1024;
112632
- }
112633
- get flags() {
112634
- return this.shared.flags;
112635
- }
112636
- set flags(val) {
112637
- this.shared.flags = val;
112638
- }
112639
- get position() {
112640
- return this.shared.position;
112641
- }
112642
- set position(val) {
112643
- this.shared.position = val;
112644
- }
112645
- }, FSNode: class {
112646
- constructor(parent, name, mode, rdev) {
112647
- __publicField$2(this, "node_ops", {});
112648
- __publicField$2(this, "stream_ops", {});
112649
- __publicField$2(this, "readMode", 292 | 73);
112650
- __publicField$2(this, "writeMode", 146);
112651
- __publicField$2(this, "mounted", null);
112652
- if (!parent) {
112653
- parent = this;
112654
- }
112655
- this.parent = parent;
112656
- this.mount = parent.mount;
112657
- this.id = FS.nextInode++;
112658
- this.name = name;
112659
- this.mode = mode;
112660
- this.rdev = rdev;
112661
- this.atime = this.mtime = this.ctime = Date.now();
112662
- }
112663
- get read() {
112664
- return (this.mode & this.readMode) === this.readMode;
112665
- }
112666
- set read(val) {
112667
- val ? this.mode |= this.readMode : this.mode &= ~this.readMode;
112668
- }
112669
- get write() {
112670
- return (this.mode & this.writeMode) === this.writeMode;
112671
- }
112672
- set write(val) {
112673
- val ? this.mode |= this.writeMode : this.mode &= ~this.writeMode;
112674
- }
112675
- get isFolder() {
112676
- return FS.isDir(this.mode);
112677
- }
112678
- get isDevice() {
112679
- return FS.isChrdev(this.mode);
112680
- }
112681
- }, lookupPath(path, opts = {}) {
112682
- if (!path) {
112683
- throw new FS.ErrnoError(44);
112684
- }
112685
- opts.follow_mount ?? (opts.follow_mount = true);
112686
- if (!PATH.isAbs(path)) {
112687
- path = FS.cwd() + "/" + path;
112688
- }
112689
- linkloop:
112690
- for (var nlinks = 0; nlinks < 40; nlinks++) {
112691
- var parts = path.split("/").filter((p) => !!p);
112692
- var current = FS.root;
112693
- var current_path = "/";
112694
- for (var i = 0; i < parts.length; i++) {
112695
- var islast = i === parts.length - 1;
112696
- if (islast && opts.parent) {
112697
- break;
112698
- }
112699
- if (parts[i] === ".") {
112700
- continue;
112701
- }
112702
- if (parts[i] === "..") {
112703
- current_path = PATH.dirname(current_path);
112704
- if (FS.isRoot(current)) {
112705
- path = current_path + "/" + parts.slice(i + 1).join("/");
112706
- continue linkloop;
112707
- } else {
112708
- current = current.parent;
112709
- }
112710
- continue;
112711
- }
112712
- current_path = PATH.join2(current_path, parts[i]);
112713
- try {
112714
- current = FS.lookupNode(current, parts[i]);
112715
- } catch (e) {
112716
- if (e?.errno === 44 && islast && opts.noent_okay) {
112717
- return { path: current_path };
112718
- }
112719
- throw e;
112720
- }
112721
- if (FS.isMountpoint(current) && (!islast || opts.follow_mount)) {
112722
- current = current.mounted.root;
112723
- }
112724
- if (FS.isLink(current.mode) && (!islast || opts.follow)) {
112725
- if (!current.node_ops.readlink) {
112726
- throw new FS.ErrnoError(52);
112727
- }
112728
- var link = current.node_ops.readlink(current);
112729
- if (!PATH.isAbs(link)) {
112730
- link = PATH.dirname(current_path) + "/" + link;
112731
- }
112732
- path = link + "/" + parts.slice(i + 1).join("/");
112733
- continue linkloop;
112734
- }
112735
- }
112736
- return { path: current_path, node: current };
112737
- }
112738
- throw new FS.ErrnoError(32);
112739
- }, getPath(node) {
112740
- var path;
112741
- while (true) {
112742
- if (FS.isRoot(node)) {
112743
- var mount = node.mount.mountpoint;
112744
- if (!path)
112745
- return mount;
112746
- return mount[mount.length - 1] !== "/" ? `${mount}/${path}` : mount + path;
112747
- }
112748
- path = path ? `${node.name}/${path}` : node.name;
112749
- node = node.parent;
112750
- }
112751
- }, hashName(parentid, name) {
112752
- var hash = 0;
112753
- for (var i = 0; i < name.length; i++) {
112754
- hash = (hash << 5) - hash + name.charCodeAt(i) | 0;
112755
- }
112756
- return (parentid + hash >>> 0) % FS.nameTable.length;
112757
- }, hashAddNode(node) {
112758
- var hash = FS.hashName(node.parent.id, node.name);
112759
- node.name_next = FS.nameTable[hash];
112760
- FS.nameTable[hash] = node;
112761
- }, hashRemoveNode(node) {
112762
- var hash = FS.hashName(node.parent.id, node.name);
112763
- if (FS.nameTable[hash] === node) {
112764
- FS.nameTable[hash] = node.name_next;
112765
- } else {
112766
- var current = FS.nameTable[hash];
112767
- while (current) {
112768
- if (current.name_next === node) {
112769
- current.name_next = node.name_next;
112770
- break;
112771
- }
112772
- current = current.name_next;
112773
- }
112774
- }
112775
- }, lookupNode(parent, name) {
112776
- var errCode = FS.mayLookup(parent);
112777
- if (errCode) {
112778
- throw new FS.ErrnoError(errCode);
112779
- }
112780
- var hash = FS.hashName(parent.id, name);
112781
- for (var node = FS.nameTable[hash]; node; node = node.name_next) {
112782
- var nodeName = node.name;
112783
- if (node.parent.id === parent.id && nodeName === name) {
112784
- return node;
112785
- }
112786
- }
112787
- return FS.lookup(parent, name);
112788
- }, createNode(parent, name, mode, rdev) {
112789
- var node = new FS.FSNode(parent, name, mode, rdev);
112790
- FS.hashAddNode(node);
112791
- return node;
112792
- }, destroyNode(node) {
112793
- FS.hashRemoveNode(node);
112794
- }, isRoot(node) {
112795
- return node === node.parent;
112796
- }, isMountpoint(node) {
112797
- return !!node.mounted;
112798
- }, isFile(mode) {
112799
- return (mode & 61440) === 32768;
112800
- }, isDir(mode) {
112801
- return (mode & 61440) === 16384;
112802
- }, isLink(mode) {
112803
- return (mode & 61440) === 40960;
112804
- }, isChrdev(mode) {
112805
- return (mode & 61440) === 8192;
112806
- }, isBlkdev(mode) {
112807
- return (mode & 61440) === 24576;
112808
- }, isFIFO(mode) {
112809
- return (mode & 61440) === 4096;
112810
- }, isSocket(mode) {
112811
- return (mode & 49152) === 49152;
112812
- }, flagsToPermissionString(flag) {
112813
- var perms = ["r", "w", "rw"][flag & 3];
112814
- if (flag & 512) {
112815
- perms += "w";
112816
- }
112817
- return perms;
112818
- }, nodePermissions(node, perms) {
112819
- if (FS.ignorePermissions) {
112820
- return 0;
112821
- }
112822
- if (perms.includes("r") && !(node.mode & 292)) {
112823
- return 2;
112824
- } else if (perms.includes("w") && !(node.mode & 146)) {
112825
- return 2;
112826
- } else if (perms.includes("x") && !(node.mode & 73)) {
112827
- return 2;
112828
- }
112829
- return 0;
112830
- }, mayLookup(dir) {
112831
- if (!FS.isDir(dir.mode))
112832
- return 54;
112833
- var errCode = FS.nodePermissions(dir, "x");
112834
- if (errCode)
112835
- return errCode;
112836
- if (!dir.node_ops.lookup)
112837
- return 2;
112838
- return 0;
112839
- }, mayCreate(dir, name) {
112840
- if (!FS.isDir(dir.mode)) {
112841
- return 54;
112842
- }
112843
- try {
112844
- var node = FS.lookupNode(dir, name);
112845
- return 20;
112846
- } catch (e) {
112847
- }
112848
- return FS.nodePermissions(dir, "wx");
112849
- }, mayDelete(dir, name, isdir) {
112850
- var node;
112851
- try {
112852
- node = FS.lookupNode(dir, name);
112853
- } catch (e) {
112854
- return e.errno;
112855
- }
112856
- var errCode = FS.nodePermissions(dir, "wx");
112857
- if (errCode) {
112858
- return errCode;
112859
- }
112860
- if (isdir) {
112861
- if (!FS.isDir(node.mode)) {
112862
- return 54;
112863
- }
112864
- if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) {
112865
- return 10;
112866
- }
112867
- } else {
112868
- if (FS.isDir(node.mode)) {
112869
- return 31;
112870
- }
112871
- }
112872
- return 0;
112873
- }, mayOpen(node, flags) {
112874
- if (!node) {
112875
- return 44;
112876
- }
112877
- if (FS.isLink(node.mode)) {
112878
- return 32;
112879
- } else if (FS.isDir(node.mode)) {
112880
- if (FS.flagsToPermissionString(flags) !== "r" || flags & (512 | 64)) {
112881
- return 31;
112882
- }
112883
- }
112884
- return FS.nodePermissions(node, FS.flagsToPermissionString(flags));
112885
- }, checkOpExists(op, err2) {
112886
- if (!op) {
112887
- throw new FS.ErrnoError(err2);
112888
- }
112889
- return op;
112890
- }, MAX_OPEN_FDS: 4096, nextfd() {
112891
- for (var fd = 0; fd <= FS.MAX_OPEN_FDS; fd++) {
112892
- if (!FS.streams[fd]) {
112893
- return fd;
112894
- }
112895
- }
112896
- throw new FS.ErrnoError(33);
112897
- }, getStreamChecked(fd) {
112898
- var stream = FS.getStream(fd);
112899
- if (!stream) {
112900
- throw new FS.ErrnoError(8);
112901
- }
112902
- return stream;
112903
- }, getStream: (fd) => FS.streams[fd], createStream(stream, fd = -1) {
112904
- stream = Object.assign(new FS.FSStream(), stream);
112905
- if (fd == -1) {
112906
- fd = FS.nextfd();
112907
- }
112908
- stream.fd = fd;
112909
- FS.streams[fd] = stream;
112910
- return stream;
112911
- }, closeStream(fd) {
112912
- FS.streams[fd] = null;
112913
- }, dupStream(origStream, fd = -1) {
112914
- var stream = FS.createStream(origStream, fd);
112915
- stream.stream_ops?.dup?.(stream);
112916
- return stream;
112917
- }, doSetAttr(stream, node, attr) {
112918
- var setattr = stream?.stream_ops.setattr;
112919
- var arg = setattr ? stream : node;
112920
- setattr ?? (setattr = node.node_ops.setattr);
112921
- FS.checkOpExists(setattr, 63);
112922
- setattr(arg, attr);
112923
- }, chrdev_stream_ops: { open(stream) {
112924
- var device = FS.getDevice(stream.node.rdev);
112925
- stream.stream_ops = device.stream_ops;
112926
- stream.stream_ops.open?.(stream);
112927
- }, llseek() {
112928
- throw new FS.ErrnoError(70);
112929
- } }, major: (dev) => dev >> 8, minor: (dev) => dev & 255, makedev: (ma, mi) => ma << 8 | mi, registerDevice(dev, ops) {
112930
- FS.devices[dev] = { stream_ops: ops };
112931
- }, getDevice: (dev) => FS.devices[dev], getMounts(mount) {
112932
- var mounts = [];
112933
- var check = [mount];
112934
- while (check.length) {
112935
- var m = check.pop();
112936
- mounts.push(m);
112937
- check.push(...m.mounts);
112938
- }
112939
- return mounts;
112940
- }, syncfs(populate, callback) {
112941
- if (typeof populate == "function") {
112942
- callback = populate;
112943
- populate = false;
112944
- }
112945
- FS.syncFSRequests++;
112946
- if (FS.syncFSRequests > 1) {
112947
- err(`warning: ${FS.syncFSRequests} FS.syncfs operations in flight at once, probably just doing extra work`);
112948
- }
112949
- var mounts = FS.getMounts(FS.root.mount);
112950
- var completed = 0;
112951
- function doCallback(errCode) {
112952
- FS.syncFSRequests--;
112953
- return callback(errCode);
112954
- }
112955
- function done(errCode) {
112956
- if (errCode) {
112957
- if (!done.errored) {
112958
- done.errored = true;
112959
- return doCallback(errCode);
112960
- }
112961
- return;
112962
- }
112963
- if (++completed >= mounts.length) {
112964
- doCallback(null);
112965
- }
112966
- }
112967
- mounts.forEach((mount) => {
112968
- if (!mount.type.syncfs) {
112969
- return done(null);
112970
- }
112971
- mount.type.syncfs(mount, populate, done);
112972
- });
112973
- }, mount(type, opts, mountpoint) {
112974
- var root = mountpoint === "/";
112975
- var pseudo = !mountpoint;
112976
- var node;
112977
- if (root && FS.root) {
112978
- throw new FS.ErrnoError(10);
112979
- } else if (!root && !pseudo) {
112980
- var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
112981
- mountpoint = lookup.path;
112982
- node = lookup.node;
112983
- if (FS.isMountpoint(node)) {
112984
- throw new FS.ErrnoError(10);
112985
- }
112986
- if (!FS.isDir(node.mode)) {
112987
- throw new FS.ErrnoError(54);
112988
- }
112989
- }
112990
- var mount = { type, opts, mountpoint, mounts: [] };
112991
- var mountRoot = type.mount(mount);
112992
- mountRoot.mount = mount;
112993
- mount.root = mountRoot;
112994
- if (root) {
112995
- FS.root = mountRoot;
112996
- } else if (node) {
112997
- node.mounted = mount;
112998
- if (node.mount) {
112999
- node.mount.mounts.push(mount);
113000
- }
113001
- }
113002
- return mountRoot;
113003
- }, unmount(mountpoint) {
113004
- var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
113005
- if (!FS.isMountpoint(lookup.node)) {
113006
- throw new FS.ErrnoError(28);
113007
- }
113008
- var node = lookup.node;
113009
- var mount = node.mounted;
113010
- var mounts = FS.getMounts(mount);
113011
- Object.keys(FS.nameTable).forEach((hash) => {
113012
- var current = FS.nameTable[hash];
113013
- while (current) {
113014
- var next = current.name_next;
113015
- if (mounts.includes(current.mount)) {
113016
- FS.destroyNode(current);
113017
- }
113018
- current = next;
113019
- }
113020
- });
113021
- node.mounted = null;
113022
- var idx = node.mount.mounts.indexOf(mount);
113023
- node.mount.mounts.splice(idx, 1);
113024
- }, lookup(parent, name) {
113025
- return parent.node_ops.lookup(parent, name);
113026
- }, mknod(path, mode, dev) {
113027
- var lookup = FS.lookupPath(path, { parent: true });
113028
- var parent = lookup.node;
113029
- var name = PATH.basename(path);
113030
- if (!name) {
113031
- throw new FS.ErrnoError(28);
113032
- }
113033
- if (name === "." || name === "..") {
113034
- throw new FS.ErrnoError(20);
113035
- }
113036
- var errCode = FS.mayCreate(parent, name);
113037
- if (errCode) {
113038
- throw new FS.ErrnoError(errCode);
113039
- }
113040
- if (!parent.node_ops.mknod) {
113041
- throw new FS.ErrnoError(63);
113042
- }
113043
- return parent.node_ops.mknod(parent, name, mode, dev);
113044
- }, statfs(path) {
113045
- return FS.statfsNode(FS.lookupPath(path, { follow: true }).node);
113046
- }, statfsStream(stream) {
113047
- return FS.statfsNode(stream.node);
113048
- }, statfsNode(node) {
113049
- var rtn = { bsize: 4096, frsize: 4096, blocks: 1e6, bfree: 5e5, bavail: 5e5, files: FS.nextInode, ffree: FS.nextInode - 1, fsid: 42, flags: 2, namelen: 255 };
113050
- if (node.node_ops.statfs) {
113051
- Object.assign(rtn, node.node_ops.statfs(node.mount.opts.root));
113052
- }
113053
- return rtn;
113054
- }, create(path, mode = 438) {
113055
- mode &= 4095;
113056
- mode |= 32768;
113057
- return FS.mknod(path, mode, 0);
113058
- }, mkdir(path, mode = 511) {
113059
- mode &= 511 | 512;
113060
- mode |= 16384;
113061
- return FS.mknod(path, mode, 0);
113062
- }, mkdirTree(path, mode) {
113063
- var dirs = path.split("/");
113064
- var d = "";
113065
- for (var dir of dirs) {
113066
- if (!dir)
113067
- continue;
113068
- if (d || PATH.isAbs(path))
113069
- d += "/";
113070
- d += dir;
113071
- try {
113072
- FS.mkdir(d, mode);
113073
- } catch (e) {
113074
- if (e.errno != 20)
113075
- throw e;
113076
- }
113077
- }
113078
- }, mkdev(path, mode, dev) {
113079
- if (typeof dev == "undefined") {
113080
- dev = mode;
113081
- mode = 438;
113082
- }
113083
- mode |= 8192;
113084
- return FS.mknod(path, mode, dev);
113085
- }, symlink(oldpath, newpath) {
113086
- if (!PATH_FS.resolve(oldpath)) {
113087
- throw new FS.ErrnoError(44);
113088
- }
113089
- var lookup = FS.lookupPath(newpath, { parent: true });
113090
- var parent = lookup.node;
113091
- if (!parent) {
113092
- throw new FS.ErrnoError(44);
113093
- }
113094
- var newname = PATH.basename(newpath);
113095
- var errCode = FS.mayCreate(parent, newname);
113096
- if (errCode) {
113097
- throw new FS.ErrnoError(errCode);
113098
- }
113099
- if (!parent.node_ops.symlink) {
113100
- throw new FS.ErrnoError(63);
113101
- }
113102
- return parent.node_ops.symlink(parent, newname, oldpath);
113103
- }, rename(old_path, new_path) {
113104
- var old_dirname = PATH.dirname(old_path);
113105
- var new_dirname = PATH.dirname(new_path);
113106
- var old_name = PATH.basename(old_path);
113107
- var new_name = PATH.basename(new_path);
113108
- var lookup, old_dir, new_dir;
113109
- lookup = FS.lookupPath(old_path, { parent: true });
113110
- old_dir = lookup.node;
113111
- lookup = FS.lookupPath(new_path, { parent: true });
113112
- new_dir = lookup.node;
113113
- if (!old_dir || !new_dir)
113114
- throw new FS.ErrnoError(44);
113115
- if (old_dir.mount !== new_dir.mount) {
113116
- throw new FS.ErrnoError(75);
113117
- }
113118
- var old_node = FS.lookupNode(old_dir, old_name);
113119
- var relative = PATH_FS.relative(old_path, new_dirname);
113120
- if (relative.charAt(0) !== ".") {
113121
- throw new FS.ErrnoError(28);
113122
- }
113123
- relative = PATH_FS.relative(new_path, old_dirname);
113124
- if (relative.charAt(0) !== ".") {
113125
- throw new FS.ErrnoError(55);
113126
- }
113127
- var new_node;
113128
- try {
113129
- new_node = FS.lookupNode(new_dir, new_name);
113130
- } catch (e) {
113131
- }
113132
- if (old_node === new_node) {
113133
- return;
113134
- }
113135
- var isdir = FS.isDir(old_node.mode);
113136
- var errCode = FS.mayDelete(old_dir, old_name, isdir);
113137
- if (errCode) {
113138
- throw new FS.ErrnoError(errCode);
113139
- }
113140
- errCode = new_node ? FS.mayDelete(new_dir, new_name, isdir) : FS.mayCreate(new_dir, new_name);
113141
- if (errCode) {
113142
- throw new FS.ErrnoError(errCode);
113143
- }
113144
- if (!old_dir.node_ops.rename) {
113145
- throw new FS.ErrnoError(63);
113146
- }
113147
- if (FS.isMountpoint(old_node) || new_node && FS.isMountpoint(new_node)) {
113148
- throw new FS.ErrnoError(10);
113149
- }
113150
- if (new_dir !== old_dir) {
113151
- errCode = FS.nodePermissions(old_dir, "w");
113152
- if (errCode) {
113153
- throw new FS.ErrnoError(errCode);
113154
- }
113155
- }
113156
- FS.hashRemoveNode(old_node);
113157
- try {
113158
- old_dir.node_ops.rename(old_node, new_dir, new_name);
113159
- old_node.parent = new_dir;
113160
- } catch (e) {
113161
- throw e;
113162
- } finally {
113163
- FS.hashAddNode(old_node);
113164
- }
113165
- }, rmdir(path) {
113166
- var lookup = FS.lookupPath(path, { parent: true });
113167
- var parent = lookup.node;
113168
- var name = PATH.basename(path);
113169
- var node = FS.lookupNode(parent, name);
113170
- var errCode = FS.mayDelete(parent, name, true);
113171
- if (errCode) {
113172
- throw new FS.ErrnoError(errCode);
113173
- }
113174
- if (!parent.node_ops.rmdir) {
113175
- throw new FS.ErrnoError(63);
113176
- }
113177
- if (FS.isMountpoint(node)) {
113178
- throw new FS.ErrnoError(10);
113179
- }
113180
- parent.node_ops.rmdir(parent, name);
113181
- FS.destroyNode(node);
113182
- }, readdir(path) {
113183
- var lookup = FS.lookupPath(path, { follow: true });
113184
- var node = lookup.node;
113185
- var readdir = FS.checkOpExists(node.node_ops.readdir, 54);
113186
- return readdir(node);
113187
- }, unlink(path) {
113188
- var lookup = FS.lookupPath(path, { parent: true });
113189
- var parent = lookup.node;
113190
- if (!parent) {
113191
- throw new FS.ErrnoError(44);
113192
- }
113193
- var name = PATH.basename(path);
113194
- var node = FS.lookupNode(parent, name);
113195
- var errCode = FS.mayDelete(parent, name, false);
113196
- if (errCode) {
113197
- throw new FS.ErrnoError(errCode);
113198
- }
113199
- if (!parent.node_ops.unlink) {
113200
- throw new FS.ErrnoError(63);
113201
- }
113202
- if (FS.isMountpoint(node)) {
113203
- throw new FS.ErrnoError(10);
113204
- }
113205
- parent.node_ops.unlink(parent, name);
113206
- FS.destroyNode(node);
113207
- }, readlink(path) {
113208
- var lookup = FS.lookupPath(path);
113209
- var link = lookup.node;
113210
- if (!link) {
113211
- throw new FS.ErrnoError(44);
113212
- }
113213
- if (!link.node_ops.readlink) {
113214
- throw new FS.ErrnoError(28);
113215
- }
113216
- return link.node_ops.readlink(link);
113217
- }, stat(path, dontFollow) {
113218
- var lookup = FS.lookupPath(path, { follow: !dontFollow });
113219
- var node = lookup.node;
113220
- var getattr = FS.checkOpExists(node.node_ops.getattr, 63);
113221
- return getattr(node);
113222
- }, fstat(fd) {
113223
- var stream = FS.getStreamChecked(fd);
113224
- var node = stream.node;
113225
- var getattr = stream.stream_ops.getattr;
113226
- var arg = getattr ? stream : node;
113227
- getattr ?? (getattr = node.node_ops.getattr);
113228
- FS.checkOpExists(getattr, 63);
113229
- return getattr(arg);
113230
- }, lstat(path) {
113231
- return FS.stat(path, true);
113232
- }, doChmod(stream, node, mode, dontFollow) {
113233
- FS.doSetAttr(stream, node, { mode: mode & 4095 | node.mode & ~4095, ctime: Date.now(), dontFollow });
113234
- }, chmod(path, mode, dontFollow) {
113235
- var node;
113236
- if (typeof path == "string") {
113237
- var lookup = FS.lookupPath(path, { follow: !dontFollow });
113238
- node = lookup.node;
113239
- } else {
113240
- node = path;
113241
- }
113242
- FS.doChmod(null, node, mode, dontFollow);
113243
- }, lchmod(path, mode) {
113244
- FS.chmod(path, mode, true);
113245
- }, fchmod(fd, mode) {
113246
- var stream = FS.getStreamChecked(fd);
113247
- FS.doChmod(stream, stream.node, mode, false);
113248
- }, doChown(stream, node, dontFollow) {
113249
- FS.doSetAttr(stream, node, { timestamp: Date.now(), dontFollow });
113250
- }, chown(path, uid, gid, dontFollow) {
113251
- var node;
113252
- if (typeof path == "string") {
113253
- var lookup = FS.lookupPath(path, { follow: !dontFollow });
113254
- node = lookup.node;
113255
- } else {
113256
- node = path;
113257
- }
113258
- FS.doChown(null, node, dontFollow);
113259
- }, lchown(path, uid, gid) {
113260
- FS.chown(path, uid, gid, true);
113261
- }, fchown(fd, uid, gid) {
113262
- var stream = FS.getStreamChecked(fd);
113263
- FS.doChown(stream, stream.node, false);
113264
- }, doTruncate(stream, node, len) {
113265
- if (FS.isDir(node.mode)) {
113266
- throw new FS.ErrnoError(31);
113267
- }
113268
- if (!FS.isFile(node.mode)) {
113269
- throw new FS.ErrnoError(28);
113270
- }
113271
- var errCode = FS.nodePermissions(node, "w");
113272
- if (errCode) {
113273
- throw new FS.ErrnoError(errCode);
113274
- }
113275
- FS.doSetAttr(stream, node, { size: len, timestamp: Date.now() });
113276
- }, truncate(path, len) {
113277
- if (len < 0) {
113278
- throw new FS.ErrnoError(28);
113279
- }
113280
- var node;
113281
- if (typeof path == "string") {
113282
- var lookup = FS.lookupPath(path, { follow: true });
113283
- node = lookup.node;
113284
- } else {
113285
- node = path;
113286
- }
113287
- FS.doTruncate(null, node, len);
113288
- }, ftruncate(fd, len) {
113289
- var stream = FS.getStreamChecked(fd);
113290
- if (len < 0 || (stream.flags & 2097155) === 0) {
113291
- throw new FS.ErrnoError(28);
113292
- }
113293
- FS.doTruncate(stream, stream.node, len);
113294
- }, utime(path, atime, mtime) {
113295
- var lookup = FS.lookupPath(path, { follow: true });
113296
- var node = lookup.node;
113297
- var setattr = FS.checkOpExists(node.node_ops.setattr, 63);
113298
- setattr(node, { atime, mtime });
113299
- }, open(path, flags, mode = 438) {
113300
- if (path === "") {
113301
- throw new FS.ErrnoError(44);
113302
- }
113303
- flags = typeof flags == "string" ? FS_modeStringToFlags(flags) : flags;
113304
- if (flags & 64) {
113305
- mode = mode & 4095 | 32768;
113306
- } else {
113307
- mode = 0;
113308
- }
113309
- var node;
113310
- var isDirPath;
113311
- if (typeof path == "object") {
113312
- node = path;
113313
- } else {
113314
- isDirPath = path.endsWith("/");
113315
- var lookup = FS.lookupPath(path, { follow: !(flags & 131072), noent_okay: true });
113316
- node = lookup.node;
113317
- path = lookup.path;
113318
- }
113319
- var created = false;
113320
- if (flags & 64) {
113321
- if (node) {
113322
- if (flags & 128) {
113323
- throw new FS.ErrnoError(20);
113324
- }
113325
- } else if (isDirPath) {
113326
- throw new FS.ErrnoError(31);
113327
- } else {
113328
- node = FS.mknod(path, mode | 511, 0);
113329
- created = true;
113330
- }
113331
- }
113332
- if (!node) {
113333
- throw new FS.ErrnoError(44);
113334
- }
113335
- if (FS.isChrdev(node.mode)) {
113336
- flags &= ~512;
113337
- }
113338
- if (flags & 65536 && !FS.isDir(node.mode)) {
113339
- throw new FS.ErrnoError(54);
113340
- }
113341
- if (!created) {
113342
- var errCode = FS.mayOpen(node, flags);
113343
- if (errCode) {
113344
- throw new FS.ErrnoError(errCode);
113345
- }
113346
- }
113347
- if (flags & 512 && !created) {
113348
- FS.truncate(node, 0);
113349
- }
113350
- flags &= ~(128 | 512 | 131072);
113351
- var stream = FS.createStream({ node, path: FS.getPath(node), flags, seekable: true, position: 0, stream_ops: node.stream_ops, ungotten: [], error: false });
113352
- if (stream.stream_ops.open) {
113353
- stream.stream_ops.open(stream);
113354
- }
113355
- if (created) {
113356
- FS.chmod(node, mode & 511);
113357
- }
113358
- if (Module["logReadFiles"] && !(flags & 1)) {
113359
- if (!(path in FS.readFiles)) {
113360
- FS.readFiles[path] = 1;
113361
- }
113362
- }
113363
- return stream;
113364
- }, close(stream) {
113365
- if (FS.isClosed(stream)) {
113366
- throw new FS.ErrnoError(8);
113367
- }
113368
- if (stream.getdents)
113369
- stream.getdents = null;
113370
- try {
113371
- if (stream.stream_ops.close) {
113372
- stream.stream_ops.close(stream);
113373
- }
113374
- } catch (e) {
113375
- throw e;
113376
- } finally {
113377
- FS.closeStream(stream.fd);
113378
- }
113379
- stream.fd = null;
113380
- }, isClosed(stream) {
113381
- return stream.fd === null;
113382
- }, llseek(stream, offset, whence) {
113383
- if (FS.isClosed(stream)) {
113384
- throw new FS.ErrnoError(8);
113385
- }
113386
- if (!stream.seekable || !stream.stream_ops.llseek) {
113387
- throw new FS.ErrnoError(70);
113388
- }
113389
- if (whence != 0 && whence != 1 && whence != 2) {
113390
- throw new FS.ErrnoError(28);
113391
- }
113392
- stream.position = stream.stream_ops.llseek(stream, offset, whence);
113393
- stream.ungotten = [];
113394
- return stream.position;
113395
- }, read(stream, buffer, offset, length, position) {
113396
- if (length < 0 || position < 0) {
113397
- throw new FS.ErrnoError(28);
113398
- }
113399
- if (FS.isClosed(stream)) {
113400
- throw new FS.ErrnoError(8);
113401
- }
113402
- if ((stream.flags & 2097155) === 1) {
113403
- throw new FS.ErrnoError(8);
113404
- }
113405
- if (FS.isDir(stream.node.mode)) {
113406
- throw new FS.ErrnoError(31);
113407
- }
113408
- if (!stream.stream_ops.read) {
113409
- throw new FS.ErrnoError(28);
113410
- }
113411
- var seeking = typeof position != "undefined";
113412
- if (!seeking) {
113413
- position = stream.position;
113414
- } else if (!stream.seekable) {
113415
- throw new FS.ErrnoError(70);
113416
- }
113417
- var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position);
113418
- if (!seeking)
113419
- stream.position += bytesRead;
113420
- return bytesRead;
113421
- }, write(stream, buffer, offset, length, position, canOwn) {
113422
- if (length < 0 || position < 0) {
113423
- throw new FS.ErrnoError(28);
113424
- }
113425
- if (FS.isClosed(stream)) {
113426
- throw new FS.ErrnoError(8);
113427
- }
113428
- if ((stream.flags & 2097155) === 0) {
113429
- throw new FS.ErrnoError(8);
113430
- }
113431
- if (FS.isDir(stream.node.mode)) {
113432
- throw new FS.ErrnoError(31);
113433
- }
113434
- if (!stream.stream_ops.write) {
113435
- throw new FS.ErrnoError(28);
113436
- }
113437
- if (stream.seekable && stream.flags & 1024) {
113438
- FS.llseek(stream, 0, 2);
113439
- }
113440
- var seeking = typeof position != "undefined";
113441
- if (!seeking) {
113442
- position = stream.position;
113443
- } else if (!stream.seekable) {
113444
- throw new FS.ErrnoError(70);
113445
- }
113446
- var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn);
113447
- if (!seeking)
113448
- stream.position += bytesWritten;
113449
- return bytesWritten;
113450
- }, mmap(stream, length, position, prot, flags) {
113451
- if ((prot & 2) !== 0 && (flags & 2) === 0 && (stream.flags & 2097155) !== 2) {
113452
- throw new FS.ErrnoError(2);
113453
- }
113454
- if ((stream.flags & 2097155) === 1) {
113455
- throw new FS.ErrnoError(2);
113456
- }
113457
- if (!stream.stream_ops.mmap) {
113458
- throw new FS.ErrnoError(43);
113459
- }
113460
- if (!length) {
113461
- throw new FS.ErrnoError(28);
113462
- }
113463
- return stream.stream_ops.mmap(stream, length, position, prot, flags);
113464
- }, msync(stream, buffer, offset, length, mmapFlags) {
113465
- if (!stream.stream_ops.msync) {
113466
- return 0;
113467
- }
113468
- return stream.stream_ops.msync(stream, buffer, offset, length, mmapFlags);
113469
- }, ioctl(stream, cmd, arg) {
113470
- if (!stream.stream_ops.ioctl) {
113471
- throw new FS.ErrnoError(59);
113472
- }
113473
- return stream.stream_ops.ioctl(stream, cmd, arg);
113474
- }, readFile(path, opts = {}) {
113475
- opts.flags = opts.flags || 0;
113476
- opts.encoding = opts.encoding || "binary";
113477
- if (opts.encoding !== "utf8" && opts.encoding !== "binary") {
113478
- throw new Error(`Invalid encoding type "${opts.encoding}"`);
113479
- }
113480
- var ret;
113481
- var stream = FS.open(path, opts.flags);
113482
- var stat = FS.stat(path);
113483
- var length = stat.size;
113484
- var buf = new Uint8Array(length);
113485
- FS.read(stream, buf, 0, length, 0);
113486
- if (opts.encoding === "utf8") {
113487
- ret = UTF8ArrayToString(buf);
113488
- } else if (opts.encoding === "binary") {
113489
- ret = buf;
113490
- }
113491
- FS.close(stream);
113492
- return ret;
113493
- }, writeFile(path, data, opts = {}) {
113494
- opts.flags = opts.flags || 577;
113495
- var stream = FS.open(path, opts.flags, opts.mode);
113496
- if (typeof data == "string") {
113497
- var buf = new Uint8Array(lengthBytesUTF8(data) + 1);
113498
- var actualNumBytes = stringToUTF8Array(data, buf, 0, buf.length);
113499
- FS.write(stream, buf, 0, actualNumBytes, void 0, opts.canOwn);
113500
- } else if (ArrayBuffer.isView(data)) {
113501
- FS.write(stream, data, 0, data.byteLength, void 0, opts.canOwn);
113502
- } else {
113503
- throw new Error("Unsupported data type");
113504
- }
113505
- FS.close(stream);
113506
- }, cwd: () => FS.currentPath, chdir(path) {
113507
- var lookup = FS.lookupPath(path, { follow: true });
113508
- if (lookup.node === null) {
113509
- throw new FS.ErrnoError(44);
113510
- }
113511
- if (!FS.isDir(lookup.node.mode)) {
113512
- throw new FS.ErrnoError(54);
113513
- }
113514
- var errCode = FS.nodePermissions(lookup.node, "x");
113515
- if (errCode) {
113516
- throw new FS.ErrnoError(errCode);
113517
- }
113518
- FS.currentPath = lookup.path;
113519
- }, createDefaultDirectories() {
113520
- FS.mkdir("/tmp");
113521
- FS.mkdir("/home");
113522
- FS.mkdir("/home/web_user");
113523
- }, createDefaultDevices() {
113524
- FS.mkdir("/dev");
113525
- FS.registerDevice(FS.makedev(1, 3), { read: () => 0, write: (stream, buffer, offset, length, pos) => length, llseek: () => 0 });
113526
- FS.mkdev("/dev/null", FS.makedev(1, 3));
113527
- TTY.register(FS.makedev(5, 0), TTY.default_tty_ops);
113528
- TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops);
113529
- FS.mkdev("/dev/tty", FS.makedev(5, 0));
113530
- FS.mkdev("/dev/tty1", FS.makedev(6, 0));
113531
- var randomBuffer = new Uint8Array(1024), randomLeft = 0;
113532
- var randomByte = () => {
113533
- if (randomLeft === 0) {
113534
- randomFill(randomBuffer);
113535
- randomLeft = randomBuffer.byteLength;
113536
- }
113537
- return randomBuffer[--randomLeft];
113538
- };
113539
- FS.createDevice("/dev", "random", randomByte);
113540
- FS.createDevice("/dev", "urandom", randomByte);
113541
- FS.mkdir("/dev/shm");
113542
- FS.mkdir("/dev/shm/tmp");
113543
- }, createSpecialDirectories() {
113544
- FS.mkdir("/proc");
113545
- var proc_self = FS.mkdir("/proc/self");
113546
- FS.mkdir("/proc/self/fd");
113547
- FS.mount({ mount() {
113548
- var node = FS.createNode(proc_self, "fd", 16895, 73);
113549
- node.stream_ops = { llseek: MEMFS.stream_ops.llseek };
113550
- node.node_ops = { lookup(parent, name) {
113551
- var fd = +name;
113552
- var stream = FS.getStreamChecked(fd);
113553
- var ret = { parent: null, mount: { mountpoint: "fake" }, node_ops: { readlink: () => stream.path }, id: fd + 1 };
113554
- ret.parent = ret;
113555
- return ret;
113556
- }, readdir() {
113557
- return Array.from(FS.streams.entries()).filter(([k, v]) => v).map(([k, v]) => k.toString());
113558
- } };
113559
- return node;
113560
- } }, {}, "/proc/self/fd");
113561
- }, createStandardStreams(input, output, error) {
113562
- if (input) {
113563
- FS.createDevice("/dev", "stdin", input);
113564
- } else {
113565
- FS.symlink("/dev/tty", "/dev/stdin");
113566
- }
113567
- if (output) {
113568
- FS.createDevice("/dev", "stdout", null, output);
113569
- } else {
113570
- FS.symlink("/dev/tty", "/dev/stdout");
113571
- }
113572
- if (error) {
113573
- FS.createDevice("/dev", "stderr", null, error);
113574
- } else {
113575
- FS.symlink("/dev/tty1", "/dev/stderr");
113576
- }
113577
- FS.open("/dev/stdin", 0);
113578
- FS.open("/dev/stdout", 1);
113579
- FS.open("/dev/stderr", 1);
113580
- }, staticInit() {
113581
- FS.nameTable = new Array(4096);
113582
- FS.mount(MEMFS, {}, "/");
113583
- FS.createDefaultDirectories();
113584
- FS.createDefaultDevices();
113585
- FS.createSpecialDirectories();
113586
- FS.filesystems = { MEMFS };
113587
- }, init(input, output, error) {
113588
- FS.initialized = true;
113589
- input ?? (input = Module["stdin"]);
113590
- output ?? (output = Module["stdout"]);
113591
- error ?? (error = Module["stderr"]);
113592
- FS.createStandardStreams(input, output, error);
113593
- }, quit() {
113594
- FS.initialized = false;
113595
- for (var stream of FS.streams) {
113596
- if (stream) {
113597
- FS.close(stream);
113598
- }
113599
- }
113600
- }, findObject(path, dontResolveLastLink) {
113601
- var ret = FS.analyzePath(path, dontResolveLastLink);
113602
- if (!ret.exists) {
113603
- return null;
113604
- }
113605
- return ret.object;
113606
- }, analyzePath(path, dontResolveLastLink) {
113607
- try {
113608
- var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
113609
- path = lookup.path;
113610
- } catch (e) {
113611
- }
113612
- var ret = { isRoot: false, exists: false, error: 0, name: null, path: null, object: null, parentExists: false, parentPath: null, parentObject: null };
113613
- try {
113614
- var lookup = FS.lookupPath(path, { parent: true });
113615
- ret.parentExists = true;
113616
- ret.parentPath = lookup.path;
113617
- ret.parentObject = lookup.node;
113618
- ret.name = PATH.basename(path);
113619
- lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
113620
- ret.exists = true;
113621
- ret.path = lookup.path;
113622
- ret.object = lookup.node;
113623
- ret.name = lookup.node.name;
113624
- ret.isRoot = lookup.path === "/";
113625
- } catch (e) {
113626
- ret.error = e.errno;
113627
- }
113628
- return ret;
113629
- }, createPath(parent, path, canRead, canWrite) {
113630
- parent = typeof parent == "string" ? parent : FS.getPath(parent);
113631
- var parts = path.split("/").reverse();
113632
- while (parts.length) {
113633
- var part = parts.pop();
113634
- if (!part)
113635
- continue;
113636
- var current = PATH.join2(parent, part);
113637
- try {
113638
- FS.mkdir(current);
113639
- } catch (e) {
113640
- if (e.errno != 20)
113641
- throw e;
113642
- }
113643
- parent = current;
113644
- }
113645
- return current;
113646
- }, createFile(parent, name, properties, canRead, canWrite) {
113647
- var path = PATH.join2(typeof parent == "string" ? parent : FS.getPath(parent), name);
113648
- var mode = FS_getMode(canRead, canWrite);
113649
- return FS.create(path, mode);
113650
- }, createDataFile(parent, name, data, canRead, canWrite, canOwn) {
113651
- var path = name;
113652
- if (parent) {
113653
- parent = typeof parent == "string" ? parent : FS.getPath(parent);
113654
- path = name ? PATH.join2(parent, name) : parent;
113655
- }
113656
- var mode = FS_getMode(canRead, canWrite);
113657
- var node = FS.create(path, mode);
113658
- if (data) {
113659
- if (typeof data == "string") {
113660
- var arr = new Array(data.length);
113661
- for (var i = 0, len = data.length; i < len; ++i)
113662
- arr[i] = data.charCodeAt(i);
113663
- data = arr;
113664
- }
113665
- FS.chmod(node, mode | 146);
113666
- var stream = FS.open(node, 577);
113667
- FS.write(stream, data, 0, data.length, 0, canOwn);
113668
- FS.close(stream);
113669
- FS.chmod(node, mode);
113670
- }
113671
- }, createDevice(parent, name, input, output) {
113672
- var _a;
113673
- var path = PATH.join2(typeof parent == "string" ? parent : FS.getPath(parent), name);
113674
- var mode = FS_getMode(!!input, !!output);
113675
- (_a = FS.createDevice).major ?? (_a.major = 64);
113676
- var dev = FS.makedev(FS.createDevice.major++, 0);
113677
- FS.registerDevice(dev, { open(stream) {
113678
- stream.seekable = false;
113679
- }, close(stream) {
113680
- if (output?.buffer?.length) {
113681
- output(10);
113682
- }
113683
- }, read(stream, buffer, offset, length, pos) {
113684
- var bytesRead = 0;
113685
- for (var i = 0; i < length; i++) {
113686
- var result;
113687
- try {
113688
- result = input();
113689
- } catch (e) {
113690
- throw new FS.ErrnoError(29);
113691
- }
113692
- if (result === void 0 && bytesRead === 0) {
113693
- throw new FS.ErrnoError(6);
113694
- }
113695
- if (result === null || result === void 0)
113696
- break;
113697
- bytesRead++;
113698
- buffer[offset + i] = result;
113699
- }
113700
- if (bytesRead) {
113701
- stream.node.atime = Date.now();
113702
- }
113703
- return bytesRead;
113704
- }, write(stream, buffer, offset, length, pos) {
113705
- for (var i = 0; i < length; i++) {
113706
- try {
113707
- output(buffer[offset + i]);
113708
- } catch (e) {
113709
- throw new FS.ErrnoError(29);
113710
- }
113711
- }
113712
- if (length) {
113713
- stream.node.mtime = stream.node.ctime = Date.now();
113714
- }
113715
- return i;
113716
- } });
113717
- return FS.mkdev(path, mode, dev);
113718
- }, forceLoadFile(obj) {
113719
- if (obj.isDevice || obj.isFolder || obj.link || obj.contents)
113720
- return true;
113721
- if (typeof XMLHttpRequest != "undefined") {
113722
- throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.");
113723
- } else {
113724
- try {
113725
- obj.contents = readBinary(obj.url);
113726
- obj.usedBytes = obj.contents.length;
113727
- } catch (e) {
113728
- throw new FS.ErrnoError(29);
113729
- }
113730
- }
113731
- }, createLazyFile(parent, name, url, canRead, canWrite) {
113732
- class LazyUint8Array {
113733
- constructor() {
113734
- __publicField$2(this, "lengthKnown", false);
113735
- __publicField$2(this, "chunks", []);
113736
- }
113737
- get(idx) {
113738
- if (idx > this.length - 1 || idx < 0) {
113739
- return void 0;
113740
- }
113741
- var chunkOffset = idx % this.chunkSize;
113742
- var chunkNum = idx / this.chunkSize | 0;
113743
- return this.getter(chunkNum)[chunkOffset];
113744
- }
113745
- setDataGetter(getter) {
113746
- this.getter = getter;
113747
- }
113748
- cacheLength() {
113749
- var xhr = new XMLHttpRequest();
113750
- xhr.open("HEAD", url, false);
113751
- xhr.send(null);
113752
- if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304))
113753
- throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
113754
- var datalength = Number(xhr.getResponseHeader("Content-length"));
113755
- var header;
113756
- var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes";
113757
- var usesGzip = (header = xhr.getResponseHeader("Content-Encoding")) && header === "gzip";
113758
- var chunkSize = 1024 * 1024;
113759
- if (!hasByteServing)
113760
- chunkSize = datalength;
113761
- var doXHR = (from, to) => {
113762
- if (from > to)
113763
- throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!");
113764
- if (to > datalength - 1)
113765
- throw new Error("only " + datalength + " bytes available! programmer error!");
113766
- var xhr2 = new XMLHttpRequest();
113767
- xhr2.open("GET", url, false);
113768
- if (datalength !== chunkSize)
113769
- xhr2.setRequestHeader("Range", "bytes=" + from + "-" + to);
113770
- xhr2.responseType = "arraybuffer";
113771
- if (xhr2.overrideMimeType) {
113772
- xhr2.overrideMimeType("text/plain; charset=x-user-defined");
113773
- }
113774
- xhr2.send(null);
113775
- if (!(xhr2.status >= 200 && xhr2.status < 300 || xhr2.status === 304))
113776
- throw new Error("Couldn't load " + url + ". Status: " + xhr2.status);
113777
- if (xhr2.response !== void 0) {
113778
- return new Uint8Array(xhr2.response || []);
113779
- }
113780
- return intArrayFromString(xhr2.responseText || "", true);
113781
- };
113782
- var lazyArray2 = this;
113783
- lazyArray2.setDataGetter((chunkNum) => {
113784
- var start = chunkNum * chunkSize;
113785
- var end = (chunkNum + 1) * chunkSize - 1;
113786
- end = Math.min(end, datalength - 1);
113787
- if (typeof lazyArray2.chunks[chunkNum] == "undefined") {
113788
- lazyArray2.chunks[chunkNum] = doXHR(start, end);
113789
- }
113790
- if (typeof lazyArray2.chunks[chunkNum] == "undefined")
113791
- throw new Error("doXHR failed!");
113792
- return lazyArray2.chunks[chunkNum];
113793
- });
113794
- if (usesGzip || !datalength) {
113795
- chunkSize = datalength = 1;
113796
- datalength = this.getter(0).length;
113797
- chunkSize = datalength;
113798
- out("LazyFiles on gzip forces download of the whole file when length is accessed");
113799
- }
113800
- this._length = datalength;
113801
- this._chunkSize = chunkSize;
113802
- this.lengthKnown = true;
113803
- }
113804
- get length() {
113805
- if (!this.lengthKnown) {
113806
- this.cacheLength();
113807
- }
113808
- return this._length;
113809
- }
113810
- get chunkSize() {
113811
- if (!this.lengthKnown) {
113812
- this.cacheLength();
113813
- }
113814
- return this._chunkSize;
113815
- }
113816
- }
113817
- if (typeof XMLHttpRequest != "undefined") {
113818
- throw "Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc";
113819
- var lazyArray = new LazyUint8Array();
113820
- var properties = { isDevice: false, contents: lazyArray };
113821
- } else {
113822
- var properties = { isDevice: false, url };
113823
- }
113824
- var node = FS.createFile(parent, name, properties, canRead, canWrite);
113825
- if (properties.contents) {
113826
- node.contents = properties.contents;
113827
- } else if (properties.url) {
113828
- node.contents = null;
113829
- node.url = properties.url;
113830
- }
113831
- Object.defineProperties(node, { usedBytes: { get: function() {
113832
- return this.contents.length;
113833
- } } });
113834
- var stream_ops = {};
113835
- var keys = Object.keys(node.stream_ops);
113836
- keys.forEach((key) => {
113837
- var fn = node.stream_ops[key];
113838
- stream_ops[key] = (...args) => {
113839
- FS.forceLoadFile(node);
113840
- return fn(...args);
113841
- };
113842
- });
113843
- function writeChunks(stream, buffer, offset, length, position) {
113844
- var contents = stream.node.contents;
113845
- if (position >= contents.length)
113846
- return 0;
113847
- var size = Math.min(contents.length - position, length);
113848
- if (contents.slice) {
113849
- for (var i = 0; i < size; i++) {
113850
- buffer[offset + i] = contents[position + i];
113851
- }
113852
- } else {
113853
- for (var i = 0; i < size; i++) {
113854
- buffer[offset + i] = contents.get(position + i);
113855
- }
113856
- }
113857
- return size;
113858
- }
113859
- stream_ops.read = (stream, buffer, offset, length, position) => {
113860
- FS.forceLoadFile(node);
113861
- return writeChunks(stream, buffer, offset, length, position);
113862
- };
113863
- stream_ops.mmap = (stream, length, position, prot, flags) => {
113864
- FS.forceLoadFile(node);
113865
- var ptr = mmapAlloc();
113866
- if (!ptr) {
113867
- throw new FS.ErrnoError(48);
113868
- }
113869
- writeChunks(stream, HEAP8, ptr, length, position);
113870
- return { ptr, allocated: true };
113871
- };
113872
- node.stream_ops = stream_ops;
113873
- return node;
113874
- } };
113875
- var UTF8ToString = (ptr, maxBytesToRead) => ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
113876
- var SYSCALLS = { DEFAULT_POLLMASK: 5, calculateAt(dirfd, path, allowEmpty) {
113877
- if (PATH.isAbs(path)) {
113878
- return path;
113879
- }
113880
- var dir;
113881
- if (dirfd === -100) {
113882
- dir = FS.cwd();
113883
- } else {
113884
- var dirstream = SYSCALLS.getStreamFromFD(dirfd);
113885
- dir = dirstream.path;
113886
- }
113887
- if (path.length == 0) {
113888
- if (!allowEmpty) {
113889
- throw new FS.ErrnoError(44);
113890
- }
113891
- return dir;
113892
- }
113893
- return dir + "/" + path;
113894
- }, writeStat(buf, stat) {
113895
- HEAP32[buf >> 2] = stat.dev;
113896
- HEAP32[buf + 4 >> 2] = stat.mode;
113897
- HEAPU32[buf + 8 >> 2] = stat.nlink;
113898
- HEAP32[buf + 12 >> 2] = stat.uid;
113899
- HEAP32[buf + 16 >> 2] = stat.gid;
113900
- HEAP32[buf + 20 >> 2] = stat.rdev;
113901
- HEAP64[buf + 24 >> 3] = BigInt(stat.size);
113902
- HEAP32[buf + 32 >> 2] = 4096;
113903
- HEAP32[buf + 36 >> 2] = stat.blocks;
113904
- var atime = stat.atime.getTime();
113905
- var mtime = stat.mtime.getTime();
113906
- var ctime = stat.ctime.getTime();
113907
- HEAP64[buf + 40 >> 3] = BigInt(Math.floor(atime / 1e3));
113908
- HEAPU32[buf + 48 >> 2] = atime % 1e3 * 1e3 * 1e3;
113909
- HEAP64[buf + 56 >> 3] = BigInt(Math.floor(mtime / 1e3));
113910
- HEAPU32[buf + 64 >> 2] = mtime % 1e3 * 1e3 * 1e3;
113911
- HEAP64[buf + 72 >> 3] = BigInt(Math.floor(ctime / 1e3));
113912
- HEAPU32[buf + 80 >> 2] = ctime % 1e3 * 1e3 * 1e3;
113913
- HEAP64[buf + 88 >> 3] = BigInt(stat.ino);
113914
- return 0;
113915
- }, writeStatFs(buf, stats) {
113916
- HEAP32[buf + 4 >> 2] = stats.bsize;
113917
- HEAP32[buf + 40 >> 2] = stats.bsize;
113918
- HEAP32[buf + 8 >> 2] = stats.blocks;
113919
- HEAP32[buf + 12 >> 2] = stats.bfree;
113920
- HEAP32[buf + 16 >> 2] = stats.bavail;
113921
- HEAP32[buf + 20 >> 2] = stats.files;
113922
- HEAP32[buf + 24 >> 2] = stats.ffree;
113923
- HEAP32[buf + 28 >> 2] = stats.fsid;
113924
- HEAP32[buf + 44 >> 2] = stats.flags;
113925
- HEAP32[buf + 36 >> 2] = stats.namelen;
113926
- }, doMsync(addr, stream, len, flags, offset) {
113927
- if (!FS.isFile(stream.node.mode)) {
113928
- throw new FS.ErrnoError(43);
113929
- }
113930
- if (flags & 2) {
113931
- return 0;
113932
- }
113933
- var buffer = HEAPU8.slice(addr, addr + len);
113934
- FS.msync(stream, buffer, offset, len, flags);
113935
- }, getStreamFromFD(fd) {
113936
- var stream = FS.getStreamChecked(fd);
113937
- return stream;
113938
- }, varargs: void 0, getStr(ptr) {
113939
- var ret = UTF8ToString(ptr);
113940
- return ret;
113941
- } };
113942
- function ___syscall_fcntl64(fd, cmd, varargs) {
113943
- SYSCALLS.varargs = varargs;
113944
- try {
113945
- var stream = SYSCALLS.getStreamFromFD(fd);
113946
- switch (cmd) {
113947
- case 0: {
113948
- var arg = syscallGetVarargI();
113949
- if (arg < 0) {
113950
- return -28;
113951
- }
113952
- while (FS.streams[arg]) {
113953
- arg++;
113954
- }
113955
- var newStream;
113956
- newStream = FS.dupStream(stream, arg);
113957
- return newStream.fd;
113958
- }
113959
- case 1:
113960
- case 2:
113961
- return 0;
113962
- case 3:
113963
- return stream.flags;
113964
- case 4: {
113965
- var arg = syscallGetVarargI();
113966
- stream.flags |= arg;
113967
- return 0;
113968
- }
113969
- case 12: {
113970
- var arg = syscallGetVarargP();
113971
- var offset = 0;
113972
- HEAP16[arg + offset >> 1] = 2;
113973
- return 0;
113974
- }
113975
- case 13:
113976
- case 14:
113977
- return 0;
113978
- }
113979
- return -28;
113980
- } catch (e) {
113981
- if (typeof FS == "undefined" || !(e.name === "ErrnoError"))
113982
- throw e;
113983
- return -e.errno;
113984
- }
113985
- }
113986
- function ___syscall_ioctl(fd, op, varargs) {
113987
- SYSCALLS.varargs = varargs;
113988
- try {
113989
- var stream = SYSCALLS.getStreamFromFD(fd);
113990
- switch (op) {
113991
- case 21509: {
113992
- if (!stream.tty)
113993
- return -59;
113994
- return 0;
113995
- }
113996
- case 21505: {
113997
- if (!stream.tty)
113998
- return -59;
113999
- if (stream.tty.ops.ioctl_tcgets) {
114000
- var termios = stream.tty.ops.ioctl_tcgets(stream);
114001
- var argp = syscallGetVarargP();
114002
- HEAP32[argp >> 2] = termios.c_iflag || 0;
114003
- HEAP32[argp + 4 >> 2] = termios.c_oflag || 0;
114004
- HEAP32[argp + 8 >> 2] = termios.c_cflag || 0;
114005
- HEAP32[argp + 12 >> 2] = termios.c_lflag || 0;
114006
- for (var i = 0; i < 32; i++) {
114007
- HEAP8[argp + i + 17] = termios.c_cc[i] || 0;
114008
- }
114009
- return 0;
114010
- }
114011
- return 0;
114012
- }
114013
- case 21510:
114014
- case 21511:
114015
- case 21512: {
114016
- if (!stream.tty)
114017
- return -59;
114018
- return 0;
114019
- }
114020
- case 21506:
114021
- case 21507:
114022
- case 21508: {
114023
- if (!stream.tty)
114024
- return -59;
114025
- if (stream.tty.ops.ioctl_tcsets) {
114026
- var argp = syscallGetVarargP();
114027
- var c_iflag = HEAP32[argp >> 2];
114028
- var c_oflag = HEAP32[argp + 4 >> 2];
114029
- var c_cflag = HEAP32[argp + 8 >> 2];
114030
- var c_lflag = HEAP32[argp + 12 >> 2];
114031
- var c_cc = [];
114032
- for (var i = 0; i < 32; i++) {
114033
- c_cc.push(HEAP8[argp + i + 17]);
114034
- }
114035
- return stream.tty.ops.ioctl_tcsets(stream.tty, op, { c_iflag, c_oflag, c_cflag, c_lflag, c_cc });
114036
- }
114037
- return 0;
114038
- }
114039
- case 21519: {
114040
- if (!stream.tty)
114041
- return -59;
114042
- var argp = syscallGetVarargP();
114043
- HEAP32[argp >> 2] = 0;
114044
- return 0;
114045
- }
114046
- case 21520: {
114047
- if (!stream.tty)
114048
- return -59;
114049
- return -28;
114050
- }
114051
- case 21531: {
114052
- var argp = syscallGetVarargP();
114053
- return FS.ioctl(stream, op, argp);
114054
- }
114055
- case 21523: {
114056
- if (!stream.tty)
114057
- return -59;
114058
- if (stream.tty.ops.ioctl_tiocgwinsz) {
114059
- var winsize = stream.tty.ops.ioctl_tiocgwinsz(stream.tty);
114060
- var argp = syscallGetVarargP();
114061
- HEAP16[argp >> 1] = winsize[0];
114062
- HEAP16[argp + 2 >> 1] = winsize[1];
114063
- }
114064
- return 0;
114065
- }
114066
- case 21524: {
114067
- if (!stream.tty)
114068
- return -59;
114069
- return 0;
114070
- }
114071
- case 21515: {
114072
- if (!stream.tty)
114073
- return -59;
114074
- return 0;
114075
- }
114076
- default:
114077
- return -28;
114078
- }
114079
- } catch (e) {
114080
- if (typeof FS == "undefined" || !(e.name === "ErrnoError"))
114081
- throw e;
114082
- return -e.errno;
114083
- }
114084
- }
114085
- function ___syscall_openat(dirfd, path, flags, varargs) {
114086
- SYSCALLS.varargs = varargs;
114087
- try {
114088
- path = SYSCALLS.getStr(path);
114089
- path = SYSCALLS.calculateAt(dirfd, path);
114090
- var mode = varargs ? syscallGetVarargI() : 0;
114091
- return FS.open(path, flags, mode).fd;
114092
- } catch (e) {
114093
- if (typeof FS == "undefined" || !(e.name === "ErrnoError"))
114094
- throw e;
114095
- return -e.errno;
114096
- }
114097
- }
114098
- function ___syscall_renameat(olddirfd, oldpath, newdirfd, newpath) {
114099
- try {
114100
- oldpath = SYSCALLS.getStr(oldpath);
114101
- newpath = SYSCALLS.getStr(newpath);
114102
- oldpath = SYSCALLS.calculateAt(olddirfd, oldpath);
114103
- newpath = SYSCALLS.calculateAt(newdirfd, newpath);
114104
- FS.rename(oldpath, newpath);
114105
- return 0;
114106
- } catch (e) {
114107
- if (typeof FS == "undefined" || !(e.name === "ErrnoError"))
114108
- throw e;
114109
- return -e.errno;
114110
- }
114111
- }
114112
- function ___syscall_rmdir(path) {
114113
- try {
114114
- path = SYSCALLS.getStr(path);
114115
- FS.rmdir(path);
114116
- return 0;
114117
- } catch (e) {
114118
- if (typeof FS == "undefined" || !(e.name === "ErrnoError"))
114119
- throw e;
114120
- return -e.errno;
114121
- }
114122
- }
114123
- function ___syscall_stat64(path, buf) {
114124
- try {
114125
- path = SYSCALLS.getStr(path);
114126
- return SYSCALLS.writeStat(buf, FS.stat(path));
114127
- } catch (e) {
114128
- if (typeof FS == "undefined" || !(e.name === "ErrnoError"))
114129
- throw e;
114130
- return -e.errno;
114131
- }
114132
- }
114133
- function ___syscall_unlinkat(dirfd, path, flags) {
114134
- try {
114135
- path = SYSCALLS.getStr(path);
114136
- path = SYSCALLS.calculateAt(dirfd, path);
114137
- if (!flags) {
114138
- FS.unlink(path);
114139
- } else if (flags === 512) {
114140
- FS.rmdir(path);
114141
- } else {
114142
- return -28;
114143
- }
114144
- return 0;
114145
- } catch (e) {
114146
- if (typeof FS == "undefined" || !(e.name === "ErrnoError"))
114147
- throw e;
114148
- return -e.errno;
114149
- }
114150
- }
114151
- var __abort_js = () => abort("");
114152
- var structRegistrations = {};
114153
- var runDestructors = (destructors) => {
114154
- while (destructors.length) {
114155
- var ptr = destructors.pop();
114156
- var del = destructors.pop();
114157
- del(ptr);
114158
- }
114159
- };
114160
- function readPointer(pointer) {
114161
- return this["fromWireType"](HEAPU32[pointer >> 2]);
114162
- }
114163
- var awaitingDependencies = {};
114164
- var registeredTypes = {};
114165
- var typeDependencies = {};
114166
- var InternalError = class InternalError extends Error {
114167
- constructor(message) {
114168
- super(message);
114169
- this.name = "InternalError";
114170
- }
114171
- };
114172
- var throwInternalError = (message) => {
114173
- throw new InternalError(message);
114174
- };
114175
- var whenDependentTypesAreResolved = (myTypes, dependentTypes, getTypeConverters) => {
114176
- myTypes.forEach((type) => typeDependencies[type] = dependentTypes);
114177
- function onComplete(typeConverters2) {
114178
- var myTypeConverters = getTypeConverters(typeConverters2);
114179
- if (myTypeConverters.length !== myTypes.length) {
114180
- throwInternalError("Mismatched type converter count");
114181
- }
114182
- for (var i = 0; i < myTypes.length; ++i) {
114183
- registerType(myTypes[i], myTypeConverters[i]);
114184
- }
114185
- }
114186
- var typeConverters = new Array(dependentTypes.length);
114187
- var unregisteredTypes = [];
114188
- var registered = 0;
114189
- dependentTypes.forEach((dt, i) => {
114190
- if (registeredTypes.hasOwnProperty(dt)) {
114191
- typeConverters[i] = registeredTypes[dt];
114192
- } else {
114193
- unregisteredTypes.push(dt);
114194
- if (!awaitingDependencies.hasOwnProperty(dt)) {
114195
- awaitingDependencies[dt] = [];
114196
- }
114197
- awaitingDependencies[dt].push(() => {
114198
- typeConverters[i] = registeredTypes[dt];
114199
- ++registered;
114200
- if (registered === unregisteredTypes.length) {
114201
- onComplete(typeConverters);
114202
- }
114203
- });
114204
- }
114205
- });
114206
- if (0 === unregisteredTypes.length) {
114207
- onComplete(typeConverters);
114208
- }
114209
- };
114210
- var __embind_finalize_value_object = (structType) => {
114211
- var reg = structRegistrations[structType];
114212
- delete structRegistrations[structType];
114213
- var rawConstructor = reg.rawConstructor;
114214
- var rawDestructor = reg.rawDestructor;
114215
- var fieldRecords = reg.fields;
114216
- var fieldTypes = fieldRecords.map((field) => field.getterReturnType).concat(fieldRecords.map((field) => field.setterArgumentType));
114217
- whenDependentTypesAreResolved([structType], fieldTypes, (fieldTypes2) => {
114218
- var fields = {};
114219
- fieldRecords.forEach((field, i) => {
114220
- var fieldName = field.fieldName;
114221
- var getterReturnType = fieldTypes2[i];
114222
- var optional = fieldTypes2[i].optional;
114223
- var getter = field.getter;
114224
- var getterContext = field.getterContext;
114225
- var setterArgumentType = fieldTypes2[i + fieldRecords.length];
114226
- var setter = field.setter;
114227
- var setterContext = field.setterContext;
114228
- fields[fieldName] = { read: (ptr) => getterReturnType["fromWireType"](getter(getterContext, ptr)), write: (ptr, o) => {
114229
- var destructors = [];
114230
- setter(setterContext, ptr, setterArgumentType["toWireType"](destructors, o));
114231
- runDestructors(destructors);
114232
- }, optional };
114233
- });
114234
- return [{ name: reg.name, fromWireType: (ptr) => {
114235
- var rv = {};
114236
- for (var i in fields) {
114237
- rv[i] = fields[i].read(ptr);
114238
- }
114239
- rawDestructor(ptr);
114240
- return rv;
114241
- }, toWireType: (destructors, o) => {
114242
- for (var fieldName in fields) {
114243
- if (!(fieldName in o) && !fields[fieldName].optional) {
114244
- throw new TypeError(`Missing field: "${fieldName}"`);
114245
- }
114246
- }
114247
- var ptr = rawConstructor();
114248
- for (fieldName in fields) {
114249
- fields[fieldName].write(ptr, o[fieldName]);
114250
- }
114251
- if (destructors !== null) {
114252
- destructors.push(rawDestructor, ptr);
114253
- }
114254
- return ptr;
114255
- }, argPackAdvance: GenericWireTypeSize, readValueFromPointer: readPointer, destructorFunction: rawDestructor }];
114256
- });
114257
- };
114258
- var embind_init_charCodes = () => {
114259
- var codes = new Array(256);
114260
- for (var i = 0; i < 256; ++i) {
114261
- codes[i] = String.fromCharCode(i);
114262
- }
114263
- embind_charCodes = codes;
114264
- };
114265
- var embind_charCodes;
114266
- var readLatin1String = (ptr) => {
114267
- var ret = "";
114268
- var c = ptr;
114269
- while (HEAPU8[c]) {
114270
- ret += embind_charCodes[HEAPU8[c++]];
114271
- }
114272
- return ret;
114273
- };
114274
- var BindingError = class BindingError extends Error {
114275
- constructor(message) {
114276
- super(message);
114277
- this.name = "BindingError";
114278
- }
114279
- };
114280
- var throwBindingError = (message) => {
114281
- throw new BindingError(message);
114282
- };
114283
- function sharedRegisterType(rawType, registeredInstance, options = {}) {
114284
- var name = registeredInstance.name;
114285
- if (!rawType) {
114286
- throwBindingError(`type "${name}" must have a positive integer typeid pointer`);
114287
- }
114288
- if (registeredTypes.hasOwnProperty(rawType)) {
114289
- if (options.ignoreDuplicateRegistrations) {
114290
- return;
114291
- } else {
114292
- throwBindingError(`Cannot register type '${name}' twice`);
114293
- }
114294
- }
114295
- registeredTypes[rawType] = registeredInstance;
114296
- delete typeDependencies[rawType];
114297
- if (awaitingDependencies.hasOwnProperty(rawType)) {
114298
- var callbacks = awaitingDependencies[rawType];
114299
- delete awaitingDependencies[rawType];
114300
- callbacks.forEach((cb) => cb());
114301
- }
114302
- }
114303
- function registerType(rawType, registeredInstance, options = {}) {
114304
- return sharedRegisterType(rawType, registeredInstance, options);
114305
- }
114306
- var integerReadValueFromPointer = (name, width, signed) => {
114307
- switch (width) {
114308
- case 1:
114309
- return signed ? (pointer) => HEAP8[pointer] : (pointer) => HEAPU8[pointer];
114310
- case 2:
114311
- return signed ? (pointer) => HEAP16[pointer >> 1] : (pointer) => HEAPU16[pointer >> 1];
114312
- case 4:
114313
- return signed ? (pointer) => HEAP32[pointer >> 2] : (pointer) => HEAPU32[pointer >> 2];
114314
- case 8:
114315
- return signed ? (pointer) => HEAP64[pointer >> 3] : (pointer) => HEAPU64[pointer >> 3];
114316
- default:
114317
- throw new TypeError(`invalid integer width (${width}): ${name}`);
114318
- }
114319
- };
114320
- var __embind_register_bigint = (primitiveType, name, size, minRange, maxRange) => {
114321
- name = readLatin1String(name);
114322
- const isUnsignedType = minRange === 0n;
114323
- let fromWireType = (value) => value;
114324
- if (isUnsignedType) {
114325
- const bitSize = size * 8;
114326
- fromWireType = (value) => BigInt.asUintN(bitSize, value);
114327
- maxRange = fromWireType(maxRange);
114328
- }
114329
- registerType(primitiveType, { name, fromWireType, toWireType: (destructors, value) => {
114330
- if (typeof value == "number") {
114331
- value = BigInt(value);
114332
- }
114333
- return value;
114334
- }, argPackAdvance: GenericWireTypeSize, readValueFromPointer: integerReadValueFromPointer(name, size, !isUnsignedType), destructorFunction: null });
114335
- };
114336
- var GenericWireTypeSize = 8;
114337
- var __embind_register_bool = (rawType, name, trueValue, falseValue) => {
114338
- name = readLatin1String(name);
114339
- registerType(rawType, { name, fromWireType: function(wt) {
114340
- return !!wt;
114341
- }, toWireType: function(destructors, o) {
114342
- return o ? trueValue : falseValue;
114343
- }, argPackAdvance: GenericWireTypeSize, readValueFromPointer: function(pointer) {
114344
- return this["fromWireType"](HEAPU8[pointer]);
114345
- }, destructorFunction: null });
114346
- };
114347
- var emval_freelist = [];
114348
- var emval_handles = [0, 1, , 1, null, 1, true, 1, false, 1];
114349
- var __emval_decref = (handle) => {
114350
- if (handle > 9 && 0 === --emval_handles[handle + 1]) {
114351
- emval_handles[handle] = void 0;
114352
- emval_freelist.push(handle);
114353
- }
114354
- };
114355
- var Emval = { toValue: (handle) => {
114356
- if (!handle) {
114357
- throwBindingError(`Cannot use deleted val. handle = ${handle}`);
114358
- }
114359
- return emval_handles[handle];
114360
- }, toHandle: (value) => {
114361
- switch (value) {
114362
- case void 0:
114363
- return 2;
114364
- case null:
114365
- return 4;
114366
- case true:
114367
- return 6;
114368
- case false:
114369
- return 8;
114370
- default: {
114371
- const handle = emval_freelist.pop() || emval_handles.length;
114372
- emval_handles[handle] = value;
114373
- emval_handles[handle + 1] = 1;
114374
- return handle;
114375
- }
114376
- }
114377
- } };
114378
- var EmValType = { name: "emscripten::val", fromWireType: (handle) => {
114379
- var rv = Emval.toValue(handle);
114380
- __emval_decref(handle);
114381
- return rv;
114382
- }, toWireType: (destructors, value) => Emval.toHandle(value), argPackAdvance: GenericWireTypeSize, readValueFromPointer: readPointer, destructorFunction: null };
114383
- var __embind_register_emval = (rawType) => registerType(rawType, EmValType);
114384
- var floatReadValueFromPointer = (name, width) => {
114385
- switch (width) {
114386
- case 4:
114387
- return function(pointer) {
114388
- return this["fromWireType"](HEAPF32[pointer >> 2]);
114389
- };
114390
- case 8:
114391
- return function(pointer) {
114392
- return this["fromWireType"](HEAPF64[pointer >> 3]);
114393
- };
114394
- default:
114395
- throw new TypeError(`invalid float width (${width}): ${name}`);
114396
- }
114397
- };
114398
- var __embind_register_float = (rawType, name, size) => {
114399
- name = readLatin1String(name);
114400
- registerType(rawType, { name, fromWireType: (value) => value, toWireType: (destructors, value) => value, argPackAdvance: GenericWireTypeSize, readValueFromPointer: floatReadValueFromPointer(name, size), destructorFunction: null });
114401
- };
114402
- var createNamedFunction = (name, func) => Object.defineProperty(func, "name", { value: name });
114403
- function usesDestructorStack(argTypes) {
114404
- for (var i = 1; i < argTypes.length; ++i) {
114405
- if (argTypes[i] !== null && argTypes[i].destructorFunction === void 0) {
114406
- return true;
114407
- }
114408
- }
114409
- return false;
114410
- }
114411
- function createJsInvoker(argTypes, isClassMethodFunc, returns, isAsync) {
114412
- var needsDestructorStack = usesDestructorStack(argTypes);
114413
- var argCount = argTypes.length - 2;
114414
- var argsList = [];
114415
- var argsListWired = ["fn"];
114416
- if (isClassMethodFunc) {
114417
- argsListWired.push("thisWired");
114418
- }
114419
- for (var i = 0; i < argCount; ++i) {
114420
- argsList.push(`arg${i}`);
114421
- argsListWired.push(`arg${i}Wired`);
114422
- }
114423
- argsList = argsList.join(",");
114424
- argsListWired = argsListWired.join(",");
114425
- var invokerFnBody = `return function (${argsList}) {
114426
- `;
114427
- if (needsDestructorStack) {
114428
- invokerFnBody += "var destructors = [];\n";
114429
- }
114430
- var dtorStack = needsDestructorStack ? "destructors" : "null";
114431
- var args1 = ["humanName", "throwBindingError", "invoker", "fn", "runDestructors", "retType", "classParam"];
114432
- if (isClassMethodFunc) {
114433
- invokerFnBody += `var thisWired = classParam['toWireType'](${dtorStack}, this);
114434
- `;
114435
- }
114436
- for (var i = 0; i < argCount; ++i) {
114437
- invokerFnBody += `var arg${i}Wired = argType${i}['toWireType'](${dtorStack}, arg${i});
114438
- `;
114439
- args1.push(`argType${i}`);
114440
- }
114441
- invokerFnBody += (returns || isAsync ? "var rv = " : "") + `invoker(${argsListWired});
114442
- `;
114443
- var returnVal = returns ? "rv" : "";
114444
- args1.push("Asyncify");
114445
- invokerFnBody += `function onDone(${returnVal}) {
114446
- `;
114447
- if (needsDestructorStack) {
114448
- invokerFnBody += "runDestructors(destructors);\n";
114449
- } else {
114450
- for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) {
114451
- var paramName = i === 1 ? "thisWired" : "arg" + (i - 2) + "Wired";
114452
- if (argTypes[i].destructorFunction !== null) {
114453
- invokerFnBody += `${paramName}_dtor(${paramName});
114454
- `;
114455
- args1.push(`${paramName}_dtor`);
114456
- }
114457
- }
114458
- }
114459
- if (returns) {
114460
- invokerFnBody += "var ret = retType['fromWireType'](rv);\nreturn ret;\n";
114461
- }
114462
- invokerFnBody += "}\n";
114463
- invokerFnBody += `return Asyncify.currData ? Asyncify.whenDone().then(onDone) : onDone(${returnVal});
114464
- `;
114465
- invokerFnBody += "}\n";
114466
- return [args1, invokerFnBody];
114467
- }
114468
- var runAndAbortIfError = (func) => {
114469
- try {
114470
- return func();
114471
- } catch (e) {
114472
- abort(e);
114473
- }
114474
- };
114475
- var handleException = (e) => {
114476
- if (e instanceof ExitStatus || e == "unwind") {
114477
- return EXITSTATUS;
114478
- }
114479
- quit_(1, e);
114480
- };
114481
- var runtimeKeepaliveCounter = 0;
114482
- var keepRuntimeAlive = () => noExitRuntime || runtimeKeepaliveCounter > 0;
114483
- var _proc_exit = (code) => {
114484
- EXITSTATUS = code;
114485
- if (!keepRuntimeAlive()) {
114486
- Module["onExit"]?.(code);
114487
- ABORT = true;
114488
- }
114489
- quit_(code, new ExitStatus(code));
114490
- };
114491
- var exitJS = (status, implicit) => {
114492
- EXITSTATUS = status;
114493
- _proc_exit(status);
114494
- };
114495
- var _exit = exitJS;
114496
- var maybeExit = () => {
114497
- if (!keepRuntimeAlive()) {
114498
- try {
114499
- _exit(EXITSTATUS);
114500
- } catch (e) {
114501
- handleException(e);
114502
- }
114503
- }
114504
- };
114505
- var callUserCallback = (func) => {
114506
- if (ABORT) {
114507
- return;
114508
- }
114509
- try {
114510
- func();
114511
- maybeExit();
114512
- } catch (e) {
114513
- handleException(e);
114514
- }
114515
- };
114516
- var Asyncify = { instrumentWasmImports(imports) {
114517
- var importPattern = /^(invoke_.*|__asyncjs__.*)$/;
114518
- for (let [x, original] of Object.entries(imports)) {
114519
- if (typeof original == "function") {
114520
- original.isAsync || importPattern.test(x);
114521
- }
114522
- }
114523
- }, instrumentWasmExports(exports) {
114524
- var ret = {};
114525
- for (let [x, original] of Object.entries(exports)) {
114526
- if (typeof original == "function") {
114527
- ret[x] = (...args) => {
114528
- Asyncify.exportCallStack.push(x);
114529
- try {
114530
- return original(...args);
114531
- } finally {
114532
- if (!ABORT) {
114533
- Asyncify.exportCallStack.pop();
114534
- Asyncify.maybeStopUnwind();
114535
- }
114536
- }
114537
- };
114538
- } else {
114539
- ret[x] = original;
114540
- }
114541
- }
114542
- return ret;
114543
- }, State: { Normal: 0, Unwinding: 1, Rewinding: 2, Disabled: 3 }, state: 0, StackSize: 4096, currData: null, handleSleepReturnValue: 0, exportCallStack: [], callStackNameToId: {}, callStackIdToName: {}, callStackId: 0, asyncPromiseHandlers: null, sleepCallbacks: [], getCallStackId(funcName) {
114544
- var id = Asyncify.callStackNameToId[funcName];
114545
- if (id === void 0) {
114546
- id = Asyncify.callStackId++;
114547
- Asyncify.callStackNameToId[funcName] = id;
114548
- Asyncify.callStackIdToName[id] = funcName;
114549
- }
114550
- return id;
114551
- }, maybeStopUnwind() {
114552
- if (Asyncify.currData && Asyncify.state === Asyncify.State.Unwinding && Asyncify.exportCallStack.length === 0) {
114553
- Asyncify.state = Asyncify.State.Normal;
114554
- runAndAbortIfError(_asyncify_stop_unwind);
114555
- if (typeof Fibers != "undefined") {
114556
- Fibers.trampoline();
114557
- }
114558
- }
114559
- }, whenDone() {
114560
- return new Promise((resolve, reject) => {
114561
- Asyncify.asyncPromiseHandlers = { resolve, reject };
114562
- });
114563
- }, allocateData() {
114564
- var ptr = _malloc(12 + Asyncify.StackSize);
114565
- Asyncify.setDataHeader(ptr, ptr + 12, Asyncify.StackSize);
114566
- Asyncify.setDataRewindFunc(ptr);
114567
- return ptr;
114568
- }, setDataHeader(ptr, stack, stackSize) {
114569
- HEAPU32[ptr >> 2] = stack;
114570
- HEAPU32[ptr + 4 >> 2] = stack + stackSize;
114571
- }, setDataRewindFunc(ptr) {
114572
- var bottomOfCallStack = Asyncify.exportCallStack[0];
114573
- var rewindId = Asyncify.getCallStackId(bottomOfCallStack);
114574
- HEAP32[ptr + 8 >> 2] = rewindId;
114575
- }, getDataRewindFuncName(ptr) {
114576
- var id = HEAP32[ptr + 8 >> 2];
114577
- var name = Asyncify.callStackIdToName[id];
114578
- return name;
114579
- }, getDataRewindFunc(name) {
114580
- var func = wasmExports[name];
114581
- return func;
114582
- }, doRewind(ptr) {
114583
- var name = Asyncify.getDataRewindFuncName(ptr);
114584
- var func = Asyncify.getDataRewindFunc(name);
114585
- return func();
114586
- }, handleSleep(startAsync) {
114587
- if (ABORT)
114588
- return;
114589
- if (Asyncify.state === Asyncify.State.Normal) {
114590
- var reachedCallback = false;
114591
- var reachedAfterCallback = false;
114592
- startAsync((handleSleepReturnValue = 0) => {
114593
- if (ABORT)
114594
- return;
114595
- Asyncify.handleSleepReturnValue = handleSleepReturnValue;
114596
- reachedCallback = true;
114597
- if (!reachedAfterCallback) {
114598
- return;
114599
- }
114600
- Asyncify.state = Asyncify.State.Rewinding;
114601
- runAndAbortIfError(() => _asyncify_start_rewind(Asyncify.currData));
114602
- if (typeof MainLoop != "undefined" && MainLoop.func) {
114603
- MainLoop.resume();
114604
- }
114605
- var asyncWasmReturnValue, isError = false;
114606
- try {
114607
- asyncWasmReturnValue = Asyncify.doRewind(Asyncify.currData);
114608
- } catch (err2) {
114609
- asyncWasmReturnValue = err2;
114610
- isError = true;
114611
- }
114612
- var handled = false;
114613
- if (!Asyncify.currData) {
114614
- var asyncPromiseHandlers = Asyncify.asyncPromiseHandlers;
114615
- if (asyncPromiseHandlers) {
114616
- Asyncify.asyncPromiseHandlers = null;
114617
- (isError ? asyncPromiseHandlers.reject : asyncPromiseHandlers.resolve)(asyncWasmReturnValue);
114618
- handled = true;
114619
- }
114620
- }
114621
- if (isError && !handled) {
114622
- throw asyncWasmReturnValue;
114623
- }
114624
- });
114625
- reachedAfterCallback = true;
114626
- if (!reachedCallback) {
114627
- Asyncify.state = Asyncify.State.Unwinding;
114628
- Asyncify.currData = Asyncify.allocateData();
114629
- if (typeof MainLoop != "undefined" && MainLoop.func) {
114630
- MainLoop.pause();
114631
- }
114632
- runAndAbortIfError(() => _asyncify_start_unwind(Asyncify.currData));
114633
- }
114634
- } else if (Asyncify.state === Asyncify.State.Rewinding) {
114635
- Asyncify.state = Asyncify.State.Normal;
114636
- runAndAbortIfError(_asyncify_stop_rewind);
114637
- _free(Asyncify.currData);
114638
- Asyncify.currData = null;
114639
- Asyncify.sleepCallbacks.forEach(callUserCallback);
114640
- } else {
114641
- abort(`invalid state: ${Asyncify.state}`);
114642
- }
114643
- return Asyncify.handleSleepReturnValue;
114644
- }, handleAsync: (startAsync) => Asyncify.handleSleep((wakeUp) => {
114645
- startAsync().then(wakeUp);
114646
- }) };
114647
- function craftInvokerFunction(humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc, isAsync) {
114648
- var argCount = argTypes.length;
114649
- if (argCount < 2) {
114650
- throwBindingError("argTypes array size mismatch! Must at least get return value and 'this' types!");
114651
- }
114652
- var isClassMethodFunc = argTypes[1] !== null && classType !== null;
114653
- var needsDestructorStack = usesDestructorStack(argTypes);
114654
- var returns = argTypes[0].name !== "void";
114655
- var closureArgs = [humanName, throwBindingError, cppInvokerFunc, cppTargetFunc, runDestructors, argTypes[0], argTypes[1]];
114656
- for (var i = 0; i < argCount - 2; ++i) {
114657
- closureArgs.push(argTypes[i + 2]);
114658
- }
114659
- closureArgs.push(Asyncify);
114660
- if (!needsDestructorStack) {
114661
- for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) {
114662
- if (argTypes[i].destructorFunction !== null) {
114663
- closureArgs.push(argTypes[i].destructorFunction);
114664
- }
114665
- }
114666
- }
114667
- let [args, invokerFnBody] = createJsInvoker(argTypes, isClassMethodFunc, returns, isAsync);
114668
- var invokerFn = new Function(...args, invokerFnBody)(...closureArgs);
114669
- return createNamedFunction(humanName, invokerFn);
114670
- }
114671
- var ensureOverloadTable = (proto, methodName, humanName) => {
114672
- if (void 0 === proto[methodName].overloadTable) {
114673
- var prevFunc = proto[methodName];
114674
- proto[methodName] = function(...args) {
114675
- if (!proto[methodName].overloadTable.hasOwnProperty(args.length)) {
114676
- throwBindingError(`Function '${humanName}' called with an invalid number of arguments (${args.length}) - expects one of (${proto[methodName].overloadTable})!`);
114677
- }
114678
- return proto[methodName].overloadTable[args.length].apply(this, args);
114679
- };
114680
- proto[methodName].overloadTable = [];
114681
- proto[methodName].overloadTable[prevFunc.argCount] = prevFunc;
114682
- }
114683
- };
114684
- var exposePublicSymbol = (name, value, numArguments) => {
114685
- if (Module.hasOwnProperty(name)) {
114686
- if (void 0 === numArguments || void 0 !== Module[name].overloadTable && void 0 !== Module[name].overloadTable[numArguments]) {
114687
- throwBindingError(`Cannot register public name '${name}' twice`);
114688
- }
114689
- ensureOverloadTable(Module, name, name);
114690
- if (Module[name].overloadTable.hasOwnProperty(numArguments)) {
114691
- throwBindingError(`Cannot register multiple overloads of a function with the same number of arguments (${numArguments})!`);
114692
- }
114693
- Module[name].overloadTable[numArguments] = value;
114694
- } else {
114695
- Module[name] = value;
114696
- Module[name].argCount = numArguments;
114697
- }
114698
- };
114699
- var heap32VectorToArray = (count, firstElement) => {
114700
- var array = [];
114701
- for (var i = 0; i < count; i++) {
114702
- array.push(HEAPU32[firstElement + i * 4 >> 2]);
114703
- }
114704
- return array;
114705
- };
114706
- var replacePublicSymbol = (name, value, numArguments) => {
114707
- if (!Module.hasOwnProperty(name)) {
114708
- throwInternalError("Replacing nonexistent public symbol");
114709
- }
114710
- if (void 0 !== Module[name].overloadTable && void 0 !== numArguments) {
114711
- Module[name].overloadTable[numArguments] = value;
114712
- } else {
114713
- Module[name] = value;
114714
- Module[name].argCount = numArguments;
114715
- }
114716
- };
114717
- var getDynCaller = (sig, ptr, promising = false) => (...args) => dynCall(sig, ptr, args, promising);
114718
- var embind__requireFunction = (signature, rawFunction, isAsync = false) => {
114719
- signature = readLatin1String(signature);
114720
- function makeDynCaller() {
114721
- return getDynCaller(signature, rawFunction);
114722
- }
114723
- var fp = makeDynCaller();
114724
- if (typeof fp != "function") {
114725
- throwBindingError(`unknown function pointer with signature ${signature}: ${rawFunction}`);
114726
- }
114727
- return fp;
114728
- };
114729
- class UnboundTypeError extends Error {
114730
- }
114731
- var getTypeName = (type) => {
114732
- var ptr = ___getTypeName(type);
114733
- var rv = readLatin1String(ptr);
114734
- _free(ptr);
114735
- return rv;
114736
- };
114737
- var throwUnboundTypeError = (message, types) => {
114738
- var unboundTypes = [];
114739
- var seen = {};
114740
- function visit(type) {
114741
- if (seen[type]) {
114742
- return;
114743
- }
114744
- if (registeredTypes[type]) {
114745
- return;
114746
- }
114747
- if (typeDependencies[type]) {
114748
- typeDependencies[type].forEach(visit);
114749
- return;
114750
- }
114751
- unboundTypes.push(type);
114752
- seen[type] = true;
114753
- }
114754
- types.forEach(visit);
114755
- throw new UnboundTypeError(`${message}: ` + unboundTypes.map(getTypeName).join([", "]));
114756
- };
114757
- var getFunctionName = (signature) => {
114758
- signature = signature.trim();
114759
- const argsIndex = signature.indexOf("(");
114760
- if (argsIndex === -1)
114761
- return signature;
114762
- return signature.slice(0, argsIndex);
114763
- };
114764
- var __embind_register_function = (name, argCount, rawArgTypesAddr, signature, rawInvoker, fn, isAsync, isNonnullReturn) => {
114765
- var argTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
114766
- name = readLatin1String(name);
114767
- name = getFunctionName(name);
114768
- rawInvoker = embind__requireFunction(signature, rawInvoker, isAsync);
114769
- exposePublicSymbol(name, function() {
114770
- throwUnboundTypeError(`Cannot call ${name} due to unbound types`, argTypes);
114771
- }, argCount - 1);
114772
- whenDependentTypesAreResolved([], argTypes, (argTypes2) => {
114773
- var invokerArgsArray = [argTypes2[0], null].concat(argTypes2.slice(1));
114774
- replacePublicSymbol(name, craftInvokerFunction(name, invokerArgsArray, null, rawInvoker, fn, isAsync), argCount - 1);
114775
- return [];
114776
- });
114777
- };
114778
- var __embind_register_integer = (primitiveType, name, size, minRange, maxRange) => {
114779
- name = readLatin1String(name);
114780
- const isUnsignedType = minRange === 0;
114781
- let fromWireType = (value) => value;
114782
- if (isUnsignedType) {
114783
- var bitshift = 32 - 8 * size;
114784
- fromWireType = (value) => value << bitshift >>> bitshift;
114785
- maxRange = fromWireType(maxRange);
114786
- }
114787
- registerType(primitiveType, { name, fromWireType, toWireType: (destructors, value) => value, argPackAdvance: GenericWireTypeSize, readValueFromPointer: integerReadValueFromPointer(name, size, minRange !== 0), destructorFunction: null });
114788
- };
114789
- var __embind_register_memory_view = (rawType, dataTypeIndex, name) => {
114790
- var typeMapping = [Int8Array, Uint8Array, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array, BigInt64Array, BigUint64Array];
114791
- var TA = typeMapping[dataTypeIndex];
114792
- function decodeMemoryView(handle) {
114793
- var size = HEAPU32[handle >> 2];
114794
- var data = HEAPU32[handle + 4 >> 2];
114795
- return new TA(HEAP8.buffer, data, size);
114796
- }
114797
- name = readLatin1String(name);
114798
- registerType(rawType, { name, fromWireType: decodeMemoryView, argPackAdvance: GenericWireTypeSize, readValueFromPointer: decodeMemoryView }, { ignoreDuplicateRegistrations: true });
114799
- };
114800
- var stringToUTF8 = (str, outPtr, maxBytesToWrite) => stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
114801
- var __embind_register_std_string = (rawType, name) => {
114802
- name = readLatin1String(name);
114803
- registerType(rawType, { name, fromWireType(value) {
114804
- var length = HEAPU32[value >> 2];
114805
- var payload = value + 4;
114806
- var str;
114807
- var i; {
114808
- var decodeStartPtr = payload;
114809
- for (var i = 0; i <= length; ++i) {
114810
- var currentBytePtr = payload + i;
114811
- if (i == length || HEAPU8[currentBytePtr] == 0) {
114812
- var maxRead = currentBytePtr - decodeStartPtr;
114813
- var stringSegment = UTF8ToString(decodeStartPtr, maxRead);
114814
- if (str === void 0) {
114815
- str = stringSegment;
114816
- } else {
114817
- str += String.fromCharCode(0);
114818
- str += stringSegment;
114819
- }
114820
- decodeStartPtr = currentBytePtr + 1;
114821
- }
114822
- }
114823
- }
114824
- _free(value);
114825
- return str;
114826
- }, toWireType(destructors, value) {
114827
- if (value instanceof ArrayBuffer) {
114828
- value = new Uint8Array(value);
114829
- }
114830
- var length;
114831
- var valueIsOfTypeString = typeof value == "string";
114832
- if (!(valueIsOfTypeString || ArrayBuffer.isView(value) && value.BYTES_PER_ELEMENT == 1)) {
114833
- throwBindingError("Cannot pass non-string to std::string");
114834
- }
114835
- if (valueIsOfTypeString) {
114836
- length = lengthBytesUTF8(value);
114837
- } else {
114838
- length = value.length;
114839
- }
114840
- var base = _malloc(4 + length + 1);
114841
- var ptr = base + 4;
114842
- HEAPU32[base >> 2] = length;
114843
- if (valueIsOfTypeString) {
114844
- {
114845
- stringToUTF8(value, ptr, length + 1);
114846
- }
114847
- } else {
114848
- HEAPU8.set(value, ptr);
114849
- }
114850
- if (destructors !== null) {
114851
- destructors.push(_free, base);
114852
- }
114853
- return base;
114854
- }, argPackAdvance: GenericWireTypeSize, readValueFromPointer: readPointer, destructorFunction(ptr) {
114855
- _free(ptr);
114856
- } });
114857
- };
114858
- var UTF16Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf-16le") : void 0;
114859
- var UTF16ToString = (ptr, maxBytesToRead) => {
114860
- var idx = ptr >> 1;
114861
- var maxIdx = idx + maxBytesToRead / 2;
114862
- var endIdx = idx;
114863
- while (!(endIdx >= maxIdx) && HEAPU16[endIdx])
114864
- ++endIdx;
114865
- if (endIdx - idx > 16 && UTF16Decoder)
114866
- return UTF16Decoder.decode(HEAPU16.subarray(idx, endIdx));
114867
- var str = "";
114868
- for (var i = idx; !(i >= maxIdx); ++i) {
114869
- var codeUnit = HEAPU16[i];
114870
- if (codeUnit == 0)
114871
- break;
114872
- str += String.fromCharCode(codeUnit);
114873
- }
114874
- return str;
114875
- };
114876
- var stringToUTF16 = (str, outPtr, maxBytesToWrite) => {
114877
- maxBytesToWrite ?? (maxBytesToWrite = 2147483647);
114878
- if (maxBytesToWrite < 2)
114879
- return 0;
114880
- maxBytesToWrite -= 2;
114881
- var startPtr = outPtr;
114882
- var numCharsToWrite = maxBytesToWrite < str.length * 2 ? maxBytesToWrite / 2 : str.length;
114883
- for (var i = 0; i < numCharsToWrite; ++i) {
114884
- var codeUnit = str.charCodeAt(i);
114885
- HEAP16[outPtr >> 1] = codeUnit;
114886
- outPtr += 2;
114887
- }
114888
- HEAP16[outPtr >> 1] = 0;
114889
- return outPtr - startPtr;
114890
- };
114891
- var lengthBytesUTF16 = (str) => str.length * 2;
114892
- var UTF32ToString = (ptr, maxBytesToRead) => {
114893
- var i = 0;
114894
- var str = "";
114895
- while (!(i >= maxBytesToRead / 4)) {
114896
- var utf32 = HEAP32[ptr + i * 4 >> 2];
114897
- if (utf32 == 0)
114898
- break;
114899
- ++i;
114900
- if (utf32 >= 65536) {
114901
- var ch = utf32 - 65536;
114902
- str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
114903
- } else {
114904
- str += String.fromCharCode(utf32);
114905
- }
114906
- }
114907
- return str;
114908
- };
114909
- var stringToUTF32 = (str, outPtr, maxBytesToWrite) => {
114910
- maxBytesToWrite ?? (maxBytesToWrite = 2147483647);
114911
- if (maxBytesToWrite < 4)
114912
- return 0;
114913
- var startPtr = outPtr;
114914
- var endPtr = startPtr + maxBytesToWrite - 4;
114915
- for (var i = 0; i < str.length; ++i) {
114916
- var codeUnit = str.charCodeAt(i);
114917
- if (codeUnit >= 55296 && codeUnit <= 57343) {
114918
- var trailSurrogate = str.charCodeAt(++i);
114919
- codeUnit = 65536 + ((codeUnit & 1023) << 10) | trailSurrogate & 1023;
114920
- }
114921
- HEAP32[outPtr >> 2] = codeUnit;
114922
- outPtr += 4;
114923
- if (outPtr + 4 > endPtr)
114924
- break;
114925
- }
114926
- HEAP32[outPtr >> 2] = 0;
114927
- return outPtr - startPtr;
114928
- };
114929
- var lengthBytesUTF32 = (str) => {
114930
- var len = 0;
114931
- for (var i = 0; i < str.length; ++i) {
114932
- var codeUnit = str.charCodeAt(i);
114933
- if (codeUnit >= 55296 && codeUnit <= 57343)
114934
- ++i;
114935
- len += 4;
114936
- }
114937
- return len;
114938
- };
114939
- var __embind_register_std_wstring = (rawType, charSize, name) => {
114940
- name = readLatin1String(name);
114941
- var decodeString, encodeString, readCharAt, lengthBytesUTF;
114942
- if (charSize === 2) {
114943
- decodeString = UTF16ToString;
114944
- encodeString = stringToUTF16;
114945
- lengthBytesUTF = lengthBytesUTF16;
114946
- readCharAt = (pointer) => HEAPU16[pointer >> 1];
114947
- } else if (charSize === 4) {
114948
- decodeString = UTF32ToString;
114949
- encodeString = stringToUTF32;
114950
- lengthBytesUTF = lengthBytesUTF32;
114951
- readCharAt = (pointer) => HEAPU32[pointer >> 2];
114952
- }
114953
- registerType(rawType, { name, fromWireType: (value) => {
114954
- var length = HEAPU32[value >> 2];
114955
- var str;
114956
- var decodeStartPtr = value + 4;
114957
- for (var i = 0; i <= length; ++i) {
114958
- var currentBytePtr = value + 4 + i * charSize;
114959
- if (i == length || readCharAt(currentBytePtr) == 0) {
114960
- var maxReadBytes = currentBytePtr - decodeStartPtr;
114961
- var stringSegment = decodeString(decodeStartPtr, maxReadBytes);
114962
- if (str === void 0) {
114963
- str = stringSegment;
114964
- } else {
114965
- str += String.fromCharCode(0);
114966
- str += stringSegment;
114967
- }
114968
- decodeStartPtr = currentBytePtr + charSize;
114969
- }
114970
- }
114971
- _free(value);
114972
- return str;
114973
- }, toWireType: (destructors, value) => {
114974
- if (!(typeof value == "string")) {
114975
- throwBindingError(`Cannot pass non-string to C++ string type ${name}`);
114976
- }
114977
- var length = lengthBytesUTF(value);
114978
- var ptr = _malloc(4 + length + charSize);
114979
- HEAPU32[ptr >> 2] = length / charSize;
114980
- encodeString(value, ptr + 4, length + charSize);
114981
- if (destructors !== null) {
114982
- destructors.push(_free, ptr);
114983
- }
114984
- return ptr;
114985
- }, argPackAdvance: GenericWireTypeSize, readValueFromPointer: readPointer, destructorFunction(ptr) {
114986
- _free(ptr);
114987
- } });
114988
- };
114989
- var __embind_register_value_object = (rawType, name, constructorSignature, rawConstructor, destructorSignature, rawDestructor) => {
114990
- structRegistrations[rawType] = { name: readLatin1String(name), rawConstructor: embind__requireFunction(constructorSignature, rawConstructor), rawDestructor: embind__requireFunction(destructorSignature, rawDestructor), fields: [] };
114991
- };
114992
- var __embind_register_value_object_field = (structType, fieldName, getterReturnType, getterSignature, getter, getterContext, setterArgumentType, setterSignature, setter, setterContext) => {
114993
- structRegistrations[structType].fields.push({ fieldName: readLatin1String(fieldName), getterReturnType, getter: embind__requireFunction(getterSignature, getter), getterContext, setterArgumentType, setter: embind__requireFunction(setterSignature, setter), setterContext });
114994
- };
114995
- var __embind_register_void = (rawType, name) => {
114996
- name = readLatin1String(name);
114997
- registerType(rawType, { isVoid: true, name, argPackAdvance: 0, fromWireType: () => void 0, toWireType: (destructors, o) => void 0 });
114998
- };
114999
- var requireRegisteredType = (rawType, humanName) => {
115000
- var impl = registeredTypes[rawType];
115001
- if (void 0 === impl) {
115002
- throwBindingError(`${humanName} has unknown type ${getTypeName(rawType)}`);
115003
- }
115004
- return impl;
115005
- };
115006
- var emval_returnValue = (returnType, destructorsRef, handle) => {
115007
- var destructors = [];
115008
- var result = returnType["toWireType"](destructors, handle);
115009
- if (destructors.length) {
115010
- HEAPU32[destructorsRef >> 2] = Emval.toHandle(destructors);
115011
- }
115012
- return result;
115013
- };
115014
- var __emval_as = (handle, returnType, destructorsRef) => {
115015
- handle = Emval.toValue(handle);
115016
- returnType = requireRegisteredType(returnType, "emval::as");
115017
- return emval_returnValue(returnType, destructorsRef, handle);
115018
- };
115019
- var emval_methodCallers = [];
115020
- var __emval_call = (caller, handle, destructorsRef, args) => {
115021
- caller = emval_methodCallers[caller];
115022
- handle = Emval.toValue(handle);
115023
- return caller(null, handle, destructorsRef, args);
115024
- };
115025
- var emval_symbols = {};
115026
- var getStringOrSymbol = (address) => {
115027
- var symbol = emval_symbols[address];
115028
- if (symbol === void 0) {
115029
- return readLatin1String(address);
115030
- }
115031
- return symbol;
115032
- };
115033
- var emval_get_global = () => {
115034
- if (typeof globalThis == "object") {
115035
- return globalThis;
115036
- }
115037
- return (/* @__PURE__ */ function() {
115038
- return Function;
115039
- }())("return this")();
115040
- };
115041
- var __emval_get_global = (name) => {
115042
- if (name === 0) {
115043
- return Emval.toHandle(emval_get_global());
115044
- } else {
115045
- name = getStringOrSymbol(name);
115046
- return Emval.toHandle(emval_get_global()[name]);
115047
- }
115048
- };
115049
- var emval_addMethodCaller = (caller) => {
115050
- var id = emval_methodCallers.length;
115051
- emval_methodCallers.push(caller);
115052
- return id;
115053
- };
115054
- var emval_lookupTypes = (argCount, argTypes) => {
115055
- var a = new Array(argCount);
115056
- for (var i = 0; i < argCount; ++i) {
115057
- a[i] = requireRegisteredType(HEAPU32[argTypes + i * 4 >> 2], `parameter ${i}`);
115058
- }
115059
- return a;
115060
- };
115061
- var __emval_get_method_caller = (argCount, argTypes, kind) => {
115062
- var types = emval_lookupTypes(argCount, argTypes);
115063
- var retType = types.shift();
115064
- argCount--;
115065
- var functionBody = `return function (obj, func, destructorsRef, args) {
115066
- `;
115067
- var offset = 0;
115068
- var argsList = [];
115069
- if (kind === 0) {
115070
- argsList.push("obj");
115071
- }
115072
- var params = ["retType"];
115073
- var args = [retType];
115074
- for (var i = 0; i < argCount; ++i) {
115075
- argsList.push(`arg${i}`);
115076
- params.push(`argType${i}`);
115077
- args.push(types[i]);
115078
- functionBody += ` var arg${i} = argType${i}.readValueFromPointer(args${offset ? "+" + offset : ""});
115079
- `;
115080
- offset += types[i].argPackAdvance;
115081
- }
115082
- var invoker = kind === 1 ? "new func" : "func.call";
115083
- functionBody += ` var rv = ${invoker}(${argsList.join(", ")});
115084
- `;
115085
- if (!retType.isVoid) {
115086
- params.push("emval_returnValue");
115087
- args.push(emval_returnValue);
115088
- functionBody += " return emval_returnValue(retType, destructorsRef, rv);\n";
115089
- }
115090
- functionBody += "};\n";
115091
- var invokerFunction = new Function(...params, functionBody)(...args);
115092
- var functionName = `methodCaller<(${types.map((t) => t.name).join(", ")}) => ${retType.name}>`;
115093
- return emval_addMethodCaller(createNamedFunction(functionName, invokerFunction));
115094
- };
115095
- var __emval_incref = (handle) => {
115096
- if (handle > 9) {
115097
- emval_handles[handle + 1] += 1;
115098
- }
115099
- };
115100
- var __emval_is_string = (handle) => {
115101
- handle = Emval.toValue(handle);
115102
- return typeof handle == "string";
115103
- };
115104
- var __emval_run_destructors = (handle) => {
115105
- var destructors = Emval.toValue(handle);
115106
- runDestructors(destructors);
115107
- __emval_decref(handle);
115108
- };
115109
- var __emval_take_value = (type, arg) => {
115110
- type = requireRegisteredType(type, "_emval_take_value");
115111
- var v = type["readValueFromPointer"](arg);
115112
- return Emval.toHandle(v);
115113
- };
115114
- var INT53_MAX = 9007199254740992;
115115
- var INT53_MIN = -9007199254740992;
115116
- var bigintToI53Checked = (num) => num < INT53_MIN || num > INT53_MAX ? NaN : Number(num);
115117
- function __gmtime_js(time, tmPtr) {
115118
- time = bigintToI53Checked(time);
115119
- var date = new Date(time * 1e3);
115120
- HEAP32[tmPtr >> 2] = date.getUTCSeconds();
115121
- HEAP32[tmPtr + 4 >> 2] = date.getUTCMinutes();
115122
- HEAP32[tmPtr + 8 >> 2] = date.getUTCHours();
115123
- HEAP32[tmPtr + 12 >> 2] = date.getUTCDate();
115124
- HEAP32[tmPtr + 16 >> 2] = date.getUTCMonth();
115125
- HEAP32[tmPtr + 20 >> 2] = date.getUTCFullYear() - 1900;
115126
- HEAP32[tmPtr + 24 >> 2] = date.getUTCDay();
115127
- var start = Date.UTC(date.getUTCFullYear(), 0, 1, 0, 0, 0, 0);
115128
- var yday = (date.getTime() - start) / (1e3 * 60 * 60 * 24) | 0;
115129
- HEAP32[tmPtr + 28 >> 2] = yday;
115130
- }
115131
- var isLeapYear = (year) => year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
115132
- var MONTH_DAYS_LEAP_CUMULATIVE = [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335];
115133
- var MONTH_DAYS_REGULAR_CUMULATIVE = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334];
115134
- var ydayFromDate = (date) => {
115135
- var leap = isLeapYear(date.getFullYear());
115136
- var monthDaysCumulative = leap ? MONTH_DAYS_LEAP_CUMULATIVE : MONTH_DAYS_REGULAR_CUMULATIVE;
115137
- var yday = monthDaysCumulative[date.getMonth()] + date.getDate() - 1;
115138
- return yday;
115139
- };
115140
- function __localtime_js(time, tmPtr) {
115141
- time = bigintToI53Checked(time);
115142
- var date = new Date(time * 1e3);
115143
- HEAP32[tmPtr >> 2] = date.getSeconds();
115144
- HEAP32[tmPtr + 4 >> 2] = date.getMinutes();
115145
- HEAP32[tmPtr + 8 >> 2] = date.getHours();
115146
- HEAP32[tmPtr + 12 >> 2] = date.getDate();
115147
- HEAP32[tmPtr + 16 >> 2] = date.getMonth();
115148
- HEAP32[tmPtr + 20 >> 2] = date.getFullYear() - 1900;
115149
- HEAP32[tmPtr + 24 >> 2] = date.getDay();
115150
- var yday = ydayFromDate(date) | 0;
115151
- HEAP32[tmPtr + 28 >> 2] = yday;
115152
- HEAP32[tmPtr + 36 >> 2] = -(date.getTimezoneOffset() * 60);
115153
- var start = new Date(date.getFullYear(), 0, 1);
115154
- var summerOffset = new Date(date.getFullYear(), 6, 1).getTimezoneOffset();
115155
- var winterOffset = start.getTimezoneOffset();
115156
- var dst = (summerOffset != winterOffset && date.getTimezoneOffset() == Math.min(winterOffset, summerOffset)) | 0;
115157
- HEAP32[tmPtr + 32 >> 2] = dst;
115158
- }
115159
- var __tzset_js = (timezone, daylight, std_name, dst_name) => {
115160
- var currentYear = (/* @__PURE__ */ new Date()).getFullYear();
115161
- var winter = new Date(currentYear, 0, 1);
115162
- var summer = new Date(currentYear, 6, 1);
115163
- var winterOffset = winter.getTimezoneOffset();
115164
- var summerOffset = summer.getTimezoneOffset();
115165
- var stdTimezoneOffset = Math.max(winterOffset, summerOffset);
115166
- HEAPU32[timezone >> 2] = stdTimezoneOffset * 60;
115167
- HEAP32[daylight >> 2] = Number(winterOffset != summerOffset);
115168
- var extractZone = (timezoneOffset) => {
115169
- var sign = timezoneOffset >= 0 ? "-" : "+";
115170
- var absOffset = Math.abs(timezoneOffset);
115171
- var hours = String(Math.floor(absOffset / 60)).padStart(2, "0");
115172
- var minutes = String(absOffset % 60).padStart(2, "0");
115173
- return `UTC${sign}${hours}${minutes}`;
115174
- };
115175
- var winterName = extractZone(winterOffset);
115176
- var summerName = extractZone(summerOffset);
115177
- if (summerOffset < winterOffset) {
115178
- stringToUTF8(winterName, std_name, 17);
115179
- stringToUTF8(summerName, dst_name, 17);
115180
- } else {
115181
- stringToUTF8(winterName, dst_name, 17);
115182
- stringToUTF8(summerName, std_name, 17);
115183
- }
115184
- };
115185
- var _emscripten_get_now = () => performance.now();
115186
- var _emscripten_date_now = () => Date.now();
115187
- var checkWasiClock = (clock_id) => clock_id >= 0 && clock_id <= 3;
115188
- function _clock_time_get(clk_id, ignored_precision, ptime) {
115189
- if (!checkWasiClock(clk_id)) {
115190
- return 28;
115191
- }
115192
- var now;
115193
- if (clk_id === 0) {
115194
- now = _emscripten_date_now();
115195
- } else {
115196
- now = _emscripten_get_now();
115197
- }
115198
- var nsec = Math.round(now * 1e3 * 1e3);
115199
- HEAP64[ptime >> 3] = BigInt(nsec);
115200
- return 0;
115201
- }
115202
- var readEmAsmArgsArray = [];
115203
- var readEmAsmArgs = (sigPtr, buf) => {
115204
- readEmAsmArgsArray.length = 0;
115205
- var ch;
115206
- while (ch = HEAPU8[sigPtr++]) {
115207
- var wide = ch != 105;
115208
- wide &= ch != 112;
115209
- buf += wide && buf % 8 ? 4 : 0;
115210
- readEmAsmArgsArray.push(ch == 112 ? HEAPU32[buf >> 2] : ch == 106 ? HEAP64[buf >> 3] : ch == 105 ? HEAP32[buf >> 2] : HEAPF64[buf >> 3]);
115211
- buf += wide ? 8 : 4;
115212
- }
115213
- return readEmAsmArgsArray;
115214
- };
115215
- var runEmAsmFunction = (code, sigPtr, argbuf) => {
115216
- var args = readEmAsmArgs(sigPtr, argbuf);
115217
- return ASM_CONSTS[code](...args);
115218
- };
115219
- var _emscripten_asm_const_int = (code, sigPtr, argbuf) => runEmAsmFunction(code, sigPtr, argbuf);
115220
- var getHeapMax = () => 2147483648;
115221
- var alignMemory = (size, alignment) => Math.ceil(size / alignment) * alignment;
115222
- var growMemory = (size) => {
115223
- var b = wasmMemory.buffer;
115224
- var pages = (size - b.byteLength + 65535) / 65536 | 0;
115225
- try {
115226
- wasmMemory.grow(pages);
115227
- updateMemoryViews();
115228
- return 1;
115229
- } catch (e) {
115230
- }
115231
- };
115232
- var _emscripten_resize_heap = (requestedSize) => {
115233
- var oldSize = HEAPU8.length;
115234
- requestedSize >>>= 0;
115235
- var maxHeapSize = getHeapMax();
115236
- if (requestedSize > maxHeapSize) {
115237
- return false;
115238
- }
115239
- for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
115240
- var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown);
115241
- overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
115242
- var newSize = Math.min(maxHeapSize, alignMemory(Math.max(requestedSize, overGrownHeapSize), 65536));
115243
- var replacement = growMemory(newSize);
115244
- if (replacement) {
115245
- return true;
115246
- }
115247
- }
115248
- return false;
115249
- };
115250
- var safeSetTimeout = (func, timeout) => setTimeout(() => {
115251
- callUserCallback(func);
115252
- }, timeout);
115253
- var _emscripten_sleep = (ms) => Asyncify.handleSleep((wakeUp) => safeSetTimeout(wakeUp, ms));
115254
- _emscripten_sleep.isAsync = true;
115255
- var ENV = {};
115256
- var getExecutableName = () => thisProgram || "./this.program";
115257
- var getEnvStrings = () => {
115258
- if (!getEnvStrings.strings) {
115259
- var lang = (typeof navigator == "object" && navigator.languages && navigator.languages[0] || "C").replace("-", "_") + ".UTF-8";
115260
- var env = { USER: "web_user", LOGNAME: "web_user", PATH: "/", PWD: "/", HOME: "/home/web_user", LANG: lang, _: getExecutableName() };
115261
- for (var x in ENV) {
115262
- if (ENV[x] === void 0)
115263
- delete env[x];
115264
- else
115265
- env[x] = ENV[x];
115266
- }
115267
- var strings = [];
115268
- for (var x in env) {
115269
- strings.push(`${x}=${env[x]}`);
115270
- }
115271
- getEnvStrings.strings = strings;
115272
- }
115273
- return getEnvStrings.strings;
115274
- };
115275
- var _environ_get = (__environ, environ_buf) => {
115276
- var bufSize = 0;
115277
- var envp = 0;
115278
- for (var string of getEnvStrings()) {
115279
- var ptr = environ_buf + bufSize;
115280
- HEAPU32[__environ + envp >> 2] = ptr;
115281
- bufSize += stringToUTF8(string, ptr, Infinity) + 1;
115282
- envp += 4;
115283
- }
115284
- return 0;
115285
- };
115286
- var _environ_sizes_get = (penviron_count, penviron_buf_size) => {
115287
- var strings = getEnvStrings();
115288
- HEAPU32[penviron_count >> 2] = strings.length;
115289
- var bufSize = 0;
115290
- for (var string of strings) {
115291
- bufSize += lengthBytesUTF8(string) + 1;
115292
- }
115293
- HEAPU32[penviron_buf_size >> 2] = bufSize;
115294
- return 0;
115295
- };
115296
- function _fd_close(fd) {
115297
- try {
115298
- var stream = SYSCALLS.getStreamFromFD(fd);
115299
- FS.close(stream);
115300
- return 0;
115301
- } catch (e) {
115302
- if (typeof FS == "undefined" || !(e.name === "ErrnoError"))
115303
- throw e;
115304
- return e.errno;
115305
- }
115306
- }
115307
- function _fd_fdstat_get(fd, pbuf) {
115308
- try {
115309
- var rightsBase = 0;
115310
- var rightsInheriting = 0;
115311
- var flags = 0;
115312
- {
115313
- var stream = SYSCALLS.getStreamFromFD(fd);
115314
- var type = stream.tty ? 2 : FS.isDir(stream.mode) ? 3 : FS.isLink(stream.mode) ? 7 : 4;
115315
- }
115316
- HEAP8[pbuf] = type;
115317
- HEAP16[pbuf + 2 >> 1] = flags;
115318
- HEAP64[pbuf + 8 >> 3] = BigInt(rightsBase);
115319
- HEAP64[pbuf + 16 >> 3] = BigInt(rightsInheriting);
115320
- return 0;
115321
- } catch (e) {
115322
- if (typeof FS == "undefined" || !(e.name === "ErrnoError"))
115323
- throw e;
115324
- return e.errno;
115325
- }
115326
- }
115327
- var doReadv = (stream, iov, iovcnt, offset) => {
115328
- var ret = 0;
115329
- for (var i = 0; i < iovcnt; i++) {
115330
- var ptr = HEAPU32[iov >> 2];
115331
- var len = HEAPU32[iov + 4 >> 2];
115332
- iov += 8;
115333
- var curr = FS.read(stream, HEAP8, ptr, len, offset);
115334
- if (curr < 0)
115335
- return -1;
115336
- ret += curr;
115337
- if (curr < len)
115338
- break;
115339
- if (typeof offset != "undefined") {
115340
- offset += curr;
115341
- }
115342
- }
115343
- return ret;
115344
- };
115345
- function _fd_read(fd, iov, iovcnt, pnum) {
115346
- try {
115347
- var stream = SYSCALLS.getStreamFromFD(fd);
115348
- var num = doReadv(stream, iov, iovcnt);
115349
- HEAPU32[pnum >> 2] = num;
115350
- return 0;
115351
- } catch (e) {
115352
- if (typeof FS == "undefined" || !(e.name === "ErrnoError"))
115353
- throw e;
115354
- return e.errno;
115355
- }
115356
- }
115357
- function _fd_seek(fd, offset, whence, newOffset) {
115358
- offset = bigintToI53Checked(offset);
115359
- try {
115360
- if (isNaN(offset))
115361
- return 61;
115362
- var stream = SYSCALLS.getStreamFromFD(fd);
115363
- FS.llseek(stream, offset, whence);
115364
- HEAP64[newOffset >> 3] = BigInt(stream.position);
115365
- if (stream.getdents && offset === 0 && whence === 0)
115366
- stream.getdents = null;
115367
- return 0;
115368
- } catch (e) {
115369
- if (typeof FS == "undefined" || !(e.name === "ErrnoError"))
115370
- throw e;
115371
- return e.errno;
115372
- }
115373
- }
115374
- var doWritev = (stream, iov, iovcnt, offset) => {
115375
- var ret = 0;
115376
- for (var i = 0; i < iovcnt; i++) {
115377
- var ptr = HEAPU32[iov >> 2];
115378
- var len = HEAPU32[iov + 4 >> 2];
115379
- iov += 8;
115380
- var curr = FS.write(stream, HEAP8, ptr, len, offset);
115381
- if (curr < 0)
115382
- return -1;
115383
- ret += curr;
115384
- if (curr < len) {
115385
- break;
115386
- }
115387
- if (typeof offset != "undefined") {
115388
- offset += curr;
115389
- }
115390
- }
115391
- return ret;
115392
- };
115393
- function _fd_write(fd, iov, iovcnt, pnum) {
115394
- try {
115395
- var stream = SYSCALLS.getStreamFromFD(fd);
115396
- var num = doWritev(stream, iov, iovcnt);
115397
- HEAPU32[pnum >> 2] = num;
115398
- return 0;
115399
- } catch (e) {
115400
- if (typeof FS == "undefined" || !(e.name === "ErrnoError"))
115401
- throw e;
115402
- return e.errno;
115403
- }
115404
- }
115405
- var stackAlloc = (sz) => __emscripten_stack_alloc(sz);
115406
- var stringToUTF8OnStack = (str) => {
115407
- var size = lengthBytesUTF8(str) + 1;
115408
- var ret = stackAlloc(size);
115409
- stringToUTF8(str, ret, size);
115410
- return ret;
115411
- };
115412
- FS.createPreloadedFile = FS_createPreloadedFile;
115413
- FS.staticInit();
115414
- MEMFS.doesNotExistError = new FS.ErrnoError(44);
115415
- MEMFS.doesNotExistError.stack = "<generic error, no stack>";
115416
- embind_init_charCodes();
115417
- {
115418
- if (Module["noExitRuntime"])
115419
- noExitRuntime = Module["noExitRuntime"];
115420
- if (Module["preloadPlugins"])
115421
- preloadPlugins = Module["preloadPlugins"];
115422
- if (Module["print"])
115423
- out = Module["print"];
115424
- if (Module["printErr"])
115425
- err = Module["printErr"];
115426
- if (Module["wasmBinary"])
115427
- wasmBinary = Module["wasmBinary"];
115428
- if (Module["arguments"])
115429
- arguments_ = Module["arguments"];
115430
- if (Module["thisProgram"])
115431
- thisProgram = Module["thisProgram"];
115432
- }
115433
- var ASM_CONSTS = { 1473352: () => {
115434
- console.error("progress callback is not set.");
115435
- } };
115436
- var wasmImports = { a: ___cxa_throw, j: ___syscall_fcntl64, G: ___syscall_ioctl, H: ___syscall_openat, r: ___syscall_renameat, s: ___syscall_rmdir, w: ___syscall_stat64, t: ___syscall_unlinkat, u: __abort_js, L: __embind_finalize_value_object, m: __embind_register_bigint, R: __embind_register_bool, P: __embind_register_emval, l: __embind_register_float, f: __embind_register_function, c: __embind_register_integer, b: __embind_register_memory_view, Q: __embind_register_std_string, g: __embind_register_std_wstring, O: __embind_register_value_object, M: __embind_register_value_object_field, S: __embind_register_void, N: __emval_as, d: __emval_call, q: __emval_decref, F: __emval_get_global, e: __emval_get_method_caller, o: __emval_incref, T: __emval_is_string, n: __emval_run_destructors, p: __emval_take_value, x: __gmtime_js, y: __localtime_js, z: __tzset_js, J: _clock_time_get, K: _emscripten_asm_const_int, I: _emscripten_date_now, v: _emscripten_resize_heap, k: _emscripten_sleep, C: _environ_get, D: _environ_sizes_get, h: _fd_close, B: _fd_fdstat_get, E: _fd_read, A: _fd_seek, i: _fd_write };
115437
- var wasmExports = await createWasm();
115438
- wasmExports["V"];
115439
- var ___getTypeName = wasmExports["W"];
115440
- var _malloc = wasmExports["X"];
115441
- var _free = wasmExports["Y"];
115442
- var _main = Module["_main"] = wasmExports["Z"];
115443
- var __emscripten_stack_alloc = wasmExports["_"];
115444
- Module["dynCall_ii"] = wasmExports["$"];
115445
- Module["dynCall_vi"] = wasmExports["aa"];
115446
- Module["dynCall_vii"] = wasmExports["ba"];
115447
- Module["dynCall_iii"] = wasmExports["ca"];
115448
- Module["dynCall_viii"] = wasmExports["da"];
115449
- Module["dynCall_v"] = wasmExports["ea"];
115450
- Module["dynCall_diiii"] = wasmExports["fa"];
115451
- Module["dynCall_viif"] = wasmExports["ga"];
115452
- Module["dynCall_iiiii"] = wasmExports["ha"];
115453
- Module["dynCall_iiii"] = wasmExports["ia"];
115454
- Module["dynCall_ddd"] = wasmExports["ja"];
115455
- Module["dynCall_i"] = wasmExports["ka"];
115456
- Module["dynCall_fii"] = wasmExports["la"];
115457
- Module["dynCall_viiii"] = wasmExports["ma"];
115458
- Module["dynCall_iiiiii"] = wasmExports["na"];
115459
- Module["dynCall_idd"] = wasmExports["oa"];
115460
- Module["dynCall_jiji"] = wasmExports["pa"];
115461
- Module["dynCall_iidiiii"] = wasmExports["qa"];
115462
- Module["dynCall_viijii"] = wasmExports["ra"];
115463
- Module["dynCall_iiiiiiiii"] = wasmExports["sa"];
115464
- Module["dynCall_iiiiiii"] = wasmExports["ta"];
115465
- Module["dynCall_iiiiij"] = wasmExports["ua"];
115466
- Module["dynCall_iiiiid"] = wasmExports["va"];
115467
- Module["dynCall_iiiiijj"] = wasmExports["wa"];
115468
- Module["dynCall_iiiiiiii"] = wasmExports["xa"];
115469
- Module["dynCall_iiiiiijj"] = wasmExports["ya"];
115470
- Module["dynCall_viiiiii"] = wasmExports["za"];
115471
- Module["dynCall_viiiii"] = wasmExports["Aa"];
115472
- var _asyncify_start_unwind = wasmExports["Ba"];
115473
- var _asyncify_stop_unwind = wasmExports["Ca"];
115474
- var _asyncify_start_rewind = wasmExports["Da"];
115475
- var _asyncify_stop_rewind = wasmExports["Ea"];
115476
- function callMain(args = []) {
115477
- var entryFunction = _main;
115478
- args.unshift(thisProgram);
115479
- var argc = args.length;
115480
- var argv = stackAlloc((argc + 1) * 4);
115481
- var argv_ptr = argv;
115482
- args.forEach((arg) => {
115483
- HEAPU32[argv_ptr >> 2] = stringToUTF8OnStack(arg);
115484
- argv_ptr += 4;
115485
- });
115486
- HEAPU32[argv_ptr >> 2] = 0;
115487
- try {
115488
- var ret = entryFunction(argc, argv);
115489
- exitJS(ret, true);
115490
- return ret;
115491
- } catch (e) {
115492
- return handleException(e);
115493
- }
115494
- }
115495
- function run(args = arguments_) {
115496
- if (runDependencies > 0) {
115497
- dependenciesFulfilled = run;
115498
- return;
115499
- }
115500
- preRun();
115501
- if (runDependencies > 0) {
115502
- dependenciesFulfilled = run;
115503
- return;
115504
- }
115505
- function doRun() {
115506
- Module["calledRun"] = true;
115507
- if (ABORT)
115508
- return;
115509
- initRuntime();
115510
- readyPromiseResolve(Module);
115511
- Module["onRuntimeInitialized"]?.();
115512
- var noInitialRun = Module["noInitialRun"] || true;
115513
- if (!noInitialRun)
115514
- callMain(args);
115515
- postRun();
115516
- }
115517
- if (Module["setStatus"]) {
115518
- Module["setStatus"]("Running...");
115519
- setTimeout(() => {
115520
- setTimeout(() => Module["setStatus"](""), 1);
115521
- doRun();
115522
- }, 1);
115523
- } else {
115524
- doRun();
115525
- }
115526
- }
115527
- function preInit() {
115528
- if (Module["preInit"]) {
115529
- if (typeof Module["preInit"] == "function")
115530
- Module["preInit"] = [Module["preInit"]];
115531
- while (Module["preInit"].length > 0) {
115532
- Module["preInit"].shift()();
115533
- }
115534
- }
115535
- }
115536
- preInit();
115537
- run();
115538
- moduleRtn = readyPromise;
115539
- return moduleRtn;
115540
- };
115541
- })();
115542
-
115543
- var __defProp$1 = Object.defineProperty;
115544
- var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
115545
- var __publicField$1 = (obj, key, value) => {
115546
- __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
115547
- return value;
115548
- };
115549
- const cdnUrl = `https://cdn.jsdelivr.net/npm/@creooxag/cxconverter@${packageJSON.version}/dist/`;
115550
- const defaultUrlPrefix = "./";
115551
- const _IfcWasmConverterLoader = class _IfcWasmConverterLoader {
115552
- constructor() {
115553
- __publicField$1(this, "module");
115554
- }
115555
- static async getInstance(userUrlPrefix = "remote") {
115556
- let urlPrefix = defaultUrlPrefix;
115557
- if (userUrlPrefix) {
115558
- urlPrefix = userUrlPrefix == "remote" ? cdnUrl : userUrlPrefix;
115559
- }
115560
- if (!_IfcWasmConverterLoader.instance) {
115561
- _IfcWasmConverterLoader.instance = new _IfcWasmConverterLoader();
115562
- const Module = {
115563
- locateFile: function(path) {
115564
- const fullPath = urlPrefix + path;
115565
- if (path.endsWith(".wasm")) {
115566
- console.log(`Loading wasm file from ${fullPath}`);
115567
- return fullPath;
115568
- }
115569
- return path;
115570
- }
115571
- };
115572
- try {
115573
- _IfcWasmConverterLoader.instance.module = await IfcDbWasm(Module);
115574
- } catch (error) {
115575
- console.error("Error on wasm import:", error);
115576
- }
115577
- }
115578
- return _IfcWasmConverterLoader.instance;
115579
- }
115580
- static async getModule(userUrlPrefix) {
115581
- return (await _IfcWasmConverterLoader.getInstance(userUrlPrefix)).module;
115582
- }
115583
- };
115584
- __publicField$1(_IfcWasmConverterLoader, "instance");
115585
- let IfcWasmConverterLoader = _IfcWasmConverterLoader;
115586
-
115587
- async function ifc2gltf(ifcData, params = { remote: true }) {
115588
- if (params.remote == void 0)
115589
- params.remote = true;
115590
- const inputOptionsString = params.inputOptions ? params.inputOptions : JSON.stringify(inputOptionsDefault);
115591
- const loadOptions = {
115592
- "maxFileSizeInMegaBytes": 1e3
115593
- };
115594
- let resolveCallbackGltf = void 0;
115595
- let resolveCallbackMetadata = void 0;
115596
- const url = params.remote ? "remote" : params.urlPath;
115597
- const module = await IfcWasmConverterLoader.getModule(url);
115598
- if (params.progressCallback)
115599
- module.setProgressCallback(params.progressCallback);
115600
- else
115601
- module.setProgressCallback((progress) => {
115602
- console.log(`Progress: ${progress}`);
115603
- });
115604
- if (params.progressTextCallback)
115605
- module.setProgressTextCallback(params.progressTextCallback);
115606
- else
115607
- module.setProgressTextCallback((progressText) => {
115608
- console.log(`Progress text: ${progressText}`);
115609
- });
115610
- module.setInputOptions(inputOptionsString);
115611
- const promiseGltf = new Promise((resolve) => {
115612
- resolveCallbackGltf = resolve;
115613
- });
115614
- const promiseMetadata = new Promise((resolve) => {
115615
- resolveCallbackMetadata = resolve;
115616
- });
115617
- if (resolveCallbackGltf)
115618
- module.setGltfCompleteCallback(resolveCallbackGltf);
115619
- if (resolveCallbackMetadata)
115620
- module.setMetaDataCompleteCallback(resolveCallbackMetadata);
115621
- module.loadModel(ifcData, loadOptions);
115622
- await Promise.all([promiseGltf, promiseMetadata]);
115623
- const gltf = await module.getGeometry();
115624
- const uint8Array = await module.getMetaData();
115625
- const decoder = new TextDecoder();
115626
- const metaStr = decoder.decode(uint8Array);
115627
- const metaData = await JSON.parse(metaStr);
115628
- return { gltf, metaData };
115629
- }
115630
- const inputOptionsDefault = {
115631
- "inputParameters": {
115632
- "exportPropertySets": "yes",
115633
- "exportIfcPropertyTypes": "yes",
115634
- "exportIfcValueTypes": "yes",
115635
- "exportPolylines": "yes",
115636
- "excludeGeometryForIfcTypes": ["IfcOpeningElement"],
115637
- "excludeGUIDs": [""],
115638
- "exportOnlyGUIDs": [""],
115639
- "centerModelAtOrigin": "yes",
115640
- "ignoreProfileRadius": "yes",
115641
- "enableGltfCompression": "yes",
115642
- "enableGltfQuantization": "no",
115643
- "exportNormals": "no",
115644
- "numPointsPerCircle": 18,
115645
- "licenceKey": "",
115646
- // JSON above is copied from default input config file. Changes applied here:
115647
- "loadingPriorityTypes": ["IFCWALL", "IFCSLAB", "IFCWINDOW", "IFCROOF", "IFCFURNISHINGELEMENT", "IFCAIRTERMINAL"]
115648
- //[ "IfcOpeningElement" ],
115649
- }
115650
- };
115651
-
115652
111704
  /**
115653
111705
  * Fetches a file from the given URL and returns its contents as text.
115654
111706
  *
@@ -115698,6 +111750,15 @@ class CxConverterIFCLoaderPlugin extends Plugin {
115698
111750
  * @type {GLTFLoaderPlugin}
115699
111751
  */
115700
111752
  this.gltfLoader = new GLTFLoaderPlugin(this.viewer);
111753
+ this.cxConverterModule = null;
111754
+ }
111755
+
111756
+ /**
111757
+ * Sets the CxConverter module to be used by this plugin.
111758
+ * @param {Object} module The CxConverter module.
111759
+ */
111760
+ setCxConverterModule(module) {
111761
+ this.cxConverterModule = module;
115701
111762
  }
115702
111763
 
115703
111764
  /**
@@ -115710,11 +111771,14 @@ class CxConverterIFCLoaderPlugin extends Plugin {
115710
111771
  * @returns {Promise<SceneModel>} A promise that resolves to the loaded SceneModel.
115711
111772
  */
115712
111773
  async load(params = {}) {
111774
+ if (!this.cxConverterModule) {
111775
+ throw new Error("CxConverter module is not set. Use setCxConverterModule() to set it.");
111776
+ }
115713
111777
  if (!params.src) {
115714
111778
  this.error("load() param expected: src");
115715
111779
  }
115716
111780
  const data = await fetchFile(params.src);
115717
- const { gltf, metaData } = await ifc2gltf(
111781
+ const { gltf, metaData } = await this.cxConverterModule.ifc2gltf(
115718
111782
  data,
115719
111783
  {
115720
111784
  remote: true,
@@ -137475,7 +133539,7 @@ class DotBIMLoaderPlugin extends Plugin {
137475
133539
 
137476
133540
  parseDBMesh(dbMeshId, element);
137477
133541
 
137478
- const meshId = `${objectId}-mesh`;
133542
+ const meshId = `${objectId}-mesh-${dbMeshId}`;
137479
133543
 
137480
133544
  let color = element.color ? [element.color.r / 255.0, element.color.g / 255.0, element.color.b / 255.0] : [1, 1, 1];
137481
133545
  let opacity = element.color ? element.color.a / 255.0 : 1.0;
@@ -137548,7 +133612,7 @@ class DotBIMLoaderPlugin extends Plugin {
137548
133612
  positions: trianglesCoordinates,
137549
133613
  indices: [...Array(trianglesCoordinates.length / 3).keys()]
137550
133614
  });
137551
- const meshId = `${objectId}-mesh-${faceColor}`;
133615
+ const meshId = `${objectId}-mesh-${dbMeshId}-${faceColor}`;
137552
133616
  const faceColorArray = faceColor.split(',').map(Number);
137553
133617
 
137554
133618
  let color = [faceColorArray[0] / 255.0, faceColorArray[1] / 255.0, faceColorArray[2] / 255.0];