diff --git a/JetStreamDriver.js b/JetStreamDriver.js index 21b16394..370ea21c 100644 --- a/JetStreamDriver.js +++ b/JetStreamDriver.js @@ -2304,7 +2304,22 @@ let BENCHMARKS = [ iterations: 15, worstCaseCount: 2, tags: ["Default", "Wasm", "dotnet"], - }) + }), + new WasmEMCCBenchmark({ + name: "nutrient-wasm", + files: [ + "./wasm/nutrient/helper.js", + "./wasm/nutrient/build/nutrient-viewer.wasm.js", + "./wasm/nutrient/benchmark.js", + ], + preload: { + pdfDocument: "./wasm/nutrient/assets/example.pdf", + wasmBinary: "./wasm/nutrient/build/nutrient-viewer.wasm", + annotations: "./wasm/nutrient/assets/annotations.json" + }, + iterations: 30, + tags: ["Wasm"], + }), ]; // FIXME: figure out what to do this these benchmarks. diff --git a/in-depth.html b/in-depth.html index b1eb1508..554fc8e8 100644 --- a/in-depth.html +++ b/in-depth.html @@ -333,6 +333,14 @@

Source code: OfflineAssembler.js +
nutrient-wasm
+
+ Tests the Nutrient Web SDK, a client-side PDF framework that runs in the browser using WebAssembly. + This benchmark loads a PDF document, renders a page, creates text annotations, and renders the annotations. + It stresses WebAssembly performance and the interaction between JavaScript and WebAssembly for complex document processing operations. + Source code: benchmark.js +
+
octane-code-load
Test of code load speed of the jQuery and Closure libraries. Because this test allows diff --git a/wasm/nutrient/assets/annotations.json b/wasm/nutrient/assets/annotations.json new file mode 100644 index 00000000..9111bc0b --- /dev/null +++ b/wasm/nutrient/assets/annotations.json @@ -0,0 +1,1192 @@ +{ + "annotations": [ + { + "bbox": [ + 36.5980110168457, + 232, + 165.18333435058594, + 18.5 + ], + "borderWidth": 0, + "createdAt": "2025-07-15T18:02:09Z", + "font": "Helvetica", + "fontColor": "#000000", + "fontSize": 18, + "horizontalAlign": "left", + "id": "01K07M0KT44DPP0GC6MEKG95HM", + "isFitting": true, + "lineHeightFactor": 1.186000108718872, + "name": "01K07M0KT44DPP0GC6MEKG95HM", + "opacity": 1, + "pageIndex": 0, + "rotation": 0, + "text": { + "format": "xhtml", + "value": "

One text annotation.

" + }, + "type": "pspdfkit/text", + "updatedAt": "2025-07-15T18:02:20Z", + "v": 2, + "verticalAlign": "top" + }, + { + "bbox": [ + 74, + 89, + 114, + 134 + ], + "createdAt": "2025-07-15T18:02:21Z", + "id": "01K07M0ZX6ZAFEBY2Z0P84D2Z1", + "isDrawnNaturally": false, + "lineWidth": 5, + "lines": { + "intensities": [ + [ + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5 + ], + [ + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5 + ], + [ + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5 + ], + [ + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5 + ], + [ + 0.5, + 0.5 + ] + ], + "points": [ + [ + [ + 109.43800354003906, + 92 + ], + [ + 109.43800354003906, + 101.20001220703125 + ], + [ + 109.43800354003906, + 110 + ], + [ + 109.43800354003906, + 122.4000244140625 + ], + [ + 109.43800354003906, + 137.5999755859375 + ], + [ + 109.43800354003906, + 149.20001220703125 + ], + [ + 109.43800354003906, + 159.5999755859375 + ], + [ + 109.43800354003906, + 168.4000244140625 + ], + [ + 109.43800354003906, + 175.20001220703125 + ], + [ + 109.43800354003906, + 183.20001220703125 + ], + [ + 109.43800354003906, + 188 + ], + [ + 109.43800354003906, + 193.20001220703125 + ], + [ + 109.43800354003906, + 196 + ] + ], + [ + [ + 146.23800659179688, + 104.79998779296875 + ], + [ + 146.23800659179688, + 112 + ], + [ + 146.63800048828125, + 120 + ], + [ + 147.43800354003906, + 132.4000244140625 + ], + [ + 149.03799438476562, + 148 + ], + [ + 149.83799743652344, + 161.20001220703125 + ], + [ + 150.23800659179688, + 174.79998779296875 + ], + [ + 150.23800659179688, + 189.5999755859375 + ], + [ + 150.23800659179688, + 200 + ], + [ + 150.23800659179688, + 205.5999755859375 + ], + [ + 150.23800659179688, + 210.4000244140625 + ], + [ + 150.23800659179688, + 214.79998779296875 + ], + [ + 150.23800659179688, + 220 + ], + [ + 150.23800659179688, + 218.4000244140625 + ] + ], + [ + [ + 147.83799743652344, + 159.5999755859375 + ], + [ + 138.63800048828125, + 158 + ], + [ + 129.83799743652344, + 155.20001220703125 + ], + [ + 121.03800201416016, + 152 + ], + [ + 110.23799896240234, + 147.5999755859375 + ], + [ + 101.43800354003906, + 144 + ], + [ + 96.23799896240234, + 141.5999755859375 + ], + [ + 90.23799896240234, + 138.79998779296875 + ], + [ + 85.43800354003906, + 136.4000244140625 + ], + [ + 79.43800354003906, + 133.5999755859375 + ], + [ + 76.63800048828125, + 132.4000244140625 + ] + ], + [ + [ + 181.43800354003906, + 145.20001220703125 + ], + [ + 181.43800354003906, + 155.20001220703125 + ], + [ + 181.43800354003906, + 162.79998779296875 + ], + [ + 181.43800354003906, + 168.4000244140625 + ], + [ + 181.43800354003906, + 173.20001220703125 + ], + [ + 181.43800354003906, + 178.4000244140625 + ], + [ + 181.43800354003906, + 183.20001220703125 + ], + [ + 181.43800354003906, + 187.5999755859375 + ], + [ + 181.03799438476562, + 191.5999755859375 + ], + [ + 181.43800354003906, + 195.5999755859375 + ], + [ + 183.03799438476562, + 199.5999755859375 + ], + [ + 183.83799743652344, + 203.5999755859375 + ], + [ + 183.83799743652344, + 204.4000244140625 + ] + ], + [ + [ + 183.83799743652344, + 118.79998779296875 + ], + [ + 185.03799438476562, + 115.5999755859375 + ] + ] + ] + }, + "name": "01K07M0ZX6ZAFEBY2Z0P84D2Z1", + "opacity": 1, + "pageIndex": 0, + "strokeColor": "#2293FB", + "type": "pspdfkit/ink", + "updatedAt": "2025-07-15T18:02:29Z", + "v": 2 + }, + { + "bbox": [ + 40.038002014160156, + 340.5450134277344, + 240, + 80 + ], + "createdAt": "2025-07-15T18:02:35Z", + "id": "01K07M1D4VEGGRTC0G2C6PSG2R", + "name": "01K07M1D4VEGGRTC0G2C6PSG2R", + "opacity": 1, + "pageIndex": 0, + "rotation": 0, + "stampType": "Approved", + "title": "Approved", + "type": "pspdfkit/stamp", + "updatedAt": "2025-07-15T18:02:38Z", + "v": 2 + }, + { + "bbox": [ + 377.84478759765625, + 218.53387451171875, + 169.78900146484375, + 160.41317749023438 + ], + "cloudyBorderInset": [ + 8.5, + 8.5, + 8.5, + 8.5 + ], + "cloudyBorderIntensity": 2, + "createdAt": "2025-07-15T18:02:50Z", + "id": "01K07M1VD0R5CPFM032SAHS7G4", + "name": "01K07M1VD0R5CPFM032SAHS7G4", + "opacity": 1, + "pageIndex": 0, + "points": [ + [ + 479.43798828125, + 234.4000244140625 + ], + [ + 393.8380126953125, + 263.5999755859375 + ], + [ + 399.8380126953125, + 344.79998779296875 + ], + [ + 468.2380065917969, + 363.20001220703125 + ], + [ + 533.0380249023438, + 331.6000061035156 + ] + ], + "strokeColor": "#2293FB", + "strokeWidth": 5, + "type": "pspdfkit/shape/polygon", + "updatedAt": "2025-07-15T18:02:55Z", + "v": 2 + }, + { + "bbox": [ + 226.45684814453125, + 428.08038330078125, + 42.857391357421875, + 141.66351318359375 + ], + "createdAt": "2025-07-15T18:03:06Z", + "endPoint": [ + 243.83799743652344, + 434.79998779296875 + ], + "id": "01K07M2BV8NMJX4X7ECFSY67HJ", + "lineCaps": { + "end": "openArrow" + }, + "name": "01K07M2BV8NMJX4X7ECFSY67HJ", + "opacity": 1, + "pageIndex": 0, + "startPoint": [ + 261.8380126953125, + 564.4000244140625 + ], + "strokeColor": "#2293FB", + "strokeWidth": 5, + "type": "pspdfkit/shape/line", + "updatedAt": "2025-07-15T18:03:09Z", + "v": 2 + }, + { + "bbox": [ + 260, + 89, + 152, + 94 + ], + "createdAt": "2025-07-15T18:11:25Z", + "id": "01K07MHJANMYDX0MEGB66HYV8D", + "isDrawnNaturally": false, + "lineWidth": 5, + "lines": { + "intensities": [ + [ + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5 + ], + [ + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5 + ], + [ + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5 + ], + [ + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5 + ], + [ + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5, + 0.5 + ], + [ + 0.5, + 0.5, + 0.5, + 0.5 + ] + ], + "points": [ + [ + [ + 263.8380126953125, + 92.0533447265625 + ], + [ + 263.8380126953125, + 96.4000244140625 + ], + [ + 263.8380126953125, + 106 + ], + [ + 263.8380126953125, + 112.4000244140625 + ], + [ + 263.8380126953125, + 117.5999755859375 + ], + [ + 263.8380126953125, + 122.4000244140625 + ], + [ + 263.8380126953125, + 129.5999755859375 + ], + [ + 263.8380126953125, + 135.20001220703125 + ], + [ + 263.8380126953125, + 139.5999755859375 + ], + [ + 265.0379943847656, + 142.79998779296875 + ] + ], + [ + [ + 265.0379943847656, + 93.25335693359375 + ], + [ + 269.8380126953125, + 92.79998779296875 + ], + [ + 277.0379943847656, + 92.79998779296875 + ], + [ + 285.43798828125, + 92.79998779296875 + ], + [ + 292.2380065917969, + 92.79998779296875 + ], + [ + 297.0379943847656, + 92.79998779296875 + ], + [ + 301.43798828125, + 92.79998779296875 + ], + [ + 304.2380065917969, + 96.4000244140625 + ], + [ + 306.2380065917969, + 100.79998779296875 + ], + [ + 308.2380065917969, + 105.5999755859375 + ], + [ + 309.43798828125, + 110.79998779296875 + ], + [ + 310.63800048828125, + 116.4000244140625 + ], + [ + 311.8380126953125, + 120.4000244140625 + ], + [ + 309.0379943847656, + 124.79998779296875 + ], + [ + 305.43798828125, + 128 + ], + [ + 299.8380126953125, + 131.20001220703125 + ], + [ + 293.8380126953125, + 133.20001220703125 + ], + [ + 289.0379943847656, + 134.4000244140625 + ], + [ + 293.0379943847656, + 131.20001220703125 + ], + [ + 298.2380065917969, + 130 + ], + [ + 302.2380065917969, + 129.5999755859375 + ], + [ + 306.63800048828125, + 129.5999755859375 + ], + [ + 308.2380065917969, + 135.5999755859375 + ], + [ + 308.2380065917969, + 141.5999755859375 + ], + [ + 308.2380065917969, + 146 + ], + [ + 307.43798828125, + 150 + ], + [ + 305.8380126953125, + 154.79998779296875 + ], + [ + 302.63800048828125, + 158.79998779296875 + ], + [ + 299.43798828125, + 161.20001220703125 + ], + [ + 295.0379943847656, + 163.20001220703125 + ], + [ + 291.0379943847656, + 164.4000244140625 + ], + [ + 286.63800048828125, + 164.79998779296875 + ], + [ + 282.2380065917969, + 163.20001220703125 + ], + [ + 279.0379943847656, + 160.79998779296875 + ], + [ + 274.63800048828125, + 158 + ], + [ + 269.8380126953125, + 154.79998779296875 + ], + [ + 265.8380126953125, + 152.4000244140625 + ], + [ + 263.43798828125, + 149.20001220703125 + ], + [ + 263.0379943847656, + 145.20001220703125 + ], + [ + 263.0379943847656, + 140 + ], + [ + 263.0379943847656, + 135.5999755859375 + ], + [ + 263.0379943847656, + 134.79998779296875 + ] + ], + [ + [ + 325.8380126953125, + 108.453369140625 + ], + [ + 325.8380126953125, + 113.5999755859375 + ], + [ + 325.8380126953125, + 118 + ], + [ + 325.8380126953125, + 122.4000244140625 + ], + [ + 325.8380126953125, + 127.5999755859375 + ], + [ + 326.2380065917969, + 132 + ], + [ + 327.0379943847656, + 136 + ], + [ + 328.2380065917969, + 140 + ], + [ + 329.43798828125, + 144 + ], + [ + 330.2380065917969, + 148.4000244140625 + ], + [ + 330.2380065917969, + 153.20001220703125 + ], + [ + 334.2380065917969, + 150 + ], + [ + 339.8380126953125, + 142 + ], + [ + 342.63800048828125, + 137.20001220703125 + ], + [ + 345.43798828125, + 133.20001220703125 + ], + [ + 349.0379943847656, + 128 + ], + [ + 352.2380065917969, + 123.5999755859375 + ], + [ + 356.63800048828125, + 118 + ], + [ + 360.63800048828125, + 113.5999755859375 + ], + [ + 363.43798828125, + 110.4000244140625 + ], + [ + 361.0379943847656, + 115.20001220703125 + ], + [ + 358.2380065917969, + 118.79998779296875 + ], + [ + 355.0379943847656, + 124 + ], + [ + 351.43798828125, + 129.5999755859375 + ], + [ + 348.2380065917969, + 134 + ], + [ + 345.43798828125, + 138.79998779296875 + ], + [ + 341.8380126953125, + 144 + ], + [ + 338.63800048828125, + 148.79998779296875 + ], + [ + 335.8380126953125, + 153.20001220703125 + ], + [ + 333.43798828125, + 157.5999755859375 + ], + [ + 331.43798828125, + 162 + ], + [ + 329.8380126953125, + 166.79998779296875 + ], + [ + 327.0379943847656, + 171.20001220703125 + ], + [ + 323.43798828125, + 175.20001220703125 + ], + [ + 319.8380126953125, + 178 + ], + [ + 317.43798828125, + 180 + ] + ], + [ + [ + 401.8380126953125, + 130.0533447265625 + ], + [ + 397.8380126953125, + 130 + ], + [ + 393.0379943847656, + 130 + ], + [ + 387.8380126953125, + 130 + ], + [ + 383.0379943847656, + 132.4000244140625 + ], + [ + 379.0379943847656, + 134.79998779296875 + ], + [ + 375.43798828125, + 138 + ], + [ + 370.2380065917969, + 142.4000244140625 + ], + [ + 365.0379943847656, + 148 + ], + [ + 363.43798828125, + 152.4000244140625 + ], + [ + 363.43798828125, + 157.5999755859375 + ], + [ + 365.0379943847656, + 161.5999755859375 + ], + [ + 367.8380126953125, + 164.79998779296875 + ], + [ + 372.2380065917969, + 166 + ], + [ + 376.2380065917969, + 167.5999755859375 + ], + [ + 380.2380065917969, + 169.20001220703125 + ], + [ + 385.0379943847656, + 170.79998779296875 + ], + [ + 389.0379943847656, + 172 + ], + [ + 389.8380126953125, + 172 + ] + ], + [ + [ + 375.43798828125, + 151.25335693359375 + ], + [ + 380.63800048828125, + 151.20001220703125 + ], + [ + 385.8380126953125, + 151.20001220703125 + ], + [ + 391.43798828125, + 151.20001220703125 + ], + [ + 396.2380065917969, + 151.20001220703125 + ], + [ + 400.2380065917969, + 152 + ], + [ + 405.0379943847656, + 152.4000244140625 + ], + [ + 409.0379943847656, + 152.79998779296875 + ] + ], + [ + [ + 366.63800048828125, + 153.25335693359375 + ], + [ + 370.63800048828125, + 153.20001220703125 + ], + [ + 375.0379943847656, + 153.20001220703125 + ], + [ + 376.63800048828125, + 151.5999755859375 + ] + ] + ] + }, + "name": "01K07MHJANMYDX0MEGB66HYV8D", + "opacity": 1, + "pageIndex": 0, + "strokeColor": "#F82400", + "type": "pspdfkit/ink", + "updatedAt": "2025-07-15T18:11:38Z", + "v": 2 + }, + { + "bbox": [ + 80.23799896240234, + 694.7999877929688, + 144.25332641601562, + 91.54669189453125 + ], + "borderColor": "#000000", + "borderStyle": "solid", + "borderWidth": 2, + "callout": { + "cap": "openArrow", + "end": [ + 147.43800354003906, + 710.2999877929688 + ], + "innerRectInset": [ + 67.19999694824219, + 0, + 0, + 60.54668045043945 + ], + "knee": [ + 128.23800659179688, + 741.9466552734375 + ], + "start": [ + 88.23799896240234, + 778.3466796875 + ] + }, + "createdAt": "2025-07-15T18:12:00Z", + "font": "Helvetica", + "fontColor": "#000000", + "fontSize": 18, + "horizontalAlign": "left", + "id": "01K07MJMTV1HY6XA5P71SNNW5D", + "isFitting": true, + "lineHeightFactor": 1.186000108718872, + "name": "01K07MJMTV1HY6XA5P71SNNW5D", + "opacity": 1, + "pageIndex": 0, + "text": { + "format": "xhtml", + "value": "

Science!

" + }, + "type": "pspdfkit/text", + "updatedAt": "2025-07-15T18:12:08Z", + "v": 2, + "verticalAlign": "top" + }, + { + "bbox": [ + 425.7979736328125, + 640.3466796875, + 107.0333251953125, + 37 + ], + "borderWidth": 0, + "createdAt": "2025-07-15T18:12:22Z", + "font": "Helvetica", + "fontColor": "#000000", + "fontSize": 18, + "horizontalAlign": "right", + "id": "01K07MKADAVM38D65EMWAEMR2R", + "isFitting": true, + "lineHeightFactor": 1.186000108718872, + "name": "01K07MKADAVM38D65EMWAEMR2R", + "opacity": 1, + "pageIndex": 0, + "rotation": 0, + "text": { + "format": "xhtml", + "value": "

Another Text

Right Here

" + }, + "type": "pspdfkit/text", + "updatedAt": "2025-07-15T18:12:41Z", + "v": 2, + "verticalAlign": "top" + }, + { + "bbox": [ + 23.21266746520996, + 557.79296875, + 287.2045593261719, + 48.5638427734375 + ], + "contentType": "image/png", + "createdAt": "2025-07-15T18:13:58Z", + "id": "01K07MP81FB3TK1HF21M6PFBN1", + "imageAttachmentId": "653bc7a2cd82b8708ac0f014717ac16dd9d879e951f8bde59ee3409e32704536", + "name": "01K07MP81FB3TK1HF21M6PFBN1", + "opacity": 1, + "pageIndex": 0, + "rotation": 0, + "type": "pspdfkit/image", + "updatedAt": "2025-07-15T18:14:05Z", + "v": 2 + } + ], + "attachments": { + "653bc7a2cd82b8708ac0f014717ac16dd9d879e951f8bde59ee3409e32704536": { + "binary": "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", + "contentType": "image/png" + } + }, + "format": "https://pspdfkit.com/instant-json/v1", + "pdfId": { + "changing": "EVtFZUyoQX2CZqJ0R/GjKg==", + "permanent": "1xb1gwDrStGZLcT/q5vdjg==" + } +} diff --git a/wasm/nutrient/assets/example.pdf b/wasm/nutrient/assets/example.pdf new file mode 100644 index 00000000..89337c99 Binary files /dev/null and b/wasm/nutrient/assets/example.pdf differ diff --git a/wasm/nutrient/benchmark.js b/wasm/nutrient/benchmark.js new file mode 100644 index 00000000..21721398 --- /dev/null +++ b/wasm/nutrient/benchmark.js @@ -0,0 +1,262 @@ +// Copyright 2025 Nutrient. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +function getSingleJsonReplyFromResult(result) { + if (result.getRepliesCount() !== 1) { + throw new Error( + `Expected 1 reply, but got ${result.getRepliesCount()} replies` + ); + } + if (!result.hasJSONReply(0)) { + throw new Error("Expected JSON reply"); + } + return JSON.parse(result.getJSONReply(0)); +} + +function setupPrerequisites() { + Module.ENVIRONMENT_IS_SHELL = + typeof document === "undefined" && typeof window === "undefined"; + Module.ENVIRONMENT_IS_WEB = !Module.ENVIRONMENT_IS_SHELL; + + if (Module.ENVIRONMENT_IS_SHELL) { + // Nutrient WASM requires a location to be set. In shell mode, this isn't available by default. + if (!globalThis.location) { + globalThis.location = { + origin: "http://localhost:8010", + href: "http://localhost:8010/index.html", + protocol: "http:", + host: "localhost:8010", + hostname: "localhost", + port: "8010", + pathname: "/", + search: "", + hash: "", + }; + } + + if (!globalThis.crypto) { + globalThis.crypto = {}; + } + if (!globalThis.crypto.getRandomValues) { + globalThis.crypto.getRandomValues = function (array) { + if ( + !( + array instanceof Int8Array || + array instanceof Uint8Array || + array instanceof Int16Array || + array instanceof Uint16Array || + array instanceof Int32Array || + array instanceof Uint32Array || + array instanceof Uint8ClampedArray + ) + ) + throw new TypeError("Expected an integer array"); + + if (array.byteLength > 65536) + throw new RangeError("Can only request a maximum of 65536 bytes"); + + var i = 0, + r; + + for (; i < array.length; i++) { + if ((i & 0x03) === 0) r = Math.random() * 0x100000000; + array[i] = (r >>> ((i & 0x03) << 3)) & 0xff; + } + + return array; + }; + } + } +} + +async function initializeNutrient() { + await PSPDFModuleInit(Module); + + const rawResult = await Module.initPSPDFKit( + "", // License key - not required. + "JetStream", // Origin - not required. + "", // Fonts path - not required. + "", // Analytics - not required. + "NodeJS", // Environment - "NodeJS" also works in the browser. + JSON.stringify([]) // Feature flags - not required. + ); + + const result = JSON.parse(rawResult); + if (!result.success) { + throw new Error("Failed to initialize Nutrient: " + result.error); + } +} + +function openDocument(path) { + const result = Module.openDocument( + path, + JSON.stringify({ + password: undefined, + initialPageIndex: undefined, + }) + ); + + // Check if document loading failed + if (result && result.error) { + throw new Error("Document loading failed:", result.error); + } +} + +function renderPage(pageIndex, width, height) { + const result = Module.dispatchCommand( + JSON.stringify({ + type: "render_page", + page: pageIndex, + format: "png", + page_width: width, + page_height: height, + }) + ); + + if (result && result.hasError()) { + throw new Error("Failed to render page: " + result.getErrorMessage()); + } + + if (result.getRepliesCount() !== 1) { + throw new Error( + `Expected 1 reply, but got ${result.getRepliesCount()} replies` + ); + } + + if (!result.hasBinaryReply(0)) { + throw new Error("Expected binary reply for rendered page"); + } +} + +function importInstantJSON(json) { + const uint = new Uint8Array(json.buffer); + const memoryHandle = Module.allocateMemory(uint.byteLength); + + try { + memoryHandle.view.set(uint); + const vector = Module.memoryHandleToVector(memoryHandle); + + try { + result = Module.dispatchCommandWithBinary( + JSON.stringify({ type: "import_document_json" }), + vector + ); + } finally { + vector.delete(); + } + } finally { + memoryHandle.delete(); + } + + if (result && result.hasError()) { + throw new Error( + "Failed to import Document JSON: " + result.getErrorMessage() + ); + } +} + +function renderAnnotation(annotationId) { + const result = Module.dispatchCommand( + JSON.stringify({ + type: "render_annotation", + annotation_id: annotationId, + page: 0, + format: "png", + bitmap_width: 350, + bitmap_height: 250, + }) + ); + + if (result && result.hasError()) { + throw new Error("Failed to render annotation: " + result.getErrorMessage()); + } +} + +// `getContentTree` retrieves the page text and accessibility tree for a given page index. +function getContentTree(pageIndex) { + const result = Module.dispatchCommand( + JSON.stringify({ + type: "get_content_tree", + pageIndex: pageIndex, + }) + ); + + if (result && result.hasError()) { + throw new Error("Failed to get content tree: " + result.getErrorMessage()); + } + + return getSingleJsonReplyFromResult(result); +} + +function verifyContentTree(contentTree) { + if ( + !contentTree || + !Array.isArray(contentTree.nodes) || + contentTree.nodes.length === 0 + ) { + throw new Error("Content tree is empty or not an array"); + } +} + +function getAnnotations() { + const result = Module.dispatchCommand( + JSON.stringify({ + type: "get_annotations", + skip_attachments: true, + }) + ); + + if (result && result.hasError()) { + throw new Error("Failed to get annotations: " + result.getErrorMessage()); + } + + const annotations = []; + for (let i = 0; i < result.getRepliesCount(); i++) { + if (result.hasJSONReply(i)) { + annotations.push(JSON.parse(result.getJSONReply(i))); + } else { + throw new Error(`Expected JSON reply for annotation ${i}`); + } + } + return annotations; +} + +// Page width and height for the assets/example.pdf document. +const PAGE_WIDTH = 1190; +const PAGE_HEIGHT = 841; + +class Benchmark { + async init() { + Module.wasmBinary = await getBinary(wasmBinary); + Module.annotations = await getBinary(annotations); + + setupPrerequisites(); + injectRequiredGlobals(globalThis); + } + + async runIteration() { + if (!Module.initPSPDFKit) { + await initializeNutrient(); + + Module.FS.writeFile("/document.pdf", await getBinary(pdfDocument)); + } + + openDocument("/document.pdf"); + + importInstantJSON(Module.annotations); + const annotations = getAnnotations(); + if (annotations.length !== 9) { + throw new Error(`Expected 9 annotations, but got ${annotations.length}`); + } + + var renderScale = 0.3; + renderPage(0, PAGE_WIDTH * renderScale, PAGE_HEIGHT * renderScale); + renderPage(1, PAGE_WIDTH * renderScale, PAGE_HEIGHT * renderScale); + + const contentTree0 = getContentTree(0); + verifyContentTree(contentTree0); + const contentTree1 = getContentTree(1); + verifyContentTree(contentTree1); + } +} diff --git a/wasm/nutrient/build/LICENSE.md b/wasm/nutrient/build/LICENSE.md new file mode 100644 index 00000000..172aae1f --- /dev/null +++ b/wasm/nutrient/build/LICENSE.md @@ -0,0 +1,5 @@ +## Nutrient Web SDK License Agreement + +Please refer to our website to read our evaluation license terms and conditions for Nutrient Web SDK: + +https://www.nutrient.io/legal/Nutrient_SDK_User_Evaluation_Subscription_Agreement diff --git a/wasm/nutrient/build/nutrient-viewer.wasm b/wasm/nutrient/build/nutrient-viewer.wasm new file mode 100644 index 00000000..225b99fb Binary files /dev/null and b/wasm/nutrient/build/nutrient-viewer.wasm differ diff --git a/wasm/nutrient/build/nutrient-viewer.wasm.js b/wasm/nutrient/build/nutrient-viewer.wasm.js new file mode 100644 index 00000000..4aa61319 --- /dev/null +++ b/wasm/nutrient/build/nutrient-viewer.wasm.js @@ -0,0 +1,22 @@ + +var PSPDFModuleInit = (() => { + var _scriptName = typeof document != 'undefined' ? document.currentScript?.src : undefined; + if (typeof __filename != 'undefined') _scriptName = _scriptName || __filename; + return ( +function(moduleArg = {}) { + var moduleRtn; + +var Module=moduleArg;var readyPromiseResolve,readyPromiseReject;var readyPromise=new Promise((resolve,reject)=>{readyPromiseResolve=resolve;readyPromiseReject=reject});var ENVIRONMENT_IS_WEB=typeof window=="object";var ENVIRONMENT_IS_WORKER=typeof WorkerGlobalScope!="undefined";var ENVIRONMENT_IS_NODE=typeof process=="object"&&typeof process.versions=="object"&&typeof process.versions.node=="string"&&process.type!="renderer";if(ENVIRONMENT_IS_NODE){}var moduleOverrides=Object.assign({},Module);var arguments_=[];var thisProgram="./this.program";var quit_=(status,toThrow)=>{throw toThrow};var scriptDirectory="";function locateFile(path){if(Module["locateFile"]){return Module["locateFile"](path,scriptDirectory)}return scriptDirectory+path}var readAsync,readBinary;if(ENVIRONMENT_IS_NODE){var fs=require("fs");var nodePath=require("path");scriptDirectory=__dirname+"/";readBinary=filename=>{filename=isFileURI(filename)?new URL(filename):filename;var ret=fs.readFileSync(filename);return ret};readAsync=async(filename,binary=true)=>{filename=isFileURI(filename)?new URL(filename):filename;var ret=fs.readFileSync(filename,binary?undefined:"utf8");return ret};if(!Module["thisProgram"]&&process.argv.length>1){thisProgram=process.argv[1].replace(/\\/g,"/")}arguments_=process.argv.slice(2);quit_=(status,toThrow)=>{process.exitCode=status;throw toThrow}}else if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){if(ENVIRONMENT_IS_WORKER){scriptDirectory=self.location.href}else if(typeof document!="undefined"&&document.currentScript){scriptDirectory=document.currentScript.src}if(_scriptName){scriptDirectory=_scriptName}if(scriptDirectory.startsWith("blob:")){scriptDirectory=""}else{scriptDirectory=scriptDirectory.substr(0,scriptDirectory.replace(/[?#].*/,"").lastIndexOf("/")+1)}{if(ENVIRONMENT_IS_WORKER){readBinary=url=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.responseType="arraybuffer";xhr.send(null);return new Uint8Array(xhr.response)}}readAsync=async url=>{if(isFileURI(url)){return new Promise((resolve,reject)=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,true);xhr.responseType="arraybuffer";xhr.onload=()=>{if(xhr.status==200||xhr.status==0&&xhr.response){resolve(xhr.response);return}reject(xhr.status)};xhr.onerror=reject;xhr.send(null)})}var response=await fetch(url,{credentials:"same-origin"});if(response.ok){return response.arrayBuffer()}throw new Error(response.status+" : "+response.url)}}}else{}var out=Module["print"]||console.log.bind(console);var err=Module["printErr"]||console.error.bind(console);Object.assign(Module,moduleOverrides);moduleOverrides=null;if(Module["arguments"])arguments_=Module["arguments"];if(Module["thisProgram"])thisProgram=Module["thisProgram"];var wasmBinary=Module["wasmBinary"];var wasmMemory;var ABORT=false;var EXITSTATUS;function assert(condition,text){if(!condition){abort(text)}}var HEAP8,HEAPU8,HEAP16,HEAPU16,HEAP32,HEAPU32,HEAPF32,HEAPF64;function updateMemoryViews(){var b=wasmMemory.buffer;Module["HEAP8"]=HEAP8=new Int8Array(b);Module["HEAP16"]=HEAP16=new Int16Array(b);Module["HEAPU8"]=HEAPU8=new Uint8Array(b);Module["HEAPU16"]=HEAPU16=new Uint16Array(b);Module["HEAP32"]=HEAP32=new Int32Array(b);Module["HEAPU32"]=HEAPU32=new Uint32Array(b);Module["HEAPF32"]=HEAPF32=new Float32Array(b);Module["HEAPF64"]=HEAPF64=new Float64Array(b)}var __ATPRERUN__=[];var __ATINIT__=[];var __ATPOSTRUN__=[];var runtimeInitialized=false;function preRun(){if(Module["preRun"]){if(typeof Module["preRun"]=="function")Module["preRun"]=[Module["preRun"]];while(Module["preRun"].length){addOnPreRun(Module["preRun"].shift())}}callRuntimeCallbacks(__ATPRERUN__)}function initRuntime(){runtimeInitialized=true;if(!Module["noFSInit"]&&!FS.initialized)FS.init();FS.ignorePermissions=false;TTY.init();callRuntimeCallbacks(__ATINIT__)}function postRun(){if(Module["postRun"]){if(typeof Module["postRun"]=="function")Module["postRun"]=[Module["postRun"]];while(Module["postRun"].length){addOnPostRun(Module["postRun"].shift())}}callRuntimeCallbacks(__ATPOSTRUN__)}function addOnPreRun(cb){__ATPRERUN__.unshift(cb)}function addOnInit(cb){__ATINIT__.unshift(cb)}function addOnPostRun(cb){__ATPOSTRUN__.unshift(cb)}var runDependencies=0;var dependenciesFulfilled=null;function getUniqueRunDependency(id){return id}function addRunDependency(id){runDependencies++;Module["monitorRunDependencies"]?.(runDependencies)}function removeRunDependency(id){runDependencies--;Module["monitorRunDependencies"]?.(runDependencies);if(runDependencies==0){if(dependenciesFulfilled){var callback=dependenciesFulfilled;dependenciesFulfilled=null;callback()}}}function abort(what){Module["onAbort"]?.(what);what="Aborted("+what+")";err(what);ABORT=true;what+=". Build with -sASSERTIONS for more info.";if(runtimeInitialized){___trap()}var e=new WebAssembly.RuntimeError(what);readyPromiseReject(e);throw e}var dataURIPrefix="data:application/octet-stream;base64,";var isDataURI=filename=>filename.startsWith(dataURIPrefix);var isFileURI=filename=>filename.startsWith("file://");function findWasmBinary(){var f="nutrient-viewer.wasm.wasm";if(!isDataURI(f)){return locateFile(f)}return f}var wasmBinaryFile;function getBinarySync(file){if(file==wasmBinaryFile&&wasmBinary){return new Uint8Array(wasmBinary)}if(readBinary){return readBinary(file)}throw"both async and sync fetching of the wasm failed"}async function getWasmBinary(binaryFile){if(!wasmBinary){try{var response=await readAsync(binaryFile);return new Uint8Array(response)}catch{}}return getBinarySync(binaryFile)}async function instantiateArrayBuffer(binaryFile,imports){try{var binary=await getWasmBinary(binaryFile);var instance=await WebAssembly.instantiate(binary,imports);return instance}catch(reason){err(`failed to asynchronously prepare wasm: ${reason}`);abort(reason)}}async function instantiateAsync(binary,binaryFile,imports){if(!binary&&typeof WebAssembly.instantiateStreaming=="function"&&!isDataURI(binaryFile)&&!isFileURI(binaryFile)&&!ENVIRONMENT_IS_NODE&&typeof fetch=="function"){try{var response=fetch(binaryFile,{credentials:"same-origin"});var instantiationResult=await WebAssembly.instantiateStreaming(response,imports);return instantiationResult}catch(reason){err(`wasm streaming compile failed: ${reason}`);err("falling back to ArrayBuffer instantiation")}}return instantiateArrayBuffer(binaryFile,imports)}function getWasmImports(){return{a:wasmImports}}async function createWasm(){function receiveInstance(instance,module){wasmExports=instance.exports;wasmMemory=wasmExports["Ca"];updateMemoryViews();wasmTable=wasmExports["Ha"];addOnInit(wasmExports["Da"]);removeRunDependency("wasm-instantiate");return wasmExports}addRunDependency("wasm-instantiate");function receiveInstantiationResult(result){receiveInstance(result["instance"])}var info=getWasmImports();if(Module["instantiateWasm"]){try{return Module["instantiateWasm"](info,receiveInstance)}catch(e){err(`Module.instantiateWasm callback failed with error: ${e}`);readyPromiseReject(e)}}wasmBinaryFile??=findWasmBinary();try{var result=await instantiateAsync(wasmBinary,wasmBinaryFile,info);receiveInstantiationResult(result);return result}catch(e){readyPromiseReject(e);return}}var tempDouble;var tempI64;var ASM_CONSTS={3231716:()=>typeof wasmOffsetConverter!=="undefined"};function HaveOffsetConverter(){return typeof wasmOffsetConverter!=="undefined"}class ExitStatus{name="ExitStatus";constructor(status){this.message=`Program terminated with exit(${status})`;this.status=status}}var callRuntimeCallbacks=callbacks=>{while(callbacks.length>0){callbacks.shift()(Module)}};var noExitRuntime=Module["noExitRuntime"]||true;var PATH={isAbs:path=>path.charAt(0)==="/",splitPath:filename=>{var splitPathRe=/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;return splitPathRe.exec(filename).slice(1)},normalizeArray:(parts,allowAboveRoot)=>{var up=0;for(var i=parts.length-1;i>=0;i--){var last=parts[i];if(last==="."){parts.splice(i,1)}else if(last===".."){parts.splice(i,1);up++}else if(up){parts.splice(i,1);up--}}if(allowAboveRoot){for(;up;up--){parts.unshift("..")}}return parts},normalize:path=>{var isAbsolute=PATH.isAbs(path),trailingSlash=path.substr(-1)==="/";path=PATH.normalizeArray(path.split("/").filter(p=>!!p),!isAbsolute).join("/");if(!path&&!isAbsolute){path="."}if(path&&trailingSlash){path+="/"}return(isAbsolute?"/":"")+path},dirname:path=>{var result=PATH.splitPath(path),root=result[0],dir=result[1];if(!root&&!dir){return"."}if(dir){dir=dir.substr(0,dir.length-1)}return root+dir},basename:path=>{if(path==="/")return"/";path=PATH.normalize(path);path=path.replace(/\/$/,"");var lastSlash=path.lastIndexOf("/");if(lastSlash===-1)return path;return path.substr(lastSlash+1)},join:(...paths)=>PATH.normalize(paths.join("/")),join2:(l,r)=>PATH.normalize(l+"/"+r)};var initRandomFill=()=>{if(typeof crypto=="object"&&typeof crypto["getRandomValues"]=="function"){return view=>crypto.getRandomValues(view)}else if(ENVIRONMENT_IS_NODE){try{var crypto_module=require("crypto");var randomFillSync=crypto_module["randomFillSync"];if(randomFillSync){return view=>crypto_module["randomFillSync"](view)}var randomBytes=crypto_module["randomBytes"];return view=>(view.set(randomBytes(view.byteLength)),view)}catch(e){}}abort("initRandomDevice")};var randomFill=view=>(randomFill=initRandomFill())(view);var PATH_FS={resolve:(...args)=>{var resolvedPath="",resolvedAbsolute=false;for(var i=args.length-1;i>=-1&&!resolvedAbsolute;i--){var path=i>=0?args[i]:FS.cwd();if(typeof path!="string"){throw new TypeError("Arguments to path.resolve must be strings")}else if(!path){return""}resolvedPath=path+"/"+resolvedPath;resolvedAbsolute=PATH.isAbs(path)}resolvedPath=PATH.normalizeArray(resolvedPath.split("/").filter(p=>!!p),!resolvedAbsolute).join("/");return(resolvedAbsolute?"/":"")+resolvedPath||"."},relative:(from,to)=>{from=PATH_FS.resolve(from).substr(1);to=PATH_FS.resolve(to).substr(1);function trim(arr){var start=0;for(;start=0;end--){if(arr[end]!=="")break}if(start>end)return[];return arr.slice(start,end-start+1)}var fromParts=trim(from.split("/"));var toParts=trim(to.split("/"));var length=Math.min(fromParts.length,toParts.length);var samePartsLength=length;for(var i=0;i{var endIdx=idx+maxBytesToRead;var endPtr=idx;while(heapOrArray[endPtr]&&!(endPtr>=endIdx))++endPtr;if(endPtr-idx>16&&heapOrArray.buffer&&UTF8Decoder){return UTF8Decoder.decode(heapOrArray.subarray(idx,endPtr))}var str="";while(idx>10,56320|ch&1023)}}return str};var FS_stdin_getChar_buffer=[];var lengthBytesUTF8=str=>{var len=0;for(var i=0;i=55296&&c<=57343){len+=4;++i}else{len+=3}}return len};var stringToUTF8Array=(str,heap,outIdx,maxBytesToWrite)=>{if(!(maxBytesToWrite>0))return 0;var startIdx=outIdx;var endIdx=outIdx+maxBytesToWrite-1;for(var i=0;i=55296&&u<=57343){var u1=str.charCodeAt(++i);u=65536+((u&1023)<<10)|u1&1023}if(u<=127){if(outIdx>=endIdx)break;heap[outIdx++]=u}else if(u<=2047){if(outIdx+1>=endIdx)break;heap[outIdx++]=192|u>>6;heap[outIdx++]=128|u&63}else if(u<=65535){if(outIdx+2>=endIdx)break;heap[outIdx++]=224|u>>12;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63}else{if(outIdx+3>=endIdx)break;heap[outIdx++]=240|u>>18;heap[outIdx++]=128|u>>12&63;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63}}heap[outIdx]=0;return outIdx-startIdx};function intArrayFromString(stringy,dontAddNull,length){var len=length>0?length:lengthBytesUTF8(stringy)+1;var u8array=new Array(len);var numBytesWritten=stringToUTF8Array(stringy,u8array,0,u8array.length);if(dontAddNull)u8array.length=numBytesWritten;return u8array}var FS_stdin_getChar=()=>{if(!FS_stdin_getChar_buffer.length){var result=null;if(ENVIRONMENT_IS_NODE){var BUFSIZE=256;var buf=Buffer.alloc(BUFSIZE);var bytesRead=0;var fd=process.stdin.fd;try{bytesRead=fs.readSync(fd,buf,0,BUFSIZE)}catch(e){if(e.toString().includes("EOF"))bytesRead=0;else throw e}if(bytesRead>0){result=buf.slice(0,bytesRead).toString("utf-8")}}else if(typeof window!="undefined"&&typeof window.prompt=="function"){result=window.prompt("Input: ");if(result!==null){result+="\n"}}else{}if(!result){return null}FS_stdin_getChar_buffer=intArrayFromString(result,true)}return FS_stdin_getChar_buffer.shift()};var TTY={ttys:[],init(){},shutdown(){},register(dev,ops){TTY.ttys[dev]={input:[],output:[],ops};FS.registerDevice(dev,TTY.stream_ops)},stream_ops:{open(stream){var tty=TTY.ttys[stream.node.rdev];if(!tty){throw new FS.ErrnoError(43)}stream.tty=tty;stream.seekable=false},close(stream){stream.tty.ops.fsync(stream.tty)},fsync(stream){stream.tty.ops.fsync(stream.tty)},read(stream,buffer,offset,length,pos){if(!stream.tty||!stream.tty.ops.get_char){throw new FS.ErrnoError(60)}var bytesRead=0;for(var i=0;i0){out(UTF8ArrayToString(tty.output));tty.output=[]}},ioctl_tcgets(tty){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]}},ioctl_tcsets(tty,optional_actions,data){return 0},ioctl_tiocgwinsz(tty){return[24,80]}},default_tty1_ops:{put_char(tty,val){if(val===null||val===10){err(UTF8ArrayToString(tty.output));tty.output=[]}else{if(val!=0)tty.output.push(val)}},fsync(tty){if(tty.output&&tty.output.length>0){err(UTF8ArrayToString(tty.output));tty.output=[]}}}};var zeroMemory=(address,size)=>{HEAPU8.fill(0,address,address+size)};var alignMemory=(size,alignment)=>Math.ceil(size/alignment)*alignment;var mmapAlloc=size=>{size=alignMemory(size,65536);var ptr=_emscripten_builtin_memalign(65536,size);if(ptr)zeroMemory(ptr,size);return ptr};var MEMFS={ops_table:null,mount(mount){return MEMFS.createNode(null,"/",16895,0)},createNode(parent,name,mode,dev){if(FS.isBlkdev(mode)||FS.isFIFO(mode)){throw new FS.ErrnoError(63)}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,allocate:MEMFS.stream_ops.allocate,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}};var node=FS.createNode(parent,name,mode,dev);if(FS.isDir(node.mode)){node.node_ops=MEMFS.ops_table.dir.node;node.stream_ops=MEMFS.ops_table.dir.stream;node.contents={}}else if(FS.isFile(node.mode)){node.node_ops=MEMFS.ops_table.file.node;node.stream_ops=MEMFS.ops_table.file.stream;node.usedBytes=0;node.contents=null}else if(FS.isLink(node.mode)){node.node_ops=MEMFS.ops_table.link.node;node.stream_ops=MEMFS.ops_table.link.stream}else if(FS.isChrdev(node.mode)){node.node_ops=MEMFS.ops_table.chrdev.node;node.stream_ops=MEMFS.ops_table.chrdev.stream}node.atime=node.mtime=node.ctime=Date.now();if(parent){parent.contents[name]=node;parent.atime=parent.mtime=parent.ctime=node.atime}return node},getFileDataAsTypedArray(node){if(!node.contents)return new Uint8Array(0);if(node.contents.subarray)return node.contents.subarray(0,node.usedBytes);return new Uint8Array(node.contents)},expandFileStorage(node,newCapacity){var prevCapacity=node.contents?node.contents.length:0;if(prevCapacity>=newCapacity)return;var CAPACITY_DOUBLING_MAX=1024*1024;newCapacity=Math.max(newCapacity,prevCapacity*(prevCapacity>>0);if(prevCapacity!=0)newCapacity=Math.max(newCapacity,256);var oldContents=node.contents;node.contents=new Uint8Array(newCapacity);if(node.usedBytes>0)node.contents.set(oldContents.subarray(0,node.usedBytes),0)},resizeFileStorage(node,newSize){if(node.usedBytes==newSize)return;if(newSize==0){node.contents=null;node.usedBytes=0}else{var oldContents=node.contents;node.contents=new Uint8Array(newSize);if(oldContents){node.contents.set(oldContents.subarray(0,Math.min(newSize,node.usedBytes)))}node.usedBytes=newSize}},node_ops:{getattr(node){var attr={};attr.dev=FS.isChrdev(node.mode)?node.id:1;attr.ino=node.id;attr.mode=node.mode;attr.nlink=1;attr.uid=0;attr.gid=0;attr.rdev=node.rdev;if(FS.isDir(node.mode)){attr.size=4096}else if(FS.isFile(node.mode)){attr.size=node.usedBytes}else if(FS.isLink(node.mode)){attr.size=node.link.length}else{attr.size=0}attr.atime=new Date(node.atime);attr.mtime=new Date(node.mtime);attr.ctime=new Date(node.ctime);attr.blksize=4096;attr.blocks=Math.ceil(attr.size/attr.blksize);return attr},setattr(node,attr){for(const key of["mode","atime","mtime","ctime"]){if(attr[key]){node[key]=attr[key]}}if(attr.size!==undefined){MEMFS.resizeFileStorage(node,attr.size)}},lookup(parent,name){throw MEMFS.doesNotExistError},mknod(parent,name,mode,dev){return MEMFS.createNode(parent,name,mode,dev)},rename(old_node,new_dir,new_name){var new_node;try{new_node=FS.lookupNode(new_dir,new_name)}catch(e){}if(new_node){if(FS.isDir(old_node.mode)){for(var i in new_node.contents){throw new FS.ErrnoError(55)}}FS.hashRemoveNode(new_node)}delete old_node.parent.contents[old_node.name];new_dir.contents[new_name]=old_node;old_node.name=new_name;new_dir.ctime=new_dir.mtime=old_node.parent.ctime=old_node.parent.mtime=Date.now()},unlink(parent,name){delete parent.contents[name];parent.ctime=parent.mtime=Date.now()},rmdir(parent,name){var node=FS.lookupNode(parent,name);for(var i in node.contents){throw new FS.ErrnoError(55)}delete parent.contents[name];parent.ctime=parent.mtime=Date.now()},readdir(node){return[".","..",...Object.keys(node.contents)]},symlink(parent,newname,oldpath){var node=MEMFS.createNode(parent,newname,511|40960,0);node.link=oldpath;return node},readlink(node){if(!FS.isLink(node.mode)){throw new FS.ErrnoError(28)}return node.link}},stream_ops:{read(stream,buffer,offset,length,position){var contents=stream.node.contents;if(position>=stream.node.usedBytes)return 0;var size=Math.min(stream.node.usedBytes-position,length);if(size>8&&contents.subarray){buffer.set(contents.subarray(position,position+size),offset)}else{for(var i=0;i0||position+length{var arrayBuffer=await readAsync(url);return new Uint8Array(arrayBuffer)};var FS_createDataFile=(parent,name,fileData,canRead,canWrite,canOwn)=>{FS.createDataFile(parent,name,fileData,canRead,canWrite,canOwn)};var preloadPlugins=Module["preloadPlugins"]||[];var FS_handledByPreloadPlugin=(byteArray,fullname,finish,onerror)=>{if(typeof Browser!="undefined")Browser.init();var handled=false;preloadPlugins.forEach(plugin=>{if(handled)return;if(plugin["canHandle"](fullname)){plugin["handle"](byteArray,fullname,finish,onerror);handled=true}});return handled};var FS_createPreloadedFile=(parent,name,url,canRead,canWrite,onload,onerror,dontCreateFile,canOwn,preFinish)=>{var fullname=name?PATH_FS.resolve(PATH.join2(parent,name)):parent;var dep=getUniqueRunDependency(`cp ${fullname}`);function processData(byteArray){function finish(byteArray){preFinish?.();if(!dontCreateFile){FS_createDataFile(parent,name,byteArray,canRead,canWrite,canOwn)}onload?.();removeRunDependency(dep)}if(FS_handledByPreloadPlugin(byteArray,fullname,finish,()=>{onerror?.();removeRunDependency(dep)})){return}finish(byteArray)}addRunDependency(dep);if(typeof url=="string"){asyncLoad(url).then(processData,onerror)}else{processData(url)}};var FS_modeStringToFlags=str=>{var flagModes={r:0,"r+":2,w:512|64|1,"w+":512|64|2,a:1024|64|1,"a+":1024|64|2};var flags=flagModes[str];if(typeof flags=="undefined"){throw new Error(`Unknown file open mode: ${str}`)}return flags};var FS_getMode=(canRead,canWrite)=>{var mode=0;if(canRead)mode|=292|73;if(canWrite)mode|=146;return mode};var WORKERFS={DIR_MODE:16895,FILE_MODE:33279,reader:null,mount(mount){assert(ENVIRONMENT_IS_WORKER);WORKERFS.reader??=new FileReaderSync;var root=WORKERFS.createNode(null,"/",WORKERFS.DIR_MODE,0);var createdParents={};function ensureParent(path){var parts=path.split("/");var parent=root;for(var i=0;i{WORKERFS.createNode(ensureParent(obj["name"]),base(obj["name"]),WORKERFS.FILE_MODE,0,obj["data"])});(mount.opts["packages"]||[]).forEach(pack=>{pack["metadata"].files.forEach(file=>{var name=file.filename.substr(1);WORKERFS.createNode(ensureParent(name),base(name),WORKERFS.FILE_MODE,0,pack["blob"].slice(file.start,file.end))})});return root},createNode(parent,name,mode,dev,contents,mtime){var node=FS.createNode(parent,name,mode);node.mode=mode;node.node_ops=WORKERFS.node_ops;node.stream_ops=WORKERFS.stream_ops;node.atime=node.mtime=node.ctime=(mtime||new Date).getTime();assert(WORKERFS.FILE_MODE!==WORKERFS.DIR_MODE);if(mode===WORKERFS.FILE_MODE){node.size=contents.size;node.contents=contents}else{node.size=4096;node.contents={}}if(parent){parent.contents[name]=node}return node},node_ops:{getattr(node){return{dev:1,ino:node.id,mode:node.mode,nlink:1,uid:0,gid:0,rdev:0,size:node.size,atime:new Date(node.atime),mtime:new Date(node.mtime),ctime:new Date(node.ctime),blksize:4096,blocks:Math.ceil(node.size/4096)}},setattr(node,attr){for(const key of["mode","atime","mtime","ctime"]){if(attr[key]){node[key]=attr[key]}}},lookup(parent,name){throw new FS.ErrnoError(44)},mknod(parent,name,mode,dev){throw new FS.ErrnoError(63)},rename(oldNode,newDir,newName){throw new FS.ErrnoError(63)},unlink(parent,name){throw new FS.ErrnoError(63)},rmdir(parent,name){throw new FS.ErrnoError(63)},readdir(node){var entries=[".",".."];for(var key of Object.keys(node.contents)){entries.push(key)}return entries},symlink(parent,newName,oldPath){throw new FS.ErrnoError(63)}},stream_ops:{read(stream,buffer,offset,length,position){if(position>=stream.node.size)return 0;var chunk=stream.node.contents.slice(position,position+length);var ab=WORKERFS.reader.readAsArrayBuffer(chunk);buffer.set(new Uint8Array(ab),offset);return chunk.size},write(stream,buffer,offset,length,position){throw new FS.ErrnoError(29)},llseek(stream,offset,whence){var position=offset;if(whence===1){position+=stream.position}else if(whence===2){if(FS.isFile(stream.node.mode)){position+=stream.node.size}}if(position<0){throw new FS.ErrnoError(28)}return position}}};var FS={root:null,mounts:[],devices:{},streams:[],nextInode:1,nameTable:null,currentPath:"/",initialized:false,ignorePermissions:true,ErrnoError:class{name="ErrnoError";constructor(errno){this.errno=errno}},filesystems:null,syncFSRequests:0,readFiles:{},FSStream:class{shared={};get object(){return this.node}set object(val){this.node=val}get isRead(){return(this.flags&2097155)!==1}get isWrite(){return(this.flags&2097155)!==0}get isAppend(){return this.flags&1024}get flags(){return this.shared.flags}set flags(val){this.shared.flags=val}get position(){return this.shared.position}set position(val){this.shared.position=val}},FSNode:class{node_ops={};stream_ops={};readMode=292|73;writeMode=146;mounted=null;constructor(parent,name,mode,rdev){if(!parent){parent=this}this.parent=parent;this.mount=parent.mount;this.id=FS.nextInode++;this.name=name;this.mode=mode;this.rdev=rdev;this.atime=this.mtime=this.ctime=Date.now()}get read(){return(this.mode&this.readMode)===this.readMode}set read(val){val?this.mode|=this.readMode:this.mode&=~this.readMode}get write(){return(this.mode&this.writeMode)===this.writeMode}set write(val){val?this.mode|=this.writeMode:this.mode&=~this.writeMode}get isFolder(){return FS.isDir(this.mode)}get isDevice(){return FS.isChrdev(this.mode)}},lookupPath(path,opts={}){if(!path)return{path:"",node:null};opts.follow_mount??=true;if(!PATH.isAbs(path)){path=FS.cwd()+"/"+path}linkloop:for(var nlinks=0;nlinks<40;nlinks++){var parts=path.split("/").filter(p=>!!p&&p!==".");var current=FS.root;var current_path="/";for(var i=0;i>>0)%FS.nameTable.length},hashAddNode(node){var hash=FS.hashName(node.parent.id,node.name);node.name_next=FS.nameTable[hash];FS.nameTable[hash]=node},hashRemoveNode(node){var hash=FS.hashName(node.parent.id,node.name);if(FS.nameTable[hash]===node){FS.nameTable[hash]=node.name_next}else{var current=FS.nameTable[hash];while(current){if(current.name_next===node){current.name_next=node.name_next;break}current=current.name_next}}},lookupNode(parent,name){var errCode=FS.mayLookup(parent);if(errCode){throw new FS.ErrnoError(errCode)}var hash=FS.hashName(parent.id,name);for(var node=FS.nameTable[hash];node;node=node.name_next){var nodeName=node.name;if(node.parent.id===parent.id&&nodeName===name){return node}}return FS.lookup(parent,name)},createNode(parent,name,mode,rdev){var node=new FS.FSNode(parent,name,mode,rdev);FS.hashAddNode(node);return node},destroyNode(node){FS.hashRemoveNode(node)},isRoot(node){return node===node.parent},isMountpoint(node){return!!node.mounted},isFile(mode){return(mode&61440)===32768},isDir(mode){return(mode&61440)===16384},isLink(mode){return(mode&61440)===40960},isChrdev(mode){return(mode&61440)===8192},isBlkdev(mode){return(mode&61440)===24576},isFIFO(mode){return(mode&61440)===4096},isSocket(mode){return(mode&49152)===49152},flagsToPermissionString(flag){var perms=["r","w","rw"][flag&3];if(flag&512){perms+="w"}return perms},nodePermissions(node,perms){if(FS.ignorePermissions){return 0}if(perms.includes("r")&&!(node.mode&292)){return 2}else if(perms.includes("w")&&!(node.mode&146)){return 2}else if(perms.includes("x")&&!(node.mode&73)){return 2}return 0},mayLookup(dir){if(!FS.isDir(dir.mode))return 54;var errCode=FS.nodePermissions(dir,"x");if(errCode)return errCode;if(!dir.node_ops.lookup)return 2;return 0},mayCreate(dir,name){if(!FS.isDir(dir.mode)){return 54}try{var node=FS.lookupNode(dir,name);return 20}catch(e){}return FS.nodePermissions(dir,"wx")},mayDelete(dir,name,isdir){var node;try{node=FS.lookupNode(dir,name)}catch(e){return e.errno}var errCode=FS.nodePermissions(dir,"wx");if(errCode){return errCode}if(isdir){if(!FS.isDir(node.mode)){return 54}if(FS.isRoot(node)||FS.getPath(node)===FS.cwd()){return 10}}else{if(FS.isDir(node.mode)){return 31}}return 0},mayOpen(node,flags){if(!node){return 44}if(FS.isLink(node.mode)){return 32}else if(FS.isDir(node.mode)){if(FS.flagsToPermissionString(flags)!=="r"||flags&512){return 31}}return FS.nodePermissions(node,FS.flagsToPermissionString(flags))},MAX_OPEN_FDS:4096,nextfd(){for(var fd=0;fd<=FS.MAX_OPEN_FDS;fd++){if(!FS.streams[fd]){return fd}}throw new FS.ErrnoError(33)},getStreamChecked(fd){var stream=FS.getStream(fd);if(!stream){throw new FS.ErrnoError(8)}return stream},getStream:fd=>FS.streams[fd],createStream(stream,fd=-1){stream=Object.assign(new FS.FSStream,stream);if(fd==-1){fd=FS.nextfd()}stream.fd=fd;FS.streams[fd]=stream;return stream},closeStream(fd){FS.streams[fd]=null},dupStream(origStream,fd=-1){var stream=FS.createStream(origStream,fd);stream.stream_ops?.dup?.(stream);return stream},chrdev_stream_ops:{open(stream){var device=FS.getDevice(stream.node.rdev);stream.stream_ops=device.stream_ops;stream.stream_ops.open?.(stream)},llseek(){throw new FS.ErrnoError(70)}},major:dev=>dev>>8,minor:dev=>dev&255,makedev:(ma,mi)=>ma<<8|mi,registerDevice(dev,ops){FS.devices[dev]={stream_ops:ops}},getDevice:dev=>FS.devices[dev],getMounts(mount){var mounts=[];var check=[mount];while(check.length){var m=check.pop();mounts.push(m);check.push(...m.mounts)}return mounts},syncfs(populate,callback){if(typeof populate=="function"){callback=populate;populate=false}FS.syncFSRequests++;if(FS.syncFSRequests>1){err(`warning: ${FS.syncFSRequests} FS.syncfs operations in flight at once, probably just doing extra work`)}var mounts=FS.getMounts(FS.root.mount);var completed=0;function doCallback(errCode){FS.syncFSRequests--;return callback(errCode)}function done(errCode){if(errCode){if(!done.errored){done.errored=true;return doCallback(errCode)}return}if(++completed>=mounts.length){doCallback(null)}}mounts.forEach(mount=>{if(!mount.type.syncfs){return done(null)}mount.type.syncfs(mount,populate,done)})},mount(type,opts,mountpoint){var root=mountpoint==="/";var pseudo=!mountpoint;var node;if(root&&FS.root){throw new FS.ErrnoError(10)}else if(!root&&!pseudo){var lookup=FS.lookupPath(mountpoint,{follow_mount:false});mountpoint=lookup.path;node=lookup.node;if(FS.isMountpoint(node)){throw new FS.ErrnoError(10)}if(!FS.isDir(node.mode)){throw new FS.ErrnoError(54)}}var mount={type,opts,mountpoint,mounts:[]};var mountRoot=type.mount(mount);mountRoot.mount=mount;mount.root=mountRoot;if(root){FS.root=mountRoot}else if(node){node.mounted=mount;if(node.mount){node.mount.mounts.push(mount)}}return mountRoot},unmount(mountpoint){var lookup=FS.lookupPath(mountpoint,{follow_mount:false});if(!FS.isMountpoint(lookup.node)){throw new FS.ErrnoError(28)}var node=lookup.node;var mount=node.mounted;var mounts=FS.getMounts(mount);Object.keys(FS.nameTable).forEach(hash=>{var current=FS.nameTable[hash];while(current){var next=current.name_next;if(mounts.includes(current.mount)){FS.destroyNode(current)}current=next}});node.mounted=null;var idx=node.mount.mounts.indexOf(mount);node.mount.mounts.splice(idx,1)},lookup(parent,name){return parent.node_ops.lookup(parent,name)},mknod(path,mode,dev){var lookup=FS.lookupPath(path,{parent:true});var parent=lookup.node;var name=PATH.basename(path);if(!name||name==="."||name===".."){throw new FS.ErrnoError(28)}var errCode=FS.mayCreate(parent,name);if(errCode){throw new FS.ErrnoError(errCode)}if(!parent.node_ops.mknod){throw new FS.ErrnoError(63)}return parent.node_ops.mknod(parent,name,mode,dev)},statfs(path){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};var parent=FS.lookupPath(path,{follow:true}).node;if(parent?.node_ops.statfs){Object.assign(rtn,parent.node_ops.statfs(parent.mount.opts.root))}return rtn},create(path,mode=438){mode&=4095;mode|=32768;return FS.mknod(path,mode,0)},mkdir(path,mode=511){mode&=511|512;mode|=16384;return FS.mknod(path,mode,0)},mkdirTree(path,mode){var dirs=path.split("/");var d="";for(var i=0;iFS.currentPath,chdir(path){var lookup=FS.lookupPath(path,{follow:true});if(lookup.node===null){throw new FS.ErrnoError(44)}if(!FS.isDir(lookup.node.mode)){throw new FS.ErrnoError(54)}var errCode=FS.nodePermissions(lookup.node,"x");if(errCode){throw new FS.ErrnoError(errCode)}FS.currentPath=lookup.path},createDefaultDirectories(){FS.mkdir("/tmp");FS.mkdir("/home");FS.mkdir("/home/web_user")},createDefaultDevices(){FS.mkdir("/dev");FS.registerDevice(FS.makedev(1,3),{read:()=>0,write:(stream,buffer,offset,length,pos)=>length,llseek:()=>0});FS.mkdev("/dev/null",FS.makedev(1,3));TTY.register(FS.makedev(5,0),TTY.default_tty_ops);TTY.register(FS.makedev(6,0),TTY.default_tty1_ops);FS.mkdev("/dev/tty",FS.makedev(5,0));FS.mkdev("/dev/tty1",FS.makedev(6,0));var randomBuffer=new Uint8Array(1024),randomLeft=0;var randomByte=()=>{if(randomLeft===0){randomLeft=randomFill(randomBuffer).byteLength}return randomBuffer[--randomLeft]};FS.createDevice("/dev","random",randomByte);FS.createDevice("/dev","urandom",randomByte);FS.mkdir("/dev/shm");FS.mkdir("/dev/shm/tmp")},createSpecialDirectories(){FS.mkdir("/proc");var proc_self=FS.mkdir("/proc/self");FS.mkdir("/proc/self/fd");FS.mount({mount(){var node=FS.createNode(proc_self,"fd",16895,73);node.stream_ops={llseek:MEMFS.stream_ops.llseek};node.node_ops={lookup(parent,name){var fd=+name;var stream=FS.getStreamChecked(fd);var ret={parent:null,mount:{mountpoint:"fake"},node_ops:{readlink:()=>stream.path},id:fd+1};ret.parent=ret;return ret},readdir(){return Array.from(FS.streams.entries()).filter(([k,v])=>v).map(([k,v])=>k.toString())}};return node}},{},"/proc/self/fd")},createStandardStreams(input,output,error){if(input){FS.createDevice("/dev","stdin",input)}else{FS.symlink("/dev/tty","/dev/stdin")}if(output){FS.createDevice("/dev","stdout",null,output)}else{FS.symlink("/dev/tty","/dev/stdout")}if(error){FS.createDevice("/dev","stderr",null,error)}else{FS.symlink("/dev/tty1","/dev/stderr")}var stdin=FS.open("/dev/stdin",0);var stdout=FS.open("/dev/stdout",1);var stderr=FS.open("/dev/stderr",1)},staticInit(){FS.nameTable=new Array(4096);FS.mount(MEMFS,{},"/");FS.createDefaultDirectories();FS.createDefaultDevices();FS.createSpecialDirectories();FS.filesystems={MEMFS,WORKERFS}},init(input,output,error){FS.initialized=true;input??=Module["stdin"];output??=Module["stdout"];error??=Module["stderr"];FS.createStandardStreams(input,output,error)},quit(){FS.initialized=false;for(var i=0;ithis.length-1||idx<0){return undefined}var chunkOffset=idx%this.chunkSize;var chunkNum=idx/this.chunkSize|0;return this.getter(chunkNum)[chunkOffset]}setDataGetter(getter){this.getter=getter}cacheLength(){var xhr=new XMLHttpRequest;xhr.open("HEAD",url,false);xhr.send(null);if(!(xhr.status>=200&&xhr.status<300||xhr.status===304))throw new Error("Couldn't load "+url+". Status: "+xhr.status);var datalength=Number(xhr.getResponseHeader("Content-length"));var header;var hasByteServing=(header=xhr.getResponseHeader("Accept-Ranges"))&&header==="bytes";var usesGzip=(header=xhr.getResponseHeader("Content-Encoding"))&&header==="gzip";var chunkSize=1024*1024;if(!hasByteServing)chunkSize=datalength;var doXHR=(from,to)=>{if(from>to)throw new Error("invalid range ("+from+", "+to+") or no bytes requested!");if(to>datalength-1)throw new Error("only "+datalength+" bytes available! programmer error!");var xhr=new XMLHttpRequest;xhr.open("GET",url,false);if(datalength!==chunkSize)xhr.setRequestHeader("Range","bytes="+from+"-"+to);xhr.responseType="arraybuffer";if(xhr.overrideMimeType){xhr.overrideMimeType("text/plain; charset=x-user-defined")}xhr.send(null);if(!(xhr.status>=200&&xhr.status<300||xhr.status===304))throw new Error("Couldn't load "+url+". Status: "+xhr.status);if(xhr.response!==undefined){return new Uint8Array(xhr.response||[])}return intArrayFromString(xhr.responseText||"",true)};var lazyArray=this;lazyArray.setDataGetter(chunkNum=>{var start=chunkNum*chunkSize;var end=(chunkNum+1)*chunkSize-1;end=Math.min(end,datalength-1);if(typeof lazyArray.chunks[chunkNum]=="undefined"){lazyArray.chunks[chunkNum]=doXHR(start,end)}if(typeof lazyArray.chunks[chunkNum]=="undefined")throw new Error("doXHR failed!");return lazyArray.chunks[chunkNum]});if(usesGzip||!datalength){chunkSize=datalength=1;datalength=this.getter(0).length;chunkSize=datalength;out("LazyFiles on gzip forces download of the whole file when length is accessed")}this._length=datalength;this._chunkSize=chunkSize;this.lengthKnown=true}get length(){if(!this.lengthKnown){this.cacheLength()}return this._length}get chunkSize(){if(!this.lengthKnown){this.cacheLength()}return this._chunkSize}}if(typeof XMLHttpRequest!="undefined"){if(!ENVIRONMENT_IS_WORKER)throw"Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc";var lazyArray=new LazyUint8Array;var properties={isDevice:false,contents:lazyArray}}else{var properties={isDevice:false,url}}var node=FS.createFile(parent,name,properties,canRead,canWrite);if(properties.contents){node.contents=properties.contents}else if(properties.url){node.contents=null;node.url=properties.url}Object.defineProperties(node,{usedBytes:{get:function(){return this.contents.length}}});var stream_ops={};var keys=Object.keys(node.stream_ops);keys.forEach(key=>{var fn=node.stream_ops[key];stream_ops[key]=(...args)=>{FS.forceLoadFile(node);return fn(...args)}});function writeChunks(stream,buffer,offset,length,position){var contents=stream.node.contents;if(position>=contents.length)return 0;var size=Math.min(contents.length-position,length);if(contents.slice){for(var i=0;i{FS.forceLoadFile(node);return writeChunks(stream,buffer,offset,length,position)};stream_ops.mmap=(stream,length,position,prot,flags)=>{FS.forceLoadFile(node);var ptr=mmapAlloc(length);if(!ptr){throw new FS.ErrnoError(48)}writeChunks(stream,HEAP8,ptr,length,position);return{ptr,allocated:true}};node.stream_ops=stream_ops;return node}};var UTF8ToString=(ptr,maxBytesToRead)=>ptr?UTF8ArrayToString(HEAPU8,ptr,maxBytesToRead):"";var SYSCALLS={DEFAULT_POLLMASK:5,calculateAt(dirfd,path,allowEmpty){if(PATH.isAbs(path)){return path}var dir;if(dirfd===-100){dir=FS.cwd()}else{var dirstream=SYSCALLS.getStreamFromFD(dirfd);dir=dirstream.path}if(path.length==0){if(!allowEmpty){throw new FS.ErrnoError(44)}return dir}return dir+"/"+path},doStat(func,path,buf){var stat=func(path);HEAP32[buf>>2]=stat.dev;HEAP32[buf+4>>2]=stat.mode;HEAPU32[buf+8>>2]=stat.nlink;HEAP32[buf+12>>2]=stat.uid;HEAP32[buf+16>>2]=stat.gid;HEAP32[buf+20>>2]=stat.rdev;tempI64=[stat.size>>>0,(tempDouble=stat.size,+Math.abs(tempDouble)>=1?tempDouble>0?+Math.floor(tempDouble/4294967296)>>>0:~~+Math.ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[buf+24>>2]=tempI64[0],HEAP32[buf+28>>2]=tempI64[1];HEAP32[buf+32>>2]=4096;HEAP32[buf+36>>2]=stat.blocks;var atime=stat.atime.getTime();var mtime=stat.mtime.getTime();var ctime=stat.ctime.getTime();tempI64=[Math.floor(atime/1e3)>>>0,(tempDouble=Math.floor(atime/1e3),+Math.abs(tempDouble)>=1?tempDouble>0?+Math.floor(tempDouble/4294967296)>>>0:~~+Math.ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[buf+40>>2]=tempI64[0],HEAP32[buf+44>>2]=tempI64[1];HEAPU32[buf+48>>2]=atime%1e3*1e3*1e3;tempI64=[Math.floor(mtime/1e3)>>>0,(tempDouble=Math.floor(mtime/1e3),+Math.abs(tempDouble)>=1?tempDouble>0?+Math.floor(tempDouble/4294967296)>>>0:~~+Math.ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[buf+56>>2]=tempI64[0],HEAP32[buf+60>>2]=tempI64[1];HEAPU32[buf+64>>2]=mtime%1e3*1e3*1e3;tempI64=[Math.floor(ctime/1e3)>>>0,(tempDouble=Math.floor(ctime/1e3),+Math.abs(tempDouble)>=1?tempDouble>0?+Math.floor(tempDouble/4294967296)>>>0:~~+Math.ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[buf+72>>2]=tempI64[0],HEAP32[buf+76>>2]=tempI64[1];HEAPU32[buf+80>>2]=ctime%1e3*1e3*1e3;tempI64=[stat.ino>>>0,(tempDouble=stat.ino,+Math.abs(tempDouble)>=1?tempDouble>0?+Math.floor(tempDouble/4294967296)>>>0:~~+Math.ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[buf+88>>2]=tempI64[0],HEAP32[buf+92>>2]=tempI64[1];return 0},doMsync(addr,stream,len,flags,offset){if(!FS.isFile(stream.node.mode)){throw new FS.ErrnoError(43)}if(flags&2){return 0}var buffer=HEAPU8.slice(addr,addr+len);FS.msync(stream,buffer,offset,len,flags)},getStreamFromFD(fd){var stream=FS.getStreamChecked(fd);return stream},varargs:undefined,getStr(ptr){var ret=UTF8ToString(ptr);return ret}};function ___syscall_chmod(path,mode){try{path=SYSCALLS.getStr(path);FS.chmod(path,mode);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_faccessat(dirfd,path,amode,flags){try{path=SYSCALLS.getStr(path);path=SYSCALLS.calculateAt(dirfd,path);if(amode&~7){return-28}var lookup=FS.lookupPath(path,{follow:true});var node=lookup.node;if(!node){return-44}var perms="";if(amode&4)perms+="r";if(amode&2)perms+="w";if(amode&1)perms+="x";if(perms&&FS.nodePermissions(node,perms)){return-2}return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_fchmod(fd,mode){try{FS.fchmod(fd,mode);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}var syscallGetVarargI=()=>{var ret=HEAP32[+SYSCALLS.varargs>>2];SYSCALLS.varargs+=4;return ret};var syscallGetVarargP=syscallGetVarargI;function ___syscall_fcntl64(fd,cmd,varargs){SYSCALLS.varargs=varargs;try{var stream=SYSCALLS.getStreamFromFD(fd);switch(cmd){case 0:{var arg=syscallGetVarargI();if(arg<0){return-28}while(FS.streams[arg]){arg++}var newStream;newStream=FS.dupStream(stream,arg);return newStream.fd}case 1:case 2:return 0;case 3:return stream.flags;case 4:{var arg=syscallGetVarargI();stream.flags|=arg;return 0}case 12:{var arg=syscallGetVarargP();var offset=0;HEAP16[arg+offset>>1]=2;return 0}case 13:case 14:return 0}return-28}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_fstat64(fd,buf){try{var stream=SYSCALLS.getStreamFromFD(fd);return SYSCALLS.doStat(FS.stat,stream.path,buf)}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}var convertI32PairToI53Checked=(lo,hi)=>hi+2097152>>>0<4194305-!!lo?(lo>>>0)+hi*4294967296:NaN;function ___syscall_ftruncate64(fd,length_low,length_high){var length=convertI32PairToI53Checked(length_low,length_high);try{if(isNaN(length))return 61;FS.ftruncate(fd,length);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}var stringToUTF8=(str,outPtr,maxBytesToWrite)=>stringToUTF8Array(str,HEAPU8,outPtr,maxBytesToWrite);function ___syscall_getdents64(fd,dirp,count){try{var stream=SYSCALLS.getStreamFromFD(fd);stream.getdents||=FS.readdir(stream.path);var struct_size=280;var pos=0;var off=FS.llseek(stream,0,1);var startIdx=Math.floor(off/struct_size);var endIdx=Math.min(stream.getdents.length,startIdx+Math.floor(count/struct_size));for(var idx=startIdx;idx>>0,(tempDouble=id,+Math.abs(tempDouble)>=1?tempDouble>0?+Math.floor(tempDouble/4294967296)>>>0:~~+Math.ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[dirp+pos>>2]=tempI64[0],HEAP32[dirp+pos+4>>2]=tempI64[1];tempI64=[(idx+1)*struct_size>>>0,(tempDouble=(idx+1)*struct_size,+Math.abs(tempDouble)>=1?tempDouble>0?+Math.floor(tempDouble/4294967296)>>>0:~~+Math.ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[dirp+pos+8>>2]=tempI64[0],HEAP32[dirp+pos+12>>2]=tempI64[1];HEAP16[dirp+pos+16>>1]=280;HEAP8[dirp+pos+18]=type;stringToUTF8(name,dirp+pos+19,256);pos+=struct_size}FS.llseek(stream,idx*struct_size,0);return pos}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_ioctl(fd,op,varargs){SYSCALLS.varargs=varargs;try{var stream=SYSCALLS.getStreamFromFD(fd);switch(op){case 21509:{if(!stream.tty)return-59;return 0}case 21505:{if(!stream.tty)return-59;if(stream.tty.ops.ioctl_tcgets){var termios=stream.tty.ops.ioctl_tcgets(stream);var argp=syscallGetVarargP();HEAP32[argp>>2]=termios.c_iflag||0;HEAP32[argp+4>>2]=termios.c_oflag||0;HEAP32[argp+8>>2]=termios.c_cflag||0;HEAP32[argp+12>>2]=termios.c_lflag||0;for(var i=0;i<32;i++){HEAP8[argp+i+17]=termios.c_cc[i]||0}return 0}return 0}case 21510:case 21511:case 21512:{if(!stream.tty)return-59;return 0}case 21506:case 21507:case 21508:{if(!stream.tty)return-59;if(stream.tty.ops.ioctl_tcsets){var argp=syscallGetVarargP();var c_iflag=HEAP32[argp>>2];var c_oflag=HEAP32[argp+4>>2];var c_cflag=HEAP32[argp+8>>2];var c_lflag=HEAP32[argp+12>>2];var c_cc=[];for(var i=0;i<32;i++){c_cc.push(HEAP8[argp+i+17])}return stream.tty.ops.ioctl_tcsets(stream.tty,op,{c_iflag,c_oflag,c_cflag,c_lflag,c_cc})}return 0}case 21519:{if(!stream.tty)return-59;var argp=syscallGetVarargP();HEAP32[argp>>2]=0;return 0}case 21520:{if(!stream.tty)return-59;return-28}case 21531:{var argp=syscallGetVarargP();return FS.ioctl(stream,op,argp)}case 21523:{if(!stream.tty)return-59;if(stream.tty.ops.ioctl_tiocgwinsz){var winsize=stream.tty.ops.ioctl_tiocgwinsz(stream.tty);var argp=syscallGetVarargP();HEAP16[argp>>1]=winsize[0];HEAP16[argp+2>>1]=winsize[1]}return 0}case 21524:{if(!stream.tty)return-59;return 0}case 21515:{if(!stream.tty)return-59;return 0}default:return-28}}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_lstat64(path,buf){try{path=SYSCALLS.getStr(path);return SYSCALLS.doStat(FS.lstat,path,buf)}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_mkdirat(dirfd,path,mode){try{path=SYSCALLS.getStr(path);path=SYSCALLS.calculateAt(dirfd,path);FS.mkdir(path,mode,0);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_newfstatat(dirfd,path,buf,flags){try{path=SYSCALLS.getStr(path);var nofollow=flags&256;var allowEmpty=flags&4096;flags=flags&~6400;path=SYSCALLS.calculateAt(dirfd,path,allowEmpty);return SYSCALLS.doStat(nofollow?FS.lstat:FS.stat,path,buf)}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_openat(dirfd,path,flags,varargs){SYSCALLS.varargs=varargs;try{path=SYSCALLS.getStr(path);path=SYSCALLS.calculateAt(dirfd,path);var mode=varargs?syscallGetVarargI():0;return FS.open(path,flags,mode).fd}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_renameat(olddirfd,oldpath,newdirfd,newpath){try{oldpath=SYSCALLS.getStr(oldpath);newpath=SYSCALLS.getStr(newpath);oldpath=SYSCALLS.calculateAt(olddirfd,oldpath);newpath=SYSCALLS.calculateAt(newdirfd,newpath);FS.rename(oldpath,newpath);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_rmdir(path){try{path=SYSCALLS.getStr(path);FS.rmdir(path);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_stat64(path,buf){try{path=SYSCALLS.getStr(path);return SYSCALLS.doStat(FS.stat,path,buf)}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function ___syscall_unlinkat(dirfd,path,flags){try{path=SYSCALLS.getStr(path);path=SYSCALLS.calculateAt(dirfd,path);if(flags===0){FS.unlink(path)}else if(flags===512){FS.rmdir(path)}else{abort("Invalid flags passed to unlinkat")}return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}var __abort_js=()=>abort("");var createNamedFunction=(name,body)=>Object.defineProperty(body,"name",{value:name});var emval_freelist=[];var emval_handles=[];var BindingError;var throwBindingError=message=>{throw new BindingError(message)};var count_emval_handles=()=>emval_handles.length/2-5-emval_freelist.length;var init_emval=()=>{emval_handles.push(0,1,undefined,1,null,1,true,1,false,1);Module["count_emval_handles"]=count_emval_handles};var Emval={toValue:handle=>{if(!handle){throwBindingError("Cannot use deleted val. handle = "+handle)}return emval_handles[handle]},toHandle:value=>{switch(value){case undefined:return 2;case null:return 4;case true:return 6;case false:return 8;default:{const handle=emval_freelist.pop()||emval_handles.length;emval_handles[handle]=value;emval_handles[handle+1]=1;return handle}}}};var extendError=(baseErrorType,errorName)=>{var errorClass=createNamedFunction(errorName,function(message){this.name=errorName;this.message=message;var stack=new Error(message).stack;if(stack!==undefined){this.stack=this.toString()+"\n"+stack.replace(/^Error(:[^\n]*)?\n/,"")}});errorClass.prototype=Object.create(baseErrorType.prototype);errorClass.prototype.constructor=errorClass;errorClass.prototype.toString=function(){if(this.message===undefined){return this.name}else{return`${this.name}: ${this.message}`}};return errorClass};var PureVirtualError;var embind_init_charCodes=()=>{var codes=new Array(256);for(var i=0;i<256;++i){codes[i]=String.fromCharCode(i)}embind_charCodes=codes};var embind_charCodes;var readLatin1String=ptr=>{var ret="";var c=ptr;while(HEAPU8[c]){ret+=embind_charCodes[HEAPU8[c++]]}return ret};var registeredInstances={};var getBasestPointer=(class_,ptr)=>{if(ptr===undefined){throwBindingError("ptr should not be undefined")}while(class_.baseClass){ptr=class_.upcast(ptr);class_=class_.baseClass}return ptr};var registerInheritedInstance=(class_,ptr,instance)=>{ptr=getBasestPointer(class_,ptr);if(registeredInstances.hasOwnProperty(ptr)){throwBindingError(`Tried to register registered instance: ${ptr}`)}else{registeredInstances[ptr]=instance}};var registeredTypes={};var getTypeName=type=>{var ptr=___getTypeName(type);var rv=readLatin1String(ptr);_free(ptr);return rv};var requireRegisteredType=(rawType,humanName)=>{var impl=registeredTypes[rawType];if(undefined===impl){throwBindingError(`${humanName} has unknown type ${getTypeName(rawType)}`)}return impl};var unregisterInheritedInstance=(class_,ptr)=>{ptr=getBasestPointer(class_,ptr);if(registeredInstances.hasOwnProperty(ptr)){delete registeredInstances[ptr]}else{throwBindingError(`Tried to unregister unregistered instance: ${ptr}`)}};var detachFinalizer=handle=>{};var finalizationRegistry=false;var runDestructor=$$=>{if($$.smartPtr){$$.smartPtrType.rawDestructor($$.smartPtr)}else{$$.ptrType.registeredClass.rawDestructor($$.ptr)}};var releaseClassHandle=$$=>{$$.count.value-=1;var toDelete=0===$$.count.value;if(toDelete){runDestructor($$)}};var downcastPointer=(ptr,ptrClass,desiredClass)=>{if(ptrClass===desiredClass){return ptr}if(undefined===desiredClass.baseClass){return null}var rv=downcastPointer(ptr,ptrClass,desiredClass.baseClass);if(rv===null){return null}return desiredClass.downcast(rv)};var registeredPointers={};var getInheritedInstance=(class_,ptr)=>{ptr=getBasestPointer(class_,ptr);return registeredInstances[ptr]};var InternalError;var throwInternalError=message=>{throw new InternalError(message)};var makeClassHandle=(prototype,record)=>{if(!record.ptrType||!record.ptr){throwInternalError("makeClassHandle requires ptr and ptrType")}var hasSmartPtrType=!!record.smartPtrType;var hasSmartPtr=!!record.smartPtr;if(hasSmartPtrType!==hasSmartPtr){throwInternalError("Both smartPtrType and smartPtr must be specified")}record.count={value:1};return attachFinalizer(Object.create(prototype,{$$:{value:record,writable:true}}))};function RegisteredPointer_fromWireType(ptr){var rawPointer=this.getPointee(ptr);if(!rawPointer){this.destructor(ptr);return null}var registeredInstance=getInheritedInstance(this.registeredClass,rawPointer);if(undefined!==registeredInstance){if(0===registeredInstance.$$.count.value){registeredInstance.$$.ptr=rawPointer;registeredInstance.$$.smartPtr=ptr;return registeredInstance["clone"]()}else{var rv=registeredInstance["clone"]();this.destructor(ptr);return rv}}function makeDefaultHandle(){if(this.isSmartPointer){return makeClassHandle(this.registeredClass.instancePrototype,{ptrType:this.pointeeType,ptr:rawPointer,smartPtrType:this,smartPtr:ptr})}else{return makeClassHandle(this.registeredClass.instancePrototype,{ptrType:this,ptr})}}var actualType=this.registeredClass.getActualType(rawPointer);var registeredPointerRecord=registeredPointers[actualType];if(!registeredPointerRecord){return makeDefaultHandle.call(this)}var toType;if(this.isConst){toType=registeredPointerRecord.constPointerType}else{toType=registeredPointerRecord.pointerType}var dp=downcastPointer(rawPointer,this.registeredClass,toType.registeredClass);if(dp===null){return makeDefaultHandle.call(this)}if(this.isSmartPointer){return makeClassHandle(toType.registeredClass.instancePrototype,{ptrType:toType,ptr:dp,smartPtrType:this,smartPtr:ptr})}else{return makeClassHandle(toType.registeredClass.instancePrototype,{ptrType:toType,ptr:dp})}}var attachFinalizer=handle=>{if("undefined"===typeof FinalizationRegistry){attachFinalizer=handle=>handle;return handle}finalizationRegistry=new FinalizationRegistry(info=>{releaseClassHandle(info.$$)});attachFinalizer=handle=>{var $$=handle.$$;var hasSmartPtr=!!$$.smartPtr;if(hasSmartPtr){var info={$$};finalizationRegistry.register(handle,info,handle)}return handle};detachFinalizer=handle=>finalizationRegistry.unregister(handle);return attachFinalizer(handle)};var __embind_create_inheriting_constructor=(constructorName,wrapperType,properties)=>{constructorName=readLatin1String(constructorName);wrapperType=requireRegisteredType(wrapperType,"wrapper");properties=Emval.toValue(properties);var registeredClass=wrapperType.registeredClass;var wrapperPrototype=registeredClass.instancePrototype;var baseClass=registeredClass.baseClass;var baseClassPrototype=baseClass.instancePrototype;var baseConstructor=registeredClass.baseClass.constructor;var ctor=createNamedFunction(constructorName,function(...args){registeredClass.baseClass.pureVirtualFunctions.forEach(function(name){if(this[name]===baseClassPrototype[name]){throw new PureVirtualError(`Pure virtual function ${name} must be implemented in JavaScript`)}}.bind(this));Object.defineProperty(this,"__parent",{value:wrapperPrototype});this["__construct"](...args)});wrapperPrototype["__construct"]=function __construct(...args){if(this===wrapperPrototype){throwBindingError("Pass correct 'this' to __construct")}var inner=baseConstructor["implement"](this,...args);detachFinalizer(inner);var $$=inner.$$;inner["notifyOnDestruction"]();$$.preservePointerOnDelete=true;Object.defineProperties(this,{$$:{value:$$}});attachFinalizer(this);registerInheritedInstance(registeredClass,$$.ptr,this)};wrapperPrototype["__destruct"]=function __destruct(){if(this===wrapperPrototype){throwBindingError("Pass correct 'this' to __destruct")}detachFinalizer(this);unregisterInheritedInstance(registeredClass,this.$$.ptr)};ctor.prototype=Object.create(wrapperPrototype);Object.assign(ctor.prototype,properties);return Emval.toHandle(ctor)};var structRegistrations={};var runDestructors=destructors=>{while(destructors.length){var ptr=destructors.pop();var del=destructors.pop();del(ptr)}};function readPointer(pointer){return this["fromWireType"](HEAPU32[pointer>>2])}var awaitingDependencies={};var typeDependencies={};var whenDependentTypesAreResolved=(myTypes,dependentTypes,getTypeConverters)=>{myTypes.forEach(type=>typeDependencies[type]=dependentTypes);function onComplete(typeConverters){var myTypeConverters=getTypeConverters(typeConverters);if(myTypeConverters.length!==myTypes.length){throwInternalError("Mismatched type converter count")}for(var i=0;i{if(registeredTypes.hasOwnProperty(dt)){typeConverters[i]=registeredTypes[dt]}else{unregisteredTypes.push(dt);if(!awaitingDependencies.hasOwnProperty(dt)){awaitingDependencies[dt]=[]}awaitingDependencies[dt].push(()=>{typeConverters[i]=registeredTypes[dt];++registered;if(registered===unregisteredTypes.length){onComplete(typeConverters)}})}});if(0===unregisteredTypes.length){onComplete(typeConverters)}};var __embind_finalize_value_object=structType=>{var reg=structRegistrations[structType];delete structRegistrations[structType];var rawConstructor=reg.rawConstructor;var rawDestructor=reg.rawDestructor;var fieldRecords=reg.fields;var fieldTypes=fieldRecords.map(field=>field.getterReturnType).concat(fieldRecords.map(field=>field.setterArgumentType));whenDependentTypesAreResolved([structType],fieldTypes,fieldTypes=>{var fields={};fieldRecords.forEach((field,i)=>{var fieldName=field.fieldName;var getterReturnType=fieldTypes[i];var getter=field.getter;var getterContext=field.getterContext;var setterArgumentType=fieldTypes[i+fieldRecords.length];var setter=field.setter;var setterContext=field.setterContext;fields[fieldName]={read:ptr=>getterReturnType["fromWireType"](getter(getterContext,ptr)),write:(ptr,o)=>{var destructors=[];setter(setterContext,ptr,setterArgumentType["toWireType"](destructors,o));runDestructors(destructors)}}});return[{name:reg.name,fromWireType:ptr=>{var rv={};for(var i in fields){rv[i]=fields[i].read(ptr)}rawDestructor(ptr);return rv},toWireType:(destructors,o)=>{for(var fieldName in fields){if(!(fieldName in o)){throw new TypeError(`Missing field: "${fieldName}"`)}}var ptr=rawConstructor();for(fieldName in fields){fields[fieldName].write(ptr,o[fieldName])}if(destructors!==null){destructors.push(rawDestructor,ptr)}return ptr},argPackAdvance:GenericWireTypeSize,readValueFromPointer:readPointer,destructorFunction:rawDestructor}]})};var __embind_register_bigint=(primitiveType,name,size,minRange,maxRange)=>{};function sharedRegisterType(rawType,registeredInstance,options={}){var name=registeredInstance.name;if(!rawType){throwBindingError(`type "${name}" must have a positive integer typeid pointer`)}if(registeredTypes.hasOwnProperty(rawType)){if(options.ignoreDuplicateRegistrations){return}else{throwBindingError(`Cannot register type '${name}' twice`)}}registeredTypes[rawType]=registeredInstance;delete typeDependencies[rawType];if(awaitingDependencies.hasOwnProperty(rawType)){var callbacks=awaitingDependencies[rawType];delete awaitingDependencies[rawType];callbacks.forEach(cb=>cb())}}function registerType(rawType,registeredInstance,options={}){return sharedRegisterType(rawType,registeredInstance,options)}var GenericWireTypeSize=8;var __embind_register_bool=(rawType,name,trueValue,falseValue)=>{name=readLatin1String(name);registerType(rawType,{name,fromWireType:function(wt){return!!wt},toWireType:function(destructors,o){return o?trueValue:falseValue},argPackAdvance:GenericWireTypeSize,readValueFromPointer:function(pointer){return this["fromWireType"](HEAPU8[pointer])},destructorFunction:null})};var shallowCopyInternalPointer=o=>({count:o.count,deleteScheduled:o.deleteScheduled,preservePointerOnDelete:o.preservePointerOnDelete,ptr:o.ptr,ptrType:o.ptrType,smartPtr:o.smartPtr,smartPtrType:o.smartPtrType});var throwInstanceAlreadyDeleted=obj=>{function getInstanceTypeName(handle){return handle.$$.ptrType.registeredClass.name}throwBindingError(getInstanceTypeName(obj)+" instance already deleted")};var deletionQueue=[];var flushPendingDeletes=()=>{while(deletionQueue.length){var obj=deletionQueue.pop();obj.$$.deleteScheduled=false;obj["delete"]()}};var delayFunction;var init_ClassHandle=()=>{Object.assign(ClassHandle.prototype,{isAliasOf(other){if(!(this instanceof ClassHandle)){return false}if(!(other instanceof ClassHandle)){return false}var leftClass=this.$$.ptrType.registeredClass;var left=this.$$.ptr;other.$$=other.$$;var rightClass=other.$$.ptrType.registeredClass;var right=other.$$.ptr;while(leftClass.baseClass){left=leftClass.upcast(left);leftClass=leftClass.baseClass}while(rightClass.baseClass){right=rightClass.upcast(right);rightClass=rightClass.baseClass}return leftClass===rightClass&&left===right},clone(){if(!this.$$.ptr){throwInstanceAlreadyDeleted(this)}if(this.$$.preservePointerOnDelete){this.$$.count.value+=1;return this}else{var clone=attachFinalizer(Object.create(Object.getPrototypeOf(this),{$$:{value:shallowCopyInternalPointer(this.$$)}}));clone.$$.count.value+=1;clone.$$.deleteScheduled=false;return clone}},delete(){if(!this.$$.ptr){throwInstanceAlreadyDeleted(this)}if(this.$$.deleteScheduled&&!this.$$.preservePointerOnDelete){throwBindingError("Object already scheduled for deletion")}detachFinalizer(this);releaseClassHandle(this.$$);if(!this.$$.preservePointerOnDelete){this.$$.smartPtr=undefined;this.$$.ptr=undefined}},isDeleted(){return!this.$$.ptr},deleteLater(){if(!this.$$.ptr){throwInstanceAlreadyDeleted(this)}if(this.$$.deleteScheduled&&!this.$$.preservePointerOnDelete){throwBindingError("Object already scheduled for deletion")}deletionQueue.push(this);if(deletionQueue.length===1&&delayFunction){delayFunction(flushPendingDeletes)}this.$$.deleteScheduled=true;return this}})};function ClassHandle(){}var ensureOverloadTable=(proto,methodName,humanName)=>{if(undefined===proto[methodName].overloadTable){var prevFunc=proto[methodName];proto[methodName]=function(...args){if(!proto[methodName].overloadTable.hasOwnProperty(args.length)){throwBindingError(`Function '${humanName}' called with an invalid number of arguments (${args.length}) - expects one of (${proto[methodName].overloadTable})!`)}return proto[methodName].overloadTable[args.length].apply(this,args)};proto[methodName].overloadTable=[];proto[methodName].overloadTable[prevFunc.argCount]=prevFunc}};var exposePublicSymbol=(name,value,numArguments)=>{if(Module.hasOwnProperty(name)){if(undefined===numArguments||undefined!==Module[name].overloadTable&&undefined!==Module[name].overloadTable[numArguments]){throwBindingError(`Cannot register public name '${name}' twice`)}ensureOverloadTable(Module,name,name);if(Module[name].overloadTable.hasOwnProperty(numArguments)){throwBindingError(`Cannot register multiple overloads of a function with the same number of arguments (${numArguments})!`)}Module[name].overloadTable[numArguments]=value}else{Module[name]=value;Module[name].argCount=numArguments}};var char_0=48;var char_9=57;var makeLegalFunctionName=name=>{name=name.replace(/[^a-zA-Z0-9_]/g,"$");var f=name.charCodeAt(0);if(f>=char_0&&f<=char_9){return`_${name}`}return name};function RegisteredClass(name,constructor,instancePrototype,rawDestructor,baseClass,getActualType,upcast,downcast){this.name=name;this.constructor=constructor;this.instancePrototype=instancePrototype;this.rawDestructor=rawDestructor;this.baseClass=baseClass;this.getActualType=getActualType;this.upcast=upcast;this.downcast=downcast;this.pureVirtualFunctions=[]}var upcastPointer=(ptr,ptrClass,desiredClass)=>{while(ptrClass!==desiredClass){if(!ptrClass.upcast){throwBindingError(`Expected null or instance of ${desiredClass.name}, got an instance of ${ptrClass.name}`)}ptr=ptrClass.upcast(ptr);ptrClass=ptrClass.baseClass}return ptr};function constNoSmartPtrRawPointerToWireType(destructors,handle){if(handle===null){if(this.isReference){throwBindingError(`null is not a valid ${this.name}`)}return 0}if(!handle.$$){throwBindingError(`Cannot pass "${embindRepr(handle)}" as a ${this.name}`)}if(!handle.$$.ptr){throwBindingError(`Cannot pass deleted object as a pointer of type ${this.name}`)}var handleClass=handle.$$.ptrType.registeredClass;var ptr=upcastPointer(handle.$$.ptr,handleClass,this.registeredClass);return ptr}function genericPointerToWireType(destructors,handle){var ptr;if(handle===null){if(this.isReference){throwBindingError(`null is not a valid ${this.name}`)}if(this.isSmartPointer){ptr=this.rawConstructor();if(destructors!==null){destructors.push(this.rawDestructor,ptr)}return ptr}else{return 0}}if(!handle||!handle.$$){throwBindingError(`Cannot pass "${embindRepr(handle)}" as a ${this.name}`)}if(!handle.$$.ptr){throwBindingError(`Cannot pass deleted object as a pointer of type ${this.name}`)}if(!this.isConst&&handle.$$.ptrType.isConst){throwBindingError(`Cannot convert argument of type ${handle.$$.smartPtrType?handle.$$.smartPtrType.name:handle.$$.ptrType.name} to parameter type ${this.name}`)}var handleClass=handle.$$.ptrType.registeredClass;ptr=upcastPointer(handle.$$.ptr,handleClass,this.registeredClass);if(this.isSmartPointer){if(undefined===handle.$$.smartPtr){throwBindingError("Passing raw pointer to smart pointer is illegal")}switch(this.sharingPolicy){case 0:if(handle.$$.smartPtrType===this){ptr=handle.$$.smartPtr}else{throwBindingError(`Cannot convert argument of type ${handle.$$.smartPtrType?handle.$$.smartPtrType.name:handle.$$.ptrType.name} to parameter type ${this.name}`)}break;case 1:ptr=handle.$$.smartPtr;break;case 2:if(handle.$$.smartPtrType===this){ptr=handle.$$.smartPtr}else{var clonedHandle=handle["clone"]();ptr=this.rawShare(ptr,Emval.toHandle(()=>clonedHandle["delete"]()));if(destructors!==null){destructors.push(this.rawDestructor,ptr)}}break;default:throwBindingError("Unsupporting sharing policy")}}return ptr}function nonConstNoSmartPtrRawPointerToWireType(destructors,handle){if(handle===null){if(this.isReference){throwBindingError(`null is not a valid ${this.name}`)}return 0}if(!handle.$$){throwBindingError(`Cannot pass "${embindRepr(handle)}" as a ${this.name}`)}if(!handle.$$.ptr){throwBindingError(`Cannot pass deleted object as a pointer of type ${this.name}`)}if(handle.$$.ptrType.isConst){throwBindingError(`Cannot convert argument of type ${handle.$$.ptrType.name} to parameter type ${this.name}`)}var handleClass=handle.$$.ptrType.registeredClass;var ptr=upcastPointer(handle.$$.ptr,handleClass,this.registeredClass);return ptr}var init_RegisteredPointer=()=>{Object.assign(RegisteredPointer.prototype,{getPointee(ptr){if(this.rawGetPointee){ptr=this.rawGetPointee(ptr)}return ptr},destructor(ptr){this.rawDestructor?.(ptr)},argPackAdvance:GenericWireTypeSize,readValueFromPointer:readPointer,fromWireType:RegisteredPointer_fromWireType})};function RegisteredPointer(name,registeredClass,isReference,isConst,isSmartPointer,pointeeType,sharingPolicy,rawGetPointee,rawConstructor,rawShare,rawDestructor){this.name=name;this.registeredClass=registeredClass;this.isReference=isReference;this.isConst=isConst;this.isSmartPointer=isSmartPointer;this.pointeeType=pointeeType;this.sharingPolicy=sharingPolicy;this.rawGetPointee=rawGetPointee;this.rawConstructor=rawConstructor;this.rawShare=rawShare;this.rawDestructor=rawDestructor;if(!isSmartPointer&®isteredClass.baseClass===undefined){if(isConst){this["toWireType"]=constNoSmartPtrRawPointerToWireType;this.destructorFunction=null}else{this["toWireType"]=nonConstNoSmartPtrRawPointerToWireType;this.destructorFunction=null}}else{this["toWireType"]=genericPointerToWireType}}var replacePublicSymbol=(name,value,numArguments)=>{if(!Module.hasOwnProperty(name)){throwInternalError("Replacing nonexistent public symbol")}if(undefined!==Module[name].overloadTable&&undefined!==numArguments){Module[name].overloadTable[numArguments]=value}else{Module[name]=value;Module[name].argCount=numArguments}};var dynCallLegacy=(sig,ptr,args)=>{sig=sig.replace(/p/g,"i");var f=Module["dynCall_"+sig];return f(ptr,...args)};var wasmTable;var getWasmTableEntry=funcPtr=>wasmTable.get(funcPtr);var dynCall=(sig,ptr,args=[])=>{if(sig.includes("j")){return dynCallLegacy(sig,ptr,args)}var rtn=getWasmTableEntry(ptr)(...args);return rtn};var getDynCaller=(sig,ptr)=>(...args)=>dynCall(sig,ptr,args);var embind__requireFunction=(signature,rawFunction)=>{signature=readLatin1String(signature);function makeDynCaller(){if(signature.includes("j")){return getDynCaller(signature,rawFunction)}return getWasmTableEntry(rawFunction)}var fp=makeDynCaller();if(typeof fp!="function"){throwBindingError(`unknown function pointer with signature ${signature}: ${rawFunction}`)}return fp};var UnboundTypeError;var throwUnboundTypeError=(message,types)=>{var unboundTypes=[];var seen={};function visit(type){if(seen[type]){return}if(registeredTypes[type]){return}if(typeDependencies[type]){typeDependencies[type].forEach(visit);return}unboundTypes.push(type);seen[type]=true}types.forEach(visit);throw new UnboundTypeError(`${message}: `+unboundTypes.map(getTypeName).join([", "]))};var __embind_register_class=(rawType,rawPointerType,rawConstPointerType,baseClassRawType,getActualTypeSignature,getActualType,upcastSignature,upcast,downcastSignature,downcast,name,destructorSignature,rawDestructor)=>{name=readLatin1String(name);getActualType=embind__requireFunction(getActualTypeSignature,getActualType);upcast&&=embind__requireFunction(upcastSignature,upcast);downcast&&=embind__requireFunction(downcastSignature,downcast);rawDestructor=embind__requireFunction(destructorSignature,rawDestructor);var legalFunctionName=makeLegalFunctionName(name);exposePublicSymbol(legalFunctionName,function(){throwUnboundTypeError(`Cannot construct ${name} due to unbound types`,[baseClassRawType])});whenDependentTypesAreResolved([rawType,rawPointerType,rawConstPointerType],baseClassRawType?[baseClassRawType]:[],base=>{base=base[0];var baseClass;var basePrototype;if(baseClassRawType){baseClass=base.registeredClass;basePrototype=baseClass.instancePrototype}else{basePrototype=ClassHandle.prototype}var constructor=createNamedFunction(name,function(...args){if(Object.getPrototypeOf(this)!==instancePrototype){throw new BindingError("Use 'new' to construct "+name)}if(undefined===registeredClass.constructor_body){throw new BindingError(name+" has no accessible constructor")}var body=registeredClass.constructor_body[args.length];if(undefined===body){throw new BindingError(`Tried to invoke ctor of ${name} with invalid number of parameters (${args.length}) - expected (${Object.keys(registeredClass.constructor_body).toString()}) parameters instead!`)}return body.apply(this,args)});var instancePrototype=Object.create(basePrototype,{constructor:{value:constructor}});constructor.prototype=instancePrototype;var registeredClass=new RegisteredClass(name,constructor,instancePrototype,rawDestructor,baseClass,getActualType,upcast,downcast);if(registeredClass.baseClass){registeredClass.baseClass.__derivedClasses??=[];registeredClass.baseClass.__derivedClasses.push(registeredClass)}var referenceConverter=new RegisteredPointer(name,registeredClass,true,false,false);var pointerConverter=new RegisteredPointer(name+"*",registeredClass,false,false,false);var constPointerConverter=new RegisteredPointer(name+" const*",registeredClass,false,true,false);registeredPointers[rawType]={pointerType:pointerConverter,constPointerType:constPointerConverter};replacePublicSymbol(legalFunctionName,constructor);return[referenceConverter,pointerConverter,constPointerConverter]})};function usesDestructorStack(argTypes){for(var i=1;i{var array=[];for(var i=0;i>2])}return array};var getFunctionName=signature=>{signature=signature.trim();const argsIndex=signature.indexOf("(");if(argsIndex!==-1){return signature.substr(0,argsIndex)}else{return signature}};var __embind_register_class_class_function=(rawClassType,methodName,argCount,rawArgTypesAddr,invokerSignature,rawInvoker,fn,isAsync,isNonnullReturn)=>{var rawArgTypes=heap32VectorToArray(argCount,rawArgTypesAddr);methodName=readLatin1String(methodName);methodName=getFunctionName(methodName);rawInvoker=embind__requireFunction(invokerSignature,rawInvoker);whenDependentTypesAreResolved([],[rawClassType],classType=>{classType=classType[0];var humanName=`${classType.name}.${methodName}`;function unboundTypesHandler(){throwUnboundTypeError(`Cannot call ${humanName} due to unbound types`,rawArgTypes)}if(methodName.startsWith("@@")){methodName=Symbol[methodName.substring(2)]}var proto=classType.registeredClass.constructor;if(undefined===proto[methodName]){unboundTypesHandler.argCount=argCount-1;proto[methodName]=unboundTypesHandler}else{ensureOverloadTable(proto,methodName,humanName);proto[methodName].overloadTable[argCount-1]=unboundTypesHandler}whenDependentTypesAreResolved([],rawArgTypes,argTypes=>{var invokerArgsArray=[argTypes[0],null].concat(argTypes.slice(1));var func=craftInvokerFunction(humanName,invokerArgsArray,null,rawInvoker,fn,isAsync);if(undefined===proto[methodName].overloadTable){func.argCount=argCount-1;proto[methodName]=func}else{proto[methodName].overloadTable[argCount-1]=func}if(classType.registeredClass.__derivedClasses){for(const derivedClass of classType.registeredClass.__derivedClasses){if(!derivedClass.constructor.hasOwnProperty(methodName)){derivedClass.constructor[methodName]=func}}}return[]});return[]})};var __embind_register_class_constructor=(rawClassType,argCount,rawArgTypesAddr,invokerSignature,invoker,rawConstructor)=>{var rawArgTypes=heap32VectorToArray(argCount,rawArgTypesAddr);invoker=embind__requireFunction(invokerSignature,invoker);whenDependentTypesAreResolved([],[rawClassType],classType=>{classType=classType[0];var humanName=`constructor ${classType.name}`;if(undefined===classType.registeredClass.constructor_body){classType.registeredClass.constructor_body=[]}if(undefined!==classType.registeredClass.constructor_body[argCount-1]){throw new BindingError(`Cannot register multiple constructors with identical number of parameters (${argCount-1}) for class '${classType.name}'! Overload resolution is currently only performed using the parameter count, not actual type info!`)}classType.registeredClass.constructor_body[argCount-1]=()=>{throwUnboundTypeError(`Cannot construct ${classType.name} due to unbound types`,rawArgTypes)};whenDependentTypesAreResolved([],rawArgTypes,argTypes=>{argTypes.splice(1,0,null);classType.registeredClass.constructor_body[argCount-1]=craftInvokerFunction(humanName,argTypes,null,invoker,rawConstructor);return[]});return[]})};var __embind_register_class_function=(rawClassType,methodName,argCount,rawArgTypesAddr,invokerSignature,rawInvoker,context,isPureVirtual,isAsync,isNonnullReturn)=>{var rawArgTypes=heap32VectorToArray(argCount,rawArgTypesAddr);methodName=readLatin1String(methodName);methodName=getFunctionName(methodName);rawInvoker=embind__requireFunction(invokerSignature,rawInvoker);whenDependentTypesAreResolved([],[rawClassType],classType=>{classType=classType[0];var humanName=`${classType.name}.${methodName}`;if(methodName.startsWith("@@")){methodName=Symbol[methodName.substring(2)]}if(isPureVirtual){classType.registeredClass.pureVirtualFunctions.push(methodName)}function unboundTypesHandler(){throwUnboundTypeError(`Cannot call ${humanName} due to unbound types`,rawArgTypes)}var proto=classType.registeredClass.instancePrototype;var method=proto[methodName];if(undefined===method||undefined===method.overloadTable&&method.className!==classType.name&&method.argCount===argCount-2){unboundTypesHandler.argCount=argCount-2;unboundTypesHandler.className=classType.name;proto[methodName]=unboundTypesHandler}else{ensureOverloadTable(proto,methodName,humanName);proto[methodName].overloadTable[argCount-2]=unboundTypesHandler}whenDependentTypesAreResolved([],rawArgTypes,argTypes=>{var memberFunction=craftInvokerFunction(humanName,argTypes,classType,rawInvoker,context,isAsync);if(undefined===proto[methodName].overloadTable){memberFunction.argCount=argCount-2;proto[methodName]=memberFunction}else{proto[methodName].overloadTable[argCount-2]=memberFunction}return[]});return[]})};var validateThis=(this_,classType,humanName)=>{if(!(this_ instanceof Object)){throwBindingError(`${humanName} with invalid "this": ${this_}`)}if(!(this_ instanceof classType.registeredClass.constructor)){throwBindingError(`${humanName} incompatible with "this" of type ${this_.constructor.name}`)}if(!this_.$$.ptr){throwBindingError(`cannot call emscripten binding method ${humanName} on deleted object`)}return upcastPointer(this_.$$.ptr,this_.$$.ptrType.registeredClass,classType.registeredClass)};var __embind_register_class_property=(classType,fieldName,getterReturnType,getterSignature,getter,getterContext,setterArgumentType,setterSignature,setter,setterContext)=>{fieldName=readLatin1String(fieldName);getter=embind__requireFunction(getterSignature,getter);whenDependentTypesAreResolved([],[classType],classType=>{classType=classType[0];var humanName=`${classType.name}.${fieldName}`;var desc={get(){throwUnboundTypeError(`Cannot access ${humanName} due to unbound types`,[getterReturnType,setterArgumentType])},enumerable:true,configurable:true};if(setter){desc.set=()=>throwUnboundTypeError(`Cannot access ${humanName} due to unbound types`,[getterReturnType,setterArgumentType])}else{desc.set=v=>throwBindingError(humanName+" is a read-only property")}Object.defineProperty(classType.registeredClass.instancePrototype,fieldName,desc);whenDependentTypesAreResolved([],setter?[getterReturnType,setterArgumentType]:[getterReturnType],types=>{var getterReturnType=types[0];var desc={get(){var ptr=validateThis(this,classType,humanName+" getter");return getterReturnType["fromWireType"](getter(getterContext,ptr))},enumerable:true};if(setter){setter=embind__requireFunction(setterSignature,setter);var setterArgumentType=types[1];desc.set=function(v){var ptr=validateThis(this,classType,humanName+" setter");var destructors=[];setter(setterContext,ptr,setterArgumentType["toWireType"](destructors,v));runDestructors(destructors)}}Object.defineProperty(classType.registeredClass.instancePrototype,fieldName,desc);return[]});return[]})};var __emval_decref=handle=>{if(handle>9&&0===--emval_handles[handle+1]){emval_handles[handle]=undefined;emval_freelist.push(handle)}};var EmValType={name:"emscripten::val",fromWireType:handle=>{var rv=Emval.toValue(handle);__emval_decref(handle);return rv},toWireType:(destructors,value)=>Emval.toHandle(value),argPackAdvance:GenericWireTypeSize,readValueFromPointer:readPointer,destructorFunction:null};var __embind_register_emval=rawType=>registerType(rawType,EmValType);var embindRepr=v=>{if(v===null){return"null"}var t=typeof v;if(t==="object"||t==="array"||t==="function"){return v.toString()}else{return""+v}};var floatReadValueFromPointer=(name,width)=>{switch(width){case 4:return function(pointer){return this["fromWireType"](HEAPF32[pointer>>2])};case 8:return function(pointer){return this["fromWireType"](HEAPF64[pointer>>3])};default:throw new TypeError(`invalid float width (${width}): ${name}`)}};var __embind_register_float=(rawType,name,size)=>{name=readLatin1String(name);registerType(rawType,{name,fromWireType:value=>value,toWireType:(destructors,value)=>value,argPackAdvance:GenericWireTypeSize,readValueFromPointer:floatReadValueFromPointer(name,size),destructorFunction:null})};var __embind_register_function=(name,argCount,rawArgTypesAddr,signature,rawInvoker,fn,isAsync,isNonnullReturn)=>{var argTypes=heap32VectorToArray(argCount,rawArgTypesAddr);name=readLatin1String(name);name=getFunctionName(name);rawInvoker=embind__requireFunction(signature,rawInvoker);exposePublicSymbol(name,function(){throwUnboundTypeError(`Cannot call ${name} due to unbound types`,argTypes)},argCount-1);whenDependentTypesAreResolved([],argTypes,argTypes=>{var invokerArgsArray=[argTypes[0],null].concat(argTypes.slice(1));replacePublicSymbol(name,craftInvokerFunction(name,invokerArgsArray,null,rawInvoker,fn,isAsync),argCount-1);return[]})};var integerReadValueFromPointer=(name,width,signed)=>{switch(width){case 1:return signed?pointer=>HEAP8[pointer]:pointer=>HEAPU8[pointer];case 2:return signed?pointer=>HEAP16[pointer>>1]:pointer=>HEAPU16[pointer>>1];case 4:return signed?pointer=>HEAP32[pointer>>2]:pointer=>HEAPU32[pointer>>2];default:throw new TypeError(`invalid integer width (${width}): ${name}`)}};var __embind_register_integer=(primitiveType,name,size,minRange,maxRange)=>{name=readLatin1String(name);if(maxRange===-1){maxRange=4294967295}var fromWireType=value=>value;if(minRange===0){var bitshift=32-8*size;fromWireType=value=>value<>>bitshift}var isUnsignedType=name.includes("unsigned");var checkAssertions=(value,toTypeName)=>{};var toWireType;if(isUnsignedType){toWireType=function(destructors,value){checkAssertions(value,this.name);return value>>>0}}else{toWireType=function(destructors,value){checkAssertions(value,this.name);return value}}registerType(primitiveType,{name,fromWireType,toWireType,argPackAdvance:GenericWireTypeSize,readValueFromPointer:integerReadValueFromPointer(name,size,minRange!==0),destructorFunction:null})};var __embind_register_memory_view=(rawType,dataTypeIndex,name)=>{var typeMapping=[Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array];var TA=typeMapping[dataTypeIndex];function decodeMemoryView(handle){var size=HEAPU32[handle>>2];var data=HEAPU32[handle+4>>2];return new TA(HEAP8.buffer,data,size)}name=readLatin1String(name);registerType(rawType,{name,fromWireType:decodeMemoryView,argPackAdvance:GenericWireTypeSize,readValueFromPointer:decodeMemoryView},{ignoreDuplicateRegistrations:true})};var EmValOptionalType=Object.assign({optional:true},EmValType);var __embind_register_optional=(rawOptionalType,rawType)=>{registerType(rawOptionalType,EmValOptionalType)};var __embind_register_smart_ptr=(rawType,rawPointeeType,name,sharingPolicy,getPointeeSignature,rawGetPointee,constructorSignature,rawConstructor,shareSignature,rawShare,destructorSignature,rawDestructor)=>{name=readLatin1String(name);rawGetPointee=embind__requireFunction(getPointeeSignature,rawGetPointee);rawConstructor=embind__requireFunction(constructorSignature,rawConstructor);rawShare=embind__requireFunction(shareSignature,rawShare);rawDestructor=embind__requireFunction(destructorSignature,rawDestructor);whenDependentTypesAreResolved([rawType],[rawPointeeType],pointeeType=>{pointeeType=pointeeType[0];var registeredPointer=new RegisteredPointer(name,pointeeType.registeredClass,false,false,true,pointeeType,sharingPolicy,rawGetPointee,rawConstructor,rawShare,rawDestructor);return[registeredPointer]})};var __embind_register_std_string=(rawType,name)=>{name=readLatin1String(name);var stdStringIsUTF8=true;registerType(rawType,{name,fromWireType(value){var length=HEAPU32[value>>2];var payload=value+4;var str;if(stdStringIsUTF8){var decodeStartPtr=payload;for(var i=0;i<=length;++i){var currentBytePtr=payload+i;if(i==length||HEAPU8[currentBytePtr]==0){var maxRead=currentBytePtr-decodeStartPtr;var stringSegment=UTF8ToString(decodeStartPtr,maxRead);if(str===undefined){str=stringSegment}else{str+=String.fromCharCode(0);str+=stringSegment}decodeStartPtr=currentBytePtr+1}}}else{var a=new Array(length);for(var i=0;i>2]=length;if(stdStringIsUTF8&&valueIsOfTypeString){stringToUTF8(value,ptr,length+1)}else{if(valueIsOfTypeString){for(var i=0;i255){_free(ptr);throwBindingError("String has UTF-16 code units that do not fit in 8 bits")}HEAPU8[ptr+i]=charCode}}else{for(var i=0;i{var endPtr=ptr;var idx=endPtr>>1;var maxIdx=idx+maxBytesToRead/2;while(!(idx>=maxIdx)&&HEAPU16[idx])++idx;endPtr=idx<<1;if(endPtr-ptr>32&&UTF16Decoder)return UTF16Decoder.decode(HEAPU8.subarray(ptr,endPtr));var str="";for(var i=0;!(i>=maxBytesToRead/2);++i){var codeUnit=HEAP16[ptr+i*2>>1];if(codeUnit==0)break;str+=String.fromCharCode(codeUnit)}return str};var stringToUTF16=(str,outPtr,maxBytesToWrite)=>{maxBytesToWrite??=2147483647;if(maxBytesToWrite<2)return 0;maxBytesToWrite-=2;var startPtr=outPtr;var numCharsToWrite=maxBytesToWrite>1]=codeUnit;outPtr+=2}HEAP16[outPtr>>1]=0;return outPtr-startPtr};var lengthBytesUTF16=str=>str.length*2;var UTF32ToString=(ptr,maxBytesToRead)=>{var i=0;var str="";while(!(i>=maxBytesToRead/4)){var utf32=HEAP32[ptr+i*4>>2];if(utf32==0)break;++i;if(utf32>=65536){var ch=utf32-65536;str+=String.fromCharCode(55296|ch>>10,56320|ch&1023)}else{str+=String.fromCharCode(utf32)}}return str};var stringToUTF32=(str,outPtr,maxBytesToWrite)=>{maxBytesToWrite??=2147483647;if(maxBytesToWrite<4)return 0;var startPtr=outPtr;var endPtr=startPtr+maxBytesToWrite-4;for(var i=0;i=55296&&codeUnit<=57343){var trailSurrogate=str.charCodeAt(++i);codeUnit=65536+((codeUnit&1023)<<10)|trailSurrogate&1023}HEAP32[outPtr>>2]=codeUnit;outPtr+=4;if(outPtr+4>endPtr)break}HEAP32[outPtr>>2]=0;return outPtr-startPtr};var lengthBytesUTF32=str=>{var len=0;for(var i=0;i=55296&&codeUnit<=57343)++i;len+=4}return len};var __embind_register_std_wstring=(rawType,charSize,name)=>{name=readLatin1String(name);var decodeString,encodeString,readCharAt,lengthBytesUTF;if(charSize===2){decodeString=UTF16ToString;encodeString=stringToUTF16;lengthBytesUTF=lengthBytesUTF16;readCharAt=pointer=>HEAPU16[pointer>>1]}else if(charSize===4){decodeString=UTF32ToString;encodeString=stringToUTF32;lengthBytesUTF=lengthBytesUTF32;readCharAt=pointer=>HEAPU32[pointer>>2]}registerType(rawType,{name,fromWireType:value=>{var length=HEAPU32[value>>2];var str;var decodeStartPtr=value+4;for(var i=0;i<=length;++i){var currentBytePtr=value+4+i*charSize;if(i==length||readCharAt(currentBytePtr)==0){var maxReadBytes=currentBytePtr-decodeStartPtr;var stringSegment=decodeString(decodeStartPtr,maxReadBytes);if(str===undefined){str=stringSegment}else{str+=String.fromCharCode(0);str+=stringSegment}decodeStartPtr=currentBytePtr+charSize}}_free(value);return str},toWireType:(destructors,value)=>{if(!(typeof value=="string")){throwBindingError(`Cannot pass non-string to C++ string type ${name}`)}var length=lengthBytesUTF(value);var ptr=_malloc(4+length+charSize);HEAPU32[ptr>>2]=length/charSize;encodeString(value,ptr+4,length+charSize);if(destructors!==null){destructors.push(_free,ptr)}return ptr},argPackAdvance:GenericWireTypeSize,readValueFromPointer:readPointer,destructorFunction(ptr){_free(ptr)}})};var __embind_register_value_object=(rawType,name,constructorSignature,rawConstructor,destructorSignature,rawDestructor)=>{structRegistrations[rawType]={name:readLatin1String(name),rawConstructor:embind__requireFunction(constructorSignature,rawConstructor),rawDestructor:embind__requireFunction(destructorSignature,rawDestructor),fields:[]}};var __embind_register_value_object_field=(structType,fieldName,getterReturnType,getterSignature,getter,getterContext,setterArgumentType,setterSignature,setter,setterContext)=>{structRegistrations[structType].fields.push({fieldName:readLatin1String(fieldName),getterReturnType,getter:embind__requireFunction(getterSignature,getter),getterContext,setterArgumentType,setter:embind__requireFunction(setterSignature,setter),setterContext})};var __embind_register_void=(rawType,name)=>{name=readLatin1String(name);registerType(rawType,{isVoid:true,name,argPackAdvance:0,fromWireType:()=>undefined,toWireType:(destructors,o)=>undefined})};var __emscripten_fs_load_embedded_files=ptr=>{do{var name_addr=HEAPU32[ptr>>2];ptr+=4;var len=HEAPU32[ptr>>2];ptr+=4;var content=HEAPU32[ptr>>2];ptr+=4;var name=UTF8ToString(name_addr);FS.createPath("/",PATH.dirname(name),true,true);FS.createDataFile(name,null,HEAP8.subarray(content,content+len),true,true,true)}while(HEAPU32[ptr>>2])};var __emscripten_memcpy_js=(dest,src,num)=>HEAPU8.copyWithin(dest,src,src+num);var runtimeKeepaliveCounter=0;var __emscripten_runtime_keepalive_clear=()=>{noExitRuntime=false;runtimeKeepaliveCounter=0};var emval_returnValue=(returnType,destructorsRef,handle)=>{var destructors=[];var result=returnType["toWireType"](destructors,handle);if(destructors.length){HEAPU32[destructorsRef>>2]=Emval.toHandle(destructors)}return result};var __emval_as=(handle,returnType,destructorsRef)=>{handle=Emval.toValue(handle);returnType=requireRegisteredType(returnType,"emval::as");return emval_returnValue(returnType,destructorsRef,handle)};var emval_methodCallers=[];var __emval_call=(caller,handle,destructorsRef,args)=>{caller=emval_methodCallers[caller];handle=Emval.toValue(handle);return caller(null,handle,destructorsRef,args)};var emval_symbols={};var getStringOrSymbol=address=>{var symbol=emval_symbols[address];if(symbol===undefined){return readLatin1String(address)}return symbol};var __emval_call_method=(caller,objHandle,methodName,destructorsRef,args)=>{caller=emval_methodCallers[caller];objHandle=Emval.toValue(objHandle);methodName=getStringOrSymbol(methodName);return caller(objHandle,objHandle[methodName],destructorsRef,args)};var emval_get_global=()=>{if(typeof globalThis=="object"){return globalThis}function testGlobal(obj){obj["$$$embind_global$$$"]=obj;var success=typeof $$$embind_global$$$=="object"&&obj["$$$embind_global$$$"]==obj;if(!success){delete obj["$$$embind_global$$$"]}return success}if(typeof $$$embind_global$$$=="object"){return $$$embind_global$$$}if(typeof global=="object"&&testGlobal(global)){$$$embind_global$$$=global}else if(typeof self=="object"&&testGlobal(self)){$$$embind_global$$$=self}if(typeof $$$embind_global$$$=="object"){return $$$embind_global$$$}throw Error("unable to get global object.")};var __emval_get_global=name=>{if(name===0){return Emval.toHandle(emval_get_global())}else{name=getStringOrSymbol(name);return Emval.toHandle(emval_get_global()[name])}};var emval_addMethodCaller=caller=>{var id=emval_methodCallers.length;emval_methodCallers.push(caller);return id};var emval_lookupTypes=(argCount,argTypes)=>{var a=new Array(argCount);for(var i=0;i>2],"parameter "+i)}return a};var reflectConstruct=Reflect.construct;var __emval_get_method_caller=(argCount,argTypes,kind)=>{var types=emval_lookupTypes(argCount,argTypes);var retType=types.shift();argCount--;var argN=new Array(argCount);var invokerFunction=(obj,func,destructorsRef,args)=>{var offset=0;for(var i=0;it.name).join(", ")}) => ${retType.name}>`;return emval_addMethodCaller(createNamedFunction(functionName,invokerFunction))};var __emval_get_module_property=name=>{name=getStringOrSymbol(name);return Emval.toHandle(Module[name])};var __emval_get_property=(handle,key)=>{handle=Emval.toValue(handle);key=Emval.toValue(key);return Emval.toHandle(handle[key])};var __emval_incref=handle=>{if(handle>9){emval_handles[handle+1]+=1}};var __emval_new_cstring=v=>Emval.toHandle(getStringOrSymbol(v));var __emval_run_destructors=handle=>{var destructors=Emval.toValue(handle);runDestructors(destructors);__emval_decref(handle)};var __emval_take_value=(type,arg)=>{type=requireRegisteredType(type,"_emval_take_value");var v=type["readValueFromPointer"](arg);return Emval.toHandle(v)};var __emval_typeof=handle=>{handle=Emval.toValue(handle);return Emval.toHandle(typeof handle)};function __gmtime_js(time_low,time_high,tmPtr){var time=convertI32PairToI53Checked(time_low,time_high);var date=new Date(time*1e3);HEAP32[tmPtr>>2]=date.getUTCSeconds();HEAP32[tmPtr+4>>2]=date.getUTCMinutes();HEAP32[tmPtr+8>>2]=date.getUTCHours();HEAP32[tmPtr+12>>2]=date.getUTCDate();HEAP32[tmPtr+16>>2]=date.getUTCMonth();HEAP32[tmPtr+20>>2]=date.getUTCFullYear()-1900;HEAP32[tmPtr+24>>2]=date.getUTCDay();var start=Date.UTC(date.getUTCFullYear(),0,1,0,0,0,0);var yday=(date.getTime()-start)/(1e3*60*60*24)|0;HEAP32[tmPtr+28>>2]=yday}var isLeapYear=year=>year%4===0&&(year%100!==0||year%400===0);var MONTH_DAYS_LEAP_CUMULATIVE=[0,31,60,91,121,152,182,213,244,274,305,335];var MONTH_DAYS_REGULAR_CUMULATIVE=[0,31,59,90,120,151,181,212,243,273,304,334];var ydayFromDate=date=>{var leap=isLeapYear(date.getFullYear());var monthDaysCumulative=leap?MONTH_DAYS_LEAP_CUMULATIVE:MONTH_DAYS_REGULAR_CUMULATIVE;var yday=monthDaysCumulative[date.getMonth()]+date.getDate()-1;return yday};function __localtime_js(time_low,time_high,tmPtr){var time=convertI32PairToI53Checked(time_low,time_high);var date=new Date(time*1e3);HEAP32[tmPtr>>2]=date.getSeconds();HEAP32[tmPtr+4>>2]=date.getMinutes();HEAP32[tmPtr+8>>2]=date.getHours();HEAP32[tmPtr+12>>2]=date.getDate();HEAP32[tmPtr+16>>2]=date.getMonth();HEAP32[tmPtr+20>>2]=date.getFullYear()-1900;HEAP32[tmPtr+24>>2]=date.getDay();var yday=ydayFromDate(date)|0;HEAP32[tmPtr+28>>2]=yday;HEAP32[tmPtr+36>>2]=-(date.getTimezoneOffset()*60);var start=new Date(date.getFullYear(),0,1);var summerOffset=new Date(date.getFullYear(),6,1).getTimezoneOffset();var winterOffset=start.getTimezoneOffset();var dst=(summerOffset!=winterOffset&&date.getTimezoneOffset()==Math.min(winterOffset,summerOffset))|0;HEAP32[tmPtr+32>>2]=dst}var setTempRet0=val=>__emscripten_tempret_set(val);var __mktime_js=function(tmPtr){var ret=(()=>{var date=new Date(HEAP32[tmPtr+20>>2]+1900,HEAP32[tmPtr+16>>2],HEAP32[tmPtr+12>>2],HEAP32[tmPtr+8>>2],HEAP32[tmPtr+4>>2],HEAP32[tmPtr>>2],0);var dst=HEAP32[tmPtr+32>>2];var guessedOffset=date.getTimezoneOffset();var start=new Date(date.getFullYear(),0,1);var summerOffset=new Date(date.getFullYear(),6,1).getTimezoneOffset();var winterOffset=start.getTimezoneOffset();var dstOffset=Math.min(winterOffset,summerOffset);if(dst<0){HEAP32[tmPtr+32>>2]=Number(summerOffset!=winterOffset&&dstOffset==guessedOffset)}else if(dst>0!=(dstOffset==guessedOffset)){var nonDstOffset=Math.max(winterOffset,summerOffset);var trueOffset=dst>0?dstOffset:nonDstOffset;date.setTime(date.getTime()+(trueOffset-guessedOffset)*6e4)}HEAP32[tmPtr+24>>2]=date.getDay();var yday=ydayFromDate(date)|0;HEAP32[tmPtr+28>>2]=yday;HEAP32[tmPtr>>2]=date.getSeconds();HEAP32[tmPtr+4>>2]=date.getMinutes();HEAP32[tmPtr+8>>2]=date.getHours();HEAP32[tmPtr+12>>2]=date.getDate();HEAP32[tmPtr+16>>2]=date.getMonth();HEAP32[tmPtr+20>>2]=date.getYear();var timeMs=date.getTime();if(isNaN(timeMs)){return-1}return timeMs/1e3})();return setTempRet0((tempDouble=ret,+Math.abs(tempDouble)>=1?tempDouble>0?+Math.floor(tempDouble/4294967296)>>>0:~~+Math.ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)),ret>>>0};function __mmap_js(len,prot,flags,fd,offset_low,offset_high,allocated,addr){var offset=convertI32PairToI53Checked(offset_low,offset_high);try{if(isNaN(offset))return 61;var stream=SYSCALLS.getStreamFromFD(fd);var res=FS.mmap(stream,len,offset,prot,flags);var ptr=res.ptr;HEAP32[allocated>>2]=res.allocated;HEAPU32[addr>>2]=ptr;return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}function __munmap_js(addr,len,prot,flags,fd,offset_low,offset_high){var offset=convertI32PairToI53Checked(offset_low,offset_high);try{var stream=SYSCALLS.getStreamFromFD(fd);if(prot&2){SYSCALLS.doMsync(addr,stream,len,flags,offset)}}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return-e.errno}}var timers={};var handleException=e=>{if(e instanceof ExitStatus||e=="unwind"){return EXITSTATUS}quit_(1,e)};var keepRuntimeAlive=()=>noExitRuntime||runtimeKeepaliveCounter>0;var _proc_exit=code=>{EXITSTATUS=code;if(!keepRuntimeAlive()){Module["onExit"]?.(code);ABORT=true}quit_(code,new ExitStatus(code))};var exitJS=(status,implicit)=>{EXITSTATUS=status;_proc_exit(status)};var _exit=exitJS;var maybeExit=()=>{if(!keepRuntimeAlive()){try{_exit(EXITSTATUS)}catch(e){handleException(e)}}};var callUserCallback=func=>{if(ABORT){return}try{func();maybeExit()}catch(e){handleException(e)}};var _emscripten_get_now=()=>performance.now();var __setitimer_js=(which,timeout_ms)=>{if(timers[which]){clearTimeout(timers[which].id);delete timers[which]}if(!timeout_ms)return 0;var id=setTimeout(()=>{delete timers[which];callUserCallback(()=>__emscripten_timeout(which,_emscripten_get_now()))},timeout_ms);timers[which]={id,timeout_ms};return 0};var __timegm_js=function(tmPtr){var ret=(()=>{var time=Date.UTC(HEAP32[tmPtr+20>>2]+1900,HEAP32[tmPtr+16>>2],HEAP32[tmPtr+12>>2],HEAP32[tmPtr+8>>2],HEAP32[tmPtr+4>>2],HEAP32[tmPtr>>2],0);var date=new Date(time);HEAP32[tmPtr+24>>2]=date.getUTCDay();var start=Date.UTC(date.getUTCFullYear(),0,1,0,0,0,0);var yday=(date.getTime()-start)/(1e3*60*60*24)|0;HEAP32[tmPtr+28>>2]=yday;return date.getTime()/1e3})();return setTempRet0((tempDouble=ret,+Math.abs(tempDouble)>=1?tempDouble>0?+Math.floor(tempDouble/4294967296)>>>0:~~+Math.ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)),ret>>>0};var _emscripten_date_now=()=>Date.now();var nowIsMonotonic=1;var checkWasiClock=clock_id=>clock_id>=0&&clock_id<=3;function _clock_time_get(clk_id,ignored_precision_low,ignored_precision_high,ptime){var ignored_precision=convertI32PairToI53Checked(ignored_precision_low,ignored_precision_high);if(!checkWasiClock(clk_id)){return 28}var now;if(clk_id===0){now=_emscripten_date_now()}else if(nowIsMonotonic){now=_emscripten_get_now()}else{return 52}var nsec=Math.round(now*1e3*1e3);tempI64=[nsec>>>0,(tempDouble=nsec,+Math.abs(tempDouble)>=1?tempDouble>0?+Math.floor(tempDouble/4294967296)>>>0:~~+Math.ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[ptime>>2]=tempI64[0],HEAP32[ptime+4>>2]=tempI64[1];return 0}var readEmAsmArgsArray=[];var readEmAsmArgs=(sigPtr,buf)=>{readEmAsmArgsArray.length=0;var ch;while(ch=HEAPU8[sigPtr++]){var wide=ch!=105;wide&=ch!=112;buf+=wide&&buf%8?4:0;readEmAsmArgsArray.push(ch==112?HEAPU32[buf>>2]:ch==105?HEAP32[buf>>2]:HEAPF64[buf>>3]);buf+=wide?8:4}return readEmAsmArgsArray};var runEmAsmFunction=(code,sigPtr,argbuf)=>{var args=readEmAsmArgs(sigPtr,argbuf);return ASM_CONSTS[code](...args)};var _emscripten_asm_const_int=(code,sigPtr,argbuf)=>runEmAsmFunction(code,sigPtr,argbuf);var getHeapMax=()=>2147483648;var _emscripten_get_heap_max=()=>getHeapMax();var _emscripten_pc_get_function=pc=>{abort("Cannot use emscripten_pc_get_function without -sUSE_OFFSET_CONVERTER");return 0};var growMemory=size=>{var b=wasmMemory.buffer;var pages=(size-b.byteLength+65535)/65536|0;try{wasmMemory.grow(pages);updateMemoryViews();return 1}catch(e){}};var _emscripten_resize_heap=requestedSize=>{var oldSize=HEAPU8.length;requestedSize>>>=0;var maxHeapSize=getHeapMax();if(requestedSize>maxHeapSize){return false}for(var cutDown=1;cutDown<=4;cutDown*=2){var overGrownHeapSize=oldSize*(1+.2/cutDown);overGrownHeapSize=Math.min(overGrownHeapSize,requestedSize+100663296);var newSize=Math.min(maxHeapSize,alignMemory(Math.max(requestedSize,overGrownHeapSize),65536));var replacement=growMemory(newSize);if(replacement){return true}}return false};var convertFrameToPC=frame=>{abort("Cannot use convertFrameToPC (needed by __builtin_return_address) without -sUSE_OFFSET_CONVERTER");return 0};var UNWIND_CACHE={};var saveInUnwindCache=callstack=>{callstack.forEach(frame=>{var pc=convertFrameToPC(frame);if(pc){UNWIND_CACHE[pc]=frame}})};var jsStackTrace=()=>(new Error).stack.toString();var _emscripten_stack_snapshot=()=>{var callstack=jsStackTrace().split("\n");if(callstack[0]=="Error"){callstack.shift()}saveInUnwindCache(callstack);UNWIND_CACHE.last_addr=convertFrameToPC(callstack[3]);UNWIND_CACHE.last_stack=callstack;return UNWIND_CACHE.last_addr};var _emscripten_stack_unwind_buffer=(addr,buffer,count)=>{var stack;if(UNWIND_CACHE.last_addr==addr){stack=UNWIND_CACHE.last_stack}else{stack=jsStackTrace().split("\n");if(stack[0]=="Error"){stack.shift()}saveInUnwindCache(stack)}var offset=3;while(stack[offset]&&convertFrameToPC(stack[offset])!=addr){++offset}for(var i=0;i>2]=convertFrameToPC(stack[i+offset])}return i};var ENV={};var getExecutableName=()=>thisProgram||"./this.program";var getEnvStrings=()=>{if(!getEnvStrings.strings){var lang=(typeof navigator=="object"&&navigator.languages&&navigator.languages[0]||"C").replace("-","_")+".UTF-8";var env={USER:"web_user",LOGNAME:"web_user",PATH:"/",PWD:"/",HOME:"/home/web_user",LANG:lang,_:getExecutableName()};for(var x in ENV){if(ENV[x]===undefined)delete env[x];else env[x]=ENV[x]}var strings=[];for(var x in env){strings.push(`${x}=${env[x]}`)}getEnvStrings.strings=strings}return getEnvStrings.strings};var stringToAscii=(str,buffer)=>{for(var i=0;i{var bufSize=0;getEnvStrings().forEach((string,i)=>{var ptr=environ_buf+bufSize;HEAPU32[__environ+i*4>>2]=ptr;stringToAscii(string,ptr);bufSize+=string.length+1});return 0};var _environ_sizes_get=(penviron_count,penviron_buf_size)=>{var strings=getEnvStrings();HEAPU32[penviron_count>>2]=strings.length;var bufSize=0;strings.forEach(string=>bufSize+=string.length+1);HEAPU32[penviron_buf_size>>2]=bufSize;return 0};function _fd_close(fd){try{var stream=SYSCALLS.getStreamFromFD(fd);FS.close(stream);return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}function _fd_fdstat_get(fd,pbuf){try{var rightsBase=0;var rightsInheriting=0;var flags=0;{var stream=SYSCALLS.getStreamFromFD(fd);var type=stream.tty?2:FS.isDir(stream.mode)?3:FS.isLink(stream.mode)?7:4}HEAP8[pbuf]=type;HEAP16[pbuf+2>>1]=flags;tempI64=[rightsBase>>>0,(tempDouble=rightsBase,+Math.abs(tempDouble)>=1?tempDouble>0?+Math.floor(tempDouble/4294967296)>>>0:~~+Math.ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[pbuf+8>>2]=tempI64[0],HEAP32[pbuf+12>>2]=tempI64[1];tempI64=[rightsInheriting>>>0,(tempDouble=rightsInheriting,+Math.abs(tempDouble)>=1?tempDouble>0?+Math.floor(tempDouble/4294967296)>>>0:~~+Math.ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[pbuf+16>>2]=tempI64[0],HEAP32[pbuf+20>>2]=tempI64[1];return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}var doReadv=(stream,iov,iovcnt,offset)=>{var ret=0;for(var i=0;i>2];var len=HEAPU32[iov+4>>2];iov+=8;var curr=FS.read(stream,HEAP8,ptr,len,offset);if(curr<0)return-1;ret+=curr;if(curr>2]=num;return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}function _fd_seek(fd,offset_low,offset_high,whence,newOffset){var offset=convertI32PairToI53Checked(offset_low,offset_high);try{if(isNaN(offset))return 61;var stream=SYSCALLS.getStreamFromFD(fd);FS.llseek(stream,offset,whence);tempI64=[stream.position>>>0,(tempDouble=stream.position,+Math.abs(tempDouble)>=1?tempDouble>0?+Math.floor(tempDouble/4294967296)>>>0:~~+Math.ceil((tempDouble-+(~~tempDouble>>>0))/4294967296)>>>0:0)],HEAP32[newOffset>>2]=tempI64[0],HEAP32[newOffset+4>>2]=tempI64[1];if(stream.getdents&&offset===0&&whence===0)stream.getdents=null;return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}function _fd_sync(fd){try{var stream=SYSCALLS.getStreamFromFD(fd);if(stream.stream_ops?.fsync){return stream.stream_ops.fsync(stream)}return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}var doWritev=(stream,iov,iovcnt,offset)=>{var ret=0;for(var i=0;i>2];var len=HEAPU32[iov+4>>2];iov+=8;var curr=FS.write(stream,HEAP8,ptr,len,offset);if(curr<0)return-1;ret+=curr;if(curr>2]=num;return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}function _random_get(buffer,size){try{randomFill(HEAPU8.subarray(buffer,buffer+size));return 0}catch(e){if(typeof FS=="undefined"||!(e.name==="ErrnoError"))throw e;return e.errno}}var arraySum=(array,index)=>{var sum=0;for(var i=0;i<=index;sum+=array[i++]){}return sum};var MONTH_DAYS_LEAP=[31,29,31,30,31,30,31,31,30,31,30,31];var MONTH_DAYS_REGULAR=[31,28,31,30,31,30,31,31,30,31,30,31];var addDays=(date,days)=>{var newDate=new Date(date.getTime());while(days>0){var leap=isLeapYear(newDate.getFullYear());var currentMonth=newDate.getMonth();var daysInCurrentMonth=(leap?MONTH_DAYS_LEAP:MONTH_DAYS_REGULAR)[currentMonth];if(days>daysInCurrentMonth-newDate.getDate()){days-=daysInCurrentMonth-newDate.getDate()+1;newDate.setDate(1);if(currentMonth<11){newDate.setMonth(currentMonth+1)}else{newDate.setMonth(0);newDate.setFullYear(newDate.getFullYear()+1)}}else{newDate.setDate(newDate.getDate()+days);return newDate}}return newDate};var jstoi_q=str=>parseInt(str);var _strptime=(buf,format,tm)=>{var pattern=UTF8ToString(format);var SPECIAL_CHARS="\\!@#$^&*()+=-[]/{}|:<>?,.";for(var i=0,ii=SPECIAL_CHARS.length;iEQUIVALENT_MATCHERS[c]||m).replace(/%(.)/g,(_,c)=>{let pat=DATE_PATTERNS[c];if(pat){capture.push(c);return`(${pat})`}else{return c}}).replace(/\s+/g,"\\s*");var matches=new RegExp("^"+pattern_out,"i").exec(UTF8ToString(buf));function initDate(){function fixup(value,min,max){return typeof value!="number"||isNaN(value)?min:value>=min?value<=max?value:max:min}return{year:fixup(HEAP32[tm+20>>2]+1900,1970,9999),month:fixup(HEAP32[tm+16>>2],0,11),day:fixup(HEAP32[tm+12>>2],1,31),hour:fixup(HEAP32[tm+8>>2],0,23),min:fixup(HEAP32[tm+4>>2],0,59),sec:fixup(HEAP32[tm>>2],0,59),gmtoff:0}}if(matches){var date=initDate();var value;var getMatch=symbol=>{var pos=capture.indexOf(symbol);if(pos>=0){return matches[pos+1]}return};if(value=getMatch("S")){date.sec=jstoi_q(value)}if(value=getMatch("M")){date.min=jstoi_q(value)}if(value=getMatch("H")){date.hour=jstoi_q(value)}else if(value=getMatch("I")){var hour=jstoi_q(value);if(value=getMatch("p")){hour+=value.toUpperCase()[0]==="P"?12:0}date.hour=hour}if(value=getMatch("Y")){date.year=jstoi_q(value)}else if(value=getMatch("y")){var year=jstoi_q(value);if(value=getMatch("C")){year+=jstoi_q(value)*100}else{year+=year<69?2e3:1900}date.year=year}if(value=getMatch("m")){date.month=jstoi_q(value)-1}else if(value=getMatch("b")){date.month=MONTH_NUMBERS[value.substring(0,3).toUpperCase()]||0}if(value=getMatch("d")){date.day=jstoi_q(value)}else if(value=getMatch("j")){var day=jstoi_q(value);var leapYear=isLeapYear(date.year);for(var month=0;month<12;++month){var daysUntilMonth=arraySum(leapYear?MONTH_DAYS_LEAP:MONTH_DAYS_REGULAR,month-1);if(day<=daysUntilMonth+(leapYear?MONTH_DAYS_LEAP:MONTH_DAYS_REGULAR)[month]){date.day=day-daysUntilMonth}}}else if(value=getMatch("a")){var weekDay=value.substring(0,3).toUpperCase();if(value=getMatch("U")){var weekDayNumber=DAY_NUMBERS_SUN_FIRST[weekDay];var weekNumber=jstoi_q(value);var janFirst=new Date(date.year,0,1);var endDate;if(janFirst.getDay()===0){endDate=addDays(janFirst,weekDayNumber+7*(weekNumber-1))}else{endDate=addDays(janFirst,7-janFirst.getDay()+weekDayNumber+7*(weekNumber-1))}date.day=endDate.getDate();date.month=endDate.getMonth()}else if(value=getMatch("W")){var weekDayNumber=DAY_NUMBERS_MON_FIRST[weekDay];var weekNumber=jstoi_q(value);var janFirst=new Date(date.year,0,1);var endDate;if(janFirst.getDay()===1){endDate=addDays(janFirst,weekDayNumber+7*(weekNumber-1))}else{endDate=addDays(janFirst,7-janFirst.getDay()+1+weekDayNumber+7*(weekNumber-1))}date.day=endDate.getDate();date.month=endDate.getMonth()}}if(value=getMatch("z")){if(value.toLowerCase()==="z"){date.gmtoff=0}else{var match=value.match(/^((?:\-|\+)\d\d):?(\d\d)?/);date.gmtoff=match[1]*3600;if(match[2]){date.gmtoff+=date.gmtoff>0?match[2]*60:-match[2]*60}}}var fullDate=new Date(date.year,date.month,date.day,date.hour,date.min,date.sec,0);HEAP32[tm>>2]=fullDate.getSeconds();HEAP32[tm+4>>2]=fullDate.getMinutes();HEAP32[tm+8>>2]=fullDate.getHours();HEAP32[tm+12>>2]=fullDate.getDate();HEAP32[tm+16>>2]=fullDate.getMonth();HEAP32[tm+20>>2]=fullDate.getFullYear()-1900;HEAP32[tm+24>>2]=fullDate.getDay();HEAP32[tm+28>>2]=arraySum(isLeapYear(fullDate.getFullYear())?MONTH_DAYS_LEAP:MONTH_DAYS_REGULAR,fullDate.getMonth()-1)+fullDate.getDate()-1;HEAP32[tm+32>>2]=0;HEAP32[tm+36>>2]=date.gmtoff;return buf+intArrayFromString(matches[0]).length-1}return 0};var FS_createPath=FS.createPath;var FS_unlink=path=>FS.unlink(path);var FS_createLazyFile=FS.createLazyFile;var FS_createDevice=FS.createDevice;FS.createPreloadedFile=FS_createPreloadedFile;FS.staticInit();Module["FS_createPath"]=FS.createPath;Module["FS_createDataFile"]=FS.createDataFile;Module["FS_createPreloadedFile"]=FS.createPreloadedFile;Module["FS_unlink"]=FS.unlink;Module["FS_createLazyFile"]=FS.createLazyFile;Module["FS_createDevice"]=FS.createDevice;MEMFS.doesNotExistError=new FS.ErrnoError(44);MEMFS.doesNotExistError.stack="";BindingError=Module["BindingError"]=class BindingError extends Error{constructor(message){super(message);this.name="BindingError"}};init_emval();PureVirtualError=Module["PureVirtualError"]=extendError(Error,"PureVirtualError");embind_init_charCodes();InternalError=Module["InternalError"]=class InternalError extends Error{constructor(message){super(message);this.name="InternalError"}};init_ClassHandle();init_RegisteredPointer();UnboundTypeError=Module["UnboundTypeError"]=extendError(Error,"UnboundTypeError");var wasmImports={qa:HaveOffsetConverter,ja:___syscall_chmod,la:___syscall_faccessat,ka:___syscall_fchmod,z:___syscall_fcntl64,ga:___syscall_fstat64,P:___syscall_ftruncate64,Z:___syscall_getdents64,ia:___syscall_ioctl,ea:___syscall_lstat64,_:___syscall_mkdirat,da:___syscall_newfstatat,s:___syscall_openat,Y:___syscall_renameat,v:___syscall_rmdir,fa:___syscall_stat64,w:___syscall_unlinkat,ma:__abort_js,wa:__embind_create_inheriting_constructor,C:__embind_finalize_value_object,R:__embind_register_bigint,Aa:__embind_register_bool,i:__embind_register_class,B:__embind_register_class_class_function,E:__embind_register_class_constructor,b:__embind_register_class_function,q:__embind_register_class_property,ya:__embind_register_emval,F:__embind_register_float,d:__embind_register_function,h:__embind_register_integer,c:__embind_register_memory_view,G:__embind_register_optional,$:__embind_register_smart_ptr,za:__embind_register_std_string,u:__embind_register_std_wstring,xa:__embind_register_value_object,D:__embind_register_value_object_field,Ba:__embind_register_void,oa:__emscripten_fs_load_embedded_files,ha:__emscripten_memcpy_js,S:__emscripten_runtime_keepalive_clear,m:__emval_as,J:__emval_call,g:__emval_call_method,a:__emval_decref,p:__emval_get_global,f:__emval_get_method_caller,ua:__emval_get_module_property,o:__emval_get_property,r:__emval_incref,n:__emval_new_cstring,e:__emval_run_destructors,k:__emval_take_value,t:__emval_typeof,K:__gmtime_js,L:__localtime_js,M:__mktime_js,H:__mmap_js,I:__munmap_js,T:__setitimer_js,N:__timegm_js,Q:_clock_time_get,ta:_emscripten_asm_const_int,A:_emscripten_date_now,X:_emscripten_get_heap_max,j:_emscripten_get_now,pa:_emscripten_pc_get_function,V:_emscripten_resize_heap,sa:_emscripten_stack_snapshot,ra:_emscripten_stack_unwind_buffer,aa:_environ_get,ba:_environ_sizes_get,l:_fd_close,W:_fd_fdstat_get,y:_fd_read,O:_fd_seek,ca:_fd_sync,x:_fd_write,na:_proc_exit,U:_random_get,va:_strptime};var wasmExports;createWasm();var ___wasm_call_ctors=()=>(___wasm_call_ctors=wasmExports["Da"])();var ___getTypeName=a0=>(___getTypeName=wasmExports["Ea"])(a0);var _malloc=a0=>(_malloc=wasmExports["Fa"])(a0);var _free=a0=>(_free=wasmExports["Ga"])(a0);var _emscripten_builtin_memalign=(a0,a1)=>(_emscripten_builtin_memalign=wasmExports["Ia"])(a0,a1);var __emscripten_timeout=(a0,a1)=>(__emscripten_timeout=wasmExports["Ja"])(a0,a1);var ___trap=()=>(___trap=wasmExports["Ka"])();var __emscripten_tempret_set=a0=>(__emscripten_tempret_set=wasmExports["La"])(a0);var dynCall_vij=Module["dynCall_vij"]=(a0,a1,a2,a3)=>(dynCall_vij=Module["dynCall_vij"]=wasmExports["Ma"])(a0,a1,a2,a3);var dynCall_jiji=Module["dynCall_jiji"]=(a0,a1,a2,a3,a4)=>(dynCall_jiji=Module["dynCall_jiji"]=wasmExports["Na"])(a0,a1,a2,a3,a4);var dynCall_ji=Module["dynCall_ji"]=(a0,a1)=>(dynCall_ji=Module["dynCall_ji"]=wasmExports["Oa"])(a0,a1);var dynCall_viij=Module["dynCall_viij"]=(a0,a1,a2,a3,a4)=>(dynCall_viij=Module["dynCall_viij"]=wasmExports["Pa"])(a0,a1,a2,a3,a4);var dynCall_iij=Module["dynCall_iij"]=(a0,a1,a2,a3)=>(dynCall_iij=Module["dynCall_iij"]=wasmExports["Qa"])(a0,a1,a2,a3);var dynCall_iiji=Module["dynCall_iiji"]=(a0,a1,a2,a3,a4)=>(dynCall_iiji=Module["dynCall_iiji"]=wasmExports["Ra"])(a0,a1,a2,a3,a4);var dynCall_jji=Module["dynCall_jji"]=(a0,a1,a2,a3)=>(dynCall_jji=Module["dynCall_jji"]=wasmExports["Sa"])(a0,a1,a2,a3);var dynCall_iji=Module["dynCall_iji"]=(a0,a1,a2,a3)=>(dynCall_iji=Module["dynCall_iji"]=wasmExports["Ta"])(a0,a1,a2,a3);var dynCall_viijj=Module["dynCall_viijj"]=(a0,a1,a2,a3,a4,a5,a6)=>(dynCall_viijj=Module["dynCall_viijj"]=wasmExports["Ua"])(a0,a1,a2,a3,a4,a5,a6);var dynCall_iiij=Module["dynCall_iiij"]=(a0,a1,a2,a3,a4)=>(dynCall_iiij=Module["dynCall_iiij"]=wasmExports["Va"])(a0,a1,a2,a3,a4);var dynCall_viiiji=Module["dynCall_viiiji"]=(a0,a1,a2,a3,a4,a5,a6)=>(dynCall_viiiji=Module["dynCall_viiiji"]=wasmExports["Wa"])(a0,a1,a2,a3,a4,a5,a6);var dynCall_viijii=Module["dynCall_viijii"]=(a0,a1,a2,a3,a4,a5,a6)=>(dynCall_viijii=Module["dynCall_viijii"]=wasmExports["Xa"])(a0,a1,a2,a3,a4,a5,a6);var dynCall_viji=Module["dynCall_viji"]=(a0,a1,a2,a3,a4)=>(dynCall_viji=Module["dynCall_viji"]=wasmExports["Ya"])(a0,a1,a2,a3,a4);var dynCall_iiiijij=Module["dynCall_iiiijij"]=(a0,a1,a2,a3,a4,a5,a6,a7,a8)=>(dynCall_iiiijij=Module["dynCall_iiiijij"]=wasmExports["Za"])(a0,a1,a2,a3,a4,a5,a6,a7,a8);var dynCall_jij=Module["dynCall_jij"]=(a0,a1,a2,a3)=>(dynCall_jij=Module["dynCall_jij"]=wasmExports["_a"])(a0,a1,a2,a3);var dynCall_iiiij=Module["dynCall_iiiij"]=(a0,a1,a2,a3,a4,a5)=>(dynCall_iiiij=Module["dynCall_iiiij"]=wasmExports["$a"])(a0,a1,a2,a3,a4,a5);var dynCall_iiiiij=Module["dynCall_iiiiij"]=(a0,a1,a2,a3,a4,a5,a6)=>(dynCall_iiiiij=Module["dynCall_iiiiij"]=wasmExports["ab"])(a0,a1,a2,a3,a4,a5,a6);var dynCall_iiiiijj=Module["dynCall_iiiiijj"]=(a0,a1,a2,a3,a4,a5,a6,a7,a8)=>(dynCall_iiiiijj=Module["dynCall_iiiiijj"]=wasmExports["bb"])(a0,a1,a2,a3,a4,a5,a6,a7,a8);var dynCall_iiiiiijj=Module["dynCall_iiiiiijj"]=(a0,a1,a2,a3,a4,a5,a6,a7,a8,a9)=>(dynCall_iiiiiijj=Module["dynCall_iiiiiijj"]=wasmExports["cb"])(a0,a1,a2,a3,a4,a5,a6,a7,a8,a9);var ___emscripten_embedded_file_data=Module["___emscripten_embedded_file_data"]=168424;Module["addRunDependency"]=addRunDependency;Module["removeRunDependency"]=removeRunDependency;Module["FS_createPreloadedFile"]=FS_createPreloadedFile;Module["FS_unlink"]=FS_unlink;Module["FS_createPath"]=FS_createPath;Module["FS_createDevice"]=FS_createDevice;Module["FS"]=FS;Module["FS_createDataFile"]=FS_createDataFile;Module["FS_createLazyFile"]=FS_createLazyFile;var calledRun;dependenciesFulfilled=function runCaller(){if(!calledRun)run();if(!calledRun)dependenciesFulfilled=runCaller};function run(){if(runDependencies>0){return}preRun();if(runDependencies>0){return}function doRun(){if(calledRun)return;calledRun=true;Module["calledRun"]=true;if(ABORT)return;initRuntime();readyPromiseResolve(Module);Module["onRuntimeInitialized"]?.();postRun()}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout(()=>{setTimeout(()=>Module["setStatus"](""),1);doRun()},1)}else{doRun()}}if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].pop()()}}run();moduleRtn=readyPromise; + + + return moduleRtn; +} +); +})(); +if (typeof exports === 'object' && typeof module === 'object') { + module.exports = PSPDFModuleInit; + // This default export looks redundant, but it allows TS to import this + // commonjs style module. + module.exports.default = PSPDFModuleInit; +} else if (typeof define === 'function' && define['amd']) + define([], () => PSPDFModuleInit); diff --git a/wasm/nutrient/helper.js b/wasm/nutrient/helper.js new file mode 100644 index 00000000..e7eae685 --- /dev/null +++ b/wasm/nutrient/helper.js @@ -0,0 +1 @@ +function injectRequiredGlobals(e){e.PSPDFLoggingServices={error(e,o){console.error(`[${e}] ${o}`)},warn(e,o){console.warn(`[${e}] ${o}`)},info(e,o){console.log(`[${e}] ${o}`)},debug(e,o){console.log(`[${e}] ${o}`)},trace(e,o){console.log(`[${e}] ${o}`)}},e.PSPDFUnicodeServices={stripDiacritics(e){const o={"Á":"A","Ă":"A","Ắ":"A","Ặ":"A","Ằ":"A","Ẳ":"A","Ẵ":"A","Ǎ":"A","Â":"A","Ấ":"A","Ậ":"A","Ầ":"A","Ẩ":"A","Ẫ":"A","Ä":"A","Ǟ":"A","Ȧ":"A","Ǡ":"A","Ạ":"A","Ȁ":"A","À":"A","Ả":"A","Ȃ":"A","Ā":"A","Ą":"A","Å":"A","Ǻ":"A","Ḁ":"A","Ⱥ":"A","Ã":"A","Ꜳ":"AA","Æ":"AE","Ǽ":"AE","Ǣ":"AE","Ꜵ":"AO","Ꜷ":"AU","Ꜹ":"AV","Ꜻ":"AV","Ꜽ":"AY","Ḃ":"B","Ḅ":"B","Ɓ":"B","Ḇ":"B","Ƀ":"B","Ƃ":"B","Ć":"C","Č":"C","Ç":"C","Ḉ":"C","Ĉ":"C","Ċ":"C","Ƈ":"C","Ȼ":"C","Ď":"D","Ḑ":"D","Ḓ":"D","Ḋ":"D","Ḍ":"D","Ɗ":"D","Ḏ":"D","Dz":"D","Dž":"D","Đ":"D","Ƌ":"D","DZ":"DZ","DŽ":"DZ","É":"E","Ĕ":"E","Ě":"E","Ȩ":"E","Ḝ":"E","Ê":"E","Ế":"E","Ệ":"E","Ề":"E","Ể":"E","Ễ":"E","Ḙ":"E","Ë":"E","Ė":"E","Ẹ":"E","Ȅ":"E","È":"E","Ẻ":"E","Ȇ":"E","Ē":"E","Ḗ":"E","Ḕ":"E","Ę":"E","Ɇ":"E","Ẽ":"E","Ḛ":"E","Ꝫ":"ET","Ḟ":"F","Ƒ":"F","Ǵ":"G","Ğ":"G","Ǧ":"G","Ģ":"G","Ĝ":"G","Ġ":"G","Ɠ":"G","Ḡ":"G","Ǥ":"G","Ḫ":"H","Ȟ":"H","Ḩ":"H","Ĥ":"H","Ⱨ":"H","Ḧ":"H","Ḣ":"H","Ḥ":"H","Ħ":"H","Í":"I","Ĭ":"I","Ǐ":"I","Î":"I","Ï":"I","Ḯ":"I","İ":"I","Ị":"I","Ȉ":"I","Ì":"I","Ỉ":"I","Ȋ":"I","Ī":"I","Į":"I","Ɨ":"I","Ĩ":"I","Ḭ":"I","Ꝺ":"D","Ꝼ":"F","Ᵹ":"G","Ꞃ":"R","Ꞅ":"S","Ꞇ":"T","Ꝭ":"IS","Ĵ":"J","Ɉ":"J","Ḱ":"K","Ǩ":"K","Ķ":"K","Ⱪ":"K","Ꝃ":"K","Ḳ":"K","Ƙ":"K","Ḵ":"K","Ꝁ":"K","Ꝅ":"K","Ĺ":"L","Ƚ":"L","Ľ":"L","Ļ":"L","Ḽ":"L","Ḷ":"L","Ḹ":"L","Ⱡ":"L","Ꝉ":"L","Ḻ":"L","Ŀ":"L","Ɫ":"L","Lj":"L","Ł":"L","LJ":"LJ","Ḿ":"M","Ṁ":"M","Ṃ":"M","Ɱ":"M","Ń":"N","Ň":"N","Ņ":"N","Ṋ":"N","Ṅ":"N","Ṇ":"N","Ǹ":"N","Ɲ":"N","Ṉ":"N","Ƞ":"N","Nj":"N","Ñ":"N","NJ":"NJ","Ó":"O","Ŏ":"O","Ǒ":"O","Ô":"O","Ố":"O","Ộ":"O","Ồ":"O","Ổ":"O","Ỗ":"O","Ö":"O","Ȫ":"O","Ȯ":"O","Ȱ":"O","Ọ":"O","Ő":"O","Ȍ":"O","Ò":"O","Ỏ":"O","Ơ":"O","Ớ":"O","Ợ":"O","Ờ":"O","Ở":"O","Ỡ":"O","Ȏ":"O","Ꝋ":"O","Ꝍ":"O","Ō":"O","Ṓ":"O","Ṑ":"O","Ɵ":"O","Ǫ":"O","Ǭ":"O","Ø":"O","Ǿ":"O","Õ":"O","Ṍ":"O","Ṏ":"O","Ȭ":"O","Ƣ":"OI","Ꝏ":"OO","Ɛ":"E","Ɔ":"O","Ȣ":"OU","Ṕ":"P","Ṗ":"P","Ꝓ":"P","Ƥ":"P","Ꝕ":"P","Ᵽ":"P","Ꝑ":"P","Ꝙ":"Q","Ꝗ":"Q","Ŕ":"R","Ř":"R","Ŗ":"R","Ṙ":"R","Ṛ":"R","Ṝ":"R","Ȑ":"R","Ȓ":"R","Ṟ":"R","Ɍ":"R","Ɽ":"R","Ꜿ":"C","Ǝ":"E","Ś":"S","Ṥ":"S","Š":"S","Ṧ":"S","Ş":"S","Ŝ":"S","Ș":"S","Ṡ":"S","Ṣ":"S","Ṩ":"S","Ť":"T","Ţ":"T","Ṱ":"T","Ț":"T","Ⱦ":"T","Ṫ":"T","Ṭ":"T","Ƭ":"T","Ṯ":"T","Ʈ":"T","Ŧ":"T","Ɐ":"A","Ꞁ":"L","Ɯ":"M","Ʌ":"V","Ꜩ":"TZ","Ú":"U","Ŭ":"U","Ǔ":"U","Û":"U","Ṷ":"U","Ü":"U","Ǘ":"U","Ǚ":"U","Ǜ":"U","Ǖ":"U","Ṳ":"U","Ụ":"U","Ű":"U","Ȕ":"U","Ù":"U","Ủ":"U","Ư":"U","Ứ":"U","Ự":"U","Ừ":"U","Ử":"U","Ữ":"U","Ȗ":"U","Ū":"U","Ṻ":"U","Ų":"U","Ů":"U","Ũ":"U","Ṹ":"U","Ṵ":"U","Ꝟ":"V","Ṿ":"V","Ʋ":"V","Ṽ":"V","Ꝡ":"VY","Ẃ":"W","Ŵ":"W","Ẅ":"W","Ẇ":"W","Ẉ":"W","Ẁ":"W","Ⱳ":"W","Ẍ":"X","Ẋ":"X","Ý":"Y","Ŷ":"Y","Ÿ":"Y","Ẏ":"Y","Ỵ":"Y","Ỳ":"Y","Ƴ":"Y","Ỷ":"Y","Ỿ":"Y","Ȳ":"Y","Ɏ":"Y","Ỹ":"Y","Ź":"Z","Ž":"Z","Ẑ":"Z","Ⱬ":"Z","Ż":"Z","Ẓ":"Z","Ȥ":"Z","Ẕ":"Z","Ƶ":"Z","IJ":"IJ","Œ":"OE","ᴀ":"A","ᴁ":"AE","ʙ":"B","ᴃ":"B","ᴄ":"C","ᴅ":"D","ᴇ":"E","ꜰ":"F","ɢ":"G","ʛ":"G","ʜ":"H","ɪ":"I","ʁ":"R","ᴊ":"J","ᴋ":"K","ʟ":"L","ᴌ":"L","ᴍ":"M","ɴ":"N","ᴏ":"O","ɶ":"OE","ᴐ":"O","ᴕ":"OU","ᴘ":"P","ʀ":"R","ᴎ":"N","ᴙ":"R","ꜱ":"S","ᴛ":"T","ⱻ":"E","ᴚ":"R","ᴜ":"U","ᴠ":"V","ᴡ":"W","ʏ":"Y","ᴢ":"Z","á":"a","ă":"a","ắ":"a","ặ":"a","ằ":"a","ẳ":"a","ẵ":"a","ǎ":"a","â":"a","ấ":"a","ậ":"a","ầ":"a","ẩ":"a","ẫ":"a","ä":"a","ǟ":"a","ȧ":"a","ǡ":"a","ạ":"a","ȁ":"a","à":"a","ả":"a","ȃ":"a","ā":"a","ą":"a","ᶏ":"a","ẚ":"a","å":"a","ǻ":"a","ḁ":"a","ⱥ":"a","ã":"a","ꜳ":"aa","æ":"ae","ǽ":"ae","ǣ":"ae","ꜵ":"ao","ꜷ":"au","ꜹ":"av","ꜻ":"av","ꜽ":"ay","ḃ":"b","ḅ":"b","ɓ":"b","ḇ":"b","ᵬ":"b","ᶀ":"b","ƀ":"b","ƃ":"b","ɵ":"o","ć":"c","č":"c","ç":"c","ḉ":"c","ĉ":"c","ɕ":"c","ċ":"c","ƈ":"c","ȼ":"c","ď":"d","ḑ":"d","ḓ":"d","ȡ":"d","ḋ":"d","ḍ":"d","ɗ":"d","ᶑ":"d","ḏ":"d","ᵭ":"d","ᶁ":"d","đ":"d","ɖ":"d","ƌ":"d","ı":"i","ȷ":"j","ɟ":"j","ʄ":"j","dz":"dz","dž":"dz","é":"e","ĕ":"e","ě":"e","ȩ":"e","ḝ":"e","ê":"e","ế":"e","ệ":"e","ề":"e","ể":"e","ễ":"e","ḙ":"e","ë":"e","ė":"e","ẹ":"e","ȅ":"e","è":"e","ẻ":"e","ȇ":"e","ē":"e","ḗ":"e","ḕ":"e","ⱸ":"e","ę":"e","ᶒ":"e","ɇ":"e","ẽ":"e","ḛ":"e","ꝫ":"et","ḟ":"f","ƒ":"f","ᵮ":"f","ᶂ":"f","ǵ":"g","ğ":"g","ǧ":"g","ģ":"g","ĝ":"g","ġ":"g","ɠ":"g","ḡ":"g","ᶃ":"g","ǥ":"g","ḫ":"h","ȟ":"h","ḩ":"h","ĥ":"h","ⱨ":"h","ḧ":"h","ḣ":"h","ḥ":"h","ɦ":"h","ẖ":"h","ħ":"h","ƕ":"hv","í":"i","ĭ":"i","ǐ":"i","î":"i","ï":"i","ḯ":"i","ị":"i","ȉ":"i","ì":"i","ỉ":"i","ȋ":"i","ī":"i","į":"i","ᶖ":"i","ɨ":"i","ĩ":"i","ḭ":"i","ꝺ":"d","ꝼ":"f","ᵹ":"g","ꞃ":"r","ꞅ":"s","ꞇ":"t","ꝭ":"is","ǰ":"j","ĵ":"j","ʝ":"j","ɉ":"j","ḱ":"k","ǩ":"k","ķ":"k","ⱪ":"k","ꝃ":"k","ḳ":"k","ƙ":"k","ḵ":"k","ᶄ":"k","ꝁ":"k","ꝅ":"k","ĺ":"l","ƚ":"l","ɬ":"l","ľ":"l","ļ":"l","ḽ":"l","ȴ":"l","ḷ":"l","ḹ":"l","ⱡ":"l","ꝉ":"l","ḻ":"l","ŀ":"l","ɫ":"l","ᶅ":"l","ɭ":"l","ł":"l","lj":"lj","ſ":"s","ẜ":"s","ẛ":"s","ẝ":"s","ḿ":"m","ṁ":"m","ṃ":"m","ɱ":"m","ᵯ":"m","ᶆ":"m","ń":"n","ň":"n","ņ":"n","ṋ":"n","ȵ":"n","ṅ":"n","ṇ":"n","ǹ":"n","ɲ":"n","ṉ":"n","ƞ":"n","ᵰ":"n","ᶇ":"n","ɳ":"n","ñ":"n","nj":"nj","ó":"o","ŏ":"o","ǒ":"o","ô":"o","ố":"o","ộ":"o","ồ":"o","ổ":"o","ỗ":"o","ö":"o","ȫ":"o","ȯ":"o","ȱ":"o","ọ":"o","ő":"o","ȍ":"o","ò":"o","ỏ":"o","ơ":"o","ớ":"o","ợ":"o","ờ":"o","ở":"o","ỡ":"o","ȏ":"o","ꝋ":"o","ꝍ":"o","ⱺ":"o","ō":"o","ṓ":"o","ṑ":"o","ǫ":"o","ǭ":"o","ø":"o","ǿ":"o","õ":"o","ṍ":"o","ṏ":"o","ȭ":"o","ƣ":"oi","ꝏ":"oo","ɛ":"e","ᶓ":"e","ɔ":"o","ᶗ":"o","ȣ":"ou","ṕ":"p","ṗ":"p","ꝓ":"p","ƥ":"p","ᵱ":"p","ᶈ":"p","ꝕ":"p","ᵽ":"p","ꝑ":"p","ꝙ":"q","ʠ":"q","ɋ":"q","ꝗ":"q","ŕ":"r","ř":"r","ŗ":"r","ṙ":"r","ṛ":"r","ṝ":"r","ȑ":"r","ɾ":"r","ᵳ":"r","ȓ":"r","ṟ":"r","ɼ":"r","ᵲ":"r","ᶉ":"r","ɍ":"r","ɽ":"r","ↄ":"c","ꜿ":"c","ɘ":"e","ɿ":"r","ś":"s","ṥ":"s","š":"s","ṧ":"s","ş":"s","ŝ":"s","ș":"s","ṡ":"s","ṣ":"s","ṩ":"s","ʂ":"s","ᵴ":"s","ᶊ":"s","ȿ":"s","ɡ":"g","ᴑ":"o","ᴓ":"o","ᴝ":"u","ť":"t","ţ":"t","ṱ":"t","ț":"t","ȶ":"t","ẗ":"t","ⱦ":"t","ṫ":"t","ṭ":"t","ƭ":"t","ṯ":"t","ᵵ":"t","ƫ":"t","ʈ":"t","ŧ":"t","ᵺ":"th","ɐ":"a","ᴂ":"ae","ǝ":"e","ᵷ":"g","ɥ":"h","ʮ":"h","ʯ":"h","ᴉ":"i","ʞ":"k","ꞁ":"l","ɯ":"m","ɰ":"m","ᴔ":"oe","ɹ":"r","ɻ":"r","ɺ":"r","ⱹ":"r","ʇ":"t","ʌ":"v","ʍ":"w","ʎ":"y","ꜩ":"tz","ú":"u","ŭ":"u","ǔ":"u","û":"u","ṷ":"u","ü":"u","ǘ":"u","ǚ":"u","ǜ":"u","ǖ":"u","ṳ":"u","ụ":"u","ű":"u","ȕ":"u","ù":"u","ủ":"u","ư":"u","ứ":"u","ự":"u","ừ":"u","ử":"u","ữ":"u","ȗ":"u","ū":"u","ṻ":"u","ų":"u","ᶙ":"u","ů":"u","ũ":"u","ṹ":"u","ṵ":"u","ᵫ":"ue","ꝸ":"um","ⱴ":"v","ꝟ":"v","ṿ":"v","ʋ":"v","ᶌ":"v","ⱱ":"v","ṽ":"v","ꝡ":"vy","ẃ":"w","ŵ":"w","ẅ":"w","ẇ":"w","ẉ":"w","ẁ":"w","ⱳ":"w","ẘ":"w","ẍ":"x","ẋ":"x","ᶍ":"x","ý":"y","ŷ":"y","ÿ":"y","ẏ":"y","ỵ":"y","ỳ":"y","ƴ":"y","ỷ":"y","ỿ":"y","ȳ":"y","ẙ":"y","ɏ":"y","ỹ":"y","ź":"z","ž":"z","ẑ":"z","ʑ":"z","ⱬ":"z","ż":"z","ẓ":"z","ȥ":"z","ẕ":"z","ᵶ":"z","ᶎ":"z","ʐ":"z","ƶ":"z","ɀ":"z","ff":"ff","ffi":"ffi","ffl":"ffl","fi":"fi","fl":"fl","ij":"ij","œ":"oe","st":"st","ₐ":"a","ₑ":"e","ᵢ":"i","ⱼ":"j","ₒ":"o","ᵣ":"r","ᵤ":"u","ᵥ":"v","ₓ":"x"};if(!e.normalize)return e;const a=e.replace(/[^A-Za-z0-9[\] ]/g,function(e){return o[e]||e});return e.normalize("NFC").length==a.normalize("NFC").length?a:""},escapeRegExp:e=>e.replace(/[.*+?^${}()|[\]\\]/g,"\\$&"),match(e,o,a){const r=new RegExp(o,a?"g":"gi"),O=[];let n=r.exec(e);for(;null!=n;)O.push([n.index,n[0].length]),n=r.exec(e);return O},exec:(e,o)=>new RegExp(e).exec(o)}} \ No newline at end of file