@unionpdf/pdfium
Version:
Pdfium webassebmly for web platform
1,642 lines (1,638 loc) • 248 kB
JavaScript
import * as $heixE$process from "process";
const $ee0f1da59c822995$export$18af1f934c132a41 = {
PDFiumExt_Init: [
[],
null
],
PDFiumExt_OpenFileWriter: [
[],
'number'
],
PDFiumExt_CloseFileWriter: [
[
'number'
],
null
],
PDFiumExt_GetFileWriterSize: [
[
'number'
],
'number'
],
PDFiumExt_GetFileWriterData: [
[
'number',
'number',
'number'
],
null
],
PDFiumExt_OpenFormFillInfo: [
[],
'number'
],
PDFiumExt_CloseFormFillInfo: [
[
'number'
],
null
],
PDFiumExt_InitFormFillEnvironment: [
[
'number',
'number'
],
'number'
],
PDFiumExt_ExitFormFillEnvironment: [
[
'number'
],
null
],
PDFiumExt_SaveAsCopy: [
[
'number',
'number'
],
null
],
FPDF_LoadMemDocument: [
[
'number',
'number',
'number'
],
'number'
],
FPDF_GetPageSizeByIndexF: [
[
'number',
'number',
'number'
],
'number'
],
FPDF_GetLastError: [
[],
'number'
],
FPDF_GetPageCount: [
[
'number'
],
'number'
],
FPDF_CloseDocument: [
[
'number'
],
null
],
FPDF_GetDocPermissions: [
[
'number'
],
'number'
],
FPDF_GetDocUserPermissions: [
[
'number'
],
'number'
],
FPDF_DestroyLibrary: [
[],
null
],
FPDF_GetMetaText: [
[
'number',
'string',
'number',
'number'
],
'number'
],
FPDFBitmap_FillRect: [
[
'number',
'number',
'number',
'number',
'number',
'number'
],
null
],
FPDFBitmap_Create: [
[
'number',
'number',
'number'
],
'number'
],
FPDFBitmap_CreateEx: [
[
'number',
'number',
'number',
'number',
'number'
],
'number'
],
FPDFBitmap_GetBuffer: [
[
'number'
],
'number'
],
FPDFBitmap_GetWidth: [
[
'number'
],
'number'
],
FPDFBitmap_GetHeight: [
[
'number'
],
'number'
],
FPDFBitmap_GetFormat: [
[
'number'
],
'number'
],
FPDFBitmap_Destroy: [
[
'number'
],
null
],
FPDFPageObj_Destroy: [
[
'number'
],
null
],
FPDFPageObj_NewImageObj: [
[
'number'
],
'number'
],
FPDFPageObj_GetMatrix: [
[
'number',
'number'
],
'boolean'
],
FPDFPageObj_SetMatrix: [
[
'number',
'number'
],
'boolean'
],
FPDFPageObj_GetBounds: [
[
'number',
'number',
'number',
'number',
'number'
],
'boolean'
],
FPDFPageObj_Transform: [
[
'number',
'number',
'number',
'number',
'number',
'number',
'number'
],
null
],
FPDFImageObj_SetBitmap: [
[
'number',
'number',
'number',
'number'
],
'boolean'
],
FPDFImageObj_GetBitmap: [
[
'number'
],
'number'
],
FPDFPath_CountSegments: [
[
'number'
],
'number'
],
FPDFPath_GetPathSegment: [
[
'number',
'number'
],
'number'
],
FPDFPathSegment_GetType: [
[
'number'
],
'number'
],
FPDFPathSegment_GetPoint: [
[
'number',
'number',
'number'
],
'boolean'
],
FPDFPathSegment_GetClose: [
[
'number'
],
'boolean'
],
FPDFFormObj_CountObjects: [
[
'number'
],
'number'
],
FPDFFormObj_GetObject: [
[
'number',
'number'
],
'number'
],
FPDFBookmark_GetFirstChild: [
[
'number',
'number'
],
'number'
],
FPDFBookmark_GetNextSibling: [
[
'number',
'number'
],
'number'
],
FPDFBookmark_Find: [
[
'number',
'string'
],
'number'
],
FPDFBookmark_GetTitle: [
[
'number',
'number',
'number'
],
'number'
],
FPDFBookmark_GetAction: [
[
'number'
],
'number'
],
FPDFBookmark_GetDest: [
[
'number',
'number'
],
'number'
],
FPDFAction_GetType: [
[
'number'
],
'number'
],
FPDFAction_GetFilePath: [
[
'number',
'number',
'number'
],
'number'
],
FPDFAction_GetDest: [
[
'number',
'number'
],
'number'
],
FPDFAction_GetURIPath: [
[
'number',
'number',
'number',
'number'
],
'number'
],
FPDFDest_GetDestPageIndex: [
[
'number',
'number'
],
'number'
],
FPDFDest_GetView: [
[
'number',
'number',
'number'
],
'number'
],
FPDFDest_GetLocationInPage: [
[
'number',
'number',
'number',
'number',
'number',
'number',
'number'
],
'boolean'
],
FPDF_LoadPage: [
[
'number',
'number'
],
'number'
],
FPDF_RenderPageBitmap: [
[
'number',
'number',
'number',
'number',
'number',
'number',
'number',
'number'
],
null
],
FPDF_PageToDevice: [
[
'number',
'number',
'number',
'number',
'number',
'number',
'number',
'number',
'number',
'number'
],
null
],
FPDF_DeviceToPage: [
[
'number',
'number',
'number',
'number',
'number',
'number',
'number',
'number',
'number',
'number'
],
'boolean'
],
FPDFPage_GetAnnotCount: [
[
'number'
],
'number'
],
FPDFPage_GetAnnot: [
[
'number',
'number'
],
'number'
],
FPDFPage_CreateAnnot: [
[
'number',
'number'
],
'number'
],
FPDFPage_InsertObject: [
[
'number',
'number'
],
'boolean'
],
FPDFPage_RemoveAnnot: [
[
'number',
'number'
],
'boolean'
],
FPDFPage_GenerateContent: [
[
'number'
],
'boolean'
],
FPDFPage_Flatten: [
[
'number',
'number'
],
'number'
],
FPDF_ClosePage: [
[
'number'
],
null
],
FPDFAnnot_GetSubtype: [
[
'number'
],
'number'
],
FPDFAnnot_GetAP: [
[
'number',
'number',
'number',
'number'
],
'number'
],
FPDFAnnot_GetObjectCount: [
[
'number'
],
'number'
],
FPDFAnnot_GetObject: [
[
'number',
'number'
],
'number'
],
FPDFAnnot_AppendObject: [
[
'number',
'number'
],
'boolean'
],
FPDFAnnot_GetRect: [
[
'number',
'number'
],
'boolean'
],
FPDFAnnot_SetRect: [
[
'number',
'number'
],
'boolean'
],
FPDFAnnot_GetLink: [
[
'number'
],
'number'
],
FPDFAnnot_GetFormFieldType: [
[
'number',
'number'
],
'number'
],
FPDFAnnot_GetFormFieldFlags: [
[
'number',
'number'
],
'number'
],
FPDFAnnot_GetFormFieldName: [
[
'number',
'number',
'number',
'number'
],
'number'
],
FPDFAnnot_GetFormFieldAlternateName: [
[
'number',
'number',
'number',
'number'
],
'number'
],
FPDFAnnot_GetFormFieldValue: [
[
'number',
'number',
'number',
'number'
],
'number'
],
FPDFAnnot_GetOptionCount: [
[
'number',
'number'
],
'number'
],
FPDFAnnot_GetOptionLabel: [
[
'number',
'number',
'number',
'number',
'number'
],
'number'
],
FPDFAnnot_IsOptionSelected: [
[
'number',
'number',
'number'
],
'boolean'
],
FPDFAnnot_IsChecked: [
[
'number',
'number'
],
'boolean'
],
FPDFAnnot_GetStringValue: [
[
'number',
'string',
'number',
'number'
],
'number'
],
FPDFAnnot_GetColor: [
[
'number',
'number',
'number',
'number',
'number',
'number'
],
'number'
],
FPDFAnnot_GetLinkedAnnot: [
[
'number',
'string'
],
'number'
],
FPDFAnnot_GetInkListCount: [
[
'number'
],
'number'
],
FPDFAnnot_GetInkListPath: [
[
'number',
'number',
'number',
'number'
],
'number'
],
FPDFAnnot_AddInkStroke: [
[
'number',
'number',
'number'
],
'number'
],
FPDFAnnot_RemoveInkList: [
[
'number'
],
'boolean'
],
FPDFAnnot_GetVertices: [
[
'number',
'number',
'number'
],
'number'
],
FPDFAnnot_GetLine: [
[
'number',
'number',
'number'
],
'number'
],
FPDFPageObj_GetType: [
[
'number'
],
'number'
],
FPDFLink_GetDest: [
[
'number',
'number'
],
'number'
],
FPDFLink_GetAction: [
[
'number'
],
'number'
],
FPDFText_LoadPage: [
[
'number'
],
'number'
],
FPDFText_CountChars: [
[
'number'
],
'number'
],
FPDFText_CountRects: [
[
'number',
'number',
'number'
],
'number'
],
FPDFText_GetRect: [
[
'number',
'number',
'number',
'number',
'number',
'number'
],
'boolean'
],
FPDFText_GetCharIndexAtPos: [
[
'number',
'number',
'number',
'number',
'number'
],
'number'
],
FPDFText_GetFontSize: [
[
'number',
'number'
],
'number'
],
FPDFText_GetFontInfo: [
[
'number',
'number',
'number',
'number',
'number'
],
'number'
],
FPDFText_GetBoundedText: [
[
'number',
'number',
'number',
'number',
'number',
'number',
'number'
],
'number'
],
FPDFText_FindStart: [
[
'number',
'number',
'number',
'number'
],
'number'
],
FPDFText_FindNext: [
[
'number'
],
'boolean'
],
FPDFText_FindPrev: [
[
'number'
],
'boolean'
],
FPDFText_GetSchResultIndex: [
[
'number'
],
'number'
],
FPDFText_GetSchCount: [
[
'number'
],
'number'
],
FPDFText_FindClose: [
[
'number'
],
null
],
FPDFText_ClosePage: [
[
'number'
],
null
],
FPDFText_GetText: [
[
'number',
'number',
'number',
'number'
],
'number'
],
FPDFText_GetCharBox: [
[
'number',
'number',
'number',
'number',
'number',
'number'
],
'boolean'
],
FPDFPage_CloseAnnot: [
[
'number'
],
null
],
FPDFDoc_GetAttachmentCount: [
[
'number'
],
'number'
],
FPDFDoc_GetAttachment: [
[
'number',
'number'
],
'number'
],
FPDFAttachment_GetName: [
[
'number',
'number',
'number'
],
'number'
],
FPDFAttachment_GetStringValue: [
[
'number',
'string',
'number',
'number'
],
'number'
],
FPDFAttachment_GetFile: [
[
'number',
'number',
'number',
'number'
],
'boolean'
],
FORM_OnAfterLoadPage: [
[
'number',
'number'
],
null
],
FORM_OnBeforeClosePage: [
[
'number',
'number'
],
null
],
FPDFAnnot_SetFocusableSubtypes: [
[
'number',
'number',
'number'
],
'boolean'
],
FPDFAnnot_GetFocusableSubtypesCount: [
[
'number'
],
'number'
],
FPDFAnnot_GetFocusableSubtypes: [
[
'number',
'number',
'number'
],
'boolean'
],
FORM_SetFocusedAnnot: [
[
'number',
'number'
],
'boolean'
],
FORM_SetIndexSelected: [
[
'number',
'number',
'number',
'boolean'
],
'boolean'
],
FORM_OnKeyDown: [
[
'number',
'number',
'number',
'number'
],
'boolean'
],
FORM_OnKeyUp: [
[
'number',
'number',
'number',
'number'
],
'boolean'
],
FORM_OnChar: [
[
'number',
'number',
'number',
'number'
],
'boolean'
],
FORM_SelectAllText: [
[
'number',
'number'
],
'boolean'
],
FORM_ReplaceSelection: [
[
'number',
'number',
'number'
],
null
],
FORM_ForceToKillFocus: [
[
'number'
],
'boolean'
],
FPDF_GetSignatureCount: [
[
'number'
],
'number'
],
FPDF_GetSignatureObject: [
[
'number',
'number'
],
'number'
],
FPDFSignatureObj_GetContents: [
[
'number',
'number',
'number'
],
'number'
],
FPDFSignatureObj_GetByteRange: [
[
'number',
'number',
'number'
],
'number'
],
FPDFSignatureObj_GetSubFilter: [
[
'number',
'number',
'number'
],
'number'
],
FPDFSignatureObj_GetReason: [
[
'number',
'number',
'number'
],
'number'
],
FPDFSignatureObj_GetTime: [
[
'number',
'number',
'number'
],
'number'
],
FPDFSignatureObj_GetDocMDPPermission: [
[
'number'
],
'number'
],
FPDF_CreateNewDocument: [
[],
'number'
],
FPDF_ImportPagesByIndex: [
[
'number',
'number',
'number',
'number',
'number'
],
'boolean'
],
FPDF_ImportPages: [
[
'number',
'number',
'number',
'number'
],
'boolean'
]
};
var $6e53761148bc2570$var$createPdfium = (()=>{
var _scriptName = "file:///packages/pdfium/src/pdfium.js";
return function(moduleArg = {}) {
var moduleRtn;
// include: shell.js
// The Module object: Our interface to the outside world. We import
// and export values on it. There are various ways Module can be used:
// 1. Not defined. We create it here
// 2. A function parameter, function(moduleArg) => Promise<Module>
// 3. pre-run appended it, var Module = {}; ..generated code..
// 4. External script tag defines var Module.
// We need to check if Module already exists (e.g. case 3 above).
// Substitution will be replaced with actual code on later stage of the build,
// this way Closure Compiler will not mangle it (e.g. case 4. above).
// Note that if you want to run closure, and also to use Module
// after the generated code, you will need to define var Module = {};
// before the code. Then that object will be used in the code, and you
// can continue to use Module afterwards as well.
var Module = moduleArg;
// Set up the promise that indicates the Module is initialized
var readyPromiseResolve, readyPromiseReject;
var readyPromise = new Promise((resolve, reject)=>{
readyPromiseResolve = resolve;
readyPromiseReject = reject;
});
[
"_malloc",
"_free",
"_PDFiumExt_Init",
"_PDFiumExt_OpenFileWriter",
"_PDFiumExt_CloseFileWriter",
"_PDFiumExt_GetFileWriterSize",
"_PDFiumExt_GetFileWriterData",
"_PDFiumExt_OpenFormFillInfo",
"_PDFiumExt_CloseFormFillInfo",
"_PDFiumExt_InitFormFillEnvironment",
"_PDFiumExt_ExitFormFillEnvironment",
"_PDFiumExt_SaveAsCopy",
"_FPDF_LoadMemDocument",
"_FPDF_GetPageSizeByIndexF",
"_FPDF_GetLastError",
"_FPDF_GetPageCount",
"_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)=>{
if (!Object.getOwnPropertyDescriptor(readyPromise, prop)) Object.defineProperty(readyPromise, prop, {
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'),
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')
});
});
// Determine the runtime environment we are in. You can customize this by
// setting the ENVIRONMENT setting at compile time (see settings.js).
var ENVIRONMENT_IS_WEB = false;
var ENVIRONMENT_IS_WORKER = true;
var ENVIRONMENT_IS_NODE = false;
var ENVIRONMENT_IS_SHELL = false;
// --pre-jses are emitted after the Module integration code, so that they can
// refer to Module (if they choose; they can also define Module)
// Sometimes an existing Module object exists with properties
// meant to overwrite the default module functionality. Here
// we collect those properties and reapply _after_ we configure
// the current environment's defaults to avoid having to be so
// defensive during initialization.
var moduleOverrides = Object.assign({}, Module);
var arguments_ = [];
var thisProgram = './this.program';
var quit_ = (status, toThrow)=>{
throw toThrow;
};
// `/` should be present at the end if `scriptDirectory` is not empty
var scriptDirectory = '';
function locateFile(path) {
if (Module['locateFile']) return Module['locateFile'](path, scriptDirectory);
return scriptDirectory + path;
}
// Hooks that are implemented differently in different runtime environments.
var readAsync, readBinary;
if (ENVIRONMENT_IS_SHELL) {
if (typeof $heixE$process == 'object' && true || 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?)');
} else // Note that this includes Node.js workers when relevant (pthreads is enabled).
// Node.js workers are detected as a combination of ENVIRONMENT_IS_WORKER and
// ENVIRONMENT_IS_NODE.
if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
if (ENVIRONMENT_IS_WORKER) scriptDirectory = self.location.href;
else if (typeof document != 'undefined' && document.currentScript) scriptDirectory = document.currentScript.src;
// When MODULARIZE, this JS may be executed later, after document.currentScript
// is gone, so we saved it, and we use it here instead of any other info.
if (_scriptName) scriptDirectory = _scriptName;
// blob urls look like blob:http://site.com/etc/etc and we cannot infer anything from them.
// otherwise, slice off the final part of the url to find the script directory.
// if scriptDirectory does not contain a slash, lastIndexOf will return -1,
// and scriptDirectory will correctly be replaced with an empty string.
// If scriptDirectory contains a query (starting with ?) or a fragment (starting with #),
// they are removed because they could contain a slash.
if (scriptDirectory.startsWith('blob:')) scriptDirectory = '';
else scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, '').lastIndexOf('/') + 1);
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?)');
// include: web_or_worker_shell_read.js
if (ENVIRONMENT_IS_WORKER) readBinary = (url)=>{
var xhr = new XMLHttpRequest();
xhr.open('GET', url, false);
xhr.responseType = 'arraybuffer';
xhr.send(null);
return new Uint8Array(/** @type{!ArrayBuffer} */ xhr.response);
};
readAsync = (url)=>{
assert(!isFileURI(url), "readAsync does not work with file:// URLs");
return fetch(url, {
credentials: 'same-origin'
}).then((response)=>{
if (response.ok) return response.arrayBuffer();
return Promise.reject(new Error(response.status + ' : ' + response.url));
});
};
} else throw new Error('environment detection error');
var out = Module['print'] || console.log.bind(console);
var err = Module['printErr'] || console.error.bind(console);
// Merge back in the overrides
Object.assign(Module, moduleOverrides);
// Free the object hierarchy contained in the overrides, this lets the GC
// reclaim data used.
moduleOverrides = null;
checkIncomingModuleAPI();
// Emit code to handle expected values on the Module object. This applies Module.x
// to the proper local x. This has two benefits: first, we only emit it if it is
// expected to arrive, and second, by using a local everywhere else that can be
// minified.
if (Module['arguments']) arguments_ = Module['arguments'];
legacyModuleProp('arguments', 'arguments_');
if (Module['thisProgram']) thisProgram = Module['thisProgram'];
legacyModuleProp('thisProgram', 'thisProgram');
// perform assertions in shell.js after we set up out() and err(), as otherwise if an assertion fails it cannot print the message
// Assertions on removed incoming Module JS APIs.
assert(typeof Module['memoryInitializerPrefixURL'] == 'undefined', 'Module.memoryInitializerPrefixURL option was removed, use Module.locateFile instead');
assert(typeof Module['pthreadMainPrefixURL'] == 'undefined', 'Module.pthreadMainPrefixURL option was removed, use Module.locateFile instead');
assert(typeof Module['cdInitializerPrefixURL'] == 'undefined', 'Module.cdInitializerPrefixURL option was removed, use Module.locateFile instead');
assert(typeof Module['filePackagePrefixURL'] == 'undefined', 'Module.filePackagePrefixURL option was removed, use Module.locateFile instead');
assert(typeof Module['read'] == 'undefined', 'Module.read option was removed');
assert(typeof Module['readAsync'] == 'undefined', 'Module.readAsync option was removed (modify readAsync in JS)');
assert(typeof Module['readBinary'] == 'undefined', 'Module.readBinary option was removed (modify readBinary in JS)');
assert(typeof Module['setWindowTitle'] == 'undefined', 'Module.setWindowTitle option was removed (modify emscripten_set_window_title in JS)');
assert(typeof Module['TOTAL_MEMORY'] == 'undefined', 'Module.TOTAL_MEMORY has been renamed Module.INITIAL_MEMORY');
legacyModuleProp('asm', 'wasmExports');
legacyModuleProp('readAsync', 'readAsync');
legacyModuleProp('readBinary', 'readBinary');
legacyModuleProp('setWindowTitle', 'setWindowTitle');
var IDBFS = 'IDBFS is no longer included by default; build with -lidbfs.js';
var PROXYFS = 'PROXYFS is no longer included by default; build with -lproxyfs.js';
var WORKERFS = 'WORKERFS is no longer included by default; build with -lworkerfs.js';
var FETCHFS = 'FETCHFS is no longer included by default; build with -lfetchfs.js';
var ICASEFS = 'ICASEFS is no longer included by default; build with -licasefs.js';
var JSFILEFS = 'JSFILEFS is no longer included by default; build with -ljsfilefs.js';
var OPFS = 'OPFS is no longer included by default; build with -lopfs.js';
var NODEFS = 'NODEFS is no longer included by default; build with -lnodefs.js';
assert(!ENVIRONMENT_IS_WEB, 'web environment detected but not enabled at build time. Add `web` to `-sENVIRONMENT` to enable.');
assert(!ENVIRONMENT_IS_NODE, 'node environment detected but not enabled at build time. Add `node` to `-sENVIRONMENT` to enable.');
assert(!ENVIRONMENT_IS_SHELL, 'shell environment detected but not enabled at build time. Add `shell` to `-sENVIRONMENT` to enable.');
// end include: shell.js
// include: preamble.js
// === Preamble library stuff ===
// Documentation for the public APIs defined in this file must be updated in:
// site/source/docs/api_reference/preamble.js.rst
// A prebuilt local version of the documentation is available at:
// site/build/text/docs/api_reference/preamble.js.txt
// You can also build docs locally as HTML or other formats in site/
// An online HTML version (which may be of a different version of Emscripten)
// is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html
var wasmBinary = Module['wasmBinary'];
legacyModuleProp('wasmBinary', 'wasmBinary');
if (typeof WebAssembly != 'object') err('no native wasm support detected');
// Wasm globals
var wasmMemory;
//========================================
// Runtime essentials
//========================================
// whether we are quitting the application. no code should run after this.
// set in exit() and abort()
var ABORT = false;
// set by exit() and abort(). Passed to 'onExit' handler.
// NOTE: This is also used as the process return code code in shell environments
// but only when noExitRuntime is false.
var EXITSTATUS;
// In STRICT mode, we only define assert() when ASSERTIONS is set. i.e. we
// don't define it at all in release modes. This matches the behaviour of
// MINIMAL_RUNTIME.
// TODO(sbc): Make this the default even without STRICT enabled.
/** @type {function(*, string=)} */ function assert(condition, text) {
if (!condition) abort('Assertion failed' + (text ? ': ' + text : ''));
}
// We used to include malloc/free by default in the past. Show a helpful error in
// builds with assertions.
// Memory management
var HEAP, /** @type {!Int8Array} */ HEAP8, /** @type {!Uint8Array} */ HEAPU8, /** @type {!Int16Array} */ HEAP16, /** @type {!Uint16Array} */ HEAPU16, /** @type {!Int32Array} */ HEAP32, /** @type {!Uint32Array} */ HEAPU32, /** @type {!Float32Array} */ HEAPF32, /** @type {!Float64Array} */ HEAPF64;
// include: runtime_shared.js
function updateMemoryViews() {
var b = wasmMemory.buffer;
Module['HEAP8'] = HEAP8 = new Int8Array(b);
Module['HEAP16'] = HEAP16 = new Int16Array(b);
Module['HEAPU8'] = HEAPU8 = new Uint8Array(b);
Module['HEAPU16'] = HEAPU16 = new Uint16Array(b);
Module['HEAP32'] = HEAP32 = new Int32Array(b);
Module['HEAPU32'] = HEAPU32 = new Uint32Array(b);
Module['HEAPF32'] = HEAPF32 = new Float32Array(b);
Module['HEAPF64'] = HEAPF64 = new Float64Array(b);
}
// end include: runtime_shared.js
assert(!Module['STACK_SIZE'], 'STACK_SIZE can no longer be set at runtime. Use -sSTACK_SIZE at link time');
assert(typeof Int32Array != 'undefined' && typeof Float64Array !== 'undefined' && Int32Array.prototype.subarray != undefined && Int32Array.prototype.set != undefined, 'JS engine does not provide full typed array support');
// If memory is defined in wasm, the user can't provide it, or set INITIAL_MEMORY
assert(!Module['wasmMemory'], 'Use of `wasmMemory` detected. Use -sIMPORTED_MEMORY to define wasmMemory externally');
assert(!Module['INITIAL_MEMORY'], 'Detected runtime INITIAL_MEMORY setting. Use -sIMPORTED_MEMORY to define wasmMemory dynamically');
// include: runtime_stack_check.js
// Initializes the stack cookie. Called at the startup of main and at the startup of each thread in pthreads mode.
function writeStackCookie() {
var max = _emscripten_stack_get_end();
assert((max & 3) == 0);
// If the stack ends at address zero we write our cookies 4 bytes into the
// stack. This prevents interference with SAFE_HEAP and ASAN which also
// monitor writes to address zero.
if (max == 0) max += 4;
// The stack grow downwards towards _emscripten_stack_get_end.
// We write cookies to the final two words in the stack and detect if they are
// ever overwritten.
HEAPU32[max >> 2] = 0x02135467;
HEAPU32[max + 4 >> 2] = 0x89BACDFE;
// Also test the global address 0 for integrity.
HEAPU32[0] = 1668509029;
}
function checkStackCookie() {
if (ABORT) return;
var max = _emscripten_stack_get_end();
// See writeStackCookie().
if (max == 0) max += 4;
var cookie1 = HEAPU32[max >> 2];
var cookie2 = HEAPU32[max + 4 >> 2];
if (cookie1 != 0x02135467 || cookie2 != 0x89BACDFE) abort(`Stack overflow! Stack cookie has been overwritten at ${ptrToString(max)}, expected hex dwords 0x89BACDFE and 0x2135467, but received ${ptrToString(cookie2)} ${ptrToString(cookie1)}`);
// Also test the global address 0 for integrity.
if (HEAPU32[0] != 0x63736d65 /* 'emsc' */ ) abort('Runtime error: The application has corrupted its heap memory area (address zero)!');
}
// end include: runtime_stack_check.js
var __ATPRERUN__ = []; // functions called before the runtime is initialized
var __ATINIT__ = []; // functions called during startup
var __ATEXIT__ = []; // functions called during shutdown
var __ATPOSTRUN__ = []; // functions called after the main() is called
var runtimeInitialized = false;
function preRun() {
var preRuns = Module['preRun'];
if (preRuns) {
if (typeof preRuns == 'function') preRuns = [
preRuns
];
preRuns.forEach(addOnPreRun);
}
callRuntimeCallbacks(__ATPRERUN__);
}
function initRuntime() {
assert(!runtimeInitialized);
runtimeInitialized = true;
checkStackCookie();
if (!Module['noFSInit'] && !FS.initialized) FS.init();
FS.ignorePermissions = false;
TTY.init();
callRuntimeCallbacks(__ATINIT__);
}
function postRun() {
checkStackCookie();
var postRuns = Module['postRun'];
if (postRuns) {
if (typeof postRuns == 'function') postRuns = [
postRuns
];
postRuns.forEach(addOnPostRun);
}
callRuntimeCallbacks(__ATPOSTRUN__);
}
function addOnPreRun(cb) {
__ATPRERUN__.unshift(cb);
}
function addOnInit(cb) {
__ATINIT__.unshift(cb);
}
function addOnExit(cb) {}
function addOnPostRun(cb) {
__ATPOSTRUN__.unshift(cb);
}
// include: runtime_math.js
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/fround
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc
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');
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');
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');
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');
// end include: runtime_math.js
// A counter of dependencies for calling run(). If we need to
// do asynchronous work before running, increment this and
// decrement it. Incrementing must happen in a place like
// Module.preRun (used by emcc to add file preloading).
// Note that you can add dependencies in preRun, even though
// it happens right before run - run will be postponed until
// the dependencies are met.
var runDependencies = 0;
var runDependencyWatcher = null;
var dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled
var runDependencyTracking = {};
function getUniqueRunDependency(id) {
var orig = id;
while(true){
if (!runDependencyTracking[id]) return id;
id = orig + Math.random();
}
}
function addRunDependency(id) {
runDependencies++;
Module['monitorRunDependencies']?.(runDependencies);
if (id) {
assert(!runDependencyTracking[id]);
runDependencyTracking[id] = 1;
if (runDependencyWatcher === null && typeof setInterval != 'undefined') // Check for missing dependencies every few seconds
runDependencyWatcher = setInterval(()=>{
if (ABORT) {
clearInterval(runDependencyWatcher);
runDependencyWatcher = null;
return;
}
var shown = false;
for(var dep in runDependencyTracking){
if (!shown) {
shown = true;
err('still waiting on run dependencies:');
}
err(`dependency: ${dep}`);
}
if (shown) err('(end of list)');
}, 10000);
} else err('warning: run dependency added without ID');
}
function removeRunDependency(id) {
runDependencies--;
Module['monitorRunDependencies']?.(runDependencies);
if (id) {
assert(runDependencyTracking[id]);
delete runDependencyTracking[id];
} else err('warning: run dependency removed without ID');
if (runDependencies == 0) {
if (runDependencyWatcher !== null) {
clearInterval(runDependencyWatcher);
runDependencyWatcher = null;
}
if (dependenciesFulfilled) {
var callback = dependenciesFulfilled;
dependenciesFulfilled = null;
callback(); // can add another dependenciesFulfilled
}
}
}
/** @param {string|number=} what */ function abort(what) {
Module['onAbort']?.(what);
what = 'Aborted(' + what + ')';
// TODO(sbc): Should we remove printing and leave it up to whoever
// catches the exception?
err(what);
ABORT = true;
// Use a wasm runtime error, because a JS error might be seen as a foreign
// exception, which means we'd run destructors on it. We need the error to
// simply make the program stop.
// FIXME This approach does not work in Wasm EH because it currently does not assume
// all RuntimeErrors are from traps; it decides whether a RuntimeError is from
// a trap or not based on a hidden field within the object. So at the moment
// we don't have a way of throwing a wasm trap from JS. TODO Make a JS API that
// allows this in the wasm spec.
// Suppress closure compiler warning here. Closure compiler's builtin extern
// definition for WebAssembly.RuntimeError claims it takes no arguments even
// though it can.
// TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure gets fixed.
/** @suppress {checkTypes} */ var e = new WebAssembly.RuntimeError(what);
readyPromiseReject(e);
// Throw the error whether or not MODULARIZE is set because abort is used
// in code paths apart from instantiation where an exception is expected
// to be thrown when abort is called.
throw e;
}
// include: memoryprofiler.js
// end include: memoryprofiler.js
// include: URIUtils.js
// Prefix of data URIs emitted by SINGLE_FILE and related options.
var dataURIPrefix = 'data:application/octet-stream;base64,';
/**
* Indicates whether filename is a base64 data URI.
* @noinline
*/ var isDataURI = (filename)=>filename.startsWith(dataURIPrefix);
/**
* Indicates whether filename is delivered via file protocol (as opposed to http/https)
* @noinline
*/ var isFileURI = (filename)=>filename.startsWith('file://');
// end include: URIUtils.js
function createExportWrapper(name, nargs) {
return (...args)=>{
assert(runtimeInitialized, `native function \`${name}\` called before runtime initialization`);
var f = wasmExports[name];
assert(f, `exported native function \`${name}\` not found`);
// Only assert for too many arguments. Too few can be valid since the missing arguments will be zero filled.
assert(args.length <= nargs, `native function \`${name}\` called with ${args.length} args but expects ${nargs}`);
return f(...args);
};
}
// include: runtime_exceptions.js
// end include: runtime_exceptions.js
function findWasmBinary() {
if (Module['locateFile']) {
var f = 'pdfium.wasm';
if (!isDataURI(f)) return locateFile(f);
return f;
}
// Use bundler-friendly `new URL(..., import.meta.url)` pattern; works in browsers too.
return new URL("pdfium.a0e42955.wasm", import.meta.url).href;
}
var wasmBinaryFile;
function getBinarySync(file) {
if (file == wasmBinaryFile && wasmBinary) return new Uint8Array(wasmBinary);
if (readBinary) return readBinary(file);
throw 'both async and sync fetching of the wasm failed';
}
function getBinaryPromise(binaryFile) {
// If we don't have the binary yet, load it asynchronously using readAsync.
if (!wasmBinary) // Fetch the binary using readAsync
return readAsync(binaryFile).then((response)=>new Uint8Array(/** @type{!ArrayBuffer} */ response), // Fall back to getBinarySync if readAsync fails
()=>getBinarySync(binaryFile));
// Otherwise, getBinarySync should be able to get it synchronously
return Promise.resolve().then(()=>getBinarySync(binaryFile));
}
function instantiateArrayBuffer(binaryFile, imports, receiver) {
return getBinaryPromise(binaryFile).then((binary)=>{
return WebAssembly.instantiate(binary, imports);
}).then(receiver, (reason)=>{
err(`failed to asynchronously prepare wasm: ${reason}`);
// Warn on some common problems.
if (isFileURI(wasmBinaryFile)) err(`warning: Loading from a file URI (${wasmBinaryFile}) is not supported in most browsers. See https://emscripten.org/docs/getti