@embedpdf/pdfium 1.0.0-alpha.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (10) hide show
  1. package/LICENSE +21 -0
  2. package/README.md +82 -0
  3. package/dist/index.cjs +4685 -0
  4. package/dist/index.cjs.map +1 -0
  5. package/dist/index.d.cts +200 -0
  6. package/dist/index.d.ts +200 -0
  7. package/dist/index.js +4664 -0
  8. package/dist/index.js.map +1 -0
  9. package/dist/pdfium.wasm +0 -0
  10. package/package.json +45 -0
package/dist/index.cjs ADDED
@@ -0,0 +1,4685 @@
1
+ "use strict";
2
+ var __defProp = Object.defineProperty;
3
+ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
4
+ var __getOwnPropNames = Object.getOwnPropertyNames;
5
+ var __hasOwnProp = Object.prototype.hasOwnProperty;
6
+ var __export = (target, all) => {
7
+ for (var name in all)
8
+ __defProp(target, name, { get: all[name], enumerable: true });
9
+ };
10
+ var __copyProps = (to, from, except, desc) => {
11
+ if (from && typeof from === "object" || typeof from === "function") {
12
+ for (let key of __getOwnPropNames(from))
13
+ if (!__hasOwnProp.call(to, key) && key !== except)
14
+ __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
15
+ }
16
+ return to;
17
+ };
18
+ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
19
+
20
+ // src/index.ts
21
+ var index_exports = {};
22
+ __export(index_exports, {
23
+ init: () => init
24
+ });
25
+ module.exports = __toCommonJS(index_exports);
26
+
27
+ // src/functions.ts
28
+ var functions = {
29
+ PDFiumExt_Init: [[], null],
30
+ PDFiumExt_OpenFileWriter: [[], "number"],
31
+ PDFiumExt_CloseFileWriter: [["number"], null],
32
+ PDFiumExt_GetFileWriterSize: [["number"], "number"],
33
+ PDFiumExt_GetFileWriterData: [["number", "number", "number"], null],
34
+ PDFiumExt_OpenFormFillInfo: [[], "number"],
35
+ PDFiumExt_CloseFormFillInfo: [["number"], null],
36
+ PDFiumExt_InitFormFillEnvironment: [["number", "number"], "number"],
37
+ PDFiumExt_ExitFormFillEnvironment: [["number"], null],
38
+ PDFiumExt_SaveAsCopy: [["number", "number"], null],
39
+ FPDF_LoadCustomDocument: [["number", "number"], "number"],
40
+ FPDF_LoadMemDocument: [["number", "number", "number"], "number"],
41
+ FPDF_GetPageSizeByIndexF: [["number", "number", "number"], "number"],
42
+ FPDF_GetLastError: [[], "number"],
43
+ FPDF_GetPageCount: [["number"], "number"],
44
+ FPDF_GetPageWidthF: [["number"], "number"],
45
+ FPDF_GetPageHeightF: [["number"], "number"],
46
+ FPDF_CloseDocument: [["number"], null],
47
+ FPDF_GetDocPermissions: [["number"], "number"],
48
+ FPDF_GetDocUserPermissions: [["number"], "number"],
49
+ FPDF_DestroyLibrary: [[], null],
50
+ FPDF_GetMetaText: [["number", "string", "number", "number"], "number"],
51
+ FPDFBitmap_FillRect: [["number", "number", "number", "number", "number", "number"], null],
52
+ FPDFBitmap_Create: [["number", "number", "number"], "number"],
53
+ FPDFBitmap_CreateEx: [["number", "number", "number", "number", "number"], "number"],
54
+ FPDFBitmap_GetBuffer: [["number"], "number"],
55
+ FPDFBitmap_GetWidth: [["number"], "number"],
56
+ FPDFBitmap_GetHeight: [["number"], "number"],
57
+ FPDFBitmap_GetFormat: [["number"], "number"],
58
+ FPDFBitmap_Destroy: [["number"], null],
59
+ FPDFPageObj_Destroy: [["number"], null],
60
+ FPDFPageObj_NewImageObj: [["number"], "number"],
61
+ FPDFPageObj_GetMatrix: [["number", "number"], "boolean"],
62
+ FPDFPageObj_SetMatrix: [["number", "number"], "boolean"],
63
+ FPDFPageObj_GetBounds: [["number", "number", "number", "number", "number"], "boolean"],
64
+ FPDFPageObj_Transform: [["number", "number", "number", "number", "number", "number", "number"], null],
65
+ FPDFImageObj_SetBitmap: [["number", "number", "number", "number"], "boolean"],
66
+ FPDFImageObj_GetBitmap: [["number"], "number"],
67
+ FPDFPath_CountSegments: [["number"], "number"],
68
+ FPDFPath_GetPathSegment: [["number", "number"], "number"],
69
+ FPDFPathSegment_GetType: [["number"], "number"],
70
+ FPDFPathSegment_GetPoint: [["number", "number", "number"], "boolean"],
71
+ FPDFPathSegment_GetClose: [["number"], "boolean"],
72
+ FPDFFormObj_CountObjects: [["number"], "number"],
73
+ FPDFFormObj_GetObject: [["number", "number"], "number"],
74
+ FPDFBookmark_GetFirstChild: [["number", "number"], "number"],
75
+ FPDFBookmark_GetNextSibling: [["number", "number"], "number"],
76
+ FPDFBookmark_Find: [["number", "string"], "number"],
77
+ FPDFBookmark_GetTitle: [["number", "number", "number"], "number"],
78
+ FPDFBookmark_GetAction: [["number"], "number"],
79
+ FPDFBookmark_GetDest: [["number", "number"], "number"],
80
+ FPDFAction_GetType: [["number"], "number"],
81
+ FPDFAction_GetFilePath: [["number", "number", "number"], "number"],
82
+ FPDFAction_GetDest: [["number", "number"], "number"],
83
+ FPDFAction_GetURIPath: [["number", "number", "number", "number"], "number"],
84
+ FPDFDest_GetDestPageIndex: [["number", "number"], "number"],
85
+ FPDFDest_GetView: [["number", "number", "number"], "number"],
86
+ FPDFDest_GetLocationInPage: [["number", "number", "number", "number", "number", "number", "number"], "boolean"],
87
+ FPDF_LoadPage: [["number", "number"], "number"],
88
+ FPDF_RenderPageBitmap: [["number", "number", "number", "number", "number", "number", "number", "number"], null],
89
+ FPDF_PageToDevice: [["number", "number", "number", "number", "number", "number", "number", "number", "number", "number"], null],
90
+ FPDF_DeviceToPage: [["number", "number", "number", "number", "number", "number", "number", "number", "number", "number"], "boolean"],
91
+ FPDFPage_GetAnnotCount: [["number"], "number"],
92
+ FPDFPage_GetAnnot: [["number", "number"], "number"],
93
+ FPDFPage_CreateAnnot: [["number", "number"], "number"],
94
+ FPDFPage_InsertObject: [["number", "number"], "boolean"],
95
+ FPDFPage_RemoveAnnot: [["number", "number"], "boolean"],
96
+ FPDFPage_GenerateContent: [["number"], "boolean"],
97
+ FPDFPage_Flatten: [["number", "number"], "number"],
98
+ FPDF_ClosePage: [["number"], null],
99
+ FPDFAnnot_GetSubtype: [["number"], "number"],
100
+ FPDFAnnot_GetAP: [["number", "number", "number", "number"], "number"],
101
+ FPDFAnnot_GetObjectCount: [["number"], "number"],
102
+ FPDFAnnot_GetObject: [["number", "number"], "number"],
103
+ FPDFAnnot_AppendObject: [["number", "number"], "boolean"],
104
+ FPDFAnnot_GetRect: [["number", "number"], "boolean"],
105
+ FPDFAnnot_SetRect: [["number", "number"], "boolean"],
106
+ FPDFAnnot_GetLink: [["number"], "number"],
107
+ FPDFAnnot_GetFormFieldType: [["number", "number"], "number"],
108
+ FPDFAnnot_GetFormFieldFlags: [["number", "number"], "number"],
109
+ FPDFAnnot_GetFormFieldName: [["number", "number", "number", "number"], "number"],
110
+ FPDFAnnot_GetFormFieldAlternateName: [["number", "number", "number", "number"], "number"],
111
+ FPDFAnnot_GetFormFieldValue: [["number", "number", "number", "number"], "number"],
112
+ FPDFAnnot_GetOptionCount: [["number", "number"], "number"],
113
+ FPDFAnnot_GetOptionLabel: [["number", "number", "number", "number", "number"], "number"],
114
+ FPDFAnnot_IsOptionSelected: [["number", "number", "number"], "boolean"],
115
+ FPDFAnnot_IsChecked: [["number", "number"], "boolean"],
116
+ FPDFAnnot_GetStringValue: [["number", "string", "number", "number"], "number"],
117
+ FPDFAnnot_GetColor: [["number", "number", "number", "number", "number", "number"], "number"],
118
+ FPDFAnnot_GetLinkedAnnot: [["number", "string"], "number"],
119
+ FPDFAnnot_GetInkListCount: [["number"], "number"],
120
+ FPDFAnnot_GetInkListPath: [["number", "number", "number", "number"], "number"],
121
+ FPDFAnnot_AddInkStroke: [["number", "number", "number"], "number"],
122
+ FPDFAnnot_RemoveInkList: [["number"], "boolean"],
123
+ FPDFAnnot_GetVertices: [["number", "number", "number"], "number"],
124
+ FPDFAnnot_GetLine: [["number", "number", "number"], "number"],
125
+ FPDFPageObj_GetType: [["number"], "number"],
126
+ FPDFLink_GetDest: [["number", "number"], "number"],
127
+ FPDFLink_GetAction: [["number"], "number"],
128
+ FPDFText_LoadPage: [["number"], "number"],
129
+ FPDFText_CountChars: [["number"], "number"],
130
+ FPDFText_CountRects: [["number", "number", "number"], "number"],
131
+ FPDFText_GetRect: [["number", "number", "number", "number", "number", "number"], "boolean"],
132
+ FPDFText_GetCharIndexAtPos: [["number", "number", "number", "number", "number"], "number"],
133
+ FPDFText_GetFontSize: [["number", "number"], "number"],
134
+ FPDFText_GetFontInfo: [["number", "number", "number", "number", "number"], "number"],
135
+ FPDFText_GetBoundedText: [["number", "number", "number", "number", "number", "number", "number"], "number"],
136
+ FPDFText_FindStart: [["number", "number", "number", "number"], "number"],
137
+ FPDFText_FindNext: [["number"], "boolean"],
138
+ FPDFText_FindPrev: [["number"], "boolean"],
139
+ FPDFText_GetSchResultIndex: [["number"], "number"],
140
+ FPDFText_GetSchCount: [["number"], "number"],
141
+ FPDFText_FindClose: [["number"], null],
142
+ FPDFText_ClosePage: [["number"], null],
143
+ FPDFText_GetText: [["number", "number", "number", "number"], "number"],
144
+ FPDFText_GetCharBox: [["number", "number", "number", "number", "number", "number"], "boolean"],
145
+ FPDFPage_CloseAnnot: [["number"], null],
146
+ FPDFDoc_GetAttachmentCount: [["number"], "number"],
147
+ FPDFDoc_GetAttachment: [["number", "number"], "number"],
148
+ FPDFAttachment_GetName: [["number", "number", "number"], "number"],
149
+ FPDFAttachment_GetStringValue: [["number", "string", "number", "number"], "number"],
150
+ FPDFAttachment_GetFile: [["number", "number", "number", "number"], "boolean"],
151
+ FORM_OnAfterLoadPage: [["number", "number"], null],
152
+ FORM_OnBeforeClosePage: [["number", "number"], null],
153
+ FPDFAnnot_SetFocusableSubtypes: [["number", "number", "number"], "boolean"],
154
+ FPDFAnnot_GetFocusableSubtypesCount: [["number"], "number"],
155
+ FPDFAnnot_GetFocusableSubtypes: [["number", "number", "number"], "boolean"],
156
+ FORM_SetFocusedAnnot: [["number", "number"], "boolean"],
157
+ FORM_SetIndexSelected: [["number", "number", "number", "boolean"], "boolean"],
158
+ FORM_OnKeyDown: [["number", "number", "number", "number"], "boolean"],
159
+ FORM_OnKeyUp: [["number", "number", "number", "number"], "boolean"],
160
+ FORM_OnChar: [["number", "number", "number", "number"], "boolean"],
161
+ FORM_SelectAllText: [["number", "number"], "boolean"],
162
+ FORM_ReplaceSelection: [["number", "number", "number"], null],
163
+ FORM_ForceToKillFocus: [["number"], "boolean"],
164
+ FPDF_GetSignatureCount: [["number"], "number"],
165
+ FPDF_GetSignatureObject: [["number", "number"], "number"],
166
+ FPDFSignatureObj_GetContents: [["number", "number", "number"], "number"],
167
+ FPDFSignatureObj_GetByteRange: [["number", "number", "number"], "number"],
168
+ FPDFSignatureObj_GetSubFilter: [["number", "number", "number"], "number"],
169
+ FPDFSignatureObj_GetReason: [["number", "number", "number"], "number"],
170
+ FPDFSignatureObj_GetTime: [["number", "number", "number"], "number"],
171
+ FPDFSignatureObj_GetDocMDPPermission: [["number"], "number"],
172
+ FPDF_CreateNewDocument: [[], "number"],
173
+ FPDF_ImportPagesByIndex: [["number", "number", "number", "number", "number"], "boolean"],
174
+ FPDF_ImportPages: [["number", "number", "number", "number"], "boolean"]
175
+ };
176
+
177
+ // src/pdfium.js
178
+ var import_meta = {};
179
+ var createPdfium = (() => {
180
+ var _scriptName = import_meta.url;
181
+ return function(moduleArg = {}) {
182
+ var moduleRtn;
183
+ var Module = moduleArg;
184
+ var readyPromiseResolve, readyPromiseReject;
185
+ var readyPromise = new Promise((resolve, reject) => {
186
+ readyPromiseResolve = resolve;
187
+ readyPromiseReject = reject;
188
+ });
189
+ ["_malloc", "_free", "_PDFiumExt_Init", "_PDFiumExt_OpenFileWriter", "_PDFiumExt_CloseFileWriter", "_PDFiumExt_GetFileWriterSize", "_PDFiumExt_GetFileWriterData", "_PDFiumExt_OpenFormFillInfo", "_PDFiumExt_CloseFormFillInfo", "_PDFiumExt_InitFormFillEnvironment", "_PDFiumExt_ExitFormFillEnvironment", "_PDFiumExt_SaveAsCopy", "_FPDF_LoadCustomDocument", "_FPDF_LoadMemDocument", "_FPDF_GetPageSizeByIndexF", "_FPDF_GetLastError", "_FPDF_GetPageCount", "_FPDF_GetPageWidthF", "_FPDF_GetPageHeightF", "_FPDF_CloseDocument", "_FPDF_GetDocPermissions", "_FPDF_GetDocUserPermissions", "_FPDF_DestroyLibrary", "_FPDF_GetMetaText", "_FPDFBitmap_FillRect", "_FPDFBitmap_Create", "_FPDFBitmap_CreateEx", "_FPDFBitmap_GetBuffer", "_FPDFBitmap_GetWidth", "_FPDFBitmap_GetHeight", "_FPDFBitmap_GetFormat", "_FPDFBitmap_Destroy", "_FPDFPageObj_Destroy", "_FPDFPageObj_NewImageObj", "_FPDFPageObj_GetMatrix", "_FPDFPageObj_SetMatrix", "_FPDFPageObj_GetBounds", "_FPDFPageObj_Transform", "_FPDFImageObj_SetBitmap", "_FPDFImageObj_GetBitmap", "_FPDFPath_CountSegments", "_FPDFPath_GetPathSegment", "_FPDFPathSegment_GetType", "_FPDFPathSegment_GetPoint", "_FPDFPathSegment_GetClose", "_FPDFFormObj_CountObjects", "_FPDFFormObj_GetObject", "_FPDFBookmark_GetFirstChild", "_FPDFBookmark_GetNextSibling", "_FPDFBookmark_Find", "_FPDFBookmark_GetTitle", "_FPDFBookmark_GetAction", "_FPDFBookmark_GetDest", "_FPDFAction_GetType", "_FPDFAction_GetFilePath", "_FPDFAction_GetDest", "_FPDFAction_GetURIPath", "_FPDFDest_GetDestPageIndex", "_FPDFDest_GetView", "_FPDFDest_GetLocationInPage", "_FPDF_LoadPage", "_FPDF_RenderPageBitmap", "_FPDF_PageToDevice", "_FPDF_DeviceToPage", "_FPDFPage_GetAnnotCount", "_FPDFPage_GetAnnot", "_FPDFPage_CreateAnnot", "_FPDFPage_InsertObject", "_FPDFPage_RemoveAnnot", "_FPDFPage_GenerateContent", "_FPDFPage_Flatten", "_FPDF_ClosePage", "_FPDFAnnot_GetSubtype", "_FPDFAnnot_GetAP", "_FPDFAnnot_GetObjectCount", "_FPDFAnnot_GetObject", "_FPDFAnnot_AppendObject", "_FPDFAnnot_GetRect", "_FPDFAnnot_SetRect", "_FPDFAnnot_GetLink", "_FPDFAnnot_GetFormFieldType", "_FPDFAnnot_GetFormFieldFlags", "_FPDFAnnot_GetFormFieldName", "_FPDFAnnot_GetFormFieldAlternateName", "_FPDFAnnot_GetFormFieldValue", "_FPDFAnnot_GetOptionCount", "_FPDFAnnot_GetOptionLabel", "_FPDFAnnot_IsOptionSelected", "_FPDFAnnot_IsChecked", "_FPDFAnnot_GetStringValue", "_FPDFAnnot_GetColor", "_FPDFAnnot_GetLinkedAnnot", "_FPDFAnnot_GetInkListCount", "_FPDFAnnot_GetInkListPath", "_FPDFAnnot_AddInkStroke", "_FPDFAnnot_RemoveInkList", "_FPDFAnnot_GetVertices", "_FPDFAnnot_GetLine", "_FPDFPageObj_GetType", "_FPDFLink_GetDest", "_FPDFLink_GetAction", "_FPDFText_LoadPage", "_FPDFText_CountChars", "_FPDFText_CountRects", "_FPDFText_GetRect", "_FPDFText_GetCharIndexAtPos", "_FPDFText_GetFontSize", "_FPDFText_GetFontInfo", "_FPDFText_GetBoundedText", "_FPDFText_FindStart", "_FPDFText_FindNext", "_FPDFText_FindPrev", "_FPDFText_GetSchResultIndex", "_FPDFText_GetSchCount", "_FPDFText_FindClose", "_FPDFText_ClosePage", "_FPDFText_GetText", "_FPDFText_GetCharBox", "_FPDFPage_CloseAnnot", "_FPDFDoc_GetAttachmentCount", "_FPDFDoc_GetAttachment", "_FPDFAttachment_GetName", "_FPDFAttachment_GetStringValue", "_FPDFAttachment_GetFile", "_FORM_OnAfterLoadPage", "_FORM_OnBeforeClosePage", "_FPDFAnnot_SetFocusableSubtypes", "_FPDFAnnot_GetFocusableSubtypesCount", "_FPDFAnnot_GetFocusableSubtypes", "_FORM_SetFocusedAnnot", "_FORM_SetIndexSelected", "_FORM_OnKeyDown", "_FORM_OnKeyUp", "_FORM_OnChar", "_FORM_SelectAllText", "_FORM_ReplaceSelection", "_FORM_ForceToKillFocus", "_FPDF_GetSignatureCount", "_FPDF_GetSignatureObject", "_FPDFSignatureObj_GetContents", "_FPDFSignatureObj_GetByteRange", "_FPDFSignatureObj_GetSubFilter", "_FPDFSignatureObj_GetReason", "_FPDFSignatureObj_GetTime", "_FPDFSignatureObj_GetDocMDPPermission", "_FPDF_CreateNewDocument", "_FPDF_ImportPagesByIndex", "_FPDF_ImportPages", "_memory", "___indirect_function_table", "onRuntimeInitialized"].forEach((prop) => {
190
+ if (!Object.getOwnPropertyDescriptor(readyPromise, prop)) {
191
+ Object.defineProperty(readyPromise, prop, {
192
+ get: () => abort("You are getting " + prop + " on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js"),
193
+ set: () => abort("You are setting " + prop + " on the Promise object, instead of the instance. Use .then() to get called back with the instance, see the MODULARIZE docs in src/settings.js")
194
+ });
195
+ }
196
+ });
197
+ var ENVIRONMENT_IS_WEB = false;
198
+ var ENVIRONMENT_IS_WORKER = true;
199
+ var ENVIRONMENT_IS_NODE = false;
200
+ var ENVIRONMENT_IS_SHELL = false;
201
+ var moduleOverrides = Object.assign({}, Module);
202
+ var arguments_ = [];
203
+ var thisProgram = "./this.program";
204
+ var quit_ = (status, toThrow) => {
205
+ throw toThrow;
206
+ };
207
+ var scriptDirectory = "";
208
+ function locateFile(path) {
209
+ if (Module["locateFile"]) {
210
+ return Module["locateFile"](path, scriptDirectory);
211
+ }
212
+ return scriptDirectory + path;
213
+ }
214
+ var readAsync, readBinary;
215
+ if (ENVIRONMENT_IS_SHELL) {
216
+ if (typeof process == "object" && typeof require === "function" || typeof window == "object" || typeof importScripts == "function") throw new Error("not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)");
217
+ } else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
218
+ if (ENVIRONMENT_IS_WORKER) {
219
+ scriptDirectory = self.location.href;
220
+ } else if (typeof document != "undefined" && document.currentScript) {
221
+ scriptDirectory = document.currentScript.src;
222
+ }
223
+ if (_scriptName) {
224
+ scriptDirectory = _scriptName;
225
+ }
226
+ if (scriptDirectory.startsWith("blob:")) {
227
+ scriptDirectory = "";
228
+ } else {
229
+ scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1);
230
+ }
231
+ if (!(typeof window == "object" || typeof importScripts == "function")) throw new Error("not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)");
232
+ {
233
+ if (ENVIRONMENT_IS_WORKER) {
234
+ readBinary = (url) => {
235
+ var xhr = new XMLHttpRequest();
236
+ xhr.open("GET", url, false);
237
+ xhr.responseType = "arraybuffer";
238
+ xhr.send(null);
239
+ return new Uint8Array(
240
+ /** @type{!ArrayBuffer} */
241
+ xhr.response
242
+ );
243
+ };
244
+ }
245
+ readAsync = (url) => {
246
+ assert(!isFileURI(url), "readAsync does not work with file:// URLs");
247
+ return fetch(url, { credentials: "same-origin" }).then((response) => {
248
+ if (response.ok) {
249
+ return response.arrayBuffer();
250
+ }
251
+ return Promise.reject(new Error(response.status + " : " + response.url));
252
+ });
253
+ };
254
+ }
255
+ } else {
256
+ throw new Error("environment detection error");
257
+ }
258
+ var out = Module["print"] || console.log.bind(console);
259
+ var err = Module["printErr"] || console.error.bind(console);
260
+ Object.assign(Module, moduleOverrides);
261
+ moduleOverrides = null;
262
+ checkIncomingModuleAPI();
263
+ if (Module["arguments"]) arguments_ = Module["arguments"];
264
+ legacyModuleProp("arguments", "arguments_");
265
+ if (Module["thisProgram"]) thisProgram = Module["thisProgram"];
266
+ legacyModuleProp("thisProgram", "thisProgram");
267
+ assert(typeof Module["memoryInitializerPrefixURL"] == "undefined", "Module.memoryInitializerPrefixURL option was removed, use Module.locateFile instead");
268
+ assert(typeof Module["pthreadMainPrefixURL"] == "undefined", "Module.pthreadMainPrefixURL option was removed, use Module.locateFile instead");
269
+ assert(typeof Module["cdInitializerPrefixURL"] == "undefined", "Module.cdInitializerPrefixURL option was removed, use Module.locateFile instead");
270
+ assert(typeof Module["filePackagePrefixURL"] == "undefined", "Module.filePackagePrefixURL option was removed, use Module.locateFile instead");
271
+ assert(typeof Module["read"] == "undefined", "Module.read option was removed");
272
+ assert(typeof Module["readAsync"] == "undefined", "Module.readAsync option was removed (modify readAsync in JS)");
273
+ assert(typeof Module["readBinary"] == "undefined", "Module.readBinary option was removed (modify readBinary in JS)");
274
+ assert(typeof Module["setWindowTitle"] == "undefined", "Module.setWindowTitle option was removed (modify emscripten_set_window_title in JS)");
275
+ assert(typeof Module["TOTAL_MEMORY"] == "undefined", "Module.TOTAL_MEMORY has been renamed Module.INITIAL_MEMORY");
276
+ legacyModuleProp("asm", "wasmExports");
277
+ legacyModuleProp("readAsync", "readAsync");
278
+ legacyModuleProp("readBinary", "readBinary");
279
+ legacyModuleProp("setWindowTitle", "setWindowTitle");
280
+ var IDBFS = "IDBFS is no longer included by default; build with -lidbfs.js";
281
+ var PROXYFS = "PROXYFS is no longer included by default; build with -lproxyfs.js";
282
+ var WORKERFS = "WORKERFS is no longer included by default; build with -lworkerfs.js";
283
+ var FETCHFS = "FETCHFS is no longer included by default; build with -lfetchfs.js";
284
+ var ICASEFS = "ICASEFS is no longer included by default; build with -licasefs.js";
285
+ var JSFILEFS = "JSFILEFS is no longer included by default; build with -ljsfilefs.js";
286
+ var OPFS = "OPFS is no longer included by default; build with -lopfs.js";
287
+ var NODEFS = "NODEFS is no longer included by default; build with -lnodefs.js";
288
+ assert(!ENVIRONMENT_IS_WEB, "web environment detected but not enabled at build time. Add `web` to `-sENVIRONMENT` to enable.");
289
+ assert(!ENVIRONMENT_IS_NODE, "node environment detected but not enabled at build time. Add `node` to `-sENVIRONMENT` to enable.");
290
+ assert(!ENVIRONMENT_IS_SHELL, "shell environment detected but not enabled at build time. Add `shell` to `-sENVIRONMENT` to enable.");
291
+ var wasmBinary = Module["wasmBinary"];
292
+ legacyModuleProp("wasmBinary", "wasmBinary");
293
+ if (typeof WebAssembly != "object") {
294
+ err("no native wasm support detected");
295
+ }
296
+ var wasmMemory;
297
+ var ABORT = false;
298
+ var EXITSTATUS;
299
+ function assert(condition, text) {
300
+ if (!condition) {
301
+ abort("Assertion failed" + (text ? ": " + text : ""));
302
+ }
303
+ }
304
+ var HEAP, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
305
+ function updateMemoryViews() {
306
+ var b = wasmMemory.buffer;
307
+ Module["HEAP8"] = HEAP8 = new Int8Array(b);
308
+ Module["HEAP16"] = HEAP16 = new Int16Array(b);
309
+ Module["HEAPU8"] = HEAPU8 = new Uint8Array(b);
310
+ Module["HEAPU16"] = HEAPU16 = new Uint16Array(b);
311
+ Module["HEAP32"] = HEAP32 = new Int32Array(b);
312
+ Module["HEAPU32"] = HEAPU32 = new Uint32Array(b);
313
+ Module["HEAPF32"] = HEAPF32 = new Float32Array(b);
314
+ Module["HEAPF64"] = HEAPF64 = new Float64Array(b);
315
+ }
316
+ assert(!Module["STACK_SIZE"], "STACK_SIZE can no longer be set at runtime. Use -sSTACK_SIZE at link time");
317
+ assert(
318
+ typeof Int32Array != "undefined" && typeof Float64Array !== "undefined" && Int32Array.prototype.subarray != void 0 && Int32Array.prototype.set != void 0,
319
+ "JS engine does not provide full typed array support"
320
+ );
321
+ assert(!Module["wasmMemory"], "Use of `wasmMemory` detected. Use -sIMPORTED_MEMORY to define wasmMemory externally");
322
+ assert(!Module["INITIAL_MEMORY"], "Detected runtime INITIAL_MEMORY setting. Use -sIMPORTED_MEMORY to define wasmMemory dynamically");
323
+ function writeStackCookie() {
324
+ var max = _emscripten_stack_get_end();
325
+ assert((max & 3) == 0);
326
+ if (max == 0) {
327
+ max += 4;
328
+ }
329
+ HEAPU32[max >> 2] = 34821223;
330
+ HEAPU32[max + 4 >> 2] = 2310721022;
331
+ HEAPU32[0 >> 2] = 1668509029;
332
+ }
333
+ function checkStackCookie() {
334
+ if (ABORT) return;
335
+ var max = _emscripten_stack_get_end();
336
+ if (max == 0) {
337
+ max += 4;
338
+ }
339
+ var cookie1 = HEAPU32[max >> 2];
340
+ var cookie2 = HEAPU32[max + 4 >> 2];
341
+ if (cookie1 != 34821223 || cookie2 != 2310721022) {
342
+ abort(`Stack overflow! Stack cookie has been overwritten at ${ptrToString(max)}, expected hex dwords 0x89BACDFE and 0x2135467, but received ${ptrToString(cookie2)} ${ptrToString(cookie1)}`);
343
+ }
344
+ if (HEAPU32[0 >> 2] != 1668509029) {
345
+ abort("Runtime error: The application has corrupted its heap memory area (address zero)!");
346
+ }
347
+ }
348
+ var __ATPRERUN__ = [];
349
+ var __ATINIT__ = [];
350
+ var __ATEXIT__ = [];
351
+ var __ATPOSTRUN__ = [];
352
+ var runtimeInitialized = false;
353
+ function preRun() {
354
+ var preRuns = Module["preRun"];
355
+ if (preRuns) {
356
+ if (typeof preRuns == "function") preRuns = [preRuns];
357
+ preRuns.forEach(addOnPreRun);
358
+ }
359
+ callRuntimeCallbacks(__ATPRERUN__);
360
+ }
361
+ function initRuntime() {
362
+ assert(!runtimeInitialized);
363
+ runtimeInitialized = true;
364
+ checkStackCookie();
365
+ if (!Module["noFSInit"] && !FS.initialized)
366
+ FS.init();
367
+ FS.ignorePermissions = false;
368
+ TTY.init();
369
+ callRuntimeCallbacks(__ATINIT__);
370
+ }
371
+ function postRun() {
372
+ checkStackCookie();
373
+ var postRuns = Module["postRun"];
374
+ if (postRuns) {
375
+ if (typeof postRuns == "function") postRuns = [postRuns];
376
+ postRuns.forEach(addOnPostRun);
377
+ }
378
+ callRuntimeCallbacks(__ATPOSTRUN__);
379
+ }
380
+ function addOnPreRun(cb) {
381
+ __ATPRERUN__.unshift(cb);
382
+ }
383
+ function addOnInit(cb) {
384
+ __ATINIT__.unshift(cb);
385
+ }
386
+ function addOnExit(cb) {
387
+ }
388
+ function addOnPostRun(cb) {
389
+ __ATPOSTRUN__.unshift(cb);
390
+ }
391
+ assert(Math.imul, "This browser does not support Math.imul(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");
392
+ assert(Math.fround, "This browser does not support Math.fround(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");
393
+ assert(Math.clz32, "This browser does not support Math.clz32(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");
394
+ assert(Math.trunc, "This browser does not support Math.trunc(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill");
395
+ var runDependencies = 0;
396
+ var runDependencyWatcher = null;
397
+ var dependenciesFulfilled = null;
398
+ var runDependencyTracking = {};
399
+ function getUniqueRunDependency(id) {
400
+ var orig = id;
401
+ while (1) {
402
+ if (!runDependencyTracking[id]) return id;
403
+ id = orig + Math.random();
404
+ }
405
+ }
406
+ function addRunDependency(id) {
407
+ runDependencies++;
408
+ Module["monitorRunDependencies"]?.(runDependencies);
409
+ if (id) {
410
+ assert(!runDependencyTracking[id]);
411
+ runDependencyTracking[id] = 1;
412
+ if (runDependencyWatcher === null && typeof setInterval != "undefined") {
413
+ runDependencyWatcher = setInterval(() => {
414
+ if (ABORT) {
415
+ clearInterval(runDependencyWatcher);
416
+ runDependencyWatcher = null;
417
+ return;
418
+ }
419
+ var shown = false;
420
+ for (var dep in runDependencyTracking) {
421
+ if (!shown) {
422
+ shown = true;
423
+ err("still waiting on run dependencies:");
424
+ }
425
+ err(`dependency: ${dep}`);
426
+ }
427
+ if (shown) {
428
+ err("(end of list)");
429
+ }
430
+ }, 1e4);
431
+ }
432
+ } else {
433
+ err("warning: run dependency added without ID");
434
+ }
435
+ }
436
+ function removeRunDependency(id) {
437
+ runDependencies--;
438
+ Module["monitorRunDependencies"]?.(runDependencies);
439
+ if (id) {
440
+ assert(runDependencyTracking[id]);
441
+ delete runDependencyTracking[id];
442
+ } else {
443
+ err("warning: run dependency removed without ID");
444
+ }
445
+ if (runDependencies == 0) {
446
+ if (runDependencyWatcher !== null) {
447
+ clearInterval(runDependencyWatcher);
448
+ runDependencyWatcher = null;
449
+ }
450
+ if (dependenciesFulfilled) {
451
+ var callback = dependenciesFulfilled;
452
+ dependenciesFulfilled = null;
453
+ callback();
454
+ }
455
+ }
456
+ }
457
+ function abort(what) {
458
+ Module["onAbort"]?.(what);
459
+ what = "Aborted(" + what + ")";
460
+ err(what);
461
+ ABORT = true;
462
+ var e = new WebAssembly.RuntimeError(what);
463
+ readyPromiseReject(e);
464
+ throw e;
465
+ }
466
+ var dataURIPrefix = "data:application/octet-stream;base64,";
467
+ var isDataURI = (filename) => filename.startsWith(dataURIPrefix);
468
+ var isFileURI = (filename) => filename.startsWith("file://");
469
+ function createExportWrapper(name, nargs) {
470
+ return (...args) => {
471
+ assert(runtimeInitialized, `native function \`${name}\` called before runtime initialization`);
472
+ var f = wasmExports[name];
473
+ assert(f, `exported native function \`${name}\` not found`);
474
+ assert(args.length <= nargs, `native function \`${name}\` called with ${args.length} args but expects ${nargs}`);
475
+ return f(...args);
476
+ };
477
+ }
478
+ function findWasmBinary() {
479
+ if (Module["locateFile"]) {
480
+ var f = "pdfium.wasm";
481
+ if (!isDataURI(f)) {
482
+ return locateFile(f);
483
+ }
484
+ return f;
485
+ }
486
+ return new URL("pdfium.wasm", import_meta.url).href;
487
+ }
488
+ var wasmBinaryFile;
489
+ function getBinarySync(file) {
490
+ if (file == wasmBinaryFile && wasmBinary) {
491
+ return new Uint8Array(wasmBinary);
492
+ }
493
+ if (readBinary) {
494
+ return readBinary(file);
495
+ }
496
+ throw "both async and sync fetching of the wasm failed";
497
+ }
498
+ function getBinaryPromise(binaryFile) {
499
+ if (!wasmBinary) {
500
+ return readAsync(binaryFile).then(
501
+ (response) => new Uint8Array(
502
+ /** @type{!ArrayBuffer} */
503
+ response
504
+ ),
505
+ // Fall back to getBinarySync if readAsync fails
506
+ () => getBinarySync(binaryFile)
507
+ );
508
+ }
509
+ return Promise.resolve().then(() => getBinarySync(binaryFile));
510
+ }
511
+ function instantiateArrayBuffer(binaryFile, imports, receiver) {
512
+ return getBinaryPromise(binaryFile).then((binary) => {
513
+ return WebAssembly.instantiate(binary, imports);
514
+ }).then(receiver, (reason) => {
515
+ err(`failed to asynchronously prepare wasm: ${reason}`);
516
+ if (isFileURI(wasmBinaryFile)) {
517
+ err(`warning: Loading from a file URI (${wasmBinaryFile}) is not supported in most browsers. See https://emscripten.org/docs/getting_started/FAQ.html#how-do-i-run-a-local-webserver-for-testing-why-does-my-program-stall-in-downloading-or-preparing`);
518
+ }
519
+ abort(reason);
520
+ });
521
+ }
522
+ function instantiateAsync(binary, binaryFile, imports, callback) {
523
+ if (!binary && typeof WebAssembly.instantiateStreaming == "function" && !isDataURI(binaryFile) && typeof fetch == "function") {
524
+ return fetch(binaryFile, { credentials: "same-origin" }).then((response) => {
525
+ var result = WebAssembly.instantiateStreaming(response, imports);
526
+ return result.then(
527
+ callback,
528
+ function(reason) {
529
+ err(`wasm streaming compile failed: ${reason}`);
530
+ err("falling back to ArrayBuffer instantiation");
531
+ return instantiateArrayBuffer(binaryFile, imports, callback);
532
+ }
533
+ );
534
+ });
535
+ }
536
+ return instantiateArrayBuffer(binaryFile, imports, callback);
537
+ }
538
+ function getWasmImports() {
539
+ return {
540
+ "env": wasmImports,
541
+ "wasi_snapshot_preview1": wasmImports
542
+ };
543
+ }
544
+ function createWasm() {
545
+ var info = getWasmImports();
546
+ function receiveInstance(instance, module2) {
547
+ wasmExports = instance.exports;
548
+ Module["wasmExports"] = wasmExports;
549
+ wasmMemory = wasmExports["memory"];
550
+ assert(wasmMemory, "memory not found in wasm exports");
551
+ updateMemoryViews();
552
+ wasmTable = wasmExports["__indirect_function_table"];
553
+ assert(wasmTable, "table not found in wasm exports");
554
+ addOnInit(wasmExports["__wasm_call_ctors"]);
555
+ removeRunDependency("wasm-instantiate");
556
+ return wasmExports;
557
+ }
558
+ addRunDependency("wasm-instantiate");
559
+ var trueModule = Module;
560
+ function receiveInstantiationResult(result) {
561
+ assert(Module === trueModule, "the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?");
562
+ trueModule = null;
563
+ receiveInstance(result["instance"]);
564
+ }
565
+ if (Module["instantiateWasm"]) {
566
+ try {
567
+ return Module["instantiateWasm"](info, receiveInstance);
568
+ } catch (e) {
569
+ err(`Module.instantiateWasm callback failed with error: ${e}`);
570
+ readyPromiseReject(e);
571
+ }
572
+ }
573
+ wasmBinaryFile ?? (wasmBinaryFile = findWasmBinary());
574
+ instantiateAsync(wasmBinary, wasmBinaryFile, info, receiveInstantiationResult).catch(readyPromiseReject);
575
+ return {};
576
+ }
577
+ var tempDouble;
578
+ var tempI64;
579
+ (() => {
580
+ var h16 = new Int16Array(1);
581
+ var h8 = new Int8Array(h16.buffer);
582
+ h16[0] = 25459;
583
+ if (h8[0] !== 115 || h8[1] !== 99) throw "Runtime error: expected the system to be little-endian! (Run with -sSUPPORT_BIG_ENDIAN to bypass)";
584
+ })();
585
+ if (Module["ENVIRONMENT"]) {
586
+ throw new Error("Module.ENVIRONMENT has been deprecated. To force the environment, use the ENVIRONMENT compile-time option (for example, -sENVIRONMENT=web or -sENVIRONMENT=node)");
587
+ }
588
+ function legacyModuleProp(prop, newName, incoming = true) {
589
+ if (!Object.getOwnPropertyDescriptor(Module, prop)) {
590
+ Object.defineProperty(Module, prop, {
591
+ configurable: true,
592
+ get() {
593
+ let extra = incoming ? " (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)" : "";
594
+ abort(`\`Module.${prop}\` has been replaced by \`${newName}\`` + extra);
595
+ }
596
+ });
597
+ }
598
+ }
599
+ function ignoredModuleProp(prop) {
600
+ if (Object.getOwnPropertyDescriptor(Module, prop)) {
601
+ abort(`\`Module.${prop}\` was supplied but \`${prop}\` not included in INCOMING_MODULE_JS_API`);
602
+ }
603
+ }
604
+ function isExportedByForceFilesystem(name) {
605
+ return name === "FS_createPath" || name === "FS_createDataFile" || name === "FS_createPreloadedFile" || name === "FS_unlink" || name === "addRunDependency" || // The old FS has some functionality that WasmFS lacks.
606
+ name === "FS_createLazyFile" || name === "FS_createDevice" || name === "removeRunDependency";
607
+ }
608
+ function hookGlobalSymbolAccess(sym, func) {
609
+ if (typeof globalThis != "undefined" && !Object.getOwnPropertyDescriptor(globalThis, sym)) {
610
+ Object.defineProperty(globalThis, sym, {
611
+ configurable: true,
612
+ get() {
613
+ func();
614
+ return void 0;
615
+ }
616
+ });
617
+ }
618
+ }
619
+ function missingGlobal(sym, msg) {
620
+ hookGlobalSymbolAccess(sym, () => {
621
+ warnOnce(`\`${sym}\` is not longer defined by emscripten. ${msg}`);
622
+ });
623
+ }
624
+ missingGlobal("buffer", "Please use HEAP8.buffer or wasmMemory.buffer");
625
+ missingGlobal("asm", "Please use wasmExports instead");
626
+ function missingLibrarySymbol(sym) {
627
+ hookGlobalSymbolAccess(sym, () => {
628
+ var msg = `\`${sym}\` is a library symbol and not included by default; add it to your library.js __deps or to DEFAULT_LIBRARY_FUNCS_TO_INCLUDE on the command line`;
629
+ var librarySymbol = sym;
630
+ if (!librarySymbol.startsWith("_")) {
631
+ librarySymbol = "$" + sym;
632
+ }
633
+ msg += ` (e.g. -sDEFAULT_LIBRARY_FUNCS_TO_INCLUDE='${librarySymbol}')`;
634
+ if (isExportedByForceFilesystem(sym)) {
635
+ msg += ". Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you";
636
+ }
637
+ warnOnce(msg);
638
+ });
639
+ unexportedRuntimeSymbol(sym);
640
+ }
641
+ function unexportedRuntimeSymbol(sym) {
642
+ if (!Object.getOwnPropertyDescriptor(Module, sym)) {
643
+ Object.defineProperty(Module, sym, {
644
+ configurable: true,
645
+ get() {
646
+ var msg = `'${sym}' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the Emscripten FAQ)`;
647
+ if (isExportedByForceFilesystem(sym)) {
648
+ msg += ". Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you";
649
+ }
650
+ abort(msg);
651
+ }
652
+ });
653
+ }
654
+ }
655
+ function dbg(...args) {
656
+ console.warn(...args);
657
+ }
658
+ function ExitStatus(status) {
659
+ this.name = "ExitStatus";
660
+ this.message = `Program terminated with exit(${status})`;
661
+ this.status = status;
662
+ }
663
+ var callRuntimeCallbacks = (callbacks) => {
664
+ callbacks.forEach((f) => f(Module));
665
+ };
666
+ function getValue(ptr, type = "i8") {
667
+ if (type.endsWith("*")) type = "*";
668
+ switch (type) {
669
+ case "i1":
670
+ return HEAP8[ptr];
671
+ case "i8":
672
+ return HEAP8[ptr];
673
+ case "i16":
674
+ return HEAP16[ptr >> 1];
675
+ case "i32":
676
+ return HEAP32[ptr >> 2];
677
+ case "i64":
678
+ abort("to do getValue(i64) use WASM_BIGINT");
679
+ case "float":
680
+ return HEAPF32[ptr >> 2];
681
+ case "double":
682
+ return HEAPF64[ptr >> 3];
683
+ case "*":
684
+ return HEAPU32[ptr >> 2];
685
+ default:
686
+ abort(`invalid type for getValue: ${type}`);
687
+ }
688
+ }
689
+ var noExitRuntime = Module["noExitRuntime"] || true;
690
+ var ptrToString = (ptr) => {
691
+ assert(typeof ptr === "number");
692
+ ptr >>>= 0;
693
+ return "0x" + ptr.toString(16).padStart(8, "0");
694
+ };
695
+ function setValue(ptr, value, type = "i8") {
696
+ if (type.endsWith("*")) type = "*";
697
+ switch (type) {
698
+ case "i1":
699
+ HEAP8[ptr] = value;
700
+ break;
701
+ case "i8":
702
+ HEAP8[ptr] = value;
703
+ break;
704
+ case "i16":
705
+ HEAP16[ptr >> 1] = value;
706
+ break;
707
+ case "i32":
708
+ HEAP32[ptr >> 2] = value;
709
+ break;
710
+ case "i64":
711
+ abort("to do setValue(i64) use WASM_BIGINT");
712
+ case "float":
713
+ HEAPF32[ptr >> 2] = value;
714
+ break;
715
+ case "double":
716
+ HEAPF64[ptr >> 3] = value;
717
+ break;
718
+ case "*":
719
+ HEAPU32[ptr >> 2] = value;
720
+ break;
721
+ default:
722
+ abort(`invalid type for setValue: ${type}`);
723
+ }
724
+ }
725
+ var stackRestore = (val) => __emscripten_stack_restore(val);
726
+ var stackSave = () => _emscripten_stack_get_current();
727
+ var warnOnce = (text) => {
728
+ warnOnce.shown || (warnOnce.shown = {});
729
+ if (!warnOnce.shown[text]) {
730
+ warnOnce.shown[text] = 1;
731
+ err(text);
732
+ }
733
+ };
734
+ var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder() : void 0;
735
+ var UTF8ArrayToString = (heapOrArray, idx = 0, maxBytesToRead = NaN) => {
736
+ var endIdx = idx + maxBytesToRead;
737
+ var endPtr = idx;
738
+ while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr;
739
+ if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
740
+ return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
741
+ }
742
+ var str = "";
743
+ while (idx < endPtr) {
744
+ var u0 = heapOrArray[idx++];
745
+ if (!(u0 & 128)) {
746
+ str += String.fromCharCode(u0);
747
+ continue;
748
+ }
749
+ var u1 = heapOrArray[idx++] & 63;
750
+ if ((u0 & 224) == 192) {
751
+ str += String.fromCharCode((u0 & 31) << 6 | u1);
752
+ continue;
753
+ }
754
+ var u2 = heapOrArray[idx++] & 63;
755
+ if ((u0 & 240) == 224) {
756
+ u0 = (u0 & 15) << 12 | u1 << 6 | u2;
757
+ } else {
758
+ if ((u0 & 248) != 240) warnOnce("Invalid UTF-8 leading byte " + ptrToString(u0) + " encountered when deserializing a UTF-8 string in wasm memory to a JS string!");
759
+ u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heapOrArray[idx++] & 63;
760
+ }
761
+ if (u0 < 65536) {
762
+ str += String.fromCharCode(u0);
763
+ } else {
764
+ var ch = u0 - 65536;
765
+ str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
766
+ }
767
+ }
768
+ return str;
769
+ };
770
+ var UTF8ToString = (ptr, maxBytesToRead) => {
771
+ assert(typeof ptr == "number", `UTF8ToString expects a number (got ${typeof ptr})`);
772
+ return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
773
+ };
774
+ var ___assert_fail = (condition, filename, line, func) => {
775
+ abort(`Assertion failed: ${UTF8ToString(condition)}, at: ` + [filename ? UTF8ToString(filename) : "unknown filename", line, func ? UTF8ToString(func) : "unknown function"]);
776
+ };
777
+ function syscallGetVarargI() {
778
+ assert(SYSCALLS.varargs != void 0);
779
+ var ret = HEAP32[+SYSCALLS.varargs >> 2];
780
+ SYSCALLS.varargs += 4;
781
+ return ret;
782
+ }
783
+ var syscallGetVarargP = syscallGetVarargI;
784
+ var PATH = {
785
+ isAbs: (path) => path.charAt(0) === "/",
786
+ splitPath: (filename) => {
787
+ var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
788
+ return splitPathRe.exec(filename).slice(1);
789
+ },
790
+ normalizeArray: (parts, allowAboveRoot) => {
791
+ var up = 0;
792
+ for (var i = parts.length - 1; i >= 0; i--) {
793
+ var last = parts[i];
794
+ if (last === ".") {
795
+ parts.splice(i, 1);
796
+ } else if (last === "..") {
797
+ parts.splice(i, 1);
798
+ up++;
799
+ } else if (up) {
800
+ parts.splice(i, 1);
801
+ up--;
802
+ }
803
+ }
804
+ if (allowAboveRoot) {
805
+ for (; up; up--) {
806
+ parts.unshift("..");
807
+ }
808
+ }
809
+ return parts;
810
+ },
811
+ normalize: (path) => {
812
+ var isAbsolute = PATH.isAbs(path), trailingSlash = path.substr(-1) === "/";
813
+ path = PATH.normalizeArray(path.split("/").filter((p) => !!p), !isAbsolute).join("/");
814
+ if (!path && !isAbsolute) {
815
+ path = ".";
816
+ }
817
+ if (path && trailingSlash) {
818
+ path += "/";
819
+ }
820
+ return (isAbsolute ? "/" : "") + path;
821
+ },
822
+ dirname: (path) => {
823
+ var result = PATH.splitPath(path), root = result[0], dir = result[1];
824
+ if (!root && !dir) {
825
+ return ".";
826
+ }
827
+ if (dir) {
828
+ dir = dir.substr(0, dir.length - 1);
829
+ }
830
+ return root + dir;
831
+ },
832
+ basename: (path) => {
833
+ if (path === "/") return "/";
834
+ path = PATH.normalize(path);
835
+ path = path.replace(/\/$/, "");
836
+ var lastSlash = path.lastIndexOf("/");
837
+ if (lastSlash === -1) return path;
838
+ return path.substr(lastSlash + 1);
839
+ },
840
+ join: (...paths) => PATH.normalize(paths.join("/")),
841
+ join2: (l, r) => PATH.normalize(l + "/" + r)
842
+ };
843
+ var initRandomFill = () => {
844
+ if (typeof crypto == "object" && typeof crypto["getRandomValues"] == "function") {
845
+ return (view) => crypto.getRandomValues(view);
846
+ } else
847
+ abort("no cryptographic support found for randomDevice. consider polyfilling it if you want to use something insecure like Math.random(), e.g. put this in a --pre-js: var crypto = { getRandomValues: (array) => { for (var i = 0; i < array.length; i++) array[i] = (Math.random()*256)|0 } };");
848
+ };
849
+ var randomFill = (view) => {
850
+ return (randomFill = initRandomFill())(view);
851
+ };
852
+ var PATH_FS = {
853
+ resolve: (...args) => {
854
+ var resolvedPath = "", resolvedAbsolute = false;
855
+ for (var i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {
856
+ var path = i >= 0 ? args[i] : FS.cwd();
857
+ if (typeof path != "string") {
858
+ throw new TypeError("Arguments to path.resolve must be strings");
859
+ } else if (!path) {
860
+ return "";
861
+ }
862
+ resolvedPath = path + "/" + resolvedPath;
863
+ resolvedAbsolute = PATH.isAbs(path);
864
+ }
865
+ resolvedPath = PATH.normalizeArray(resolvedPath.split("/").filter((p) => !!p), !resolvedAbsolute).join("/");
866
+ return (resolvedAbsolute ? "/" : "") + resolvedPath || ".";
867
+ },
868
+ relative: (from, to) => {
869
+ from = PATH_FS.resolve(from).substr(1);
870
+ to = PATH_FS.resolve(to).substr(1);
871
+ function trim(arr) {
872
+ var start = 0;
873
+ for (; start < arr.length; start++) {
874
+ if (arr[start] !== "") break;
875
+ }
876
+ var end = arr.length - 1;
877
+ for (; end >= 0; end--) {
878
+ if (arr[end] !== "") break;
879
+ }
880
+ if (start > end) return [];
881
+ return arr.slice(start, end - start + 1);
882
+ }
883
+ var fromParts = trim(from.split("/"));
884
+ var toParts = trim(to.split("/"));
885
+ var length = Math.min(fromParts.length, toParts.length);
886
+ var samePartsLength = length;
887
+ for (var i = 0; i < length; i++) {
888
+ if (fromParts[i] !== toParts[i]) {
889
+ samePartsLength = i;
890
+ break;
891
+ }
892
+ }
893
+ var outputParts = [];
894
+ for (var i = samePartsLength; i < fromParts.length; i++) {
895
+ outputParts.push("..");
896
+ }
897
+ outputParts = outputParts.concat(toParts.slice(samePartsLength));
898
+ return outputParts.join("/");
899
+ }
900
+ };
901
+ var FS_stdin_getChar_buffer = [];
902
+ var lengthBytesUTF8 = (str) => {
903
+ var len = 0;
904
+ for (var i = 0; i < str.length; ++i) {
905
+ var c = str.charCodeAt(i);
906
+ if (c <= 127) {
907
+ len++;
908
+ } else if (c <= 2047) {
909
+ len += 2;
910
+ } else if (c >= 55296 && c <= 57343) {
911
+ len += 4;
912
+ ++i;
913
+ } else {
914
+ len += 3;
915
+ }
916
+ }
917
+ return len;
918
+ };
919
+ var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => {
920
+ assert(typeof str === "string", `stringToUTF8Array expects a string (got ${typeof str})`);
921
+ if (!(maxBytesToWrite > 0))
922
+ return 0;
923
+ var startIdx = outIdx;
924
+ var endIdx = outIdx + maxBytesToWrite - 1;
925
+ for (var i = 0; i < str.length; ++i) {
926
+ var u = str.charCodeAt(i);
927
+ if (u >= 55296 && u <= 57343) {
928
+ var u1 = str.charCodeAt(++i);
929
+ u = 65536 + ((u & 1023) << 10) | u1 & 1023;
930
+ }
931
+ if (u <= 127) {
932
+ if (outIdx >= endIdx) break;
933
+ heap[outIdx++] = u;
934
+ } else if (u <= 2047) {
935
+ if (outIdx + 1 >= endIdx) break;
936
+ heap[outIdx++] = 192 | u >> 6;
937
+ heap[outIdx++] = 128 | u & 63;
938
+ } else if (u <= 65535) {
939
+ if (outIdx + 2 >= endIdx) break;
940
+ heap[outIdx++] = 224 | u >> 12;
941
+ heap[outIdx++] = 128 | u >> 6 & 63;
942
+ heap[outIdx++] = 128 | u & 63;
943
+ } else {
944
+ if (outIdx + 3 >= endIdx) break;
945
+ if (u > 1114111) warnOnce("Invalid Unicode code point " + ptrToString(u) + " encountered when serializing a JS string to a UTF-8 string in wasm memory! (Valid unicode code points should be in range 0-0x10FFFF).");
946
+ heap[outIdx++] = 240 | u >> 18;
947
+ heap[outIdx++] = 128 | u >> 12 & 63;
948
+ heap[outIdx++] = 128 | u >> 6 & 63;
949
+ heap[outIdx++] = 128 | u & 63;
950
+ }
951
+ }
952
+ heap[outIdx] = 0;
953
+ return outIdx - startIdx;
954
+ };
955
+ function intArrayFromString(stringy, dontAddNull, length) {
956
+ var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1;
957
+ var u8array = new Array(len);
958
+ var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length);
959
+ if (dontAddNull) u8array.length = numBytesWritten;
960
+ return u8array;
961
+ }
962
+ var FS_stdin_getChar = () => {
963
+ if (!FS_stdin_getChar_buffer.length) {
964
+ var result = null;
965
+ {
966
+ }
967
+ if (!result) {
968
+ return null;
969
+ }
970
+ FS_stdin_getChar_buffer = intArrayFromString(result, true);
971
+ }
972
+ return FS_stdin_getChar_buffer.shift();
973
+ };
974
+ var TTY = {
975
+ ttys: [],
976
+ init() {
977
+ },
978
+ shutdown() {
979
+ },
980
+ register(dev, ops) {
981
+ TTY.ttys[dev] = { input: [], output: [], ops };
982
+ FS.registerDevice(dev, TTY.stream_ops);
983
+ },
984
+ stream_ops: {
985
+ open(stream) {
986
+ var tty = TTY.ttys[stream.node.rdev];
987
+ if (!tty) {
988
+ throw new FS.ErrnoError(43);
989
+ }
990
+ stream.tty = tty;
991
+ stream.seekable = false;
992
+ },
993
+ close(stream) {
994
+ stream.tty.ops.fsync(stream.tty);
995
+ },
996
+ fsync(stream) {
997
+ stream.tty.ops.fsync(stream.tty);
998
+ },
999
+ read(stream, buffer, offset, length, pos) {
1000
+ if (!stream.tty || !stream.tty.ops.get_char) {
1001
+ throw new FS.ErrnoError(60);
1002
+ }
1003
+ var bytesRead = 0;
1004
+ for (var i = 0; i < length; i++) {
1005
+ var result;
1006
+ try {
1007
+ result = stream.tty.ops.get_char(stream.tty);
1008
+ } catch (e) {
1009
+ throw new FS.ErrnoError(29);
1010
+ }
1011
+ if (result === void 0 && bytesRead === 0) {
1012
+ throw new FS.ErrnoError(6);
1013
+ }
1014
+ if (result === null || result === void 0) break;
1015
+ bytesRead++;
1016
+ buffer[offset + i] = result;
1017
+ }
1018
+ if (bytesRead) {
1019
+ stream.node.timestamp = Date.now();
1020
+ }
1021
+ return bytesRead;
1022
+ },
1023
+ write(stream, buffer, offset, length, pos) {
1024
+ if (!stream.tty || !stream.tty.ops.put_char) {
1025
+ throw new FS.ErrnoError(60);
1026
+ }
1027
+ try {
1028
+ for (var i = 0; i < length; i++) {
1029
+ stream.tty.ops.put_char(stream.tty, buffer[offset + i]);
1030
+ }
1031
+ } catch (e) {
1032
+ throw new FS.ErrnoError(29);
1033
+ }
1034
+ if (length) {
1035
+ stream.node.timestamp = Date.now();
1036
+ }
1037
+ return i;
1038
+ }
1039
+ },
1040
+ default_tty_ops: {
1041
+ get_char(tty) {
1042
+ return FS_stdin_getChar();
1043
+ },
1044
+ put_char(tty, val) {
1045
+ if (val === null || val === 10) {
1046
+ out(UTF8ArrayToString(tty.output));
1047
+ tty.output = [];
1048
+ } else {
1049
+ if (val != 0) tty.output.push(val);
1050
+ }
1051
+ },
1052
+ fsync(tty) {
1053
+ if (tty.output && tty.output.length > 0) {
1054
+ out(UTF8ArrayToString(tty.output));
1055
+ tty.output = [];
1056
+ }
1057
+ },
1058
+ ioctl_tcgets(tty) {
1059
+ return {
1060
+ c_iflag: 25856,
1061
+ c_oflag: 5,
1062
+ c_cflag: 191,
1063
+ c_lflag: 35387,
1064
+ c_cc: [
1065
+ 3,
1066
+ 28,
1067
+ 127,
1068
+ 21,
1069
+ 4,
1070
+ 0,
1071
+ 1,
1072
+ 0,
1073
+ 17,
1074
+ 19,
1075
+ 26,
1076
+ 0,
1077
+ 18,
1078
+ 15,
1079
+ 23,
1080
+ 22,
1081
+ 0,
1082
+ 0,
1083
+ 0,
1084
+ 0,
1085
+ 0,
1086
+ 0,
1087
+ 0,
1088
+ 0,
1089
+ 0,
1090
+ 0,
1091
+ 0,
1092
+ 0,
1093
+ 0,
1094
+ 0,
1095
+ 0,
1096
+ 0
1097
+ ]
1098
+ };
1099
+ },
1100
+ ioctl_tcsets(tty, optional_actions, data) {
1101
+ return 0;
1102
+ },
1103
+ ioctl_tiocgwinsz(tty) {
1104
+ return [24, 80];
1105
+ }
1106
+ },
1107
+ default_tty1_ops: {
1108
+ put_char(tty, val) {
1109
+ if (val === null || val === 10) {
1110
+ err(UTF8ArrayToString(tty.output));
1111
+ tty.output = [];
1112
+ } else {
1113
+ if (val != 0) tty.output.push(val);
1114
+ }
1115
+ },
1116
+ fsync(tty) {
1117
+ if (tty.output && tty.output.length > 0) {
1118
+ err(UTF8ArrayToString(tty.output));
1119
+ tty.output = [];
1120
+ }
1121
+ }
1122
+ }
1123
+ };
1124
+ var zeroMemory = (address, size) => {
1125
+ HEAPU8.fill(0, address, address + size);
1126
+ };
1127
+ var alignMemory = (size, alignment) => {
1128
+ assert(alignment, "alignment argument is required");
1129
+ return Math.ceil(size / alignment) * alignment;
1130
+ };
1131
+ var mmapAlloc = (size) => {
1132
+ abort("internal error: mmapAlloc called but `emscripten_builtin_memalign` native symbol not exported");
1133
+ };
1134
+ var MEMFS = {
1135
+ ops_table: null,
1136
+ mount(mount) {
1137
+ return MEMFS.createNode(null, "/", 16384 | 511, 0);
1138
+ },
1139
+ createNode(parent, name, mode, dev) {
1140
+ if (FS.isBlkdev(mode) || FS.isFIFO(mode)) {
1141
+ throw new FS.ErrnoError(63);
1142
+ }
1143
+ MEMFS.ops_table || (MEMFS.ops_table = {
1144
+ dir: {
1145
+ node: {
1146
+ getattr: MEMFS.node_ops.getattr,
1147
+ setattr: MEMFS.node_ops.setattr,
1148
+ lookup: MEMFS.node_ops.lookup,
1149
+ mknod: MEMFS.node_ops.mknod,
1150
+ rename: MEMFS.node_ops.rename,
1151
+ unlink: MEMFS.node_ops.unlink,
1152
+ rmdir: MEMFS.node_ops.rmdir,
1153
+ readdir: MEMFS.node_ops.readdir,
1154
+ symlink: MEMFS.node_ops.symlink
1155
+ },
1156
+ stream: {
1157
+ llseek: MEMFS.stream_ops.llseek
1158
+ }
1159
+ },
1160
+ file: {
1161
+ node: {
1162
+ getattr: MEMFS.node_ops.getattr,
1163
+ setattr: MEMFS.node_ops.setattr
1164
+ },
1165
+ stream: {
1166
+ llseek: MEMFS.stream_ops.llseek,
1167
+ read: MEMFS.stream_ops.read,
1168
+ write: MEMFS.stream_ops.write,
1169
+ allocate: MEMFS.stream_ops.allocate,
1170
+ mmap: MEMFS.stream_ops.mmap,
1171
+ msync: MEMFS.stream_ops.msync
1172
+ }
1173
+ },
1174
+ link: {
1175
+ node: {
1176
+ getattr: MEMFS.node_ops.getattr,
1177
+ setattr: MEMFS.node_ops.setattr,
1178
+ readlink: MEMFS.node_ops.readlink
1179
+ },
1180
+ stream: {}
1181
+ },
1182
+ chrdev: {
1183
+ node: {
1184
+ getattr: MEMFS.node_ops.getattr,
1185
+ setattr: MEMFS.node_ops.setattr
1186
+ },
1187
+ stream: FS.chrdev_stream_ops
1188
+ }
1189
+ });
1190
+ var node = FS.createNode(parent, name, mode, dev);
1191
+ if (FS.isDir(node.mode)) {
1192
+ node.node_ops = MEMFS.ops_table.dir.node;
1193
+ node.stream_ops = MEMFS.ops_table.dir.stream;
1194
+ node.contents = {};
1195
+ } else if (FS.isFile(node.mode)) {
1196
+ node.node_ops = MEMFS.ops_table.file.node;
1197
+ node.stream_ops = MEMFS.ops_table.file.stream;
1198
+ node.usedBytes = 0;
1199
+ node.contents = null;
1200
+ } else if (FS.isLink(node.mode)) {
1201
+ node.node_ops = MEMFS.ops_table.link.node;
1202
+ node.stream_ops = MEMFS.ops_table.link.stream;
1203
+ } else if (FS.isChrdev(node.mode)) {
1204
+ node.node_ops = MEMFS.ops_table.chrdev.node;
1205
+ node.stream_ops = MEMFS.ops_table.chrdev.stream;
1206
+ }
1207
+ node.timestamp = Date.now();
1208
+ if (parent) {
1209
+ parent.contents[name] = node;
1210
+ parent.timestamp = node.timestamp;
1211
+ }
1212
+ return node;
1213
+ },
1214
+ getFileDataAsTypedArray(node) {
1215
+ if (!node.contents) return new Uint8Array(0);
1216
+ if (node.contents.subarray) return node.contents.subarray(0, node.usedBytes);
1217
+ return new Uint8Array(node.contents);
1218
+ },
1219
+ expandFileStorage(node, newCapacity) {
1220
+ var prevCapacity = node.contents ? node.contents.length : 0;
1221
+ if (prevCapacity >= newCapacity) return;
1222
+ var CAPACITY_DOUBLING_MAX = 1024 * 1024;
1223
+ newCapacity = Math.max(newCapacity, prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2 : 1.125) >>> 0);
1224
+ if (prevCapacity != 0) newCapacity = Math.max(newCapacity, 256);
1225
+ var oldContents = node.contents;
1226
+ node.contents = new Uint8Array(newCapacity);
1227
+ if (node.usedBytes > 0) node.contents.set(oldContents.subarray(0, node.usedBytes), 0);
1228
+ },
1229
+ resizeFileStorage(node, newSize) {
1230
+ if (node.usedBytes == newSize) return;
1231
+ if (newSize == 0) {
1232
+ node.contents = null;
1233
+ node.usedBytes = 0;
1234
+ } else {
1235
+ var oldContents = node.contents;
1236
+ node.contents = new Uint8Array(newSize);
1237
+ if (oldContents) {
1238
+ node.contents.set(oldContents.subarray(0, Math.min(newSize, node.usedBytes)));
1239
+ }
1240
+ node.usedBytes = newSize;
1241
+ }
1242
+ },
1243
+ node_ops: {
1244
+ getattr(node) {
1245
+ var attr = {};
1246
+ attr.dev = FS.isChrdev(node.mode) ? node.id : 1;
1247
+ attr.ino = node.id;
1248
+ attr.mode = node.mode;
1249
+ attr.nlink = 1;
1250
+ attr.uid = 0;
1251
+ attr.gid = 0;
1252
+ attr.rdev = node.rdev;
1253
+ if (FS.isDir(node.mode)) {
1254
+ attr.size = 4096;
1255
+ } else if (FS.isFile(node.mode)) {
1256
+ attr.size = node.usedBytes;
1257
+ } else if (FS.isLink(node.mode)) {
1258
+ attr.size = node.link.length;
1259
+ } else {
1260
+ attr.size = 0;
1261
+ }
1262
+ attr.atime = new Date(node.timestamp);
1263
+ attr.mtime = new Date(node.timestamp);
1264
+ attr.ctime = new Date(node.timestamp);
1265
+ attr.blksize = 4096;
1266
+ attr.blocks = Math.ceil(attr.size / attr.blksize);
1267
+ return attr;
1268
+ },
1269
+ setattr(node, attr) {
1270
+ if (attr.mode !== void 0) {
1271
+ node.mode = attr.mode;
1272
+ }
1273
+ if (attr.timestamp !== void 0) {
1274
+ node.timestamp = attr.timestamp;
1275
+ }
1276
+ if (attr.size !== void 0) {
1277
+ MEMFS.resizeFileStorage(node, attr.size);
1278
+ }
1279
+ },
1280
+ lookup(parent, name) {
1281
+ throw FS.genericErrors[44];
1282
+ },
1283
+ mknod(parent, name, mode, dev) {
1284
+ return MEMFS.createNode(parent, name, mode, dev);
1285
+ },
1286
+ rename(old_node, new_dir, new_name) {
1287
+ if (FS.isDir(old_node.mode)) {
1288
+ var new_node;
1289
+ try {
1290
+ new_node = FS.lookupNode(new_dir, new_name);
1291
+ } catch (e) {
1292
+ }
1293
+ if (new_node) {
1294
+ for (var i in new_node.contents) {
1295
+ throw new FS.ErrnoError(55);
1296
+ }
1297
+ }
1298
+ }
1299
+ delete old_node.parent.contents[old_node.name];
1300
+ old_node.parent.timestamp = Date.now();
1301
+ old_node.name = new_name;
1302
+ new_dir.contents[new_name] = old_node;
1303
+ new_dir.timestamp = old_node.parent.timestamp;
1304
+ },
1305
+ unlink(parent, name) {
1306
+ delete parent.contents[name];
1307
+ parent.timestamp = Date.now();
1308
+ },
1309
+ rmdir(parent, name) {
1310
+ var node = FS.lookupNode(parent, name);
1311
+ for (var i in node.contents) {
1312
+ throw new FS.ErrnoError(55);
1313
+ }
1314
+ delete parent.contents[name];
1315
+ parent.timestamp = Date.now();
1316
+ },
1317
+ readdir(node) {
1318
+ var entries = [".", ".."];
1319
+ for (var key of Object.keys(node.contents)) {
1320
+ entries.push(key);
1321
+ }
1322
+ return entries;
1323
+ },
1324
+ symlink(parent, newname, oldpath) {
1325
+ var node = MEMFS.createNode(parent, newname, 511 | 40960, 0);
1326
+ node.link = oldpath;
1327
+ return node;
1328
+ },
1329
+ readlink(node) {
1330
+ if (!FS.isLink(node.mode)) {
1331
+ throw new FS.ErrnoError(28);
1332
+ }
1333
+ return node.link;
1334
+ }
1335
+ },
1336
+ stream_ops: {
1337
+ read(stream, buffer, offset, length, position) {
1338
+ var contents = stream.node.contents;
1339
+ if (position >= stream.node.usedBytes) return 0;
1340
+ var size = Math.min(stream.node.usedBytes - position, length);
1341
+ assert(size >= 0);
1342
+ if (size > 8 && contents.subarray) {
1343
+ buffer.set(contents.subarray(position, position + size), offset);
1344
+ } else {
1345
+ for (var i = 0; i < size; i++) buffer[offset + i] = contents[position + i];
1346
+ }
1347
+ return size;
1348
+ },
1349
+ write(stream, buffer, offset, length, position, canOwn) {
1350
+ assert(!(buffer instanceof ArrayBuffer));
1351
+ if (buffer.buffer === HEAP8.buffer) {
1352
+ canOwn = false;
1353
+ }
1354
+ if (!length) return 0;
1355
+ var node = stream.node;
1356
+ node.timestamp = Date.now();
1357
+ if (buffer.subarray && (!node.contents || node.contents.subarray)) {
1358
+ if (canOwn) {
1359
+ assert(position === 0, "canOwn must imply no weird position inside the file");
1360
+ node.contents = buffer.subarray(offset, offset + length);
1361
+ node.usedBytes = length;
1362
+ return length;
1363
+ } else if (node.usedBytes === 0 && position === 0) {
1364
+ node.contents = buffer.slice(offset, offset + length);
1365
+ node.usedBytes = length;
1366
+ return length;
1367
+ } else if (position + length <= node.usedBytes) {
1368
+ node.contents.set(buffer.subarray(offset, offset + length), position);
1369
+ return length;
1370
+ }
1371
+ }
1372
+ MEMFS.expandFileStorage(node, position + length);
1373
+ if (node.contents.subarray && buffer.subarray) {
1374
+ node.contents.set(buffer.subarray(offset, offset + length), position);
1375
+ } else {
1376
+ for (var i = 0; i < length; i++) {
1377
+ node.contents[position + i] = buffer[offset + i];
1378
+ }
1379
+ }
1380
+ node.usedBytes = Math.max(node.usedBytes, position + length);
1381
+ return length;
1382
+ },
1383
+ llseek(stream, offset, whence) {
1384
+ var position = offset;
1385
+ if (whence === 1) {
1386
+ position += stream.position;
1387
+ } else if (whence === 2) {
1388
+ if (FS.isFile(stream.node.mode)) {
1389
+ position += stream.node.usedBytes;
1390
+ }
1391
+ }
1392
+ if (position < 0) {
1393
+ throw new FS.ErrnoError(28);
1394
+ }
1395
+ return position;
1396
+ },
1397
+ allocate(stream, offset, length) {
1398
+ MEMFS.expandFileStorage(stream.node, offset + length);
1399
+ stream.node.usedBytes = Math.max(stream.node.usedBytes, offset + length);
1400
+ },
1401
+ mmap(stream, length, position, prot, flags) {
1402
+ if (!FS.isFile(stream.node.mode)) {
1403
+ throw new FS.ErrnoError(43);
1404
+ }
1405
+ var ptr;
1406
+ var allocated;
1407
+ var contents = stream.node.contents;
1408
+ if (!(flags & 2) && contents && contents.buffer === HEAP8.buffer) {
1409
+ allocated = false;
1410
+ ptr = contents.byteOffset;
1411
+ } else {
1412
+ allocated = true;
1413
+ ptr = mmapAlloc(length);
1414
+ if (!ptr) {
1415
+ throw new FS.ErrnoError(48);
1416
+ }
1417
+ if (contents) {
1418
+ if (position > 0 || position + length < contents.length) {
1419
+ if (contents.subarray) {
1420
+ contents = contents.subarray(position, position + length);
1421
+ } else {
1422
+ contents = Array.prototype.slice.call(contents, position, position + length);
1423
+ }
1424
+ }
1425
+ HEAP8.set(contents, ptr);
1426
+ }
1427
+ }
1428
+ return { ptr, allocated };
1429
+ },
1430
+ msync(stream, buffer, offset, length, mmapFlags) {
1431
+ MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false);
1432
+ return 0;
1433
+ }
1434
+ }
1435
+ };
1436
+ var asyncLoad = (url, onload, onerror, noRunDep) => {
1437
+ var dep = !noRunDep ? getUniqueRunDependency(`al ${url}`) : "";
1438
+ readAsync(url).then(
1439
+ (arrayBuffer) => {
1440
+ assert(arrayBuffer, `Loading data file "${url}" failed (no arrayBuffer).`);
1441
+ onload(new Uint8Array(arrayBuffer));
1442
+ if (dep) removeRunDependency(dep);
1443
+ },
1444
+ (err2) => {
1445
+ if (onerror) {
1446
+ onerror();
1447
+ } else {
1448
+ throw `Loading data file "${url}" failed.`;
1449
+ }
1450
+ }
1451
+ );
1452
+ if (dep) addRunDependency(dep);
1453
+ };
1454
+ var FS_createDataFile = (parent, name, fileData, canRead, canWrite, canOwn) => {
1455
+ FS.createDataFile(parent, name, fileData, canRead, canWrite, canOwn);
1456
+ };
1457
+ var preloadPlugins = Module["preloadPlugins"] || [];
1458
+ var FS_handledByPreloadPlugin = (byteArray, fullname, finish, onerror) => {
1459
+ if (typeof Browser != "undefined") Browser.init();
1460
+ var handled = false;
1461
+ preloadPlugins.forEach((plugin) => {
1462
+ if (handled) return;
1463
+ if (plugin["canHandle"](fullname)) {
1464
+ plugin["handle"](byteArray, fullname, finish, onerror);
1465
+ handled = true;
1466
+ }
1467
+ });
1468
+ return handled;
1469
+ };
1470
+ var FS_createPreloadedFile = (parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn, preFinish) => {
1471
+ var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent;
1472
+ var dep = getUniqueRunDependency(`cp ${fullname}`);
1473
+ function processData(byteArray) {
1474
+ function finish(byteArray2) {
1475
+ preFinish?.();
1476
+ if (!dontCreateFile) {
1477
+ FS_createDataFile(parent, name, byteArray2, canRead, canWrite, canOwn);
1478
+ }
1479
+ onload?.();
1480
+ removeRunDependency(dep);
1481
+ }
1482
+ if (FS_handledByPreloadPlugin(byteArray, fullname, finish, () => {
1483
+ onerror?.();
1484
+ removeRunDependency(dep);
1485
+ })) {
1486
+ return;
1487
+ }
1488
+ finish(byteArray);
1489
+ }
1490
+ addRunDependency(dep);
1491
+ if (typeof url == "string") {
1492
+ asyncLoad(url, processData, onerror);
1493
+ } else {
1494
+ processData(url);
1495
+ }
1496
+ };
1497
+ var FS_modeStringToFlags = (str) => {
1498
+ var flagModes = {
1499
+ "r": 0,
1500
+ "r+": 2,
1501
+ "w": 512 | 64 | 1,
1502
+ "w+": 512 | 64 | 2,
1503
+ "a": 1024 | 64 | 1,
1504
+ "a+": 1024 | 64 | 2
1505
+ };
1506
+ var flags = flagModes[str];
1507
+ if (typeof flags == "undefined") {
1508
+ throw new Error(`Unknown file open mode: ${str}`);
1509
+ }
1510
+ return flags;
1511
+ };
1512
+ var FS_getMode = (canRead, canWrite) => {
1513
+ var mode = 0;
1514
+ if (canRead) mode |= 292 | 73;
1515
+ if (canWrite) mode |= 146;
1516
+ return mode;
1517
+ };
1518
+ var strError = (errno) => {
1519
+ return UTF8ToString(_strerror(errno));
1520
+ };
1521
+ var ERRNO_CODES = {
1522
+ "EPERM": 63,
1523
+ "ENOENT": 44,
1524
+ "ESRCH": 71,
1525
+ "EINTR": 27,
1526
+ "EIO": 29,
1527
+ "ENXIO": 60,
1528
+ "E2BIG": 1,
1529
+ "ENOEXEC": 45,
1530
+ "EBADF": 8,
1531
+ "ECHILD": 12,
1532
+ "EAGAIN": 6,
1533
+ "EWOULDBLOCK": 6,
1534
+ "ENOMEM": 48,
1535
+ "EACCES": 2,
1536
+ "EFAULT": 21,
1537
+ "ENOTBLK": 105,
1538
+ "EBUSY": 10,
1539
+ "EEXIST": 20,
1540
+ "EXDEV": 75,
1541
+ "ENODEV": 43,
1542
+ "ENOTDIR": 54,
1543
+ "EISDIR": 31,
1544
+ "EINVAL": 28,
1545
+ "ENFILE": 41,
1546
+ "EMFILE": 33,
1547
+ "ENOTTY": 59,
1548
+ "ETXTBSY": 74,
1549
+ "EFBIG": 22,
1550
+ "ENOSPC": 51,
1551
+ "ESPIPE": 70,
1552
+ "EROFS": 69,
1553
+ "EMLINK": 34,
1554
+ "EPIPE": 64,
1555
+ "EDOM": 18,
1556
+ "ERANGE": 68,
1557
+ "ENOMSG": 49,
1558
+ "EIDRM": 24,
1559
+ "ECHRNG": 106,
1560
+ "EL2NSYNC": 156,
1561
+ "EL3HLT": 107,
1562
+ "EL3RST": 108,
1563
+ "ELNRNG": 109,
1564
+ "EUNATCH": 110,
1565
+ "ENOCSI": 111,
1566
+ "EL2HLT": 112,
1567
+ "EDEADLK": 16,
1568
+ "ENOLCK": 46,
1569
+ "EBADE": 113,
1570
+ "EBADR": 114,
1571
+ "EXFULL": 115,
1572
+ "ENOANO": 104,
1573
+ "EBADRQC": 103,
1574
+ "EBADSLT": 102,
1575
+ "EDEADLOCK": 16,
1576
+ "EBFONT": 101,
1577
+ "ENOSTR": 100,
1578
+ "ENODATA": 116,
1579
+ "ETIME": 117,
1580
+ "ENOSR": 118,
1581
+ "ENONET": 119,
1582
+ "ENOPKG": 120,
1583
+ "EREMOTE": 121,
1584
+ "ENOLINK": 47,
1585
+ "EADV": 122,
1586
+ "ESRMNT": 123,
1587
+ "ECOMM": 124,
1588
+ "EPROTO": 65,
1589
+ "EMULTIHOP": 36,
1590
+ "EDOTDOT": 125,
1591
+ "EBADMSG": 9,
1592
+ "ENOTUNIQ": 126,
1593
+ "EBADFD": 127,
1594
+ "EREMCHG": 128,
1595
+ "ELIBACC": 129,
1596
+ "ELIBBAD": 130,
1597
+ "ELIBSCN": 131,
1598
+ "ELIBMAX": 132,
1599
+ "ELIBEXEC": 133,
1600
+ "ENOSYS": 52,
1601
+ "ENOTEMPTY": 55,
1602
+ "ENAMETOOLONG": 37,
1603
+ "ELOOP": 32,
1604
+ "EOPNOTSUPP": 138,
1605
+ "EPFNOSUPPORT": 139,
1606
+ "ECONNRESET": 15,
1607
+ "ENOBUFS": 42,
1608
+ "EAFNOSUPPORT": 5,
1609
+ "EPROTOTYPE": 67,
1610
+ "ENOTSOCK": 57,
1611
+ "ENOPROTOOPT": 50,
1612
+ "ESHUTDOWN": 140,
1613
+ "ECONNREFUSED": 14,
1614
+ "EADDRINUSE": 3,
1615
+ "ECONNABORTED": 13,
1616
+ "ENETUNREACH": 40,
1617
+ "ENETDOWN": 38,
1618
+ "ETIMEDOUT": 73,
1619
+ "EHOSTDOWN": 142,
1620
+ "EHOSTUNREACH": 23,
1621
+ "EINPROGRESS": 26,
1622
+ "EALREADY": 7,
1623
+ "EDESTADDRREQ": 17,
1624
+ "EMSGSIZE": 35,
1625
+ "EPROTONOSUPPORT": 66,
1626
+ "ESOCKTNOSUPPORT": 137,
1627
+ "EADDRNOTAVAIL": 4,
1628
+ "ENETRESET": 39,
1629
+ "EISCONN": 30,
1630
+ "ENOTCONN": 53,
1631
+ "ETOOMANYREFS": 141,
1632
+ "EUSERS": 136,
1633
+ "EDQUOT": 19,
1634
+ "ESTALE": 72,
1635
+ "ENOTSUP": 138,
1636
+ "ENOMEDIUM": 148,
1637
+ "EILSEQ": 25,
1638
+ "EOVERFLOW": 61,
1639
+ "ECANCELED": 11,
1640
+ "ENOTRECOVERABLE": 56,
1641
+ "EOWNERDEAD": 62,
1642
+ "ESTRPIPE": 135
1643
+ };
1644
+ var FS = {
1645
+ root: null,
1646
+ mounts: [],
1647
+ devices: {},
1648
+ streams: [],
1649
+ nextInode: 1,
1650
+ nameTable: null,
1651
+ currentPath: "/",
1652
+ initialized: false,
1653
+ ignorePermissions: true,
1654
+ ErrnoError: class extends Error {
1655
+ // We set the `name` property to be able to identify `FS.ErrnoError`
1656
+ // - the `name` is a standard ECMA-262 property of error objects. Kind of good to have it anyway.
1657
+ // - when using PROXYFS, an error can come from an underlying FS
1658
+ // as different FS objects have their own FS.ErrnoError each,
1659
+ // the test `err instanceof FS.ErrnoError` won't detect an error coming from another filesystem, causing bugs.
1660
+ // we'll use the reliable test `err.name == "ErrnoError"` instead
1661
+ constructor(errno) {
1662
+ super(runtimeInitialized ? strError(errno) : "");
1663
+ this.name = "ErrnoError";
1664
+ this.errno = errno;
1665
+ for (var key in ERRNO_CODES) {
1666
+ if (ERRNO_CODES[key] === errno) {
1667
+ this.code = key;
1668
+ break;
1669
+ }
1670
+ }
1671
+ }
1672
+ },
1673
+ genericErrors: {},
1674
+ filesystems: null,
1675
+ syncFSRequests: 0,
1676
+ readFiles: {},
1677
+ FSStream: class {
1678
+ constructor() {
1679
+ this.shared = {};
1680
+ }
1681
+ get object() {
1682
+ return this.node;
1683
+ }
1684
+ set object(val) {
1685
+ this.node = val;
1686
+ }
1687
+ get isRead() {
1688
+ return (this.flags & 2097155) !== 1;
1689
+ }
1690
+ get isWrite() {
1691
+ return (this.flags & 2097155) !== 0;
1692
+ }
1693
+ get isAppend() {
1694
+ return this.flags & 1024;
1695
+ }
1696
+ get flags() {
1697
+ return this.shared.flags;
1698
+ }
1699
+ set flags(val) {
1700
+ this.shared.flags = val;
1701
+ }
1702
+ get position() {
1703
+ return this.shared.position;
1704
+ }
1705
+ set position(val) {
1706
+ this.shared.position = val;
1707
+ }
1708
+ },
1709
+ FSNode: class {
1710
+ constructor(parent, name, mode, rdev) {
1711
+ if (!parent) {
1712
+ parent = this;
1713
+ }
1714
+ this.parent = parent;
1715
+ this.mount = parent.mount;
1716
+ this.mounted = null;
1717
+ this.id = FS.nextInode++;
1718
+ this.name = name;
1719
+ this.mode = mode;
1720
+ this.node_ops = {};
1721
+ this.stream_ops = {};
1722
+ this.rdev = rdev;
1723
+ this.readMode = 292 | 73;
1724
+ this.writeMode = 146;
1725
+ }
1726
+ get read() {
1727
+ return (this.mode & this.readMode) === this.readMode;
1728
+ }
1729
+ set read(val) {
1730
+ val ? this.mode |= this.readMode : this.mode &= ~this.readMode;
1731
+ }
1732
+ get write() {
1733
+ return (this.mode & this.writeMode) === this.writeMode;
1734
+ }
1735
+ set write(val) {
1736
+ val ? this.mode |= this.writeMode : this.mode &= ~this.writeMode;
1737
+ }
1738
+ get isFolder() {
1739
+ return FS.isDir(this.mode);
1740
+ }
1741
+ get isDevice() {
1742
+ return FS.isChrdev(this.mode);
1743
+ }
1744
+ },
1745
+ lookupPath(path, opts = {}) {
1746
+ path = PATH_FS.resolve(path);
1747
+ if (!path) return { path: "", node: null };
1748
+ var defaults = {
1749
+ follow_mount: true,
1750
+ recurse_count: 0
1751
+ };
1752
+ opts = Object.assign(defaults, opts);
1753
+ if (opts.recurse_count > 8) {
1754
+ throw new FS.ErrnoError(32);
1755
+ }
1756
+ var parts = path.split("/").filter((p) => !!p);
1757
+ var current = FS.root;
1758
+ var current_path = "/";
1759
+ for (var i = 0; i < parts.length; i++) {
1760
+ var islast = i === parts.length - 1;
1761
+ if (islast && opts.parent) {
1762
+ break;
1763
+ }
1764
+ current = FS.lookupNode(current, parts[i]);
1765
+ current_path = PATH.join2(current_path, parts[i]);
1766
+ if (FS.isMountpoint(current)) {
1767
+ if (!islast || islast && opts.follow_mount) {
1768
+ current = current.mounted.root;
1769
+ }
1770
+ }
1771
+ if (!islast || opts.follow) {
1772
+ var count = 0;
1773
+ while (FS.isLink(current.mode)) {
1774
+ var link = FS.readlink(current_path);
1775
+ current_path = PATH_FS.resolve(PATH.dirname(current_path), link);
1776
+ var lookup = FS.lookupPath(current_path, { recurse_count: opts.recurse_count + 1 });
1777
+ current = lookup.node;
1778
+ if (count++ > 40) {
1779
+ throw new FS.ErrnoError(32);
1780
+ }
1781
+ }
1782
+ }
1783
+ }
1784
+ return { path: current_path, node: current };
1785
+ },
1786
+ getPath(node) {
1787
+ var path;
1788
+ while (true) {
1789
+ if (FS.isRoot(node)) {
1790
+ var mount = node.mount.mountpoint;
1791
+ if (!path) return mount;
1792
+ return mount[mount.length - 1] !== "/" ? `${mount}/${path}` : mount + path;
1793
+ }
1794
+ path = path ? `${node.name}/${path}` : node.name;
1795
+ node = node.parent;
1796
+ }
1797
+ },
1798
+ hashName(parentid, name) {
1799
+ var hash = 0;
1800
+ for (var i = 0; i < name.length; i++) {
1801
+ hash = (hash << 5) - hash + name.charCodeAt(i) | 0;
1802
+ }
1803
+ return (parentid + hash >>> 0) % FS.nameTable.length;
1804
+ },
1805
+ hashAddNode(node) {
1806
+ var hash = FS.hashName(node.parent.id, node.name);
1807
+ node.name_next = FS.nameTable[hash];
1808
+ FS.nameTable[hash] = node;
1809
+ },
1810
+ hashRemoveNode(node) {
1811
+ var hash = FS.hashName(node.parent.id, node.name);
1812
+ if (FS.nameTable[hash] === node) {
1813
+ FS.nameTable[hash] = node.name_next;
1814
+ } else {
1815
+ var current = FS.nameTable[hash];
1816
+ while (current) {
1817
+ if (current.name_next === node) {
1818
+ current.name_next = node.name_next;
1819
+ break;
1820
+ }
1821
+ current = current.name_next;
1822
+ }
1823
+ }
1824
+ },
1825
+ lookupNode(parent, name) {
1826
+ var errCode = FS.mayLookup(parent);
1827
+ if (errCode) {
1828
+ throw new FS.ErrnoError(errCode);
1829
+ }
1830
+ var hash = FS.hashName(parent.id, name);
1831
+ for (var node = FS.nameTable[hash]; node; node = node.name_next) {
1832
+ var nodeName = node.name;
1833
+ if (node.parent.id === parent.id && nodeName === name) {
1834
+ return node;
1835
+ }
1836
+ }
1837
+ return FS.lookup(parent, name);
1838
+ },
1839
+ createNode(parent, name, mode, rdev) {
1840
+ assert(typeof parent == "object");
1841
+ var node = new FS.FSNode(parent, name, mode, rdev);
1842
+ FS.hashAddNode(node);
1843
+ return node;
1844
+ },
1845
+ destroyNode(node) {
1846
+ FS.hashRemoveNode(node);
1847
+ },
1848
+ isRoot(node) {
1849
+ return node === node.parent;
1850
+ },
1851
+ isMountpoint(node) {
1852
+ return !!node.mounted;
1853
+ },
1854
+ isFile(mode) {
1855
+ return (mode & 61440) === 32768;
1856
+ },
1857
+ isDir(mode) {
1858
+ return (mode & 61440) === 16384;
1859
+ },
1860
+ isLink(mode) {
1861
+ return (mode & 61440) === 40960;
1862
+ },
1863
+ isChrdev(mode) {
1864
+ return (mode & 61440) === 8192;
1865
+ },
1866
+ isBlkdev(mode) {
1867
+ return (mode & 61440) === 24576;
1868
+ },
1869
+ isFIFO(mode) {
1870
+ return (mode & 61440) === 4096;
1871
+ },
1872
+ isSocket(mode) {
1873
+ return (mode & 49152) === 49152;
1874
+ },
1875
+ flagsToPermissionString(flag) {
1876
+ var perms = ["r", "w", "rw"][flag & 3];
1877
+ if (flag & 512) {
1878
+ perms += "w";
1879
+ }
1880
+ return perms;
1881
+ },
1882
+ nodePermissions(node, perms) {
1883
+ if (FS.ignorePermissions) {
1884
+ return 0;
1885
+ }
1886
+ if (perms.includes("r") && !(node.mode & 292)) {
1887
+ return 2;
1888
+ } else if (perms.includes("w") && !(node.mode & 146)) {
1889
+ return 2;
1890
+ } else if (perms.includes("x") && !(node.mode & 73)) {
1891
+ return 2;
1892
+ }
1893
+ return 0;
1894
+ },
1895
+ mayLookup(dir) {
1896
+ if (!FS.isDir(dir.mode)) return 54;
1897
+ var errCode = FS.nodePermissions(dir, "x");
1898
+ if (errCode) return errCode;
1899
+ if (!dir.node_ops.lookup) return 2;
1900
+ return 0;
1901
+ },
1902
+ mayCreate(dir, name) {
1903
+ try {
1904
+ var node = FS.lookupNode(dir, name);
1905
+ return 20;
1906
+ } catch (e) {
1907
+ }
1908
+ return FS.nodePermissions(dir, "wx");
1909
+ },
1910
+ mayDelete(dir, name, isdir) {
1911
+ var node;
1912
+ try {
1913
+ node = FS.lookupNode(dir, name);
1914
+ } catch (e) {
1915
+ return e.errno;
1916
+ }
1917
+ var errCode = FS.nodePermissions(dir, "wx");
1918
+ if (errCode) {
1919
+ return errCode;
1920
+ }
1921
+ if (isdir) {
1922
+ if (!FS.isDir(node.mode)) {
1923
+ return 54;
1924
+ }
1925
+ if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) {
1926
+ return 10;
1927
+ }
1928
+ } else {
1929
+ if (FS.isDir(node.mode)) {
1930
+ return 31;
1931
+ }
1932
+ }
1933
+ return 0;
1934
+ },
1935
+ mayOpen(node, flags) {
1936
+ if (!node) {
1937
+ return 44;
1938
+ }
1939
+ if (FS.isLink(node.mode)) {
1940
+ return 32;
1941
+ } else if (FS.isDir(node.mode)) {
1942
+ if (FS.flagsToPermissionString(flags) !== "r" || // opening for write
1943
+ flags & 512) {
1944
+ return 31;
1945
+ }
1946
+ }
1947
+ return FS.nodePermissions(node, FS.flagsToPermissionString(flags));
1948
+ },
1949
+ MAX_OPEN_FDS: 4096,
1950
+ nextfd() {
1951
+ for (var fd = 0; fd <= FS.MAX_OPEN_FDS; fd++) {
1952
+ if (!FS.streams[fd]) {
1953
+ return fd;
1954
+ }
1955
+ }
1956
+ throw new FS.ErrnoError(33);
1957
+ },
1958
+ getStreamChecked(fd) {
1959
+ var stream = FS.getStream(fd);
1960
+ if (!stream) {
1961
+ throw new FS.ErrnoError(8);
1962
+ }
1963
+ return stream;
1964
+ },
1965
+ getStream: (fd) => FS.streams[fd],
1966
+ createStream(stream, fd = -1) {
1967
+ assert(fd >= -1);
1968
+ stream = Object.assign(new FS.FSStream(), stream);
1969
+ if (fd == -1) {
1970
+ fd = FS.nextfd();
1971
+ }
1972
+ stream.fd = fd;
1973
+ FS.streams[fd] = stream;
1974
+ return stream;
1975
+ },
1976
+ closeStream(fd) {
1977
+ FS.streams[fd] = null;
1978
+ },
1979
+ dupStream(origStream, fd = -1) {
1980
+ var stream = FS.createStream(origStream, fd);
1981
+ stream.stream_ops?.dup?.(stream);
1982
+ return stream;
1983
+ },
1984
+ chrdev_stream_ops: {
1985
+ open(stream) {
1986
+ var device = FS.getDevice(stream.node.rdev);
1987
+ stream.stream_ops = device.stream_ops;
1988
+ stream.stream_ops.open?.(stream);
1989
+ },
1990
+ llseek() {
1991
+ throw new FS.ErrnoError(70);
1992
+ }
1993
+ },
1994
+ major: (dev) => dev >> 8,
1995
+ minor: (dev) => dev & 255,
1996
+ makedev: (ma, mi) => ma << 8 | mi,
1997
+ registerDevice(dev, ops) {
1998
+ FS.devices[dev] = { stream_ops: ops };
1999
+ },
2000
+ getDevice: (dev) => FS.devices[dev],
2001
+ getMounts(mount) {
2002
+ var mounts = [];
2003
+ var check = [mount];
2004
+ while (check.length) {
2005
+ var m = check.pop();
2006
+ mounts.push(m);
2007
+ check.push(...m.mounts);
2008
+ }
2009
+ return mounts;
2010
+ },
2011
+ syncfs(populate, callback) {
2012
+ if (typeof populate == "function") {
2013
+ callback = populate;
2014
+ populate = false;
2015
+ }
2016
+ FS.syncFSRequests++;
2017
+ if (FS.syncFSRequests > 1) {
2018
+ err(`warning: ${FS.syncFSRequests} FS.syncfs operations in flight at once, probably just doing extra work`);
2019
+ }
2020
+ var mounts = FS.getMounts(FS.root.mount);
2021
+ var completed = 0;
2022
+ function doCallback(errCode) {
2023
+ assert(FS.syncFSRequests > 0);
2024
+ FS.syncFSRequests--;
2025
+ return callback(errCode);
2026
+ }
2027
+ function done(errCode) {
2028
+ if (errCode) {
2029
+ if (!done.errored) {
2030
+ done.errored = true;
2031
+ return doCallback(errCode);
2032
+ }
2033
+ return;
2034
+ }
2035
+ if (++completed >= mounts.length) {
2036
+ doCallback(null);
2037
+ }
2038
+ }
2039
+ ;
2040
+ mounts.forEach((mount) => {
2041
+ if (!mount.type.syncfs) {
2042
+ return done(null);
2043
+ }
2044
+ mount.type.syncfs(mount, populate, done);
2045
+ });
2046
+ },
2047
+ mount(type, opts, mountpoint) {
2048
+ if (typeof type == "string") {
2049
+ throw type;
2050
+ }
2051
+ var root = mountpoint === "/";
2052
+ var pseudo = !mountpoint;
2053
+ var node;
2054
+ if (root && FS.root) {
2055
+ throw new FS.ErrnoError(10);
2056
+ } else if (!root && !pseudo) {
2057
+ var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
2058
+ mountpoint = lookup.path;
2059
+ node = lookup.node;
2060
+ if (FS.isMountpoint(node)) {
2061
+ throw new FS.ErrnoError(10);
2062
+ }
2063
+ if (!FS.isDir(node.mode)) {
2064
+ throw new FS.ErrnoError(54);
2065
+ }
2066
+ }
2067
+ var mount = {
2068
+ type,
2069
+ opts,
2070
+ mountpoint,
2071
+ mounts: []
2072
+ };
2073
+ var mountRoot = type.mount(mount);
2074
+ mountRoot.mount = mount;
2075
+ mount.root = mountRoot;
2076
+ if (root) {
2077
+ FS.root = mountRoot;
2078
+ } else if (node) {
2079
+ node.mounted = mount;
2080
+ if (node.mount) {
2081
+ node.mount.mounts.push(mount);
2082
+ }
2083
+ }
2084
+ return mountRoot;
2085
+ },
2086
+ unmount(mountpoint) {
2087
+ var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
2088
+ if (!FS.isMountpoint(lookup.node)) {
2089
+ throw new FS.ErrnoError(28);
2090
+ }
2091
+ var node = lookup.node;
2092
+ var mount = node.mounted;
2093
+ var mounts = FS.getMounts(mount);
2094
+ Object.keys(FS.nameTable).forEach((hash) => {
2095
+ var current = FS.nameTable[hash];
2096
+ while (current) {
2097
+ var next = current.name_next;
2098
+ if (mounts.includes(current.mount)) {
2099
+ FS.destroyNode(current);
2100
+ }
2101
+ current = next;
2102
+ }
2103
+ });
2104
+ node.mounted = null;
2105
+ var idx = node.mount.mounts.indexOf(mount);
2106
+ assert(idx !== -1);
2107
+ node.mount.mounts.splice(idx, 1);
2108
+ },
2109
+ lookup(parent, name) {
2110
+ return parent.node_ops.lookup(parent, name);
2111
+ },
2112
+ mknod(path, mode, dev) {
2113
+ var lookup = FS.lookupPath(path, { parent: true });
2114
+ var parent = lookup.node;
2115
+ var name = PATH.basename(path);
2116
+ if (!name || name === "." || name === "..") {
2117
+ throw new FS.ErrnoError(28);
2118
+ }
2119
+ var errCode = FS.mayCreate(parent, name);
2120
+ if (errCode) {
2121
+ throw new FS.ErrnoError(errCode);
2122
+ }
2123
+ if (!parent.node_ops.mknod) {
2124
+ throw new FS.ErrnoError(63);
2125
+ }
2126
+ return parent.node_ops.mknod(parent, name, mode, dev);
2127
+ },
2128
+ create(path, mode) {
2129
+ mode = mode !== void 0 ? mode : 438;
2130
+ mode &= 4095;
2131
+ mode |= 32768;
2132
+ return FS.mknod(path, mode, 0);
2133
+ },
2134
+ mkdir(path, mode) {
2135
+ mode = mode !== void 0 ? mode : 511;
2136
+ mode &= 511 | 512;
2137
+ mode |= 16384;
2138
+ return FS.mknod(path, mode, 0);
2139
+ },
2140
+ mkdirTree(path, mode) {
2141
+ var dirs = path.split("/");
2142
+ var d = "";
2143
+ for (var i = 0; i < dirs.length; ++i) {
2144
+ if (!dirs[i]) continue;
2145
+ d += "/" + dirs[i];
2146
+ try {
2147
+ FS.mkdir(d, mode);
2148
+ } catch (e) {
2149
+ if (e.errno != 20) throw e;
2150
+ }
2151
+ }
2152
+ },
2153
+ mkdev(path, mode, dev) {
2154
+ if (typeof dev == "undefined") {
2155
+ dev = mode;
2156
+ mode = 438;
2157
+ }
2158
+ mode |= 8192;
2159
+ return FS.mknod(path, mode, dev);
2160
+ },
2161
+ symlink(oldpath, newpath) {
2162
+ if (!PATH_FS.resolve(oldpath)) {
2163
+ throw new FS.ErrnoError(44);
2164
+ }
2165
+ var lookup = FS.lookupPath(newpath, { parent: true });
2166
+ var parent = lookup.node;
2167
+ if (!parent) {
2168
+ throw new FS.ErrnoError(44);
2169
+ }
2170
+ var newname = PATH.basename(newpath);
2171
+ var errCode = FS.mayCreate(parent, newname);
2172
+ if (errCode) {
2173
+ throw new FS.ErrnoError(errCode);
2174
+ }
2175
+ if (!parent.node_ops.symlink) {
2176
+ throw new FS.ErrnoError(63);
2177
+ }
2178
+ return parent.node_ops.symlink(parent, newname, oldpath);
2179
+ },
2180
+ rename(old_path, new_path) {
2181
+ var old_dirname = PATH.dirname(old_path);
2182
+ var new_dirname = PATH.dirname(new_path);
2183
+ var old_name = PATH.basename(old_path);
2184
+ var new_name = PATH.basename(new_path);
2185
+ var lookup, old_dir, new_dir;
2186
+ lookup = FS.lookupPath(old_path, { parent: true });
2187
+ old_dir = lookup.node;
2188
+ lookup = FS.lookupPath(new_path, { parent: true });
2189
+ new_dir = lookup.node;
2190
+ if (!old_dir || !new_dir) throw new FS.ErrnoError(44);
2191
+ if (old_dir.mount !== new_dir.mount) {
2192
+ throw new FS.ErrnoError(75);
2193
+ }
2194
+ var old_node = FS.lookupNode(old_dir, old_name);
2195
+ var relative = PATH_FS.relative(old_path, new_dirname);
2196
+ if (relative.charAt(0) !== ".") {
2197
+ throw new FS.ErrnoError(28);
2198
+ }
2199
+ relative = PATH_FS.relative(new_path, old_dirname);
2200
+ if (relative.charAt(0) !== ".") {
2201
+ throw new FS.ErrnoError(55);
2202
+ }
2203
+ var new_node;
2204
+ try {
2205
+ new_node = FS.lookupNode(new_dir, new_name);
2206
+ } catch (e) {
2207
+ }
2208
+ if (old_node === new_node) {
2209
+ return;
2210
+ }
2211
+ var isdir = FS.isDir(old_node.mode);
2212
+ var errCode = FS.mayDelete(old_dir, old_name, isdir);
2213
+ if (errCode) {
2214
+ throw new FS.ErrnoError(errCode);
2215
+ }
2216
+ errCode = new_node ? FS.mayDelete(new_dir, new_name, isdir) : FS.mayCreate(new_dir, new_name);
2217
+ if (errCode) {
2218
+ throw new FS.ErrnoError(errCode);
2219
+ }
2220
+ if (!old_dir.node_ops.rename) {
2221
+ throw new FS.ErrnoError(63);
2222
+ }
2223
+ if (FS.isMountpoint(old_node) || new_node && FS.isMountpoint(new_node)) {
2224
+ throw new FS.ErrnoError(10);
2225
+ }
2226
+ if (new_dir !== old_dir) {
2227
+ errCode = FS.nodePermissions(old_dir, "w");
2228
+ if (errCode) {
2229
+ throw new FS.ErrnoError(errCode);
2230
+ }
2231
+ }
2232
+ FS.hashRemoveNode(old_node);
2233
+ try {
2234
+ old_dir.node_ops.rename(old_node, new_dir, new_name);
2235
+ old_node.parent = new_dir;
2236
+ } catch (e) {
2237
+ throw e;
2238
+ } finally {
2239
+ FS.hashAddNode(old_node);
2240
+ }
2241
+ },
2242
+ rmdir(path) {
2243
+ var lookup = FS.lookupPath(path, { parent: true });
2244
+ var parent = lookup.node;
2245
+ var name = PATH.basename(path);
2246
+ var node = FS.lookupNode(parent, name);
2247
+ var errCode = FS.mayDelete(parent, name, true);
2248
+ if (errCode) {
2249
+ throw new FS.ErrnoError(errCode);
2250
+ }
2251
+ if (!parent.node_ops.rmdir) {
2252
+ throw new FS.ErrnoError(63);
2253
+ }
2254
+ if (FS.isMountpoint(node)) {
2255
+ throw new FS.ErrnoError(10);
2256
+ }
2257
+ parent.node_ops.rmdir(parent, name);
2258
+ FS.destroyNode(node);
2259
+ },
2260
+ readdir(path) {
2261
+ var lookup = FS.lookupPath(path, { follow: true });
2262
+ var node = lookup.node;
2263
+ if (!node.node_ops.readdir) {
2264
+ throw new FS.ErrnoError(54);
2265
+ }
2266
+ return node.node_ops.readdir(node);
2267
+ },
2268
+ unlink(path) {
2269
+ var lookup = FS.lookupPath(path, { parent: true });
2270
+ var parent = lookup.node;
2271
+ if (!parent) {
2272
+ throw new FS.ErrnoError(44);
2273
+ }
2274
+ var name = PATH.basename(path);
2275
+ var node = FS.lookupNode(parent, name);
2276
+ var errCode = FS.mayDelete(parent, name, false);
2277
+ if (errCode) {
2278
+ throw new FS.ErrnoError(errCode);
2279
+ }
2280
+ if (!parent.node_ops.unlink) {
2281
+ throw new FS.ErrnoError(63);
2282
+ }
2283
+ if (FS.isMountpoint(node)) {
2284
+ throw new FS.ErrnoError(10);
2285
+ }
2286
+ parent.node_ops.unlink(parent, name);
2287
+ FS.destroyNode(node);
2288
+ },
2289
+ readlink(path) {
2290
+ var lookup = FS.lookupPath(path);
2291
+ var link = lookup.node;
2292
+ if (!link) {
2293
+ throw new FS.ErrnoError(44);
2294
+ }
2295
+ if (!link.node_ops.readlink) {
2296
+ throw new FS.ErrnoError(28);
2297
+ }
2298
+ return PATH_FS.resolve(FS.getPath(link.parent), link.node_ops.readlink(link));
2299
+ },
2300
+ stat(path, dontFollow) {
2301
+ var lookup = FS.lookupPath(path, { follow: !dontFollow });
2302
+ var node = lookup.node;
2303
+ if (!node) {
2304
+ throw new FS.ErrnoError(44);
2305
+ }
2306
+ if (!node.node_ops.getattr) {
2307
+ throw new FS.ErrnoError(63);
2308
+ }
2309
+ return node.node_ops.getattr(node);
2310
+ },
2311
+ lstat(path) {
2312
+ return FS.stat(path, true);
2313
+ },
2314
+ chmod(path, mode, dontFollow) {
2315
+ var node;
2316
+ if (typeof path == "string") {
2317
+ var lookup = FS.lookupPath(path, { follow: !dontFollow });
2318
+ node = lookup.node;
2319
+ } else {
2320
+ node = path;
2321
+ }
2322
+ if (!node.node_ops.setattr) {
2323
+ throw new FS.ErrnoError(63);
2324
+ }
2325
+ node.node_ops.setattr(node, {
2326
+ mode: mode & 4095 | node.mode & ~4095,
2327
+ timestamp: Date.now()
2328
+ });
2329
+ },
2330
+ lchmod(path, mode) {
2331
+ FS.chmod(path, mode, true);
2332
+ },
2333
+ fchmod(fd, mode) {
2334
+ var stream = FS.getStreamChecked(fd);
2335
+ FS.chmod(stream.node, mode);
2336
+ },
2337
+ chown(path, uid, gid, dontFollow) {
2338
+ var node;
2339
+ if (typeof path == "string") {
2340
+ var lookup = FS.lookupPath(path, { follow: !dontFollow });
2341
+ node = lookup.node;
2342
+ } else {
2343
+ node = path;
2344
+ }
2345
+ if (!node.node_ops.setattr) {
2346
+ throw new FS.ErrnoError(63);
2347
+ }
2348
+ node.node_ops.setattr(node, {
2349
+ timestamp: Date.now()
2350
+ // we ignore the uid / gid for now
2351
+ });
2352
+ },
2353
+ lchown(path, uid, gid) {
2354
+ FS.chown(path, uid, gid, true);
2355
+ },
2356
+ fchown(fd, uid, gid) {
2357
+ var stream = FS.getStreamChecked(fd);
2358
+ FS.chown(stream.node, uid, gid);
2359
+ },
2360
+ truncate(path, len) {
2361
+ if (len < 0) {
2362
+ throw new FS.ErrnoError(28);
2363
+ }
2364
+ var node;
2365
+ if (typeof path == "string") {
2366
+ var lookup = FS.lookupPath(path, { follow: true });
2367
+ node = lookup.node;
2368
+ } else {
2369
+ node = path;
2370
+ }
2371
+ if (!node.node_ops.setattr) {
2372
+ throw new FS.ErrnoError(63);
2373
+ }
2374
+ if (FS.isDir(node.mode)) {
2375
+ throw new FS.ErrnoError(31);
2376
+ }
2377
+ if (!FS.isFile(node.mode)) {
2378
+ throw new FS.ErrnoError(28);
2379
+ }
2380
+ var errCode = FS.nodePermissions(node, "w");
2381
+ if (errCode) {
2382
+ throw new FS.ErrnoError(errCode);
2383
+ }
2384
+ node.node_ops.setattr(node, {
2385
+ size: len,
2386
+ timestamp: Date.now()
2387
+ });
2388
+ },
2389
+ ftruncate(fd, len) {
2390
+ var stream = FS.getStreamChecked(fd);
2391
+ if ((stream.flags & 2097155) === 0) {
2392
+ throw new FS.ErrnoError(28);
2393
+ }
2394
+ FS.truncate(stream.node, len);
2395
+ },
2396
+ utime(path, atime, mtime) {
2397
+ var lookup = FS.lookupPath(path, { follow: true });
2398
+ var node = lookup.node;
2399
+ node.node_ops.setattr(node, {
2400
+ timestamp: Math.max(atime, mtime)
2401
+ });
2402
+ },
2403
+ open(path, flags, mode) {
2404
+ if (path === "") {
2405
+ throw new FS.ErrnoError(44);
2406
+ }
2407
+ flags = typeof flags == "string" ? FS_modeStringToFlags(flags) : flags;
2408
+ if (flags & 64) {
2409
+ mode = typeof mode == "undefined" ? 438 : mode;
2410
+ mode = mode & 4095 | 32768;
2411
+ } else {
2412
+ mode = 0;
2413
+ }
2414
+ var node;
2415
+ if (typeof path == "object") {
2416
+ node = path;
2417
+ } else {
2418
+ path = PATH.normalize(path);
2419
+ try {
2420
+ var lookup = FS.lookupPath(path, {
2421
+ follow: !(flags & 131072)
2422
+ });
2423
+ node = lookup.node;
2424
+ } catch (e) {
2425
+ }
2426
+ }
2427
+ var created = false;
2428
+ if (flags & 64) {
2429
+ if (node) {
2430
+ if (flags & 128) {
2431
+ throw new FS.ErrnoError(20);
2432
+ }
2433
+ } else {
2434
+ node = FS.mknod(path, mode, 0);
2435
+ created = true;
2436
+ }
2437
+ }
2438
+ if (!node) {
2439
+ throw new FS.ErrnoError(44);
2440
+ }
2441
+ if (FS.isChrdev(node.mode)) {
2442
+ flags &= ~512;
2443
+ }
2444
+ if (flags & 65536 && !FS.isDir(node.mode)) {
2445
+ throw new FS.ErrnoError(54);
2446
+ }
2447
+ if (!created) {
2448
+ var errCode = FS.mayOpen(node, flags);
2449
+ if (errCode) {
2450
+ throw new FS.ErrnoError(errCode);
2451
+ }
2452
+ }
2453
+ if (flags & 512 && !created) {
2454
+ FS.truncate(node, 0);
2455
+ }
2456
+ flags &= ~(128 | 512 | 131072);
2457
+ var stream = FS.createStream({
2458
+ node,
2459
+ path: FS.getPath(node),
2460
+ // we want the absolute path to the node
2461
+ flags,
2462
+ seekable: true,
2463
+ position: 0,
2464
+ stream_ops: node.stream_ops,
2465
+ // used by the file family libc calls (fopen, fwrite, ferror, etc.)
2466
+ ungotten: [],
2467
+ error: false
2468
+ });
2469
+ if (stream.stream_ops.open) {
2470
+ stream.stream_ops.open(stream);
2471
+ }
2472
+ if (Module["logReadFiles"] && !(flags & 1)) {
2473
+ if (!(path in FS.readFiles)) {
2474
+ FS.readFiles[path] = 1;
2475
+ }
2476
+ }
2477
+ return stream;
2478
+ },
2479
+ close(stream) {
2480
+ if (FS.isClosed(stream)) {
2481
+ throw new FS.ErrnoError(8);
2482
+ }
2483
+ if (stream.getdents) stream.getdents = null;
2484
+ try {
2485
+ if (stream.stream_ops.close) {
2486
+ stream.stream_ops.close(stream);
2487
+ }
2488
+ } catch (e) {
2489
+ throw e;
2490
+ } finally {
2491
+ FS.closeStream(stream.fd);
2492
+ }
2493
+ stream.fd = null;
2494
+ },
2495
+ isClosed(stream) {
2496
+ return stream.fd === null;
2497
+ },
2498
+ llseek(stream, offset, whence) {
2499
+ if (FS.isClosed(stream)) {
2500
+ throw new FS.ErrnoError(8);
2501
+ }
2502
+ if (!stream.seekable || !stream.stream_ops.llseek) {
2503
+ throw new FS.ErrnoError(70);
2504
+ }
2505
+ if (whence != 0 && whence != 1 && whence != 2) {
2506
+ throw new FS.ErrnoError(28);
2507
+ }
2508
+ stream.position = stream.stream_ops.llseek(stream, offset, whence);
2509
+ stream.ungotten = [];
2510
+ return stream.position;
2511
+ },
2512
+ read(stream, buffer, offset, length, position) {
2513
+ assert(offset >= 0);
2514
+ if (length < 0 || position < 0) {
2515
+ throw new FS.ErrnoError(28);
2516
+ }
2517
+ if (FS.isClosed(stream)) {
2518
+ throw new FS.ErrnoError(8);
2519
+ }
2520
+ if ((stream.flags & 2097155) === 1) {
2521
+ throw new FS.ErrnoError(8);
2522
+ }
2523
+ if (FS.isDir(stream.node.mode)) {
2524
+ throw new FS.ErrnoError(31);
2525
+ }
2526
+ if (!stream.stream_ops.read) {
2527
+ throw new FS.ErrnoError(28);
2528
+ }
2529
+ var seeking = typeof position != "undefined";
2530
+ if (!seeking) {
2531
+ position = stream.position;
2532
+ } else if (!stream.seekable) {
2533
+ throw new FS.ErrnoError(70);
2534
+ }
2535
+ var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position);
2536
+ if (!seeking) stream.position += bytesRead;
2537
+ return bytesRead;
2538
+ },
2539
+ write(stream, buffer, offset, length, position, canOwn) {
2540
+ assert(offset >= 0);
2541
+ if (length < 0 || position < 0) {
2542
+ throw new FS.ErrnoError(28);
2543
+ }
2544
+ if (FS.isClosed(stream)) {
2545
+ throw new FS.ErrnoError(8);
2546
+ }
2547
+ if ((stream.flags & 2097155) === 0) {
2548
+ throw new FS.ErrnoError(8);
2549
+ }
2550
+ if (FS.isDir(stream.node.mode)) {
2551
+ throw new FS.ErrnoError(31);
2552
+ }
2553
+ if (!stream.stream_ops.write) {
2554
+ throw new FS.ErrnoError(28);
2555
+ }
2556
+ if (stream.seekable && stream.flags & 1024) {
2557
+ FS.llseek(stream, 0, 2);
2558
+ }
2559
+ var seeking = typeof position != "undefined";
2560
+ if (!seeking) {
2561
+ position = stream.position;
2562
+ } else if (!stream.seekable) {
2563
+ throw new FS.ErrnoError(70);
2564
+ }
2565
+ var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn);
2566
+ if (!seeking) stream.position += bytesWritten;
2567
+ return bytesWritten;
2568
+ },
2569
+ allocate(stream, offset, length) {
2570
+ if (FS.isClosed(stream)) {
2571
+ throw new FS.ErrnoError(8);
2572
+ }
2573
+ if (offset < 0 || length <= 0) {
2574
+ throw new FS.ErrnoError(28);
2575
+ }
2576
+ if ((stream.flags & 2097155) === 0) {
2577
+ throw new FS.ErrnoError(8);
2578
+ }
2579
+ if (!FS.isFile(stream.node.mode) && !FS.isDir(stream.node.mode)) {
2580
+ throw new FS.ErrnoError(43);
2581
+ }
2582
+ if (!stream.stream_ops.allocate) {
2583
+ throw new FS.ErrnoError(138);
2584
+ }
2585
+ stream.stream_ops.allocate(stream, offset, length);
2586
+ },
2587
+ mmap(stream, length, position, prot, flags) {
2588
+ if ((prot & 2) !== 0 && (flags & 2) === 0 && (stream.flags & 2097155) !== 2) {
2589
+ throw new FS.ErrnoError(2);
2590
+ }
2591
+ if ((stream.flags & 2097155) === 1) {
2592
+ throw new FS.ErrnoError(2);
2593
+ }
2594
+ if (!stream.stream_ops.mmap) {
2595
+ throw new FS.ErrnoError(43);
2596
+ }
2597
+ if (!length) {
2598
+ throw new FS.ErrnoError(28);
2599
+ }
2600
+ return stream.stream_ops.mmap(stream, length, position, prot, flags);
2601
+ },
2602
+ msync(stream, buffer, offset, length, mmapFlags) {
2603
+ assert(offset >= 0);
2604
+ if (!stream.stream_ops.msync) {
2605
+ return 0;
2606
+ }
2607
+ return stream.stream_ops.msync(stream, buffer, offset, length, mmapFlags);
2608
+ },
2609
+ ioctl(stream, cmd, arg) {
2610
+ if (!stream.stream_ops.ioctl) {
2611
+ throw new FS.ErrnoError(59);
2612
+ }
2613
+ return stream.stream_ops.ioctl(stream, cmd, arg);
2614
+ },
2615
+ readFile(path, opts = {}) {
2616
+ opts.flags = opts.flags || 0;
2617
+ opts.encoding = opts.encoding || "binary";
2618
+ if (opts.encoding !== "utf8" && opts.encoding !== "binary") {
2619
+ throw new Error(`Invalid encoding type "${opts.encoding}"`);
2620
+ }
2621
+ var ret;
2622
+ var stream = FS.open(path, opts.flags);
2623
+ var stat = FS.stat(path);
2624
+ var length = stat.size;
2625
+ var buf = new Uint8Array(length);
2626
+ FS.read(stream, buf, 0, length, 0);
2627
+ if (opts.encoding === "utf8") {
2628
+ ret = UTF8ArrayToString(buf);
2629
+ } else if (opts.encoding === "binary") {
2630
+ ret = buf;
2631
+ }
2632
+ FS.close(stream);
2633
+ return ret;
2634
+ },
2635
+ writeFile(path, data, opts = {}) {
2636
+ opts.flags = opts.flags || 577;
2637
+ var stream = FS.open(path, opts.flags, opts.mode);
2638
+ if (typeof data == "string") {
2639
+ var buf = new Uint8Array(lengthBytesUTF8(data) + 1);
2640
+ var actualNumBytes = stringToUTF8Array(data, buf, 0, buf.length);
2641
+ FS.write(stream, buf, 0, actualNumBytes, void 0, opts.canOwn);
2642
+ } else if (ArrayBuffer.isView(data)) {
2643
+ FS.write(stream, data, 0, data.byteLength, void 0, opts.canOwn);
2644
+ } else {
2645
+ throw new Error("Unsupported data type");
2646
+ }
2647
+ FS.close(stream);
2648
+ },
2649
+ cwd: () => FS.currentPath,
2650
+ chdir(path) {
2651
+ var lookup = FS.lookupPath(path, { follow: true });
2652
+ if (lookup.node === null) {
2653
+ throw new FS.ErrnoError(44);
2654
+ }
2655
+ if (!FS.isDir(lookup.node.mode)) {
2656
+ throw new FS.ErrnoError(54);
2657
+ }
2658
+ var errCode = FS.nodePermissions(lookup.node, "x");
2659
+ if (errCode) {
2660
+ throw new FS.ErrnoError(errCode);
2661
+ }
2662
+ FS.currentPath = lookup.path;
2663
+ },
2664
+ createDefaultDirectories() {
2665
+ FS.mkdir("/tmp");
2666
+ FS.mkdir("/home");
2667
+ FS.mkdir("/home/web_user");
2668
+ },
2669
+ createDefaultDevices() {
2670
+ FS.mkdir("/dev");
2671
+ FS.registerDevice(FS.makedev(1, 3), {
2672
+ read: () => 0,
2673
+ write: (stream, buffer, offset, length, pos) => length
2674
+ });
2675
+ FS.mkdev("/dev/null", FS.makedev(1, 3));
2676
+ TTY.register(FS.makedev(5, 0), TTY.default_tty_ops);
2677
+ TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops);
2678
+ FS.mkdev("/dev/tty", FS.makedev(5, 0));
2679
+ FS.mkdev("/dev/tty1", FS.makedev(6, 0));
2680
+ var randomBuffer = new Uint8Array(1024), randomLeft = 0;
2681
+ var randomByte = () => {
2682
+ if (randomLeft === 0) {
2683
+ randomLeft = randomFill(randomBuffer).byteLength;
2684
+ }
2685
+ return randomBuffer[--randomLeft];
2686
+ };
2687
+ FS.createDevice("/dev", "random", randomByte);
2688
+ FS.createDevice("/dev", "urandom", randomByte);
2689
+ FS.mkdir("/dev/shm");
2690
+ FS.mkdir("/dev/shm/tmp");
2691
+ },
2692
+ createSpecialDirectories() {
2693
+ FS.mkdir("/proc");
2694
+ var proc_self = FS.mkdir("/proc/self");
2695
+ FS.mkdir("/proc/self/fd");
2696
+ FS.mount({
2697
+ mount() {
2698
+ var node = FS.createNode(proc_self, "fd", 16384 | 511, 73);
2699
+ node.node_ops = {
2700
+ lookup(parent, name) {
2701
+ var fd = +name;
2702
+ var stream = FS.getStreamChecked(fd);
2703
+ var ret = {
2704
+ parent: null,
2705
+ mount: { mountpoint: "fake" },
2706
+ node_ops: { readlink: () => stream.path }
2707
+ };
2708
+ ret.parent = ret;
2709
+ return ret;
2710
+ }
2711
+ };
2712
+ return node;
2713
+ }
2714
+ }, {}, "/proc/self/fd");
2715
+ },
2716
+ createStandardStreams(input, output, error) {
2717
+ if (input) {
2718
+ FS.createDevice("/dev", "stdin", input);
2719
+ } else {
2720
+ FS.symlink("/dev/tty", "/dev/stdin");
2721
+ }
2722
+ if (output) {
2723
+ FS.createDevice("/dev", "stdout", null, output);
2724
+ } else {
2725
+ FS.symlink("/dev/tty", "/dev/stdout");
2726
+ }
2727
+ if (error) {
2728
+ FS.createDevice("/dev", "stderr", null, error);
2729
+ } else {
2730
+ FS.symlink("/dev/tty1", "/dev/stderr");
2731
+ }
2732
+ var stdin = FS.open("/dev/stdin", 0);
2733
+ var stdout = FS.open("/dev/stdout", 1);
2734
+ var stderr = FS.open("/dev/stderr", 1);
2735
+ assert(stdin.fd === 0, `invalid handle for stdin (${stdin.fd})`);
2736
+ assert(stdout.fd === 1, `invalid handle for stdout (${stdout.fd})`);
2737
+ assert(stderr.fd === 2, `invalid handle for stderr (${stderr.fd})`);
2738
+ },
2739
+ staticInit() {
2740
+ [44].forEach((code) => {
2741
+ FS.genericErrors[code] = new FS.ErrnoError(code);
2742
+ FS.genericErrors[code].stack = "<generic error, no stack>";
2743
+ });
2744
+ FS.nameTable = new Array(4096);
2745
+ FS.mount(MEMFS, {}, "/");
2746
+ FS.createDefaultDirectories();
2747
+ FS.createDefaultDevices();
2748
+ FS.createSpecialDirectories();
2749
+ FS.filesystems = {
2750
+ "MEMFS": MEMFS
2751
+ };
2752
+ },
2753
+ init(input, output, error) {
2754
+ assert(!FS.initialized, "FS.init was previously called. If you want to initialize later with custom parameters, remove any earlier calls (note that one is automatically added to the generated code)");
2755
+ FS.initialized = true;
2756
+ input ?? (input = Module["stdin"]);
2757
+ output ?? (output = Module["stdout"]);
2758
+ error ?? (error = Module["stderr"]);
2759
+ FS.createStandardStreams(input, output, error);
2760
+ },
2761
+ quit() {
2762
+ FS.initialized = false;
2763
+ _fflush(0);
2764
+ for (var i = 0; i < FS.streams.length; i++) {
2765
+ var stream = FS.streams[i];
2766
+ if (!stream) {
2767
+ continue;
2768
+ }
2769
+ FS.close(stream);
2770
+ }
2771
+ },
2772
+ findObject(path, dontResolveLastLink) {
2773
+ var ret = FS.analyzePath(path, dontResolveLastLink);
2774
+ if (!ret.exists) {
2775
+ return null;
2776
+ }
2777
+ return ret.object;
2778
+ },
2779
+ analyzePath(path, dontResolveLastLink) {
2780
+ try {
2781
+ var lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
2782
+ path = lookup.path;
2783
+ } catch (e) {
2784
+ }
2785
+ var ret = {
2786
+ isRoot: false,
2787
+ exists: false,
2788
+ error: 0,
2789
+ name: null,
2790
+ path: null,
2791
+ object: null,
2792
+ parentExists: false,
2793
+ parentPath: null,
2794
+ parentObject: null
2795
+ };
2796
+ try {
2797
+ var lookup = FS.lookupPath(path, { parent: true });
2798
+ ret.parentExists = true;
2799
+ ret.parentPath = lookup.path;
2800
+ ret.parentObject = lookup.node;
2801
+ ret.name = PATH.basename(path);
2802
+ lookup = FS.lookupPath(path, { follow: !dontResolveLastLink });
2803
+ ret.exists = true;
2804
+ ret.path = lookup.path;
2805
+ ret.object = lookup.node;
2806
+ ret.name = lookup.node.name;
2807
+ ret.isRoot = lookup.path === "/";
2808
+ } catch (e) {
2809
+ ret.error = e.errno;
2810
+ }
2811
+ ;
2812
+ return ret;
2813
+ },
2814
+ createPath(parent, path, canRead, canWrite) {
2815
+ parent = typeof parent == "string" ? parent : FS.getPath(parent);
2816
+ var parts = path.split("/").reverse();
2817
+ while (parts.length) {
2818
+ var part = parts.pop();
2819
+ if (!part) continue;
2820
+ var current = PATH.join2(parent, part);
2821
+ try {
2822
+ FS.mkdir(current);
2823
+ } catch (e) {
2824
+ }
2825
+ parent = current;
2826
+ }
2827
+ return current;
2828
+ },
2829
+ createFile(parent, name, properties, canRead, canWrite) {
2830
+ var path = PATH.join2(typeof parent == "string" ? parent : FS.getPath(parent), name);
2831
+ var mode = FS_getMode(canRead, canWrite);
2832
+ return FS.create(path, mode);
2833
+ },
2834
+ createDataFile(parent, name, data, canRead, canWrite, canOwn) {
2835
+ var path = name;
2836
+ if (parent) {
2837
+ parent = typeof parent == "string" ? parent : FS.getPath(parent);
2838
+ path = name ? PATH.join2(parent, name) : parent;
2839
+ }
2840
+ var mode = FS_getMode(canRead, canWrite);
2841
+ var node = FS.create(path, mode);
2842
+ if (data) {
2843
+ if (typeof data == "string") {
2844
+ var arr = new Array(data.length);
2845
+ for (var i = 0, len = data.length; i < len; ++i) arr[i] = data.charCodeAt(i);
2846
+ data = arr;
2847
+ }
2848
+ FS.chmod(node, mode | 146);
2849
+ var stream = FS.open(node, 577);
2850
+ FS.write(stream, data, 0, data.length, 0, canOwn);
2851
+ FS.close(stream);
2852
+ FS.chmod(node, mode);
2853
+ }
2854
+ },
2855
+ createDevice(parent, name, input, output) {
2856
+ var _a;
2857
+ var path = PATH.join2(typeof parent == "string" ? parent : FS.getPath(parent), name);
2858
+ var mode = FS_getMode(!!input, !!output);
2859
+ (_a = FS.createDevice).major ?? (_a.major = 64);
2860
+ var dev = FS.makedev(FS.createDevice.major++, 0);
2861
+ FS.registerDevice(dev, {
2862
+ open(stream) {
2863
+ stream.seekable = false;
2864
+ },
2865
+ close(stream) {
2866
+ if (output?.buffer?.length) {
2867
+ output(10);
2868
+ }
2869
+ },
2870
+ read(stream, buffer, offset, length, pos) {
2871
+ var bytesRead = 0;
2872
+ for (var i = 0; i < length; i++) {
2873
+ var result;
2874
+ try {
2875
+ result = input();
2876
+ } catch (e) {
2877
+ throw new FS.ErrnoError(29);
2878
+ }
2879
+ if (result === void 0 && bytesRead === 0) {
2880
+ throw new FS.ErrnoError(6);
2881
+ }
2882
+ if (result === null || result === void 0) break;
2883
+ bytesRead++;
2884
+ buffer[offset + i] = result;
2885
+ }
2886
+ if (bytesRead) {
2887
+ stream.node.timestamp = Date.now();
2888
+ }
2889
+ return bytesRead;
2890
+ },
2891
+ write(stream, buffer, offset, length, pos) {
2892
+ for (var i = 0; i < length; i++) {
2893
+ try {
2894
+ output(buffer[offset + i]);
2895
+ } catch (e) {
2896
+ throw new FS.ErrnoError(29);
2897
+ }
2898
+ }
2899
+ if (length) {
2900
+ stream.node.timestamp = Date.now();
2901
+ }
2902
+ return i;
2903
+ }
2904
+ });
2905
+ return FS.mkdev(path, mode, dev);
2906
+ },
2907
+ forceLoadFile(obj) {
2908
+ if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true;
2909
+ if (typeof XMLHttpRequest != "undefined") {
2910
+ throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.");
2911
+ } else {
2912
+ try {
2913
+ obj.contents = readBinary(obj.url);
2914
+ obj.usedBytes = obj.contents.length;
2915
+ } catch (e) {
2916
+ throw new FS.ErrnoError(29);
2917
+ }
2918
+ }
2919
+ },
2920
+ createLazyFile(parent, name, url, canRead, canWrite) {
2921
+ class LazyUint8Array {
2922
+ constructor() {
2923
+ this.lengthKnown = false;
2924
+ this.chunks = [];
2925
+ }
2926
+ get(idx) {
2927
+ if (idx > this.length - 1 || idx < 0) {
2928
+ return void 0;
2929
+ }
2930
+ var chunkOffset = idx % this.chunkSize;
2931
+ var chunkNum = idx / this.chunkSize | 0;
2932
+ return this.getter(chunkNum)[chunkOffset];
2933
+ }
2934
+ setDataGetter(getter) {
2935
+ this.getter = getter;
2936
+ }
2937
+ cacheLength() {
2938
+ var xhr = new XMLHttpRequest();
2939
+ xhr.open("HEAD", url, false);
2940
+ xhr.send(null);
2941
+ if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
2942
+ var datalength = Number(xhr.getResponseHeader("Content-length"));
2943
+ var header;
2944
+ var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes";
2945
+ var usesGzip = (header = xhr.getResponseHeader("Content-Encoding")) && header === "gzip";
2946
+ var chunkSize = 1024 * 1024;
2947
+ if (!hasByteServing) chunkSize = datalength;
2948
+ var doXHR = (from, to) => {
2949
+ if (from > to) throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!");
2950
+ if (to > datalength - 1) throw new Error("only " + datalength + " bytes available! programmer error!");
2951
+ var xhr2 = new XMLHttpRequest();
2952
+ xhr2.open("GET", url, false);
2953
+ if (datalength !== chunkSize) xhr2.setRequestHeader("Range", "bytes=" + from + "-" + to);
2954
+ xhr2.responseType = "arraybuffer";
2955
+ if (xhr2.overrideMimeType) {
2956
+ xhr2.overrideMimeType("text/plain; charset=x-user-defined");
2957
+ }
2958
+ xhr2.send(null);
2959
+ if (!(xhr2.status >= 200 && xhr2.status < 300 || xhr2.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr2.status);
2960
+ if (xhr2.response !== void 0) {
2961
+ return new Uint8Array(
2962
+ /** @type{Array<number>} */
2963
+ xhr2.response || []
2964
+ );
2965
+ }
2966
+ return intArrayFromString(xhr2.responseText || "", true);
2967
+ };
2968
+ var lazyArray2 = this;
2969
+ lazyArray2.setDataGetter((chunkNum) => {
2970
+ var start = chunkNum * chunkSize;
2971
+ var end = (chunkNum + 1) * chunkSize - 1;
2972
+ end = Math.min(end, datalength - 1);
2973
+ if (typeof lazyArray2.chunks[chunkNum] == "undefined") {
2974
+ lazyArray2.chunks[chunkNum] = doXHR(start, end);
2975
+ }
2976
+ if (typeof lazyArray2.chunks[chunkNum] == "undefined") throw new Error("doXHR failed!");
2977
+ return lazyArray2.chunks[chunkNum];
2978
+ });
2979
+ if (usesGzip || !datalength) {
2980
+ chunkSize = datalength = 1;
2981
+ datalength = this.getter(0).length;
2982
+ chunkSize = datalength;
2983
+ out("LazyFiles on gzip forces download of the whole file when length is accessed");
2984
+ }
2985
+ this._length = datalength;
2986
+ this._chunkSize = chunkSize;
2987
+ this.lengthKnown = true;
2988
+ }
2989
+ get length() {
2990
+ if (!this.lengthKnown) {
2991
+ this.cacheLength();
2992
+ }
2993
+ return this._length;
2994
+ }
2995
+ get chunkSize() {
2996
+ if (!this.lengthKnown) {
2997
+ this.cacheLength();
2998
+ }
2999
+ return this._chunkSize;
3000
+ }
3001
+ }
3002
+ if (typeof XMLHttpRequest != "undefined") {
3003
+ if (!ENVIRONMENT_IS_WORKER) throw "Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc";
3004
+ var lazyArray = new LazyUint8Array();
3005
+ var properties = { isDevice: false, contents: lazyArray };
3006
+ } else {
3007
+ var properties = { isDevice: false, url };
3008
+ }
3009
+ var node = FS.createFile(parent, name, properties, canRead, canWrite);
3010
+ if (properties.contents) {
3011
+ node.contents = properties.contents;
3012
+ } else if (properties.url) {
3013
+ node.contents = null;
3014
+ node.url = properties.url;
3015
+ }
3016
+ Object.defineProperties(node, {
3017
+ usedBytes: {
3018
+ get: function() {
3019
+ return this.contents.length;
3020
+ }
3021
+ }
3022
+ });
3023
+ var stream_ops = {};
3024
+ var keys = Object.keys(node.stream_ops);
3025
+ keys.forEach((key) => {
3026
+ var fn = node.stream_ops[key];
3027
+ stream_ops[key] = (...args) => {
3028
+ FS.forceLoadFile(node);
3029
+ return fn(...args);
3030
+ };
3031
+ });
3032
+ function writeChunks(stream, buffer, offset, length, position) {
3033
+ var contents = stream.node.contents;
3034
+ if (position >= contents.length)
3035
+ return 0;
3036
+ var size = Math.min(contents.length - position, length);
3037
+ assert(size >= 0);
3038
+ if (contents.slice) {
3039
+ for (var i = 0; i < size; i++) {
3040
+ buffer[offset + i] = contents[position + i];
3041
+ }
3042
+ } else {
3043
+ for (var i = 0; i < size; i++) {
3044
+ buffer[offset + i] = contents.get(position + i);
3045
+ }
3046
+ }
3047
+ return size;
3048
+ }
3049
+ stream_ops.read = (stream, buffer, offset, length, position) => {
3050
+ FS.forceLoadFile(node);
3051
+ return writeChunks(stream, buffer, offset, length, position);
3052
+ };
3053
+ stream_ops.mmap = (stream, length, position, prot, flags) => {
3054
+ FS.forceLoadFile(node);
3055
+ var ptr = mmapAlloc(length);
3056
+ if (!ptr) {
3057
+ throw new FS.ErrnoError(48);
3058
+ }
3059
+ writeChunks(stream, HEAP8, ptr, length, position);
3060
+ return { ptr, allocated: true };
3061
+ };
3062
+ node.stream_ops = stream_ops;
3063
+ return node;
3064
+ },
3065
+ absolutePath() {
3066
+ abort("FS.absolutePath has been removed; use PATH_FS.resolve instead");
3067
+ },
3068
+ createFolder() {
3069
+ abort("FS.createFolder has been removed; use FS.mkdir instead");
3070
+ },
3071
+ createLink() {
3072
+ abort("FS.createLink has been removed; use FS.symlink instead");
3073
+ },
3074
+ joinPath() {
3075
+ abort("FS.joinPath has been removed; use PATH.join instead");
3076
+ },
3077
+ mmapAlloc() {
3078
+ abort("FS.mmapAlloc has been replaced by the top level function mmapAlloc");
3079
+ },
3080
+ standardizePath() {
3081
+ abort("FS.standardizePath has been removed; use PATH.normalize instead");
3082
+ }
3083
+ };
3084
+ var SYSCALLS = {
3085
+ DEFAULT_POLLMASK: 5,
3086
+ calculateAt(dirfd, path, allowEmpty) {
3087
+ if (PATH.isAbs(path)) {
3088
+ return path;
3089
+ }
3090
+ var dir;
3091
+ if (dirfd === -100) {
3092
+ dir = FS.cwd();
3093
+ } else {
3094
+ var dirstream = SYSCALLS.getStreamFromFD(dirfd);
3095
+ dir = dirstream.path;
3096
+ }
3097
+ if (path.length == 0) {
3098
+ if (!allowEmpty) {
3099
+ throw new FS.ErrnoError(44);
3100
+ ;
3101
+ }
3102
+ return dir;
3103
+ }
3104
+ return PATH.join2(dir, path);
3105
+ },
3106
+ doStat(func, path, buf) {
3107
+ var stat = func(path);
3108
+ HEAP32[buf >> 2] = stat.dev;
3109
+ HEAP32[buf + 4 >> 2] = stat.mode;
3110
+ HEAPU32[buf + 8 >> 2] = stat.nlink;
3111
+ HEAP32[buf + 12 >> 2] = stat.uid;
3112
+ HEAP32[buf + 16 >> 2] = stat.gid;
3113
+ HEAP32[buf + 20 >> 2] = stat.rdev;
3114
+ 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];
3115
+ HEAP32[buf + 32 >> 2] = 4096;
3116
+ HEAP32[buf + 36 >> 2] = stat.blocks;
3117
+ var atime = stat.atime.getTime();
3118
+ var mtime = stat.mtime.getTime();
3119
+ var ctime = stat.ctime.getTime();
3120
+ 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];
3121
+ HEAPU32[buf + 48 >> 2] = atime % 1e3 * 1e3 * 1e3;
3122
+ 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];
3123
+ HEAPU32[buf + 64 >> 2] = mtime % 1e3 * 1e3 * 1e3;
3124
+ 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];
3125
+ HEAPU32[buf + 80 >> 2] = ctime % 1e3 * 1e3 * 1e3;
3126
+ 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];
3127
+ return 0;
3128
+ },
3129
+ doMsync(addr, stream, len, flags, offset) {
3130
+ if (!FS.isFile(stream.node.mode)) {
3131
+ throw new FS.ErrnoError(43);
3132
+ }
3133
+ if (flags & 2) {
3134
+ return 0;
3135
+ }
3136
+ var buffer = HEAPU8.slice(addr, addr + len);
3137
+ FS.msync(stream, buffer, offset, len, flags);
3138
+ },
3139
+ getStreamFromFD(fd) {
3140
+ var stream = FS.getStreamChecked(fd);
3141
+ return stream;
3142
+ },
3143
+ varargs: void 0,
3144
+ getStr(ptr) {
3145
+ var ret = UTF8ToString(ptr);
3146
+ return ret;
3147
+ }
3148
+ };
3149
+ function ___syscall_fcntl64(fd, cmd, varargs) {
3150
+ SYSCALLS.varargs = varargs;
3151
+ try {
3152
+ var stream = SYSCALLS.getStreamFromFD(fd);
3153
+ switch (cmd) {
3154
+ case 0: {
3155
+ var arg = syscallGetVarargI();
3156
+ if (arg < 0) {
3157
+ return -28;
3158
+ }
3159
+ while (FS.streams[arg]) {
3160
+ arg++;
3161
+ }
3162
+ var newStream;
3163
+ newStream = FS.dupStream(stream, arg);
3164
+ return newStream.fd;
3165
+ }
3166
+ case 1:
3167
+ case 2:
3168
+ return 0;
3169
+ // FD_CLOEXEC makes no sense for a single process.
3170
+ case 3:
3171
+ return stream.flags;
3172
+ case 4: {
3173
+ var arg = syscallGetVarargI();
3174
+ stream.flags |= arg;
3175
+ return 0;
3176
+ }
3177
+ case 12: {
3178
+ var arg = syscallGetVarargP();
3179
+ var offset = 0;
3180
+ HEAP16[arg + offset >> 1] = 2;
3181
+ return 0;
3182
+ }
3183
+ case 13:
3184
+ case 14:
3185
+ return 0;
3186
+ }
3187
+ return -28;
3188
+ } catch (e) {
3189
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
3190
+ return -e.errno;
3191
+ }
3192
+ }
3193
+ function ___syscall_fstat64(fd, buf) {
3194
+ try {
3195
+ var stream = SYSCALLS.getStreamFromFD(fd);
3196
+ return SYSCALLS.doStat(FS.stat, stream.path, buf);
3197
+ } catch (e) {
3198
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
3199
+ return -e.errno;
3200
+ }
3201
+ }
3202
+ var stringToUTF8 = (str, outPtr, maxBytesToWrite) => {
3203
+ assert(typeof maxBytesToWrite == "number", "stringToUTF8(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!");
3204
+ return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
3205
+ };
3206
+ function ___syscall_getdents64(fd, dirp, count) {
3207
+ try {
3208
+ var stream = SYSCALLS.getStreamFromFD(fd);
3209
+ stream.getdents || (stream.getdents = FS.readdir(stream.path));
3210
+ var struct_size = 280;
3211
+ var pos = 0;
3212
+ var off = FS.llseek(stream, 0, 1);
3213
+ var idx = Math.floor(off / struct_size);
3214
+ while (idx < stream.getdents.length && pos + struct_size <= count) {
3215
+ var id;
3216
+ var type;
3217
+ var name = stream.getdents[idx];
3218
+ if (name === ".") {
3219
+ id = stream.node.id;
3220
+ type = 4;
3221
+ } else if (name === "..") {
3222
+ var lookup = FS.lookupPath(stream.path, { parent: true });
3223
+ id = lookup.node.id;
3224
+ type = 4;
3225
+ } else {
3226
+ var child = FS.lookupNode(stream.node, name);
3227
+ id = child.id;
3228
+ type = FS.isChrdev(child.mode) ? 2 : (
3229
+ // DT_CHR, character device.
3230
+ FS.isDir(child.mode) ? 4 : (
3231
+ // DT_DIR, directory.
3232
+ FS.isLink(child.mode) ? 10 : (
3233
+ // DT_LNK, symbolic link.
3234
+ 8
3235
+ )
3236
+ )
3237
+ );
3238
+ }
3239
+ assert(id);
3240
+ tempI64 = [id >>> 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];
3241
+ 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];
3242
+ HEAP16[dirp + pos + 16 >> 1] = 280;
3243
+ HEAP8[dirp + pos + 18] = type;
3244
+ stringToUTF8(name, dirp + pos + 19, 256);
3245
+ pos += struct_size;
3246
+ idx += 1;
3247
+ }
3248
+ FS.llseek(stream, idx * struct_size, 0);
3249
+ return pos;
3250
+ } catch (e) {
3251
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
3252
+ return -e.errno;
3253
+ }
3254
+ }
3255
+ function ___syscall_ioctl(fd, op, varargs) {
3256
+ SYSCALLS.varargs = varargs;
3257
+ try {
3258
+ var stream = SYSCALLS.getStreamFromFD(fd);
3259
+ switch (op) {
3260
+ case 21509: {
3261
+ if (!stream.tty) return -59;
3262
+ return 0;
3263
+ }
3264
+ case 21505: {
3265
+ if (!stream.tty) return -59;
3266
+ if (stream.tty.ops.ioctl_tcgets) {
3267
+ var termios = stream.tty.ops.ioctl_tcgets(stream);
3268
+ var argp = syscallGetVarargP();
3269
+ HEAP32[argp >> 2] = termios.c_iflag || 0;
3270
+ HEAP32[argp + 4 >> 2] = termios.c_oflag || 0;
3271
+ HEAP32[argp + 8 >> 2] = termios.c_cflag || 0;
3272
+ HEAP32[argp + 12 >> 2] = termios.c_lflag || 0;
3273
+ for (var i = 0; i < 32; i++) {
3274
+ HEAP8[argp + i + 17] = termios.c_cc[i] || 0;
3275
+ }
3276
+ return 0;
3277
+ }
3278
+ return 0;
3279
+ }
3280
+ case 21510:
3281
+ case 21511:
3282
+ case 21512: {
3283
+ if (!stream.tty) return -59;
3284
+ return 0;
3285
+ }
3286
+ case 21506:
3287
+ case 21507:
3288
+ case 21508: {
3289
+ if (!stream.tty) return -59;
3290
+ if (stream.tty.ops.ioctl_tcsets) {
3291
+ var argp = syscallGetVarargP();
3292
+ var c_iflag = HEAP32[argp >> 2];
3293
+ var c_oflag = HEAP32[argp + 4 >> 2];
3294
+ var c_cflag = HEAP32[argp + 8 >> 2];
3295
+ var c_lflag = HEAP32[argp + 12 >> 2];
3296
+ var c_cc = [];
3297
+ for (var i = 0; i < 32; i++) {
3298
+ c_cc.push(HEAP8[argp + i + 17]);
3299
+ }
3300
+ return stream.tty.ops.ioctl_tcsets(stream.tty, op, { c_iflag, c_oflag, c_cflag, c_lflag, c_cc });
3301
+ }
3302
+ return 0;
3303
+ }
3304
+ case 21519: {
3305
+ if (!stream.tty) return -59;
3306
+ var argp = syscallGetVarargP();
3307
+ HEAP32[argp >> 2] = 0;
3308
+ return 0;
3309
+ }
3310
+ case 21520: {
3311
+ if (!stream.tty) return -59;
3312
+ return -28;
3313
+ }
3314
+ case 21531: {
3315
+ var argp = syscallGetVarargP();
3316
+ return FS.ioctl(stream, op, argp);
3317
+ }
3318
+ case 21523: {
3319
+ if (!stream.tty) return -59;
3320
+ if (stream.tty.ops.ioctl_tiocgwinsz) {
3321
+ var winsize = stream.tty.ops.ioctl_tiocgwinsz(stream.tty);
3322
+ var argp = syscallGetVarargP();
3323
+ HEAP16[argp >> 1] = winsize[0];
3324
+ HEAP16[argp + 2 >> 1] = winsize[1];
3325
+ }
3326
+ return 0;
3327
+ }
3328
+ case 21524: {
3329
+ if (!stream.tty) return -59;
3330
+ return 0;
3331
+ }
3332
+ case 21515: {
3333
+ if (!stream.tty) return -59;
3334
+ return 0;
3335
+ }
3336
+ default:
3337
+ return -28;
3338
+ }
3339
+ } catch (e) {
3340
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
3341
+ return -e.errno;
3342
+ }
3343
+ }
3344
+ function ___syscall_lstat64(path, buf) {
3345
+ try {
3346
+ path = SYSCALLS.getStr(path);
3347
+ return SYSCALLS.doStat(FS.lstat, path, buf);
3348
+ } catch (e) {
3349
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
3350
+ return -e.errno;
3351
+ }
3352
+ }
3353
+ function ___syscall_newfstatat(dirfd, path, buf, flags) {
3354
+ try {
3355
+ path = SYSCALLS.getStr(path);
3356
+ var nofollow = flags & 256;
3357
+ var allowEmpty = flags & 4096;
3358
+ flags = flags & ~6400;
3359
+ assert(!flags, `unknown flags in __syscall_newfstatat: ${flags}`);
3360
+ path = SYSCALLS.calculateAt(dirfd, path, allowEmpty);
3361
+ return SYSCALLS.doStat(nofollow ? FS.lstat : FS.stat, path, buf);
3362
+ } catch (e) {
3363
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
3364
+ return -e.errno;
3365
+ }
3366
+ }
3367
+ function ___syscall_openat(dirfd, path, flags, varargs) {
3368
+ SYSCALLS.varargs = varargs;
3369
+ try {
3370
+ path = SYSCALLS.getStr(path);
3371
+ path = SYSCALLS.calculateAt(dirfd, path);
3372
+ var mode = varargs ? syscallGetVarargI() : 0;
3373
+ return FS.open(path, flags, mode).fd;
3374
+ } catch (e) {
3375
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
3376
+ return -e.errno;
3377
+ }
3378
+ }
3379
+ function ___syscall_rmdir(path) {
3380
+ try {
3381
+ path = SYSCALLS.getStr(path);
3382
+ FS.rmdir(path);
3383
+ return 0;
3384
+ } catch (e) {
3385
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
3386
+ return -e.errno;
3387
+ }
3388
+ }
3389
+ function ___syscall_stat64(path, buf) {
3390
+ try {
3391
+ path = SYSCALLS.getStr(path);
3392
+ return SYSCALLS.doStat(FS.stat, path, buf);
3393
+ } catch (e) {
3394
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
3395
+ return -e.errno;
3396
+ }
3397
+ }
3398
+ function ___syscall_unlinkat(dirfd, path, flags) {
3399
+ try {
3400
+ path = SYSCALLS.getStr(path);
3401
+ path = SYSCALLS.calculateAt(dirfd, path);
3402
+ if (flags === 0) {
3403
+ FS.unlink(path);
3404
+ } else if (flags === 512) {
3405
+ FS.rmdir(path);
3406
+ } else {
3407
+ abort("Invalid flags passed to unlinkat");
3408
+ }
3409
+ return 0;
3410
+ } catch (e) {
3411
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
3412
+ return -e.errno;
3413
+ }
3414
+ }
3415
+ var __abort_js = () => {
3416
+ abort("native code called abort()");
3417
+ };
3418
+ var __emscripten_memcpy_js = (dest, src, num) => HEAPU8.copyWithin(dest, src, src + num);
3419
+ var __emscripten_throw_longjmp = () => {
3420
+ throw Infinity;
3421
+ };
3422
+ var convertI32PairToI53Checked = (lo, hi) => {
3423
+ assert(lo == lo >>> 0 || lo == (lo | 0));
3424
+ assert(hi === (hi | 0));
3425
+ return hi + 2097152 >>> 0 < 4194305 - !!lo ? (lo >>> 0) + hi * 4294967296 : NaN;
3426
+ };
3427
+ function __gmtime_js(time_low, time_high, tmPtr) {
3428
+ var time = convertI32PairToI53Checked(time_low, time_high);
3429
+ var date = new Date(time * 1e3);
3430
+ HEAP32[tmPtr >> 2] = date.getUTCSeconds();
3431
+ HEAP32[tmPtr + 4 >> 2] = date.getUTCMinutes();
3432
+ HEAP32[tmPtr + 8 >> 2] = date.getUTCHours();
3433
+ HEAP32[tmPtr + 12 >> 2] = date.getUTCDate();
3434
+ HEAP32[tmPtr + 16 >> 2] = date.getUTCMonth();
3435
+ HEAP32[tmPtr + 20 >> 2] = date.getUTCFullYear() - 1900;
3436
+ HEAP32[tmPtr + 24 >> 2] = date.getUTCDay();
3437
+ var start = Date.UTC(date.getUTCFullYear(), 0, 1, 0, 0, 0, 0);
3438
+ var yday = (date.getTime() - start) / (1e3 * 60 * 60 * 24) | 0;
3439
+ HEAP32[tmPtr + 28 >> 2] = yday;
3440
+ ;
3441
+ }
3442
+ var isLeapYear = (year) => year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
3443
+ var MONTH_DAYS_LEAP_CUMULATIVE = [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335];
3444
+ var MONTH_DAYS_REGULAR_CUMULATIVE = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334];
3445
+ var ydayFromDate = (date) => {
3446
+ var leap = isLeapYear(date.getFullYear());
3447
+ var monthDaysCumulative = leap ? MONTH_DAYS_LEAP_CUMULATIVE : MONTH_DAYS_REGULAR_CUMULATIVE;
3448
+ var yday = monthDaysCumulative[date.getMonth()] + date.getDate() - 1;
3449
+ return yday;
3450
+ };
3451
+ function __localtime_js(time_low, time_high, tmPtr) {
3452
+ var time = convertI32PairToI53Checked(time_low, time_high);
3453
+ var date = new Date(time * 1e3);
3454
+ HEAP32[tmPtr >> 2] = date.getSeconds();
3455
+ HEAP32[tmPtr + 4 >> 2] = date.getMinutes();
3456
+ HEAP32[tmPtr + 8 >> 2] = date.getHours();
3457
+ HEAP32[tmPtr + 12 >> 2] = date.getDate();
3458
+ HEAP32[tmPtr + 16 >> 2] = date.getMonth();
3459
+ HEAP32[tmPtr + 20 >> 2] = date.getFullYear() - 1900;
3460
+ HEAP32[tmPtr + 24 >> 2] = date.getDay();
3461
+ var yday = ydayFromDate(date) | 0;
3462
+ HEAP32[tmPtr + 28 >> 2] = yday;
3463
+ HEAP32[tmPtr + 36 >> 2] = -(date.getTimezoneOffset() * 60);
3464
+ var start = new Date(date.getFullYear(), 0, 1);
3465
+ var summerOffset = new Date(date.getFullYear(), 6, 1).getTimezoneOffset();
3466
+ var winterOffset = start.getTimezoneOffset();
3467
+ var dst = (summerOffset != winterOffset && date.getTimezoneOffset() == Math.min(winterOffset, summerOffset)) | 0;
3468
+ HEAP32[tmPtr + 32 >> 2] = dst;
3469
+ ;
3470
+ }
3471
+ var __tzset_js = (timezone, daylight, std_name, dst_name) => {
3472
+ var currentYear = (/* @__PURE__ */ new Date()).getFullYear();
3473
+ var winter = new Date(currentYear, 0, 1);
3474
+ var summer = new Date(currentYear, 6, 1);
3475
+ var winterOffset = winter.getTimezoneOffset();
3476
+ var summerOffset = summer.getTimezoneOffset();
3477
+ var stdTimezoneOffset = Math.max(winterOffset, summerOffset);
3478
+ HEAPU32[timezone >> 2] = stdTimezoneOffset * 60;
3479
+ HEAP32[daylight >> 2] = Number(winterOffset != summerOffset);
3480
+ var extractZone = (timezoneOffset) => {
3481
+ var sign = timezoneOffset >= 0 ? "-" : "+";
3482
+ var absOffset = Math.abs(timezoneOffset);
3483
+ var hours = String(Math.floor(absOffset / 60)).padStart(2, "0");
3484
+ var minutes = String(absOffset % 60).padStart(2, "0");
3485
+ return `UTC${sign}${hours}${minutes}`;
3486
+ };
3487
+ var winterName = extractZone(winterOffset);
3488
+ var summerName = extractZone(summerOffset);
3489
+ assert(winterName);
3490
+ assert(summerName);
3491
+ assert(lengthBytesUTF8(winterName) <= 16, `timezone name truncated to fit in TZNAME_MAX (${winterName})`);
3492
+ assert(lengthBytesUTF8(summerName) <= 16, `timezone name truncated to fit in TZNAME_MAX (${summerName})`);
3493
+ if (summerOffset < winterOffset) {
3494
+ stringToUTF8(winterName, std_name, 17);
3495
+ stringToUTF8(summerName, dst_name, 17);
3496
+ } else {
3497
+ stringToUTF8(winterName, dst_name, 17);
3498
+ stringToUTF8(summerName, std_name, 17);
3499
+ }
3500
+ };
3501
+ var _emscripten_date_now = () => Date.now();
3502
+ var _emscripten_errn = (str, len) => err(UTF8ToString(str, len));
3503
+ var getHeapMax = () => (
3504
+ // Stay one Wasm page short of 4GB: while e.g. Chrome is able to allocate
3505
+ // full 4GB Wasm memories, the size will wrap back to 0 bytes in Wasm side
3506
+ // for any code that deals with heap sizes, which would require special
3507
+ // casing all heap size related code to treat 0 specially.
3508
+ 2147483648
3509
+ );
3510
+ var growMemory = (size) => {
3511
+ var b = wasmMemory.buffer;
3512
+ var pages = (size - b.byteLength + 65535) / 65536 | 0;
3513
+ try {
3514
+ wasmMemory.grow(pages);
3515
+ updateMemoryViews();
3516
+ return 1;
3517
+ } catch (e) {
3518
+ err(`growMemory: Attempted to grow heap from ${b.byteLength} bytes to ${size} bytes, but got error: ${e}`);
3519
+ }
3520
+ };
3521
+ var _emscripten_resize_heap = (requestedSize) => {
3522
+ var oldSize = HEAPU8.length;
3523
+ requestedSize >>>= 0;
3524
+ assert(requestedSize > oldSize);
3525
+ var maxHeapSize = getHeapMax();
3526
+ if (requestedSize > maxHeapSize) {
3527
+ err(`Cannot enlarge memory, requested ${requestedSize} bytes, but the limit is ${maxHeapSize} bytes!`);
3528
+ return false;
3529
+ }
3530
+ for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
3531
+ var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown);
3532
+ overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
3533
+ var newSize = Math.min(maxHeapSize, alignMemory(Math.max(requestedSize, overGrownHeapSize), 65536));
3534
+ var replacement = growMemory(newSize);
3535
+ if (replacement) {
3536
+ return true;
3537
+ }
3538
+ }
3539
+ err(`Failed to grow the heap from ${oldSize} bytes to ${newSize} bytes, not enough memory!`);
3540
+ return false;
3541
+ };
3542
+ var ENV = {};
3543
+ var getExecutableName = () => {
3544
+ return thisProgram || "./this.program";
3545
+ };
3546
+ var getEnvStrings = () => {
3547
+ if (!getEnvStrings.strings) {
3548
+ var lang = (typeof navigator == "object" && navigator.languages && navigator.languages[0] || "C").replace("-", "_") + ".UTF-8";
3549
+ var env = {
3550
+ "USER": "web_user",
3551
+ "LOGNAME": "web_user",
3552
+ "PATH": "/",
3553
+ "PWD": "/",
3554
+ "HOME": "/home/web_user",
3555
+ "LANG": lang,
3556
+ "_": getExecutableName()
3557
+ };
3558
+ for (var x in ENV) {
3559
+ if (ENV[x] === void 0) delete env[x];
3560
+ else env[x] = ENV[x];
3561
+ }
3562
+ var strings = [];
3563
+ for (var x in env) {
3564
+ strings.push(`${x}=${env[x]}`);
3565
+ }
3566
+ getEnvStrings.strings = strings;
3567
+ }
3568
+ return getEnvStrings.strings;
3569
+ };
3570
+ var stringToAscii = (str, buffer) => {
3571
+ for (var i = 0; i < str.length; ++i) {
3572
+ assert(str.charCodeAt(i) === (str.charCodeAt(i) & 255));
3573
+ HEAP8[buffer++] = str.charCodeAt(i);
3574
+ }
3575
+ HEAP8[buffer] = 0;
3576
+ };
3577
+ var _environ_get = (__environ, environ_buf) => {
3578
+ var bufSize = 0;
3579
+ getEnvStrings().forEach((string, i) => {
3580
+ var ptr = environ_buf + bufSize;
3581
+ HEAPU32[__environ + i * 4 >> 2] = ptr;
3582
+ stringToAscii(string, ptr);
3583
+ bufSize += string.length + 1;
3584
+ });
3585
+ return 0;
3586
+ };
3587
+ var _environ_sizes_get = (penviron_count, penviron_buf_size) => {
3588
+ var strings = getEnvStrings();
3589
+ HEAPU32[penviron_count >> 2] = strings.length;
3590
+ var bufSize = 0;
3591
+ strings.forEach((string) => bufSize += string.length + 1);
3592
+ HEAPU32[penviron_buf_size >> 2] = bufSize;
3593
+ return 0;
3594
+ };
3595
+ function _fd_close(fd) {
3596
+ try {
3597
+ var stream = SYSCALLS.getStreamFromFD(fd);
3598
+ FS.close(stream);
3599
+ return 0;
3600
+ } catch (e) {
3601
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
3602
+ return e.errno;
3603
+ }
3604
+ }
3605
+ var doReadv = (stream, iov, iovcnt, offset) => {
3606
+ var ret = 0;
3607
+ for (var i = 0; i < iovcnt; i++) {
3608
+ var ptr = HEAPU32[iov >> 2];
3609
+ var len = HEAPU32[iov + 4 >> 2];
3610
+ iov += 8;
3611
+ var curr = FS.read(stream, HEAP8, ptr, len, offset);
3612
+ if (curr < 0) return -1;
3613
+ ret += curr;
3614
+ if (curr < len) break;
3615
+ if (typeof offset != "undefined") {
3616
+ offset += curr;
3617
+ }
3618
+ }
3619
+ return ret;
3620
+ };
3621
+ function _fd_read(fd, iov, iovcnt, pnum) {
3622
+ try {
3623
+ var stream = SYSCALLS.getStreamFromFD(fd);
3624
+ var num = doReadv(stream, iov, iovcnt);
3625
+ HEAPU32[pnum >> 2] = num;
3626
+ return 0;
3627
+ } catch (e) {
3628
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
3629
+ return e.errno;
3630
+ }
3631
+ }
3632
+ function _fd_seek(fd, offset_low, offset_high, whence, newOffset) {
3633
+ var offset = convertI32PairToI53Checked(offset_low, offset_high);
3634
+ try {
3635
+ if (isNaN(offset)) return 61;
3636
+ var stream = SYSCALLS.getStreamFromFD(fd);
3637
+ FS.llseek(stream, offset, whence);
3638
+ 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];
3639
+ if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null;
3640
+ return 0;
3641
+ } catch (e) {
3642
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
3643
+ return e.errno;
3644
+ }
3645
+ ;
3646
+ }
3647
+ var doWritev = (stream, iov, iovcnt, offset) => {
3648
+ var ret = 0;
3649
+ for (var i = 0; i < iovcnt; i++) {
3650
+ var ptr = HEAPU32[iov >> 2];
3651
+ var len = HEAPU32[iov + 4 >> 2];
3652
+ iov += 8;
3653
+ var curr = FS.write(stream, HEAP8, ptr, len, offset);
3654
+ if (curr < 0) return -1;
3655
+ ret += curr;
3656
+ if (curr < len) {
3657
+ break;
3658
+ }
3659
+ if (typeof offset != "undefined") {
3660
+ offset += curr;
3661
+ }
3662
+ }
3663
+ return ret;
3664
+ };
3665
+ function _fd_write(fd, iov, iovcnt, pnum) {
3666
+ try {
3667
+ var stream = SYSCALLS.getStreamFromFD(fd);
3668
+ var num = doWritev(stream, iov, iovcnt);
3669
+ HEAPU32[pnum >> 2] = num;
3670
+ return 0;
3671
+ } catch (e) {
3672
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
3673
+ return e.errno;
3674
+ }
3675
+ }
3676
+ var wasmTableMirror = [];
3677
+ var wasmTable;
3678
+ var getWasmTableEntry = (funcPtr) => {
3679
+ var func = wasmTableMirror[funcPtr];
3680
+ if (!func) {
3681
+ if (funcPtr >= wasmTableMirror.length) wasmTableMirror.length = funcPtr + 1;
3682
+ wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr);
3683
+ }
3684
+ assert(wasmTable.get(funcPtr) == func, "JavaScript-side Wasm function table mirror is out of date!");
3685
+ return func;
3686
+ };
3687
+ var getCFunc = (ident) => {
3688
+ var func = Module["_" + ident];
3689
+ assert(func, "Cannot call unknown function " + ident + ", make sure it is exported");
3690
+ return func;
3691
+ };
3692
+ var writeArrayToMemory = (array, buffer) => {
3693
+ assert(array.length >= 0, "writeArrayToMemory array must have a length (should be an array or typed array)");
3694
+ HEAP8.set(array, buffer);
3695
+ };
3696
+ var stackAlloc = (sz) => __emscripten_stack_alloc(sz);
3697
+ var stringToUTF8OnStack = (str) => {
3698
+ var size = lengthBytesUTF8(str) + 1;
3699
+ var ret = stackAlloc(size);
3700
+ stringToUTF8(str, ret, size);
3701
+ return ret;
3702
+ };
3703
+ var ccall = (ident, returnType, argTypes, args, opts) => {
3704
+ var toC = {
3705
+ "string": (str) => {
3706
+ var ret2 = 0;
3707
+ if (str !== null && str !== void 0 && str !== 0) {
3708
+ ret2 = stringToUTF8OnStack(str);
3709
+ }
3710
+ return ret2;
3711
+ },
3712
+ "array": (arr) => {
3713
+ var ret2 = stackAlloc(arr.length);
3714
+ writeArrayToMemory(arr, ret2);
3715
+ return ret2;
3716
+ }
3717
+ };
3718
+ function convertReturnValue(ret2) {
3719
+ if (returnType === "string") {
3720
+ return UTF8ToString(ret2);
3721
+ }
3722
+ if (returnType === "boolean") return Boolean(ret2);
3723
+ return ret2;
3724
+ }
3725
+ var func = getCFunc(ident);
3726
+ var cArgs = [];
3727
+ var stack = 0;
3728
+ assert(returnType !== "array", 'Return type should not be "array".');
3729
+ if (args) {
3730
+ for (var i = 0; i < args.length; i++) {
3731
+ var converter = toC[argTypes[i]];
3732
+ if (converter) {
3733
+ if (stack === 0) stack = stackSave();
3734
+ cArgs[i] = converter(args[i]);
3735
+ } else {
3736
+ cArgs[i] = args[i];
3737
+ }
3738
+ }
3739
+ }
3740
+ var ret = func(...cArgs);
3741
+ function onDone(ret2) {
3742
+ if (stack !== 0) stackRestore(stack);
3743
+ return convertReturnValue(ret2);
3744
+ }
3745
+ ret = onDone(ret);
3746
+ return ret;
3747
+ };
3748
+ var cwrap = (ident, returnType, argTypes, opts) => {
3749
+ return (...args) => ccall(ident, returnType, argTypes, args, opts);
3750
+ };
3751
+ var uleb128Encode = (n, target) => {
3752
+ assert(n < 16384);
3753
+ if (n < 128) {
3754
+ target.push(n);
3755
+ } else {
3756
+ target.push(n % 128 | 128, n >> 7);
3757
+ }
3758
+ };
3759
+ var sigToWasmTypes = (sig) => {
3760
+ assert(!sig.includes("j"), "i64 not permitted in function signatures when WASM_BIGINT is disabled");
3761
+ var typeNames = {
3762
+ "i": "i32",
3763
+ "j": "i64",
3764
+ "f": "f32",
3765
+ "d": "f64",
3766
+ "e": "externref",
3767
+ "p": "i32"
3768
+ };
3769
+ var type = {
3770
+ parameters: [],
3771
+ results: sig[0] == "v" ? [] : [typeNames[sig[0]]]
3772
+ };
3773
+ for (var i = 1; i < sig.length; ++i) {
3774
+ assert(sig[i] in typeNames, "invalid signature char: " + sig[i]);
3775
+ type.parameters.push(typeNames[sig[i]]);
3776
+ }
3777
+ return type;
3778
+ };
3779
+ var generateFuncType = (sig, target) => {
3780
+ var sigRet = sig.slice(0, 1);
3781
+ var sigParam = sig.slice(1);
3782
+ var typeCodes = {
3783
+ "i": 127,
3784
+ // i32
3785
+ "p": 127,
3786
+ // i32
3787
+ "j": 126,
3788
+ // i64
3789
+ "f": 125,
3790
+ // f32
3791
+ "d": 124,
3792
+ // f64
3793
+ "e": 111
3794
+ // externref
3795
+ };
3796
+ target.push(
3797
+ 96
3798
+ /* form: func */
3799
+ );
3800
+ uleb128Encode(sigParam.length, target);
3801
+ for (var i = 0; i < sigParam.length; ++i) {
3802
+ assert(sigParam[i] in typeCodes, "invalid signature char: " + sigParam[i]);
3803
+ target.push(typeCodes[sigParam[i]]);
3804
+ }
3805
+ if (sigRet == "v") {
3806
+ target.push(0);
3807
+ } else {
3808
+ target.push(1, typeCodes[sigRet]);
3809
+ }
3810
+ };
3811
+ var convertJsFunctionToWasm = (func, sig) => {
3812
+ assert(!sig.includes("j"), "i64 not permitted in function signatures when WASM_BIGINT is disabled");
3813
+ if (typeof WebAssembly.Function == "function") {
3814
+ return new WebAssembly.Function(sigToWasmTypes(sig), func);
3815
+ }
3816
+ var typeSectionBody = [
3817
+ 1
3818
+ // count: 1
3819
+ ];
3820
+ generateFuncType(sig, typeSectionBody);
3821
+ var bytes = [
3822
+ 0,
3823
+ 97,
3824
+ 115,
3825
+ 109,
3826
+ // magic ("\0asm")
3827
+ 1,
3828
+ 0,
3829
+ 0,
3830
+ 0,
3831
+ // version: 1
3832
+ 1
3833
+ // Type section code
3834
+ ];
3835
+ uleb128Encode(typeSectionBody.length, bytes);
3836
+ bytes.push(...typeSectionBody);
3837
+ bytes.push(
3838
+ 2,
3839
+ 7,
3840
+ // import section
3841
+ // (import "e" "f" (func 0 (type 0)))
3842
+ 1,
3843
+ 1,
3844
+ 101,
3845
+ 1,
3846
+ 102,
3847
+ 0,
3848
+ 0,
3849
+ 7,
3850
+ 5,
3851
+ // export section
3852
+ // (export "f" (func 0 (type 0)))
3853
+ 1,
3854
+ 1,
3855
+ 102,
3856
+ 0,
3857
+ 0
3858
+ );
3859
+ var module2 = new WebAssembly.Module(new Uint8Array(bytes));
3860
+ var instance = new WebAssembly.Instance(module2, { "e": { "f": func } });
3861
+ var wrappedFunc = instance.exports["f"];
3862
+ return wrappedFunc;
3863
+ };
3864
+ var updateTableMap = (offset, count) => {
3865
+ if (functionsInTableMap) {
3866
+ for (var i = offset; i < offset + count; i++) {
3867
+ var item = getWasmTableEntry(i);
3868
+ if (item) {
3869
+ functionsInTableMap.set(item, i);
3870
+ }
3871
+ }
3872
+ }
3873
+ };
3874
+ var functionsInTableMap;
3875
+ var getFunctionAddress = (func) => {
3876
+ if (!functionsInTableMap) {
3877
+ functionsInTableMap = /* @__PURE__ */ new WeakMap();
3878
+ updateTableMap(0, wasmTable.length);
3879
+ }
3880
+ return functionsInTableMap.get(func) || 0;
3881
+ };
3882
+ var freeTableIndexes = [];
3883
+ var getEmptyTableSlot = () => {
3884
+ if (freeTableIndexes.length) {
3885
+ return freeTableIndexes.pop();
3886
+ }
3887
+ try {
3888
+ wasmTable.grow(1);
3889
+ } catch (err2) {
3890
+ if (!(err2 instanceof RangeError)) {
3891
+ throw err2;
3892
+ }
3893
+ throw "Unable to grow wasm table. Set ALLOW_TABLE_GROWTH.";
3894
+ }
3895
+ return wasmTable.length - 1;
3896
+ };
3897
+ var setWasmTableEntry = (idx, func) => {
3898
+ wasmTable.set(idx, func);
3899
+ wasmTableMirror[idx] = wasmTable.get(idx);
3900
+ };
3901
+ var addFunction = (func, sig) => {
3902
+ assert(typeof func != "undefined");
3903
+ var rtn = getFunctionAddress(func);
3904
+ if (rtn) {
3905
+ return rtn;
3906
+ }
3907
+ var ret = getEmptyTableSlot();
3908
+ try {
3909
+ setWasmTableEntry(ret, func);
3910
+ } catch (err2) {
3911
+ if (!(err2 instanceof TypeError)) {
3912
+ throw err2;
3913
+ }
3914
+ assert(typeof sig != "undefined", "Missing signature argument to addFunction: " + func);
3915
+ var wrapped = convertJsFunctionToWasm(func, sig);
3916
+ setWasmTableEntry(ret, wrapped);
3917
+ }
3918
+ functionsInTableMap.set(func, ret);
3919
+ return ret;
3920
+ };
3921
+ var removeFunction = (index) => {
3922
+ functionsInTableMap.delete(getWasmTableEntry(index));
3923
+ setWasmTableEntry(index, null);
3924
+ freeTableIndexes.push(index);
3925
+ };
3926
+ var UTF16Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf-16le") : void 0;
3927
+ ;
3928
+ var UTF16ToString = (ptr, maxBytesToRead) => {
3929
+ assert(ptr % 2 == 0, "Pointer passed to UTF16ToString must be aligned to two bytes!");
3930
+ var endPtr = ptr;
3931
+ var idx = endPtr >> 1;
3932
+ var maxIdx = idx + maxBytesToRead / 2;
3933
+ while (!(idx >= maxIdx) && HEAPU16[idx]) ++idx;
3934
+ endPtr = idx << 1;
3935
+ if (endPtr - ptr > 32 && UTF16Decoder)
3936
+ return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr));
3937
+ var str = "";
3938
+ for (var i = 0; !(i >= maxBytesToRead / 2); ++i) {
3939
+ var codeUnit = HEAP16[ptr + i * 2 >> 1];
3940
+ if (codeUnit == 0) break;
3941
+ str += String.fromCharCode(codeUnit);
3942
+ }
3943
+ return str;
3944
+ };
3945
+ var stringToUTF16 = (str, outPtr, maxBytesToWrite) => {
3946
+ assert(outPtr % 2 == 0, "Pointer passed to stringToUTF16 must be aligned to two bytes!");
3947
+ assert(typeof maxBytesToWrite == "number", "stringToUTF16(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!");
3948
+ maxBytesToWrite ?? (maxBytesToWrite = 2147483647);
3949
+ if (maxBytesToWrite < 2) return 0;
3950
+ maxBytesToWrite -= 2;
3951
+ var startPtr = outPtr;
3952
+ var numCharsToWrite = maxBytesToWrite < str.length * 2 ? maxBytesToWrite / 2 : str.length;
3953
+ for (var i = 0; i < numCharsToWrite; ++i) {
3954
+ var codeUnit = str.charCodeAt(i);
3955
+ HEAP16[outPtr >> 1] = codeUnit;
3956
+ outPtr += 2;
3957
+ }
3958
+ HEAP16[outPtr >> 1] = 0;
3959
+ return outPtr - startPtr;
3960
+ };
3961
+ FS.createPreloadedFile = FS_createPreloadedFile;
3962
+ FS.staticInit();
3963
+ ;
3964
+ function checkIncomingModuleAPI() {
3965
+ ignoredModuleProp("fetchSettings");
3966
+ }
3967
+ var wasmImports = {
3968
+ /** @export */
3969
+ __assert_fail: ___assert_fail,
3970
+ /** @export */
3971
+ __syscall_fcntl64: ___syscall_fcntl64,
3972
+ /** @export */
3973
+ __syscall_fstat64: ___syscall_fstat64,
3974
+ /** @export */
3975
+ __syscall_getdents64: ___syscall_getdents64,
3976
+ /** @export */
3977
+ __syscall_ioctl: ___syscall_ioctl,
3978
+ /** @export */
3979
+ __syscall_lstat64: ___syscall_lstat64,
3980
+ /** @export */
3981
+ __syscall_newfstatat: ___syscall_newfstatat,
3982
+ /** @export */
3983
+ __syscall_openat: ___syscall_openat,
3984
+ /** @export */
3985
+ __syscall_rmdir: ___syscall_rmdir,
3986
+ /** @export */
3987
+ __syscall_stat64: ___syscall_stat64,
3988
+ /** @export */
3989
+ __syscall_unlinkat: ___syscall_unlinkat,
3990
+ /** @export */
3991
+ _abort_js: __abort_js,
3992
+ /** @export */
3993
+ _emscripten_memcpy_js: __emscripten_memcpy_js,
3994
+ /** @export */
3995
+ _emscripten_throw_longjmp: __emscripten_throw_longjmp,
3996
+ /** @export */
3997
+ _gmtime_js: __gmtime_js,
3998
+ /** @export */
3999
+ _localtime_js: __localtime_js,
4000
+ /** @export */
4001
+ _tzset_js: __tzset_js,
4002
+ /** @export */
4003
+ emscripten_date_now: _emscripten_date_now,
4004
+ /** @export */
4005
+ emscripten_errn: _emscripten_errn,
4006
+ /** @export */
4007
+ emscripten_resize_heap: _emscripten_resize_heap,
4008
+ /** @export */
4009
+ environ_get: _environ_get,
4010
+ /** @export */
4011
+ environ_sizes_get: _environ_sizes_get,
4012
+ /** @export */
4013
+ fd_close: _fd_close,
4014
+ /** @export */
4015
+ fd_read: _fd_read,
4016
+ /** @export */
4017
+ fd_seek: _fd_seek,
4018
+ /** @export */
4019
+ fd_write: _fd_write,
4020
+ /** @export */
4021
+ invoke_ii,
4022
+ /** @export */
4023
+ invoke_iii,
4024
+ /** @export */
4025
+ invoke_iiii,
4026
+ /** @export */
4027
+ invoke_iiiii,
4028
+ /** @export */
4029
+ invoke_v,
4030
+ /** @export */
4031
+ invoke_vi,
4032
+ /** @export */
4033
+ invoke_viii,
4034
+ /** @export */
4035
+ invoke_viiii
4036
+ };
4037
+ var wasmExports = createWasm();
4038
+ var ___wasm_call_ctors = createExportWrapper("__wasm_call_ctors", 0);
4039
+ var _PDFiumExt_Init = Module["_PDFiumExt_Init"] = createExportWrapper("PDFiumExt_Init", 0);
4040
+ var _PDFiumExt_OpenFileWriter = Module["_PDFiumExt_OpenFileWriter"] = createExportWrapper("PDFiumExt_OpenFileWriter", 0);
4041
+ var _PDFiumExt_GetFileWriterSize = Module["_PDFiumExt_GetFileWriterSize"] = createExportWrapper("PDFiumExt_GetFileWriterSize", 1);
4042
+ var _PDFiumExt_GetFileWriterData = Module["_PDFiumExt_GetFileWriterData"] = createExportWrapper("PDFiumExt_GetFileWriterData", 3);
4043
+ var _PDFiumExt_CloseFileWriter = Module["_PDFiumExt_CloseFileWriter"] = createExportWrapper("PDFiumExt_CloseFileWriter", 1);
4044
+ var _PDFiumExt_SaveAsCopy = Module["_PDFiumExt_SaveAsCopy"] = createExportWrapper("PDFiumExt_SaveAsCopy", 2);
4045
+ var _PDFiumExt_OpenFormFillInfo = Module["_PDFiumExt_OpenFormFillInfo"] = createExportWrapper("PDFiumExt_OpenFormFillInfo", 0);
4046
+ var _PDFiumExt_CloseFormFillInfo = Module["_PDFiumExt_CloseFormFillInfo"] = createExportWrapper("PDFiumExt_CloseFormFillInfo", 1);
4047
+ var _PDFiumExt_InitFormFillEnvironment = Module["_PDFiumExt_InitFormFillEnvironment"] = createExportWrapper("PDFiumExt_InitFormFillEnvironment", 2);
4048
+ var _PDFiumExt_ExitFormFillEnvironment = Module["_PDFiumExt_ExitFormFillEnvironment"] = createExportWrapper("PDFiumExt_ExitFormFillEnvironment", 1);
4049
+ var _FPDFPage_CreateAnnot = Module["_FPDFPage_CreateAnnot"] = createExportWrapper("FPDFPage_CreateAnnot", 2);
4050
+ var _FPDFPage_GetAnnotCount = Module["_FPDFPage_GetAnnotCount"] = createExportWrapper("FPDFPage_GetAnnotCount", 1);
4051
+ var _FPDFPage_GetAnnot = Module["_FPDFPage_GetAnnot"] = createExportWrapper("FPDFPage_GetAnnot", 2);
4052
+ var _FPDFPage_CloseAnnot = Module["_FPDFPage_CloseAnnot"] = createExportWrapper("FPDFPage_CloseAnnot", 1);
4053
+ var _FPDFPage_RemoveAnnot = Module["_FPDFPage_RemoveAnnot"] = createExportWrapper("FPDFPage_RemoveAnnot", 2);
4054
+ var _FPDFAnnot_GetSubtype = Module["_FPDFAnnot_GetSubtype"] = createExportWrapper("FPDFAnnot_GetSubtype", 1);
4055
+ var _FPDFAnnot_AddInkStroke = Module["_FPDFAnnot_AddInkStroke"] = createExportWrapper("FPDFAnnot_AddInkStroke", 3);
4056
+ var _FPDFAnnot_RemoveInkList = Module["_FPDFAnnot_RemoveInkList"] = createExportWrapper("FPDFAnnot_RemoveInkList", 1);
4057
+ var _FPDFAnnot_AppendObject = Module["_FPDFAnnot_AppendObject"] = createExportWrapper("FPDFAnnot_AppendObject", 2);
4058
+ var _FPDFAnnot_GetObjectCount = Module["_FPDFAnnot_GetObjectCount"] = createExportWrapper("FPDFAnnot_GetObjectCount", 1);
4059
+ var _FPDFAnnot_GetObject = Module["_FPDFAnnot_GetObject"] = createExportWrapper("FPDFAnnot_GetObject", 2);
4060
+ var _FPDFAnnot_GetColor = Module["_FPDFAnnot_GetColor"] = createExportWrapper("FPDFAnnot_GetColor", 6);
4061
+ var _FPDFAnnot_SetRect = Module["_FPDFAnnot_SetRect"] = createExportWrapper("FPDFAnnot_SetRect", 2);
4062
+ var _FPDFAnnot_GetRect = Module["_FPDFAnnot_GetRect"] = createExportWrapper("FPDFAnnot_GetRect", 2);
4063
+ var _FPDFAnnot_GetVertices = Module["_FPDFAnnot_GetVertices"] = createExportWrapper("FPDFAnnot_GetVertices", 3);
4064
+ var _FPDFAnnot_GetInkListCount = Module["_FPDFAnnot_GetInkListCount"] = createExportWrapper("FPDFAnnot_GetInkListCount", 1);
4065
+ var _FPDFAnnot_GetInkListPath = Module["_FPDFAnnot_GetInkListPath"] = createExportWrapper("FPDFAnnot_GetInkListPath", 4);
4066
+ var _FPDFAnnot_GetLine = Module["_FPDFAnnot_GetLine"] = createExportWrapper("FPDFAnnot_GetLine", 3);
4067
+ var _FPDFAnnot_GetStringValue = Module["_FPDFAnnot_GetStringValue"] = createExportWrapper("FPDFAnnot_GetStringValue", 4);
4068
+ var _FPDFAnnot_GetAP = Module["_FPDFAnnot_GetAP"] = createExportWrapper("FPDFAnnot_GetAP", 4);
4069
+ var _FPDFAnnot_GetLinkedAnnot = Module["_FPDFAnnot_GetLinkedAnnot"] = createExportWrapper("FPDFAnnot_GetLinkedAnnot", 2);
4070
+ var _FPDFAnnot_GetFormFieldFlags = Module["_FPDFAnnot_GetFormFieldFlags"] = createExportWrapper("FPDFAnnot_GetFormFieldFlags", 2);
4071
+ var _FPDFAnnot_GetFormFieldName = Module["_FPDFAnnot_GetFormFieldName"] = createExportWrapper("FPDFAnnot_GetFormFieldName", 4);
4072
+ var _FPDFAnnot_GetFormFieldType = Module["_FPDFAnnot_GetFormFieldType"] = createExportWrapper("FPDFAnnot_GetFormFieldType", 2);
4073
+ var _FPDFAnnot_GetFormFieldAlternateName = Module["_FPDFAnnot_GetFormFieldAlternateName"] = createExportWrapper("FPDFAnnot_GetFormFieldAlternateName", 4);
4074
+ var _FPDFAnnot_GetFormFieldValue = Module["_FPDFAnnot_GetFormFieldValue"] = createExportWrapper("FPDFAnnot_GetFormFieldValue", 4);
4075
+ var _FPDFAnnot_GetOptionCount = Module["_FPDFAnnot_GetOptionCount"] = createExportWrapper("FPDFAnnot_GetOptionCount", 2);
4076
+ var _FPDFAnnot_GetOptionLabel = Module["_FPDFAnnot_GetOptionLabel"] = createExportWrapper("FPDFAnnot_GetOptionLabel", 5);
4077
+ var _FPDFAnnot_IsOptionSelected = Module["_FPDFAnnot_IsOptionSelected"] = createExportWrapper("FPDFAnnot_IsOptionSelected", 3);
4078
+ var _FPDFAnnot_IsChecked = Module["_FPDFAnnot_IsChecked"] = createExportWrapper("FPDFAnnot_IsChecked", 2);
4079
+ var _FPDFAnnot_SetFocusableSubtypes = Module["_FPDFAnnot_SetFocusableSubtypes"] = createExportWrapper("FPDFAnnot_SetFocusableSubtypes", 3);
4080
+ var _FPDFAnnot_GetFocusableSubtypesCount = Module["_FPDFAnnot_GetFocusableSubtypesCount"] = createExportWrapper("FPDFAnnot_GetFocusableSubtypesCount", 1);
4081
+ var _FPDFAnnot_GetFocusableSubtypes = Module["_FPDFAnnot_GetFocusableSubtypes"] = createExportWrapper("FPDFAnnot_GetFocusableSubtypes", 3);
4082
+ var _FPDFAnnot_GetLink = Module["_FPDFAnnot_GetLink"] = createExportWrapper("FPDFAnnot_GetLink", 1);
4083
+ var _FPDFDoc_GetAttachmentCount = Module["_FPDFDoc_GetAttachmentCount"] = createExportWrapper("FPDFDoc_GetAttachmentCount", 1);
4084
+ var _FPDFDoc_GetAttachment = Module["_FPDFDoc_GetAttachment"] = createExportWrapper("FPDFDoc_GetAttachment", 2);
4085
+ var _FPDFAttachment_GetName = Module["_FPDFAttachment_GetName"] = createExportWrapper("FPDFAttachment_GetName", 3);
4086
+ var _FPDFAttachment_GetStringValue = Module["_FPDFAttachment_GetStringValue"] = createExportWrapper("FPDFAttachment_GetStringValue", 4);
4087
+ var _FPDFAttachment_GetFile = Module["_FPDFAttachment_GetFile"] = createExportWrapper("FPDFAttachment_GetFile", 4);
4088
+ var _FPDFBookmark_GetFirstChild = Module["_FPDFBookmark_GetFirstChild"] = createExportWrapper("FPDFBookmark_GetFirstChild", 2);
4089
+ var _FPDFBookmark_GetNextSibling = Module["_FPDFBookmark_GetNextSibling"] = createExportWrapper("FPDFBookmark_GetNextSibling", 2);
4090
+ var _FPDFBookmark_GetTitle = Module["_FPDFBookmark_GetTitle"] = createExportWrapper("FPDFBookmark_GetTitle", 3);
4091
+ var _FPDFBookmark_Find = Module["_FPDFBookmark_Find"] = createExportWrapper("FPDFBookmark_Find", 2);
4092
+ var _FPDFBookmark_GetDest = Module["_FPDFBookmark_GetDest"] = createExportWrapper("FPDFBookmark_GetDest", 2);
4093
+ var _FPDFBookmark_GetAction = Module["_FPDFBookmark_GetAction"] = createExportWrapper("FPDFBookmark_GetAction", 1);
4094
+ var _FPDFAction_GetType = Module["_FPDFAction_GetType"] = createExportWrapper("FPDFAction_GetType", 1);
4095
+ var _FPDFAction_GetDest = Module["_FPDFAction_GetDest"] = createExportWrapper("FPDFAction_GetDest", 2);
4096
+ var _FPDFAction_GetFilePath = Module["_FPDFAction_GetFilePath"] = createExportWrapper("FPDFAction_GetFilePath", 3);
4097
+ var _FPDFAction_GetURIPath = Module["_FPDFAction_GetURIPath"] = createExportWrapper("FPDFAction_GetURIPath", 4);
4098
+ var _FPDFDest_GetDestPageIndex = Module["_FPDFDest_GetDestPageIndex"] = createExportWrapper("FPDFDest_GetDestPageIndex", 2);
4099
+ var _FPDFDest_GetView = Module["_FPDFDest_GetView"] = createExportWrapper("FPDFDest_GetView", 3);
4100
+ var _FPDFDest_GetLocationInPage = Module["_FPDFDest_GetLocationInPage"] = createExportWrapper("FPDFDest_GetLocationInPage", 7);
4101
+ var _FPDFLink_GetDest = Module["_FPDFLink_GetDest"] = createExportWrapper("FPDFLink_GetDest", 2);
4102
+ var _FPDFLink_GetAction = Module["_FPDFLink_GetAction"] = createExportWrapper("FPDFLink_GetAction", 1);
4103
+ var _FPDF_GetMetaText = Module["_FPDF_GetMetaText"] = createExportWrapper("FPDF_GetMetaText", 4);
4104
+ var _FPDFPageObj_NewImageObj = Module["_FPDFPageObj_NewImageObj"] = createExportWrapper("FPDFPageObj_NewImageObj", 1);
4105
+ var _FPDFImageObj_SetBitmap = Module["_FPDFImageObj_SetBitmap"] = createExportWrapper("FPDFImageObj_SetBitmap", 4);
4106
+ var _FPDFImageObj_GetBitmap = Module["_FPDFImageObj_GetBitmap"] = createExportWrapper("FPDFImageObj_GetBitmap", 1);
4107
+ var _FPDF_CreateNewDocument = Module["_FPDF_CreateNewDocument"] = createExportWrapper("FPDF_CreateNewDocument", 0);
4108
+ var _FPDFPage_InsertObject = Module["_FPDFPage_InsertObject"] = createExportWrapper("FPDFPage_InsertObject", 2);
4109
+ var _FPDFPageObj_Destroy = Module["_FPDFPageObj_Destroy"] = createExportWrapper("FPDFPageObj_Destroy", 1);
4110
+ var _FPDFPageObj_GetType = Module["_FPDFPageObj_GetType"] = createExportWrapper("FPDFPageObj_GetType", 1);
4111
+ var _FPDFPage_GenerateContent = Module["_FPDFPage_GenerateContent"] = createExportWrapper("FPDFPage_GenerateContent", 1);
4112
+ var _FPDFPageObj_Transform = Module["_FPDFPageObj_Transform"] = createExportWrapper("FPDFPageObj_Transform", 7);
4113
+ var _FPDFPageObj_GetMatrix = Module["_FPDFPageObj_GetMatrix"] = createExportWrapper("FPDFPageObj_GetMatrix", 2);
4114
+ var _FPDFPageObj_SetMatrix = Module["_FPDFPageObj_SetMatrix"] = createExportWrapper("FPDFPageObj_SetMatrix", 2);
4115
+ var _FPDFPageObj_GetBounds = Module["_FPDFPageObj_GetBounds"] = createExportWrapper("FPDFPageObj_GetBounds", 5);
4116
+ var _FPDFFormObj_CountObjects = Module["_FPDFFormObj_CountObjects"] = createExportWrapper("FPDFFormObj_CountObjects", 1);
4117
+ var _FPDFFormObj_GetObject = Module["_FPDFFormObj_GetObject"] = createExportWrapper("FPDFFormObj_GetObject", 2);
4118
+ var _FPDFPath_CountSegments = Module["_FPDFPath_CountSegments"] = createExportWrapper("FPDFPath_CountSegments", 1);
4119
+ var _FPDFPath_GetPathSegment = Module["_FPDFPath_GetPathSegment"] = createExportWrapper("FPDFPath_GetPathSegment", 2);
4120
+ var _FPDFPathSegment_GetPoint = Module["_FPDFPathSegment_GetPoint"] = createExportWrapper("FPDFPathSegment_GetPoint", 3);
4121
+ var _FPDFPathSegment_GetType = Module["_FPDFPathSegment_GetType"] = createExportWrapper("FPDFPathSegment_GetType", 1);
4122
+ var _FPDFPathSegment_GetClose = Module["_FPDFPathSegment_GetClose"] = createExportWrapper("FPDFPathSegment_GetClose", 1);
4123
+ var _FPDFPage_Flatten = Module["_FPDFPage_Flatten"] = createExportWrapper("FPDFPage_Flatten", 2);
4124
+ var _malloc = Module["_malloc"] = createExportWrapper("malloc", 1);
4125
+ var _free = Module["_free"] = createExportWrapper("free", 1);
4126
+ var _FORM_OnKeyDown = Module["_FORM_OnKeyDown"] = createExportWrapper("FORM_OnKeyDown", 4);
4127
+ var _FORM_OnKeyUp = Module["_FORM_OnKeyUp"] = createExportWrapper("FORM_OnKeyUp", 4);
4128
+ var _FORM_OnChar = Module["_FORM_OnChar"] = createExportWrapper("FORM_OnChar", 4);
4129
+ var _FORM_ReplaceSelection = Module["_FORM_ReplaceSelection"] = createExportWrapper("FORM_ReplaceSelection", 3);
4130
+ var _FORM_SelectAllText = Module["_FORM_SelectAllText"] = createExportWrapper("FORM_SelectAllText", 2);
4131
+ var _FORM_ForceToKillFocus = Module["_FORM_ForceToKillFocus"] = createExportWrapper("FORM_ForceToKillFocus", 1);
4132
+ var _FORM_SetFocusedAnnot = Module["_FORM_SetFocusedAnnot"] = createExportWrapper("FORM_SetFocusedAnnot", 2);
4133
+ var _FORM_OnAfterLoadPage = Module["_FORM_OnAfterLoadPage"] = createExportWrapper("FORM_OnAfterLoadPage", 2);
4134
+ var _FORM_OnBeforeClosePage = Module["_FORM_OnBeforeClosePage"] = createExportWrapper("FORM_OnBeforeClosePage", 2);
4135
+ var _FORM_SetIndexSelected = Module["_FORM_SetIndexSelected"] = createExportWrapper("FORM_SetIndexSelected", 4);
4136
+ var _FPDF_ImportPagesByIndex = Module["_FPDF_ImportPagesByIndex"] = createExportWrapper("FPDF_ImportPagesByIndex", 5);
4137
+ var _FPDF_ImportPages = Module["_FPDF_ImportPages"] = createExportWrapper("FPDF_ImportPages", 4);
4138
+ var _FPDF_GetSignatureCount = Module["_FPDF_GetSignatureCount"] = createExportWrapper("FPDF_GetSignatureCount", 1);
4139
+ var _FPDF_GetSignatureObject = Module["_FPDF_GetSignatureObject"] = createExportWrapper("FPDF_GetSignatureObject", 2);
4140
+ var _FPDFSignatureObj_GetContents = Module["_FPDFSignatureObj_GetContents"] = createExportWrapper("FPDFSignatureObj_GetContents", 3);
4141
+ var _FPDFSignatureObj_GetByteRange = Module["_FPDFSignatureObj_GetByteRange"] = createExportWrapper("FPDFSignatureObj_GetByteRange", 3);
4142
+ var _FPDFSignatureObj_GetSubFilter = Module["_FPDFSignatureObj_GetSubFilter"] = createExportWrapper("FPDFSignatureObj_GetSubFilter", 3);
4143
+ var _FPDFSignatureObj_GetReason = Module["_FPDFSignatureObj_GetReason"] = createExportWrapper("FPDFSignatureObj_GetReason", 3);
4144
+ var _FPDFSignatureObj_GetTime = Module["_FPDFSignatureObj_GetTime"] = createExportWrapper("FPDFSignatureObj_GetTime", 3);
4145
+ var _FPDFSignatureObj_GetDocMDPPermission = Module["_FPDFSignatureObj_GetDocMDPPermission"] = createExportWrapper("FPDFSignatureObj_GetDocMDPPermission", 1);
4146
+ var _FPDFText_LoadPage = Module["_FPDFText_LoadPage"] = createExportWrapper("FPDFText_LoadPage", 1);
4147
+ var _FPDFText_ClosePage = Module["_FPDFText_ClosePage"] = createExportWrapper("FPDFText_ClosePage", 1);
4148
+ var _FPDFText_CountChars = Module["_FPDFText_CountChars"] = createExportWrapper("FPDFText_CountChars", 1);
4149
+ var _FPDFText_GetFontSize = Module["_FPDFText_GetFontSize"] = createExportWrapper("FPDFText_GetFontSize", 2);
4150
+ var _FPDFText_GetFontInfo = Module["_FPDFText_GetFontInfo"] = createExportWrapper("FPDFText_GetFontInfo", 5);
4151
+ var _FPDFText_GetCharBox = Module["_FPDFText_GetCharBox"] = createExportWrapper("FPDFText_GetCharBox", 6);
4152
+ var _FPDFText_GetCharIndexAtPos = Module["_FPDFText_GetCharIndexAtPos"] = createExportWrapper("FPDFText_GetCharIndexAtPos", 5);
4153
+ var _FPDFText_GetText = Module["_FPDFText_GetText"] = createExportWrapper("FPDFText_GetText", 4);
4154
+ var _FPDFText_CountRects = Module["_FPDFText_CountRects"] = createExportWrapper("FPDFText_CountRects", 3);
4155
+ var _FPDFText_GetRect = Module["_FPDFText_GetRect"] = createExportWrapper("FPDFText_GetRect", 6);
4156
+ var _FPDFText_GetBoundedText = Module["_FPDFText_GetBoundedText"] = createExportWrapper("FPDFText_GetBoundedText", 7);
4157
+ var _FPDFText_FindStart = Module["_FPDFText_FindStart"] = createExportWrapper("FPDFText_FindStart", 4);
4158
+ var _FPDFText_FindNext = Module["_FPDFText_FindNext"] = createExportWrapper("FPDFText_FindNext", 1);
4159
+ var _FPDFText_FindPrev = Module["_FPDFText_FindPrev"] = createExportWrapper("FPDFText_FindPrev", 1);
4160
+ var _FPDFText_GetSchResultIndex = Module["_FPDFText_GetSchResultIndex"] = createExportWrapper("FPDFText_GetSchResultIndex", 1);
4161
+ var _FPDFText_GetSchCount = Module["_FPDFText_GetSchCount"] = createExportWrapper("FPDFText_GetSchCount", 1);
4162
+ var _FPDFText_FindClose = Module["_FPDFText_FindClose"] = createExportWrapper("FPDFText_FindClose", 1);
4163
+ var _FPDF_DestroyLibrary = Module["_FPDF_DestroyLibrary"] = createExportWrapper("FPDF_DestroyLibrary", 0);
4164
+ var _FPDF_LoadMemDocument = Module["_FPDF_LoadMemDocument"] = createExportWrapper("FPDF_LoadMemDocument", 3);
4165
+ var _FPDF_LoadCustomDocument = Module["_FPDF_LoadCustomDocument"] = createExportWrapper("FPDF_LoadCustomDocument", 2);
4166
+ var _FPDF_GetDocPermissions = Module["_FPDF_GetDocPermissions"] = createExportWrapper("FPDF_GetDocPermissions", 1);
4167
+ var _FPDF_GetDocUserPermissions = Module["_FPDF_GetDocUserPermissions"] = createExportWrapper("FPDF_GetDocUserPermissions", 1);
4168
+ var _FPDF_GetPageCount = Module["_FPDF_GetPageCount"] = createExportWrapper("FPDF_GetPageCount", 1);
4169
+ var _FPDF_LoadPage = Module["_FPDF_LoadPage"] = createExportWrapper("FPDF_LoadPage", 2);
4170
+ var _FPDF_GetPageWidthF = Module["_FPDF_GetPageWidthF"] = createExportWrapper("FPDF_GetPageWidthF", 1);
4171
+ var _FPDF_GetPageHeightF = Module["_FPDF_GetPageHeightF"] = createExportWrapper("FPDF_GetPageHeightF", 1);
4172
+ var _FPDF_RenderPageBitmap = Module["_FPDF_RenderPageBitmap"] = createExportWrapper("FPDF_RenderPageBitmap", 8);
4173
+ var _FPDF_ClosePage = Module["_FPDF_ClosePage"] = createExportWrapper("FPDF_ClosePage", 1);
4174
+ var _FPDF_CloseDocument = Module["_FPDF_CloseDocument"] = createExportWrapper("FPDF_CloseDocument", 1);
4175
+ var _FPDF_GetLastError = Module["_FPDF_GetLastError"] = createExportWrapper("FPDF_GetLastError", 0);
4176
+ var _FPDF_DeviceToPage = Module["_FPDF_DeviceToPage"] = createExportWrapper("FPDF_DeviceToPage", 10);
4177
+ var _FPDF_PageToDevice = Module["_FPDF_PageToDevice"] = createExportWrapper("FPDF_PageToDevice", 10);
4178
+ var _FPDFBitmap_Create = Module["_FPDFBitmap_Create"] = createExportWrapper("FPDFBitmap_Create", 3);
4179
+ var _FPDFBitmap_CreateEx = Module["_FPDFBitmap_CreateEx"] = createExportWrapper("FPDFBitmap_CreateEx", 5);
4180
+ var _FPDFBitmap_GetFormat = Module["_FPDFBitmap_GetFormat"] = createExportWrapper("FPDFBitmap_GetFormat", 1);
4181
+ var _FPDFBitmap_FillRect = Module["_FPDFBitmap_FillRect"] = createExportWrapper("FPDFBitmap_FillRect", 6);
4182
+ var _FPDFBitmap_GetBuffer = Module["_FPDFBitmap_GetBuffer"] = createExportWrapper("FPDFBitmap_GetBuffer", 1);
4183
+ var _FPDFBitmap_GetWidth = Module["_FPDFBitmap_GetWidth"] = createExportWrapper("FPDFBitmap_GetWidth", 1);
4184
+ var _FPDFBitmap_GetHeight = Module["_FPDFBitmap_GetHeight"] = createExportWrapper("FPDFBitmap_GetHeight", 1);
4185
+ var _FPDFBitmap_Destroy = Module["_FPDFBitmap_Destroy"] = createExportWrapper("FPDFBitmap_Destroy", 1);
4186
+ var _FPDF_GetPageSizeByIndexF = Module["_FPDF_GetPageSizeByIndexF"] = createExportWrapper("FPDF_GetPageSizeByIndexF", 3);
4187
+ var _fflush = createExportWrapper("fflush", 1);
4188
+ var _strerror = createExportWrapper("strerror", 1);
4189
+ var _setThrew = createExportWrapper("setThrew", 2);
4190
+ var __emscripten_tempret_set = createExportWrapper("_emscripten_tempret_set", 1);
4191
+ var _emscripten_stack_init = () => (_emscripten_stack_init = wasmExports["emscripten_stack_init"])();
4192
+ var _emscripten_stack_get_free = () => (_emscripten_stack_get_free = wasmExports["emscripten_stack_get_free"])();
4193
+ var _emscripten_stack_get_base = () => (_emscripten_stack_get_base = wasmExports["emscripten_stack_get_base"])();
4194
+ var _emscripten_stack_get_end = () => (_emscripten_stack_get_end = wasmExports["emscripten_stack_get_end"])();
4195
+ var __emscripten_stack_restore = (a0) => (__emscripten_stack_restore = wasmExports["_emscripten_stack_restore"])(a0);
4196
+ var __emscripten_stack_alloc = (a0) => (__emscripten_stack_alloc = wasmExports["_emscripten_stack_alloc"])(a0);
4197
+ var _emscripten_stack_get_current = () => (_emscripten_stack_get_current = wasmExports["emscripten_stack_get_current"])();
4198
+ var dynCall_j = Module["dynCall_j"] = createExportWrapper("dynCall_j", 1);
4199
+ var dynCall_ji = Module["dynCall_ji"] = createExportWrapper("dynCall_ji", 2);
4200
+ var dynCall_iiij = Module["dynCall_iiij"] = createExportWrapper("dynCall_iiij", 5);
4201
+ var dynCall_jji = Module["dynCall_jji"] = createExportWrapper("dynCall_jji", 4);
4202
+ var dynCall_iji = Module["dynCall_iji"] = createExportWrapper("dynCall_iji", 4);
4203
+ var dynCall_viijii = Module["dynCall_viijii"] = createExportWrapper("dynCall_viijii", 7);
4204
+ var dynCall_iiji = Module["dynCall_iiji"] = createExportWrapper("dynCall_iiji", 5);
4205
+ var dynCall_jiji = Module["dynCall_jiji"] = createExportWrapper("dynCall_jiji", 5);
4206
+ var dynCall_iiiiij = Module["dynCall_iiiiij"] = createExportWrapper("dynCall_iiiiij", 7);
4207
+ var dynCall_iiiiijj = Module["dynCall_iiiiijj"] = createExportWrapper("dynCall_iiiiijj", 9);
4208
+ var dynCall_iiiiiijj = Module["dynCall_iiiiiijj"] = createExportWrapper("dynCall_iiiiiijj", 10);
4209
+ function invoke_viii(index, a1, a2, a3) {
4210
+ var sp = stackSave();
4211
+ try {
4212
+ getWasmTableEntry(index)(a1, a2, a3);
4213
+ } catch (e) {
4214
+ stackRestore(sp);
4215
+ if (e !== e + 0) throw e;
4216
+ _setThrew(1, 0);
4217
+ }
4218
+ }
4219
+ function invoke_iii(index, a1, a2) {
4220
+ var sp = stackSave();
4221
+ try {
4222
+ return getWasmTableEntry(index)(a1, a2);
4223
+ } catch (e) {
4224
+ stackRestore(sp);
4225
+ if (e !== e + 0) throw e;
4226
+ _setThrew(1, 0);
4227
+ }
4228
+ }
4229
+ function invoke_vi(index, a1) {
4230
+ var sp = stackSave();
4231
+ try {
4232
+ getWasmTableEntry(index)(a1);
4233
+ } catch (e) {
4234
+ stackRestore(sp);
4235
+ if (e !== e + 0) throw e;
4236
+ _setThrew(1, 0);
4237
+ }
4238
+ }
4239
+ function invoke_ii(index, a1) {
4240
+ var sp = stackSave();
4241
+ try {
4242
+ return getWasmTableEntry(index)(a1);
4243
+ } catch (e) {
4244
+ stackRestore(sp);
4245
+ if (e !== e + 0) throw e;
4246
+ _setThrew(1, 0);
4247
+ }
4248
+ }
4249
+ function invoke_iiii(index, a1, a2, a3) {
4250
+ var sp = stackSave();
4251
+ try {
4252
+ return getWasmTableEntry(index)(a1, a2, a3);
4253
+ } catch (e) {
4254
+ stackRestore(sp);
4255
+ if (e !== e + 0) throw e;
4256
+ _setThrew(1, 0);
4257
+ }
4258
+ }
4259
+ function invoke_viiii(index, a1, a2, a3, a4) {
4260
+ var sp = stackSave();
4261
+ try {
4262
+ getWasmTableEntry(index)(a1, a2, a3, a4);
4263
+ } catch (e) {
4264
+ stackRestore(sp);
4265
+ if (e !== e + 0) throw e;
4266
+ _setThrew(1, 0);
4267
+ }
4268
+ }
4269
+ function invoke_iiiii(index, a1, a2, a3, a4) {
4270
+ var sp = stackSave();
4271
+ try {
4272
+ return getWasmTableEntry(index)(a1, a2, a3, a4);
4273
+ } catch (e) {
4274
+ stackRestore(sp);
4275
+ if (e !== e + 0) throw e;
4276
+ _setThrew(1, 0);
4277
+ }
4278
+ }
4279
+ function invoke_v(index) {
4280
+ var sp = stackSave();
4281
+ try {
4282
+ getWasmTableEntry(index)();
4283
+ } catch (e) {
4284
+ stackRestore(sp);
4285
+ if (e !== e + 0) throw e;
4286
+ _setThrew(1, 0);
4287
+ }
4288
+ }
4289
+ Module["wasmExports"] = wasmExports;
4290
+ Module["ccall"] = ccall;
4291
+ Module["cwrap"] = cwrap;
4292
+ Module["addFunction"] = addFunction;
4293
+ Module["removeFunction"] = removeFunction;
4294
+ Module["setValue"] = setValue;
4295
+ Module["getValue"] = getValue;
4296
+ Module["UTF8ToString"] = UTF8ToString;
4297
+ Module["stringToUTF8"] = stringToUTF8;
4298
+ Module["UTF16ToString"] = UTF16ToString;
4299
+ Module["stringToUTF16"] = stringToUTF16;
4300
+ var missingLibrarySymbols = [
4301
+ "writeI53ToI64",
4302
+ "writeI53ToI64Clamped",
4303
+ "writeI53ToI64Signaling",
4304
+ "writeI53ToU64Clamped",
4305
+ "writeI53ToU64Signaling",
4306
+ "readI53FromI64",
4307
+ "readI53FromU64",
4308
+ "convertI32PairToI53",
4309
+ "convertU32PairToI53",
4310
+ "getTempRet0",
4311
+ "setTempRet0",
4312
+ "exitJS",
4313
+ "inetPton4",
4314
+ "inetNtop4",
4315
+ "inetPton6",
4316
+ "inetNtop6",
4317
+ "readSockaddr",
4318
+ "writeSockaddr",
4319
+ "emscriptenLog",
4320
+ "readEmAsmArgs",
4321
+ "jstoi_q",
4322
+ "listenOnce",
4323
+ "autoResumeAudioContext",
4324
+ "dynCallLegacy",
4325
+ "getDynCaller",
4326
+ "dynCall",
4327
+ "handleException",
4328
+ "keepRuntimeAlive",
4329
+ "runtimeKeepalivePush",
4330
+ "runtimeKeepalivePop",
4331
+ "callUserCallback",
4332
+ "maybeExit",
4333
+ "asmjsMangle",
4334
+ "HandleAllocator",
4335
+ "getNativeTypeSize",
4336
+ "STACK_SIZE",
4337
+ "STACK_ALIGN",
4338
+ "POINTER_SIZE",
4339
+ "ASSERTIONS",
4340
+ "reallyNegative",
4341
+ "unSign",
4342
+ "strLen",
4343
+ "reSign",
4344
+ "formatString",
4345
+ "intArrayToString",
4346
+ "AsciiToString",
4347
+ "lengthBytesUTF16",
4348
+ "UTF32ToString",
4349
+ "stringToUTF32",
4350
+ "lengthBytesUTF32",
4351
+ "stringToNewUTF8",
4352
+ "registerKeyEventCallback",
4353
+ "maybeCStringToJsString",
4354
+ "findEventTarget",
4355
+ "getBoundingClientRect",
4356
+ "fillMouseEventData",
4357
+ "registerMouseEventCallback",
4358
+ "registerWheelEventCallback",
4359
+ "registerUiEventCallback",
4360
+ "registerFocusEventCallback",
4361
+ "fillDeviceOrientationEventData",
4362
+ "registerDeviceOrientationEventCallback",
4363
+ "fillDeviceMotionEventData",
4364
+ "registerDeviceMotionEventCallback",
4365
+ "screenOrientation",
4366
+ "fillOrientationChangeEventData",
4367
+ "registerOrientationChangeEventCallback",
4368
+ "fillFullscreenChangeEventData",
4369
+ "registerFullscreenChangeEventCallback",
4370
+ "JSEvents_requestFullscreen",
4371
+ "JSEvents_resizeCanvasForFullscreen",
4372
+ "registerRestoreOldStyle",
4373
+ "hideEverythingExceptGivenElement",
4374
+ "restoreHiddenElements",
4375
+ "setLetterbox",
4376
+ "softFullscreenResizeWebGLRenderTarget",
4377
+ "doRequestFullscreen",
4378
+ "fillPointerlockChangeEventData",
4379
+ "registerPointerlockChangeEventCallback",
4380
+ "registerPointerlockErrorEventCallback",
4381
+ "requestPointerLock",
4382
+ "fillVisibilityChangeEventData",
4383
+ "registerVisibilityChangeEventCallback",
4384
+ "registerTouchEventCallback",
4385
+ "fillGamepadEventData",
4386
+ "registerGamepadEventCallback",
4387
+ "registerBeforeUnloadEventCallback",
4388
+ "fillBatteryEventData",
4389
+ "battery",
4390
+ "registerBatteryEventCallback",
4391
+ "setCanvasElementSize",
4392
+ "getCanvasElementSize",
4393
+ "jsStackTrace",
4394
+ "getCallstack",
4395
+ "convertPCtoSourceLocation",
4396
+ "checkWasiClock",
4397
+ "wasiRightsToMuslOFlags",
4398
+ "wasiOFlagsToMuslOFlags",
4399
+ "createDyncallWrapper",
4400
+ "safeSetTimeout",
4401
+ "setImmediateWrapped",
4402
+ "clearImmediateWrapped",
4403
+ "polyfillSetImmediate",
4404
+ "registerPostMainLoop",
4405
+ "registerPreMainLoop",
4406
+ "getPromise",
4407
+ "makePromise",
4408
+ "idsToPromises",
4409
+ "makePromiseCallback",
4410
+ "ExceptionInfo",
4411
+ "findMatchingCatch",
4412
+ "Browser_asyncPrepareDataCounter",
4413
+ "safeRequestAnimationFrame",
4414
+ "arraySum",
4415
+ "addDays",
4416
+ "getSocketFromFD",
4417
+ "getSocketAddress",
4418
+ "FS_unlink",
4419
+ "FS_mkdirTree",
4420
+ "_setNetworkCallback",
4421
+ "heapObjectForWebGLType",
4422
+ "toTypedArrayIndex",
4423
+ "webgl_enable_ANGLE_instanced_arrays",
4424
+ "webgl_enable_OES_vertex_array_object",
4425
+ "webgl_enable_WEBGL_draw_buffers",
4426
+ "webgl_enable_WEBGL_multi_draw",
4427
+ "webgl_enable_EXT_polygon_offset_clamp",
4428
+ "webgl_enable_EXT_clip_control",
4429
+ "webgl_enable_WEBGL_polygon_mode",
4430
+ "emscriptenWebGLGet",
4431
+ "computeUnpackAlignedImageSize",
4432
+ "colorChannelsInGlTextureFormat",
4433
+ "emscriptenWebGLGetTexPixelData",
4434
+ "emscriptenWebGLGetUniform",
4435
+ "webglGetUniformLocation",
4436
+ "webglPrepareUniformLocationsBeforeFirstUse",
4437
+ "webglGetLeftBracePos",
4438
+ "emscriptenWebGLGetVertexAttrib",
4439
+ "__glGetActiveAttribOrUniform",
4440
+ "writeGLArray",
4441
+ "registerWebGlEventCallback",
4442
+ "runAndAbortIfError",
4443
+ "ALLOC_NORMAL",
4444
+ "ALLOC_STACK",
4445
+ "allocate",
4446
+ "writeStringToMemory",
4447
+ "writeAsciiToMemory",
4448
+ "setErrNo",
4449
+ "demangle",
4450
+ "stackTrace"
4451
+ ];
4452
+ missingLibrarySymbols.forEach(missingLibrarySymbol);
4453
+ var unexportedSymbols = [
4454
+ "run",
4455
+ "addOnPreRun",
4456
+ "addOnInit",
4457
+ "addOnPreMain",
4458
+ "addOnExit",
4459
+ "addOnPostRun",
4460
+ "addRunDependency",
4461
+ "removeRunDependency",
4462
+ "out",
4463
+ "err",
4464
+ "callMain",
4465
+ "abort",
4466
+ "wasmMemory",
4467
+ "writeStackCookie",
4468
+ "checkStackCookie",
4469
+ "convertI32PairToI53Checked",
4470
+ "stackSave",
4471
+ "stackRestore",
4472
+ "stackAlloc",
4473
+ "ptrToString",
4474
+ "zeroMemory",
4475
+ "getHeapMax",
4476
+ "growMemory",
4477
+ "ENV",
4478
+ "ERRNO_CODES",
4479
+ "strError",
4480
+ "DNS",
4481
+ "Protocols",
4482
+ "Sockets",
4483
+ "initRandomFill",
4484
+ "randomFill",
4485
+ "timers",
4486
+ "warnOnce",
4487
+ "readEmAsmArgsArray",
4488
+ "jstoi_s",
4489
+ "getExecutableName",
4490
+ "asyncLoad",
4491
+ "alignMemory",
4492
+ "mmapAlloc",
4493
+ "wasmTable",
4494
+ "noExitRuntime",
4495
+ "getCFunc",
4496
+ "uleb128Encode",
4497
+ "sigToWasmTypes",
4498
+ "generateFuncType",
4499
+ "convertJsFunctionToWasm",
4500
+ "freeTableIndexes",
4501
+ "functionsInTableMap",
4502
+ "getEmptyTableSlot",
4503
+ "updateTableMap",
4504
+ "getFunctionAddress",
4505
+ "PATH",
4506
+ "PATH_FS",
4507
+ "UTF8Decoder",
4508
+ "UTF8ArrayToString",
4509
+ "stringToUTF8Array",
4510
+ "lengthBytesUTF8",
4511
+ "intArrayFromString",
4512
+ "stringToAscii",
4513
+ "UTF16Decoder",
4514
+ "stringToUTF8OnStack",
4515
+ "writeArrayToMemory",
4516
+ "JSEvents",
4517
+ "specialHTMLTargets",
4518
+ "findCanvasEventTarget",
4519
+ "currentFullscreenStrategy",
4520
+ "restoreOldWindowedStyle",
4521
+ "UNWIND_CACHE",
4522
+ "ExitStatus",
4523
+ "getEnvStrings",
4524
+ "doReadv",
4525
+ "doWritev",
4526
+ "promiseMap",
4527
+ "uncaughtExceptionCount",
4528
+ "exceptionLast",
4529
+ "exceptionCaught",
4530
+ "Browser",
4531
+ "getPreloadedImageData__data",
4532
+ "wget",
4533
+ "MONTH_DAYS_REGULAR",
4534
+ "MONTH_DAYS_LEAP",
4535
+ "MONTH_DAYS_REGULAR_CUMULATIVE",
4536
+ "MONTH_DAYS_LEAP_CUMULATIVE",
4537
+ "isLeapYear",
4538
+ "ydayFromDate",
4539
+ "SYSCALLS",
4540
+ "preloadPlugins",
4541
+ "FS_createPreloadedFile",
4542
+ "FS_modeStringToFlags",
4543
+ "FS_getMode",
4544
+ "FS_stdin_getChar_buffer",
4545
+ "FS_stdin_getChar",
4546
+ "FS_createPath",
4547
+ "FS_createDevice",
4548
+ "FS_readFile",
4549
+ "FS",
4550
+ "FS_createDataFile",
4551
+ "FS_createLazyFile",
4552
+ "MEMFS",
4553
+ "TTY",
4554
+ "PIPEFS",
4555
+ "SOCKFS",
4556
+ "tempFixedLengthArray",
4557
+ "miniTempWebGLFloatBuffers",
4558
+ "miniTempWebGLIntBuffers",
4559
+ "GL",
4560
+ "AL",
4561
+ "GLUT",
4562
+ "EGL",
4563
+ "GLEW",
4564
+ "IDBStore",
4565
+ "SDL",
4566
+ "SDL_gfx",
4567
+ "allocateUTF8",
4568
+ "allocateUTF8OnStack",
4569
+ "print",
4570
+ "printErr"
4571
+ ];
4572
+ unexportedSymbols.forEach(unexportedRuntimeSymbol);
4573
+ var calledRun;
4574
+ var calledPrerun;
4575
+ dependenciesFulfilled = function runCaller() {
4576
+ if (!calledRun) run();
4577
+ if (!calledRun) dependenciesFulfilled = runCaller;
4578
+ };
4579
+ function stackCheckInit() {
4580
+ _emscripten_stack_init();
4581
+ writeStackCookie();
4582
+ }
4583
+ function run() {
4584
+ if (runDependencies > 0) {
4585
+ return;
4586
+ }
4587
+ stackCheckInit();
4588
+ if (!calledPrerun) {
4589
+ calledPrerun = 1;
4590
+ preRun();
4591
+ if (runDependencies > 0) {
4592
+ return;
4593
+ }
4594
+ }
4595
+ function doRun() {
4596
+ if (calledRun) return;
4597
+ calledRun = 1;
4598
+ Module["calledRun"] = 1;
4599
+ if (ABORT) return;
4600
+ initRuntime();
4601
+ readyPromiseResolve(Module);
4602
+ Module["onRuntimeInitialized"]?.();
4603
+ assert(!Module["_main"], 'compiled without a main, but one is present. if you added it from JS, use Module["onRuntimeInitialized"]');
4604
+ postRun();
4605
+ }
4606
+ if (Module["setStatus"]) {
4607
+ Module["setStatus"]("Running...");
4608
+ setTimeout(() => {
4609
+ setTimeout(() => Module["setStatus"](""), 1);
4610
+ doRun();
4611
+ }, 1);
4612
+ } else {
4613
+ doRun();
4614
+ }
4615
+ checkStackCookie();
4616
+ }
4617
+ function checkUnflushedContent() {
4618
+ var oldOut = out;
4619
+ var oldErr = err;
4620
+ var has = false;
4621
+ out = err = (x) => {
4622
+ has = true;
4623
+ };
4624
+ try {
4625
+ _fflush(0);
4626
+ ["stdout", "stderr"].forEach((name) => {
4627
+ var info = FS.analyzePath("/dev/" + name);
4628
+ if (!info) return;
4629
+ var stream = info.object;
4630
+ var rdev = stream.rdev;
4631
+ var tty = TTY.ttys[rdev];
4632
+ if (tty?.output?.length) {
4633
+ has = true;
4634
+ }
4635
+ });
4636
+ } catch (e) {
4637
+ }
4638
+ out = oldOut;
4639
+ err = oldErr;
4640
+ if (has) {
4641
+ warnOnce("stdio streams had content in them that was not flushed. you should set EXIT_RUNTIME to 1 (see the Emscripten FAQ), or make sure to emit a newline when you printf etc.");
4642
+ }
4643
+ }
4644
+ if (Module["preInit"]) {
4645
+ if (typeof Module["preInit"] == "function") Module["preInit"] = [Module["preInit"]];
4646
+ while (Module["preInit"].length > 0) {
4647
+ Module["preInit"].pop()();
4648
+ }
4649
+ }
4650
+ run();
4651
+ moduleRtn = readyPromise;
4652
+ for (const prop of Object.keys(Module)) {
4653
+ if (!(prop in moduleArg)) {
4654
+ Object.defineProperty(moduleArg, prop, {
4655
+ configurable: true,
4656
+ get() {
4657
+ abort(`Access to module property ('${prop}') is no longer possible via the module constructor argument; Instead, use the result of the module constructor.`);
4658
+ }
4659
+ });
4660
+ }
4661
+ }
4662
+ return moduleRtn;
4663
+ };
4664
+ })();
4665
+ var pdfium_default = createPdfium;
4666
+
4667
+ // src/index.ts
4668
+ async function init(moduleOverrides) {
4669
+ const pdfium = await pdfium_default(moduleOverrides);
4670
+ const module2 = {
4671
+ pdfium
4672
+ };
4673
+ for (const key in functions) {
4674
+ const ident = key;
4675
+ const args = functions[ident][0];
4676
+ const ret = functions[ident][1];
4677
+ module2[ident] = pdfium.cwrap(key, ret, args);
4678
+ }
4679
+ return module2;
4680
+ }
4681
+ // Annotate the CommonJS export names for ESM import in node:
4682
+ 0 && (module.exports = {
4683
+ init
4684
+ });
4685
+ //# sourceMappingURL=index.cjs.map