diff --git a/How to/Delete FormFields in Non Rendered Pages/.eslintrc.json b/How to/Delete FormFields in Non Rendered Pages/.eslintrc.json new file mode 100644 index 0000000..bffb357 --- /dev/null +++ b/How to/Delete FormFields in Non Rendered Pages/.eslintrc.json @@ -0,0 +1,3 @@ +{ + "extends": "next/core-web-vitals" +} diff --git a/How to/Delete FormFields in Non Rendered Pages/.gitignore b/How to/Delete FormFields in Non Rendered Pages/.gitignore new file mode 100644 index 0000000..fd3dbb5 --- /dev/null +++ b/How to/Delete FormFields in Non Rendered Pages/.gitignore @@ -0,0 +1,36 @@ +# See https://help.github.com/articles/ignoring-files/ for more about ignoring files. + +# dependencies +/node_modules +/.pnp +.pnp.js +.yarn/install-state.gz + +# testing +/coverage + +# next.js +/.next/ +/out/ + +# production +/build + +# misc +.DS_Store +*.pem + +# debug +npm-debug.log* +yarn-debug.log* +yarn-error.log* + +# local env files +.env*.local + +# vercel +.vercel + +# typescript +*.tsbuildinfo +next-env.d.ts diff --git a/How to/Delete FormFields in Non Rendered Pages/README.md b/How to/Delete FormFields in Non Rendered Pages/README.md new file mode 100644 index 0000000..c403366 --- /dev/null +++ b/How to/Delete FormFields in Non Rendered Pages/README.md @@ -0,0 +1,36 @@ +This is a [Next.js](https://nextjs.org/) project bootstrapped with [`create-next-app`](https://github.com/vercel/next.js/tree/canary/packages/create-next-app). + +## Getting Started + +First, run the development server: + +```bash +npm run dev +# or +yarn dev +# or +pnpm dev +# or +bun dev +``` + +Open [http://localhost:3000](http://localhost:3000) with your browser to see the result. + +You can start editing the page by modifying `app/page.tsx`. The page auto-updates as you edit the file. + +This project uses [`next/font`](https://nextjs.org/docs/basic-features/font-optimization) to automatically optimize and load Inter, a custom Google Font. + +## Learn More + +To learn more about Next.js, take a look at the following resources: + +- [Next.js Documentation](https://nextjs.org/docs) - learn about Next.js features and API. +- [Learn Next.js](https://nextjs.org/learn) - an interactive Next.js tutorial. + +You can check out [the Next.js GitHub repository](https://github.com/vercel/next.js/) - your feedback and contributions are welcome! + +## Deploy on Vercel + +The easiest way to deploy your Next.js app is to use the [Vercel Platform](https://vercel.com/new?utm_medium=default-template&filter=next.js&utm_source=create-next-app&utm_campaign=create-next-app-readme) from the creators of Next.js. + +Check out our [Next.js deployment documentation](https://nextjs.org/docs/deployment) for more details. diff --git a/How to/Delete FormFields in Non Rendered Pages/next.config.mjs b/How to/Delete FormFields in Non Rendered Pages/next.config.mjs new file mode 100644 index 0000000..4678774 --- /dev/null +++ b/How to/Delete FormFields in Non Rendered Pages/next.config.mjs @@ -0,0 +1,4 @@ +/** @type {import('next').NextConfig} */ +const nextConfig = {}; + +export default nextConfig; diff --git a/How to/Delete FormFields in Non Rendered Pages/package.json b/How to/Delete FormFields in Non Rendered Pages/package.json new file mode 100644 index 0000000..e62db9f --- /dev/null +++ b/How to/Delete FormFields in Non Rendered Pages/package.json @@ -0,0 +1,26 @@ +{ + "name": "deleteformfields", + "version": "0.1.0", + "private": true, + "scripts": { + "dev": "next dev", + "build": "next build", + "start": "next start", + "lint": "next lint" + }, + "dependencies": { + "@syncfusion/ej2-react-buttons": "^28.1.33", + "@syncfusion/ej2-react-pdfviewer": "^28.1.35", + "next": "14.1.1", + "react": "^18", + "react-dom": "^18" + }, + "devDependencies": { + "@types/node": "^20", + "@types/react": "^18", + "@types/react-dom": "^18", + "eslint": "^8", + "eslint-config-next": "14.1.1", + "typescript": "^5" + } +} diff --git a/How to/Delete FormFields in Non Rendered Pages/public/ej2-pdfviewer-lib/pdfium.js b/How to/Delete FormFields in Non Rendered Pages/public/ej2-pdfviewer-lib/pdfium.js new file mode 100644 index 0000000..f912e98 --- /dev/null +++ b/How to/Delete FormFields in Non Rendered Pages/public/ej2-pdfviewer-lib/pdfium.js @@ -0,0 +1,5288 @@ +var PDFiumModule = (() => { + var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined; + if (typeof __filename !== 'undefined') + _scriptDir = _scriptDir || __filename; + return (function (PDFiumModule = {}) { + var Module = typeof PDFiumModule != "undefined" ? PDFiumModule : {}; + var moduleOverrides = Object.assign({}, Module); + var arguments_ = []; + var thisProgram = "./this.program"; + var quit_ = (status, toThrow) => { + throw toThrow + }; + var ENVIRONMENT_IS_WEB = typeof window == "object"; + var ENVIRONMENT_IS_WORKER = typeof importScripts == "function"; + var ENVIRONMENT_IS_NODE = typeof process == "object" && typeof process.versions == "object" && typeof process.versions.node == "string"; + var scriptDirectory = ""; + + function locateFile(path) { + if (Module["locateFile"]) { + return Module["locateFile"](path, scriptDirectory) + } + return scriptDirectory + path + } + var read_, readAsync, readBinary, setWindowTitle; + if (ENVIRONMENT_IS_NODE) { + var fs = require("fs"); + var nodePath = require("path"); + if (ENVIRONMENT_IS_WORKER) { + scriptDirectory = nodePath.dirname(scriptDirectory) + "/" + } else { + scriptDirectory = __dirname + "/" + } + read_ = (filename, binary) => { + filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename); + return fs.readFileSync(filename, binary ? undefined : "utf8") + }; + readBinary = filename => { + var ret = read_(filename, true); + if (!ret.buffer) { + ret = new Uint8Array(ret) + } + return ret + }; + readAsync = (filename, onload, onerror) => { + filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename); + fs.readFile(filename, function (err, data) { + if (err) onerror(err); + else onload(data.buffer) + }) + }; + if (process.argv.length > 1) { + thisProgram = process.argv[1].replace(/\\/g, "/") + } + arguments_ = process.argv.slice(2); + if (typeof module != "undefined") { + module["exports"] = Module + } + process.on("uncaughtException", function (ex) { + if (ex !== "unwind" && !(ex instanceof ExitStatus) && !(ex.context instanceof ExitStatus)) { + throw ex + } + }); + var nodeMajor = process.versions.node.split(".")[0]; + if (nodeMajor < 15) { + process.on("unhandledRejection", function (reason) { + throw reason + }) + } + quit_ = (status, toThrow) => { + process.exitCode = status; + throw toThrow + }; + Module["inspect"] = function () { + return "[Emscripten Module object]" + } + } else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) { + if (ENVIRONMENT_IS_WORKER) { + scriptDirectory = self.location.href + } else if (typeof document != "undefined" && document.currentScript) { + scriptDirectory = document.currentScript.src + } + if (scriptDirectory.indexOf("blob:") !== 0) { + scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1) + } else { + scriptDirectory = "" + } { + read_ = url => { + var xhr = new XMLHttpRequest; + xhr.open("GET", url, false); + xhr.send(null); + return xhr.responseText + }; + if (ENVIRONMENT_IS_WORKER) { + readBinary = url => { + var xhr = new XMLHttpRequest; + xhr.open("GET", url, false); + xhr.responseType = "arraybuffer"; + xhr.send(null); + return new Uint8Array(xhr.response) + } + } + readAsync = (url, onload, onerror) => { + var xhr = new XMLHttpRequest; + xhr.open("GET", url, true); + xhr.responseType = "arraybuffer"; + xhr.onload = () => { + if (xhr.status == 200 || xhr.status == 0 && xhr.response) { + onload(xhr.response); + return + } + onerror() + }; + xhr.onerror = onerror; + xhr.send(null) + } + } + setWindowTitle = title => document.title = title + } else {} + var out = Module["print"] || console.log.bind(console); + var err = Module["printErr"] || console.warn.bind(console); + Object.assign(Module, moduleOverrides); + moduleOverrides = null; + if (Module["arguments"]) arguments_ = Module["arguments"]; + if (Module["thisProgram"]) thisProgram = Module["thisProgram"]; + if (Module["quit"]) quit_ = Module["quit"]; + var wasmBinary; + if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"]; + var noExitRuntime = Module["noExitRuntime"] || true; + if (typeof WebAssembly != "object") { + abort("no native wasm support detected") + } + var wasmMemory; + var ABORT = false; + var EXITSTATUS; + + function assert(condition, text) { + if (!condition) { + abort(text) + } + } + var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder("utf8") : undefined; + + function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) { + var endIdx = idx + maxBytesToRead; + var endPtr = idx; + while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr; + if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) { + return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr)) + } + var str = ""; + while (idx < endPtr) { + var u0 = heapOrArray[idx++]; + if (!(u0 & 128)) { + str += String.fromCharCode(u0); + continue + } + var u1 = heapOrArray[idx++] & 63; + if ((u0 & 224) == 192) { + str += String.fromCharCode((u0 & 31) << 6 | u1); + continue + } + var u2 = heapOrArray[idx++] & 63; + if ((u0 & 240) == 224) { + u0 = (u0 & 15) << 12 | u1 << 6 | u2 + } else { + u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heapOrArray[idx++] & 63 + } + if (u0 < 65536) { + str += String.fromCharCode(u0) + } else { + var ch = u0 - 65536; + str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023) + } + } + return str + } + + function UTF8ToString(ptr, maxBytesToRead) { + return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "" + } + + function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) { + if (!(maxBytesToWrite > 0)) return 0; + var startIdx = outIdx; + var endIdx = outIdx + maxBytesToWrite - 1; + for (var i = 0; i < str.length; ++i) { + var u = str.charCodeAt(i); + if (u >= 55296 && u <= 57343) { + var u1 = str.charCodeAt(++i); + u = 65536 + ((u & 1023) << 10) | u1 & 1023 + } + if (u <= 127) { + if (outIdx >= endIdx) break; + heap[outIdx++] = u + } else if (u <= 2047) { + if (outIdx + 1 >= endIdx) break; + heap[outIdx++] = 192 | u >> 6; + heap[outIdx++] = 128 | u & 63 + } else if (u <= 65535) { + if (outIdx + 2 >= endIdx) break; + heap[outIdx++] = 224 | u >> 12; + heap[outIdx++] = 128 | u >> 6 & 63; + heap[outIdx++] = 128 | u & 63 + } else { + if (outIdx + 3 >= endIdx) break; + heap[outIdx++] = 240 | u >> 18; + heap[outIdx++] = 128 | u >> 12 & 63; + heap[outIdx++] = 128 | u >> 6 & 63; + heap[outIdx++] = 128 | u & 63 + } + } + heap[outIdx] = 0; + return outIdx - startIdx + } + + function stringToUTF8(str, outPtr, maxBytesToWrite) { + return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite) + } + + function lengthBytesUTF8(str) { + var len = 0; + for (var i = 0; i < str.length; ++i) { + var c = str.charCodeAt(i); + if (c <= 127) { + len++ + } else if (c <= 2047) { + len += 2 + } else if (c >= 55296 && c <= 57343) { + len += 4; + ++i + } else { + len += 3 + } + } + return len + } + var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64; + + function updateMemoryViews() { + var b = wasmMemory.buffer; + Module["HEAP8"] = HEAP8 = new Int8Array(b); + Module["HEAP16"] = HEAP16 = new Int16Array(b); + Module["HEAP32"] = HEAP32 = new Int32Array(b); + Module["HEAPU8"] = HEAPU8 = new Uint8Array(b); + Module["HEAPU16"] = HEAPU16 = new Uint16Array(b); + Module["HEAPU32"] = HEAPU32 = new Uint32Array(b); + Module["HEAPF32"] = HEAPF32 = new Float32Array(b); + Module["HEAPF64"] = HEAPF64 = new Float64Array(b) + } + var wasmTable; + var __ATPRERUN__ = []; + var __ATINIT__ = []; + var __ATPOSTRUN__ = []; + var runtimeInitialized = false; + var runtimeKeepaliveCounter = 0; + + function keepRuntimeAlive() { + return noExitRuntime || runtimeKeepaliveCounter > 0 + } + + function preRun() { + if (Module["preRun"]) { + if (typeof Module["preRun"] == "function") Module["preRun"] = [Module["preRun"]]; + while (Module["preRun"].length) { + addOnPreRun(Module["preRun"].shift()) + } + } + callRuntimeCallbacks(__ATPRERUN__) + } + + function initRuntime() { + runtimeInitialized = true; + if (!Module["noFSInit"] && !FS.init.initialized) FS.init(); + FS.ignorePermissions = false; + TTY.init(); + callRuntimeCallbacks(__ATINIT__) + } + + function postRun() { + if (Module["postRun"]) { + if (typeof Module["postRun"] == "function") Module["postRun"] = [Module["postRun"]]; + while (Module["postRun"].length) { + addOnPostRun(Module["postRun"].shift()) + } + } + callRuntimeCallbacks(__ATPOSTRUN__) + } + + function addOnPreRun(cb) { + __ATPRERUN__.unshift(cb) + } + + function addOnInit(cb) { + __ATINIT__.unshift(cb) + } + + function addOnPostRun(cb) { + __ATPOSTRUN__.unshift(cb) + } + var runDependencies = 0; + var runDependencyWatcher = null; + var dependenciesFulfilled = null; + + function getUniqueRunDependency(id) { + return id + } + + function addRunDependency(id) { + runDependencies++; + if (Module["monitorRunDependencies"]) { + Module["monitorRunDependencies"](runDependencies) + } + } + + function removeRunDependency(id) { + runDependencies--; + if (Module["monitorRunDependencies"]) { + Module["monitorRunDependencies"](runDependencies) + } + if (runDependencies == 0) { + if (runDependencyWatcher !== null) { + clearInterval(runDependencyWatcher); + runDependencyWatcher = null + } + if (dependenciesFulfilled) { + var callback = dependenciesFulfilled; + dependenciesFulfilled = null; + callback() + } + } + } + + function abort(what) { + if (Module["onAbort"]) { + Module["onAbort"](what) + } + what = "Aborted(" + what + ")"; + err(what); + ABORT = true; + EXITSTATUS = 1; + what += ". Build with -sASSERTIONS for more info."; + var e = new WebAssembly.RuntimeError(what); + throw e + } + var dataURIPrefix = "data:application/octet-stream;base64,"; + + function isDataURI(filename) { + return filename.startsWith(dataURIPrefix) + } + + function isFileURI(filename) { + return filename.startsWith("file://") + } + var wasmBinaryFile; + if (PDFiumModule.url) { + wasmBinaryFile = PDFiumModule.url + '/pdfium.wasm'; + } + else { + wasmBinaryFile = 'pdfium.wasm'; + } + if (!isDataURI(wasmBinaryFile)) { + wasmBinaryFile = locateFile(wasmBinaryFile) + } + + function getBinary(file) { + try { + if (file == wasmBinaryFile && wasmBinary) { + return new Uint8Array(wasmBinary) + } + if (readBinary) { + return readBinary(file) + } + throw "both async and sync fetching of the wasm failed" + } catch (err) { + abort(err) + } + } + + function getBinaryPromise(binaryFile) { + if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) { + if (typeof fetch == "function" && !isFileURI(binaryFile)) { + return fetch(binaryFile, { + credentials: "same-origin" + }).then(function (response) { + if (!response["ok"]) { + throw "failed to load wasm binary file at '" + binaryFile + "'" + } + return response["arrayBuffer"]() + }).catch(function () { + return getBinary(binaryFile) + }) + } else { + if (readAsync) { + return new Promise(function (resolve, reject) { + readAsync(binaryFile, function (response) { + resolve(new Uint8Array(response)) + }, reject) + }) + } + } + } + return Promise.resolve().then(function () { + return getBinary(binaryFile) + }) + } + + function instantiateArrayBuffer(binaryFile, imports, receiver) { + return getBinaryPromise(binaryFile).then(function (binary) { + return WebAssembly.instantiate(binary, imports) + }).then(function (instance) { + return instance + }).then(receiver, function (reason) { + err("failed to asynchronously prepare wasm: " + reason); + abort(reason) + }) + } + + function instantiateAsync(binary, binaryFile, imports, callback) { + if (!binary && typeof WebAssembly.instantiateStreaming == "function" && !isDataURI(binaryFile) && !isFileURI(binaryFile) && !ENVIRONMENT_IS_NODE && typeof fetch == "function") { + return fetch(binaryFile, { + credentials: "same-origin" + }).then(function (response) { + var result = WebAssembly.instantiateStreaming(response, imports); + return result.then(callback, function (reason) { + err("wasm streaming compile failed: " + reason); + err("falling back to ArrayBuffer instantiation"); + return instantiateArrayBuffer(binaryFile, imports, callback) + }) + }) + } else { + return instantiateArrayBuffer(binaryFile, imports, callback) + } + } + + function createWasm() { + var info = { + "env": wasmImports, + "wasi_snapshot_preview1": wasmImports + }; + + function receiveInstance(instance, module) { + var exports = instance.exports; + Module["asm"] = exports; + wasmMemory = Module["asm"]["memory"]; + updateMemoryViews(); + wasmTable = Module["asm"]["__indirect_function_table"]; + addOnInit(Module["asm"]["__wasm_call_ctors"]); + removeRunDependency("wasm-instantiate"); + return exports + } + addRunDependency("wasm-instantiate"); + + function receiveInstantiationResult(result) { + receiveInstance(result["instance"]) + } + if (Module["instantiateWasm"]) { + try { + return Module["instantiateWasm"](info, receiveInstance) + } catch (e) { + err("Module.instantiateWasm callback failed with error: " + e); + return false + } + } + instantiateAsync(wasmBinary, wasmBinaryFile, info, receiveInstantiationResult); + return {} + } + var tempDouble; + var tempI64; + + function ExitStatus(status) { + this.name = "ExitStatus"; + this.message = "Program terminated with exit(" + status + ")"; + this.status = status + } + + function callRuntimeCallbacks(callbacks) { + while (callbacks.length > 0) { + callbacks.shift()(Module) + } + } + var wasmTableMirror = []; + + function getWasmTableEntry(funcPtr) { + var func = wasmTableMirror[funcPtr]; + if (!func) { + if (funcPtr >= wasmTableMirror.length) wasmTableMirror.length = funcPtr + 1; + wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr) + } + return func + } + + function ___call_sighandler(fp, sig) { + getWasmTableEntry(fp)(sig) + } + + function setErrNo(value) { + HEAP32[___errno_location() >> 2] = value; + return value + } + var PATH = { + isAbs: path => path.charAt(0) === "/", + splitPath: filename => { + var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/; + return splitPathRe.exec(filename).slice(1) + }, + normalizeArray: (parts, allowAboveRoot) => { + var up = 0; + for (var i = parts.length - 1; i >= 0; i--) { + var last = parts[i]; + if (last === ".") { + parts.splice(i, 1) + } else if (last === "..") { + parts.splice(i, 1); + up++ + } else if (up) { + parts.splice(i, 1); + up-- + } + } + if (allowAboveRoot) { + for (; up; up--) { + parts.unshift("..") + } + } + return parts + }, + normalize: path => { + var isAbsolute = PATH.isAbs(path), + trailingSlash = path.substr(-1) === "/"; + path = PATH.normalizeArray(path.split("/").filter(p => !!p), !isAbsolute).join("/"); + if (!path && !isAbsolute) { + path = "." + } + if (path && trailingSlash) { + path += "/" + } + return (isAbsolute ? "/" : "") + path + }, + dirname: path => { + var result = PATH.splitPath(path), + root = result[0], + dir = result[1]; + if (!root && !dir) { + return "." + } + if (dir) { + dir = dir.substr(0, dir.length - 1) + } + return root + dir + }, + basename: path => { + if (path === "/") return "/"; + path = PATH.normalize(path); + path = path.replace(/\/$/, ""); + var lastSlash = path.lastIndexOf("/"); + if (lastSlash === -1) return path; + return path.substr(lastSlash + 1) + }, + join: function () { + var paths = Array.prototype.slice.call(arguments); + return PATH.normalize(paths.join("/")) + }, + join2: (l, r) => { + return PATH.normalize(l + "/" + r) + } + }; + + function getRandomDevice() { + if (typeof crypto == "object" && typeof crypto["getRandomValues"] == "function") { + var randomBuffer = new Uint8Array(1); + return () => { + crypto.getRandomValues(randomBuffer); + return randomBuffer[0] + } + } else if (ENVIRONMENT_IS_NODE) { + try { + var crypto_module = require("crypto"); + return () => crypto_module["randomBytes"](1)[0] + } catch (e) {} + } + return () => abort("randomDevice") + } + var PATH_FS = { + resolve: function () { + var resolvedPath = "", + resolvedAbsolute = false; + for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) { + var path = i >= 0 ? arguments[i] : FS.cwd(); + if (typeof path != "string") { + throw new TypeError("Arguments to path.resolve must be strings") + } else if (!path) { + return "" + } + resolvedPath = path + "/" + resolvedPath; + resolvedAbsolute = PATH.isAbs(path) + } + resolvedPath = PATH.normalizeArray(resolvedPath.split("/").filter(p => !!p), !resolvedAbsolute).join("/"); + return (resolvedAbsolute ? "/" : "") + resolvedPath || "." + }, + relative: (from, to) => { + from = PATH_FS.resolve(from).substr(1); + to = PATH_FS.resolve(to).substr(1); + + function trim(arr) { + var start = 0; + for (; start < arr.length; start++) { + if (arr[start] !== "") break + } + var end = arr.length - 1; + for (; end >= 0; end--) { + if (arr[end] !== "") break + } + if (start > end) return []; + return arr.slice(start, end - start + 1) + } + var fromParts = trim(from.split("/")); + var toParts = trim(to.split("/")); + var length = Math.min(fromParts.length, toParts.length); + var samePartsLength = length; + for (var i = 0; i < length; i++) { + if (fromParts[i] !== toParts[i]) { + samePartsLength = i; + break + } + } + var outputParts = []; + for (var i = samePartsLength; i < fromParts.length; i++) { + outputParts.push("..") + } + outputParts = outputParts.concat(toParts.slice(samePartsLength)); + return outputParts.join("/") + } + }; + + function intArrayFromString(stringy, dontAddNull, length) { + var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1; + var u8array = new Array(len); + var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length); + if (dontAddNull) u8array.length = numBytesWritten; + return u8array + } + var TTY = { + ttys: [], + init: function () {}, + shutdown: function () {}, + register: function (dev, ops) { + TTY.ttys[dev] = { + input: [], + output: [], + ops: ops + }; + FS.registerDevice(dev, TTY.stream_ops) + }, + stream_ops: { + open: function (stream) { + var tty = TTY.ttys[stream.node.rdev]; + if (!tty) { + throw new FS.ErrnoError(43) + } + stream.tty = tty; + stream.seekable = false + }, + close: function (stream) { + stream.tty.ops.fsync(stream.tty) + }, + fsync: function (stream) { + stream.tty.ops.fsync(stream.tty) + }, + read: function (stream, buffer, offset, length, pos) { + if (!stream.tty || !stream.tty.ops.get_char) { + throw new FS.ErrnoError(60) + } + var bytesRead = 0; + for (var i = 0; i < length; i++) { + var result; + try { + result = stream.tty.ops.get_char(stream.tty) + } catch (e) { + throw new FS.ErrnoError(29) + } + if (result === undefined && bytesRead === 0) { + throw new FS.ErrnoError(6) + } + if (result === null || result === undefined) break; + bytesRead++; + buffer[offset + i] = result + } + if (bytesRead) { + stream.node.timestamp = Date.now() + } + return bytesRead + }, + write: function (stream, buffer, offset, length, pos) { + if (!stream.tty || !stream.tty.ops.put_char) { + throw new FS.ErrnoError(60) + } + try { + for (var i = 0; i < length; i++) { + stream.tty.ops.put_char(stream.tty, buffer[offset + i]) + } + } catch (e) { + throw new FS.ErrnoError(29) + } + if (length) { + stream.node.timestamp = Date.now() + } + return i + } + }, + default_tty_ops: { + get_char: function (tty) { + if (!tty.input.length) { + var result = null; + if (ENVIRONMENT_IS_NODE) { + var BUFSIZE = 256; + var buf = Buffer.alloc(BUFSIZE); + var bytesRead = 0; + try { + bytesRead = fs.readSync(process.stdin.fd, buf, 0, BUFSIZE, -1) + } catch (e) { + if (e.toString().includes("EOF")) bytesRead = 0; + else throw e + } + if (bytesRead > 0) { + result = buf.slice(0, bytesRead).toString("utf-8") + } else { + result = null + } + } else if (typeof window != "undefined" && typeof window.prompt == "function") { + result = window.prompt("Input: "); + if (result !== null) { + result += "\n" + } + } else if (typeof readline == "function") { + result = readline(); + if (result !== null) { + result += "\n" + } + } + if (!result) { + return null + } + tty.input = intArrayFromString(result, true) + } + return tty.input.shift() + }, + put_char: function (tty, val) { + if (val === null || val === 10) { + out(UTF8ArrayToString(tty.output, 0)); + tty.output = [] + } else { + if (val != 0) tty.output.push(val) + } + }, + fsync: function (tty) { + if (tty.output && tty.output.length > 0) { + out(UTF8ArrayToString(tty.output, 0)); + tty.output = [] + } + } + }, + default_tty1_ops: { + put_char: function (tty, val) { + if (val === null || val === 10) { + err(UTF8ArrayToString(tty.output, 0)); + tty.output = [] + } else { + if (val != 0) tty.output.push(val) + } + }, + fsync: function (tty) { + if (tty.output && tty.output.length > 0) { + err(UTF8ArrayToString(tty.output, 0)); + tty.output = [] + } + } + } + }; + + function zeroMemory(address, size) { + HEAPU8.fill(0, address, address + size); + return address + } + + function alignMemory(size, alignment) { + return Math.ceil(size / alignment) * alignment + } + + function mmapAlloc(size) { + size = alignMemory(size, 65536); + var ptr = _emscripten_builtin_memalign(65536, size); + if (!ptr) return 0; + return zeroMemory(ptr, size) + } + var MEMFS = { + ops_table: null, + mount: function (mount) { + return MEMFS.createNode(null, "/", 16384 | 511, 0) + }, + createNode: function (parent, name, mode, dev) { + if (FS.isBlkdev(mode) || FS.isFIFO(mode)) { + throw new FS.ErrnoError(63) + } + if (!MEMFS.ops_table) { + MEMFS.ops_table = { + dir: { + node: { + getattr: MEMFS.node_ops.getattr, + setattr: MEMFS.node_ops.setattr, + lookup: MEMFS.node_ops.lookup, + mknod: MEMFS.node_ops.mknod, + rename: MEMFS.node_ops.rename, + unlink: MEMFS.node_ops.unlink, + rmdir: MEMFS.node_ops.rmdir, + readdir: MEMFS.node_ops.readdir, + symlink: MEMFS.node_ops.symlink + }, + stream: { + llseek: MEMFS.stream_ops.llseek + } + }, + file: { + node: { + getattr: MEMFS.node_ops.getattr, + setattr: MEMFS.node_ops.setattr + }, + stream: { + llseek: MEMFS.stream_ops.llseek, + read: MEMFS.stream_ops.read, + write: MEMFS.stream_ops.write, + allocate: MEMFS.stream_ops.allocate, + mmap: MEMFS.stream_ops.mmap, + msync: MEMFS.stream_ops.msync + } + }, + link: { + node: { + getattr: MEMFS.node_ops.getattr, + setattr: MEMFS.node_ops.setattr, + readlink: MEMFS.node_ops.readlink + }, + stream: {} + }, + chrdev: { + node: { + getattr: MEMFS.node_ops.getattr, + setattr: MEMFS.node_ops.setattr + }, + stream: FS.chrdev_stream_ops + } + } + } + var node = FS.createNode(parent, name, mode, dev); + if (FS.isDir(node.mode)) { + node.node_ops = MEMFS.ops_table.dir.node; + node.stream_ops = MEMFS.ops_table.dir.stream; + node.contents = {} + } else if (FS.isFile(node.mode)) { + node.node_ops = MEMFS.ops_table.file.node; + node.stream_ops = MEMFS.ops_table.file.stream; + node.usedBytes = 0; + node.contents = null + } else if (FS.isLink(node.mode)) { + node.node_ops = MEMFS.ops_table.link.node; + node.stream_ops = MEMFS.ops_table.link.stream + } else if (FS.isChrdev(node.mode)) { + node.node_ops = MEMFS.ops_table.chrdev.node; + node.stream_ops = MEMFS.ops_table.chrdev.stream + } + node.timestamp = Date.now(); + if (parent) { + parent.contents[name] = node; + parent.timestamp = node.timestamp + } + return node + }, + getFileDataAsTypedArray: function (node) { + if (!node.contents) return new Uint8Array(0); + if (node.contents.subarray) return node.contents.subarray(0, node.usedBytes); + return new Uint8Array(node.contents) + }, + expandFileStorage: function (node, newCapacity) { + var prevCapacity = node.contents ? node.contents.length : 0; + if (prevCapacity >= newCapacity) return; + var CAPACITY_DOUBLING_MAX = 1024 * 1024; + newCapacity = Math.max(newCapacity, prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2 : 1.125) >>> 0); + if (prevCapacity != 0) newCapacity = Math.max(newCapacity, 256); + var oldContents = node.contents; + node.contents = new Uint8Array(newCapacity); + if (node.usedBytes > 0) node.contents.set(oldContents.subarray(0, node.usedBytes), 0) + }, + resizeFileStorage: function (node, newSize) { + if (node.usedBytes == newSize) return; + if (newSize == 0) { + node.contents = null; + node.usedBytes = 0 + } else { + var oldContents = node.contents; + node.contents = new Uint8Array(newSize); + if (oldContents) { + node.contents.set(oldContents.subarray(0, Math.min(newSize, node.usedBytes))) + } + node.usedBytes = newSize + } + }, + node_ops: { + getattr: function (node) { + var attr = {}; + attr.dev = FS.isChrdev(node.mode) ? node.id : 1; + attr.ino = node.id; + attr.mode = node.mode; + attr.nlink = 1; + attr.uid = 0; + attr.gid = 0; + attr.rdev = node.rdev; + if (FS.isDir(node.mode)) { + attr.size = 4096 + } else if (FS.isFile(node.mode)) { + attr.size = node.usedBytes + } else if (FS.isLink(node.mode)) { + attr.size = node.link.length + } else { + attr.size = 0 + } + attr.atime = new Date(node.timestamp); + attr.mtime = new Date(node.timestamp); + attr.ctime = new Date(node.timestamp); + attr.blksize = 4096; + attr.blocks = Math.ceil(attr.size / attr.blksize); + return attr + }, + setattr: function (node, attr) { + if (attr.mode !== undefined) { + node.mode = attr.mode + } + if (attr.timestamp !== undefined) { + node.timestamp = attr.timestamp + } + if (attr.size !== undefined) { + MEMFS.resizeFileStorage(node, attr.size) + } + }, + lookup: function (parent, name) { + throw FS.genericErrors[44] + }, + mknod: function (parent, name, mode, dev) { + return MEMFS.createNode(parent, name, mode, dev) + }, + rename: function (old_node, new_dir, new_name) { + if (FS.isDir(old_node.mode)) { + var new_node; + try { + new_node = FS.lookupNode(new_dir, new_name) + } catch (e) {} + if (new_node) { + for (var i in new_node.contents) { + throw new FS.ErrnoError(55) + } + } + } + delete old_node.parent.contents[old_node.name]; + old_node.parent.timestamp = Date.now(); + old_node.name = new_name; + new_dir.contents[new_name] = old_node; + new_dir.timestamp = old_node.parent.timestamp; + old_node.parent = new_dir + }, + unlink: function (parent, name) { + delete parent.contents[name]; + parent.timestamp = Date.now() + }, + rmdir: function (parent, name) { + var node = FS.lookupNode(parent, name); + for (var i in node.contents) { + throw new FS.ErrnoError(55) + } + delete parent.contents[name]; + parent.timestamp = Date.now() + }, + readdir: function (node) { + var entries = [".", ".."]; + for (var key in node.contents) { + if (!node.contents.hasOwnProperty(key)) { + continue + } + entries.push(key) + } + return entries + }, + symlink: function (parent, newname, oldpath) { + var node = MEMFS.createNode(parent, newname, 511 | 40960, 0); + node.link = oldpath; + return node + }, + readlink: function (node) { + if (!FS.isLink(node.mode)) { + throw new FS.ErrnoError(28) + } + return node.link + } + }, + stream_ops: { + read: function (stream, buffer, offset, length, position) { + var contents = stream.node.contents; + if (position >= stream.node.usedBytes) return 0; + var size = Math.min(stream.node.usedBytes - position, length); + if (size > 8 && contents.subarray) { + buffer.set(contents.subarray(position, position + size), offset) + } else { + for (var i = 0; i < size; i++) buffer[offset + i] = contents[position + i] + } + return size + }, + write: function (stream, buffer, offset, length, position, canOwn) { + if (buffer.buffer === HEAP8.buffer) { + canOwn = false + } + if (!length) return 0; + var node = stream.node; + node.timestamp = Date.now(); + if (buffer.subarray && (!node.contents || node.contents.subarray)) { + if (canOwn) { + node.contents = buffer.subarray(offset, offset + length); + node.usedBytes = length; + return length + } else if (node.usedBytes === 0 && position === 0) { + node.contents = buffer.slice(offset, offset + length); + node.usedBytes = length; + return length + } else if (position + length <= node.usedBytes) { + node.contents.set(buffer.subarray(offset, offset + length), position); + return length + } + } + MEMFS.expandFileStorage(node, position + length); + if (node.contents.subarray && buffer.subarray) { + node.contents.set(buffer.subarray(offset, offset + length), position) + } else { + for (var i = 0; i < length; i++) { + node.contents[position + i] = buffer[offset + i] + } + } + node.usedBytes = Math.max(node.usedBytes, position + length); + return length + }, + llseek: function (stream, offset, whence) { + var position = offset; + if (whence === 1) { + position += stream.position + } else if (whence === 2) { + if (FS.isFile(stream.node.mode)) { + position += stream.node.usedBytes + } + } + if (position < 0) { + throw new FS.ErrnoError(28) + } + return position + }, + allocate: function (stream, offset, length) { + MEMFS.expandFileStorage(stream.node, offset + length); + stream.node.usedBytes = Math.max(stream.node.usedBytes, offset + length) + }, + mmap: function (stream, length, position, prot, flags) { + if (!FS.isFile(stream.node.mode)) { + throw new FS.ErrnoError(43) + } + var ptr; + var allocated; + var contents = stream.node.contents; + if (!(flags & 2) && contents.buffer === HEAP8.buffer) { + allocated = false; + ptr = contents.byteOffset + } else { + if (position > 0 || position + length < contents.length) { + if (contents.subarray) { + contents = contents.subarray(position, position + length) + } else { + contents = Array.prototype.slice.call(contents, position, position + length) + } + } + allocated = true; + ptr = mmapAlloc(length); + if (!ptr) { + throw new FS.ErrnoError(48) + } + HEAP8.set(contents, ptr) + } + return { + ptr: ptr, + allocated: allocated + } + }, + msync: function (stream, buffer, offset, length, mmapFlags) { + MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false); + return 0 + } + } + }; + + function asyncLoad(url, onload, onerror, noRunDep) { + var dep = !noRunDep ? getUniqueRunDependency("al " + url) : ""; + readAsync(url, arrayBuffer => { + assert(arrayBuffer, 'Loading data file "' + url + '" failed (no arrayBuffer).'); + onload(new Uint8Array(arrayBuffer)); + if (dep) removeRunDependency(dep) + }, event => { + if (onerror) { + onerror() + } else { + throw 'Loading data file "' + url + '" failed.' + } + }); + if (dep) addRunDependency(dep) + } + var FS = { + root: null, + mounts: [], + devices: {}, + streams: [], + nextInode: 1, + nameTable: null, + currentPath: "/", + initialized: false, + ignorePermissions: true, + ErrnoError: null, + genericErrors: {}, + filesystems: null, + syncFSRequests: 0, + lookupPath: (path, opts = {}) => { + path = PATH_FS.resolve(path); + if (!path) return { + path: "", + node: null + }; + var defaults = { + follow_mount: true, + recurse_count: 0 + }; + opts = Object.assign(defaults, opts); + if (opts.recurse_count > 8) { + throw new FS.ErrnoError(32) + } + var parts = path.split("/").filter(p => !!p); + var current = FS.root; + var current_path = "/"; + for (var i = 0; i < parts.length; i++) { + var islast = i === parts.length - 1; + if (islast && opts.parent) { + break + } + current = FS.lookupNode(current, parts[i]); + current_path = PATH.join2(current_path, parts[i]); + if (FS.isMountpoint(current)) { + if (!islast || islast && opts.follow_mount) { + current = current.mounted.root + } + } + if (!islast || opts.follow) { + var count = 0; + while (FS.isLink(current.mode)) { + var link = FS.readlink(current_path); + current_path = PATH_FS.resolve(PATH.dirname(current_path), link); + var lookup = FS.lookupPath(current_path, { + recurse_count: opts.recurse_count + 1 + }); + current = lookup.node; + if (count++ > 40) { + throw new FS.ErrnoError(32) + } + } + } + } + return { + path: current_path, + node: current + } + }, + getPath: node => { + var path; + while (true) { + if (FS.isRoot(node)) { + var mount = node.mount.mountpoint; + if (!path) return mount; + return mount[mount.length - 1] !== "/" ? mount + "/" + path : mount + path + } + path = path ? node.name + "/" + path : node.name; + node = node.parent + } + }, + hashName: (parentid, name) => { + var hash = 0; + for (var i = 0; i < name.length; i++) { + hash = (hash << 5) - hash + name.charCodeAt(i) | 0 + } + return (parentid + hash >>> 0) % FS.nameTable.length + }, + hashAddNode: node => { + var hash = FS.hashName(node.parent.id, node.name); + node.name_next = FS.nameTable[hash]; + FS.nameTable[hash] = node + }, + hashRemoveNode: node => { + var hash = FS.hashName(node.parent.id, node.name); + if (FS.nameTable[hash] === node) { + FS.nameTable[hash] = node.name_next + } else { + var current = FS.nameTable[hash]; + while (current) { + if (current.name_next === node) { + current.name_next = node.name_next; + break + } + current = current.name_next + } + } + }, + lookupNode: (parent, name) => { + var errCode = FS.mayLookup(parent); + if (errCode) { + throw new FS.ErrnoError(errCode, parent) + } + var hash = FS.hashName(parent.id, name); + for (var node = FS.nameTable[hash]; node; node = node.name_next) { + var nodeName = node.name; + if (node.parent.id === parent.id && nodeName === name) { + return node + } + } + return FS.lookup(parent, name) + }, + createNode: (parent, name, mode, rdev) => { + var node = new FS.FSNode(parent, name, mode, rdev); + FS.hashAddNode(node); + return node + }, + destroyNode: node => { + FS.hashRemoveNode(node) + }, + isRoot: node => { + return node === node.parent + }, + isMountpoint: node => { + return !!node.mounted + }, + isFile: mode => { + return (mode & 61440) === 32768 + }, + isDir: mode => { + return (mode & 61440) === 16384 + }, + isLink: mode => { + return (mode & 61440) === 40960 + }, + isChrdev: mode => { + return (mode & 61440) === 8192 + }, + isBlkdev: mode => { + return (mode & 61440) === 24576 + }, + isFIFO: mode => { + return (mode & 61440) === 4096 + }, + isSocket: mode => { + return (mode & 49152) === 49152 + }, + flagModes: { + "r": 0, + "r+": 2, + "w": 577, + "w+": 578, + "a": 1089, + "a+": 1090 + }, + modeStringToFlags: str => { + var flags = FS.flagModes[str]; + if (typeof flags == "undefined") { + throw new Error("Unknown file open mode: " + str) + } + return flags + }, + flagsToPermissionString: flag => { + var perms = ["r", "w", "rw"][flag & 3]; + if (flag & 512) { + perms += "w" + } + return perms + }, + nodePermissions: (node, perms) => { + if (FS.ignorePermissions) { + return 0 + } + if (perms.includes("r") && !(node.mode & 292)) { + return 2 + } else if (perms.includes("w") && !(node.mode & 146)) { + return 2 + } else if (perms.includes("x") && !(node.mode & 73)) { + return 2 + } + return 0 + }, + mayLookup: dir => { + var errCode = FS.nodePermissions(dir, "x"); + if (errCode) return errCode; + if (!dir.node_ops.lookup) return 2; + return 0 + }, + mayCreate: (dir, name) => { + try { + var node = FS.lookupNode(dir, name); + return 20 + } catch (e) {} + return FS.nodePermissions(dir, "wx") + }, + mayDelete: (dir, name, isdir) => { + var node; + try { + node = FS.lookupNode(dir, name) + } catch (e) { + return e.errno + } + var errCode = FS.nodePermissions(dir, "wx"); + if (errCode) { + return errCode + } + if (isdir) { + if (!FS.isDir(node.mode)) { + return 54 + } + if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) { + return 10 + } + } else { + if (FS.isDir(node.mode)) { + return 31 + } + } + return 0 + }, + mayOpen: (node, flags) => { + if (!node) { + return 44 + } + if (FS.isLink(node.mode)) { + return 32 + } else if (FS.isDir(node.mode)) { + if (FS.flagsToPermissionString(flags) !== "r" || flags & 512) { + return 31 + } + } + return FS.nodePermissions(node, FS.flagsToPermissionString(flags)) + }, + MAX_OPEN_FDS: 4096, + nextfd: (fd_start = 0, fd_end = FS.MAX_OPEN_FDS) => { + for (var fd = fd_start; fd <= fd_end; fd++) { + if (!FS.streams[fd]) { + return fd + } + } + throw new FS.ErrnoError(33) + }, + getStream: fd => FS.streams[fd], + createStream: (stream, fd_start, fd_end) => { + if (!FS.FSStream) { + FS.FSStream = function () { + this.shared = {} + }; + FS.FSStream.prototype = {}; + Object.defineProperties(FS.FSStream.prototype, { + object: { + get: function () { + return this.node + }, + set: function (val) { + this.node = val + } + }, + isRead: { + get: function () { + return (this.flags & 2097155) !== 1 + } + }, + isWrite: { + get: function () { + return (this.flags & 2097155) !== 0 + } + }, + isAppend: { + get: function () { + return this.flags & 1024 + } + }, + flags: { + get: function () { + return this.shared.flags + }, + set: function (val) { + this.shared.flags = val + } + }, + position: { + get: function () { + return this.shared.position + }, + set: function (val) { + this.shared.position = val + } + } + }) + } + stream = Object.assign(new FS.FSStream, stream); + var fd = FS.nextfd(fd_start, fd_end); + stream.fd = fd; + FS.streams[fd] = stream; + return stream + }, + closeStream: fd => { + FS.streams[fd] = null + }, + chrdev_stream_ops: { + open: stream => { + var device = FS.getDevice(stream.node.rdev); + stream.stream_ops = device.stream_ops; + if (stream.stream_ops.open) { + stream.stream_ops.open(stream) + } + }, + llseek: () => { + throw new FS.ErrnoError(70) + } + }, + major: dev => dev >> 8, + minor: dev => dev & 255, + makedev: (ma, mi) => ma << 8 | mi, + registerDevice: (dev, ops) => { + FS.devices[dev] = { + stream_ops: ops + } + }, + getDevice: dev => FS.devices[dev], + getMounts: mount => { + var mounts = []; + var check = [mount]; + while (check.length) { + var m = check.pop(); + mounts.push(m); + check.push.apply(check, m.mounts) + } + return mounts + }, + syncfs: (populate, callback) => { + if (typeof populate == "function") { + callback = populate; + populate = false + } + FS.syncFSRequests++; + if (FS.syncFSRequests > 1) { + err("warning: " + FS.syncFSRequests + " FS.syncfs operations in flight at once, probably just doing extra work") + } + var mounts = FS.getMounts(FS.root.mount); + var completed = 0; + + function doCallback(errCode) { + FS.syncFSRequests--; + return callback(errCode) + } + + function done(errCode) { + if (errCode) { + if (!done.errored) { + done.errored = true; + return doCallback(errCode) + } + return + } + if (++completed >= mounts.length) { + doCallback(null) + } + } + mounts.forEach(mount => { + if (!mount.type.syncfs) { + return done(null) + } + mount.type.syncfs(mount, populate, done) + }) + }, + mount: (type, opts, mountpoint) => { + var root = mountpoint === "/"; + var pseudo = !mountpoint; + var node; + if (root && FS.root) { + throw new FS.ErrnoError(10) + } else if (!root && !pseudo) { + var lookup = FS.lookupPath(mountpoint, { + follow_mount: false + }); + mountpoint = lookup.path; + node = lookup.node; + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10) + } + if (!FS.isDir(node.mode)) { + throw new FS.ErrnoError(54) + } + } + var mount = { + type: type, + opts: opts, + mountpoint: mountpoint, + mounts: [] + }; + var mountRoot = type.mount(mount); + mountRoot.mount = mount; + mount.root = mountRoot; + if (root) { + FS.root = mountRoot + } else if (node) { + node.mounted = mount; + if (node.mount) { + node.mount.mounts.push(mount) + } + } + return mountRoot + }, + unmount: mountpoint => { + var lookup = FS.lookupPath(mountpoint, { + follow_mount: false + }); + if (!FS.isMountpoint(lookup.node)) { + throw new FS.ErrnoError(28) + } + var node = lookup.node; + var mount = node.mounted; + var mounts = FS.getMounts(mount); + Object.keys(FS.nameTable).forEach(hash => { + var current = FS.nameTable[hash]; + while (current) { + var next = current.name_next; + if (mounts.includes(current.mount)) { + FS.destroyNode(current) + } + current = next + } + }); + node.mounted = null; + var idx = node.mount.mounts.indexOf(mount); + node.mount.mounts.splice(idx, 1) + }, + lookup: (parent, name) => { + return parent.node_ops.lookup(parent, name) + }, + mknod: (path, mode, dev) => { + var lookup = FS.lookupPath(path, { + parent: true + }); + var parent = lookup.node; + var name = PATH.basename(path); + if (!name || name === "." || name === "..") { + throw new FS.ErrnoError(28) + } + var errCode = FS.mayCreate(parent, name); + if (errCode) { + throw new FS.ErrnoError(errCode) + } + if (!parent.node_ops.mknod) { + throw new FS.ErrnoError(63) + } + return parent.node_ops.mknod(parent, name, mode, dev) + }, + create: (path, mode) => { + mode = mode !== undefined ? mode : 438; + mode &= 4095; + mode |= 32768; + return FS.mknod(path, mode, 0) + }, + mkdir: (path, mode) => { + mode = mode !== undefined ? mode : 511; + mode &= 511 | 512; + mode |= 16384; + return FS.mknod(path, mode, 0) + }, + mkdirTree: (path, mode) => { + var dirs = path.split("/"); + var d = ""; + for (var i = 0; i < dirs.length; ++i) { + if (!dirs[i]) continue; + d += "/" + dirs[i]; + try { + FS.mkdir(d, mode) + } catch (e) { + if (e.errno != 20) throw e + } + } + }, + mkdev: (path, mode, dev) => { + if (typeof dev == "undefined") { + dev = mode; + mode = 438 + } + mode |= 8192; + return FS.mknod(path, mode, dev) + }, + symlink: (oldpath, newpath) => { + if (!PATH_FS.resolve(oldpath)) { + throw new FS.ErrnoError(44) + } + var lookup = FS.lookupPath(newpath, { + parent: true + }); + var parent = lookup.node; + if (!parent) { + throw new FS.ErrnoError(44) + } + var newname = PATH.basename(newpath); + var errCode = FS.mayCreate(parent, newname); + if (errCode) { + throw new FS.ErrnoError(errCode) + } + if (!parent.node_ops.symlink) { + throw new FS.ErrnoError(63) + } + return parent.node_ops.symlink(parent, newname, oldpath) + }, + rename: (old_path, new_path) => { + var old_dirname = PATH.dirname(old_path); + var new_dirname = PATH.dirname(new_path); + var old_name = PATH.basename(old_path); + var new_name = PATH.basename(new_path); + var lookup, old_dir, new_dir; + lookup = FS.lookupPath(old_path, { + parent: true + }); + old_dir = lookup.node; + lookup = FS.lookupPath(new_path, { + parent: true + }); + new_dir = lookup.node; + if (!old_dir || !new_dir) throw new FS.ErrnoError(44); + if (old_dir.mount !== new_dir.mount) { + throw new FS.ErrnoError(75) + } + var old_node = FS.lookupNode(old_dir, old_name); + var relative = PATH_FS.relative(old_path, new_dirname); + if (relative.charAt(0) !== ".") { + throw new FS.ErrnoError(28) + } + relative = PATH_FS.relative(new_path, old_dirname); + if (relative.charAt(0) !== ".") { + throw new FS.ErrnoError(55) + } + var new_node; + try { + new_node = FS.lookupNode(new_dir, new_name) + } catch (e) {} + if (old_node === new_node) { + return + } + var isdir = FS.isDir(old_node.mode); + var errCode = FS.mayDelete(old_dir, old_name, isdir); + if (errCode) { + throw new FS.ErrnoError(errCode) + } + errCode = new_node ? FS.mayDelete(new_dir, new_name, isdir) : FS.mayCreate(new_dir, new_name); + if (errCode) { + throw new FS.ErrnoError(errCode) + } + if (!old_dir.node_ops.rename) { + throw new FS.ErrnoError(63) + } + if (FS.isMountpoint(old_node) || new_node && FS.isMountpoint(new_node)) { + throw new FS.ErrnoError(10) + } + if (new_dir !== old_dir) { + errCode = FS.nodePermissions(old_dir, "w"); + if (errCode) { + throw new FS.ErrnoError(errCode) + } + } + FS.hashRemoveNode(old_node); + try { + old_dir.node_ops.rename(old_node, new_dir, new_name) + } catch (e) { + throw e + } finally { + FS.hashAddNode(old_node) + } + }, + rmdir: path => { + var lookup = FS.lookupPath(path, { + parent: true + }); + var parent = lookup.node; + var name = PATH.basename(path); + var node = FS.lookupNode(parent, name); + var errCode = FS.mayDelete(parent, name, true); + if (errCode) { + throw new FS.ErrnoError(errCode) + } + if (!parent.node_ops.rmdir) { + throw new FS.ErrnoError(63) + } + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10) + } + parent.node_ops.rmdir(parent, name); + FS.destroyNode(node) + }, + readdir: path => { + var lookup = FS.lookupPath(path, { + follow: true + }); + var node = lookup.node; + if (!node.node_ops.readdir) { + throw new FS.ErrnoError(54) + } + return node.node_ops.readdir(node) + }, + unlink: path => { + var lookup = FS.lookupPath(path, { + parent: true + }); + var parent = lookup.node; + if (!parent) { + throw new FS.ErrnoError(44) + } + var name = PATH.basename(path); + var node = FS.lookupNode(parent, name); + var errCode = FS.mayDelete(parent, name, false); + if (errCode) { + throw new FS.ErrnoError(errCode) + } + if (!parent.node_ops.unlink) { + throw new FS.ErrnoError(63) + } + if (FS.isMountpoint(node)) { + throw new FS.ErrnoError(10) + } + parent.node_ops.unlink(parent, name); + FS.destroyNode(node) + }, + readlink: path => { + var lookup = FS.lookupPath(path); + var link = lookup.node; + if (!link) { + throw new FS.ErrnoError(44) + } + if (!link.node_ops.readlink) { + throw new FS.ErrnoError(28) + } + return PATH_FS.resolve(FS.getPath(link.parent), link.node_ops.readlink(link)) + }, + stat: (path, dontFollow) => { + var lookup = FS.lookupPath(path, { + follow: !dontFollow + }); + var node = lookup.node; + if (!node) { + throw new FS.ErrnoError(44) + } + if (!node.node_ops.getattr) { + throw new FS.ErrnoError(63) + } + return node.node_ops.getattr(node) + }, + lstat: path => { + return FS.stat(path, true) + }, + chmod: (path, mode, dontFollow) => { + var node; + if (typeof path == "string") { + var lookup = FS.lookupPath(path, { + follow: !dontFollow + }); + node = lookup.node + } else { + node = path + } + if (!node.node_ops.setattr) { + throw new FS.ErrnoError(63) + } + node.node_ops.setattr(node, { + mode: mode & 4095 | node.mode & ~4095, + timestamp: Date.now() + }) + }, + lchmod: (path, mode) => { + FS.chmod(path, mode, true) + }, + fchmod: (fd, mode) => { + var stream = FS.getStream(fd); + if (!stream) { + throw new FS.ErrnoError(8) + } + FS.chmod(stream.node, mode) + }, + chown: (path, uid, gid, dontFollow) => { + var node; + if (typeof path == "string") { + var lookup = FS.lookupPath(path, { + follow: !dontFollow + }); + node = lookup.node + } else { + node = path + } + if (!node.node_ops.setattr) { + throw new FS.ErrnoError(63) + } + node.node_ops.setattr(node, { + timestamp: Date.now() + }) + }, + lchown: (path, uid, gid) => { + FS.chown(path, uid, gid, true) + }, + fchown: (fd, uid, gid) => { + var stream = FS.getStream(fd); + if (!stream) { + throw new FS.ErrnoError(8) + } + FS.chown(stream.node, uid, gid) + }, + truncate: (path, len) => { + if (len < 0) { + throw new FS.ErrnoError(28) + } + var node; + if (typeof path == "string") { + var lookup = FS.lookupPath(path, { + follow: true + }); + node = lookup.node + } else { + node = path + } + if (!node.node_ops.setattr) { + throw new FS.ErrnoError(63) + } + if (FS.isDir(node.mode)) { + throw new FS.ErrnoError(31) + } + if (!FS.isFile(node.mode)) { + throw new FS.ErrnoError(28) + } + var errCode = FS.nodePermissions(node, "w"); + if (errCode) { + throw new FS.ErrnoError(errCode) + } + node.node_ops.setattr(node, { + size: len, + timestamp: Date.now() + }) + }, + ftruncate: (fd, len) => { + var stream = FS.getStream(fd); + if (!stream) { + throw new FS.ErrnoError(8) + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(28) + } + FS.truncate(stream.node, len) + }, + utime: (path, atime, mtime) => { + var lookup = FS.lookupPath(path, { + follow: true + }); + var node = lookup.node; + node.node_ops.setattr(node, { + timestamp: Math.max(atime, mtime) + }) + }, + open: (path, flags, mode) => { + if (path === "") { + throw new FS.ErrnoError(44) + } + flags = typeof flags == "string" ? FS.modeStringToFlags(flags) : flags; + mode = typeof mode == "undefined" ? 438 : mode; + if (flags & 64) { + mode = mode & 4095 | 32768 + } else { + mode = 0 + } + var node; + if (typeof path == "object") { + node = path + } else { + path = PATH.normalize(path); + try { + var lookup = FS.lookupPath(path, { + follow: !(flags & 131072) + }); + node = lookup.node + } catch (e) {} + } + var created = false; + if (flags & 64) { + if (node) { + if (flags & 128) { + throw new FS.ErrnoError(20) + } + } else { + node = FS.mknod(path, mode, 0); + created = true + } + } + if (!node) { + throw new FS.ErrnoError(44) + } + if (FS.isChrdev(node.mode)) { + flags &= ~512 + } + if (flags & 65536 && !FS.isDir(node.mode)) { + throw new FS.ErrnoError(54) + } + if (!created) { + var errCode = FS.mayOpen(node, flags); + if (errCode) { + throw new FS.ErrnoError(errCode) + } + } + if (flags & 512 && !created) { + FS.truncate(node, 0) + } + flags &= ~(128 | 512 | 131072); + var stream = FS.createStream({ + node: node, + path: FS.getPath(node), + flags: flags, + seekable: true, + position: 0, + stream_ops: node.stream_ops, + ungotten: [], + error: false + }); + if (stream.stream_ops.open) { + stream.stream_ops.open(stream) + } + if (Module["logReadFiles"] && !(flags & 1)) { + if (!FS.readFiles) FS.readFiles = {}; + if (!(path in FS.readFiles)) { + FS.readFiles[path] = 1 + } + } + return stream + }, + close: stream => { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8) + } + if (stream.getdents) stream.getdents = null; + try { + if (stream.stream_ops.close) { + stream.stream_ops.close(stream) + } + } catch (e) { + throw e + } finally { + FS.closeStream(stream.fd) + } + stream.fd = null + }, + isClosed: stream => { + return stream.fd === null + }, + llseek: (stream, offset, whence) => { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8) + } + if (!stream.seekable || !stream.stream_ops.llseek) { + throw new FS.ErrnoError(70) + } + if (whence != 0 && whence != 1 && whence != 2) { + throw new FS.ErrnoError(28) + } + stream.position = stream.stream_ops.llseek(stream, offset, whence); + stream.ungotten = []; + return stream.position + }, + read: (stream, buffer, offset, length, position) => { + if (length < 0 || position < 0) { + throw new FS.ErrnoError(28) + } + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8) + } + if ((stream.flags & 2097155) === 1) { + throw new FS.ErrnoError(8) + } + if (FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(31) + } + if (!stream.stream_ops.read) { + throw new FS.ErrnoError(28) + } + var seeking = typeof position != "undefined"; + if (!seeking) { + position = stream.position + } else if (!stream.seekable) { + throw new FS.ErrnoError(70) + } + var bytesRead = stream.stream_ops.read(stream, buffer, offset, length, position); + if (!seeking) stream.position += bytesRead; + return bytesRead + }, + write: (stream, buffer, offset, length, position, canOwn) => { + if (length < 0 || position < 0) { + throw new FS.ErrnoError(28) + } + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8) + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(8) + } + if (FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(31) + } + if (!stream.stream_ops.write) { + throw new FS.ErrnoError(28) + } + if (stream.seekable && stream.flags & 1024) { + FS.llseek(stream, 0, 2) + } + var seeking = typeof position != "undefined"; + if (!seeking) { + position = stream.position + } else if (!stream.seekable) { + throw new FS.ErrnoError(70) + } + var bytesWritten = stream.stream_ops.write(stream, buffer, offset, length, position, canOwn); + if (!seeking) stream.position += bytesWritten; + return bytesWritten + }, + allocate: (stream, offset, length) => { + if (FS.isClosed(stream)) { + throw new FS.ErrnoError(8) + } + if (offset < 0 || length <= 0) { + throw new FS.ErrnoError(28) + } + if ((stream.flags & 2097155) === 0) { + throw new FS.ErrnoError(8) + } + if (!FS.isFile(stream.node.mode) && !FS.isDir(stream.node.mode)) { + throw new FS.ErrnoError(43) + } + if (!stream.stream_ops.allocate) { + throw new FS.ErrnoError(138) + } + stream.stream_ops.allocate(stream, offset, length) + }, + mmap: (stream, length, position, prot, flags) => { + if ((prot & 2) !== 0 && (flags & 2) === 0 && (stream.flags & 2097155) !== 2) { + throw new FS.ErrnoError(2) + } + if ((stream.flags & 2097155) === 1) { + throw new FS.ErrnoError(2) + } + if (!stream.stream_ops.mmap) { + throw new FS.ErrnoError(43) + } + return stream.stream_ops.mmap(stream, length, position, prot, flags) + }, + msync: (stream, buffer, offset, length, mmapFlags) => { + if (!stream.stream_ops.msync) { + return 0 + } + return stream.stream_ops.msync(stream, buffer, offset, length, mmapFlags) + }, + munmap: stream => 0, + ioctl: (stream, cmd, arg) => { + if (!stream.stream_ops.ioctl) { + throw new FS.ErrnoError(59) + } + return stream.stream_ops.ioctl(stream, cmd, arg) + }, + readFile: (path, opts = {}) => { + opts.flags = opts.flags || 0; + opts.encoding = opts.encoding || "binary"; + if (opts.encoding !== "utf8" && opts.encoding !== "binary") { + throw new Error('Invalid encoding type "' + opts.encoding + '"') + } + var ret; + var stream = FS.open(path, opts.flags); + var stat = FS.stat(path); + var length = stat.size; + var buf = new Uint8Array(length); + FS.read(stream, buf, 0, length, 0); + if (opts.encoding === "utf8") { + ret = UTF8ArrayToString(buf, 0) + } else if (opts.encoding === "binary") { + ret = buf + } + FS.close(stream); + return ret + }, + writeFile: (path, data, opts = {}) => { + opts.flags = opts.flags || 577; + var stream = FS.open(path, opts.flags, opts.mode); + if (typeof data == "string") { + var buf = new Uint8Array(lengthBytesUTF8(data) + 1); + var actualNumBytes = stringToUTF8Array(data, buf, 0, buf.length); + FS.write(stream, buf, 0, actualNumBytes, undefined, opts.canOwn) + } else if (ArrayBuffer.isView(data)) { + FS.write(stream, data, 0, data.byteLength, undefined, opts.canOwn) + } else { + throw new Error("Unsupported data type") + } + FS.close(stream) + }, + cwd: () => FS.currentPath, + chdir: path => { + var lookup = FS.lookupPath(path, { + follow: true + }); + if (lookup.node === null) { + throw new FS.ErrnoError(44) + } + if (!FS.isDir(lookup.node.mode)) { + throw new FS.ErrnoError(54) + } + var errCode = FS.nodePermissions(lookup.node, "x"); + if (errCode) { + throw new FS.ErrnoError(errCode) + } + FS.currentPath = lookup.path + }, + createDefaultDirectories: () => { + FS.mkdir("/tmp"); + FS.mkdir("/home"); + FS.mkdir("/home/web_user") + }, + createDefaultDevices: () => { + FS.mkdir("/dev"); + FS.registerDevice(FS.makedev(1, 3), { + read: () => 0, + write: (stream, buffer, offset, length, pos) => length + }); + FS.mkdev("/dev/null", FS.makedev(1, 3)); + TTY.register(FS.makedev(5, 0), TTY.default_tty_ops); + TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops); + FS.mkdev("/dev/tty", FS.makedev(5, 0)); + FS.mkdev("/dev/tty1", FS.makedev(6, 0)); + var random_device = getRandomDevice(); + FS.createDevice("/dev", "random", random_device); + FS.createDevice("/dev", "urandom", random_device); + FS.mkdir("/dev/shm"); + FS.mkdir("/dev/shm/tmp") + }, + createSpecialDirectories: () => { + FS.mkdir("/proc"); + var proc_self = FS.mkdir("/proc/self"); + FS.mkdir("/proc/self/fd"); + FS.mount({ + mount: () => { + var node = FS.createNode(proc_self, "fd", 16384 | 511, 73); + node.node_ops = { + lookup: (parent, name) => { + var fd = +name; + var stream = FS.getStream(fd); + if (!stream) throw new FS.ErrnoError(8); + var ret = { + parent: null, + mount: { + mountpoint: "fake" + }, + node_ops: { + readlink: () => stream.path + } + }; + ret.parent = ret; + return ret + } + }; + return node + } + }, {}, "/proc/self/fd") + }, + createStandardStreams: () => { + if (Module["stdin"]) { + FS.createDevice("/dev", "stdin", Module["stdin"]) + } else { + FS.symlink("/dev/tty", "/dev/stdin") + } + if (Module["stdout"]) { + FS.createDevice("/dev", "stdout", null, Module["stdout"]) + } else { + FS.symlink("/dev/tty", "/dev/stdout") + } + if (Module["stderr"]) { + FS.createDevice("/dev", "stderr", null, Module["stderr"]) + } else { + FS.symlink("/dev/tty1", "/dev/stderr") + } + var stdin = FS.open("/dev/stdin", 0); + var stdout = FS.open("/dev/stdout", 1); + var stderr = FS.open("/dev/stderr", 1) + }, + ensureErrnoError: () => { + if (FS.ErrnoError) return; + FS.ErrnoError = function ErrnoError(errno, node) { + this.name = "ErrnoError"; + this.node = node; + this.setErrno = function (errno) { + this.errno = errno + }; + this.setErrno(errno); + this.message = "FS error" + }; + FS.ErrnoError.prototype = new Error; + FS.ErrnoError.prototype.constructor = FS.ErrnoError; + [44].forEach(code => { + FS.genericErrors[code] = new FS.ErrnoError(code); + FS.genericErrors[code].stack = "" + }) + }, + staticInit: () => { + FS.ensureErrnoError(); + FS.nameTable = new Array(4096); + FS.mount(MEMFS, {}, "/"); + FS.createDefaultDirectories(); + FS.createDefaultDevices(); + FS.createSpecialDirectories(); + FS.filesystems = { + "MEMFS": MEMFS + } + }, + init: (input, output, error) => { + FS.init.initialized = true; + FS.ensureErrnoError(); + Module["stdin"] = input || Module["stdin"]; + Module["stdout"] = output || Module["stdout"]; + Module["stderr"] = error || Module["stderr"]; + FS.createStandardStreams() + }, + quit: () => { + FS.init.initialized = false; + for (var i = 0; i < FS.streams.length; i++) { + var stream = FS.streams[i]; + if (!stream) { + continue + } + FS.close(stream) + } + }, + getMode: (canRead, canWrite) => { + var mode = 0; + if (canRead) mode |= 292 | 73; + if (canWrite) mode |= 146; + return mode + }, + findObject: (path, dontResolveLastLink) => { + var ret = FS.analyzePath(path, dontResolveLastLink); + if (!ret.exists) { + return null + } + return ret.object + }, + analyzePath: (path, dontResolveLastLink) => { + try { + var lookup = FS.lookupPath(path, { + follow: !dontResolveLastLink + }); + path = lookup.path + } catch (e) {} + var ret = { + isRoot: false, + exists: false, + error: 0, + name: null, + path: null, + object: null, + parentExists: false, + parentPath: null, + parentObject: null + }; + try { + var lookup = FS.lookupPath(path, { + parent: true + }); + ret.parentExists = true; + ret.parentPath = lookup.path; + ret.parentObject = lookup.node; + ret.name = PATH.basename(path); + lookup = FS.lookupPath(path, { + follow: !dontResolveLastLink + }); + ret.exists = true; + ret.path = lookup.path; + ret.object = lookup.node; + ret.name = lookup.node.name; + ret.isRoot = lookup.path === "/" + } catch (e) { + ret.error = e.errno + } + return ret + }, + createPath: (parent, path, canRead, canWrite) => { + parent = typeof parent == "string" ? parent : FS.getPath(parent); + var parts = path.split("/").reverse(); + while (parts.length) { + var part = parts.pop(); + if (!part) continue; + var current = PATH.join2(parent, part); + try { + FS.mkdir(current) + } catch (e) {} + parent = current + } + return current + }, + createFile: (parent, name, properties, canRead, canWrite) => { + var path = PATH.join2(typeof parent == "string" ? parent : FS.getPath(parent), name); + var mode = FS.getMode(canRead, canWrite); + return FS.create(path, mode) + }, + createDataFile: (parent, name, data, canRead, canWrite, canOwn) => { + var path = name; + if (parent) { + parent = typeof parent == "string" ? parent : FS.getPath(parent); + path = name ? PATH.join2(parent, name) : parent + } + var mode = FS.getMode(canRead, canWrite); + var node = FS.create(path, mode); + if (data) { + if (typeof data == "string") { + var arr = new Array(data.length); + for (var i = 0, len = data.length; i < len; ++i) arr[i] = data.charCodeAt(i); + data = arr + } + FS.chmod(node, mode | 146); + var stream = FS.open(node, 577); + FS.write(stream, data, 0, data.length, 0, canOwn); + FS.close(stream); + FS.chmod(node, mode) + } + return node + }, + createDevice: (parent, name, input, output) => { + var path = PATH.join2(typeof parent == "string" ? parent : FS.getPath(parent), name); + var mode = FS.getMode(!!input, !!output); + if (!FS.createDevice.major) FS.createDevice.major = 64; + var dev = FS.makedev(FS.createDevice.major++, 0); + FS.registerDevice(dev, { + open: stream => { + stream.seekable = false + }, + close: stream => { + if (output && output.buffer && output.buffer.length) { + output(10) + } + }, + read: (stream, buffer, offset, length, pos) => { + var bytesRead = 0; + for (var i = 0; i < length; i++) { + var result; + try { + result = input() + } catch (e) { + throw new FS.ErrnoError(29) + } + if (result === undefined && bytesRead === 0) { + throw new FS.ErrnoError(6) + } + if (result === null || result === undefined) break; + bytesRead++; + buffer[offset + i] = result + } + if (bytesRead) { + stream.node.timestamp = Date.now() + } + return bytesRead + }, + write: (stream, buffer, offset, length, pos) => { + for (var i = 0; i < length; i++) { + try { + output(buffer[offset + i]) + } catch (e) { + throw new FS.ErrnoError(29) + } + } + if (length) { + stream.node.timestamp = Date.now() + } + return i + } + }); + return FS.mkdev(path, mode, dev) + }, + forceLoadFile: obj => { + if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true; + if (typeof XMLHttpRequest != "undefined") { + 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.") + } else if (read_) { + try { + obj.contents = intArrayFromString(read_(obj.url), true); + obj.usedBytes = obj.contents.length + } catch (e) { + throw new FS.ErrnoError(29) + } + } else { + throw new Error("Cannot load without read() or XMLHttpRequest.") + } + }, + createLazyFile: (parent, name, url, canRead, canWrite) => { + function LazyUint8Array() { + this.lengthKnown = false; + this.chunks = [] + } + LazyUint8Array.prototype.get = function LazyUint8Array_get(idx) { + if (idx > this.length - 1 || idx < 0) { + return undefined + } + var chunkOffset = idx % this.chunkSize; + var chunkNum = idx / this.chunkSize | 0; + return this.getter(chunkNum)[chunkOffset] + }; + LazyUint8Array.prototype.setDataGetter = function LazyUint8Array_setDataGetter(getter) { + this.getter = getter + }; + LazyUint8Array.prototype.cacheLength = function LazyUint8Array_cacheLength() { + var xhr = new XMLHttpRequest; + xhr.open("HEAD", url, false); + xhr.send(null); + if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status); + var datalength = Number(xhr.getResponseHeader("Content-length")); + var header; + var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes"; + var usesGzip = (header = xhr.getResponseHeader("Content-Encoding")) && header === "gzip"; + var chunkSize = 1024 * 1024; + if (!hasByteServing) chunkSize = datalength; + var doXHR = (from, to) => { + if (from > to) throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!"); + if (to > datalength - 1) throw new Error("only " + datalength + " bytes available! programmer error!"); + var xhr = new XMLHttpRequest; + xhr.open("GET", url, false); + if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to); + xhr.responseType = "arraybuffer"; + if (xhr.overrideMimeType) { + xhr.overrideMimeType("text/plain; charset=x-user-defined") + } + xhr.send(null); + if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status); + if (xhr.response !== undefined) { + return new Uint8Array(xhr.response || []) + } + return intArrayFromString(xhr.responseText || "", true) + }; + var lazyArray = this; + lazyArray.setDataGetter(chunkNum => { + var start = chunkNum * chunkSize; + var end = (chunkNum + 1) * chunkSize - 1; + end = Math.min(end, datalength - 1); + if (typeof lazyArray.chunks[chunkNum] == "undefined") { + lazyArray.chunks[chunkNum] = doXHR(start, end) + } + if (typeof lazyArray.chunks[chunkNum] == "undefined") throw new Error("doXHR failed!"); + return lazyArray.chunks[chunkNum] + }); + if (usesGzip || !datalength) { + chunkSize = datalength = 1; + datalength = this.getter(0).length; + chunkSize = datalength; + out("LazyFiles on gzip forces download of the whole file when length is accessed") + } + this._length = datalength; + this._chunkSize = chunkSize; + this.lengthKnown = true + }; + if (typeof XMLHttpRequest != "undefined") { + if (!ENVIRONMENT_IS_WORKER) throw "Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc"; + var lazyArray = new LazyUint8Array; + Object.defineProperties(lazyArray, { + length: { + get: function () { + if (!this.lengthKnown) { + this.cacheLength() + } + return this._length + } + }, + chunkSize: { + get: function () { + if (!this.lengthKnown) { + this.cacheLength() + } + return this._chunkSize + } + } + }); + var properties = { + isDevice: false, + contents: lazyArray + } + } else { + var properties = { + isDevice: false, + url: url + } + } + var node = FS.createFile(parent, name, properties, canRead, canWrite); + if (properties.contents) { + node.contents = properties.contents + } else if (properties.url) { + node.contents = null; + node.url = properties.url + } + Object.defineProperties(node, { + usedBytes: { + get: function () { + return this.contents.length + } + } + }); + var stream_ops = {}; + var keys = Object.keys(node.stream_ops); + keys.forEach(key => { + var fn = node.stream_ops[key]; + stream_ops[key] = function forceLoadLazyFile() { + FS.forceLoadFile(node); + return fn.apply(null, arguments) + } + }); + + function writeChunks(stream, buffer, offset, length, position) { + var contents = stream.node.contents; + if (position >= contents.length) return 0; + var size = Math.min(contents.length - position, length); + if (contents.slice) { + for (var i = 0; i < size; i++) { + buffer[offset + i] = contents[position + i] + } + } else { + for (var i = 0; i < size; i++) { + buffer[offset + i] = contents.get(position + i) + } + } + return size + } + stream_ops.read = (stream, buffer, offset, length, position) => { + FS.forceLoadFile(node); + return writeChunks(stream, buffer, offset, length, position) + }; + stream_ops.mmap = (stream, length, position, prot, flags) => { + FS.forceLoadFile(node); + var ptr = mmapAlloc(length); + if (!ptr) { + throw new FS.ErrnoError(48) + } + writeChunks(stream, HEAP8, ptr, length, position); + return { + ptr: ptr, + allocated: true + } + }; + node.stream_ops = stream_ops; + return node + }, + createPreloadedFile: (parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn, preFinish) => { + var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent; + var dep = getUniqueRunDependency("cp " + fullname); + + function processData(byteArray) { + function finish(byteArray) { + if (preFinish) preFinish(); + if (!dontCreateFile) { + FS.createDataFile(parent, name, byteArray, canRead, canWrite, canOwn) + } + if (onload) onload(); + removeRunDependency(dep) + } + if (Browser.handledByPreloadPlugin(byteArray, fullname, finish, () => { + if (onerror) onerror(); + removeRunDependency(dep) + })) { + return + } + finish(byteArray) + } + addRunDependency(dep); + if (typeof url == "string") { + asyncLoad(url, byteArray => processData(byteArray), onerror) + } else { + processData(url) + } + }, + indexedDB: () => { + return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB + }, + DB_NAME: () => { + return "EM_FS_" + window.location.pathname + }, + DB_VERSION: 20, + DB_STORE_NAME: "FILE_DATA", + saveFilesToDB: (paths, onload = (() => {}), onerror = (() => {})) => { + var indexedDB = FS.indexedDB(); + try { + var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION) + } catch (e) { + return onerror(e) + } + openRequest.onupgradeneeded = () => { + out("creating db"); + var db = openRequest.result; + db.createObjectStore(FS.DB_STORE_NAME) + }; + openRequest.onsuccess = () => { + var db = openRequest.result; + var transaction = db.transaction([FS.DB_STORE_NAME], "readwrite"); + var files = transaction.objectStore(FS.DB_STORE_NAME); + var ok = 0, + fail = 0, + total = paths.length; + + function finish() { + if (fail == 0) onload(); + else onerror() + } + paths.forEach(path => { + var putRequest = files.put(FS.analyzePath(path).object.contents, path); + putRequest.onsuccess = () => { + ok++; + if (ok + fail == total) finish() + }; + putRequest.onerror = () => { + fail++; + if (ok + fail == total) finish() + } + }); + transaction.onerror = onerror + }; + openRequest.onerror = onerror + }, + loadFilesFromDB: (paths, onload = (() => {}), onerror = (() => {})) => { + var indexedDB = FS.indexedDB(); + try { + var openRequest = indexedDB.open(FS.DB_NAME(), FS.DB_VERSION) + } catch (e) { + return onerror(e) + } + openRequest.onupgradeneeded = onerror; + openRequest.onsuccess = () => { + var db = openRequest.result; + try { + var transaction = db.transaction([FS.DB_STORE_NAME], "readonly") + } catch (e) { + onerror(e); + return + } + var files = transaction.objectStore(FS.DB_STORE_NAME); + var ok = 0, + fail = 0, + total = paths.length; + + function finish() { + if (fail == 0) onload(); + else onerror() + } + paths.forEach(path => { + var getRequest = files.get(path); + getRequest.onsuccess = () => { + if (FS.analyzePath(path).exists) { + FS.unlink(path) + } + FS.createDataFile(PATH.dirname(path), PATH.basename(path), getRequest.result, true, true, true); + ok++; + if (ok + fail == total) finish() + }; + getRequest.onerror = () => { + fail++; + if (ok + fail == total) finish() + } + }); + transaction.onerror = onerror + }; + openRequest.onerror = onerror + } + }; + var SYSCALLS = { + DEFAULT_POLLMASK: 5, + calculateAt: function (dirfd, path, allowEmpty) { + if (PATH.isAbs(path)) { + return path + } + var dir; + if (dirfd === -100) { + dir = FS.cwd() + } else { + var dirstream = SYSCALLS.getStreamFromFD(dirfd); + dir = dirstream.path + } + if (path.length == 0) { + if (!allowEmpty) { + throw new FS.ErrnoError(44) + } + return dir + } + return PATH.join2(dir, path) + }, + doStat: function (func, path, buf) { + try { + var stat = func(path) + } catch (e) { + if (e && e.node && PATH.normalize(path) !== PATH.normalize(FS.getPath(e.node))) { + return -54 + } + throw e + } + HEAP32[buf >> 2] = stat.dev; + HEAP32[buf + 8 >> 2] = stat.ino; + HEAP32[buf + 12 >> 2] = stat.mode; + HEAPU32[buf + 16 >> 2] = stat.nlink; + HEAP32[buf + 20 >> 2] = stat.uid; + HEAP32[buf + 24 >> 2] = stat.gid; + HEAP32[buf + 28 >> 2] = stat.rdev; + tempI64 = [stat.size >>> 0, (tempDouble = stat.size, +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)], HEAP32[buf + 40 >> 2] = tempI64[0], HEAP32[buf + 44 >> 2] = tempI64[1]; + HEAP32[buf + 48 >> 2] = 4096; + HEAP32[buf + 52 >> 2] = stat.blocks; + var atime = stat.atime.getTime(); + var mtime = stat.mtime.getTime(); + var ctime = stat.ctime.getTime(); + tempI64 = [Math.floor(atime / 1e3) >>> 0, (tempDouble = Math.floor(atime / 1e3), +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)], HEAP32[buf + 56 >> 2] = tempI64[0], HEAP32[buf + 60 >> 2] = tempI64[1]; + HEAPU32[buf + 64 >> 2] = atime % 1e3 * 1e3; + tempI64 = [Math.floor(mtime / 1e3) >>> 0, (tempDouble = Math.floor(mtime / 1e3), +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)], HEAP32[buf + 72 >> 2] = tempI64[0], HEAP32[buf + 76 >> 2] = tempI64[1]; + HEAPU32[buf + 80 >> 2] = mtime % 1e3 * 1e3; + tempI64 = [Math.floor(ctime / 1e3) >>> 0, (tempDouble = Math.floor(ctime / 1e3), +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)], HEAP32[buf + 88 >> 2] = tempI64[0], HEAP32[buf + 92 >> 2] = tempI64[1]; + HEAPU32[buf + 96 >> 2] = ctime % 1e3 * 1e3; + tempI64 = [stat.ino >>> 0, (tempDouble = stat.ino, +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)], HEAP32[buf + 104 >> 2] = tempI64[0], HEAP32[buf + 108 >> 2] = tempI64[1]; + return 0 + }, + doMsync: function (addr, stream, len, flags, offset) { + if (!FS.isFile(stream.node.mode)) { + throw new FS.ErrnoError(43) + } + if (flags & 2) { + return 0 + } + var buffer = HEAPU8.slice(addr, addr + len); + FS.msync(stream, buffer, offset, len, flags) + }, + varargs: undefined, + get: function () { + SYSCALLS.varargs += 4; + var ret = HEAP32[SYSCALLS.varargs - 4 >> 2]; + return ret + }, + getStr: function (ptr) { + var ret = UTF8ToString(ptr); + return ret + }, + getStreamFromFD: function (fd) { + var stream = FS.getStream(fd); + if (!stream) throw new FS.ErrnoError(8); + return stream + } + }; + + function ___syscall_fcntl64(fd, cmd, varargs) { + SYSCALLS.varargs = varargs; + try { + var stream = SYSCALLS.getStreamFromFD(fd); + switch (cmd) { + case 0: { + var arg = SYSCALLS.get(); + if (arg < 0) { + return -28 + } + var newStream; + newStream = FS.createStream(stream, arg); + return newStream.fd + } + case 1: + case 2: + return 0; + case 3: + return stream.flags; + case 4: { + var arg = SYSCALLS.get(); + stream.flags |= arg; + return 0 + } + case 5: { + var arg = SYSCALLS.get(); + var offset = 0; + HEAP16[arg + offset >> 1] = 2; + return 0 + } + case 6: + case 7: + return 0; + case 16: + case 8: + return -28; + case 9: + setErrNo(28); + return -1; + default: { + return -28 + } + } + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno + } + } + + function ___syscall_fstat64(fd, buf) { + try { + var stream = SYSCALLS.getStreamFromFD(fd); + return SYSCALLS.doStat(FS.stat, stream.path, buf) + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno + } + } + + function convertI32PairToI53Checked(lo, hi) { + return hi + 2097152 >>> 0 < 4194305 - !!lo ? (lo >>> 0) + hi * 4294967296 : NaN + } + + function ___syscall_ftruncate64(fd, length_low, length_high) { + try { + var length = convertI32PairToI53Checked(length_low, length_high); + if (isNaN(length)) return -61; + FS.ftruncate(fd, length); + return 0 + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno + } + } + + function ___syscall_getdents64(fd, dirp, count) { + try { + var stream = SYSCALLS.getStreamFromFD(fd); + if (!stream.getdents) { + stream.getdents = FS.readdir(stream.path) + } + var struct_size = 280; + var pos = 0; + var off = FS.llseek(stream, 0, 1); + var idx = Math.floor(off / struct_size); + while (idx < stream.getdents.length && pos + struct_size <= count) { + var id; + var type; + var name = stream.getdents[idx]; + if (name === ".") { + id = stream.node.id; + type = 4 + } else if (name === "..") { + var lookup = FS.lookupPath(stream.path, { + parent: true + }); + id = lookup.node.id; + type = 4 + } else { + var child = FS.lookupNode(stream.node, name); + id = child.id; + type = FS.isChrdev(child.mode) ? 2 : FS.isDir(child.mode) ? 4 : FS.isLink(child.mode) ? 10 : 8 + } + tempI64 = [id >>> 0, (tempDouble = id, +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)], HEAP32[dirp + pos >> 2] = tempI64[0], HEAP32[dirp + pos + 4 >> 2] = tempI64[1]; + tempI64 = [(idx + 1) * struct_size >>> 0, (tempDouble = (idx + 1) * struct_size, +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)], HEAP32[dirp + pos + 8 >> 2] = tempI64[0], HEAP32[dirp + pos + 12 >> 2] = tempI64[1]; + HEAP16[dirp + pos + 16 >> 1] = 280; + HEAP8[dirp + pos + 18 >> 0] = type; + stringToUTF8(name, dirp + pos + 19, 256); + pos += struct_size; + idx += 1 + } + FS.llseek(stream, idx * struct_size, 0); + return pos + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno + } + } + + function ___syscall_ioctl(fd, op, varargs) { + SYSCALLS.varargs = varargs; + try { + var stream = SYSCALLS.getStreamFromFD(fd); + switch (op) { + case 21509: + case 21505: { + if (!stream.tty) return -59; + return 0 + } + case 21510: + case 21511: + case 21512: + case 21506: + case 21507: + case 21508: { + if (!stream.tty) return -59; + return 0 + } + case 21519: { + if (!stream.tty) return -59; + var argp = SYSCALLS.get(); + HEAP32[argp >> 2] = 0; + return 0 + } + case 21520: { + if (!stream.tty) return -59; + return -28 + } + case 21531: { + var argp = SYSCALLS.get(); + return FS.ioctl(stream, op, argp) + } + case 21523: { + if (!stream.tty) return -59; + return 0 + } + case 21524: { + if (!stream.tty) return -59; + return 0 + } + default: + return -28 + } + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno + } + } + + function ___syscall_lstat64(path, buf) { + try { + path = SYSCALLS.getStr(path); + return SYSCALLS.doStat(FS.lstat, path, buf) + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno + } + } + + function ___syscall_newfstatat(dirfd, path, buf, flags) { + try { + path = SYSCALLS.getStr(path); + var nofollow = flags & 256; + var allowEmpty = flags & 4096; + flags = flags & ~6400; + path = SYSCALLS.calculateAt(dirfd, path, allowEmpty); + return SYSCALLS.doStat(nofollow ? FS.lstat : FS.stat, path, buf) + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno + } + } + + function ___syscall_openat(dirfd, path, flags, varargs) { + SYSCALLS.varargs = varargs; + try { + path = SYSCALLS.getStr(path); + path = SYSCALLS.calculateAt(dirfd, path); + var mode = varargs ? SYSCALLS.get() : 0; + return FS.open(path, flags, mode).fd + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno + } + } + + function ___syscall_rmdir(path) { + try { + path = SYSCALLS.getStr(path); + FS.rmdir(path); + return 0 + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno + } + } + + function ___syscall_stat64(path, buf) { + try { + path = SYSCALLS.getStr(path); + return SYSCALLS.doStat(FS.stat, path, buf) + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno + } + } + + function ___syscall_unlinkat(dirfd, path, flags) { + try { + path = SYSCALLS.getStr(path); + path = SYSCALLS.calculateAt(dirfd, path); + if (flags === 0) { + FS.unlink(path) + } else if (flags === 512) { + FS.rmdir(path) + } else { + abort("Invalid flags passed to unlinkat") + } + return 0 + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return -e.errno + } + } + + function __emscripten_throw_longjmp() { + throw Infinity + } + + function readI53FromI64(ptr) { + return HEAPU32[ptr >> 2] + HEAP32[ptr + 4 >> 2] * 4294967296 + } + + function __gmtime_js(time, tmPtr) { + var date = new Date(readI53FromI64(time) * 1e3); + HEAP32[tmPtr >> 2] = date.getUTCSeconds(); + HEAP32[tmPtr + 4 >> 2] = date.getUTCMinutes(); + HEAP32[tmPtr + 8 >> 2] = date.getUTCHours(); + HEAP32[tmPtr + 12 >> 2] = date.getUTCDate(); + HEAP32[tmPtr + 16 >> 2] = date.getUTCMonth(); + HEAP32[tmPtr + 20 >> 2] = date.getUTCFullYear() - 1900; + HEAP32[tmPtr + 24 >> 2] = date.getUTCDay(); + var start = Date.UTC(date.getUTCFullYear(), 0, 1, 0, 0, 0, 0); + var yday = (date.getTime() - start) / (1e3 * 60 * 60 * 24) | 0; + HEAP32[tmPtr + 28 >> 2] = yday + } + + function __isLeapYear(year) { + return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0) + } + var __MONTH_DAYS_LEAP_CUMULATIVE = [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335]; + var __MONTH_DAYS_REGULAR_CUMULATIVE = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334]; + + function __yday_from_date(date) { + var isLeapYear = __isLeapYear(date.getFullYear()); + var monthDaysCumulative = isLeapYear ? __MONTH_DAYS_LEAP_CUMULATIVE : __MONTH_DAYS_REGULAR_CUMULATIVE; + var yday = monthDaysCumulative[date.getMonth()] + date.getDate() - 1; + return yday + } + + function __localtime_js(time, tmPtr) { + var date = new Date(readI53FromI64(time) * 1e3); + HEAP32[tmPtr >> 2] = date.getSeconds(); + HEAP32[tmPtr + 4 >> 2] = date.getMinutes(); + HEAP32[tmPtr + 8 >> 2] = date.getHours(); + HEAP32[tmPtr + 12 >> 2] = date.getDate(); + HEAP32[tmPtr + 16 >> 2] = date.getMonth(); + HEAP32[tmPtr + 20 >> 2] = date.getFullYear() - 1900; + HEAP32[tmPtr + 24 >> 2] = date.getDay(); + var yday = __yday_from_date(date) | 0; + HEAP32[tmPtr + 28 >> 2] = yday; + HEAP32[tmPtr + 36 >> 2] = -(date.getTimezoneOffset() * 60); + var start = new Date(date.getFullYear(), 0, 1); + var summerOffset = new Date(date.getFullYear(), 6, 1).getTimezoneOffset(); + var winterOffset = start.getTimezoneOffset(); + var dst = (summerOffset != winterOffset && date.getTimezoneOffset() == Math.min(winterOffset, summerOffset)) | 0; + HEAP32[tmPtr + 32 >> 2] = dst + } + var timers = {}; + + function handleException(e) { + if (e instanceof ExitStatus || e == "unwind") { + return EXITSTATUS + } + quit_(1, e) + } + + function _proc_exit(code) { + EXITSTATUS = code; + if (!keepRuntimeAlive()) { + if (Module["onExit"]) Module["onExit"](code); + ABORT = true + } + quit_(code, new ExitStatus(code)) + } + + function exitJS(status, implicit) { + EXITSTATUS = status; + _proc_exit(status) + } + var _exit = exitJS; + + function maybeExit() { + if (!keepRuntimeAlive()) { + try { + _exit(EXITSTATUS) + } catch (e) { + handleException(e) + } + } + } + + function callUserCallback(func) { + if (ABORT) { + return + } + try { + func(); + maybeExit() + } catch (e) { + handleException(e) + } + } + var _emscripten_get_now; + if (ENVIRONMENT_IS_NODE) { + _emscripten_get_now = () => { + var t = process.hrtime(); + return t[0] * 1e3 + t[1] / 1e6 + } + } else _emscripten_get_now = () => performance.now(); + + function __setitimer_js(which, timeout_ms) { + if (timers[which]) { + clearTimeout(timers[which].id); + delete timers[which] + } + if (!timeout_ms) return 0; + var id = setTimeout(() => { + delete timers[which]; + callUserCallback(() => __emscripten_timeout(which, _emscripten_get_now())) + }, timeout_ms); + timers[which] = { + id: id, + timeout_ms: timeout_ms + }; + return 0 + } + + function allocateUTF8(str) { + var size = lengthBytesUTF8(str) + 1; + var ret = _malloc(size); + if (ret) stringToUTF8Array(str, HEAP8, ret, size); + return ret + } + + function __tzset_js(timezone, daylight, tzname) { + var currentYear = (new Date).getFullYear(); + var winter = new Date(currentYear, 0, 1); + var summer = new Date(currentYear, 6, 1); + var winterOffset = winter.getTimezoneOffset(); + var summerOffset = summer.getTimezoneOffset(); + var stdTimezoneOffset = Math.max(winterOffset, summerOffset); + HEAPU32[timezone >> 2] = stdTimezoneOffset * 60; + HEAP32[daylight >> 2] = Number(winterOffset != summerOffset); + + function extractZone(date) { + var match = date.toTimeString().match(/\(([A-Za-z ]+)\)$/); + return match ? match[1] : "GMT" + } + var winterName = extractZone(winter); + var summerName = extractZone(summer); + var winterNamePtr = allocateUTF8(winterName); + var summerNamePtr = allocateUTF8(summerName); + if (summerOffset < winterOffset) { + HEAPU32[tzname >> 2] = winterNamePtr; + HEAPU32[tzname + 4 >> 2] = summerNamePtr + } else { + HEAPU32[tzname >> 2] = summerNamePtr; + HEAPU32[tzname + 4 >> 2] = winterNamePtr + } + } + + function _abort() { + abort("") + } + + function _emscripten_date_now() { + return Date.now() + } + + function _emscripten_memcpy_big(dest, src, num) { + HEAPU8.copyWithin(dest, src, src + num) + } + + function getHeapMax() { + return 2147483648 + } + + function emscripten_realloc_buffer(size) { + var b = wasmMemory.buffer; + try { + wasmMemory.grow(size - b.byteLength + 65535 >>> 16); + updateMemoryViews(); + return 1 + } catch (e) {} + } + + function _emscripten_resize_heap(requestedSize) { + var oldSize = HEAPU8.length; + requestedSize = requestedSize >>> 0; + var maxHeapSize = getHeapMax(); + if (requestedSize > maxHeapSize) { + return false + } + let alignUp = (x, multiple) => x + (multiple - x % multiple) % multiple; + for (var cutDown = 1; cutDown <= 4; cutDown *= 2) { + var overGrownHeapSize = oldSize * (1 + .2 / cutDown); + overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296); + var newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536)); + var replacement = emscripten_realloc_buffer(newSize); + if (replacement) { + return true + } + } + return false + } + var ENV = {}; + + function getExecutableName() { + return thisProgram || "./this.program" + } + + function getEnvStrings() { + if (!getEnvStrings.strings) { + var lang = (typeof navigator == "object" && navigator.languages && navigator.languages[0] || "C").replace("-", "_") + ".UTF-8"; + var env = { + "USER": "web_user", + "LOGNAME": "web_user", + "PATH": "/", + "PWD": "/", + "HOME": "/home/web_user", + "LANG": lang, + "_": getExecutableName() + }; + for (var x in ENV) { + if (ENV[x] === undefined) delete env[x]; + else env[x] = ENV[x] + } + var strings = []; + for (var x in env) { + strings.push(x + "=" + env[x]) + } + getEnvStrings.strings = strings + } + return getEnvStrings.strings + } + + function writeAsciiToMemory(str, buffer, dontAddNull) { + for (var i = 0; i < str.length; ++i) { + HEAP8[buffer++ >> 0] = str.charCodeAt(i) + } + if (!dontAddNull) HEAP8[buffer >> 0] = 0 + } + + function _environ_get(__environ, environ_buf) { + var bufSize = 0; + getEnvStrings().forEach(function (string, i) { + var ptr = environ_buf + bufSize; + HEAPU32[__environ + i * 4 >> 2] = ptr; + writeAsciiToMemory(string, ptr); + bufSize += string.length + 1 + }); + return 0 + } + + function _environ_sizes_get(penviron_count, penviron_buf_size) { + var strings = getEnvStrings(); + HEAPU32[penviron_count >> 2] = strings.length; + var bufSize = 0; + strings.forEach(function (string) { + bufSize += string.length + 1 + }); + HEAPU32[penviron_buf_size >> 2] = bufSize; + return 0 + } + + function _fd_close(fd) { + try { + var stream = SYSCALLS.getStreamFromFD(fd); + FS.close(stream); + return 0 + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return e.errno + } + } + + function doReadv(stream, iov, iovcnt, offset) { + var ret = 0; + for (var i = 0; i < iovcnt; i++) { + var ptr = HEAPU32[iov >> 2]; + var len = HEAPU32[iov + 4 >> 2]; + iov += 8; + var curr = FS.read(stream, HEAP8, ptr, len, offset); + if (curr < 0) return -1; + ret += curr; + if (curr < len) break; + if (typeof offset !== "undefined") { + offset += curr + } + } + return ret + } + + function _fd_read(fd, iov, iovcnt, pnum) { + try { + var stream = SYSCALLS.getStreamFromFD(fd); + var num = doReadv(stream, iov, iovcnt); + HEAPU32[pnum >> 2] = num; + return 0 + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return e.errno + } + } + + function _fd_seek(fd, offset_low, offset_high, whence, newOffset) { + try { + var offset = convertI32PairToI53Checked(offset_low, offset_high); + if (isNaN(offset)) return 61; + var stream = SYSCALLS.getStreamFromFD(fd); + FS.llseek(stream, offset, whence); + tempI64 = [stream.position >>> 0, (tempDouble = stream.position, +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0)], HEAP32[newOffset >> 2] = tempI64[0], HEAP32[newOffset + 4 >> 2] = tempI64[1]; + if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null; + return 0 + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return e.errno + } + } + + function _fd_sync(fd) { + try { + var stream = SYSCALLS.getStreamFromFD(fd); + if (stream.stream_ops && stream.stream_ops.fsync) { + return stream.stream_ops.fsync(stream) + } + return 0 + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return e.errno + } + } + + function doWritev(stream, iov, iovcnt, offset) { + var ret = 0; + for (var i = 0; i < iovcnt; i++) { + var ptr = HEAPU32[iov >> 2]; + var len = HEAPU32[iov + 4 >> 2]; + iov += 8; + var curr = FS.write(stream, HEAP8, ptr, len, offset); + if (curr < 0) return -1; + ret += curr; + if (typeof offset !== "undefined") { + offset += curr + } + } + return ret + } + + function _fd_write(fd, iov, iovcnt, pnum) { + try { + var stream = SYSCALLS.getStreamFromFD(fd); + var num = doWritev(stream, iov, iovcnt); + HEAPU32[pnum >> 2] = num; + return 0 + } catch (e) { + if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e; + return e.errno + } + } + + function __arraySum(array, index) { + var sum = 0; + for (var i = 0; i <= index; sum += array[i++]) {} + return sum + } + var __MONTH_DAYS_LEAP = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]; + var __MONTH_DAYS_REGULAR = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]; + + function __addDays(date, days) { + var newDate = new Date(date.getTime()); + while (days > 0) { + var leap = __isLeapYear(newDate.getFullYear()); + var currentMonth = newDate.getMonth(); + var daysInCurrentMonth = (leap ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR)[currentMonth]; + if (days > daysInCurrentMonth - newDate.getDate()) { + days -= daysInCurrentMonth - newDate.getDate() + 1; + newDate.setDate(1); + if (currentMonth < 11) { + newDate.setMonth(currentMonth + 1) + } else { + newDate.setMonth(0); + newDate.setFullYear(newDate.getFullYear() + 1) + } + } else { + newDate.setDate(newDate.getDate() + days); + return newDate + } + } + return newDate + } + + function writeArrayToMemory(array, buffer) { + HEAP8.set(array, buffer) + } + + function _strftime(s, maxsize, format, tm) { + var tm_zone = HEAP32[tm + 40 >> 2]; + var date = { + tm_sec: HEAP32[tm >> 2], + tm_min: HEAP32[tm + 4 >> 2], + tm_hour: HEAP32[tm + 8 >> 2], + tm_mday: HEAP32[tm + 12 >> 2], + tm_mon: HEAP32[tm + 16 >> 2], + tm_year: HEAP32[tm + 20 >> 2], + tm_wday: HEAP32[tm + 24 >> 2], + tm_yday: HEAP32[tm + 28 >> 2], + tm_isdst: HEAP32[tm + 32 >> 2], + tm_gmtoff: HEAP32[tm + 36 >> 2], + tm_zone: tm_zone ? UTF8ToString(tm_zone) : "" + }; + var pattern = UTF8ToString(format); + var EXPANSION_RULES_1 = { + "%c": "%a %b %d %H:%M:%S %Y", + "%D": "%m/%d/%y", + "%F": "%Y-%m-%d", + "%h": "%b", + "%r": "%I:%M:%S %p", + "%R": "%H:%M", + "%T": "%H:%M:%S", + "%x": "%m/%d/%y", + "%X": "%H:%M:%S", + "%Ec": "%c", + "%EC": "%C", + "%Ex": "%m/%d/%y", + "%EX": "%H:%M:%S", + "%Ey": "%y", + "%EY": "%Y", + "%Od": "%d", + "%Oe": "%e", + "%OH": "%H", + "%OI": "%I", + "%Om": "%m", + "%OM": "%M", + "%OS": "%S", + "%Ou": "%u", + "%OU": "%U", + "%OV": "%V", + "%Ow": "%w", + "%OW": "%W", + "%Oy": "%y" + }; + for (var rule in EXPANSION_RULES_1) { + pattern = pattern.replace(new RegExp(rule, "g"), EXPANSION_RULES_1[rule]) + } + var WEEKDAYS = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"]; + var MONTHS = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"]; + + function leadingSomething(value, digits, character) { + var str = typeof value == "number" ? value.toString() : value || ""; + while (str.length < digits) { + str = character[0] + str + } + return str + } + + function leadingNulls(value, digits) { + return leadingSomething(value, digits, "0") + } + + function compareByDay(date1, date2) { + function sgn(value) { + return value < 0 ? -1 : value > 0 ? 1 : 0 + } + var compare; + if ((compare = sgn(date1.getFullYear() - date2.getFullYear())) === 0) { + if ((compare = sgn(date1.getMonth() - date2.getMonth())) === 0) { + compare = sgn(date1.getDate() - date2.getDate()) + } + } + return compare + } + + function getFirstWeekStartDate(janFourth) { + switch (janFourth.getDay()) { + case 0: + return new Date(janFourth.getFullYear() - 1, 11, 29); + case 1: + return janFourth; + case 2: + return new Date(janFourth.getFullYear(), 0, 3); + case 3: + return new Date(janFourth.getFullYear(), 0, 2); + case 4: + return new Date(janFourth.getFullYear(), 0, 1); + case 5: + return new Date(janFourth.getFullYear() - 1, 11, 31); + case 6: + return new Date(janFourth.getFullYear() - 1, 11, 30) + } + } + + function getWeekBasedYear(date) { + var thisDate = __addDays(new Date(date.tm_year + 1900, 0, 1), date.tm_yday); + var janFourthThisYear = new Date(thisDate.getFullYear(), 0, 4); + var janFourthNextYear = new Date(thisDate.getFullYear() + 1, 0, 4); + var firstWeekStartThisYear = getFirstWeekStartDate(janFourthThisYear); + var firstWeekStartNextYear = getFirstWeekStartDate(janFourthNextYear); + if (compareByDay(firstWeekStartThisYear, thisDate) <= 0) { + if (compareByDay(firstWeekStartNextYear, thisDate) <= 0) { + return thisDate.getFullYear() + 1 + } + return thisDate.getFullYear() + } + return thisDate.getFullYear() - 1 + } + var EXPANSION_RULES_2 = { + "%a": function (date) { + return WEEKDAYS[date.tm_wday].substring(0, 3) + }, + "%A": function (date) { + return WEEKDAYS[date.tm_wday] + }, + "%b": function (date) { + return MONTHS[date.tm_mon].substring(0, 3) + }, + "%B": function (date) { + return MONTHS[date.tm_mon] + }, + "%C": function (date) { + var year = date.tm_year + 1900; + return leadingNulls(year / 100 | 0, 2) + }, + "%d": function (date) { + return leadingNulls(date.tm_mday, 2) + }, + "%e": function (date) { + return leadingSomething(date.tm_mday, 2, " ") + }, + "%g": function (date) { + return getWeekBasedYear(date).toString().substring(2) + }, + "%G": function (date) { + return getWeekBasedYear(date) + }, + "%H": function (date) { + return leadingNulls(date.tm_hour, 2) + }, + "%I": function (date) { + var twelveHour = date.tm_hour; + if (twelveHour == 0) twelveHour = 12; + else if (twelveHour > 12) twelveHour -= 12; + return leadingNulls(twelveHour, 2) + }, + "%j": function (date) { + return leadingNulls(date.tm_mday + __arraySum(__isLeapYear(date.tm_year + 1900) ? __MONTH_DAYS_LEAP : __MONTH_DAYS_REGULAR, date.tm_mon - 1), 3) + }, + "%m": function (date) { + return leadingNulls(date.tm_mon + 1, 2) + }, + "%M": function (date) { + return leadingNulls(date.tm_min, 2) + }, + "%n": function () { + return "\n" + }, + "%p": function (date) { + if (date.tm_hour >= 0 && date.tm_hour < 12) { + return "AM" + } + return "PM" + }, + "%S": function (date) { + return leadingNulls(date.tm_sec, 2) + }, + "%t": function () { + return "\t" + }, + "%u": function (date) { + return date.tm_wday || 7 + }, + "%U": function (date) { + var days = date.tm_yday + 7 - date.tm_wday; + return leadingNulls(Math.floor(days / 7), 2) + }, + "%V": function (date) { + var val = Math.floor((date.tm_yday + 7 - (date.tm_wday + 6) % 7) / 7); + if ((date.tm_wday + 371 - date.tm_yday - 2) % 7 <= 2) { + val++ + } + if (!val) { + val = 52; + var dec31 = (date.tm_wday + 7 - date.tm_yday - 1) % 7; + if (dec31 == 4 || dec31 == 5 && __isLeapYear(date.tm_year % 400 - 1)) { + val++ + } + } else if (val == 53) { + var jan1 = (date.tm_wday + 371 - date.tm_yday) % 7; + if (jan1 != 4 && (jan1 != 3 || !__isLeapYear(date.tm_year))) val = 1 + } + return leadingNulls(val, 2) + }, + "%w": function (date) { + return date.tm_wday + }, + "%W": function (date) { + var days = date.tm_yday + 7 - (date.tm_wday + 6) % 7; + return leadingNulls(Math.floor(days / 7), 2) + }, + "%y": function (date) { + return (date.tm_year + 1900).toString().substring(2) + }, + "%Y": function (date) { + return date.tm_year + 1900 + }, + "%z": function (date) { + var off = date.tm_gmtoff; + var ahead = off >= 0; + off = Math.abs(off) / 60; + off = off / 60 * 100 + off % 60; + return (ahead ? "+" : "-") + String("0000" + off).slice(-4) + }, + "%Z": function (date) { + return date.tm_zone + }, + "%%": function () { + return "%" + } + }; + pattern = pattern.replace(/%%/g, "\0\0"); + for (var rule in EXPANSION_RULES_2) { + if (pattern.includes(rule)) { + pattern = pattern.replace(new RegExp(rule, "g"), EXPANSION_RULES_2[rule](date)) + } + } + pattern = pattern.replace(/\0\0/g, "%"); + var bytes = intArrayFromString(pattern, false); + if (bytes.length > maxsize) { + return 0 + } + writeArrayToMemory(bytes, s); + return bytes.length - 1 + } + + function _strftime_l(s, maxsize, format, tm, loc) { + return _strftime(s, maxsize, format, tm) + } + + function getCFunc(ident) { + var func = Module["_" + ident]; + return func + } + + function ccall(ident, returnType, argTypes, args, opts) { + var toC = { + "string": str => { + var ret = 0; + if (str !== null && str !== undefined && str !== 0) { + var len = (str.length << 2) + 1; + ret = stackAlloc(len); + stringToUTF8(str, ret, len) + } + return ret + }, + "array": arr => { + var ret = stackAlloc(arr.length); + writeArrayToMemory(arr, ret); + return ret + } + }; + + function convertReturnValue(ret) { + if (returnType === "string") { + return UTF8ToString(ret) + } + if (returnType === "boolean") return Boolean(ret); + return ret + } + var func = getCFunc(ident); + var cArgs = []; + var stack = 0; + if (args) { + for (var i = 0; i < args.length; i++) { + var converter = toC[argTypes[i]]; + if (converter) { + if (stack === 0) stack = stackSave(); + cArgs[i] = converter(args[i]) + } else { + cArgs[i] = args[i] + } + } + } + var ret = func.apply(null, cArgs); + + function onDone(ret) { + if (stack !== 0) stackRestore(stack); + return convertReturnValue(ret) + } + ret = onDone(ret); + return ret + } + + function cwrap(ident, returnType, argTypes, opts) { + var numericArgs = !argTypes || argTypes.every(type => type === "number" || type === "boolean"); + var numericRet = returnType !== "string"; + if (numericRet && numericArgs && !opts) { + return getCFunc(ident) + } + return function () { + return ccall(ident, returnType, argTypes, arguments, opts) + } + } + var FSNode = function (parent, name, mode, rdev) { + if (!parent) { + parent = this + } + this.parent = parent; + this.mount = parent.mount; + this.mounted = null; + this.id = FS.nextInode++; + this.name = name; + this.mode = mode; + this.node_ops = {}; + this.stream_ops = {}; + this.rdev = rdev + }; + var readMode = 292 | 73; + var writeMode = 146; + Object.defineProperties(FSNode.prototype, { + read: { + get: function () { + return (this.mode & readMode) === readMode + }, + set: function (val) { + val ? this.mode |= readMode : this.mode &= ~readMode + } + }, + write: { + get: function () { + return (this.mode & writeMode) === writeMode + }, + set: function (val) { + val ? this.mode |= writeMode : this.mode &= ~writeMode + } + }, + isFolder: { + get: function () { + return FS.isDir(this.mode) + } + }, + isDevice: { + get: function () { + return FS.isChrdev(this.mode) + } + } + }); + FS.FSNode = FSNode; + FS.staticInit(); + Module["FS"] = FS; + var wasmImports = { + "__call_sighandler": ___call_sighandler, + "__syscall_fcntl64": ___syscall_fcntl64, + "__syscall_fstat64": ___syscall_fstat64, + "__syscall_ftruncate64": ___syscall_ftruncate64, + "__syscall_getdents64": ___syscall_getdents64, + "__syscall_ioctl": ___syscall_ioctl, + "__syscall_lstat64": ___syscall_lstat64, + "__syscall_newfstatat": ___syscall_newfstatat, + "__syscall_openat": ___syscall_openat, + "__syscall_rmdir": ___syscall_rmdir, + "__syscall_stat64": ___syscall_stat64, + "__syscall_unlinkat": ___syscall_unlinkat, + "_emscripten_throw_longjmp": __emscripten_throw_longjmp, + "_gmtime_js": __gmtime_js, + "_localtime_js": __localtime_js, + "_setitimer_js": __setitimer_js, + "_tzset_js": __tzset_js, + "abort": _abort, + "emscripten_date_now": _emscripten_date_now, + "emscripten_memcpy_big": _emscripten_memcpy_big, + "emscripten_resize_heap": _emscripten_resize_heap, + "environ_get": _environ_get, + "environ_sizes_get": _environ_sizes_get, + "fd_close": _fd_close, + "fd_read": _fd_read, + "fd_seek": _fd_seek, + "fd_sync": _fd_sync, + "fd_write": _fd_write, + "invoke_ii": invoke_ii, + "invoke_iii": invoke_iii, + "invoke_iiii": invoke_iiii, + "invoke_iiiii": invoke_iiiii, + "invoke_v": invoke_v, + "invoke_vi": invoke_vi, + "invoke_viii": invoke_viii, + "invoke_viiii": invoke_viiii, + "strftime_l": _strftime_l + }; + var asm = createWasm(); + var ___wasm_call_ctors = function () { + return (___wasm_call_ctors = Module["asm"]["__wasm_call_ctors"]).apply(null, arguments) + }; + var _FPDFAnnot_IsSupportedSubtype = Module["_FPDFAnnot_IsSupportedSubtype"] = function () { + return (_FPDFAnnot_IsSupportedSubtype = Module["_FPDFAnnot_IsSupportedSubtype"] = Module["asm"]["FPDFAnnot_IsSupportedSubtype"]).apply(null, arguments) + }; + var _FPDFPage_CreateAnnot = Module["_FPDFPage_CreateAnnot"] = function () { + return (_FPDFPage_CreateAnnot = Module["_FPDFPage_CreateAnnot"] = Module["asm"]["FPDFPage_CreateAnnot"]).apply(null, arguments) + }; + var _FPDFPage_GetAnnotCount = Module["_FPDFPage_GetAnnotCount"] = function () { + return (_FPDFPage_GetAnnotCount = Module["_FPDFPage_GetAnnotCount"] = Module["asm"]["FPDFPage_GetAnnotCount"]).apply(null, arguments) + }; + var _FPDFPage_GetAnnot = Module["_FPDFPage_GetAnnot"] = function () { + return (_FPDFPage_GetAnnot = Module["_FPDFPage_GetAnnot"] = Module["asm"]["FPDFPage_GetAnnot"]).apply(null, arguments) + }; + var _FPDFPage_GetAnnotIndex = Module["_FPDFPage_GetAnnotIndex"] = function () { + return (_FPDFPage_GetAnnotIndex = Module["_FPDFPage_GetAnnotIndex"] = Module["asm"]["FPDFPage_GetAnnotIndex"]).apply(null, arguments) + }; + var _FPDFPage_CloseAnnot = Module["_FPDFPage_CloseAnnot"] = function () { + return (_FPDFPage_CloseAnnot = Module["_FPDFPage_CloseAnnot"] = Module["asm"]["FPDFPage_CloseAnnot"]).apply(null, arguments) + }; + var _FPDFPage_RemoveAnnot = Module["_FPDFPage_RemoveAnnot"] = function () { + return (_FPDFPage_RemoveAnnot = Module["_FPDFPage_RemoveAnnot"] = Module["asm"]["FPDFPage_RemoveAnnot"]).apply(null, arguments) + }; + var _FPDFAnnot_GetSubtype = Module["_FPDFAnnot_GetSubtype"] = function () { + return (_FPDFAnnot_GetSubtype = Module["_FPDFAnnot_GetSubtype"] = Module["asm"]["FPDFAnnot_GetSubtype"]).apply(null, arguments) + }; + var _FPDFAnnot_IsObjectSupportedSubtype = Module["_FPDFAnnot_IsObjectSupportedSubtype"] = function () { + return (_FPDFAnnot_IsObjectSupportedSubtype = Module["_FPDFAnnot_IsObjectSupportedSubtype"] = Module["asm"]["FPDFAnnot_IsObjectSupportedSubtype"]).apply(null, arguments) + }; + var _FPDFAnnot_UpdateObject = Module["_FPDFAnnot_UpdateObject"] = function () { + return (_FPDFAnnot_UpdateObject = Module["_FPDFAnnot_UpdateObject"] = Module["asm"]["FPDFAnnot_UpdateObject"]).apply(null, arguments) + }; + var _FPDFAnnot_AddInkStroke = Module["_FPDFAnnot_AddInkStroke"] = function () { + return (_FPDFAnnot_AddInkStroke = Module["_FPDFAnnot_AddInkStroke"] = Module["asm"]["FPDFAnnot_AddInkStroke"]).apply(null, arguments) + }; + var _FPDFAnnot_RemoveInkList = Module["_FPDFAnnot_RemoveInkList"] = function () { + return (_FPDFAnnot_RemoveInkList = Module["_FPDFAnnot_RemoveInkList"] = Module["asm"]["FPDFAnnot_RemoveInkList"]).apply(null, arguments) + }; + var _FPDFAnnot_AppendObject = Module["_FPDFAnnot_AppendObject"] = function () { + return (_FPDFAnnot_AppendObject = Module["_FPDFAnnot_AppendObject"] = Module["asm"]["FPDFAnnot_AppendObject"]).apply(null, arguments) + }; + var _FPDFAnnot_GetObjectCount = Module["_FPDFAnnot_GetObjectCount"] = function () { + return (_FPDFAnnot_GetObjectCount = Module["_FPDFAnnot_GetObjectCount"] = Module["asm"]["FPDFAnnot_GetObjectCount"]).apply(null, arguments) + }; + var _FPDFAnnot_GetObject = Module["_FPDFAnnot_GetObject"] = function () { + return (_FPDFAnnot_GetObject = Module["_FPDFAnnot_GetObject"] = Module["asm"]["FPDFAnnot_GetObject"]).apply(null, arguments) + }; + var _FPDFAnnot_RemoveObject = Module["_FPDFAnnot_RemoveObject"] = function () { + return (_FPDFAnnot_RemoveObject = Module["_FPDFAnnot_RemoveObject"] = Module["asm"]["FPDFAnnot_RemoveObject"]).apply(null, arguments) + }; + var _FPDFAnnot_SetColor = Module["_FPDFAnnot_SetColor"] = function () { + return (_FPDFAnnot_SetColor = Module["_FPDFAnnot_SetColor"] = Module["asm"]["FPDFAnnot_SetColor"]).apply(null, arguments) + }; + var _FPDFAnnot_GetColor = Module["_FPDFAnnot_GetColor"] = function () { + return (_FPDFAnnot_GetColor = Module["_FPDFAnnot_GetColor"] = Module["asm"]["FPDFAnnot_GetColor"]).apply(null, arguments) + }; + var _FPDFAnnot_HasAttachmentPoints = Module["_FPDFAnnot_HasAttachmentPoints"] = function () { + return (_FPDFAnnot_HasAttachmentPoints = Module["_FPDFAnnot_HasAttachmentPoints"] = Module["asm"]["FPDFAnnot_HasAttachmentPoints"]).apply(null, arguments) + }; + var _FPDFAnnot_SetAttachmentPoints = Module["_FPDFAnnot_SetAttachmentPoints"] = function () { + return (_FPDFAnnot_SetAttachmentPoints = Module["_FPDFAnnot_SetAttachmentPoints"] = Module["asm"]["FPDFAnnot_SetAttachmentPoints"]).apply(null, arguments) + }; + var _FPDFAnnot_AppendAttachmentPoints = Module["_FPDFAnnot_AppendAttachmentPoints"] = function () { + return (_FPDFAnnot_AppendAttachmentPoints = Module["_FPDFAnnot_AppendAttachmentPoints"] = Module["asm"]["FPDFAnnot_AppendAttachmentPoints"]).apply(null, arguments) + }; + var _FPDFAnnot_CountAttachmentPoints = Module["_FPDFAnnot_CountAttachmentPoints"] = function () { + return (_FPDFAnnot_CountAttachmentPoints = Module["_FPDFAnnot_CountAttachmentPoints"] = Module["asm"]["FPDFAnnot_CountAttachmentPoints"]).apply(null, arguments) + }; + var _FPDFAnnot_GetAttachmentPoints = Module["_FPDFAnnot_GetAttachmentPoints"] = function () { + return (_FPDFAnnot_GetAttachmentPoints = Module["_FPDFAnnot_GetAttachmentPoints"] = Module["asm"]["FPDFAnnot_GetAttachmentPoints"]).apply(null, arguments) + }; + var _FPDFAnnot_SetRect = Module["_FPDFAnnot_SetRect"] = function () { + return (_FPDFAnnot_SetRect = Module["_FPDFAnnot_SetRect"] = Module["asm"]["FPDFAnnot_SetRect"]).apply(null, arguments) + }; + var _FPDFAnnot_GetRect = Module["_FPDFAnnot_GetRect"] = function () { + return (_FPDFAnnot_GetRect = Module["_FPDFAnnot_GetRect"] = Module["asm"]["FPDFAnnot_GetRect"]).apply(null, arguments) + }; + var _FPDFAnnot_GetVertices = Module["_FPDFAnnot_GetVertices"] = function () { + return (_FPDFAnnot_GetVertices = Module["_FPDFAnnot_GetVertices"] = Module["asm"]["FPDFAnnot_GetVertices"]).apply(null, arguments) + }; + var _FPDFAnnot_GetInkListCount = Module["_FPDFAnnot_GetInkListCount"] = function () { + return (_FPDFAnnot_GetInkListCount = Module["_FPDFAnnot_GetInkListCount"] = Module["asm"]["FPDFAnnot_GetInkListCount"]).apply(null, arguments) + }; + var _FPDFAnnot_GetInkListPath = Module["_FPDFAnnot_GetInkListPath"] = function () { + return (_FPDFAnnot_GetInkListPath = Module["_FPDFAnnot_GetInkListPath"] = Module["asm"]["FPDFAnnot_GetInkListPath"]).apply(null, arguments) + }; + var _FPDFAnnot_GetLine = Module["_FPDFAnnot_GetLine"] = function () { + return (_FPDFAnnot_GetLine = Module["_FPDFAnnot_GetLine"] = Module["asm"]["FPDFAnnot_GetLine"]).apply(null, arguments) + }; + var _FPDFAnnot_SetBorder = Module["_FPDFAnnot_SetBorder"] = function () { + return (_FPDFAnnot_SetBorder = Module["_FPDFAnnot_SetBorder"] = Module["asm"]["FPDFAnnot_SetBorder"]).apply(null, arguments) + }; + var _FPDFAnnot_GetBorder = Module["_FPDFAnnot_GetBorder"] = function () { + return (_FPDFAnnot_GetBorder = Module["_FPDFAnnot_GetBorder"] = Module["asm"]["FPDFAnnot_GetBorder"]).apply(null, arguments) + }; + var _FPDFAnnot_HasKey = Module["_FPDFAnnot_HasKey"] = function () { + return (_FPDFAnnot_HasKey = Module["_FPDFAnnot_HasKey"] = Module["asm"]["FPDFAnnot_HasKey"]).apply(null, arguments) + }; + var _FPDFAnnot_GetValueType = Module["_FPDFAnnot_GetValueType"] = function () { + return (_FPDFAnnot_GetValueType = Module["_FPDFAnnot_GetValueType"] = Module["asm"]["FPDFAnnot_GetValueType"]).apply(null, arguments) + }; + var _FPDFAnnot_SetStringValue = Module["_FPDFAnnot_SetStringValue"] = function () { + return (_FPDFAnnot_SetStringValue = Module["_FPDFAnnot_SetStringValue"] = Module["asm"]["FPDFAnnot_SetStringValue"]).apply(null, arguments) + }; + var _FPDFAnnot_GetStringValue = Module["_FPDFAnnot_GetStringValue"] = function () { + return (_FPDFAnnot_GetStringValue = Module["_FPDFAnnot_GetStringValue"] = Module["asm"]["FPDFAnnot_GetStringValue"]).apply(null, arguments) + }; + var _FPDFAnnot_GetNumberValue = Module["_FPDFAnnot_GetNumberValue"] = function () { + return (_FPDFAnnot_GetNumberValue = Module["_FPDFAnnot_GetNumberValue"] = Module["asm"]["FPDFAnnot_GetNumberValue"]).apply(null, arguments) + }; + var _FPDFAnnot_SetAP = Module["_FPDFAnnot_SetAP"] = function () { + return (_FPDFAnnot_SetAP = Module["_FPDFAnnot_SetAP"] = Module["asm"]["FPDFAnnot_SetAP"]).apply(null, arguments) + }; + var _FPDFAnnot_GetAP = Module["_FPDFAnnot_GetAP"] = function () { + return (_FPDFAnnot_GetAP = Module["_FPDFAnnot_GetAP"] = Module["asm"]["FPDFAnnot_GetAP"]).apply(null, arguments) + }; + var _FPDFAnnot_GetLinkedAnnot = Module["_FPDFAnnot_GetLinkedAnnot"] = function () { + return (_FPDFAnnot_GetLinkedAnnot = Module["_FPDFAnnot_GetLinkedAnnot"] = Module["asm"]["FPDFAnnot_GetLinkedAnnot"]).apply(null, arguments) + }; + var _FPDFAnnot_GetFlags = Module["_FPDFAnnot_GetFlags"] = function () { + return (_FPDFAnnot_GetFlags = Module["_FPDFAnnot_GetFlags"] = Module["asm"]["FPDFAnnot_GetFlags"]).apply(null, arguments) + }; + var _FPDFAnnot_SetFlags = Module["_FPDFAnnot_SetFlags"] = function () { + return (_FPDFAnnot_SetFlags = Module["_FPDFAnnot_SetFlags"] = Module["asm"]["FPDFAnnot_SetFlags"]).apply(null, arguments) + }; + var _FPDFAnnot_GetFormFieldFlags = Module["_FPDFAnnot_GetFormFieldFlags"] = function () { + return (_FPDFAnnot_GetFormFieldFlags = Module["_FPDFAnnot_GetFormFieldFlags"] = Module["asm"]["FPDFAnnot_GetFormFieldFlags"]).apply(null, arguments) + }; + var _FPDFAnnot_GetFormFieldAtPoint = Module["_FPDFAnnot_GetFormFieldAtPoint"] = function () { + return (_FPDFAnnot_GetFormFieldAtPoint = Module["_FPDFAnnot_GetFormFieldAtPoint"] = Module["asm"]["FPDFAnnot_GetFormFieldAtPoint"]).apply(null, arguments) + }; + var _FPDFAnnot_GetFormFieldName = Module["_FPDFAnnot_GetFormFieldName"] = function () { + return (_FPDFAnnot_GetFormFieldName = Module["_FPDFAnnot_GetFormFieldName"] = Module["asm"]["FPDFAnnot_GetFormFieldName"]).apply(null, arguments) + }; + var _FPDFAnnot_GetFormFieldType = Module["_FPDFAnnot_GetFormFieldType"] = function () { + return (_FPDFAnnot_GetFormFieldType = Module["_FPDFAnnot_GetFormFieldType"] = Module["asm"]["FPDFAnnot_GetFormFieldType"]).apply(null, arguments) + }; + var _FPDFAnnot_GetFormAdditionalActionJavaScript = Module["_FPDFAnnot_GetFormAdditionalActionJavaScript"] = function () { + return (_FPDFAnnot_GetFormAdditionalActionJavaScript = Module["_FPDFAnnot_GetFormAdditionalActionJavaScript"] = Module["asm"]["FPDFAnnot_GetFormAdditionalActionJavaScript"]).apply(null, arguments) + }; + var _FPDFAnnot_GetFormFieldAlternateName = Module["_FPDFAnnot_GetFormFieldAlternateName"] = function () { + return (_FPDFAnnot_GetFormFieldAlternateName = Module["_FPDFAnnot_GetFormFieldAlternateName"] = Module["asm"]["FPDFAnnot_GetFormFieldAlternateName"]).apply(null, arguments) + }; + var _FPDFAnnot_GetFormFieldValue = Module["_FPDFAnnot_GetFormFieldValue"] = function () { + return (_FPDFAnnot_GetFormFieldValue = Module["_FPDFAnnot_GetFormFieldValue"] = Module["asm"]["FPDFAnnot_GetFormFieldValue"]).apply(null, arguments) + }; + var _FPDFAnnot_GetOptionCount = Module["_FPDFAnnot_GetOptionCount"] = function () { + return (_FPDFAnnot_GetOptionCount = Module["_FPDFAnnot_GetOptionCount"] = Module["asm"]["FPDFAnnot_GetOptionCount"]).apply(null, arguments) + }; + var _FPDFAnnot_GetOptionLabel = Module["_FPDFAnnot_GetOptionLabel"] = function () { + return (_FPDFAnnot_GetOptionLabel = Module["_FPDFAnnot_GetOptionLabel"] = Module["asm"]["FPDFAnnot_GetOptionLabel"]).apply(null, arguments) + }; + var _FPDFAnnot_IsOptionSelected = Module["_FPDFAnnot_IsOptionSelected"] = function () { + return (_FPDFAnnot_IsOptionSelected = Module["_FPDFAnnot_IsOptionSelected"] = Module["asm"]["FPDFAnnot_IsOptionSelected"]).apply(null, arguments) + }; + var _FPDFAnnot_GetFontSize = Module["_FPDFAnnot_GetFontSize"] = function () { + return (_FPDFAnnot_GetFontSize = Module["_FPDFAnnot_GetFontSize"] = Module["asm"]["FPDFAnnot_GetFontSize"]).apply(null, arguments) + }; + var _FPDFAnnot_IsChecked = Module["_FPDFAnnot_IsChecked"] = function () { + return (_FPDFAnnot_IsChecked = Module["_FPDFAnnot_IsChecked"] = Module["asm"]["FPDFAnnot_IsChecked"]).apply(null, arguments) + }; + var _FPDFAnnot_SetFocusableSubtypes = Module["_FPDFAnnot_SetFocusableSubtypes"] = function () { + return (_FPDFAnnot_SetFocusableSubtypes = Module["_FPDFAnnot_SetFocusableSubtypes"] = Module["asm"]["FPDFAnnot_SetFocusableSubtypes"]).apply(null, arguments) + }; + var _FPDFAnnot_GetFocusableSubtypesCount = Module["_FPDFAnnot_GetFocusableSubtypesCount"] = function () { + return (_FPDFAnnot_GetFocusableSubtypesCount = Module["_FPDFAnnot_GetFocusableSubtypesCount"] = Module["asm"]["FPDFAnnot_GetFocusableSubtypesCount"]).apply(null, arguments) + }; + var _FPDFAnnot_GetFocusableSubtypes = Module["_FPDFAnnot_GetFocusableSubtypes"] = function () { + return (_FPDFAnnot_GetFocusableSubtypes = Module["_FPDFAnnot_GetFocusableSubtypes"] = Module["asm"]["FPDFAnnot_GetFocusableSubtypes"]).apply(null, arguments) + }; + var _FPDFAnnot_GetLink = Module["_FPDFAnnot_GetLink"] = function () { + return (_FPDFAnnot_GetLink = Module["_FPDFAnnot_GetLink"] = Module["asm"]["FPDFAnnot_GetLink"]).apply(null, arguments) + }; + var _FPDFAnnot_GetFormControlCount = Module["_FPDFAnnot_GetFormControlCount"] = function () { + return (_FPDFAnnot_GetFormControlCount = Module["_FPDFAnnot_GetFormControlCount"] = Module["asm"]["FPDFAnnot_GetFormControlCount"]).apply(null, arguments) + }; + var _FPDFAnnot_GetFormControlIndex = Module["_FPDFAnnot_GetFormControlIndex"] = function () { + return (_FPDFAnnot_GetFormControlIndex = Module["_FPDFAnnot_GetFormControlIndex"] = Module["asm"]["FPDFAnnot_GetFormControlIndex"]).apply(null, arguments) + }; + var _FPDFAnnot_GetFormFieldExportValue = Module["_FPDFAnnot_GetFormFieldExportValue"] = function () { + return (_FPDFAnnot_GetFormFieldExportValue = Module["_FPDFAnnot_GetFormFieldExportValue"] = Module["asm"]["FPDFAnnot_GetFormFieldExportValue"]).apply(null, arguments) + }; + var _FPDFAnnot_SetURI = Module["_FPDFAnnot_SetURI"] = function () { + return (_FPDFAnnot_SetURI = Module["_FPDFAnnot_SetURI"] = Module["asm"]["FPDFAnnot_SetURI"]).apply(null, arguments) + }; + var _FPDFDoc_GetAttachmentCount = Module["_FPDFDoc_GetAttachmentCount"] = function () { + return (_FPDFDoc_GetAttachmentCount = Module["_FPDFDoc_GetAttachmentCount"] = Module["asm"]["FPDFDoc_GetAttachmentCount"]).apply(null, arguments) + }; + var _FPDFDoc_AddAttachment = Module["_FPDFDoc_AddAttachment"] = function () { + return (_FPDFDoc_AddAttachment = Module["_FPDFDoc_AddAttachment"] = Module["asm"]["FPDFDoc_AddAttachment"]).apply(null, arguments) + }; + var _FPDFDoc_GetAttachment = Module["_FPDFDoc_GetAttachment"] = function () { + return (_FPDFDoc_GetAttachment = Module["_FPDFDoc_GetAttachment"] = Module["asm"]["FPDFDoc_GetAttachment"]).apply(null, arguments) + }; + var _FPDFDoc_DeleteAttachment = Module["_FPDFDoc_DeleteAttachment"] = function () { + return (_FPDFDoc_DeleteAttachment = Module["_FPDFDoc_DeleteAttachment"] = Module["asm"]["FPDFDoc_DeleteAttachment"]).apply(null, arguments) + }; + var _FPDFAttachment_GetName = Module["_FPDFAttachment_GetName"] = function () { + return (_FPDFAttachment_GetName = Module["_FPDFAttachment_GetName"] = Module["asm"]["FPDFAttachment_GetName"]).apply(null, arguments) + }; + var _FPDFAttachment_HasKey = Module["_FPDFAttachment_HasKey"] = function () { + return (_FPDFAttachment_HasKey = Module["_FPDFAttachment_HasKey"] = Module["asm"]["FPDFAttachment_HasKey"]).apply(null, arguments) + }; + var _FPDFAttachment_GetValueType = Module["_FPDFAttachment_GetValueType"] = function () { + return (_FPDFAttachment_GetValueType = Module["_FPDFAttachment_GetValueType"] = Module["asm"]["FPDFAttachment_GetValueType"]).apply(null, arguments) + }; + var _FPDFAttachment_SetStringValue = Module["_FPDFAttachment_SetStringValue"] = function () { + return (_FPDFAttachment_SetStringValue = Module["_FPDFAttachment_SetStringValue"] = Module["asm"]["FPDFAttachment_SetStringValue"]).apply(null, arguments) + }; + var _FPDFAttachment_GetStringValue = Module["_FPDFAttachment_GetStringValue"] = function () { + return (_FPDFAttachment_GetStringValue = Module["_FPDFAttachment_GetStringValue"] = Module["asm"]["FPDFAttachment_GetStringValue"]).apply(null, arguments) + }; + var _FPDFAttachment_SetFile = Module["_FPDFAttachment_SetFile"] = function () { + return (_FPDFAttachment_SetFile = Module["_FPDFAttachment_SetFile"] = Module["asm"]["FPDFAttachment_SetFile"]).apply(null, arguments) + }; + var _FPDFAttachment_GetFile = Module["_FPDFAttachment_GetFile"] = function () { + return (_FPDFAttachment_GetFile = Module["_FPDFAttachment_GetFile"] = Module["asm"]["FPDFAttachment_GetFile"]).apply(null, arguments) + }; + var _FPDFCatalog_IsTagged = Module["_FPDFCatalog_IsTagged"] = function () { + return (_FPDFCatalog_IsTagged = Module["_FPDFCatalog_IsTagged"] = Module["asm"]["FPDFCatalog_IsTagged"]).apply(null, arguments) + }; + var _FPDFAvail_Create = Module["_FPDFAvail_Create"] = function () { + return (_FPDFAvail_Create = Module["_FPDFAvail_Create"] = Module["asm"]["FPDFAvail_Create"]).apply(null, arguments) + }; + var _FPDFAvail_Destroy = Module["_FPDFAvail_Destroy"] = function () { + return (_FPDFAvail_Destroy = Module["_FPDFAvail_Destroy"] = Module["asm"]["FPDFAvail_Destroy"]).apply(null, arguments) + }; + var _FPDFAvail_IsDocAvail = Module["_FPDFAvail_IsDocAvail"] = function () { + return (_FPDFAvail_IsDocAvail = Module["_FPDFAvail_IsDocAvail"] = Module["asm"]["FPDFAvail_IsDocAvail"]).apply(null, arguments) + }; + var _FPDFAvail_GetDocument = Module["_FPDFAvail_GetDocument"] = function () { + return (_FPDFAvail_GetDocument = Module["_FPDFAvail_GetDocument"] = Module["asm"]["FPDFAvail_GetDocument"]).apply(null, arguments) + }; + var _FPDFAvail_GetFirstPageNum = Module["_FPDFAvail_GetFirstPageNum"] = function () { + return (_FPDFAvail_GetFirstPageNum = Module["_FPDFAvail_GetFirstPageNum"] = Module["asm"]["FPDFAvail_GetFirstPageNum"]).apply(null, arguments) + }; + var _FPDFAvail_IsPageAvail = Module["_FPDFAvail_IsPageAvail"] = function () { + return (_FPDFAvail_IsPageAvail = Module["_FPDFAvail_IsPageAvail"] = Module["asm"]["FPDFAvail_IsPageAvail"]).apply(null, arguments) + }; + var _FPDFAvail_IsFormAvail = Module["_FPDFAvail_IsFormAvail"] = function () { + return (_FPDFAvail_IsFormAvail = Module["_FPDFAvail_IsFormAvail"] = Module["asm"]["FPDFAvail_IsFormAvail"]).apply(null, arguments) + }; + var _FPDFAvail_IsLinearized = Module["_FPDFAvail_IsLinearized"] = function () { + return (_FPDFAvail_IsLinearized = Module["_FPDFAvail_IsLinearized"] = Module["asm"]["FPDFAvail_IsLinearized"]).apply(null, arguments) + }; + var _FPDFBookmark_GetFirstChild = Module["_FPDFBookmark_GetFirstChild"] = function () { + return (_FPDFBookmark_GetFirstChild = Module["_FPDFBookmark_GetFirstChild"] = Module["asm"]["FPDFBookmark_GetFirstChild"]).apply(null, arguments) + }; + var _FPDFBookmark_GetNextSibling = Module["_FPDFBookmark_GetNextSibling"] = function () { + return (_FPDFBookmark_GetNextSibling = Module["_FPDFBookmark_GetNextSibling"] = Module["asm"]["FPDFBookmark_GetNextSibling"]).apply(null, arguments) + }; + var _FPDFBookmark_GetTitle = Module["_FPDFBookmark_GetTitle"] = function () { + return (_FPDFBookmark_GetTitle = Module["_FPDFBookmark_GetTitle"] = Module["asm"]["FPDFBookmark_GetTitle"]).apply(null, arguments) + }; + var _FPDFBookmark_GetCount = Module["_FPDFBookmark_GetCount"] = function () { + return (_FPDFBookmark_GetCount = Module["_FPDFBookmark_GetCount"] = Module["asm"]["FPDFBookmark_GetCount"]).apply(null, arguments) + }; + var _FPDFBookmark_Find = Module["_FPDFBookmark_Find"] = function () { + return (_FPDFBookmark_Find = Module["_FPDFBookmark_Find"] = Module["asm"]["FPDFBookmark_Find"]).apply(null, arguments) + }; + var _FPDFBookmark_GetDest = Module["_FPDFBookmark_GetDest"] = function () { + return (_FPDFBookmark_GetDest = Module["_FPDFBookmark_GetDest"] = Module["asm"]["FPDFBookmark_GetDest"]).apply(null, arguments) + }; + var _FPDFBookmark_GetAction = Module["_FPDFBookmark_GetAction"] = function () { + return (_FPDFBookmark_GetAction = Module["_FPDFBookmark_GetAction"] = Module["asm"]["FPDFBookmark_GetAction"]).apply(null, arguments) + }; + var _FPDFAction_GetType = Module["_FPDFAction_GetType"] = function () { + return (_FPDFAction_GetType = Module["_FPDFAction_GetType"] = Module["asm"]["FPDFAction_GetType"]).apply(null, arguments) + }; + var _FPDFAction_GetDest = Module["_FPDFAction_GetDest"] = function () { + return (_FPDFAction_GetDest = Module["_FPDFAction_GetDest"] = Module["asm"]["FPDFAction_GetDest"]).apply(null, arguments) + }; + var _FPDFAction_GetFilePath = Module["_FPDFAction_GetFilePath"] = function () { + return (_FPDFAction_GetFilePath = Module["_FPDFAction_GetFilePath"] = Module["asm"]["FPDFAction_GetFilePath"]).apply(null, arguments) + }; + var _FPDFAction_GetURIPath = Module["_FPDFAction_GetURIPath"] = function () { + return (_FPDFAction_GetURIPath = Module["_FPDFAction_GetURIPath"] = Module["asm"]["FPDFAction_GetURIPath"]).apply(null, arguments) + }; + var _FPDFDest_GetDestPageIndex = Module["_FPDFDest_GetDestPageIndex"] = function () { + return (_FPDFDest_GetDestPageIndex = Module["_FPDFDest_GetDestPageIndex"] = Module["asm"]["FPDFDest_GetDestPageIndex"]).apply(null, arguments) + }; + var _FPDFDest_GetView = Module["_FPDFDest_GetView"] = function () { + return (_FPDFDest_GetView = Module["_FPDFDest_GetView"] = Module["asm"]["FPDFDest_GetView"]).apply(null, arguments) + }; + var _FPDFDest_GetLocationInPage = Module["_FPDFDest_GetLocationInPage"] = function () { + return (_FPDFDest_GetLocationInPage = Module["_FPDFDest_GetLocationInPage"] = Module["asm"]["FPDFDest_GetLocationInPage"]).apply(null, arguments) + }; + var _FPDFLink_GetLinkAtPoint = Module["_FPDFLink_GetLinkAtPoint"] = function () { + return (_FPDFLink_GetLinkAtPoint = Module["_FPDFLink_GetLinkAtPoint"] = Module["asm"]["FPDFLink_GetLinkAtPoint"]).apply(null, arguments) + }; + var _FPDFLink_GetLinkZOrderAtPoint = Module["_FPDFLink_GetLinkZOrderAtPoint"] = function () { + return (_FPDFLink_GetLinkZOrderAtPoint = Module["_FPDFLink_GetLinkZOrderAtPoint"] = Module["asm"]["FPDFLink_GetLinkZOrderAtPoint"]).apply(null, arguments) + }; + var _FPDFLink_GetDest = Module["_FPDFLink_GetDest"] = function () { + return (_FPDFLink_GetDest = Module["_FPDFLink_GetDest"] = Module["asm"]["FPDFLink_GetDest"]).apply(null, arguments) + }; + var _FPDFLink_GetAction = Module["_FPDFLink_GetAction"] = function () { + return (_FPDFLink_GetAction = Module["_FPDFLink_GetAction"] = Module["asm"]["FPDFLink_GetAction"]).apply(null, arguments) + }; + var _FPDFLink_Enumerate = Module["_FPDFLink_Enumerate"] = function () { + return (_FPDFLink_Enumerate = Module["_FPDFLink_Enumerate"] = Module["asm"]["FPDFLink_Enumerate"]).apply(null, arguments) + }; + var _FPDFLink_GetAnnot = Module["_FPDFLink_GetAnnot"] = function () { + return (_FPDFLink_GetAnnot = Module["_FPDFLink_GetAnnot"] = Module["asm"]["FPDFLink_GetAnnot"]).apply(null, arguments) + }; + var _FPDFLink_GetAnnotRect = Module["_FPDFLink_GetAnnotRect"] = function () { + return (_FPDFLink_GetAnnotRect = Module["_FPDFLink_GetAnnotRect"] = Module["asm"]["FPDFLink_GetAnnotRect"]).apply(null, arguments) + }; + var _FPDFLink_CountQuadPoints = Module["_FPDFLink_CountQuadPoints"] = function () { + return (_FPDFLink_CountQuadPoints = Module["_FPDFLink_CountQuadPoints"] = Module["asm"]["FPDFLink_CountQuadPoints"]).apply(null, arguments) + }; + var _FPDFLink_GetQuadPoints = Module["_FPDFLink_GetQuadPoints"] = function () { + return (_FPDFLink_GetQuadPoints = Module["_FPDFLink_GetQuadPoints"] = Module["asm"]["FPDFLink_GetQuadPoints"]).apply(null, arguments) + }; + var _FPDF_GetPageAAction = Module["_FPDF_GetPageAAction"] = function () { + return (_FPDF_GetPageAAction = Module["_FPDF_GetPageAAction"] = Module["asm"]["FPDF_GetPageAAction"]).apply(null, arguments) + }; + var _FPDF_GetFileIdentifier = Module["_FPDF_GetFileIdentifier"] = function () { + return (_FPDF_GetFileIdentifier = Module["_FPDF_GetFileIdentifier"] = Module["asm"]["FPDF_GetFileIdentifier"]).apply(null, arguments) + }; + var _FPDF_GetMetaText = Module["_FPDF_GetMetaText"] = function () { + return (_FPDF_GetMetaText = Module["_FPDF_GetMetaText"] = Module["asm"]["FPDF_GetMetaText"]).apply(null, arguments) + }; + var _FPDF_GetPageLabel = Module["_FPDF_GetPageLabel"] = function () { + return (_FPDF_GetPageLabel = Module["_FPDF_GetPageLabel"] = Module["asm"]["FPDF_GetPageLabel"]).apply(null, arguments) + }; + var _FPDFPageObj_NewImageObj = Module["_FPDFPageObj_NewImageObj"] = function () { + return (_FPDFPageObj_NewImageObj = Module["_FPDFPageObj_NewImageObj"] = Module["asm"]["FPDFPageObj_NewImageObj"]).apply(null, arguments) + }; + var _FPDFImageObj_LoadJpegFile = Module["_FPDFImageObj_LoadJpegFile"] = function () { + return (_FPDFImageObj_LoadJpegFile = Module["_FPDFImageObj_LoadJpegFile"] = Module["asm"]["FPDFImageObj_LoadJpegFile"]).apply(null, arguments) + }; + var _FPDFImageObj_LoadJpegFileInline = Module["_FPDFImageObj_LoadJpegFileInline"] = function () { + return (_FPDFImageObj_LoadJpegFileInline = Module["_FPDFImageObj_LoadJpegFileInline"] = Module["asm"]["FPDFImageObj_LoadJpegFileInline"]).apply(null, arguments) + }; + var _FPDFImageObj_SetMatrix = Module["_FPDFImageObj_SetMatrix"] = function () { + return (_FPDFImageObj_SetMatrix = Module["_FPDFImageObj_SetMatrix"] = Module["asm"]["FPDFImageObj_SetMatrix"]).apply(null, arguments) + }; + var _FPDFImageObj_SetBitmap = Module["_FPDFImageObj_SetBitmap"] = function () { + return (_FPDFImageObj_SetBitmap = Module["_FPDFImageObj_SetBitmap"] = Module["asm"]["FPDFImageObj_SetBitmap"]).apply(null, arguments) + }; + var _FPDFImageObj_GetBitmap = Module["_FPDFImageObj_GetBitmap"] = function () { + return (_FPDFImageObj_GetBitmap = Module["_FPDFImageObj_GetBitmap"] = Module["asm"]["FPDFImageObj_GetBitmap"]).apply(null, arguments) + }; + var _FPDFImageObj_GetRenderedBitmap = Module["_FPDFImageObj_GetRenderedBitmap"] = function () { + return (_FPDFImageObj_GetRenderedBitmap = Module["_FPDFImageObj_GetRenderedBitmap"] = Module["asm"]["FPDFImageObj_GetRenderedBitmap"]).apply(null, arguments) + }; + var _FPDFImageObj_GetImageDataDecoded = Module["_FPDFImageObj_GetImageDataDecoded"] = function () { + return (_FPDFImageObj_GetImageDataDecoded = Module["_FPDFImageObj_GetImageDataDecoded"] = Module["asm"]["FPDFImageObj_GetImageDataDecoded"]).apply(null, arguments) + }; + var _FPDFImageObj_GetImageDataRaw = Module["_FPDFImageObj_GetImageDataRaw"] = function () { + return (_FPDFImageObj_GetImageDataRaw = Module["_FPDFImageObj_GetImageDataRaw"] = Module["asm"]["FPDFImageObj_GetImageDataRaw"]).apply(null, arguments) + }; + var _FPDFImageObj_GetImageFilterCount = Module["_FPDFImageObj_GetImageFilterCount"] = function () { + return (_FPDFImageObj_GetImageFilterCount = Module["_FPDFImageObj_GetImageFilterCount"] = Module["asm"]["FPDFImageObj_GetImageFilterCount"]).apply(null, arguments) + }; + var _FPDFImageObj_GetImageFilter = Module["_FPDFImageObj_GetImageFilter"] = function () { + return (_FPDFImageObj_GetImageFilter = Module["_FPDFImageObj_GetImageFilter"] = Module["asm"]["FPDFImageObj_GetImageFilter"]).apply(null, arguments) + }; + var _FPDFImageObj_GetImageMetadata = Module["_FPDFImageObj_GetImageMetadata"] = function () { + return (_FPDFImageObj_GetImageMetadata = Module["_FPDFImageObj_GetImageMetadata"] = Module["asm"]["FPDFImageObj_GetImageMetadata"]).apply(null, arguments) + }; + var _FPDFImageObj_GetImagePixelSize = Module["_FPDFImageObj_GetImagePixelSize"] = function () { + return (_FPDFImageObj_GetImagePixelSize = Module["_FPDFImageObj_GetImagePixelSize"] = Module["asm"]["FPDFImageObj_GetImagePixelSize"]).apply(null, arguments) + }; + var _FPDF_CreateNewDocument = Module["_FPDF_CreateNewDocument"] = function () { + return (_FPDF_CreateNewDocument = Module["_FPDF_CreateNewDocument"] = Module["asm"]["FPDF_CreateNewDocument"]).apply(null, arguments) + }; + var _FPDFPage_Delete = Module["_FPDFPage_Delete"] = function () { + return (_FPDFPage_Delete = Module["_FPDFPage_Delete"] = Module["asm"]["FPDFPage_Delete"]).apply(null, arguments) + }; + var _FPDFPage_New = Module["_FPDFPage_New"] = function () { + return (_FPDFPage_New = Module["_FPDFPage_New"] = Module["asm"]["FPDFPage_New"]).apply(null, arguments) + }; + var _FPDFPage_GetRotation = Module["_FPDFPage_GetRotation"] = function () { + return (_FPDFPage_GetRotation = Module["_FPDFPage_GetRotation"] = Module["asm"]["FPDFPage_GetRotation"]).apply(null, arguments) + }; + var _FPDFPage_InsertObject = Module["_FPDFPage_InsertObject"] = function () { + return (_FPDFPage_InsertObject = Module["_FPDFPage_InsertObject"] = Module["asm"]["FPDFPage_InsertObject"]).apply(null, arguments) + }; + var _FPDFPage_RemoveObject = Module["_FPDFPage_RemoveObject"] = function () { + return (_FPDFPage_RemoveObject = Module["_FPDFPage_RemoveObject"] = Module["asm"]["FPDFPage_RemoveObject"]).apply(null, arguments) + }; + var _FPDFPage_CountObjects = Module["_FPDFPage_CountObjects"] = function () { + return (_FPDFPage_CountObjects = Module["_FPDFPage_CountObjects"] = Module["asm"]["FPDFPage_CountObjects"]).apply(null, arguments) + }; + var _FPDFPage_GetObject = Module["_FPDFPage_GetObject"] = function () { + return (_FPDFPage_GetObject = Module["_FPDFPage_GetObject"] = Module["asm"]["FPDFPage_GetObject"]).apply(null, arguments) + }; + var _FPDFPage_HasTransparency = Module["_FPDFPage_HasTransparency"] = function () { + return (_FPDFPage_HasTransparency = Module["_FPDFPage_HasTransparency"] = Module["asm"]["FPDFPage_HasTransparency"]).apply(null, arguments) + }; + var _FPDFPageObj_Destroy = Module["_FPDFPageObj_Destroy"] = function () { + return (_FPDFPageObj_Destroy = Module["_FPDFPageObj_Destroy"] = Module["asm"]["FPDFPageObj_Destroy"]).apply(null, arguments) + }; + var _FPDFPageObj_CountMarks = Module["_FPDFPageObj_CountMarks"] = function () { + return (_FPDFPageObj_CountMarks = Module["_FPDFPageObj_CountMarks"] = Module["asm"]["FPDFPageObj_CountMarks"]).apply(null, arguments) + }; + var _FPDFPageObj_GetMark = Module["_FPDFPageObj_GetMark"] = function () { + return (_FPDFPageObj_GetMark = Module["_FPDFPageObj_GetMark"] = Module["asm"]["FPDFPageObj_GetMark"]).apply(null, arguments) + }; + var _FPDFPageObj_AddMark = Module["_FPDFPageObj_AddMark"] = function () { + return (_FPDFPageObj_AddMark = Module["_FPDFPageObj_AddMark"] = Module["asm"]["FPDFPageObj_AddMark"]).apply(null, arguments) + }; + var _FPDFPageObj_RemoveMark = Module["_FPDFPageObj_RemoveMark"] = function () { + return (_FPDFPageObj_RemoveMark = Module["_FPDFPageObj_RemoveMark"] = Module["asm"]["FPDFPageObj_RemoveMark"]).apply(null, arguments) + }; + var _FPDFPageObjMark_GetName = Module["_FPDFPageObjMark_GetName"] = function () { + return (_FPDFPageObjMark_GetName = Module["_FPDFPageObjMark_GetName"] = Module["asm"]["FPDFPageObjMark_GetName"]).apply(null, arguments) + }; + var _FPDFPageObjMark_CountParams = Module["_FPDFPageObjMark_CountParams"] = function () { + return (_FPDFPageObjMark_CountParams = Module["_FPDFPageObjMark_CountParams"] = Module["asm"]["FPDFPageObjMark_CountParams"]).apply(null, arguments) + }; + var _FPDFPageObjMark_GetParamKey = Module["_FPDFPageObjMark_GetParamKey"] = function () { + return (_FPDFPageObjMark_GetParamKey = Module["_FPDFPageObjMark_GetParamKey"] = Module["asm"]["FPDFPageObjMark_GetParamKey"]).apply(null, arguments) + }; + var _FPDFPageObjMark_GetParamValueType = Module["_FPDFPageObjMark_GetParamValueType"] = function () { + return (_FPDFPageObjMark_GetParamValueType = Module["_FPDFPageObjMark_GetParamValueType"] = Module["asm"]["FPDFPageObjMark_GetParamValueType"]).apply(null, arguments) + }; + var _FPDFPageObjMark_GetParamIntValue = Module["_FPDFPageObjMark_GetParamIntValue"] = function () { + return (_FPDFPageObjMark_GetParamIntValue = Module["_FPDFPageObjMark_GetParamIntValue"] = Module["asm"]["FPDFPageObjMark_GetParamIntValue"]).apply(null, arguments) + }; + var _FPDFPageObjMark_GetParamStringValue = Module["_FPDFPageObjMark_GetParamStringValue"] = function () { + return (_FPDFPageObjMark_GetParamStringValue = Module["_FPDFPageObjMark_GetParamStringValue"] = Module["asm"]["FPDFPageObjMark_GetParamStringValue"]).apply(null, arguments) + }; + var _FPDFPageObjMark_GetParamBlobValue = Module["_FPDFPageObjMark_GetParamBlobValue"] = function () { + return (_FPDFPageObjMark_GetParamBlobValue = Module["_FPDFPageObjMark_GetParamBlobValue"] = Module["asm"]["FPDFPageObjMark_GetParamBlobValue"]).apply(null, arguments) + }; + var _FPDFPageObj_HasTransparency = Module["_FPDFPageObj_HasTransparency"] = function () { + return (_FPDFPageObj_HasTransparency = Module["_FPDFPageObj_HasTransparency"] = Module["asm"]["FPDFPageObj_HasTransparency"]).apply(null, arguments) + }; + var _FPDFPageObjMark_SetIntParam = Module["_FPDFPageObjMark_SetIntParam"] = function () { + return (_FPDFPageObjMark_SetIntParam = Module["_FPDFPageObjMark_SetIntParam"] = Module["asm"]["FPDFPageObjMark_SetIntParam"]).apply(null, arguments) + }; + var _FPDFPageObjMark_SetStringParam = Module["_FPDFPageObjMark_SetStringParam"] = function () { + return (_FPDFPageObjMark_SetStringParam = Module["_FPDFPageObjMark_SetStringParam"] = Module["asm"]["FPDFPageObjMark_SetStringParam"]).apply(null, arguments) + }; + var _FPDFPageObjMark_SetBlobParam = Module["_FPDFPageObjMark_SetBlobParam"] = function () { + return (_FPDFPageObjMark_SetBlobParam = Module["_FPDFPageObjMark_SetBlobParam"] = Module["asm"]["FPDFPageObjMark_SetBlobParam"]).apply(null, arguments) + }; + var _FPDFPageObjMark_RemoveParam = Module["_FPDFPageObjMark_RemoveParam"] = function () { + return (_FPDFPageObjMark_RemoveParam = Module["_FPDFPageObjMark_RemoveParam"] = Module["asm"]["FPDFPageObjMark_RemoveParam"]).apply(null, arguments) + }; + var _FPDFPageObj_GetType = Module["_FPDFPageObj_GetType"] = function () { + return (_FPDFPageObj_GetType = Module["_FPDFPageObj_GetType"] = Module["asm"]["FPDFPageObj_GetType"]).apply(null, arguments) + }; + var _FPDFPage_GenerateContent = Module["_FPDFPage_GenerateContent"] = function () { + return (_FPDFPage_GenerateContent = Module["_FPDFPage_GenerateContent"] = Module["asm"]["FPDFPage_GenerateContent"]).apply(null, arguments) + }; + var _FPDFPageObj_Transform = Module["_FPDFPageObj_Transform"] = function () { + return (_FPDFPageObj_Transform = Module["_FPDFPageObj_Transform"] = Module["asm"]["FPDFPageObj_Transform"]).apply(null, arguments) + }; + var _FPDFPageObj_GetMatrix = Module["_FPDFPageObj_GetMatrix"] = function () { + return (_FPDFPageObj_GetMatrix = Module["_FPDFPageObj_GetMatrix"] = Module["asm"]["FPDFPageObj_GetMatrix"]).apply(null, arguments) + }; + var _FPDFPageObj_SetMatrix = Module["_FPDFPageObj_SetMatrix"] = function () { + return (_FPDFPageObj_SetMatrix = Module["_FPDFPageObj_SetMatrix"] = Module["asm"]["FPDFPageObj_SetMatrix"]).apply(null, arguments) + }; + var _FPDFPageObj_SetBlendMode = Module["_FPDFPageObj_SetBlendMode"] = function () { + return (_FPDFPageObj_SetBlendMode = Module["_FPDFPageObj_SetBlendMode"] = Module["asm"]["FPDFPageObj_SetBlendMode"]).apply(null, arguments) + }; + var _FPDFPage_TransformAnnots = Module["_FPDFPage_TransformAnnots"] = function () { + return (_FPDFPage_TransformAnnots = Module["_FPDFPage_TransformAnnots"] = Module["asm"]["FPDFPage_TransformAnnots"]).apply(null, arguments) + }; + var _FPDFPage_SetRotation = Module["_FPDFPage_SetRotation"] = function () { + return (_FPDFPage_SetRotation = Module["_FPDFPage_SetRotation"] = Module["asm"]["FPDFPage_SetRotation"]).apply(null, arguments) + }; + var _FPDFPageObj_SetFillColor = Module["_FPDFPageObj_SetFillColor"] = function () { + return (_FPDFPageObj_SetFillColor = Module["_FPDFPageObj_SetFillColor"] = Module["asm"]["FPDFPageObj_SetFillColor"]).apply(null, arguments) + }; + var _FPDFPageObj_GetFillColor = Module["_FPDFPageObj_GetFillColor"] = function () { + return (_FPDFPageObj_GetFillColor = Module["_FPDFPageObj_GetFillColor"] = Module["asm"]["FPDFPageObj_GetFillColor"]).apply(null, arguments) + }; + var _FPDFPageObj_GetBounds = Module["_FPDFPageObj_GetBounds"] = function () { + return (_FPDFPageObj_GetBounds = Module["_FPDFPageObj_GetBounds"] = Module["asm"]["FPDFPageObj_GetBounds"]).apply(null, arguments) + }; + var _FPDFPageObj_GetRotatedBounds = Module["_FPDFPageObj_GetRotatedBounds"] = function () { + return (_FPDFPageObj_GetRotatedBounds = Module["_FPDFPageObj_GetRotatedBounds"] = Module["asm"]["FPDFPageObj_GetRotatedBounds"]).apply(null, arguments) + }; + var _FPDFPageObj_SetStrokeColor = Module["_FPDFPageObj_SetStrokeColor"] = function () { + return (_FPDFPageObj_SetStrokeColor = Module["_FPDFPageObj_SetStrokeColor"] = Module["asm"]["FPDFPageObj_SetStrokeColor"]).apply(null, arguments) + }; + var _FPDFPageObj_GetStrokeColor = Module["_FPDFPageObj_GetStrokeColor"] = function () { + return (_FPDFPageObj_GetStrokeColor = Module["_FPDFPageObj_GetStrokeColor"] = Module["asm"]["FPDFPageObj_GetStrokeColor"]).apply(null, arguments) + }; + var _FPDFPageObj_SetStrokeWidth = Module["_FPDFPageObj_SetStrokeWidth"] = function () { + return (_FPDFPageObj_SetStrokeWidth = Module["_FPDFPageObj_SetStrokeWidth"] = Module["asm"]["FPDFPageObj_SetStrokeWidth"]).apply(null, arguments) + }; + var _FPDFPageObj_GetStrokeWidth = Module["_FPDFPageObj_GetStrokeWidth"] = function () { + return (_FPDFPageObj_GetStrokeWidth = Module["_FPDFPageObj_GetStrokeWidth"] = Module["asm"]["FPDFPageObj_GetStrokeWidth"]).apply(null, arguments) + }; + var _FPDFPageObj_GetLineJoin = Module["_FPDFPageObj_GetLineJoin"] = function () { + return (_FPDFPageObj_GetLineJoin = Module["_FPDFPageObj_GetLineJoin"] = Module["asm"]["FPDFPageObj_GetLineJoin"]).apply(null, arguments) + }; + var _FPDFPageObj_SetLineJoin = Module["_FPDFPageObj_SetLineJoin"] = function () { + return (_FPDFPageObj_SetLineJoin = Module["_FPDFPageObj_SetLineJoin"] = Module["asm"]["FPDFPageObj_SetLineJoin"]).apply(null, arguments) + }; + var _FPDFPageObj_GetLineCap = Module["_FPDFPageObj_GetLineCap"] = function () { + return (_FPDFPageObj_GetLineCap = Module["_FPDFPageObj_GetLineCap"] = Module["asm"]["FPDFPageObj_GetLineCap"]).apply(null, arguments) + }; + var _FPDFPageObj_SetLineCap = Module["_FPDFPageObj_SetLineCap"] = function () { + return (_FPDFPageObj_SetLineCap = Module["_FPDFPageObj_SetLineCap"] = Module["asm"]["FPDFPageObj_SetLineCap"]).apply(null, arguments) + }; + var _FPDFPageObj_GetDashPhase = Module["_FPDFPageObj_GetDashPhase"] = function () { + return (_FPDFPageObj_GetDashPhase = Module["_FPDFPageObj_GetDashPhase"] = Module["asm"]["FPDFPageObj_GetDashPhase"]).apply(null, arguments) + }; + var _FPDFPageObj_SetDashPhase = Module["_FPDFPageObj_SetDashPhase"] = function () { + return (_FPDFPageObj_SetDashPhase = Module["_FPDFPageObj_SetDashPhase"] = Module["asm"]["FPDFPageObj_SetDashPhase"]).apply(null, arguments) + }; + var _FPDFPageObj_GetDashCount = Module["_FPDFPageObj_GetDashCount"] = function () { + return (_FPDFPageObj_GetDashCount = Module["_FPDFPageObj_GetDashCount"] = Module["asm"]["FPDFPageObj_GetDashCount"]).apply(null, arguments) + }; + var _FPDFPageObj_GetDashArray = Module["_FPDFPageObj_GetDashArray"] = function () { + return (_FPDFPageObj_GetDashArray = Module["_FPDFPageObj_GetDashArray"] = Module["asm"]["FPDFPageObj_GetDashArray"]).apply(null, arguments) + }; + var _FPDFPageObj_SetDashArray = Module["_FPDFPageObj_SetDashArray"] = function () { + return (_FPDFPageObj_SetDashArray = Module["_FPDFPageObj_SetDashArray"] = Module["asm"]["FPDFPageObj_SetDashArray"]).apply(null, arguments) + }; + var _FPDFFormObj_CountObjects = Module["_FPDFFormObj_CountObjects"] = function () { + return (_FPDFFormObj_CountObjects = Module["_FPDFFormObj_CountObjects"] = Module["asm"]["FPDFFormObj_CountObjects"]).apply(null, arguments) + }; + var _FPDFFormObj_GetObject = Module["_FPDFFormObj_GetObject"] = function () { + return (_FPDFFormObj_GetObject = Module["_FPDFFormObj_GetObject"] = Module["asm"]["FPDFFormObj_GetObject"]).apply(null, arguments) + }; + var _FPDFPageObj_CreateNewPath = Module["_FPDFPageObj_CreateNewPath"] = function () { + return (_FPDFPageObj_CreateNewPath = Module["_FPDFPageObj_CreateNewPath"] = Module["asm"]["FPDFPageObj_CreateNewPath"]).apply(null, arguments) + }; + var _FPDFPageObj_CreateNewRect = Module["_FPDFPageObj_CreateNewRect"] = function () { + return (_FPDFPageObj_CreateNewRect = Module["_FPDFPageObj_CreateNewRect"] = Module["asm"]["FPDFPageObj_CreateNewRect"]).apply(null, arguments) + }; + var _FPDFPath_CountSegments = Module["_FPDFPath_CountSegments"] = function () { + return (_FPDFPath_CountSegments = Module["_FPDFPath_CountSegments"] = Module["asm"]["FPDFPath_CountSegments"]).apply(null, arguments) + }; + var _FPDFPath_GetPathSegment = Module["_FPDFPath_GetPathSegment"] = function () { + return (_FPDFPath_GetPathSegment = Module["_FPDFPath_GetPathSegment"] = Module["asm"]["FPDFPath_GetPathSegment"]).apply(null, arguments) + }; + var _FPDFPath_MoveTo = Module["_FPDFPath_MoveTo"] = function () { + return (_FPDFPath_MoveTo = Module["_FPDFPath_MoveTo"] = Module["asm"]["FPDFPath_MoveTo"]).apply(null, arguments) + }; + var _FPDFPath_LineTo = Module["_FPDFPath_LineTo"] = function () { + return (_FPDFPath_LineTo = Module["_FPDFPath_LineTo"] = Module["asm"]["FPDFPath_LineTo"]).apply(null, arguments) + }; + var _FPDFPath_BezierTo = Module["_FPDFPath_BezierTo"] = function () { + return (_FPDFPath_BezierTo = Module["_FPDFPath_BezierTo"] = Module["asm"]["FPDFPath_BezierTo"]).apply(null, arguments) + }; + var _FPDFPath_Close = Module["_FPDFPath_Close"] = function () { + return (_FPDFPath_Close = Module["_FPDFPath_Close"] = Module["asm"]["FPDFPath_Close"]).apply(null, arguments) + }; + var _FPDFPath_SetDrawMode = Module["_FPDFPath_SetDrawMode"] = function () { + return (_FPDFPath_SetDrawMode = Module["_FPDFPath_SetDrawMode"] = Module["asm"]["FPDFPath_SetDrawMode"]).apply(null, arguments) + }; + var _FPDFPath_GetDrawMode = Module["_FPDFPath_GetDrawMode"] = function () { + return (_FPDFPath_GetDrawMode = Module["_FPDFPath_GetDrawMode"] = Module["asm"]["FPDFPath_GetDrawMode"]).apply(null, arguments) + }; + var _FPDFPathSegment_GetPoint = Module["_FPDFPathSegment_GetPoint"] = function () { + return (_FPDFPathSegment_GetPoint = Module["_FPDFPathSegment_GetPoint"] = Module["asm"]["FPDFPathSegment_GetPoint"]).apply(null, arguments) + }; + var _FPDFPathSegment_GetType = Module["_FPDFPathSegment_GetType"] = function () { + return (_FPDFPathSegment_GetType = Module["_FPDFPathSegment_GetType"] = Module["asm"]["FPDFPathSegment_GetType"]).apply(null, arguments) + }; + var _FPDFPathSegment_GetClose = Module["_FPDFPathSegment_GetClose"] = function () { + return (_FPDFPathSegment_GetClose = Module["_FPDFPathSegment_GetClose"] = Module["asm"]["FPDFPathSegment_GetClose"]).apply(null, arguments) + }; + var _FPDFPageObj_NewTextObj = Module["_FPDFPageObj_NewTextObj"] = function () { + return (_FPDFPageObj_NewTextObj = Module["_FPDFPageObj_NewTextObj"] = Module["asm"]["FPDFPageObj_NewTextObj"]).apply(null, arguments) + }; + var _FPDFText_SetText = Module["_FPDFText_SetText"] = function () { + return (_FPDFText_SetText = Module["_FPDFText_SetText"] = Module["asm"]["FPDFText_SetText"]).apply(null, arguments) + }; + var _FPDFText_SetCharcodes = Module["_FPDFText_SetCharcodes"] = function () { + return (_FPDFText_SetCharcodes = Module["_FPDFText_SetCharcodes"] = Module["asm"]["FPDFText_SetCharcodes"]).apply(null, arguments) + }; + var _FPDFText_LoadFont = Module["_FPDFText_LoadFont"] = function () { + return (_FPDFText_LoadFont = Module["_FPDFText_LoadFont"] = Module["asm"]["FPDFText_LoadFont"]).apply(null, arguments) + }; + var _FPDFText_LoadStandardFont = Module["_FPDFText_LoadStandardFont"] = function () { + return (_FPDFText_LoadStandardFont = Module["_FPDFText_LoadStandardFont"] = Module["asm"]["FPDFText_LoadStandardFont"]).apply(null, arguments) + }; + var _FPDFTextObj_GetFontSize = Module["_FPDFTextObj_GetFontSize"] = function () { + return (_FPDFTextObj_GetFontSize = Module["_FPDFTextObj_GetFontSize"] = Module["asm"]["FPDFTextObj_GetFontSize"]).apply(null, arguments) + }; + var _FPDFTextObj_GetText = Module["_FPDFTextObj_GetText"] = function () { + return (_FPDFTextObj_GetText = Module["_FPDFTextObj_GetText"] = Module["asm"]["FPDFTextObj_GetText"]).apply(null, arguments) + }; + var _FPDFTextObj_GetRenderedBitmap = Module["_FPDFTextObj_GetRenderedBitmap"] = function () { + return (_FPDFTextObj_GetRenderedBitmap = Module["_FPDFTextObj_GetRenderedBitmap"] = Module["asm"]["FPDFTextObj_GetRenderedBitmap"]).apply(null, arguments) + }; + var _FPDFFont_Close = Module["_FPDFFont_Close"] = function () { + return (_FPDFFont_Close = Module["_FPDFFont_Close"] = Module["asm"]["FPDFFont_Close"]).apply(null, arguments) + }; + var _FPDFPageObj_CreateTextObj = Module["_FPDFPageObj_CreateTextObj"] = function () { + return (_FPDFPageObj_CreateTextObj = Module["_FPDFPageObj_CreateTextObj"] = Module["asm"]["FPDFPageObj_CreateTextObj"]).apply(null, arguments) + }; + var _FPDFTextObj_GetTextRenderMode = Module["_FPDFTextObj_GetTextRenderMode"] = function () { + return (_FPDFTextObj_GetTextRenderMode = Module["_FPDFTextObj_GetTextRenderMode"] = Module["asm"]["FPDFTextObj_GetTextRenderMode"]).apply(null, arguments) + }; + var _FPDFTextObj_SetTextRenderMode = Module["_FPDFTextObj_SetTextRenderMode"] = function () { + return (_FPDFTextObj_SetTextRenderMode = Module["_FPDFTextObj_SetTextRenderMode"] = Module["asm"]["FPDFTextObj_SetTextRenderMode"]).apply(null, arguments) + }; + var _FPDFTextObj_GetFont = Module["_FPDFTextObj_GetFont"] = function () { + return (_FPDFTextObj_GetFont = Module["_FPDFTextObj_GetFont"] = Module["asm"]["FPDFTextObj_GetFont"]).apply(null, arguments) + }; + var _FPDFFont_GetFontName = Module["_FPDFFont_GetFontName"] = function () { + return (_FPDFFont_GetFontName = Module["_FPDFFont_GetFontName"] = Module["asm"]["FPDFFont_GetFontName"]).apply(null, arguments) + }; + var _FPDFFont_GetFontData = Module["_FPDFFont_GetFontData"] = function () { + return (_FPDFFont_GetFontData = Module["_FPDFFont_GetFontData"] = Module["asm"]["FPDFFont_GetFontData"]).apply(null, arguments) + }; + var _FPDFFont_GetIsEmbedded = Module["_FPDFFont_GetIsEmbedded"] = function () { + return (_FPDFFont_GetIsEmbedded = Module["_FPDFFont_GetIsEmbedded"] = Module["asm"]["FPDFFont_GetIsEmbedded"]).apply(null, arguments) + }; + var _FPDFFont_GetFlags = Module["_FPDFFont_GetFlags"] = function () { + return (_FPDFFont_GetFlags = Module["_FPDFFont_GetFlags"] = Module["asm"]["FPDFFont_GetFlags"]).apply(null, arguments) + }; + var _FPDFFont_GetWeight = Module["_FPDFFont_GetWeight"] = function () { + return (_FPDFFont_GetWeight = Module["_FPDFFont_GetWeight"] = Module["asm"]["FPDFFont_GetWeight"]).apply(null, arguments) + }; + var _FPDFFont_GetItalicAngle = Module["_FPDFFont_GetItalicAngle"] = function () { + return (_FPDFFont_GetItalicAngle = Module["_FPDFFont_GetItalicAngle"] = Module["asm"]["FPDFFont_GetItalicAngle"]).apply(null, arguments) + }; + var _FPDFFont_GetAscent = Module["_FPDFFont_GetAscent"] = function () { + return (_FPDFFont_GetAscent = Module["_FPDFFont_GetAscent"] = Module["asm"]["FPDFFont_GetAscent"]).apply(null, arguments) + }; + var _FPDFFont_GetDescent = Module["_FPDFFont_GetDescent"] = function () { + return (_FPDFFont_GetDescent = Module["_FPDFFont_GetDescent"] = Module["asm"]["FPDFFont_GetDescent"]).apply(null, arguments) + }; + var _FPDFFont_GetGlyphWidth = Module["_FPDFFont_GetGlyphWidth"] = function () { + return (_FPDFFont_GetGlyphWidth = Module["_FPDFFont_GetGlyphWidth"] = Module["asm"]["FPDFFont_GetGlyphWidth"]).apply(null, arguments) + }; + var _FPDFFont_GetGlyphPath = Module["_FPDFFont_GetGlyphPath"] = function () { + return (_FPDFFont_GetGlyphPath = Module["_FPDFFont_GetGlyphPath"] = Module["asm"]["FPDFFont_GetGlyphPath"]).apply(null, arguments) + }; + var _FPDFGlyphPath_CountGlyphSegments = Module["_FPDFGlyphPath_CountGlyphSegments"] = function () { + return (_FPDFGlyphPath_CountGlyphSegments = Module["_FPDFGlyphPath_CountGlyphSegments"] = Module["asm"]["FPDFGlyphPath_CountGlyphSegments"]).apply(null, arguments) + }; + var _FPDFGlyphPath_GetGlyphPathSegment = Module["_FPDFGlyphPath_GetGlyphPathSegment"] = function () { + return (_FPDFGlyphPath_GetGlyphPathSegment = Module["_FPDFGlyphPath_GetGlyphPathSegment"] = Module["asm"]["FPDFGlyphPath_GetGlyphPathSegment"]).apply(null, arguments) + }; + var _FSDK_SetUnSpObjProcessHandler = Module["_FSDK_SetUnSpObjProcessHandler"] = function () { + return (_FSDK_SetUnSpObjProcessHandler = Module["_FSDK_SetUnSpObjProcessHandler"] = Module["asm"]["FSDK_SetUnSpObjProcessHandler"]).apply(null, arguments) + }; + var _FSDK_SetTimeFunction = Module["_FSDK_SetTimeFunction"] = function () { + return (_FSDK_SetTimeFunction = Module["_FSDK_SetTimeFunction"] = Module["asm"]["FSDK_SetTimeFunction"]).apply(null, arguments) + }; + var _FSDK_SetLocaltimeFunction = Module["_FSDK_SetLocaltimeFunction"] = function () { + return (_FSDK_SetLocaltimeFunction = Module["_FSDK_SetLocaltimeFunction"] = Module["asm"]["FSDK_SetLocaltimeFunction"]).apply(null, arguments) + }; + var _FPDFDoc_GetPageMode = Module["_FPDFDoc_GetPageMode"] = function () { + return (_FPDFDoc_GetPageMode = Module["_FPDFDoc_GetPageMode"] = Module["asm"]["FPDFDoc_GetPageMode"]).apply(null, arguments) + }; + var _FPDFPage_Flatten = Module["_FPDFPage_Flatten"] = function () { + return (_FPDFPage_Flatten = Module["_FPDFPage_Flatten"] = Module["asm"]["FPDFPage_Flatten"]).apply(null, arguments) + }; + var _FPDFPage_HasFormFieldAtPoint = Module["_FPDFPage_HasFormFieldAtPoint"] = function () { + return (_FPDFPage_HasFormFieldAtPoint = Module["_FPDFPage_HasFormFieldAtPoint"] = Module["asm"]["FPDFPage_HasFormFieldAtPoint"]).apply(null, arguments) + }; + var _FPDFPage_FormFieldZOrderAtPoint = Module["_FPDFPage_FormFieldZOrderAtPoint"] = function () { + return (_FPDFPage_FormFieldZOrderAtPoint = Module["_FPDFPage_FormFieldZOrderAtPoint"] = Module["asm"]["FPDFPage_FormFieldZOrderAtPoint"]).apply(null, arguments) + }; + var _FPDFDOC_InitFormFillEnvironment = Module["_FPDFDOC_InitFormFillEnvironment"] = function () { + return (_FPDFDOC_InitFormFillEnvironment = Module["_FPDFDOC_InitFormFillEnvironment"] = Module["asm"]["FPDFDOC_InitFormFillEnvironment"]).apply(null, arguments) + }; + var _FPDFDOC_ExitFormFillEnvironment = Module["_FPDFDOC_ExitFormFillEnvironment"] = function () { + return (_FPDFDOC_ExitFormFillEnvironment = Module["_FPDFDOC_ExitFormFillEnvironment"] = Module["asm"]["FPDFDOC_ExitFormFillEnvironment"]).apply(null, arguments) + }; + var _FORM_OnMouseMove = Module["_FORM_OnMouseMove"] = function () { + return (_FORM_OnMouseMove = Module["_FORM_OnMouseMove"] = Module["asm"]["FORM_OnMouseMove"]).apply(null, arguments) + }; + var _FORM_OnMouseWheel = Module["_FORM_OnMouseWheel"] = function () { + return (_FORM_OnMouseWheel = Module["_FORM_OnMouseWheel"] = Module["asm"]["FORM_OnMouseWheel"]).apply(null, arguments) + }; + var _FORM_OnFocus = Module["_FORM_OnFocus"] = function () { + return (_FORM_OnFocus = Module["_FORM_OnFocus"] = Module["asm"]["FORM_OnFocus"]).apply(null, arguments) + }; + var _FORM_OnLButtonDown = Module["_FORM_OnLButtonDown"] = function () { + return (_FORM_OnLButtonDown = Module["_FORM_OnLButtonDown"] = Module["asm"]["FORM_OnLButtonDown"]).apply(null, arguments) + }; + var _FORM_OnLButtonUp = Module["_FORM_OnLButtonUp"] = function () { + return (_FORM_OnLButtonUp = Module["_FORM_OnLButtonUp"] = Module["asm"]["FORM_OnLButtonUp"]).apply(null, arguments) + }; + var _FORM_OnLButtonDoubleClick = Module["_FORM_OnLButtonDoubleClick"] = function () { + return (_FORM_OnLButtonDoubleClick = Module["_FORM_OnLButtonDoubleClick"] = Module["asm"]["FORM_OnLButtonDoubleClick"]).apply(null, arguments) + }; + var _FORM_OnRButtonDown = Module["_FORM_OnRButtonDown"] = function () { + return (_FORM_OnRButtonDown = Module["_FORM_OnRButtonDown"] = Module["asm"]["FORM_OnRButtonDown"]).apply(null, arguments) + }; + var _FORM_OnRButtonUp = Module["_FORM_OnRButtonUp"] = function () { + return (_FORM_OnRButtonUp = Module["_FORM_OnRButtonUp"] = Module["asm"]["FORM_OnRButtonUp"]).apply(null, arguments) + }; + var _FORM_OnKeyDown = Module["_FORM_OnKeyDown"] = function () { + return (_FORM_OnKeyDown = Module["_FORM_OnKeyDown"] = Module["asm"]["FORM_OnKeyDown"]).apply(null, arguments) + }; + var _FORM_OnKeyUp = Module["_FORM_OnKeyUp"] = function () { + return (_FORM_OnKeyUp = Module["_FORM_OnKeyUp"] = Module["asm"]["FORM_OnKeyUp"]).apply(null, arguments) + }; + var _FORM_OnChar = Module["_FORM_OnChar"] = function () { + return (_FORM_OnChar = Module["_FORM_OnChar"] = Module["asm"]["FORM_OnChar"]).apply(null, arguments) + }; + var _FORM_GetFocusedText = Module["_FORM_GetFocusedText"] = function () { + return (_FORM_GetFocusedText = Module["_FORM_GetFocusedText"] = Module["asm"]["FORM_GetFocusedText"]).apply(null, arguments) + }; + var _FORM_GetSelectedText = Module["_FORM_GetSelectedText"] = function () { + return (_FORM_GetSelectedText = Module["_FORM_GetSelectedText"] = Module["asm"]["FORM_GetSelectedText"]).apply(null, arguments) + }; + var _FORM_ReplaceAndKeepSelection = Module["_FORM_ReplaceAndKeepSelection"] = function () { + return (_FORM_ReplaceAndKeepSelection = Module["_FORM_ReplaceAndKeepSelection"] = Module["asm"]["FORM_ReplaceAndKeepSelection"]).apply(null, arguments) + }; + var _FORM_ReplaceSelection = Module["_FORM_ReplaceSelection"] = function () { + return (_FORM_ReplaceSelection = Module["_FORM_ReplaceSelection"] = Module["asm"]["FORM_ReplaceSelection"]).apply(null, arguments) + }; + var _FORM_SelectAllText = Module["_FORM_SelectAllText"] = function () { + return (_FORM_SelectAllText = Module["_FORM_SelectAllText"] = Module["asm"]["FORM_SelectAllText"]).apply(null, arguments) + }; + var _FORM_CanUndo = Module["_FORM_CanUndo"] = function () { + return (_FORM_CanUndo = Module["_FORM_CanUndo"] = Module["asm"]["FORM_CanUndo"]).apply(null, arguments) + }; + var _FORM_CanRedo = Module["_FORM_CanRedo"] = function () { + return (_FORM_CanRedo = Module["_FORM_CanRedo"] = Module["asm"]["FORM_CanRedo"]).apply(null, arguments) + }; + var _FORM_Undo = Module["_FORM_Undo"] = function () { + return (_FORM_Undo = Module["_FORM_Undo"] = Module["asm"]["FORM_Undo"]).apply(null, arguments) + }; + var _FORM_Redo = Module["_FORM_Redo"] = function () { + return (_FORM_Redo = Module["_FORM_Redo"] = Module["asm"]["FORM_Redo"]).apply(null, arguments) + }; + var _FORM_ForceToKillFocus = Module["_FORM_ForceToKillFocus"] = function () { + return (_FORM_ForceToKillFocus = Module["_FORM_ForceToKillFocus"] = Module["asm"]["FORM_ForceToKillFocus"]).apply(null, arguments) + }; + var _FORM_GetFocusedAnnot = Module["_FORM_GetFocusedAnnot"] = function () { + return (_FORM_GetFocusedAnnot = Module["_FORM_GetFocusedAnnot"] = Module["asm"]["FORM_GetFocusedAnnot"]).apply(null, arguments) + }; + var _FORM_SetFocusedAnnot = Module["_FORM_SetFocusedAnnot"] = function () { + return (_FORM_SetFocusedAnnot = Module["_FORM_SetFocusedAnnot"] = Module["asm"]["FORM_SetFocusedAnnot"]).apply(null, arguments) + }; + var _FPDF_FFLDraw = Module["_FPDF_FFLDraw"] = function () { + return (_FPDF_FFLDraw = Module["_FPDF_FFLDraw"] = Module["asm"]["FPDF_FFLDraw"]).apply(null, arguments) + }; + var _FPDF_SetFormFieldHighlightColor = Module["_FPDF_SetFormFieldHighlightColor"] = function () { + return (_FPDF_SetFormFieldHighlightColor = Module["_FPDF_SetFormFieldHighlightColor"] = Module["asm"]["FPDF_SetFormFieldHighlightColor"]).apply(null, arguments) + }; + var _FPDF_SetFormFieldHighlightAlpha = Module["_FPDF_SetFormFieldHighlightAlpha"] = function () { + return (_FPDF_SetFormFieldHighlightAlpha = Module["_FPDF_SetFormFieldHighlightAlpha"] = Module["asm"]["FPDF_SetFormFieldHighlightAlpha"]).apply(null, arguments) + }; + var _FPDF_RemoveFormFieldHighlight = Module["_FPDF_RemoveFormFieldHighlight"] = function () { + return (_FPDF_RemoveFormFieldHighlight = Module["_FPDF_RemoveFormFieldHighlight"] = Module["asm"]["FPDF_RemoveFormFieldHighlight"]).apply(null, arguments) + }; + var _FORM_OnAfterLoadPage = Module["_FORM_OnAfterLoadPage"] = function () { + return (_FORM_OnAfterLoadPage = Module["_FORM_OnAfterLoadPage"] = Module["asm"]["FORM_OnAfterLoadPage"]).apply(null, arguments) + }; + var _FORM_OnBeforeClosePage = Module["_FORM_OnBeforeClosePage"] = function () { + return (_FORM_OnBeforeClosePage = Module["_FORM_OnBeforeClosePage"] = Module["asm"]["FORM_OnBeforeClosePage"]).apply(null, arguments) + }; + var _FORM_DoDocumentJSAction = Module["_FORM_DoDocumentJSAction"] = function () { + return (_FORM_DoDocumentJSAction = Module["_FORM_DoDocumentJSAction"] = Module["asm"]["FORM_DoDocumentJSAction"]).apply(null, arguments) + }; + var _FORM_DoDocumentOpenAction = Module["_FORM_DoDocumentOpenAction"] = function () { + return (_FORM_DoDocumentOpenAction = Module["_FORM_DoDocumentOpenAction"] = Module["asm"]["FORM_DoDocumentOpenAction"]).apply(null, arguments) + }; + var _FORM_DoDocumentAAction = Module["_FORM_DoDocumentAAction"] = function () { + return (_FORM_DoDocumentAAction = Module["_FORM_DoDocumentAAction"] = Module["asm"]["FORM_DoDocumentAAction"]).apply(null, arguments) + }; + var _FORM_DoPageAAction = Module["_FORM_DoPageAAction"] = function () { + return (_FORM_DoPageAAction = Module["_FORM_DoPageAAction"] = Module["asm"]["FORM_DoPageAAction"]).apply(null, arguments) + }; + var _FORM_SetIndexSelected = Module["_FORM_SetIndexSelected"] = function () { + return (_FORM_SetIndexSelected = Module["_FORM_SetIndexSelected"] = Module["asm"]["FORM_SetIndexSelected"]).apply(null, arguments) + }; + var _FORM_IsIndexSelected = Module["_FORM_IsIndexSelected"] = function () { + return (_FORM_IsIndexSelected = Module["_FORM_IsIndexSelected"] = Module["asm"]["FORM_IsIndexSelected"]).apply(null, arguments) + }; + var _FPDFDoc_GetJavaScriptActionCount = Module["_FPDFDoc_GetJavaScriptActionCount"] = function () { + return (_FPDFDoc_GetJavaScriptActionCount = Module["_FPDFDoc_GetJavaScriptActionCount"] = Module["asm"]["FPDFDoc_GetJavaScriptActionCount"]).apply(null, arguments) + }; + var _FPDFDoc_GetJavaScriptAction = Module["_FPDFDoc_GetJavaScriptAction"] = function () { + return (_FPDFDoc_GetJavaScriptAction = Module["_FPDFDoc_GetJavaScriptAction"] = Module["asm"]["FPDFDoc_GetJavaScriptAction"]).apply(null, arguments) + }; + var _FPDFDoc_CloseJavaScriptAction = Module["_FPDFDoc_CloseJavaScriptAction"] = function () { + return (_FPDFDoc_CloseJavaScriptAction = Module["_FPDFDoc_CloseJavaScriptAction"] = Module["asm"]["FPDFDoc_CloseJavaScriptAction"]).apply(null, arguments) + }; + var _FPDFJavaScriptAction_GetName = Module["_FPDFJavaScriptAction_GetName"] = function () { + return (_FPDFJavaScriptAction_GetName = Module["_FPDFJavaScriptAction_GetName"] = Module["asm"]["FPDFJavaScriptAction_GetName"]).apply(null, arguments) + }; + var _FPDFJavaScriptAction_GetScript = Module["_FPDFJavaScriptAction_GetScript"] = function () { + return (_FPDFJavaScriptAction_GetScript = Module["_FPDFJavaScriptAction_GetScript"] = Module["asm"]["FPDFJavaScriptAction_GetScript"]).apply(null, arguments) + }; + var _FPDF_ImportPagesByIndex = Module["_FPDF_ImportPagesByIndex"] = function () { + return (_FPDF_ImportPagesByIndex = Module["_FPDF_ImportPagesByIndex"] = Module["asm"]["FPDF_ImportPagesByIndex"]).apply(null, arguments) + }; + var _FPDF_ImportPages = Module["_FPDF_ImportPages"] = function () { + return (_FPDF_ImportPages = Module["_FPDF_ImportPages"] = Module["asm"]["FPDF_ImportPages"]).apply(null, arguments) + }; + var _FPDF_ImportNPagesToOne = Module["_FPDF_ImportNPagesToOne"] = function () { + return (_FPDF_ImportNPagesToOne = Module["_FPDF_ImportNPagesToOne"] = Module["asm"]["FPDF_ImportNPagesToOne"]).apply(null, arguments) + }; + var _FPDF_NewXObjectFromPage = Module["_FPDF_NewXObjectFromPage"] = function () { + return (_FPDF_NewXObjectFromPage = Module["_FPDF_NewXObjectFromPage"] = Module["asm"]["FPDF_NewXObjectFromPage"]).apply(null, arguments) + }; + var _FPDF_CloseXObject = Module["_FPDF_CloseXObject"] = function () { + return (_FPDF_CloseXObject = Module["_FPDF_CloseXObject"] = Module["asm"]["FPDF_CloseXObject"]).apply(null, arguments) + }; + var _FPDF_NewFormObjectFromXObject = Module["_FPDF_NewFormObjectFromXObject"] = function () { + return (_FPDF_NewFormObjectFromXObject = Module["_FPDF_NewFormObjectFromXObject"] = Module["asm"]["FPDF_NewFormObjectFromXObject"]).apply(null, arguments) + }; + var _FPDF_CopyViewerPreferences = Module["_FPDF_CopyViewerPreferences"] = function () { + return (_FPDF_CopyViewerPreferences = Module["_FPDF_CopyViewerPreferences"] = Module["asm"]["FPDF_CopyViewerPreferences"]).apply(null, arguments) + }; + var _FPDF_RenderPageBitmapWithColorScheme_Start = Module["_FPDF_RenderPageBitmapWithColorScheme_Start"] = function () { + return (_FPDF_RenderPageBitmapWithColorScheme_Start = Module["_FPDF_RenderPageBitmapWithColorScheme_Start"] = Module["asm"]["FPDF_RenderPageBitmapWithColorScheme_Start"]).apply(null, arguments) + }; + var _FPDF_RenderPageBitmap_Start = Module["_FPDF_RenderPageBitmap_Start"] = function () { + return (_FPDF_RenderPageBitmap_Start = Module["_FPDF_RenderPageBitmap_Start"] = Module["asm"]["FPDF_RenderPageBitmap_Start"]).apply(null, arguments) + }; + var _FPDF_RenderPage_Continue = Module["_FPDF_RenderPage_Continue"] = function () { + return (_FPDF_RenderPage_Continue = Module["_FPDF_RenderPage_Continue"] = Module["asm"]["FPDF_RenderPage_Continue"]).apply(null, arguments) + }; + var _FPDF_RenderPage_Close = Module["_FPDF_RenderPage_Close"] = function () { + return (_FPDF_RenderPage_Close = Module["_FPDF_RenderPage_Close"] = Module["asm"]["FPDF_RenderPage_Close"]).apply(null, arguments) + }; + var _FPDF_SaveAsCopy = Module["_FPDF_SaveAsCopy"] = function () { + return (_FPDF_SaveAsCopy = Module["_FPDF_SaveAsCopy"] = Module["asm"]["FPDF_SaveAsCopy"]).apply(null, arguments) + }; + var _FPDF_SaveWithVersion = Module["_FPDF_SaveWithVersion"] = function () { + return (_FPDF_SaveWithVersion = Module["_FPDF_SaveWithVersion"] = Module["asm"]["FPDF_SaveWithVersion"]).apply(null, arguments) + }; + var _FPDFText_GetCharIndexFromTextIndex = Module["_FPDFText_GetCharIndexFromTextIndex"] = function () { + return (_FPDFText_GetCharIndexFromTextIndex = Module["_FPDFText_GetCharIndexFromTextIndex"] = Module["asm"]["FPDFText_GetCharIndexFromTextIndex"]).apply(null, arguments) + }; + var _FPDFText_GetTextIndexFromCharIndex = Module["_FPDFText_GetTextIndexFromCharIndex"] = function () { + return (_FPDFText_GetTextIndexFromCharIndex = Module["_FPDFText_GetTextIndexFromCharIndex"] = Module["asm"]["FPDFText_GetTextIndexFromCharIndex"]).apply(null, arguments) + }; + var _FPDF_GetSignatureCount = Module["_FPDF_GetSignatureCount"] = function () { + return (_FPDF_GetSignatureCount = Module["_FPDF_GetSignatureCount"] = Module["asm"]["FPDF_GetSignatureCount"]).apply(null, arguments) + }; + var _FPDF_GetSignatureObject = Module["_FPDF_GetSignatureObject"] = function () { + return (_FPDF_GetSignatureObject = Module["_FPDF_GetSignatureObject"] = Module["asm"]["FPDF_GetSignatureObject"]).apply(null, arguments) + }; + var _FPDFSignatureObj_GetContents = Module["_FPDFSignatureObj_GetContents"] = function () { + return (_FPDFSignatureObj_GetContents = Module["_FPDFSignatureObj_GetContents"] = Module["asm"]["FPDFSignatureObj_GetContents"]).apply(null, arguments) + }; + var _FPDFSignatureObj_GetByteRange = Module["_FPDFSignatureObj_GetByteRange"] = function () { + return (_FPDFSignatureObj_GetByteRange = Module["_FPDFSignatureObj_GetByteRange"] = Module["asm"]["FPDFSignatureObj_GetByteRange"]).apply(null, arguments) + }; + var _FPDFSignatureObj_GetSubFilter = Module["_FPDFSignatureObj_GetSubFilter"] = function () { + return (_FPDFSignatureObj_GetSubFilter = Module["_FPDFSignatureObj_GetSubFilter"] = Module["asm"]["FPDFSignatureObj_GetSubFilter"]).apply(null, arguments) + }; + var _FPDFSignatureObj_GetReason = Module["_FPDFSignatureObj_GetReason"] = function () { + return (_FPDFSignatureObj_GetReason = Module["_FPDFSignatureObj_GetReason"] = Module["asm"]["FPDFSignatureObj_GetReason"]).apply(null, arguments) + }; + var _FPDFSignatureObj_GetTime = Module["_FPDFSignatureObj_GetTime"] = function () { + return (_FPDFSignatureObj_GetTime = Module["_FPDFSignatureObj_GetTime"] = Module["asm"]["FPDFSignatureObj_GetTime"]).apply(null, arguments) + }; + var _FPDFSignatureObj_GetDocMDPPermission = Module["_FPDFSignatureObj_GetDocMDPPermission"] = function () { + return (_FPDFSignatureObj_GetDocMDPPermission = Module["_FPDFSignatureObj_GetDocMDPPermission"] = Module["asm"]["FPDFSignatureObj_GetDocMDPPermission"]).apply(null, arguments) + }; + var _FPDF_StructTree_GetForPage = Module["_FPDF_StructTree_GetForPage"] = function () { + return (_FPDF_StructTree_GetForPage = Module["_FPDF_StructTree_GetForPage"] = Module["asm"]["FPDF_StructTree_GetForPage"]).apply(null, arguments) + }; + var _FPDF_StructTree_Close = Module["_FPDF_StructTree_Close"] = function () { + return (_FPDF_StructTree_Close = Module["_FPDF_StructTree_Close"] = Module["asm"]["FPDF_StructTree_Close"]).apply(null, arguments) + }; + var _FPDF_StructTree_CountChildren = Module["_FPDF_StructTree_CountChildren"] = function () { + return (_FPDF_StructTree_CountChildren = Module["_FPDF_StructTree_CountChildren"] = Module["asm"]["FPDF_StructTree_CountChildren"]).apply(null, arguments) + }; + var _FPDF_StructTree_GetChildAtIndex = Module["_FPDF_StructTree_GetChildAtIndex"] = function () { + return (_FPDF_StructTree_GetChildAtIndex = Module["_FPDF_StructTree_GetChildAtIndex"] = Module["asm"]["FPDF_StructTree_GetChildAtIndex"]).apply(null, arguments) + }; + var _FPDF_StructElement_GetAltText = Module["_FPDF_StructElement_GetAltText"] = function () { + return (_FPDF_StructElement_GetAltText = Module["_FPDF_StructElement_GetAltText"] = Module["asm"]["FPDF_StructElement_GetAltText"]).apply(null, arguments) + }; + var _FPDF_StructElement_GetActualText = Module["_FPDF_StructElement_GetActualText"] = function () { + return (_FPDF_StructElement_GetActualText = Module["_FPDF_StructElement_GetActualText"] = Module["asm"]["FPDF_StructElement_GetActualText"]).apply(null, arguments) + }; + var _FPDF_StructElement_GetID = Module["_FPDF_StructElement_GetID"] = function () { + return (_FPDF_StructElement_GetID = Module["_FPDF_StructElement_GetID"] = Module["asm"]["FPDF_StructElement_GetID"]).apply(null, arguments) + }; + var _FPDF_StructElement_GetLang = Module["_FPDF_StructElement_GetLang"] = function () { + return (_FPDF_StructElement_GetLang = Module["_FPDF_StructElement_GetLang"] = Module["asm"]["FPDF_StructElement_GetLang"]).apply(null, arguments) + }; + var _FPDF_StructElement_GetAttributeCount = Module["_FPDF_StructElement_GetAttributeCount"] = function () { + return (_FPDF_StructElement_GetAttributeCount = Module["_FPDF_StructElement_GetAttributeCount"] = Module["asm"]["FPDF_StructElement_GetAttributeCount"]).apply(null, arguments) + }; + var _FPDF_StructElement_GetAttributeAtIndex = Module["_FPDF_StructElement_GetAttributeAtIndex"] = function () { + return (_FPDF_StructElement_GetAttributeAtIndex = Module["_FPDF_StructElement_GetAttributeAtIndex"] = Module["asm"]["FPDF_StructElement_GetAttributeAtIndex"]).apply(null, arguments) + }; + var _FPDF_StructElement_GetStringAttribute = Module["_FPDF_StructElement_GetStringAttribute"] = function () { + return (_FPDF_StructElement_GetStringAttribute = Module["_FPDF_StructElement_GetStringAttribute"] = Module["asm"]["FPDF_StructElement_GetStringAttribute"]).apply(null, arguments) + }; + var _FPDF_StructElement_GetMarkedContentID = Module["_FPDF_StructElement_GetMarkedContentID"] = function () { + return (_FPDF_StructElement_GetMarkedContentID = Module["_FPDF_StructElement_GetMarkedContentID"] = Module["asm"]["FPDF_StructElement_GetMarkedContentID"]).apply(null, arguments) + }; + var _FPDF_StructElement_GetType = Module["_FPDF_StructElement_GetType"] = function () { + return (_FPDF_StructElement_GetType = Module["_FPDF_StructElement_GetType"] = Module["asm"]["FPDF_StructElement_GetType"]).apply(null, arguments) + }; + var _FPDF_StructElement_GetObjType = Module["_FPDF_StructElement_GetObjType"] = function () { + return (_FPDF_StructElement_GetObjType = Module["_FPDF_StructElement_GetObjType"] = Module["asm"]["FPDF_StructElement_GetObjType"]).apply(null, arguments) + }; + var _FPDF_StructElement_GetTitle = Module["_FPDF_StructElement_GetTitle"] = function () { + return (_FPDF_StructElement_GetTitle = Module["_FPDF_StructElement_GetTitle"] = Module["asm"]["FPDF_StructElement_GetTitle"]).apply(null, arguments) + }; + var _FPDF_StructElement_CountChildren = Module["_FPDF_StructElement_CountChildren"] = function () { + return (_FPDF_StructElement_CountChildren = Module["_FPDF_StructElement_CountChildren"] = Module["asm"]["FPDF_StructElement_CountChildren"]).apply(null, arguments) + }; + var _FPDF_StructElement_GetChildAtIndex = Module["_FPDF_StructElement_GetChildAtIndex"] = function () { + return (_FPDF_StructElement_GetChildAtIndex = Module["_FPDF_StructElement_GetChildAtIndex"] = Module["asm"]["FPDF_StructElement_GetChildAtIndex"]).apply(null, arguments) + }; + var _FPDF_StructElement_GetParent = Module["_FPDF_StructElement_GetParent"] = function () { + return (_FPDF_StructElement_GetParent = Module["_FPDF_StructElement_GetParent"] = Module["asm"]["FPDF_StructElement_GetParent"]).apply(null, arguments) + }; + var _FPDF_StructElement_Attr_GetCount = Module["_FPDF_StructElement_Attr_GetCount"] = function () { + return (_FPDF_StructElement_Attr_GetCount = Module["_FPDF_StructElement_Attr_GetCount"] = Module["asm"]["FPDF_StructElement_Attr_GetCount"]).apply(null, arguments) + }; + var _FPDF_StructElement_Attr_GetName = Module["_FPDF_StructElement_Attr_GetName"] = function () { + return (_FPDF_StructElement_Attr_GetName = Module["_FPDF_StructElement_Attr_GetName"] = Module["asm"]["FPDF_StructElement_Attr_GetName"]).apply(null, arguments) + }; + var _FPDF_StructElement_Attr_GetType = Module["_FPDF_StructElement_Attr_GetType"] = function () { + return (_FPDF_StructElement_Attr_GetType = Module["_FPDF_StructElement_Attr_GetType"] = Module["asm"]["FPDF_StructElement_Attr_GetType"]).apply(null, arguments) + }; + var _FPDF_StructElement_Attr_GetBooleanValue = Module["_FPDF_StructElement_Attr_GetBooleanValue"] = function () { + return (_FPDF_StructElement_Attr_GetBooleanValue = Module["_FPDF_StructElement_Attr_GetBooleanValue"] = Module["asm"]["FPDF_StructElement_Attr_GetBooleanValue"]).apply(null, arguments) + }; + var _FPDF_StructElement_Attr_GetNumberValue = Module["_FPDF_StructElement_Attr_GetNumberValue"] = function () { + return (_FPDF_StructElement_Attr_GetNumberValue = Module["_FPDF_StructElement_Attr_GetNumberValue"] = Module["asm"]["FPDF_StructElement_Attr_GetNumberValue"]).apply(null, arguments) + }; + var _FPDF_StructElement_Attr_GetStringValue = Module["_FPDF_StructElement_Attr_GetStringValue"] = function () { + return (_FPDF_StructElement_Attr_GetStringValue = Module["_FPDF_StructElement_Attr_GetStringValue"] = Module["asm"]["FPDF_StructElement_Attr_GetStringValue"]).apply(null, arguments) + }; + var _FPDF_StructElement_Attr_GetBlobValue = Module["_FPDF_StructElement_Attr_GetBlobValue"] = function () { + return (_FPDF_StructElement_Attr_GetBlobValue = Module["_FPDF_StructElement_Attr_GetBlobValue"] = Module["asm"]["FPDF_StructElement_Attr_GetBlobValue"]).apply(null, arguments) + }; + var _FPDF_StructElement_GetMarkedContentIdCount = Module["_FPDF_StructElement_GetMarkedContentIdCount"] = function () { + return (_FPDF_StructElement_GetMarkedContentIdCount = Module["_FPDF_StructElement_GetMarkedContentIdCount"] = Module["asm"]["FPDF_StructElement_GetMarkedContentIdCount"]).apply(null, arguments) + }; + var _FPDF_StructElement_GetMarkedContentIdAtIndex = Module["_FPDF_StructElement_GetMarkedContentIdAtIndex"] = function () { + return (_FPDF_StructElement_GetMarkedContentIdAtIndex = Module["_FPDF_StructElement_GetMarkedContentIdAtIndex"] = Module["asm"]["FPDF_StructElement_GetMarkedContentIdAtIndex"]).apply(null, arguments) + }; + var _FPDF_AddInstalledFont = Module["_FPDF_AddInstalledFont"] = function () { + return (_FPDF_AddInstalledFont = Module["_FPDF_AddInstalledFont"] = Module["asm"]["FPDF_AddInstalledFont"]).apply(null, arguments) + }; + var _FPDF_SetSystemFontInfo = Module["_FPDF_SetSystemFontInfo"] = function () { + return (_FPDF_SetSystemFontInfo = Module["_FPDF_SetSystemFontInfo"] = Module["asm"]["FPDF_SetSystemFontInfo"]).apply(null, arguments) + }; + var _FPDF_GetDefaultTTFMap = Module["_FPDF_GetDefaultTTFMap"] = function () { + return (_FPDF_GetDefaultTTFMap = Module["_FPDF_GetDefaultTTFMap"] = Module["asm"]["FPDF_GetDefaultTTFMap"]).apply(null, arguments) + }; + var _FPDF_GetDefaultSystemFontInfo = Module["_FPDF_GetDefaultSystemFontInfo"] = function () { + return (_FPDF_GetDefaultSystemFontInfo = Module["_FPDF_GetDefaultSystemFontInfo"] = Module["asm"]["FPDF_GetDefaultSystemFontInfo"]).apply(null, arguments) + }; + var _FPDF_FreeDefaultSystemFontInfo = Module["_FPDF_FreeDefaultSystemFontInfo"] = function () { + return (_FPDF_FreeDefaultSystemFontInfo = Module["_FPDF_FreeDefaultSystemFontInfo"] = Module["asm"]["FPDF_FreeDefaultSystemFontInfo"]).apply(null, arguments) + }; + var _FPDFText_LoadPage = Module["_FPDFText_LoadPage"] = function () { + return (_FPDFText_LoadPage = Module["_FPDFText_LoadPage"] = Module["asm"]["FPDFText_LoadPage"]).apply(null, arguments) + }; + var _FPDFText_ClosePage = Module["_FPDFText_ClosePage"] = function () { + return (_FPDFText_ClosePage = Module["_FPDFText_ClosePage"] = Module["asm"]["FPDFText_ClosePage"]).apply(null, arguments) + }; + var _FPDFText_CountChars = Module["_FPDFText_CountChars"] = function () { + return (_FPDFText_CountChars = Module["_FPDFText_CountChars"] = Module["asm"]["FPDFText_CountChars"]).apply(null, arguments) + }; + var _FPDFText_GetUnicode = Module["_FPDFText_GetUnicode"] = function () { + return (_FPDFText_GetUnicode = Module["_FPDFText_GetUnicode"] = Module["asm"]["FPDFText_GetUnicode"]).apply(null, arguments) + }; + var _FPDFText_IsGenerated = Module["_FPDFText_IsGenerated"] = function () { + return (_FPDFText_IsGenerated = Module["_FPDFText_IsGenerated"] = Module["asm"]["FPDFText_IsGenerated"]).apply(null, arguments) + }; + var _FPDFText_HasUnicodeMapError = Module["_FPDFText_HasUnicodeMapError"] = function () { + return (_FPDFText_HasUnicodeMapError = Module["_FPDFText_HasUnicodeMapError"] = Module["asm"]["FPDFText_HasUnicodeMapError"]).apply(null, arguments) + }; + var _FPDFText_GetFontSize = Module["_FPDFText_GetFontSize"] = function () { + return (_FPDFText_GetFontSize = Module["_FPDFText_GetFontSize"] = Module["asm"]["FPDFText_GetFontSize"]).apply(null, arguments) + }; + var _FPDFText_GetFontInfo = Module["_FPDFText_GetFontInfo"] = function () { + return (_FPDFText_GetFontInfo = Module["_FPDFText_GetFontInfo"] = Module["asm"]["FPDFText_GetFontInfo"]).apply(null, arguments) + }; + var _FPDFText_GetFontWeight = Module["_FPDFText_GetFontWeight"] = function () { + return (_FPDFText_GetFontWeight = Module["_FPDFText_GetFontWeight"] = Module["asm"]["FPDFText_GetFontWeight"]).apply(null, arguments) + }; + var _FPDFText_GetTextRenderMode = Module["_FPDFText_GetTextRenderMode"] = function () { + return (_FPDFText_GetTextRenderMode = Module["_FPDFText_GetTextRenderMode"] = Module["asm"]["FPDFText_GetTextRenderMode"]).apply(null, arguments) + }; + var _FPDFText_GetFillColor = Module["_FPDFText_GetFillColor"] = function () { + return (_FPDFText_GetFillColor = Module["_FPDFText_GetFillColor"] = Module["asm"]["FPDFText_GetFillColor"]).apply(null, arguments) + }; + var _FPDFText_GetStrokeColor = Module["_FPDFText_GetStrokeColor"] = function () { + return (_FPDFText_GetStrokeColor = Module["_FPDFText_GetStrokeColor"] = Module["asm"]["FPDFText_GetStrokeColor"]).apply(null, arguments) + }; + var _FPDFText_GetCharAngle = Module["_FPDFText_GetCharAngle"] = function () { + return (_FPDFText_GetCharAngle = Module["_FPDFText_GetCharAngle"] = Module["asm"]["FPDFText_GetCharAngle"]).apply(null, arguments) + }; + var _FPDFText_GetCharBox = Module["_FPDFText_GetCharBox"] = function () { + return (_FPDFText_GetCharBox = Module["_FPDFText_GetCharBox"] = Module["asm"]["FPDFText_GetCharBox"]).apply(null, arguments) + }; + var _FPDFText_GetLooseCharBox = Module["_FPDFText_GetLooseCharBox"] = function () { + return (_FPDFText_GetLooseCharBox = Module["_FPDFText_GetLooseCharBox"] = Module["asm"]["FPDFText_GetLooseCharBox"]).apply(null, arguments) + }; + var _FPDFText_GetMatrix = Module["_FPDFText_GetMatrix"] = function () { + return (_FPDFText_GetMatrix = Module["_FPDFText_GetMatrix"] = Module["asm"]["FPDFText_GetMatrix"]).apply(null, arguments) + }; + var _FPDFText_GetCharOrigin = Module["_FPDFText_GetCharOrigin"] = function () { + return (_FPDFText_GetCharOrigin = Module["_FPDFText_GetCharOrigin"] = Module["asm"]["FPDFText_GetCharOrigin"]).apply(null, arguments) + }; + var _FPDFText_GetCharIndexAtPos = Module["_FPDFText_GetCharIndexAtPos"] = function () { + return (_FPDFText_GetCharIndexAtPos = Module["_FPDFText_GetCharIndexAtPos"] = Module["asm"]["FPDFText_GetCharIndexAtPos"]).apply(null, arguments) + }; + var _FPDFText_GetText = Module["_FPDFText_GetText"] = function () { + return (_FPDFText_GetText = Module["_FPDFText_GetText"] = Module["asm"]["FPDFText_GetText"]).apply(null, arguments) + }; + var _FPDFText_CountRects = Module["_FPDFText_CountRects"] = function () { + return (_FPDFText_CountRects = Module["_FPDFText_CountRects"] = Module["asm"]["FPDFText_CountRects"]).apply(null, arguments) + }; + var _FPDFText_GetRect = Module["_FPDFText_GetRect"] = function () { + return (_FPDFText_GetRect = Module["_FPDFText_GetRect"] = Module["asm"]["FPDFText_GetRect"]).apply(null, arguments) + }; + var _FPDFText_GetBoundedText = Module["_FPDFText_GetBoundedText"] = function () { + return (_FPDFText_GetBoundedText = Module["_FPDFText_GetBoundedText"] = Module["asm"]["FPDFText_GetBoundedText"]).apply(null, arguments) + }; + var _FPDFText_FindStart = Module["_FPDFText_FindStart"] = function () { + return (_FPDFText_FindStart = Module["_FPDFText_FindStart"] = Module["asm"]["FPDFText_FindStart"]).apply(null, arguments) + }; + var _FPDFText_FindNext = Module["_FPDFText_FindNext"] = function () { + return (_FPDFText_FindNext = Module["_FPDFText_FindNext"] = Module["asm"]["FPDFText_FindNext"]).apply(null, arguments) + }; + var _FPDFText_FindPrev = Module["_FPDFText_FindPrev"] = function () { + return (_FPDFText_FindPrev = Module["_FPDFText_FindPrev"] = Module["asm"]["FPDFText_FindPrev"]).apply(null, arguments) + }; + var _FPDFText_GetSchResultIndex = Module["_FPDFText_GetSchResultIndex"] = function () { + return (_FPDFText_GetSchResultIndex = Module["_FPDFText_GetSchResultIndex"] = Module["asm"]["FPDFText_GetSchResultIndex"]).apply(null, arguments) + }; + var _FPDFText_GetSchCount = Module["_FPDFText_GetSchCount"] = function () { + return (_FPDFText_GetSchCount = Module["_FPDFText_GetSchCount"] = Module["asm"]["FPDFText_GetSchCount"]).apply(null, arguments) + }; + var _FPDFText_FindClose = Module["_FPDFText_FindClose"] = function () { + return (_FPDFText_FindClose = Module["_FPDFText_FindClose"] = Module["asm"]["FPDFText_FindClose"]).apply(null, arguments) + }; + var _FPDFLink_LoadWebLinks = Module["_FPDFLink_LoadWebLinks"] = function () { + return (_FPDFLink_LoadWebLinks = Module["_FPDFLink_LoadWebLinks"] = Module["asm"]["FPDFLink_LoadWebLinks"]).apply(null, arguments) + }; + var _FPDFLink_CountWebLinks = Module["_FPDFLink_CountWebLinks"] = function () { + return (_FPDFLink_CountWebLinks = Module["_FPDFLink_CountWebLinks"] = Module["asm"]["FPDFLink_CountWebLinks"]).apply(null, arguments) + }; + var _FPDFLink_GetURL = Module["_FPDFLink_GetURL"] = function () { + return (_FPDFLink_GetURL = Module["_FPDFLink_GetURL"] = Module["asm"]["FPDFLink_GetURL"]).apply(null, arguments) + }; + var _FPDFLink_CountRects = Module["_FPDFLink_CountRects"] = function () { + return (_FPDFLink_CountRects = Module["_FPDFLink_CountRects"] = Module["asm"]["FPDFLink_CountRects"]).apply(null, arguments) + }; + var _FPDFLink_GetRect = Module["_FPDFLink_GetRect"] = function () { + return (_FPDFLink_GetRect = Module["_FPDFLink_GetRect"] = Module["asm"]["FPDFLink_GetRect"]).apply(null, arguments) + }; + var _FPDFLink_GetTextRange = Module["_FPDFLink_GetTextRange"] = function () { + return (_FPDFLink_GetTextRange = Module["_FPDFLink_GetTextRange"] = Module["asm"]["FPDFLink_GetTextRange"]).apply(null, arguments) + }; + var _FPDFLink_CloseWebLinks = Module["_FPDFLink_CloseWebLinks"] = function () { + return (_FPDFLink_CloseWebLinks = Module["_FPDFLink_CloseWebLinks"] = Module["asm"]["FPDFLink_CloseWebLinks"]).apply(null, arguments) + }; + var _FPDFPage_GetDecodedThumbnailData = Module["_FPDFPage_GetDecodedThumbnailData"] = function () { + return (_FPDFPage_GetDecodedThumbnailData = Module["_FPDFPage_GetDecodedThumbnailData"] = Module["asm"]["FPDFPage_GetDecodedThumbnailData"]).apply(null, arguments) + }; + var _FPDFPage_GetRawThumbnailData = Module["_FPDFPage_GetRawThumbnailData"] = function () { + return (_FPDFPage_GetRawThumbnailData = Module["_FPDFPage_GetRawThumbnailData"] = Module["asm"]["FPDFPage_GetRawThumbnailData"]).apply(null, arguments) + }; + var _FPDFPage_GetThumbnailAsBitmap = Module["_FPDFPage_GetThumbnailAsBitmap"] = function () { + return (_FPDFPage_GetThumbnailAsBitmap = Module["_FPDFPage_GetThumbnailAsBitmap"] = Module["asm"]["FPDFPage_GetThumbnailAsBitmap"]).apply(null, arguments) + }; + var _FPDFPage_SetMediaBox = Module["_FPDFPage_SetMediaBox"] = function () { + return (_FPDFPage_SetMediaBox = Module["_FPDFPage_SetMediaBox"] = Module["asm"]["FPDFPage_SetMediaBox"]).apply(null, arguments) + }; + var _FPDFPage_SetCropBox = Module["_FPDFPage_SetCropBox"] = function () { + return (_FPDFPage_SetCropBox = Module["_FPDFPage_SetCropBox"] = Module["asm"]["FPDFPage_SetCropBox"]).apply(null, arguments) + }; + var _FPDFPage_SetBleedBox = Module["_FPDFPage_SetBleedBox"] = function () { + return (_FPDFPage_SetBleedBox = Module["_FPDFPage_SetBleedBox"] = Module["asm"]["FPDFPage_SetBleedBox"]).apply(null, arguments) + }; + var _FPDFPage_SetTrimBox = Module["_FPDFPage_SetTrimBox"] = function () { + return (_FPDFPage_SetTrimBox = Module["_FPDFPage_SetTrimBox"] = Module["asm"]["FPDFPage_SetTrimBox"]).apply(null, arguments) + }; + var _FPDFPage_SetArtBox = Module["_FPDFPage_SetArtBox"] = function () { + return (_FPDFPage_SetArtBox = Module["_FPDFPage_SetArtBox"] = Module["asm"]["FPDFPage_SetArtBox"]).apply(null, arguments) + }; + var _FPDFPage_GetMediaBox = Module["_FPDFPage_GetMediaBox"] = function () { + return (_FPDFPage_GetMediaBox = Module["_FPDFPage_GetMediaBox"] = Module["asm"]["FPDFPage_GetMediaBox"]).apply(null, arguments) + }; + var _FPDFPage_GetCropBox = Module["_FPDFPage_GetCropBox"] = function () { + return (_FPDFPage_GetCropBox = Module["_FPDFPage_GetCropBox"] = Module["asm"]["FPDFPage_GetCropBox"]).apply(null, arguments) + }; + var _FPDFPage_GetBleedBox = Module["_FPDFPage_GetBleedBox"] = function () { + return (_FPDFPage_GetBleedBox = Module["_FPDFPage_GetBleedBox"] = Module["asm"]["FPDFPage_GetBleedBox"]).apply(null, arguments) + }; + var _FPDFPage_GetTrimBox = Module["_FPDFPage_GetTrimBox"] = function () { + return (_FPDFPage_GetTrimBox = Module["_FPDFPage_GetTrimBox"] = Module["asm"]["FPDFPage_GetTrimBox"]).apply(null, arguments) + }; + var _FPDFPage_GetArtBox = Module["_FPDFPage_GetArtBox"] = function () { + return (_FPDFPage_GetArtBox = Module["_FPDFPage_GetArtBox"] = Module["asm"]["FPDFPage_GetArtBox"]).apply(null, arguments) + }; + var _FPDFPage_TransFormWithClip = Module["_FPDFPage_TransFormWithClip"] = function () { + return (_FPDFPage_TransFormWithClip = Module["_FPDFPage_TransFormWithClip"] = Module["asm"]["FPDFPage_TransFormWithClip"]).apply(null, arguments) + }; + var _FPDFPageObj_TransformClipPath = Module["_FPDFPageObj_TransformClipPath"] = function () { + return (_FPDFPageObj_TransformClipPath = Module["_FPDFPageObj_TransformClipPath"] = Module["asm"]["FPDFPageObj_TransformClipPath"]).apply(null, arguments) + }; + var _FPDFPageObj_GetClipPath = Module["_FPDFPageObj_GetClipPath"] = function () { + return (_FPDFPageObj_GetClipPath = Module["_FPDFPageObj_GetClipPath"] = Module["asm"]["FPDFPageObj_GetClipPath"]).apply(null, arguments) + }; + var _FPDFClipPath_CountPaths = Module["_FPDFClipPath_CountPaths"] = function () { + return (_FPDFClipPath_CountPaths = Module["_FPDFClipPath_CountPaths"] = Module["asm"]["FPDFClipPath_CountPaths"]).apply(null, arguments) + }; + var _FPDFClipPath_CountPathSegments = Module["_FPDFClipPath_CountPathSegments"] = function () { + return (_FPDFClipPath_CountPathSegments = Module["_FPDFClipPath_CountPathSegments"] = Module["asm"]["FPDFClipPath_CountPathSegments"]).apply(null, arguments) + }; + var _FPDFClipPath_GetPathSegment = Module["_FPDFClipPath_GetPathSegment"] = function () { + return (_FPDFClipPath_GetPathSegment = Module["_FPDFClipPath_GetPathSegment"] = Module["asm"]["FPDFClipPath_GetPathSegment"]).apply(null, arguments) + }; + var _FPDF_CreateClipPath = Module["_FPDF_CreateClipPath"] = function () { + return (_FPDF_CreateClipPath = Module["_FPDF_CreateClipPath"] = Module["asm"]["FPDF_CreateClipPath"]).apply(null, arguments) + }; + var _FPDF_DestroyClipPath = Module["_FPDF_DestroyClipPath"] = function () { + return (_FPDF_DestroyClipPath = Module["_FPDF_DestroyClipPath"] = Module["asm"]["FPDF_DestroyClipPath"]).apply(null, arguments) + }; + var _FPDFPage_InsertClipPath = Module["_FPDFPage_InsertClipPath"] = function () { + return (_FPDFPage_InsertClipPath = Module["_FPDFPage_InsertClipPath"] = Module["asm"]["FPDFPage_InsertClipPath"]).apply(null, arguments) + }; + var _FPDF_InitLibrary = Module["_FPDF_InitLibrary"] = function () { + return (_FPDF_InitLibrary = Module["_FPDF_InitLibrary"] = Module["asm"]["FPDF_InitLibrary"]).apply(null, arguments) + }; + var _FPDF_InitLibraryWithConfig = Module["_FPDF_InitLibraryWithConfig"] = function () { + return (_FPDF_InitLibraryWithConfig = Module["_FPDF_InitLibraryWithConfig"] = Module["asm"]["FPDF_InitLibraryWithConfig"]).apply(null, arguments) + }; + var _FPDF_DestroyLibrary = Module["_FPDF_DestroyLibrary"] = function () { + return (_FPDF_DestroyLibrary = Module["_FPDF_DestroyLibrary"] = Module["asm"]["FPDF_DestroyLibrary"]).apply(null, arguments) + }; + var _FPDF_SetSandBoxPolicy = Module["_FPDF_SetSandBoxPolicy"] = function () { + return (_FPDF_SetSandBoxPolicy = Module["_FPDF_SetSandBoxPolicy"] = Module["asm"]["FPDF_SetSandBoxPolicy"]).apply(null, arguments) + }; + var _FPDF_LoadDocument = Module["_FPDF_LoadDocument"] = function () { + return (_FPDF_LoadDocument = Module["_FPDF_LoadDocument"] = Module["asm"]["FPDF_LoadDocument"]).apply(null, arguments) + }; + var _FPDF_GetFormType = Module["_FPDF_GetFormType"] = function () { + return (_FPDF_GetFormType = Module["_FPDF_GetFormType"] = Module["asm"]["FPDF_GetFormType"]).apply(null, arguments) + }; + var _FPDF_LoadXFA = Module["_FPDF_LoadXFA"] = function () { + return (_FPDF_LoadXFA = Module["_FPDF_LoadXFA"] = Module["asm"]["FPDF_LoadXFA"]).apply(null, arguments) + }; + var _FPDF_LoadMemDocument = Module["_FPDF_LoadMemDocument"] = function () { + return (_FPDF_LoadMemDocument = Module["_FPDF_LoadMemDocument"] = Module["asm"]["FPDF_LoadMemDocument"]).apply(null, arguments) + }; + var _FPDF_LoadMemDocument64 = Module["_FPDF_LoadMemDocument64"] = function () { + return (_FPDF_LoadMemDocument64 = Module["_FPDF_LoadMemDocument64"] = Module["asm"]["FPDF_LoadMemDocument64"]).apply(null, arguments) + }; + var _FPDF_LoadCustomDocument = Module["_FPDF_LoadCustomDocument"] = function () { + return (_FPDF_LoadCustomDocument = Module["_FPDF_LoadCustomDocument"] = Module["asm"]["FPDF_LoadCustomDocument"]).apply(null, arguments) + }; + var _FPDF_GetFileVersion = Module["_FPDF_GetFileVersion"] = function () { + return (_FPDF_GetFileVersion = Module["_FPDF_GetFileVersion"] = Module["asm"]["FPDF_GetFileVersion"]).apply(null, arguments) + }; + var _FPDF_DocumentHasValidCrossReferenceTable = Module["_FPDF_DocumentHasValidCrossReferenceTable"] = function () { + return (_FPDF_DocumentHasValidCrossReferenceTable = Module["_FPDF_DocumentHasValidCrossReferenceTable"] = Module["asm"]["FPDF_DocumentHasValidCrossReferenceTable"]).apply(null, arguments) + }; + var _FPDF_GetDocPermissions = Module["_FPDF_GetDocPermissions"] = function () { + return (_FPDF_GetDocPermissions = Module["_FPDF_GetDocPermissions"] = Module["asm"]["FPDF_GetDocPermissions"]).apply(null, arguments) + }; + var _FPDF_GetSecurityHandlerRevision = Module["_FPDF_GetSecurityHandlerRevision"] = function () { + return (_FPDF_GetSecurityHandlerRevision = Module["_FPDF_GetSecurityHandlerRevision"] = Module["asm"]["FPDF_GetSecurityHandlerRevision"]).apply(null, arguments) + }; + var _FPDF_GetPageCount = Module["_FPDF_GetPageCount"] = function () { + return (_FPDF_GetPageCount = Module["_FPDF_GetPageCount"] = Module["asm"]["FPDF_GetPageCount"]).apply(null, arguments) + }; + var _FPDF_LoadPage = Module["_FPDF_LoadPage"] = function () { + return (_FPDF_LoadPage = Module["_FPDF_LoadPage"] = Module["asm"]["FPDF_LoadPage"]).apply(null, arguments) + }; + var _FPDF_GetPageWidthF = Module["_FPDF_GetPageWidthF"] = function () { + return (_FPDF_GetPageWidthF = Module["_FPDF_GetPageWidthF"] = Module["asm"]["FPDF_GetPageWidthF"]).apply(null, arguments) + }; + var _FPDF_GetPageWidth = Module["_FPDF_GetPageWidth"] = function () { + return (_FPDF_GetPageWidth = Module["_FPDF_GetPageWidth"] = Module["asm"]["FPDF_GetPageWidth"]).apply(null, arguments) + }; + var _FPDF_GetPageHeightF = Module["_FPDF_GetPageHeightF"] = function () { + return (_FPDF_GetPageHeightF = Module["_FPDF_GetPageHeightF"] = Module["asm"]["FPDF_GetPageHeightF"]).apply(null, arguments) + }; + var _FPDF_GetPageHeight = Module["_FPDF_GetPageHeight"] = function () { + return (_FPDF_GetPageHeight = Module["_FPDF_GetPageHeight"] = Module["asm"]["FPDF_GetPageHeight"]).apply(null, arguments) + }; + var _FPDF_GetPageBoundingBox = Module["_FPDF_GetPageBoundingBox"] = function () { + return (_FPDF_GetPageBoundingBox = Module["_FPDF_GetPageBoundingBox"] = Module["asm"]["FPDF_GetPageBoundingBox"]).apply(null, arguments) + }; + var _FPDF_RenderPageBitmap = Module["_FPDF_RenderPageBitmap"] = function () { + return (_FPDF_RenderPageBitmap = Module["_FPDF_RenderPageBitmap"] = Module["asm"]["FPDF_RenderPageBitmap"]).apply(null, arguments) + }; + var _FPDF_RenderPageBitmapWithMatrix = Module["_FPDF_RenderPageBitmapWithMatrix"] = function () { + return (_FPDF_RenderPageBitmapWithMatrix = Module["_FPDF_RenderPageBitmapWithMatrix"] = Module["asm"]["FPDF_RenderPageBitmapWithMatrix"]).apply(null, arguments) + }; + var _FPDF_ClosePage = Module["_FPDF_ClosePage"] = function () { + return (_FPDF_ClosePage = Module["_FPDF_ClosePage"] = Module["asm"]["FPDF_ClosePage"]).apply(null, arguments) + }; + var _FPDF_CloseDocument = Module["_FPDF_CloseDocument"] = function () { + return (_FPDF_CloseDocument = Module["_FPDF_CloseDocument"] = Module["asm"]["FPDF_CloseDocument"]).apply(null, arguments) + }; + var _FPDF_GetLastError = Module["_FPDF_GetLastError"] = function () { + return (_FPDF_GetLastError = Module["_FPDF_GetLastError"] = Module["asm"]["FPDF_GetLastError"]).apply(null, arguments) + }; + var _FPDF_DeviceToPage = Module["_FPDF_DeviceToPage"] = function () { + return (_FPDF_DeviceToPage = Module["_FPDF_DeviceToPage"] = Module["asm"]["FPDF_DeviceToPage"]).apply(null, arguments) + }; + var _FPDF_PageToDevice = Module["_FPDF_PageToDevice"] = function () { + return (_FPDF_PageToDevice = Module["_FPDF_PageToDevice"] = Module["asm"]["FPDF_PageToDevice"]).apply(null, arguments) + }; + var _FPDFBitmap_Create = Module["_FPDFBitmap_Create"] = function () { + return (_FPDFBitmap_Create = Module["_FPDFBitmap_Create"] = Module["asm"]["FPDFBitmap_Create"]).apply(null, arguments) + }; + var _FPDFBitmap_CreateEx = Module["_FPDFBitmap_CreateEx"] = function () { + return (_FPDFBitmap_CreateEx = Module["_FPDFBitmap_CreateEx"] = Module["asm"]["FPDFBitmap_CreateEx"]).apply(null, arguments) + }; + var _FPDFBitmap_GetFormat = Module["_FPDFBitmap_GetFormat"] = function () { + return (_FPDFBitmap_GetFormat = Module["_FPDFBitmap_GetFormat"] = Module["asm"]["FPDFBitmap_GetFormat"]).apply(null, arguments) + }; + var _FPDFBitmap_FillRect = Module["_FPDFBitmap_FillRect"] = function () { + return (_FPDFBitmap_FillRect = Module["_FPDFBitmap_FillRect"] = Module["asm"]["FPDFBitmap_FillRect"]).apply(null, arguments) + }; + var _FPDFBitmap_GetBuffer = Module["_FPDFBitmap_GetBuffer"] = function () { + return (_FPDFBitmap_GetBuffer = Module["_FPDFBitmap_GetBuffer"] = Module["asm"]["FPDFBitmap_GetBuffer"]).apply(null, arguments) + }; + var _FPDFBitmap_GetWidth = Module["_FPDFBitmap_GetWidth"] = function () { + return (_FPDFBitmap_GetWidth = Module["_FPDFBitmap_GetWidth"] = Module["asm"]["FPDFBitmap_GetWidth"]).apply(null, arguments) + }; + var _FPDFBitmap_GetHeight = Module["_FPDFBitmap_GetHeight"] = function () { + return (_FPDFBitmap_GetHeight = Module["_FPDFBitmap_GetHeight"] = Module["asm"]["FPDFBitmap_GetHeight"]).apply(null, arguments) + }; + var _FPDFBitmap_GetStride = Module["_FPDFBitmap_GetStride"] = function () { + return (_FPDFBitmap_GetStride = Module["_FPDFBitmap_GetStride"] = Module["asm"]["FPDFBitmap_GetStride"]).apply(null, arguments) + }; + var _FPDFBitmap_Destroy = Module["_FPDFBitmap_Destroy"] = function () { + return (_FPDFBitmap_Destroy = Module["_FPDFBitmap_Destroy"] = Module["asm"]["FPDFBitmap_Destroy"]).apply(null, arguments) + }; + var _FPDF_GetPageSizeByIndexF = Module["_FPDF_GetPageSizeByIndexF"] = function () { + return (_FPDF_GetPageSizeByIndexF = Module["_FPDF_GetPageSizeByIndexF"] = Module["asm"]["FPDF_GetPageSizeByIndexF"]).apply(null, arguments) + }; + var _FPDF_GetPageSizeByIndex = Module["_FPDF_GetPageSizeByIndex"] = function () { + return (_FPDF_GetPageSizeByIndex = Module["_FPDF_GetPageSizeByIndex"] = Module["asm"]["FPDF_GetPageSizeByIndex"]).apply(null, arguments) + }; + var _FPDF_VIEWERREF_GetPrintScaling = Module["_FPDF_VIEWERREF_GetPrintScaling"] = function () { + return (_FPDF_VIEWERREF_GetPrintScaling = Module["_FPDF_VIEWERREF_GetPrintScaling"] = Module["asm"]["FPDF_VIEWERREF_GetPrintScaling"]).apply(null, arguments) + }; + var _FPDF_VIEWERREF_GetNumCopies = Module["_FPDF_VIEWERREF_GetNumCopies"] = function () { + return (_FPDF_VIEWERREF_GetNumCopies = Module["_FPDF_VIEWERREF_GetNumCopies"] = Module["asm"]["FPDF_VIEWERREF_GetNumCopies"]).apply(null, arguments) + }; + var _FPDF_VIEWERREF_GetPrintPageRange = Module["_FPDF_VIEWERREF_GetPrintPageRange"] = function () { + return (_FPDF_VIEWERREF_GetPrintPageRange = Module["_FPDF_VIEWERREF_GetPrintPageRange"] = Module["asm"]["FPDF_VIEWERREF_GetPrintPageRange"]).apply(null, arguments) + }; + var _FPDF_VIEWERREF_GetPrintPageRangeCount = Module["_FPDF_VIEWERREF_GetPrintPageRangeCount"] = function () { + return (_FPDF_VIEWERREF_GetPrintPageRangeCount = Module["_FPDF_VIEWERREF_GetPrintPageRangeCount"] = Module["asm"]["FPDF_VIEWERREF_GetPrintPageRangeCount"]).apply(null, arguments) + }; + var _FPDF_VIEWERREF_GetPrintPageRangeElement = Module["_FPDF_VIEWERREF_GetPrintPageRangeElement"] = function () { + return (_FPDF_VIEWERREF_GetPrintPageRangeElement = Module["_FPDF_VIEWERREF_GetPrintPageRangeElement"] = Module["asm"]["FPDF_VIEWERREF_GetPrintPageRangeElement"]).apply(null, arguments) + }; + var _FPDF_VIEWERREF_GetDuplex = Module["_FPDF_VIEWERREF_GetDuplex"] = function () { + return (_FPDF_VIEWERREF_GetDuplex = Module["_FPDF_VIEWERREF_GetDuplex"] = Module["asm"]["FPDF_VIEWERREF_GetDuplex"]).apply(null, arguments) + }; + var _FPDF_VIEWERREF_GetName = Module["_FPDF_VIEWERREF_GetName"] = function () { + return (_FPDF_VIEWERREF_GetName = Module["_FPDF_VIEWERREF_GetName"] = Module["asm"]["FPDF_VIEWERREF_GetName"]).apply(null, arguments) + }; + var _FPDF_CountNamedDests = Module["_FPDF_CountNamedDests"] = function () { + return (_FPDF_CountNamedDests = Module["_FPDF_CountNamedDests"] = Module["asm"]["FPDF_CountNamedDests"]).apply(null, arguments) + }; + var _FPDF_GetNamedDestByName = Module["_FPDF_GetNamedDestByName"] = function () { + return (_FPDF_GetNamedDestByName = Module["_FPDF_GetNamedDestByName"] = Module["asm"]["FPDF_GetNamedDestByName"]).apply(null, arguments) + }; + var _FPDF_GetNamedDest = Module["_FPDF_GetNamedDest"] = function () { + return (_FPDF_GetNamedDest = Module["_FPDF_GetNamedDest"] = Module["asm"]["FPDF_GetNamedDest"]).apply(null, arguments) + }; + var _FPDF_GetXFAPacketCount = Module["_FPDF_GetXFAPacketCount"] = function () { + return (_FPDF_GetXFAPacketCount = Module["_FPDF_GetXFAPacketCount"] = Module["asm"]["FPDF_GetXFAPacketCount"]).apply(null, arguments) + }; + var _FPDF_GetXFAPacketName = Module["_FPDF_GetXFAPacketName"] = function () { + return (_FPDF_GetXFAPacketName = Module["_FPDF_GetXFAPacketName"] = Module["asm"]["FPDF_GetXFAPacketName"]).apply(null, arguments) + }; + var _FPDF_GetXFAPacketContent = Module["_FPDF_GetXFAPacketContent"] = function () { + return (_FPDF_GetXFAPacketContent = Module["_FPDF_GetXFAPacketContent"] = Module["asm"]["FPDF_GetXFAPacketContent"]).apply(null, arguments) + }; + var _FPDF_GetTrailerEnds = Module["_FPDF_GetTrailerEnds"] = function () { + return (_FPDF_GetTrailerEnds = Module["_FPDF_GetTrailerEnds"] = Module["asm"]["FPDF_GetTrailerEnds"]).apply(null, arguments) + }; + var ___errno_location = function () { + return (___errno_location = Module["asm"]["__errno_location"]).apply(null, arguments) + }; + var __emscripten_timeout = function () { + return (__emscripten_timeout = Module["asm"]["_emscripten_timeout"]).apply(null, arguments) + }; + var _malloc = function () { + return (_malloc = Module["asm"]["malloc"]).apply(null, arguments) + }; + var _free = function () { + return (_free = Module["asm"]["free"]).apply(null, arguments) + }; + var _emscripten_builtin_memalign = function () { + return (_emscripten_builtin_memalign = Module["asm"]["emscripten_builtin_memalign"]).apply(null, arguments) + }; + var _setThrew = function () { + return (_setThrew = Module["asm"]["setThrew"]).apply(null, arguments) + }; + var _saveSetjmp = function () { + return (_saveSetjmp = Module["asm"]["saveSetjmp"]).apply(null, arguments) + }; + var stackSave = function () { + return (stackSave = Module["asm"]["stackSave"]).apply(null, arguments) + }; + var stackRestore = function () { + return (stackRestore = Module["asm"]["stackRestore"]).apply(null, arguments) + }; + var stackAlloc = function () { + return (stackAlloc = Module["asm"]["stackAlloc"]).apply(null, arguments) + }; + var dynCall_jiji = Module["dynCall_jiji"] = function () { + return (dynCall_jiji = Module["dynCall_jiji"] = Module["asm"]["dynCall_jiji"]).apply(null, arguments) + }; + var dynCall_iiiiij = Module["dynCall_iiiiij"] = function () { + return (dynCall_iiiiij = Module["dynCall_iiiiij"] = Module["asm"]["dynCall_iiiiij"]).apply(null, arguments) + }; + var dynCall_iiiiijj = Module["dynCall_iiiiijj"] = function () { + return (dynCall_iiiiijj = Module["dynCall_iiiiijj"] = Module["asm"]["dynCall_iiiiijj"]).apply(null, arguments) + }; + var dynCall_iiiiiijj = Module["dynCall_iiiiiijj"] = function () { + return (dynCall_iiiiiijj = Module["dynCall_iiiiiijj"] = Module["asm"]["dynCall_iiiiiijj"]).apply(null, arguments) + }; + var dynCall_viijii = Module["dynCall_viijii"] = function () { + return (dynCall_viijii = Module["dynCall_viijii"] = Module["asm"]["dynCall_viijii"]).apply(null, arguments) + }; + var dynCall_ji = Module["dynCall_ji"] = function () { + return (dynCall_ji = Module["dynCall_ji"] = Module["asm"]["dynCall_ji"]).apply(null, arguments) + }; + var dynCall_jij = Module["dynCall_jij"] = function () { + return (dynCall_jij = Module["dynCall_jij"] = Module["asm"]["dynCall_jij"]).apply(null, arguments) + }; + var dynCall_iiiij = Module["dynCall_iiiij"] = function () { + return (dynCall_iiiij = Module["dynCall_iiiij"] = Module["asm"]["dynCall_iiiij"]).apply(null, arguments) + }; + var dynCall_iij = Module["dynCall_iij"] = function () { + return (dynCall_iij = Module["dynCall_iij"] = Module["asm"]["dynCall_iij"]).apply(null, arguments) + }; + var dynCall_iiij = Module["dynCall_iiij"] = function () { + return (dynCall_iiij = Module["dynCall_iiij"] = Module["asm"]["dynCall_iiij"]).apply(null, arguments) + }; + var dynCall_j = Module["dynCall_j"] = function () { + return (dynCall_j = Module["dynCall_j"] = Module["asm"]["dynCall_j"]).apply(null, arguments) + }; + var dynCall_iji = Module["dynCall_iji"] = function () { + return (dynCall_iji = Module["dynCall_iji"] = Module["asm"]["dynCall_iji"]).apply(null, arguments) + }; + var dynCall_jji = Module["dynCall_jji"] = function () { + return (dynCall_jji = Module["dynCall_jji"] = Module["asm"]["dynCall_jji"]).apply(null, arguments) + }; + var dynCall_iiji = Module["dynCall_iiji"] = function () { + return (dynCall_iiji = Module["dynCall_iiji"] = Module["asm"]["dynCall_iiji"]).apply(null, arguments) + }; + var dynCall_viji = Module["dynCall_viji"] = function () { + return (dynCall_viji = Module["dynCall_viji"] = Module["asm"]["dynCall_viji"]).apply(null, arguments) + }; + + function invoke_viiii(index, a1, a2, a3, a4) { + var sp = stackSave(); + try { + getWasmTableEntry(index)(a1, a2, a3, a4) + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0) + } + } + + function invoke_iii(index, a1, a2) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1, a2) + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0) + } + } + + function invoke_iiiii(index, a1, a2, a3, a4) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1, a2, a3, a4) + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0) + } + } + + function invoke_v(index) { + var sp = stackSave(); + try { + getWasmTableEntry(index)() + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0) + } + } + + function invoke_iiii(index, a1, a2, a3) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1, a2, a3) + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0) + } + } + + function invoke_viii(index, a1, a2, a3) { + var sp = stackSave(); + try { + getWasmTableEntry(index)(a1, a2, a3) + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0) + } + } + + function invoke_vi(index, a1) { + var sp = stackSave(); + try { + getWasmTableEntry(index)(a1) + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0) + } + } + + function invoke_ii(index, a1) { + var sp = stackSave(); + try { + return getWasmTableEntry(index)(a1) + } catch (e) { + stackRestore(sp); + if (e !== e + 0) throw e; + _setThrew(1, 0) + } + } + Module["ccall"] = ccall; + Module["cwrap"] = cwrap; + var calledRun; + dependenciesFulfilled = function runCaller() { + if (!calledRun) run(); + if (!calledRun) dependenciesFulfilled = runCaller + }; + + function run() { + if (runDependencies > 0) { + return + } + preRun(); + if (runDependencies > 0) { + return + } + + function doRun() { + if (calledRun) return; + calledRun = true; + Module["calledRun"] = true; + if (ABORT) return; + initRuntime(); + if (Module["onRuntimeInitialized"]) Module["onRuntimeInitialized"](); + postRun() + } + if (Module["setStatus"]) { + Module["setStatus"]("Running..."); + setTimeout(function () { + setTimeout(function () { + Module["setStatus"]("") + }, 1); + doRun() + }, 1) + } else { + doRun() + } + } + if (Module["preInit"]) { + if (typeof Module["preInit"] == "function") Module["preInit"] = [Module["preInit"]]; + while (Module["preInit"].length > 0) { + Module["preInit"].pop()() + } + } + run(); + return PDFiumModule.ready + }); +})(); +if (typeof exports === 'object' && typeof module === 'object') + module.exports = PDFiumModule; +else if (typeof define === 'function' && define['amd']) + define([], function () { + return PDFiumModule; + }); +else if (typeof exports === 'object') + exports["PDFiumModule"] = PDFiumModule; diff --git a/How to/Delete FormFields in Non Rendered Pages/public/ej2-pdfviewer-lib/pdfium.wasm b/How to/Delete FormFields in Non Rendered Pages/public/ej2-pdfviewer-lib/pdfium.wasm new file mode 100644 index 0000000..31aea9b Binary files /dev/null and b/How to/Delete FormFields in Non Rendered Pages/public/ej2-pdfviewer-lib/pdfium.wasm differ diff --git a/How to/Delete FormFields in Non Rendered Pages/public/next.svg b/How to/Delete FormFields in Non Rendered Pages/public/next.svg new file mode 100644 index 0000000..5174b28 --- /dev/null +++ b/How to/Delete FormFields in Non Rendered Pages/public/next.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/How to/Delete FormFields in Non Rendered Pages/public/vercel.svg b/How to/Delete FormFields in Non Rendered Pages/public/vercel.svg new file mode 100644 index 0000000..d2f8422 --- /dev/null +++ b/How to/Delete FormFields in Non Rendered Pages/public/vercel.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/How to/Delete FormFields in Non Rendered Pages/src/app/favicon.ico b/How to/Delete FormFields in Non Rendered Pages/src/app/favicon.ico new file mode 100644 index 0000000..718d6fe Binary files /dev/null and b/How to/Delete FormFields in Non Rendered Pages/src/app/favicon.ico differ diff --git a/How to/Delete FormFields in Non Rendered Pages/src/app/globals.css b/How to/Delete FormFields in Non Rendered Pages/src/app/globals.css new file mode 100644 index 0000000..3328ff5 --- /dev/null +++ b/How to/Delete FormFields in Non Rendered Pages/src/app/globals.css @@ -0,0 +1,8 @@ +@import '../../node_modules/@syncfusion/ej2-base/styles/material.css'; +@import '../../node_modules/@syncfusion/ej2-buttons/styles/material.css'; +@import '../../node_modules/@syncfusion/ej2-dropdowns/styles/material.css'; +@import '../../node_modules/@syncfusion/ej2-inputs/styles/material.css'; +@import '../../node_modules/@syncfusion/ej2-navigations/styles/material.css'; +@import '../../node_modules/@syncfusion/ej2-popups/styles/material.css'; +@import '../../node_modules/@syncfusion/ej2-splitbuttons/styles/material.css'; +@import "../../node_modules/@syncfusion/ej2-pdfviewer/styles/material.css"; \ No newline at end of file diff --git a/How to/Delete FormFields in Non Rendered Pages/src/app/layout.tsx b/How to/Delete FormFields in Non Rendered Pages/src/app/layout.tsx new file mode 100644 index 0000000..3314e47 --- /dev/null +++ b/How to/Delete FormFields in Non Rendered Pages/src/app/layout.tsx @@ -0,0 +1,22 @@ +import type { Metadata } from "next"; +import { Inter } from "next/font/google"; +import "./globals.css"; + +const inter = Inter({ subsets: ["latin"] }); + +export const metadata: Metadata = { + title: "Create Next App", + description: "Generated by create next app", +}; + +export default function RootLayout({ + children, +}: Readonly<{ + children: React.ReactNode; +}>) { + return ( + + {children} + + ); +} diff --git a/How to/Delete FormFields in Non Rendered Pages/src/app/page.module.css b/How to/Delete FormFields in Non Rendered Pages/src/app/page.module.css new file mode 100644 index 0000000..5c4b1e6 --- /dev/null +++ b/How to/Delete FormFields in Non Rendered Pages/src/app/page.module.css @@ -0,0 +1,230 @@ +.main { + display: flex; + flex-direction: column; + justify-content: space-between; + align-items: center; + padding: 6rem; + min-height: 100vh; +} + +.description { + display: inherit; + justify-content: inherit; + align-items: inherit; + font-size: 0.85rem; + max-width: var(--max-width); + width: 100%; + z-index: 2; + font-family: var(--font-mono); +} + +.description a { + display: flex; + justify-content: center; + align-items: center; + gap: 0.5rem; +} + +.description p { + position: relative; + margin: 0; + padding: 1rem; + background-color: rgba(var(--callout-rgb), 0.5); + border: 1px solid rgba(var(--callout-border-rgb), 0.3); + border-radius: var(--border-radius); +} + +.code { + font-weight: 700; + font-family: var(--font-mono); +} + +.grid { + display: grid; + grid-template-columns: repeat(4, minmax(25%, auto)); + max-width: 100%; + width: var(--max-width); +} + +.card { + padding: 1rem 1.2rem; + border-radius: var(--border-radius); + background: rgba(var(--card-rgb), 0); + border: 1px solid rgba(var(--card-border-rgb), 0); + transition: background 200ms, border 200ms; +} + +.card span { + display: inline-block; + transition: transform 200ms; +} + +.card h2 { + font-weight: 600; + margin-bottom: 0.7rem; +} + +.card p { + margin: 0; + opacity: 0.6; + font-size: 0.9rem; + line-height: 1.5; + max-width: 30ch; + text-wrap: balance; +} + +.center { + display: flex; + justify-content: center; + align-items: center; + position: relative; + padding: 4rem 0; +} + +.center::before { + background: var(--secondary-glow); + border-radius: 50%; + width: 480px; + height: 360px; + margin-left: -400px; +} + +.center::after { + background: var(--primary-glow); + width: 240px; + height: 180px; + z-index: -1; +} + +.center::before, +.center::after { + content: ""; + left: 50%; + position: absolute; + filter: blur(45px); + transform: translateZ(0); +} + +.logo { + position: relative; +} +/* Enable hover only on non-touch devices */ +@media (hover: hover) and (pointer: fine) { + .card:hover { + background: rgba(var(--card-rgb), 0.1); + border: 1px solid rgba(var(--card-border-rgb), 0.15); + } + + .card:hover span { + transform: translateX(4px); + } +} + +@media (prefers-reduced-motion) { + .card:hover span { + transform: none; + } +} + +/* Mobile */ +@media (max-width: 700px) { + .content { + padding: 4rem; + } + + .grid { + grid-template-columns: 1fr; + margin-bottom: 120px; + max-width: 320px; + text-align: center; + } + + .card { + padding: 1rem 2.5rem; + } + + .card h2 { + margin-bottom: 0.5rem; + } + + .center { + padding: 8rem 0 6rem; + } + + .center::before { + transform: none; + height: 300px; + } + + .description { + font-size: 0.8rem; + } + + .description a { + padding: 1rem; + } + + .description p, + .description div { + display: flex; + justify-content: center; + position: fixed; + width: 100%; + } + + .description p { + align-items: center; + inset: 0 0 auto; + padding: 2rem 1rem 1.4rem; + border-radius: 0; + border: none; + border-bottom: 1px solid rgba(var(--callout-border-rgb), 0.25); + background: linear-gradient( + to bottom, + rgba(var(--background-start-rgb), 1), + rgba(var(--callout-rgb), 0.5) + ); + background-clip: padding-box; + backdrop-filter: blur(24px); + } + + .description div { + align-items: flex-end; + pointer-events: none; + inset: auto 0 0; + padding: 2rem; + height: 200px; + background: linear-gradient( + to bottom, + transparent 0%, + rgb(var(--background-end-rgb)) 40% + ); + z-index: 1; + } +} + +/* Tablet and Smaller Desktop */ +@media (min-width: 701px) and (max-width: 1120px) { + .grid { + grid-template-columns: repeat(2, 50%); + } +} + +@media (prefers-color-scheme: dark) { + .vercelLogo { + filter: invert(1); + } + + .logo { + filter: invert(1) drop-shadow(0 0 0.3rem #ffffff70); + } +} + +@keyframes rotate { + from { + transform: rotate(360deg); + } + to { + transform: rotate(0deg); + } +} diff --git a/How to/Delete FormFields in Non Rendered Pages/src/app/page.tsx b/How to/Delete FormFields in Non Rendered Pages/src/app/page.tsx new file mode 100644 index 0000000..00de3e8 --- /dev/null +++ b/How to/Delete FormFields in Non Rendered Pages/src/app/page.tsx @@ -0,0 +1,44 @@ +'use client' +import { PdfViewerComponent, Toolbar, Magnification, Navigation, LinkAnnotation, BookmarkView, + ThumbnailView, Print, TextSelection, Annotation, TextSearch, FormFields, FormDesigner, Inject} from '@syncfusion/ej2-react-pdfviewer'; +import { ButtonComponent } from '@syncfusion/ej2-react-buttons'; + +export function App() { +let viewer: PdfViewerComponent | null; +let documentPath: string = "data:application/pdf;base64,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"; +const deleteFormField = () => { + var formFieldCollections = viewer?.formFieldCollections; + if(formFieldCollections){ + for(var i=0; i { + viewer?.load(documentPath, ""); +}; + +return (
+
+ Load Pdf + Delete FormField + { viewer = scope; }} + id="container" + resourceUrl="https://cdn.syncfusion.com/ej2/26.2.11/dist/ej2-pdfviewer-lib" + style={{ 'height': '640px' }}> + {/* Inject the required services */} + + +
+
+ +); +} +export default App; \ No newline at end of file diff --git a/How to/Delete FormFields in Non Rendered Pages/tsconfig.json b/How to/Delete FormFields in Non Rendered Pages/tsconfig.json new file mode 100644 index 0000000..7b28589 --- /dev/null +++ b/How to/Delete FormFields in Non Rendered Pages/tsconfig.json @@ -0,0 +1,26 @@ +{ + "compilerOptions": { + "lib": ["dom", "dom.iterable", "esnext"], + "allowJs": true, + "skipLibCheck": true, + "strict": true, + "noEmit": true, + "esModuleInterop": true, + "module": "esnext", + "moduleResolution": "bundler", + "resolveJsonModule": true, + "isolatedModules": true, + "jsx": "preserve", + "incremental": true, + "plugins": [ + { + "name": "next" + } + ], + "paths": { + "@/*": ["./src/*"] + } + }, + "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"], + "exclude": ["node_modules"] +}