From f7638337ab390433bdb7bd92f7d7b66686ff1197 Mon Sep 17 00:00:00 2001
From: Uma-SF4267 <156883240+Uma-SF4267@users.noreply.github.com>
Date: Fri, 5 Sep 2025 15:05:36 +0530
Subject: [PATCH 1/2] 980143: Line Angle Constraint Sample for ASP .NET MVC
platform
---
.../PDFViewerSample.csproj | 14 +
.../Line Angle Constraint/PDFViewerSample.sln | 25 +
.../Line Angle Constraint/Pages/Error.cshtml | 26 +
.../Pages/Error.cshtml.cs | 27 +
.../Line Angle Constraint/Pages/Index.cshtml | 22 +
.../Pages/Index.cshtml.cs | 310 ++
.../Pages/Privacy.cshtml | 8 +
.../Pages/Privacy.cshtml.cs | 19 +
.../Pages/Shared/_Layout.cshtml | 51 +
.../Pages/Shared/_Layout.cshtml.css | 48 +
.../Shared/_ValidationScriptsPartial.cshtml | 2 +
.../Pages/_ViewImports.cshtml | 4 +
.../Pages/_ViewStart.cshtml | 3 +
How to/Line Angle Constraint/Program.cs | 25 +
.../Properties/launchSettings.json | 28 +
How to/Line Angle Constraint/README.md | 26 +
.../appsettings.Development.json | 9 +
How to/Line Angle Constraint/appsettings.json | 9 +
.../wwwroot/ej2-pdfviewer-lib/pdfium.js | 4065 +++++++++++++++++
.../wwwroot/ej2-pdfviewer-lib/pdfium.wasm | Bin 0 -> 3985982 bytes
.../Line Angle Constraint/wwwroot/ej2.min.js | 1 +
.../Line Angle Constraint/wwwroot/favicon.ico | Bin 0 -> 5430 bytes
22 files changed, 4722 insertions(+)
create mode 100644 How to/Line Angle Constraint/PDFViewerSample.csproj
create mode 100644 How to/Line Angle Constraint/PDFViewerSample.sln
create mode 100644 How to/Line Angle Constraint/Pages/Error.cshtml
create mode 100644 How to/Line Angle Constraint/Pages/Error.cshtml.cs
create mode 100644 How to/Line Angle Constraint/Pages/Index.cshtml
create mode 100644 How to/Line Angle Constraint/Pages/Index.cshtml.cs
create mode 100644 How to/Line Angle Constraint/Pages/Privacy.cshtml
create mode 100644 How to/Line Angle Constraint/Pages/Privacy.cshtml.cs
create mode 100644 How to/Line Angle Constraint/Pages/Shared/_Layout.cshtml
create mode 100644 How to/Line Angle Constraint/Pages/Shared/_Layout.cshtml.css
create mode 100644 How to/Line Angle Constraint/Pages/Shared/_ValidationScriptsPartial.cshtml
create mode 100644 How to/Line Angle Constraint/Pages/_ViewImports.cshtml
create mode 100644 How to/Line Angle Constraint/Pages/_ViewStart.cshtml
create mode 100644 How to/Line Angle Constraint/Program.cs
create mode 100644 How to/Line Angle Constraint/Properties/launchSettings.json
create mode 100644 How to/Line Angle Constraint/README.md
create mode 100644 How to/Line Angle Constraint/appsettings.Development.json
create mode 100644 How to/Line Angle Constraint/appsettings.json
create mode 100644 How to/Line Angle Constraint/wwwroot/ej2-pdfviewer-lib/pdfium.js
create mode 100644 How to/Line Angle Constraint/wwwroot/ej2-pdfviewer-lib/pdfium.wasm
create mode 100644 How to/Line Angle Constraint/wwwroot/ej2.min.js
create mode 100644 How to/Line Angle Constraint/wwwroot/favicon.ico
diff --git a/How to/Line Angle Constraint/PDFViewerSample.csproj b/How to/Line Angle Constraint/PDFViewerSample.csproj
new file mode 100644
index 0000000..dcbd110
--- /dev/null
+++ b/How to/Line Angle Constraint/PDFViewerSample.csproj
@@ -0,0 +1,14 @@
+
+
+
+ net6.0
+ enable
+ enable
+
+
+
+
+
+
+
+
diff --git a/How to/Line Angle Constraint/PDFViewerSample.sln b/How to/Line Angle Constraint/PDFViewerSample.sln
new file mode 100644
index 0000000..67ddc5d
--- /dev/null
+++ b/How to/Line Angle Constraint/PDFViewerSample.sln
@@ -0,0 +1,25 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.0.32112.339
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PDFViewerSample", "PDFViewerSample.csproj", "{39AA1883-BB43-4C46-9892-6033EA59C990}"
+EndProject
+Global
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution
+ Debug|Any CPU = Debug|Any CPU
+ Release|Any CPU = Release|Any CPU
+ EndGlobalSection
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution
+ {39AA1883-BB43-4C46-9892-6033EA59C990}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {39AA1883-BB43-4C46-9892-6033EA59C990}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {39AA1883-BB43-4C46-9892-6033EA59C990}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {39AA1883-BB43-4C46-9892-6033EA59C990}.Release|Any CPU.Build.0 = Release|Any CPU
+ EndGlobalSection
+ GlobalSection(SolutionProperties) = preSolution
+ HideSolutionNode = FALSE
+ EndGlobalSection
+ GlobalSection(ExtensibilityGlobals) = postSolution
+ SolutionGuid = {5F13CE16-9CC4-4755-AFB4-367F461A209C}
+ EndGlobalSection
+EndGlobal
diff --git a/How to/Line Angle Constraint/Pages/Error.cshtml b/How to/Line Angle Constraint/Pages/Error.cshtml
new file mode 100644
index 0000000..6f92b95
--- /dev/null
+++ b/How to/Line Angle Constraint/Pages/Error.cshtml
@@ -0,0 +1,26 @@
+@page
+@model ErrorModel
+@{
+ ViewData["Title"] = "Error";
+}
+
+
Error.
+An error occurred while processing your request.
+
+@if (Model.ShowRequestId)
+{
+
+ Request ID: @Model.RequestId
+
+}
+
+Development Mode
+
+ Swapping to the Development environment displays detailed information about the error that occurred.
+
+
+ The Development environment shouldn't be enabled for deployed applications.
+ It can result in displaying sensitive information from exceptions to end users.
+ For local debugging, enable the Development environment by setting the ASPNETCORE_ENVIRONMENT environment variable to Development
+ and restarting the app.
+
diff --git a/How to/Line Angle Constraint/Pages/Error.cshtml.cs b/How to/Line Angle Constraint/Pages/Error.cshtml.cs
new file mode 100644
index 0000000..0a23fb0
--- /dev/null
+++ b/How to/Line Angle Constraint/Pages/Error.cshtml.cs
@@ -0,0 +1,27 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.RazorPages;
+using System.Diagnostics;
+
+namespace PDFViewerSample.Pages
+{
+ [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
+ [IgnoreAntiforgeryToken]
+ public class ErrorModel : PageModel
+ {
+ public string? RequestId { get; set; }
+
+ public bool ShowRequestId => !string.IsNullOrEmpty(RequestId);
+
+ private readonly ILogger _logger;
+
+ public ErrorModel(ILogger logger)
+ {
+ _logger = logger;
+ }
+
+ public void OnGet()
+ {
+ RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier;
+ }
+ }
+}
\ No newline at end of file
diff --git a/How to/Line Angle Constraint/Pages/Index.cshtml b/How to/Line Angle Constraint/Pages/Index.cshtml
new file mode 100644
index 0000000..14c73df
--- /dev/null
+++ b/How to/Line Angle Constraint/Pages/Index.cshtml
@@ -0,0 +1,22 @@
+@page "{handler?}"
+@model IndexModel
+@{
+ ViewData["Title"] = "Home page";
+}
+
+
+
+
+
+
+
+
diff --git a/How to/Line Angle Constraint/Pages/Index.cshtml.cs b/How to/Line Angle Constraint/Pages/Index.cshtml.cs
new file mode 100644
index 0000000..ed5bb1c
--- /dev/null
+++ b/How to/Line Angle Constraint/Pages/Index.cshtml.cs
@@ -0,0 +1,310 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Caching.Memory;
+using Syncfusion.EJ2.PdfViewer;
+using Newtonsoft.Json;
+using Microsoft.AspNetCore.Mvc.RazorPages;
+using System.Reflection;
+using System.Net;
+
+namespace PDFViewerSample.Pages
+{
+ [IgnoreAntiforgeryToken(Order = 1001)]
+ public class IndexModel : PageModel
+ {
+
+ private readonly Microsoft.AspNetCore.Hosting.IHostingEnvironment _hostingEnvironment;
+ private IMemoryCache _cache;
+
+ public IndexModel(Microsoft.AspNetCore.Hosting.IHostingEnvironment hostingEnvironment, IMemoryCache cache)
+ {
+ _hostingEnvironment = hostingEnvironment;
+ _cache = cache;
+ }
+
+ public IActionResult OnPostLoad([FromBody] jsonObjects responseData)
+ {
+ PdfRenderer pdfviewer = new PdfRenderer(_cache);
+ MemoryStream stream = new MemoryStream();
+ var jsonObject = JsonConverterstring(responseData);
+ object jsonResult = new object();
+ if (jsonObject != null && jsonObject.ContainsKey("document"))
+ {
+ if (bool.Parse(jsonObject["isFileName"]))
+ {
+ string documentPath = GetDocumentPath(jsonObject["document"]);
+ if (!string.IsNullOrEmpty(documentPath))
+ {
+ byte[] bytes = System.IO.File.ReadAllBytes(documentPath);
+ stream = new MemoryStream(bytes);
+ }
+ else
+ {
+ string fileName = jsonObject["document"].Split(new string[] { "://" }, StringSplitOptions.None)[0];
+ if (fileName == "http" || fileName == "https")
+ {
+ WebClient WebClient = new WebClient();
+ byte[] pdfDoc = WebClient.DownloadData(jsonObject["document"]);
+ stream = new MemoryStream(pdfDoc);
+ }
+ else
+ return this.Content(jsonObject["document"] + " is not found");
+ }
+ }
+ else
+ {
+ byte[] bytes = Convert.FromBase64String(jsonObject["document"]);
+ stream = new MemoryStream(bytes);
+ }
+ }
+ jsonResult = pdfviewer.Load(stream, jsonObject);
+ return Content(JsonConvert.SerializeObject(jsonResult));
+ }
+
+ public IActionResult OnPostValidatePassword([FromBody] jsonObjects responseData)
+ {
+ PdfRenderer pdfviewer = new PdfRenderer(_cache);
+ MemoryStream stream = new MemoryStream();
+ var jsonObject = JsonConverterstring(responseData);
+ object jsonResult = new object();
+ if (jsonObject != null && jsonObject.ContainsKey("document"))
+ {
+ if (bool.Parse(jsonObject["isFileName"]))
+ {
+ string documentPath = GetDocumentPath(jsonObject["document"]);
+ if (!string.IsNullOrEmpty(documentPath))
+ {
+ byte[] bytes = System.IO.File.ReadAllBytes(documentPath);
+ stream = new MemoryStream(bytes);
+ }
+ else
+ {
+ string fileName = jsonObject["document"].Split(new string[] { "://" }, StringSplitOptions.None)[0];
+ if (fileName == "http" || fileName == "https")
+ {
+ WebClient WebClient = new WebClient();
+ byte[] pdfDoc = WebClient.DownloadData(jsonObject["document"]);
+ stream = new MemoryStream(pdfDoc);
+ }
+ else
+ return this.Content(jsonObject["document"] + " is not found");
+ }
+ }
+ else
+ {
+ byte[] bytes = Convert.FromBase64String(jsonObject["document"]);
+ stream = new MemoryStream(bytes);
+ }
+ }
+ string password = null;
+ if (jsonObject.ContainsKey("password"))
+ {
+ password = jsonObject["password"];
+ }
+ var result = pdfviewer.Load(stream, password);
+
+ return Content(JsonConvert.SerializeObject(result));
+ }
+ public Dictionary JsonConverterstring(jsonObjects results)
+ {
+ Dictionary resultObjects = new Dictionary();
+ resultObjects = results.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public)
+ .ToDictionary(prop => prop.Name, prop => prop.GetValue(results, null));
+ var emptyObjects = (from kv in resultObjects
+ where kv.Value != null
+ select kv).ToDictionary(kv => kv.Key, kv => kv.Value);
+ Dictionary jsonResult = emptyObjects.ToDictionary(k => k.Key, k => k.Value.ToString());
+ return jsonResult;
+ }
+
+ //Post action for processing the PDF documents.
+ public IActionResult OnPostRenderPdfPages([FromBody] jsonObjects responseData)
+ {
+ PdfRenderer pdfviewer = new PdfRenderer(_cache);
+ var jsonObject = JsonConverterstring(responseData);
+ object jsonResult = pdfviewer.GetPage(jsonObject);
+ return Content(JsonConvert.SerializeObject(jsonResult));
+ }
+
+ //Post action for unloading and disposing the PDF document resources
+ public IActionResult OnPostUnload([FromBody] jsonObjects responseData)
+ {
+ PdfRenderer pdfviewer = new PdfRenderer(_cache);
+ var jsonObject = JsonConverterstring(responseData);
+ pdfviewer.ClearCache(jsonObject);
+ return this.Content("Document cache is cleared");
+ }
+
+ //Post action for rendering the ThumbnailImages
+ public IActionResult OnPostRenderThumbnailImages([FromBody] jsonObjects responseData)
+ {
+ PdfRenderer pdfviewer = new PdfRenderer(_cache);
+ var jsonObject = JsonConverterstring(responseData);
+ object result = pdfviewer.GetThumbnailImages(jsonObject);
+ return Content(JsonConvert.SerializeObject(result));
+ }
+
+ //Post action for processing the bookmarks from the PDF documents
+ public IActionResult OnPostBookmarks([FromBody] jsonObjects responseData)
+ {
+ PdfRenderer pdfviewer = new PdfRenderer(_cache);
+ var jsonObject = JsonConverterstring(responseData);
+ object jsonResult = pdfviewer.GetBookmarks(jsonObject);
+ return Content(JsonConvert.SerializeObject(jsonResult));
+ }
+
+ //Post action for rendering the annotation comments
+ public IActionResult OnPostRenderAnnotationComments([FromBody] jsonObjects responseData)
+ {
+ PdfRenderer pdfviewer = new PdfRenderer(_cache);
+ var jsonObject = JsonConverterstring(responseData);
+ object jsonResult = pdfviewer.GetAnnotationComments(jsonObject);
+ return Content(JsonConvert.SerializeObject(jsonResult));
+ }
+
+ //Post action for exporting the annotations
+ public IActionResult OnPostExportAnnotations([FromBody] jsonObjects responseData)
+ {
+ PdfRenderer pdfviewer = new PdfRenderer(_cache);
+ var jsonObject = JsonConverterstring(responseData);
+ string jsonResult = pdfviewer.ExportAnnotation(jsonObject);
+ return Content(jsonResult);
+ }
+
+ //Post action for importing the annotations
+ public IActionResult OnPostImportAnnotations([FromBody] jsonObjects responseData)
+ {
+ PdfRenderer pdfviewer = new PdfRenderer(_cache);
+ var jsonObject = JsonConverterstring(responseData);
+ string jsonResult = string.Empty;
+ object JsonResult;
+ if (jsonObject != null && jsonObject.ContainsKey("fileName"))
+ {
+ string documentPath = GetDocumentPath(jsonObject["fileName"]);
+ if (!string.IsNullOrEmpty(documentPath))
+ {
+ jsonResult = System.IO.File.ReadAllText(documentPath);
+ }
+ else
+ {
+ return this.Content(jsonObject["document"] + " is not found");
+ }
+ }
+ else
+ {
+ string extension = Path.GetExtension(jsonObject["importedData"]);
+ if (extension != ".xfdf")
+ {
+ JsonResult = pdfviewer.ImportAnnotation(jsonObject);
+ return Content(JsonConvert.SerializeObject(JsonResult));
+ }
+ else
+ {
+ string documentPath = GetDocumentPath(jsonObject["importedData"]);
+ if (!string.IsNullOrEmpty(documentPath))
+ {
+ byte[] bytes = System.IO.File.ReadAllBytes(documentPath);
+ jsonObject["importedData"] = Convert.ToBase64String(bytes);
+ JsonResult = pdfviewer.ImportAnnotation(jsonObject);
+ return Content(JsonConvert.SerializeObject(JsonResult));
+ }
+ else
+ {
+ return this.Content(jsonObject["document"] + " is not found");
+ }
+ }
+ }
+ return Content(jsonResult);
+ }
+
+ //Post action for downloading the PDF documents
+ public IActionResult OnPostDownload([FromBody] jsonObjects responseData)
+ {
+ PdfRenderer pdfviewer = new PdfRenderer(_cache);
+ var jsonObject = JsonConverterstring(responseData);
+ string documentBase = pdfviewer.GetDocumentAsBase64(jsonObject);
+ return Content(documentBase);
+ }
+
+ //Post action for printing the PDF documents
+ public IActionResult OnPostPrintImages([FromBody] jsonObjects responseData)
+ {
+ PdfRenderer pdfviewer = new PdfRenderer(_cache);
+ var jsonObject = JsonConverterstring(responseData);
+ object pageImage = pdfviewer.GetPrintImage(jsonObject);
+ return Content(JsonConvert.SerializeObject(pageImage));
+ }
+
+ //Gets the path of the PDF document
+ private string GetDocumentPath(string document)
+ {
+ string documentPath = string.Empty;
+ if (!System.IO.File.Exists(document))
+ {
+ string basePath = _hostingEnvironment.WebRootPath;
+ string dataPath = string.Empty;
+ dataPath = basePath + "/";
+ if (System.IO.File.Exists(dataPath + (document)))
+ documentPath = dataPath + document;
+ }
+ else
+ {
+ documentPath = document;
+ }
+ return documentPath;
+ }
+ }
+
+ public class jsonObjects
+ {
+ public string document { get; set; }
+ public string password { get; set; }
+ public string zoomFactor { get; set; }
+ public string isFileName { get; set; }
+ public string xCoordinate { get; set; }
+ public string yCoordinate { get; set; }
+ public string pageNumber { get; set; }
+ public string documentId { get; set; }
+ public string hashId { get; set; }
+ public string sizeX { get; set; }
+ public string sizeY { get; set; }
+ public string startPage { get; set; }
+ public string endPage { get; set; }
+ public string stampAnnotations { get; set; }
+ public string textMarkupAnnotations { get; set; }
+ public string stickyNotesAnnotation { get; set; }
+ public string shapeAnnotations { get; set; }
+ public string measureShapeAnnotations { get; set; }
+ public string action { get; set; }
+ public string pageStartIndex { get; set; }
+ public string pageEndIndex { get; set; }
+ public string fileName { get; set; }
+ public string elementId { get; set; }
+ public string pdfAnnotation { get; set; }
+ public string importPageList { get; set; }
+ public string uniqueId { get; set; }
+ public string data { get; set; }
+ public string viewPortWidth { get; set; }
+ public string viewPortHeight { get; set; }
+ public string tilecount { get; set; }
+ public bool isCompletePageSizeNotReceived { get; set; }
+ public string freeTextAnnotation { get; set; }
+ public string signatureData { get; set; }
+ public string fieldsData { get; set; }
+ public string FormDesigner { get; set; }
+ public string inkSignatureData { get; set; }
+ public bool hideEmptyDigitalSignatureFields { get; set; }
+ public bool showDigitalSignatureAppearance { get; set; }
+ public bool digitalSignaturePresent { get; set; }
+ public string tileXCount { get; set; }
+ public string tileYCount { get; set; }
+ public string digitalSignaturePageList { get; set; }
+ public string annotationCollection { get; set; }
+ public string annotationsPageList { get; set; }
+ public string formFieldsPageList { get; set; }
+ public bool isAnnotationsExist { get; set; }
+ public bool isFormFieldAnnotationsExist { get; set; }
+ public string documentLiveCount { get; set; }
+ public string annotationDataFormat { get; set; }
+ public string importedData { get; set; }
+ }
+}
\ No newline at end of file
diff --git a/How to/Line Angle Constraint/Pages/Privacy.cshtml b/How to/Line Angle Constraint/Pages/Privacy.cshtml
new file mode 100644
index 0000000..46ba966
--- /dev/null
+++ b/How to/Line Angle Constraint/Pages/Privacy.cshtml
@@ -0,0 +1,8 @@
+@page
+@model PrivacyModel
+@{
+ ViewData["Title"] = "Privacy Policy";
+}
+@ViewData["Title"]
+
+Use this page to detail your site's privacy policy.
diff --git a/How to/Line Angle Constraint/Pages/Privacy.cshtml.cs b/How to/Line Angle Constraint/Pages/Privacy.cshtml.cs
new file mode 100644
index 0000000..f9a85a1
--- /dev/null
+++ b/How to/Line Angle Constraint/Pages/Privacy.cshtml.cs
@@ -0,0 +1,19 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.RazorPages;
+
+namespace PDFViewerSample.Pages
+{
+ public class PrivacyModel : PageModel
+ {
+ private readonly ILogger _logger;
+
+ public PrivacyModel(ILogger logger)
+ {
+ _logger = logger;
+ }
+
+ public void OnGet()
+ {
+ }
+ }
+}
\ No newline at end of file
diff --git a/How to/Line Angle Constraint/Pages/Shared/_Layout.cshtml b/How to/Line Angle Constraint/Pages/Shared/_Layout.cshtml
new file mode 100644
index 0000000..a3810b4
--- /dev/null
+++ b/How to/Line Angle Constraint/Pages/Shared/_Layout.cshtml
@@ -0,0 +1,51 @@
+
+
+
+
+
+ @ViewData["Title"] - PDFViewerSample
+
+
+
+
+
+
+
+
+
+
+ @RenderBody()
+
+
+
+
+
+ @await RenderSectionAsync("Scripts", required: false)
+
+
+
+
\ No newline at end of file
diff --git a/How to/Line Angle Constraint/Pages/Shared/_Layout.cshtml.css b/How to/Line Angle Constraint/Pages/Shared/_Layout.cshtml.css
new file mode 100644
index 0000000..a72cbea
--- /dev/null
+++ b/How to/Line Angle Constraint/Pages/Shared/_Layout.cshtml.css
@@ -0,0 +1,48 @@
+/* Please see documentation at https://docs.microsoft.com/aspnet/core/client-side/bundling-and-minification
+for details on configuring this project to bundle and minify static web assets. */
+
+a.navbar-brand {
+ white-space: normal;
+ text-align: center;
+ word-break: break-all;
+}
+
+a {
+ color: #0077cc;
+}
+
+.btn-primary {
+ color: #fff;
+ background-color: #1b6ec2;
+ border-color: #1861ac;
+}
+
+.nav-pills .nav-link.active, .nav-pills .show > .nav-link {
+ color: #fff;
+ background-color: #1b6ec2;
+ border-color: #1861ac;
+}
+
+.border-top {
+ border-top: 1px solid #e5e5e5;
+}
+.border-bottom {
+ border-bottom: 1px solid #e5e5e5;
+}
+
+.box-shadow {
+ box-shadow: 0 .25rem .75rem rgba(0, 0, 0, .05);
+}
+
+button.accept-policy {
+ font-size: 1rem;
+ line-height: inherit;
+}
+
+.footer {
+ position: absolute;
+ bottom: 0;
+ width: 100%;
+ white-space: nowrap;
+ line-height: 60px;
+}
diff --git a/How to/Line Angle Constraint/Pages/Shared/_ValidationScriptsPartial.cshtml b/How to/Line Angle Constraint/Pages/Shared/_ValidationScriptsPartial.cshtml
new file mode 100644
index 0000000..5a16d80
--- /dev/null
+++ b/How to/Line Angle Constraint/Pages/Shared/_ValidationScriptsPartial.cshtml
@@ -0,0 +1,2 @@
+
+
diff --git a/How to/Line Angle Constraint/Pages/_ViewImports.cshtml b/How to/Line Angle Constraint/Pages/_ViewImports.cshtml
new file mode 100644
index 0000000..51b8015
--- /dev/null
+++ b/How to/Line Angle Constraint/Pages/_ViewImports.cshtml
@@ -0,0 +1,4 @@
+@using PDFViewerSample
+@namespace PDFViewerSample.Pages
+@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
+@addTagHelper *, Syncfusion.EJ2
\ No newline at end of file
diff --git a/How to/Line Angle Constraint/Pages/_ViewStart.cshtml b/How to/Line Angle Constraint/Pages/_ViewStart.cshtml
new file mode 100644
index 0000000..a5f1004
--- /dev/null
+++ b/How to/Line Angle Constraint/Pages/_ViewStart.cshtml
@@ -0,0 +1,3 @@
+@{
+ Layout = "_Layout";
+}
diff --git a/How to/Line Angle Constraint/Program.cs b/How to/Line Angle Constraint/Program.cs
new file mode 100644
index 0000000..bc275e4
--- /dev/null
+++ b/How to/Line Angle Constraint/Program.cs
@@ -0,0 +1,25 @@
+var builder = WebApplication.CreateBuilder(args);
+
+// Add services to the container.
+builder.Services.AddRazorPages();
+
+var app = builder.Build();
+
+// Configure the HTTP request pipeline.
+if (!app.Environment.IsDevelopment())
+{
+ app.UseExceptionHandler("/Error");
+ // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
+ app.UseHsts();
+}
+
+app.UseHttpsRedirection();
+app.UseStaticFiles();
+
+app.UseRouting();
+
+app.UseAuthorization();
+
+app.MapRazorPages();
+
+app.Run();
diff --git a/How to/Line Angle Constraint/Properties/launchSettings.json b/How to/Line Angle Constraint/Properties/launchSettings.json
new file mode 100644
index 0000000..d52972e
--- /dev/null
+++ b/How to/Line Angle Constraint/Properties/launchSettings.json
@@ -0,0 +1,28 @@
+{
+ "iisSettings": {
+ "windowsAuthentication": false,
+ "anonymousAuthentication": true,
+ "iisExpress": {
+ "applicationUrl": "http://localhost:38233",
+ "sslPort": 44357
+ }
+ },
+ "profiles": {
+ "PDFViewerSample": {
+ "commandName": "Project",
+ "dotnetRunMessages": true,
+ "launchBrowser": true,
+ "applicationUrl": "https://localhost:7173;http://localhost:5173",
+ "environmentVariables": {
+ "ASPNETCORE_ENVIRONMENT": "Development"
+ }
+ },
+ "IIS Express": {
+ "commandName": "IISExpress",
+ "launchBrowser": true,
+ "environmentVariables": {
+ "ASPNETCORE_ENVIRONMENT": "Development"
+ }
+ }
+ }
+}
diff --git a/How to/Line Angle Constraint/README.md b/How to/Line Angle Constraint/README.md
new file mode 100644
index 0000000..30d532e
--- /dev/null
+++ b/How to/Line Angle Constraint/README.md
@@ -0,0 +1,26 @@
+# Create a simple PDF Viewer
+This example shows how to create a simple PDF Viewer application.
+
+## Project pre-requisites
+One of the the following .NET SDK is required to develop and run the Syncfusion® UI controls for ASP.NET Core application.
+
+* NET 6.0 SDK
+* NET 5.0 SDK
+* NET Core SDK 3.1
+* NET Core SDK 2.0
+* NET 4.5 Framework
+
+If you are planning to use Visual Studio to develop ASP.NET Core Applications.
+
+.NET 6.0 requires Visual Studio 2022 17.0 or later.
+.NET 5.0 requires Visual Studio 2019 16.8 or later.
+.NET Core SDK 3.1 requires Visual Studio 2019 16.4 or later.
+.NET Core SDK 2.0 requires Visual Studio 2017 15.7 or later.
+.NET 4.5 Framework requires Visual Studio 2015 20.1 or later
+
+## Running the sample
+Execute the following commands to run the sample via command prompt window.
+
+* dotnet restore
+* dotnet run
+
diff --git a/How to/Line Angle Constraint/appsettings.Development.json b/How to/Line Angle Constraint/appsettings.Development.json
new file mode 100644
index 0000000..770d3e9
--- /dev/null
+++ b/How to/Line Angle Constraint/appsettings.Development.json
@@ -0,0 +1,9 @@
+{
+ "DetailedErrors": true,
+ "Logging": {
+ "LogLevel": {
+ "Default": "Information",
+ "Microsoft.AspNetCore": "Warning"
+ }
+ }
+}
diff --git a/How to/Line Angle Constraint/appsettings.json b/How to/Line Angle Constraint/appsettings.json
new file mode 100644
index 0000000..10f68b8
--- /dev/null
+++ b/How to/Line Angle Constraint/appsettings.json
@@ -0,0 +1,9 @@
+{
+ "Logging": {
+ "LogLevel": {
+ "Default": "Information",
+ "Microsoft.AspNetCore": "Warning"
+ }
+ },
+ "AllowedHosts": "*"
+}
diff --git a/How to/Line Angle Constraint/wwwroot/ej2-pdfviewer-lib/pdfium.js b/How to/Line Angle Constraint/wwwroot/ej2-pdfviewer-lib/pdfium.js
new file mode 100644
index 0000000..207f7d9
--- /dev/null
+++ b/How to/Line Angle Constraint/wwwroot/ej2-pdfviewer-lib/pdfium.js
@@ -0,0 +1,4065 @@
+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 ENVIRONMENT_IS_WEB = typeof window == "object";
+ var ENVIRONMENT_IS_WORKER = typeof WorkerGlobalScope != "undefined";
+ var ENVIRONMENT_IS_NODE = typeof process == "object" && process.versions && process.versions.node && process.type != "renderer";
+ var arguments_ = [];
+ var thisProgram = "./this.program";
+ var quit_ = (status, toThrow) => {
+ throw toThrow
+ };
+ var _scriptName = typeof document != "undefined" ? document.currentScript && document.currentScript.src : undefined;
+ if (typeof __filename != "undefined") {
+ _scriptName = __filename
+ } else if (ENVIRONMENT_IS_WORKER) {
+ _scriptName = self.location.href
+ }
+ var scriptDirectory = "";
+
+ function locateFile(path) {
+ if (Module["locateFile"]) {
+ return Module["locateFile"](path, scriptDirectory)
+ }
+ return scriptDirectory + path
+ }
+ var readAsync, readBinary;
+ if (ENVIRONMENT_IS_NODE) {
+ var fs = require("fs");
+ scriptDirectory = __dirname + "/";
+ readBinary = filename => {
+ filename = isFileURI(filename) ? new URL(filename) : filename;
+ var ret = fs.readFileSync(filename);
+ return ret
+ };
+ readAsync = async (filename, binary = true) => {
+ filename = isFileURI(filename) ? new URL(filename) : filename;
+ var ret = fs.readFileSync(filename, binary ? undefined : "utf8");
+ return ret
+ };
+ if (process.argv.length > 1) {
+ thisProgram = process.argv[1].replace(/\\/g, "/")
+ }
+ arguments_ = process.argv.slice(2);
+ if (typeof module != "undefined") {
+ module["exports"] = Module
+ }
+ quit_ = (status, toThrow) => {
+ process.exitCode = status;
+ throw toThrow
+ }
+ } else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
+ try {
+ scriptDirectory = new URL(".", _scriptName).href
+ } catch {} {
+ if (ENVIRONMENT_IS_WORKER) {
+ readBinary = url => {
+ var xhr = new XMLHttpRequest;
+ xhr.open("GET", url, false);
+ xhr.responseType = "arraybuffer";
+ xhr.send(null);
+ return new Uint8Array(xhr.response)
+ }
+ }
+ readAsync = async url => {
+ if (isFileURI(url)) {
+ return new Promise((resolve, reject) => {
+ var xhr = new XMLHttpRequest;
+ xhr.open("GET", url, true);
+ xhr.responseType = "arraybuffer";
+ xhr.onload = () => {
+ if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
+ resolve(xhr.response);
+ return
+ }
+ reject(xhr.status)
+ };
+ xhr.onerror = reject;
+ xhr.send(null)
+ })
+ }
+ var response = await fetch(url, {
+ credentials: "same-origin"
+ });
+ if (response.ok) {
+ return response.arrayBuffer()
+ }
+ throw new Error(response.status + " : " + response.url)
+ }
+ }
+ } else {}
+ var out = console.log.bind(console);
+ var err = console.error.bind(console);
+ var wasmBinary;
+ var ABORT = false;
+ var isFileURI = filename => filename.startsWith("file://");
+ var wasmMemory;
+ var HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAPF64;
+ var HEAP64, HEAPU64;
+ var runtimeInitialized = false;
+
+ function updateMemoryViews() {
+ var b = wasmMemory.buffer;
+ Module["HEAP8"] = HEAP8 = new Int8Array(b);
+ Module["HEAP16"] = HEAP16 = new Int16Array(b);
+ Module["HEAPU8"] = HEAPU8 = new Uint8Array(b);
+ Module["HEAPU16"] = HEAPU16 = new Uint16Array(b);
+ Module["HEAP32"] = HEAP32 = new Int32Array(b);
+ Module["HEAPU32"] = HEAPU32 = new Uint32Array(b);
+ Module["HEAPF32"] = HEAPF32 = new Float32Array(b);
+ Module["HEAPF64"] = HEAPF64 = new Float64Array(b);
+ Module["HEAP64"] = HEAP64 = new BigInt64Array(b);
+ Module["HEAPU64"] = HEAPU64 = new BigUint64Array(b)
+ }
+
+ function preRun() {
+ if (Module["preRun"]) {
+ if (typeof Module["preRun"] == "function") Module["preRun"] = [Module["preRun"]];
+ while (Module["preRun"].length) {
+ addOnPreRun(Module["preRun"].shift())
+ }
+ }
+ callRuntimeCallbacks(onPreRuns)
+ }
+
+ function initRuntime() {
+ runtimeInitialized = true;
+ if (!Module["noFSInit"] && !FS.initialized) FS.init();
+ TTY.init();
+ wasmExports["__wasm_call_ctors"]();
+ FS.ignorePermissions = false
+ }
+
+ function postRun() {
+ if (Module["postRun"]) {
+ if (typeof Module["postRun"] == "function") Module["postRun"] = [Module["postRun"]];
+ while (Module["postRun"].length) {
+ addOnPostRun(Module["postRun"].shift())
+ }
+ }
+ callRuntimeCallbacks(onPostRuns)
+ }
+ var runDependencies = 0;
+ var dependenciesFulfilled = null;
+
+ function addRunDependency(id) {
+ runDependencies++;
+ if(Module["monitorRunDependencies"]){
+ Module["monitorRunDependencies"](runDependencies)
+ }
+ }
+
+ function removeRunDependency(id) {
+ runDependencies--;
+ if (Module["monitorRunDependencies"]) {
+ Module["monitorRunDependencies"](runDependencies);
+ }
+ if (runDependencies == 0) {
+ if (dependenciesFulfilled) {
+ var callback = dependenciesFulfilled;
+ dependenciesFulfilled = null;
+ callback()
+ }
+ }
+ }
+
+ function abort(what) {
+ if (Module["onAbort"]) {
+ Module["onAbort"](what)
+ }
+ what = "Aborted(" + what + ")";
+ err(what);
+ ABORT = true;
+ 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)
+ }
+ var wasmBinaryFile;
+ function findWasmBinary() {
+ var wasmBinaryFile;
+ if (PDFiumModule.url) {
+ wasmBinaryFile = PDFiumModule.url + '/pdfium.wasm';
+ }
+ else {
+ wasmBinaryFile = 'pdfium.wasm';
+ }
+ if (!isDataURI(wasmBinaryFile)) {
+ wasmBinaryFile = locateFile(wasmBinaryFile)
+ }
+ return locateFile(wasmBinaryFile)
+ }
+
+ function getBinarySync(file) {
+ if (file == wasmBinaryFile && wasmBinary) {
+ return new Uint8Array(wasmBinary)
+ }
+ if (readBinary) {
+ return readBinary(file)
+ }
+ throw "both async and sync fetching of the wasm failed"
+ }
+ async function getWasmBinary(binaryFile) {
+ if (!wasmBinary) {
+ try {
+ var response = await readAsync(binaryFile);
+ return new Uint8Array(response)
+ } catch {}
+ }
+ return getBinarySync(binaryFile)
+ }
+ async function instantiateArrayBuffer(binaryFile, imports) {
+ try {
+ var binary = await getWasmBinary(binaryFile);
+ var instance = await WebAssembly.instantiate(binary, imports);
+ return instance
+ } catch (reason) {
+ err(`failed to asynchronously prepare wasm: ${reason}`);
+ abort(reason)
+ }
+ }
+ async function instantiateAsync(binary, binaryFile, imports) {
+ if (!binary && typeof WebAssembly.instantiateStreaming == "function" && !isFileURI(binaryFile) && !ENVIRONMENT_IS_NODE) {
+ try {
+ var response = fetch(binaryFile, {
+ credentials: "same-origin"
+ });
+ var instantiationResult = await WebAssembly.instantiateStreaming(response, imports);
+ return instantiationResult
+ } catch (reason) {
+ err(`wasm streaming compile failed: ${reason}`);
+ err("falling back to ArrayBuffer instantiation")
+ }
+ }
+ return instantiateArrayBuffer(binaryFile, imports)
+ }
+
+ function getWasmImports() {
+ return {
+ env: wasmImports,
+ wasi_snapshot_preview1: wasmImports
+ }
+ }
+ async function createWasm() {
+ function receiveInstance(instance, module) {
+ wasmExports = instance.exports;
+ wasmExports = applySignatureConversions(wasmExports);
+ wasmMemory = wasmExports["memory"];
+ updateMemoryViews();
+ wasmTable = wasmExports["__indirect_function_table"];
+ assignWasmExports(wasmExports);
+ removeRunDependency("wasm-instantiate");
+ return wasmExports
+ }
+ addRunDependency("wasm-instantiate");
+
+ function receiveInstantiationResult(result) {
+ return receiveInstance(result["instance"])
+ }
+ var info = getWasmImports();
+ if (Module["instantiateWasm"]) {
+ return new Promise((resolve, reject) => {
+ Module["instantiateWasm"](info, (mod, inst) => {
+ resolve(receiveInstance(mod, inst))
+ })
+ })
+ }
+ wasmBinaryFile = findWasmBinary();
+ var result = await instantiateAsync(wasmBinary, wasmBinaryFile, info);
+ var exports = receiveInstantiationResult(result);
+ return exports
+ }
+ class ExitStatus {
+ name = "ExitStatus";
+ constructor(status) {
+ this.message = `Program terminated with exit(${status})`;
+ this.status = status
+ }
+ }
+ var callRuntimeCallbacks = callbacks => {
+ while (callbacks.length > 0) {
+ callbacks.shift()(Module)
+ }
+ };
+ var onPostRuns = [];
+ var addOnPostRun = cb => onPostRuns.push(cb);
+ var onPreRuns = [];
+ var addOnPreRun = cb => onPreRuns.push(cb);
+ var noExitRuntime = true;
+
+ function setValue(ptr, value, type = "i8") {
+ if (type.endsWith("*")) type = "*";
+ switch (type) {
+ case "i1":
+ HEAP8[ptr >>> 0] = value;
+ break;
+ case "i8":
+ HEAP8[ptr >>> 0] = value;
+ break;
+ case "i16":
+ HEAP16[ptr >>> 1 >>> 0] = value;
+ break;
+ case "i32":
+ HEAP32[ptr >>> 2 >>> 0] = value;
+ break;
+ case "i64":
+ HEAP64[ptr >>> 3 >>> 0] = BigInt(value);
+ break;
+ case "float":
+ HEAPF32[ptr >>> 2 >>> 0] = value;
+ break;
+ case "double":
+ HEAPF64[ptr >>> 3 >>> 0] = value;
+ break;
+ case "*":
+ HEAPU32[ptr >>> 2 >>> 0] = value;
+ break;
+ default:
+ abort(`invalid type for setValue: ${type}`)
+ }
+ }
+ var stackRestore = val => __emscripten_stack_restore(val);
+ var stackSave = () => _emscripten_stack_get_current();
+ var syscallGetVarargI = () => {
+ var ret = HEAP32[+SYSCALLS.varargs >>> 2 >>> 0];
+ SYSCALLS.varargs += 4;
+ return ret
+ };
+ var syscallGetVarargP = syscallGetVarargI;
+ 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.slice(-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.slice(0, -1)
+ }
+ return root + dir
+ },
+ basename: path => path && path.match(/([^\/]+|\/)\/*$/)[1],
+ join: (...paths) => PATH.normalize(paths.join("/")),
+ join2: (l, r) => PATH.normalize(l + "/" + r)
+ };
+ var initRandomFill = () => {
+ if (ENVIRONMENT_IS_NODE) {
+ var nodeCrypto = require("crypto");
+ return view => nodeCrypto.randomFillSync(view)
+ }
+ return view => crypto.getRandomValues(view)
+ };
+ var randomFill = view => {
+ (randomFill = initRandomFill())(view)
+ };
+ var PATH_FS = {
+ resolve: (...args) => {
+ var resolvedPath = "",
+ resolvedAbsolute = false;
+ for (var i = args.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+ var path = i >= 0 ? args[i] : FS.cwd();
+ if (typeof path != "string") {
+ throw new TypeError("Arguments to path.resolve must be strings")
+ } else if (!path) {
+ return ""
+ }
+ resolvedPath = path + "/" + resolvedPath;
+ resolvedAbsolute = PATH.isAbs(path)
+ }
+ resolvedPath = PATH.normalizeArray(resolvedPath.split("/").filter(p => !!p), !resolvedAbsolute).join("/");
+ return (resolvedAbsolute ? "/" : "") + resolvedPath || "."
+ },
+ relative: (from, to) => {
+ from = PATH_FS.resolve(from).slice(1);
+ to = PATH_FS.resolve(to).slice(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("/")
+ }
+ };
+ var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder : undefined;
+ var UTF8ArrayToString = (heapOrArray, idx = 0, maxBytesToRead = NaN) => {
+ idx >>>= 0;
+ 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
+ };
+ var FS_stdin_getChar_buffer = [];
+ var 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 stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => {
+ outIdx >>>= 0;
+ if (!(maxBytesToWrite > 0)) return 0;
+ var startIdx = outIdx;
+ var endIdx = outIdx + maxBytesToWrite - 1;
+ for (var i = 0; i < str.length; ++i) {
+ var u = str.codePointAt(i);
+ if (u <= 127) {
+ if (outIdx >= endIdx) break;
+ heap[outIdx++ >>> 0] = u
+ } else if (u <= 2047) {
+ if (outIdx + 1 >= endIdx) break;
+ heap[outIdx++ >>> 0] = 192 | u >> 6;
+ heap[outIdx++ >>> 0] = 128 | u & 63
+ } else if (u <= 65535) {
+ if (outIdx + 2 >= endIdx) break;
+ heap[outIdx++ >>> 0] = 224 | u >> 12;
+ heap[outIdx++ >>> 0] = 128 | u >> 6 & 63;
+ heap[outIdx++ >>> 0] = 128 | u & 63
+ } else {
+ if (outIdx + 3 >= endIdx) break;
+ heap[outIdx++ >>> 0] = 240 | u >> 18;
+ heap[outIdx++ >>> 0] = 128 | u >> 12 & 63;
+ heap[outIdx++ >>> 0] = 128 | u >> 6 & 63;
+ heap[outIdx++ >>> 0] = 128 | u & 63;
+ i++
+ }
+ }
+ heap[outIdx >>> 0] = 0;
+ return outIdx - startIdx
+ };
+ var intArrayFromString = (stringy, dontAddNull, length) => {
+ var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1;
+ var u8array = new Array(len);
+ var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length);
+ if (dontAddNull) u8array.length = numBytesWritten;
+ return u8array
+ };
+ var FS_stdin_getChar = () => {
+ if (!FS_stdin_getChar_buffer.length) {
+ var result = null;
+ if (ENVIRONMENT_IS_NODE) {
+ var BUFSIZE = 256;
+ var buf = Buffer.alloc(BUFSIZE);
+ var bytesRead = 0;
+ var fd = process.stdin.fd;
+ try {
+ bytesRead = fs.readSync(fd, buf, 0, BUFSIZE)
+ } catch (e) {
+ if (e.toString().includes("EOF")) bytesRead = 0;
+ else throw e
+ }
+ if (bytesRead > 0) {
+ result = buf.slice(0, bytesRead).toString("utf-8")
+ }
+ } else if (typeof window != "undefined" && typeof window.prompt == "function") {
+ result = window.prompt("Input: ");
+ if (result !== null) {
+ result += "\n"
+ }
+ } else {}
+ if (!result) {
+ return null
+ }
+ FS_stdin_getChar_buffer = intArrayFromString(result, true)
+ }
+ return FS_stdin_getChar_buffer.shift()
+ };
+ var TTY = {
+ ttys: [],
+ init() {},
+ shutdown() {},
+ register(dev, ops) {
+ TTY.ttys[dev] = {
+ input: [],
+ output: [],
+ ops
+ };
+ FS.registerDevice(dev, TTY.stream_ops)
+ },
+ stream_ops: {
+ open(stream) {
+ var tty = TTY.ttys[stream.node.rdev];
+ if (!tty) {
+ throw new FS.ErrnoError(43)
+ }
+ stream.tty = tty;
+ stream.seekable = false
+ },
+ close(stream) {
+ stream.tty.ops.fsync(stream.tty)
+ },
+ fsync(stream) {
+ stream.tty.ops.fsync(stream.tty)
+ },
+ read(stream, buffer, offset, length, pos) {
+ if (!stream.tty || !stream.tty.ops.get_char) {
+ throw new FS.ErrnoError(60)
+ }
+ var bytesRead = 0;
+ for (var i = 0; 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.atime = Date.now()
+ }
+ return bytesRead
+ },
+ write(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.mtime = stream.node.ctime = Date.now()
+ }
+ return i
+ }
+ },
+ default_tty_ops: {
+ get_char(tty) {
+ return FS_stdin_getChar()
+ },
+ put_char(tty, val) {
+ if (val === null || val === 10) {
+ out(UTF8ArrayToString(tty.output));
+ tty.output = []
+ } else {
+ if (val != 0) tty.output.push(val)
+ }
+ },
+ fsync(tty) {
+ if (tty.output && tty.output.length > 0) {
+ out(UTF8ArrayToString(tty.output));
+ tty.output = []
+ }
+ },
+ ioctl_tcgets(tty) {
+ return {
+ c_iflag: 25856,
+ c_oflag: 5,
+ c_cflag: 191,
+ c_lflag: 35387,
+ c_cc: [3, 28, 127, 21, 4, 0, 1, 0, 17, 19, 26, 0, 18, 15, 23, 22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+ }
+ },
+ ioctl_tcsets(tty, optional_actions, data) {
+ return 0
+ },
+ ioctl_tiocgwinsz(tty) {
+ return [24, 80]
+ }
+ },
+ default_tty1_ops: {
+ put_char(tty, val) {
+ if (val === null || val === 10) {
+ err(UTF8ArrayToString(tty.output));
+ tty.output = []
+ } else {
+ if (val != 0) tty.output.push(val)
+ }
+ },
+ fsync(tty) {
+ if (tty.output && tty.output.length > 0) {
+ err(UTF8ArrayToString(tty.output));
+ tty.output = []
+ }
+ }
+ }
+ };
+ var zeroMemory = (ptr, size) => HEAPU8.fill(0, ptr, ptr + size);
+ var alignMemory = (size, alignment) => Math.ceil(size / alignment) * alignment;
+ var mmapAlloc = size => {
+ size = alignMemory(size, 65536);
+ var ptr = _emscripten_builtin_memalign(65536, size);
+ if (ptr) zeroMemory(ptr, size);
+ return ptr
+ };
+ var MEMFS = {
+ ops_table: null,
+ mount(mount) {
+ return MEMFS.createNode(null, "/", 16895, 0)
+ },
+ createNode(parent, name, mode, dev) {
+ if (FS.isBlkdev(mode) || FS.isFIFO(mode)) {
+ throw new FS.ErrnoError(63)
+ }
+ MEMFS.ops_table = {
+ dir: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr,
+ lookup: MEMFS.node_ops.lookup,
+ mknod: MEMFS.node_ops.mknod,
+ rename: MEMFS.node_ops.rename,
+ unlink: MEMFS.node_ops.unlink,
+ rmdir: MEMFS.node_ops.rmdir,
+ readdir: MEMFS.node_ops.readdir,
+ symlink: MEMFS.node_ops.symlink
+ },
+ stream: {
+ llseek: MEMFS.stream_ops.llseek
+ }
+ },
+ file: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr
+ },
+ stream: {
+ llseek: MEMFS.stream_ops.llseek,
+ read: MEMFS.stream_ops.read,
+ write: MEMFS.stream_ops.write,
+ mmap: MEMFS.stream_ops.mmap,
+ msync: MEMFS.stream_ops.msync
+ }
+ },
+ link: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr,
+ readlink: MEMFS.node_ops.readlink
+ },
+ stream: {}
+ },
+ chrdev: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr
+ },
+ stream: FS.chrdev_stream_ops
+ }
+ };
+ var node = FS.createNode(parent, name, mode, dev);
+ if (FS.isDir(node.mode)) {
+ node.node_ops = MEMFS.ops_table.dir.node;
+ node.stream_ops = MEMFS.ops_table.dir.stream;
+ node.contents = {}
+ } else if (FS.isFile(node.mode)) {
+ node.node_ops = MEMFS.ops_table.file.node;
+ node.stream_ops = MEMFS.ops_table.file.stream;
+ node.usedBytes = 0;
+ node.contents = null
+ } else if (FS.isLink(node.mode)) {
+ node.node_ops = MEMFS.ops_table.link.node;
+ node.stream_ops = MEMFS.ops_table.link.stream
+ } else if (FS.isChrdev(node.mode)) {
+ node.node_ops = MEMFS.ops_table.chrdev.node;
+ node.stream_ops = MEMFS.ops_table.chrdev.stream
+ }
+ node.atime = node.mtime = node.ctime = Date.now();
+ if (parent) {
+ parent.contents[name] = node;
+ parent.atime = parent.mtime = parent.ctime = node.atime
+ }
+ return node
+ },
+ getFileDataAsTypedArray(node) {
+ if (!node.contents) return new Uint8Array(0);
+ if (node.contents.subarray) return node.contents.subarray(0, node.usedBytes);
+ return new Uint8Array(node.contents)
+ },
+ expandFileStorage(node, newCapacity) {
+ var prevCapacity = node.contents ? node.contents.length : 0;
+ if (prevCapacity >= newCapacity) return;
+ var CAPACITY_DOUBLING_MAX = 1024 * 1024;
+ newCapacity = Math.max(newCapacity, prevCapacity * (prevCapacity < 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(node, newSize) {
+ if (node.usedBytes == newSize) return;
+ if (newSize == 0) {
+ node.contents = null;
+ node.usedBytes = 0
+ } else {
+ var oldContents = node.contents;
+ node.contents = new Uint8Array(newSize);
+ if (oldContents) {
+ node.contents.set(oldContents.subarray(0, Math.min(newSize, node.usedBytes)))
+ }
+ node.usedBytes = newSize
+ }
+ },
+ node_ops: {
+ getattr(node) {
+ var attr = {};
+ attr.dev = FS.isChrdev(node.mode) ? node.id : 1;
+ attr.ino = node.id;
+ attr.mode = node.mode;
+ attr.nlink = 1;
+ attr.uid = 0;
+ attr.gid = 0;
+ attr.rdev = node.rdev;
+ if (FS.isDir(node.mode)) {
+ attr.size = 4096
+ } else if (FS.isFile(node.mode)) {
+ attr.size = node.usedBytes
+ } else if (FS.isLink(node.mode)) {
+ attr.size = node.link.length
+ } else {
+ attr.size = 0
+ }
+ attr.atime = new Date(node.atime);
+ attr.mtime = new Date(node.mtime);
+ attr.ctime = new Date(node.ctime);
+ attr.blksize = 4096;
+ attr.blocks = Math.ceil(attr.size / attr.blksize);
+ return attr
+ },
+ setattr(node, attr) {
+ for (const key of ["mode", "atime", "mtime", "ctime"]) {
+ if (attr[key] != null) {
+ node[key] = attr[key]
+ }
+ }
+ if (attr.size !== undefined) {
+ MEMFS.resizeFileStorage(node, attr.size)
+ }
+ },
+ lookup(parent, name) {
+ throw MEMFS.doesNotExistError
+ },
+ mknod(parent, name, mode, dev) {
+ return MEMFS.createNode(parent, name, mode, dev)
+ },
+ rename(old_node, new_dir, new_name) {
+ var new_node;
+ try {
+ new_node = FS.lookupNode(new_dir, new_name)
+ } catch (e) {}
+ if (new_node) {
+ if (FS.isDir(old_node.mode)) {
+ for (var i in new_node.contents) {
+ throw new FS.ErrnoError(55)
+ }
+ }
+ FS.hashRemoveNode(new_node)
+ }
+ delete old_node.parent.contents[old_node.name];
+ new_dir.contents[new_name] = old_node;
+ old_node.name = new_name;
+ new_dir.ctime = new_dir.mtime = old_node.parent.ctime = old_node.parent.mtime = Date.now()
+ },
+ unlink(parent, name) {
+ delete parent.contents[name];
+ parent.ctime = parent.mtime = Date.now()
+ },
+ rmdir(parent, name) {
+ var node = FS.lookupNode(parent, name);
+ for (var i in node.contents) {
+ throw new FS.ErrnoError(55)
+ }
+ delete parent.contents[name];
+ parent.ctime = parent.mtime = Date.now()
+ },
+ readdir(node) {
+ return [".", "..", ...Object.keys(node.contents)]
+ },
+ symlink(parent, newname, oldpath) {
+ var node = MEMFS.createNode(parent, newname, 511 | 40960, 0);
+ node.link = oldpath;
+ return node
+ },
+ readlink(node) {
+ if (!FS.isLink(node.mode)) {
+ throw new FS.ErrnoError(28)
+ }
+ return node.link
+ }
+ },
+ stream_ops: {
+ read(stream, buffer, offset, length, position) {
+ var contents = stream.node.contents;
+ if (position >= stream.node.usedBytes) return 0;
+ var size = Math.min(stream.node.usedBytes - position, length);
+ if (size > 8 && contents.subarray) {
+ buffer.set(contents.subarray(position, position + size), offset)
+ } else {
+ for (var i = 0; i < size; i++) buffer[offset + i] = contents[position + i]
+ }
+ return size
+ },
+ write(stream, buffer, offset, length, position, canOwn) {
+ if (buffer.buffer === HEAP8.buffer) {
+ canOwn = false
+ }
+ if (!length) return 0;
+ var node = stream.node;
+ node.mtime = node.ctime = 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(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
+ },
+ mmap(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 && contents.buffer === HEAP8.buffer) {
+ allocated = false;
+ ptr = contents.byteOffset
+ } else {
+ allocated = true;
+ ptr = mmapAlloc(length);
+ if (!ptr) {
+ throw new FS.ErrnoError(48)
+ }
+ if (contents) {
+ 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)
+ }
+ }
+ HEAP8.set(contents, ptr >>> 0)
+ }
+ }
+ return {
+ ptr,
+ allocated
+ }
+ },
+ msync(stream, buffer, offset, length, mmapFlags) {
+ MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false);
+ return 0
+ }
+ }
+ };
+ var asyncLoad = async url => {
+ var arrayBuffer = await readAsync(url);
+ return new Uint8Array(arrayBuffer)
+ };
+ var FS_createDataFile = (...args) => FS.createDataFile(...args);
+ var getUniqueRunDependency = id => id;
+ var preloadPlugins = [];
+ var FS_handledByPreloadPlugin = (byteArray, fullname, finish, onerror) => {
+ if (typeof Browser != "undefined") Browser.init();
+ var handled = false;
+ preloadPlugins.forEach(plugin => {
+ if (handled) return;
+ if (plugin["canHandle"](fullname)) {
+ plugin["handle"](byteArray, fullname, finish, onerror);
+ handled = true
+ }
+ });
+ return handled
+ };
+ var FS_createPreloadedFile = (parent, name, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn, preFinish) => {
+ var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent;
+ var dep = getUniqueRunDependency(`cp ${fullname}`);
+
+ function processData(byteArray) {
+ function finish(byteArray) {
+ if(preFinish) preFinish();
+ if (!dontCreateFile) {
+ FS_createDataFile(parent, name, byteArray, canRead, canWrite, canOwn)
+ }
+ if(onload) onload();
+ removeRunDependency(dep)
+ }
+ if (FS_handledByPreloadPlugin(byteArray, fullname, finish, () => {
+ if(onerror) onerror();
+ removeRunDependency(dep)
+ })) {
+ return
+ }
+ finish(byteArray)
+ }
+ addRunDependency(dep);
+ if (typeof url == "string") {
+ asyncLoad(url).then(processData, onerror)
+ } else {
+ processData(url)
+ }
+ };
+ var FS_modeStringToFlags = str => {
+ var flagModes = {
+ r: 0,
+ "r+": 2,
+ w: 512 | 64 | 1,
+ "w+": 512 | 64 | 2,
+ a: 1024 | 64 | 1,
+ "a+": 1024 | 64 | 2
+ };
+ var flags = flagModes[str];
+ if (typeof flags == "undefined") {
+ throw new Error(`Unknown file open mode: ${str}`)
+ }
+ return flags
+ };
+ var FS_getMode = (canRead, canWrite) => {
+ var mode = 0;
+ if (canRead) mode |= 292 | 73;
+ if (canWrite) mode |= 146;
+ return mode
+ };
+ var FS = {
+ root: null,
+ mounts: [],
+ devices: {},
+ streams: [],
+ nextInode: 1,
+ nameTable: null,
+ currentPath: "/",
+ initialized: false,
+ ignorePermissions: true,
+ filesystems: null,
+ syncFSRequests: 0,
+ readFiles: {},
+ ErrnoError: class {
+ name = "ErrnoError";
+ constructor(errno) {
+ this.errno = errno
+ }
+ },
+ FSStream: class {
+ shared = {};
+ get object() {
+ return this.node
+ }
+ set object(val) {
+ this.node = val
+ }
+ get isRead() {
+ return (this.flags & 2097155) !== 1
+ }
+ get isWrite() {
+ return (this.flags & 2097155) !== 0
+ }
+ get isAppend() {
+ return this.flags & 1024
+ }
+ get flags() {
+ return this.shared.flags
+ }
+ set flags(val) {
+ this.shared.flags = val
+ }
+ get position() {
+ return this.shared.position
+ }
+ set position(val) {
+ this.shared.position = val
+ }
+ },
+ FSNode: class {
+ node_ops = {};
+ stream_ops = {};
+ readMode = 292 | 73;
+ writeMode = 146;
+ mounted = null;
+ constructor(parent, name, mode, rdev) {
+ if (!parent) {
+ parent = this
+ }
+ this.parent = parent;
+ this.mount = parent.mount;
+ this.id = FS.nextInode++;
+ this.name = name;
+ this.mode = mode;
+ this.rdev = rdev;
+ this.atime = this.mtime = this.ctime = Date.now()
+ }
+ get read() {
+ return (this.mode & this.readMode) === this.readMode
+ }
+ set read(val) {
+ val ? this.mode |= this.readMode : this.mode &= ~this.readMode
+ }
+ get write() {
+ return (this.mode & this.writeMode) === this.writeMode
+ }
+ set write(val) {
+ val ? this.mode |= this.writeMode : this.mode &= ~this.writeMode
+ }
+ get isFolder() {
+ return FS.isDir(this.mode)
+ }
+ get isDevice() {
+ return FS.isChrdev(this.mode)
+ }
+ },
+ lookupPath(path, opts = {}) {
+ if (!path) {
+ throw new FS.ErrnoError(44)
+ }
+ opts.follow_mount = true;
+ if (!PATH.isAbs(path)) {
+ path = FS.cwd() + "/" + path
+ }
+ linkloop: for (var nlinks = 0; nlinks < 40; nlinks++) {
+ var parts = path.split("/").filter(p => !!p);
+ 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
+ }
+ if (parts[i] === ".") {
+ continue
+ }
+ if (parts[i] === "..") {
+ current_path = PATH.dirname(current_path);
+ if (FS.isRoot(current)) {
+ path = current_path + "/" + parts.slice(i + 1).join("/");
+ continue linkloop
+ } else {
+ current = current.parent
+ }
+ continue
+ }
+ current_path = PATH.join2(current_path, parts[i]);
+ try {
+ current = FS.lookupNode(current, parts[i])
+ } catch (e) {
+ if (e && e.errno === 44 && islast && opts.noent_okay) {
+ return {
+ path: current_path
+ }
+ }
+ throw e
+ }
+ if (FS.isMountpoint(current) && (!islast || opts.follow_mount)) {
+ current = current.mounted.root
+ }
+ if (FS.isLink(current.mode) && (!islast || opts.follow)) {
+ if (!current.node_ops.readlink) {
+ throw new FS.ErrnoError(52)
+ }
+ var link = current.node_ops.readlink(current);
+ if (!PATH.isAbs(link)) {
+ link = PATH.dirname(current_path) + "/" + link
+ }
+ path = link + "/" + parts.slice(i + 1).join("/");
+ continue linkloop
+ }
+ }
+ return {
+ path: current_path,
+ node: current
+ }
+ }
+ throw new FS.ErrnoError(32)
+ },
+ 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)
+ }
+ var hash = FS.hashName(parent.id, name);
+ for (var node = FS.nameTable[hash]; node; node = node.name_next) {
+ var nodeName = node.name;
+ if (node.parent.id === parent.id && nodeName === name) {
+ return node
+ }
+ }
+ return FS.lookup(parent, name)
+ },
+ createNode(parent, name, mode, rdev) {
+ var node = new FS.FSNode(parent, name, mode, rdev);
+ FS.hashAddNode(node);
+ return node
+ },
+ destroyNode(node) {
+ FS.hashRemoveNode(node)
+ },
+ isRoot(node) {
+ return node === node.parent
+ },
+ isMountpoint(node) {
+ return !!node.mounted
+ },
+ isFile(mode) {
+ return (mode & 61440) === 32768
+ },
+ isDir(mode) {
+ return (mode & 61440) === 16384
+ },
+ isLink(mode) {
+ return (mode & 61440) === 40960
+ },
+ isChrdev(mode) {
+ return (mode & 61440) === 8192
+ },
+ isBlkdev(mode) {
+ return (mode & 61440) === 24576
+ },
+ isFIFO(mode) {
+ return (mode & 61440) === 4096
+ },
+ isSocket(mode) {
+ return (mode & 49152) === 49152
+ },
+ flagsToPermissionString(flag) {
+ var perms = ["r", "w", "rw"][flag & 3];
+ if (flag & 512) {
+ perms += "w"
+ }
+ return perms
+ },
+ nodePermissions(node, perms) {
+ if (FS.ignorePermissions) {
+ return 0
+ }
+ if (perms.includes("r") && !(node.mode & 292)) {
+ return 2
+ } else if (perms.includes("w") && !(node.mode & 146)) {
+ return 2
+ } else if (perms.includes("x") && !(node.mode & 73)) {
+ return 2
+ }
+ return 0
+ },
+ mayLookup(dir) {
+ if (!FS.isDir(dir.mode)) return 54;
+ var errCode = FS.nodePermissions(dir, "x");
+ if (errCode) return errCode;
+ if (!dir.node_ops.lookup) return 2;
+ return 0
+ },
+ mayCreate(dir, name) {
+ if (!FS.isDir(dir.mode)) {
+ return 54
+ }
+ try {
+ var node = FS.lookupNode(dir, name);
+ return 20
+ } catch (e) {}
+ return FS.nodePermissions(dir, "wx")
+ },
+ mayDelete(dir, name, isdir) {
+ var node;
+ try {
+ node = FS.lookupNode(dir, name)
+ } catch (e) {
+ return e.errno
+ }
+ var errCode = FS.nodePermissions(dir, "wx");
+ if (errCode) {
+ return errCode
+ }
+ if (isdir) {
+ if (!FS.isDir(node.mode)) {
+ return 54
+ }
+ if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) {
+ return 10
+ }
+ } else {
+ if (FS.isDir(node.mode)) {
+ return 31
+ }
+ }
+ return 0
+ },
+ mayOpen(node, flags) {
+ if (!node) {
+ return 44
+ }
+ if (FS.isLink(node.mode)) {
+ return 32
+ } else if (FS.isDir(node.mode)) {
+ if (FS.flagsToPermissionString(flags) !== "r" || flags & (512 | 64)) {
+ return 31
+ }
+ }
+ return FS.nodePermissions(node, FS.flagsToPermissionString(flags))
+ },
+ checkOpExists(op, err) {
+ if (!op) {
+ throw new FS.ErrnoError(err)
+ }
+ return op
+ },
+ MAX_OPEN_FDS: 4096,
+ nextfd() {
+ for (var fd = 0; fd <= FS.MAX_OPEN_FDS; fd++) {
+ if (!FS.streams[fd]) {
+ return fd
+ }
+ }
+ throw new FS.ErrnoError(33)
+ },
+ getStreamChecked(fd) {
+ var stream = FS.getStream(fd);
+ if (!stream) {
+ throw new FS.ErrnoError(8)
+ }
+ return stream
+ },
+ getStream: fd => FS.streams[fd],
+ createStream(stream, fd = -1) {
+ stream = Object.assign(new FS.FSStream, stream);
+ if (fd == -1) {
+ fd = FS.nextfd()
+ }
+ stream.fd = fd;
+ FS.streams[fd] = stream;
+ return stream
+ },
+ closeStream(fd) {
+ FS.streams[fd] = null
+ },
+ dupStream(origStream, fd = -1) {
+ var stream = FS.createStream(origStream, fd);
+ if (stream.stream_ops && stream.stream_ops.dup) {
+ stream.stream_ops.dup(stream);
+ }
+ return stream
+ },
+ doSetAttr(stream, node, attr) {
+ var setattr = stream && stream.stream_ops && stream.stream_ops.setattr;
+ var arg = setattr ? stream : node;
+ setattr = node.node_ops.setattr;
+ FS.checkOpExists(setattr, 63);
+ setattr(arg, attr)
+ },
+ chrdev_stream_ops: {
+ open(stream) {
+ var device = FS.getDevice(stream.node.rdev);
+ stream.stream_ops = device.stream_ops;
+ stream.stream_ops.open(stream)
+ },
+ llseek() {
+ throw new FS.ErrnoError(70)
+ }
+ },
+ major: dev => dev >> 8,
+ minor: dev => dev & 255,
+ makedev: (ma, mi) => ma << 8 | mi,
+ registerDevice(dev, ops) {
+ FS.devices[dev] = {
+ stream_ops: ops
+ }
+ },
+ getDevice: dev => FS.devices[dev],
+ getMounts(mount) {
+ var mounts = [];
+ var check = [mount];
+ while (check.length) {
+ var m = check.pop();
+ mounts.push(m);
+ check.push(...m.mounts)
+ }
+ return mounts
+ },
+ syncfs(populate, callback) {
+ if (typeof populate == "function") {
+ callback = populate;
+ populate = false
+ }
+ FS.syncFSRequests++;
+ if (FS.syncFSRequests > 1) {
+ err(`warning: ${FS.syncFSRequests} FS.syncfs operations in flight at once, probably just doing extra work`)
+ }
+ var mounts = FS.getMounts(FS.root.mount);
+ var completed = 0;
+
+ function doCallback(errCode) {
+ FS.syncFSRequests--;
+ return callback(errCode)
+ }
+
+ function done(errCode) {
+ if (errCode) {
+ if (!done.errored) {
+ done.errored = true;
+ return doCallback(errCode)
+ }
+ return
+ }
+ if (++completed >= mounts.length) {
+ doCallback(null)
+ }
+ }
+ mounts.forEach(mount => {
+ if (!mount.type.syncfs) {
+ return done(null)
+ }
+ mount.type.syncfs(mount, populate, done)
+ })
+ },
+ mount(type, opts, mountpoint) {
+ var root = mountpoint === "/";
+ var pseudo = !mountpoint;
+ var node;
+ if (root && FS.root) {
+ throw new FS.ErrnoError(10)
+ } else if (!root && !pseudo) {
+ var lookup = FS.lookupPath(mountpoint, {
+ follow_mount: false
+ });
+ mountpoint = lookup.path;
+ node = lookup.node;
+ if (FS.isMountpoint(node)) {
+ throw new FS.ErrnoError(10)
+ }
+ if (!FS.isDir(node.mode)) {
+ throw new FS.ErrnoError(54)
+ }
+ }
+ var mount = {
+ type,
+ opts,
+ mountpoint,
+ mounts: []
+ };
+ var mountRoot = type.mount(mount);
+ mountRoot.mount = mount;
+ mount.root = mountRoot;
+ if (root) {
+ FS.root = mountRoot
+ } else if (node) {
+ node.mounted = mount;
+ if (node.mount) {
+ node.mount.mounts.push(mount)
+ }
+ }
+ return mountRoot
+ },
+ unmount(mountpoint) {
+ var lookup = FS.lookupPath(mountpoint, {
+ follow_mount: false
+ });
+ if (!FS.isMountpoint(lookup.node)) {
+ throw new FS.ErrnoError(28)
+ }
+ var node = lookup.node;
+ var mount = node.mounted;
+ var mounts = FS.getMounts(mount);
+ Object.keys(FS.nameTable).forEach(hash => {
+ var current = FS.nameTable[hash];
+ while (current) {
+ var next = current.name_next;
+ if (mounts.includes(current.mount)) {
+ FS.destroyNode(current)
+ }
+ current = next
+ }
+ });
+ node.mounted = null;
+ var idx = node.mount.mounts.indexOf(mount);
+ node.mount.mounts.splice(idx, 1)
+ },
+ lookup(parent, name) {
+ return parent.node_ops.lookup(parent, name)
+ },
+ mknod(path, mode, dev) {
+ var lookup = FS.lookupPath(path, {
+ parent: true
+ });
+ var parent = lookup.node;
+ var name = PATH.basename(path);
+ if (!name) {
+ throw new FS.ErrnoError(28)
+ }
+ if (name === "." || name === "..") {
+ throw new FS.ErrnoError(20)
+ }
+ var errCode = FS.mayCreate(parent, name);
+ if (errCode) {
+ throw new FS.ErrnoError(errCode)
+ }
+ if (!parent.node_ops.mknod) {
+ throw new FS.ErrnoError(63)
+ }
+ return parent.node_ops.mknod(parent, name, mode, dev)
+ },
+ statfs(path) {
+ return FS.statfsNode(FS.lookupPath(path, {
+ follow: true
+ }).node)
+ },
+ statfsStream(stream) {
+ return FS.statfsNode(stream.node)
+ },
+ statfsNode(node) {
+ var rtn = {
+ bsize: 4096,
+ frsize: 4096,
+ blocks: 1e6,
+ bfree: 5e5,
+ bavail: 5e5,
+ files: FS.nextInode,
+ ffree: FS.nextInode - 1,
+ fsid: 42,
+ flags: 2,
+ namelen: 255
+ };
+ if (node.node_ops.statfs) {
+ Object.assign(rtn, node.node_ops.statfs(node.mount.opts.root))
+ }
+ return rtn
+ },
+ create(path, mode = 438) {
+ mode &= 4095;
+ mode |= 32768;
+ return FS.mknod(path, mode, 0)
+ },
+ mkdir(path, mode = 511) {
+ mode &= 511 | 512;
+ mode |= 16384;
+ return FS.mknod(path, mode, 0)
+ },
+ mkdirTree(path, mode) {
+ var dirs = path.split("/");
+ var d = "";
+ for (var dir of dirs) {
+ if (!dir) continue;
+ if (d || PATH.isAbs(path)) d += "/";
+ d += dir;
+ 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);
+ old_node.parent = new_dir
+ } 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;
+ var readdir = FS.checkOpExists(node.node_ops.readdir, 54);
+ return 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 link.node_ops.readlink(link)
+ },
+ stat(path, dontFollow) {
+ var lookup = FS.lookupPath(path, {
+ follow: !dontFollow
+ });
+ var node = lookup.node;
+ var getattr = FS.checkOpExists(node.node_ops.getattr, 63);
+ return getattr(node)
+ },
+ fstat(fd) {
+ var stream = FS.getStreamChecked(fd);
+ var node = stream.node;
+ var getattr = stream.stream_ops.getattr;
+ var arg = getattr ? stream : node;
+ getattr = node.node_ops.getattr;
+ FS.checkOpExists(getattr, 63);
+ return getattr(arg)
+ },
+ lstat(path) {
+ return FS.stat(path, true)
+ },
+ doChmod(stream, node, mode, dontFollow) {
+ FS.doSetAttr(stream, node, {
+ mode: mode & 4095 | node.mode & ~4095,
+ ctime: Date.now(),
+ dontFollow
+ })
+ },
+ chmod(path, mode, dontFollow) {
+ var node;
+ if (typeof path == "string") {
+ var lookup = FS.lookupPath(path, {
+ follow: !dontFollow
+ });
+ node = lookup.node
+ } else {
+ node = path
+ }
+ FS.doChmod(null, node, mode, dontFollow)
+ },
+ lchmod(path, mode) {
+ FS.chmod(path, mode, true)
+ },
+ fchmod(fd, mode) {
+ var stream = FS.getStreamChecked(fd);
+ FS.doChmod(stream, stream.node, mode, false)
+ },
+ doChown(stream, node, dontFollow) {
+ FS.doSetAttr(stream, node, {
+ timestamp: Date.now(),
+ dontFollow
+ })
+ },
+ chown(path, uid, gid, dontFollow) {
+ var node;
+ if (typeof path == "string") {
+ var lookup = FS.lookupPath(path, {
+ follow: !dontFollow
+ });
+ node = lookup.node
+ } else {
+ node = path
+ }
+ FS.doChown(null, node, dontFollow)
+ },
+ lchown(path, uid, gid) {
+ FS.chown(path, uid, gid, true)
+ },
+ fchown(fd, uid, gid) {
+ var stream = FS.getStreamChecked(fd);
+ FS.doChown(stream, stream.node, false)
+ },
+ doTruncate(stream, node, len) {
+ 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)
+ }
+ FS.doSetAttr(stream, node, {
+ size: len,
+ timestamp: Date.now()
+ })
+ },
+ 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
+ }
+ FS.doTruncate(null, node, len)
+ },
+ ftruncate(fd, len) {
+ var stream = FS.getStreamChecked(fd);
+ if (len < 0 || (stream.flags & 2097155) === 0) {
+ throw new FS.ErrnoError(28)
+ }
+ FS.doTruncate(stream, stream.node, len)
+ },
+ utime(path, atime, mtime) {
+ var lookup = FS.lookupPath(path, {
+ follow: true
+ });
+ var node = lookup.node;
+ var setattr = FS.checkOpExists(node.node_ops.setattr, 63);
+ setattr(node, {
+ atime,
+ mtime
+ })
+ },
+ open(path, flags, mode = 438) {
+ if (path === "") {
+ throw new FS.ErrnoError(44)
+ }
+ flags = typeof flags == "string" ? FS_modeStringToFlags(flags) : flags;
+ if (flags & 64) {
+ mode = mode & 4095 | 32768
+ } else {
+ mode = 0
+ }
+ var node;
+ var isDirPath;
+ if (typeof path == "object") {
+ node = path
+ } else {
+ isDirPath = path.endsWith("/");
+ var lookup = FS.lookupPath(path, {
+ follow: !(flags & 131072),
+ noent_okay: true
+ });
+ node = lookup.node;
+ path = lookup.path
+ }
+ var created = false;
+ if (flags & 64) {
+ if (node) {
+ if (flags & 128) {
+ throw new FS.ErrnoError(20)
+ }
+ } else if (isDirPath) {
+ throw new FS.ErrnoError(31)
+ } else {
+ node = FS.mknod(path, mode | 511, 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,
+ path: FS.getPath(node),
+ flags,
+ seekable: true,
+ position: 0,
+ stream_ops: node.stream_ops,
+ ungotten: [],
+ error: false
+ });
+ if (stream.stream_ops.open) {
+ stream.stream_ops.open(stream)
+ }
+ if (created) {
+ FS.chmod(node, mode & 511)
+ }
+ if (Module["logReadFiles"] && !(flags & 1)) {
+ 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
+ },
+ 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)
+ }
+ if (!length) {
+ throw new FS.ErrnoError(28)
+ }
+ 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)
+ },
+ 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 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") {
+ buf = UTF8ArrayToString(buf)
+ }
+ FS.close(stream);
+ return buf
+ },
+ writeFile(path, data, opts = {}) {
+ opts.flags = opts.flags || 577;
+ var stream = FS.open(path, opts.flags, opts.mode);
+ if (typeof data == "string") {
+ data = new Uint8Array(intArrayFromString(data, true))
+ }
+ 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,
+ llseek: () => 0
+ });
+ FS.mkdev("/dev/null", FS.makedev(1, 3));
+ TTY.register(FS.makedev(5, 0), TTY.default_tty_ops);
+ TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops);
+ FS.mkdev("/dev/tty", FS.makedev(5, 0));
+ FS.mkdev("/dev/tty1", FS.makedev(6, 0));
+ var randomBuffer = new Uint8Array(1024),
+ randomLeft = 0;
+ var randomByte = () => {
+ if (randomLeft === 0) {
+ randomFill(randomBuffer);
+ randomLeft = randomBuffer.byteLength
+ }
+ return randomBuffer[--randomLeft]
+ };
+ FS.createDevice("/dev", "random", randomByte);
+ FS.createDevice("/dev", "urandom", randomByte);
+ FS.mkdir("/dev/shm");
+ FS.mkdir("/dev/shm/tmp")
+ },
+ createSpecialDirectories() {
+ FS.mkdir("/proc");
+ var proc_self = FS.mkdir("/proc/self");
+ FS.mkdir("/proc/self/fd");
+ FS.mount({
+ mount() {
+ var node = FS.createNode(proc_self, "fd", 16895, 73);
+ node.stream_ops = {
+ llseek: MEMFS.stream_ops.llseek
+ };
+ node.node_ops = {
+ lookup(parent, name) {
+ var fd = +name;
+ var stream = FS.getStreamChecked(fd);
+ var ret = {
+ parent: null,
+ mount: {
+ mountpoint: "fake"
+ },
+ node_ops: {
+ readlink: () => stream.path
+ },
+ id: fd + 1
+ };
+ ret.parent = ret;
+ return ret
+ },
+ readdir() {
+ return Array.from(FS.streams.entries()).filter(([k, v]) => v).map(([k, v]) => k.toString())
+ }
+ };
+ return node
+ }
+ }, {}, "/proc/self/fd")
+ },
+ createStandardStreams(input, output, error) {
+ if (input) {
+ FS.createDevice("/dev", "stdin", input)
+ } else {
+ FS.symlink("/dev/tty", "/dev/stdin")
+ }
+ if (output) {
+ FS.createDevice("/dev", "stdout", null, output)
+ } else {
+ FS.symlink("/dev/tty", "/dev/stdout")
+ }
+ if (error) {
+ FS.createDevice("/dev", "stderr", null, error)
+ } else {
+ FS.symlink("/dev/tty1", "/dev/stderr")
+ }
+ var stdin = FS.open("/dev/stdin", 0);
+ var stdout = FS.open("/dev/stdout", 1);
+ var stderr = FS.open("/dev/stderr", 1)
+ },
+ staticInit() {
+ FS.nameTable = new Array(4096);
+ FS.mount(MEMFS, {}, "/");
+ FS.createDefaultDirectories();
+ FS.createDefaultDevices();
+ FS.createSpecialDirectories();
+ FS.filesystems = {
+ MEMFS
+ }
+ },
+ init(input, output, error) {
+ FS.initialized = true;
+ input = Module["stdin"];
+ output = Module["stdout"];
+ error = Module["stderr"];
+ FS.createStandardStreams(input, output, error)
+ },
+ quit() {
+ FS.initialized = false;
+ for (var stream of FS.streams) {
+ if (stream) {
+ FS.close(stream)
+ }
+ }
+ },
+ 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) {
+ if (e.errno != 20) throw 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)
+ }
+ },
+ createDevice(parent, name, input, output) {
+ var path = PATH.join2(typeof parent == "string" ? parent : FS.getPath(parent), name);
+ var mode = FS_getMode(!!input, !!output);
+ 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.atime = 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.mtime = stream.node.ctime = 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 {
+ try {
+ obj.contents = readBinary(obj.url);
+ obj.usedBytes = obj.contents.length
+ } catch (e) {
+ throw new FS.ErrnoError(29)
+ }
+ }
+ },
+ createLazyFile(parent, name, url, canRead, canWrite) {
+ class LazyUint8Array {
+ lengthKnown = false;
+ chunks = [];
+ 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]
+ }
+ setDataGetter(getter) {
+ this.getter = getter
+ }
+ cacheLength() {
+ var xhr = new XMLHttpRequest;
+ xhr.open("HEAD", url, false);
+ xhr.send(null);
+ if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
+ var datalength = Number(xhr.getResponseHeader("Content-length"));
+ var header;
+ var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes";
+ var usesGzip = (header = xhr.getResponseHeader("Content-Encoding")) && header === "gzip";
+ var chunkSize = 1024 * 1024;
+ if (!hasByteServing) chunkSize = datalength;
+ var doXHR = (from, to) => {
+ if (from > to) throw new Error("invalid range (" + from + ", " + to + ") or no bytes requested!");
+ if (to > datalength - 1) throw new Error("only " + datalength + " bytes available! programmer error!");
+ var xhr = new XMLHttpRequest;
+ xhr.open("GET", url, false);
+ if (datalength !== chunkSize) xhr.setRequestHeader("Range", "bytes=" + from + "-" + to);
+ xhr.responseType = "arraybuffer";
+ if (xhr.overrideMimeType) {
+ xhr.overrideMimeType("text/plain; charset=x-user-defined")
+ }
+ xhr.send(null);
+ if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
+ if (xhr.response !== undefined) {
+ return new Uint8Array(xhr.response || [])
+ }
+ return intArrayFromString(xhr.responseText || "", true)
+ };
+ var lazyArray = this;
+ lazyArray.setDataGetter(chunkNum => {
+ var start = chunkNum * chunkSize;
+ var end = (chunkNum + 1) * chunkSize - 1;
+ end = Math.min(end, datalength - 1);
+ if (typeof lazyArray.chunks[chunkNum] == "undefined") {
+ lazyArray.chunks[chunkNum] = doXHR(start, end)
+ }
+ if (typeof lazyArray.chunks[chunkNum] == "undefined") throw new Error("doXHR failed!");
+ return lazyArray.chunks[chunkNum]
+ });
+ if (usesGzip || !datalength) {
+ chunkSize = datalength = 1;
+ datalength = this.getter(0).length;
+ chunkSize = datalength;
+ out("LazyFiles on gzip forces download of the whole file when length is accessed")
+ }
+ this._length = datalength;
+ this._chunkSize = chunkSize;
+ this.lengthKnown = true
+ }
+ get length() {
+ if (!this.lengthKnown) {
+ this.cacheLength()
+ }
+ return this._length
+ }
+ get chunkSize() {
+ if (!this.lengthKnown) {
+ this.cacheLength()
+ }
+ return this._chunkSize
+ }
+ }
+ if (typeof XMLHttpRequest != "undefined") {
+ if (!ENVIRONMENT_IS_WORKER) throw "Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc";
+ var lazyArray = new LazyUint8Array;
+ var properties = {
+ isDevice: false,
+ contents: lazyArray
+ }
+ } else {
+ var properties = {
+ isDevice: false,
+ url
+ }
+ }
+ var node = FS.createFile(parent, name, properties, canRead, canWrite);
+ if (properties.contents) {
+ node.contents = properties.contents
+ } else if (properties.url) {
+ node.contents = null;
+ node.url = properties.url
+ }
+ Object.defineProperties(node, {
+ usedBytes: {
+ get: function () {
+ return this.contents.length
+ }
+ }
+ });
+ var stream_ops = {};
+ var keys = Object.keys(node.stream_ops);
+ keys.forEach(key => {
+ var fn = node.stream_ops[key];
+ stream_ops[key] = (...args) => {
+ FS.forceLoadFile(node);
+ return fn(...args)
+ }
+ });
+
+ function writeChunks(stream, buffer, offset, length, position) {
+ var contents = stream.node.contents;
+ if (position >= contents.length) return 0;
+ var size = Math.min(contents.length - position, length);
+ if (contents.slice) {
+ for (var i = 0; i < 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,
+ allocated: true
+ }
+ };
+ node.stream_ops = stream_ops;
+ return node
+ }
+ };
+ var UTF8ToString = (ptr, maxBytesToRead) => {
+ ptr >>>= 0;
+ return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : ""
+ };
+ var SYSCALLS = {
+ DEFAULT_POLLMASK: 5,
+ calculateAt(dirfd, path, allowEmpty) {
+ if (PATH.isAbs(path)) {
+ return path
+ }
+ var dir;
+ if (dirfd === -100) {
+ dir = FS.cwd()
+ } else {
+ var dirstream = SYSCALLS.getStreamFromFD(dirfd);
+ dir = dirstream.path
+ }
+ if (path.length == 0) {
+ if (!allowEmpty) {
+ throw new FS.ErrnoError(44)
+ }
+ return dir
+ }
+ return dir + "/" + path
+ },
+ writeStat(buf, stat) {
+ HEAP32[buf >>> 2 >>> 0] = stat.dev;
+ HEAP32[buf + 4 >>> 2 >>> 0] = stat.mode;
+ HEAPU32[buf + 8 >>> 2 >>> 0] = stat.nlink;
+ HEAP32[buf + 12 >>> 2 >>> 0] = stat.uid;
+ HEAP32[buf + 16 >>> 2 >>> 0] = stat.gid;
+ HEAP32[buf + 20 >>> 2 >>> 0] = stat.rdev;
+ HEAP64[buf + 24 >>> 3 >>> 0] = BigInt(stat.size);
+ HEAP32[buf + 32 >>> 2 >>> 0] = 4096;
+ HEAP32[buf + 36 >>> 2 >>> 0] = stat.blocks;
+ var atime = stat.atime.getTime();
+ var mtime = stat.mtime.getTime();
+ var ctime = stat.ctime.getTime();
+ HEAP64[buf + 40 >>> 3 >>> 0] = BigInt(Math.floor(atime / 1e3));
+ HEAPU32[buf + 48 >>> 2 >>> 0] = atime % 1e3 * 1e3 * 1e3;
+ HEAP64[buf + 56 >>> 3 >>> 0] = BigInt(Math.floor(mtime / 1e3));
+ HEAPU32[buf + 64 >>> 2 >>> 0] = mtime % 1e3 * 1e3 * 1e3;
+ HEAP64[buf + 72 >>> 3 >>> 0] = BigInt(Math.floor(ctime / 1e3));
+ HEAPU32[buf + 80 >>> 2 >>> 0] = ctime % 1e3 * 1e3 * 1e3;
+ HEAP64[buf + 88 >>> 3 >>> 0] = BigInt(stat.ino);
+ return 0
+ },
+ writeStatFs(buf, stats) {
+ HEAP32[buf + 4 >>> 2 >>> 0] = stats.bsize;
+ HEAP32[buf + 40 >>> 2 >>> 0] = stats.bsize;
+ HEAP32[buf + 8 >>> 2 >>> 0] = stats.blocks;
+ HEAP32[buf + 12 >>> 2 >>> 0] = stats.bfree;
+ HEAP32[buf + 16 >>> 2 >>> 0] = stats.bavail;
+ HEAP32[buf + 20 >>> 2 >>> 0] = stats.files;
+ HEAP32[buf + 24 >>> 2 >>> 0] = stats.ffree;
+ HEAP32[buf + 28 >>> 2 >>> 0] = stats.fsid;
+ HEAP32[buf + 44 >>> 2 >>> 0] = stats.flags;
+ HEAP32[buf + 36 >>> 2 >>> 0] = stats.namelen
+ },
+ doMsync(addr, stream, len, flags, offset) {
+ if (!FS.isFile(stream.node.mode)) {
+ throw new FS.ErrnoError(43)
+ }
+ if (flags & 2) {
+ return 0
+ }
+ var buffer = HEAPU8.slice(addr, addr + len);
+ FS.msync(stream, buffer, offset, len, flags)
+ },
+ getStreamFromFD(fd) {
+ var stream = FS.getStreamChecked(fd);
+ return stream
+ },
+ varargs: undefined,
+ getStr(ptr) {
+ var ret = UTF8ToString(ptr);
+ return ret
+ }
+ };
+ var INT53_MAX = 9007199254740992;
+ var INT53_MIN = -9007199254740992;
+ var bigintToI53Checked = num => num < INT53_MIN || num > INT53_MAX ? NaN : Number(num);
+
+ function ___syscall_fcntl64(fd, cmd, varargs) {
+ varargs >>>= 0;
+ SYSCALLS.varargs = varargs;
+ try {
+ var stream = SYSCALLS.getStreamFromFD(fd);
+ switch (cmd) {
+ case 0: {
+ var arg = syscallGetVarargI();
+ if (arg < 0) {
+ return -28
+ }
+ while (FS.streams[arg]) {
+ arg++
+ }
+ var newStream;
+ newStream = FS.dupStream(stream, arg);
+ return newStream.fd
+ }
+ case 1:
+ case 2:
+ return 0;
+ case 3:
+ return stream.flags;
+ case 4: {
+ var arg = syscallGetVarargI();
+ stream.flags |= arg;
+ return 0
+ }
+ case 12: {
+ var arg = syscallGetVarargP();
+ var offset = 0;
+ HEAP16[arg + offset >>> 1 >>> 0] = 2;
+ return 0
+ }
+ case 13:
+ case 14:
+ return 0
+ }
+ return -28
+ } catch (e) {
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+ return -e.errno
+ }
+ }
+
+ function ___syscall_fstat64(fd, buf) {
+ buf >>>= 0;
+ try {
+ return SYSCALLS.writeStat(buf, FS.fstat(fd))
+ } catch (e) {
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+ return -e.errno
+ }
+ }
+
+ function ___syscall_ftruncate64(fd, length) {
+ length = bigintToI53Checked(length);
+ try {
+ if (isNaN(length)) return -61;
+ FS.ftruncate(fd, length);
+ return 0
+ } catch (e) {
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+ return -e.errno
+ }
+ }
+ var stringToUTF8 = (str, outPtr, maxBytesToWrite) => stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
+
+ function ___syscall_getdents64(fd, dirp, count) {
+ dirp >>>= 0;
+ count >>>= 0;
+ try {
+ var stream = SYSCALLS.getStreamFromFD(fd);
+ stream.getdents = FS.readdir(stream.path);
+ var struct_size = 280;
+ var pos = 0;
+ var off = FS.llseek(stream, 0, 1);
+ var startIdx = Math.floor(off / struct_size);
+ var endIdx = Math.min(stream.getdents.length, startIdx + Math.floor(count / struct_size));
+ for (var idx = startIdx; idx < endIdx; idx++) {
+ 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;
+ try {
+ child = FS.lookupNode(stream.node, name)
+ } catch (e) {
+ if (e && e.errno === 28) {
+ continue
+ }
+ throw e
+ }
+ id = child.id;
+ type = FS.isChrdev(child.mode) ? 2 : FS.isDir(child.mode) ? 4 : FS.isLink(child.mode) ? 10 : 8
+ }
+ HEAP64[dirp + pos >>> 3 >>> 0] = BigInt(id);
+ HEAP64[dirp + pos + 8 >>> 3 >>> 0] = BigInt((idx + 1) * struct_size);
+ HEAP16[dirp + pos + 16 >>> 1 >>> 0] = 280;
+ HEAP8[dirp + pos + 18 >>> 0] = type;
+ stringToUTF8(name, dirp + pos + 19, 256);
+ pos += struct_size
+ }
+ FS.llseek(stream, idx * struct_size, 0);
+ return pos
+ } catch (e) {
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+ return -e.errno
+ }
+ }
+
+ function ___syscall_ioctl(fd, op, varargs) {
+ varargs >>>= 0;
+ SYSCALLS.varargs = varargs;
+ try {
+ var stream = SYSCALLS.getStreamFromFD(fd);
+ switch (op) {
+ case 21509: {
+ if (!stream.tty) return -59;
+ return 0
+ }
+ case 21505: {
+ if (!stream.tty) return -59;
+ if (stream.tty.ops.ioctl_tcgets) {
+ var termios = stream.tty.ops.ioctl_tcgets(stream);
+ var argp = syscallGetVarargP();
+ HEAP32[argp >>> 2 >>> 0] = termios.c_iflag || 0;
+ HEAP32[argp + 4 >>> 2 >>> 0] = termios.c_oflag || 0;
+ HEAP32[argp + 8 >>> 2 >>> 0] = termios.c_cflag || 0;
+ HEAP32[argp + 12 >>> 2 >>> 0] = termios.c_lflag || 0;
+ for (var i = 0; i < 32; i++) {
+ HEAP8[argp + i + 17 >>> 0] = termios.c_cc[i] || 0
+ }
+ return 0
+ }
+ return 0
+ }
+ case 21510:
+ case 21511:
+ case 21512: {
+ if (!stream.tty) return -59;
+ return 0
+ }
+ case 21506:
+ case 21507:
+ case 21508: {
+ if (!stream.tty) return -59;
+ if (stream.tty.ops.ioctl_tcsets) {
+ var argp = syscallGetVarargP();
+ var c_iflag = HEAP32[argp >>> 2 >>> 0];
+ var c_oflag = HEAP32[argp + 4 >>> 2 >>> 0];
+ var c_cflag = HEAP32[argp + 8 >>> 2 >>> 0];
+ var c_lflag = HEAP32[argp + 12 >>> 2 >>> 0];
+ var c_cc = [];
+ for (var i = 0; i < 32; i++) {
+ c_cc.push(HEAP8[argp + i + 17 >>> 0])
+ }
+ return stream.tty.ops.ioctl_tcsets(stream.tty, op, {
+ c_iflag,
+ c_oflag,
+ c_cflag,
+ c_lflag,
+ c_cc
+ })
+ }
+ return 0
+ }
+ case 21519: {
+ if (!stream.tty) return -59;
+ var argp = syscallGetVarargP();
+ HEAP32[argp >>> 2 >>> 0] = 0;
+ return 0
+ }
+ case 21520: {
+ if (!stream.tty) return -59;
+ return -28
+ }
+ case 21531: {
+ var argp = syscallGetVarargP();
+ return FS.ioctl(stream, op, argp)
+ }
+ case 21523: {
+ if (!stream.tty) return -59;
+ if (stream.tty.ops.ioctl_tiocgwinsz) {
+ var winsize = stream.tty.ops.ioctl_tiocgwinsz(stream.tty);
+ var argp = syscallGetVarargP();
+ HEAP16[argp >>> 1 >>> 0] = winsize[0];
+ HEAP16[argp + 2 >>> 1 >>> 0] = winsize[1]
+ }
+ return 0
+ }
+ case 21524: {
+ if (!stream.tty) return -59;
+ return 0
+ }
+ case 21515: {
+ if (!stream.tty) return -59;
+ return 0
+ }
+ default:
+ return -28
+ }
+ } catch (e) {
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+ return -e.errno
+ }
+ }
+
+ function ___syscall_lstat64(path, buf) {
+ path >>>= 0;
+ buf >>>= 0;
+ try {
+ path = SYSCALLS.getStr(path);
+ return SYSCALLS.writeStat(buf, FS.lstat(path))
+ } catch (e) {
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+ return -e.errno
+ }
+ }
+
+ function ___syscall_newfstatat(dirfd, path, buf, flags) {
+ path >>>= 0;
+ buf >>>= 0;
+ try {
+ path = SYSCALLS.getStr(path);
+ var nofollow = flags & 256;
+ var allowEmpty = flags & 4096;
+ flags = flags & ~6400;
+ path = SYSCALLS.calculateAt(dirfd, path, allowEmpty);
+ return SYSCALLS.writeStat(buf, nofollow ? FS.lstat(path) : FS.stat(path))
+ } catch (e) {
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+ return -e.errno
+ }
+ }
+
+ function ___syscall_openat(dirfd, path, flags, varargs) {
+ path >>>= 0;
+ varargs >>>= 0;
+ SYSCALLS.varargs = varargs;
+ try {
+ path = SYSCALLS.getStr(path);
+ path = SYSCALLS.calculateAt(dirfd, path);
+ var mode = varargs ? syscallGetVarargI() : 0;
+ return FS.open(path, flags, mode).fd
+ } catch (e) {
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+ return -e.errno
+ }
+ }
+
+ function ___syscall_rmdir(path) {
+ path >>>= 0;
+ 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) {
+ path >>>= 0;
+ buf >>>= 0;
+ try {
+ path = SYSCALLS.getStr(path);
+ return SYSCALLS.writeStat(buf, FS.stat(path))
+ } catch (e) {
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+ return -e.errno
+ }
+ }
+
+ function ___syscall_unlinkat(dirfd, path, flags) {
+ path >>>= 0;
+ try {
+ path = SYSCALLS.getStr(path);
+ path = SYSCALLS.calculateAt(dirfd, path);
+ if (!flags) {
+ FS.unlink(path)
+ } else if (flags === 512) {
+ FS.rmdir(path)
+ } else {
+ return -28
+ }
+ return 0
+ } catch (e) {
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+ return -e.errno
+ }
+ }
+ var __abort_js = () => abort("");
+ var __emscripten_throw_longjmp = () => {
+ throw Infinity
+ };
+
+ function __gmtime_js(time, tmPtr) {
+ time = bigintToI53Checked(time);
+ tmPtr >>>= 0;
+ var date = new Date(time * 1e3);
+ HEAP32[tmPtr >>> 2 >>> 0] = date.getUTCSeconds();
+ HEAP32[tmPtr + 4 >>> 2 >>> 0] = date.getUTCMinutes();
+ HEAP32[tmPtr + 8 >>> 2 >>> 0] = date.getUTCHours();
+ HEAP32[tmPtr + 12 >>> 2 >>> 0] = date.getUTCDate();
+ HEAP32[tmPtr + 16 >>> 2 >>> 0] = date.getUTCMonth();
+ HEAP32[tmPtr + 20 >>> 2 >>> 0] = date.getUTCFullYear() - 1900;
+ HEAP32[tmPtr + 24 >>> 2 >>> 0] = 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 >>> 0] = yday
+ }
+ var isLeapYear = year => year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+ var MONTH_DAYS_LEAP_CUMULATIVE = [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335];
+ var MONTH_DAYS_REGULAR_CUMULATIVE = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334];
+ var ydayFromDate = date => {
+ var leap = isLeapYear(date.getFullYear());
+ var monthDaysCumulative = leap ? MONTH_DAYS_LEAP_CUMULATIVE : MONTH_DAYS_REGULAR_CUMULATIVE;
+ var yday = monthDaysCumulative[date.getMonth()] + date.getDate() - 1;
+ return yday
+ };
+
+ function __localtime_js(time, tmPtr) {
+ time = bigintToI53Checked(time);
+ tmPtr >>>= 0;
+ var date = new Date(time * 1e3);
+ HEAP32[tmPtr >>> 2 >>> 0] = date.getSeconds();
+ HEAP32[tmPtr + 4 >>> 2 >>> 0] = date.getMinutes();
+ HEAP32[tmPtr + 8 >>> 2 >>> 0] = date.getHours();
+ HEAP32[tmPtr + 12 >>> 2 >>> 0] = date.getDate();
+ HEAP32[tmPtr + 16 >>> 2 >>> 0] = date.getMonth();
+ HEAP32[tmPtr + 20 >>> 2 >>> 0] = date.getFullYear() - 1900;
+ HEAP32[tmPtr + 24 >>> 2 >>> 0] = date.getDay();
+ var yday = ydayFromDate(date) | 0;
+ HEAP32[tmPtr + 28 >>> 2 >>> 0] = yday;
+ HEAP32[tmPtr + 36 >>> 2 >>> 0] = -(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 >>> 0] = dst
+ }
+ var __tzset_js = function (timezone, daylight, std_name, dst_name) {
+ timezone >>>= 0;
+ daylight >>>= 0;
+ std_name >>>= 0;
+ dst_name >>>= 0;
+ 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 >>> 0] = stdTimezoneOffset * 60;
+ HEAP32[daylight >>> 2 >>> 0] = Number(winterOffset != summerOffset);
+ var extractZone = timezoneOffset => {
+ var sign = timezoneOffset >= 0 ? "-" : "+";
+ var absOffset = Math.abs(timezoneOffset);
+ var hours = String(Math.floor(absOffset / 60)).padStart(2, "0");
+ var minutes = String(absOffset % 60).padStart(2, "0");
+ return `UTC${sign}${hours}${minutes}`
+ };
+ var winterName = extractZone(winterOffset);
+ var summerName = extractZone(summerOffset);
+ if (summerOffset < winterOffset) {
+ stringToUTF8(winterName, std_name, 17);
+ stringToUTF8(summerName, dst_name, 17)
+ } else {
+ stringToUTF8(winterName, dst_name, 17);
+ stringToUTF8(summerName, std_name, 17)
+ }
+ };
+ var _emscripten_date_now = () => Date.now();
+ var getHeapMax = () => 4294901760;
+ var growMemory = size => {
+ var b = wasmMemory.buffer;
+ var pages = (size - b.byteLength + 65535) / 65536 | 0;
+ try {
+ wasmMemory.grow(pages);
+ updateMemoryViews();
+ return 1
+ } catch (e) {}
+ };
+
+ function _emscripten_resize_heap(requestedSize) {
+ requestedSize >>>= 0;
+ var oldSize = HEAPU8.length;
+ var maxHeapSize = getHeapMax();
+ if (requestedSize > maxHeapSize) {
+ return false
+ }
+ for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
+ var overGrownHeapSize = oldSize * (1 + .2 / cutDown);
+ overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
+ var newSize = Math.min(maxHeapSize, alignMemory(Math.max(requestedSize, overGrownHeapSize), 65536));
+ var replacement = growMemory(newSize);
+ if (replacement) {
+ return true
+ }
+ }
+ return false
+ }
+ var ENV = {};
+ var getExecutableName = () => thisProgram || "./this.program";
+ var getEnvStrings = () => {
+ if (!getEnvStrings.strings) {
+ var lang = (typeof navigator == "object" && navigator.language || "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 _environ_get(__environ, environ_buf) {
+ __environ >>>= 0;
+ environ_buf >>>= 0;
+ var bufSize = 0;
+ var envp = 0;
+ for (var string of getEnvStrings()) {
+ var ptr = environ_buf + bufSize;
+ HEAPU32[__environ + envp >>> 2 >>> 0] = ptr;
+ bufSize += stringToUTF8(string, ptr, Infinity) + 1;
+ envp += 4
+ }
+ return 0
+ }
+
+ function _environ_sizes_get(penviron_count, penviron_buf_size) {
+ penviron_count >>>= 0;
+ penviron_buf_size >>>= 0;
+ var strings = getEnvStrings();
+ HEAPU32[penviron_count >>> 2 >>> 0] = strings.length;
+ var bufSize = 0;
+ for (var string of strings) {
+ bufSize += lengthBytesUTF8(string) + 1
+ }
+ HEAPU32[penviron_buf_size >>> 2 >>> 0] = 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
+ }
+ }
+ var doReadv = (stream, iov, iovcnt, offset) => {
+ var ret = 0;
+ for (var i = 0; i < iovcnt; i++) {
+ var ptr = HEAPU32[iov >>> 2 >>> 0];
+ var len = HEAPU32[iov + 4 >>> 2 >>> 0];
+ 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) {
+ iov >>>= 0;
+ iovcnt >>>= 0;
+ pnum >>>= 0;
+ try {
+ var stream = SYSCALLS.getStreamFromFD(fd);
+ var num = doReadv(stream, iov, iovcnt);
+ HEAPU32[pnum >>> 2 >>> 0] = num;
+ return 0
+ } catch (e) {
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+ return e.errno
+ }
+ }
+
+ function _fd_seek(fd, offset, whence, newOffset) {
+ offset = bigintToI53Checked(offset);
+ newOffset >>>= 0;
+ try {
+ if (isNaN(offset)) return 61;
+ var stream = SYSCALLS.getStreamFromFD(fd);
+ FS.llseek(stream, offset, whence);
+ HEAP64[newOffset >>> 3 >>> 0] = BigInt(stream.position);
+ 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
+ }
+ }
+ var doWritev = (stream, iov, iovcnt, offset) => {
+ var ret = 0;
+ for (var i = 0; i < iovcnt; i++) {
+ var ptr = HEAPU32[iov >>> 2 >>> 0];
+ var len = HEAPU32[iov + 4 >>> 2 >>> 0];
+ iov += 8;
+ var curr = FS.write(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_write(fd, iov, iovcnt, pnum) {
+ iov >>>= 0;
+ iovcnt >>>= 0;
+ pnum >>>= 0;
+ try {
+ var stream = SYSCALLS.getStreamFromFD(fd);
+ var num = doWritev(stream, iov, iovcnt);
+ HEAPU32[pnum >>> 2 >>> 0] = num;
+ return 0
+ } catch (e) {
+ if (typeof FS == "undefined" || !(e.name === "ErrnoError")) throw e;
+ return e.errno
+ }
+ }
+ var wasmTableMirror = [];
+ var wasmTable;
+ var getWasmTableEntry = funcPtr => {
+ var func = wasmTableMirror[funcPtr];
+ if (!func) {
+ wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr)
+ }
+ return func
+ };
+ var getCFunc = ident => {
+ var func = Module["_" + ident];
+ return func
+ };
+ var writeArrayToMemory = (array, buffer) => {
+ HEAP8.set(array, buffer >>> 0)
+ };
+ var stackAlloc = sz => __emscripten_stack_alloc(sz);
+ var stringToUTF8OnStack = str => {
+ var size = lengthBytesUTF8(str) + 1;
+ var ret = stackAlloc(size);
+ stringToUTF8(str, ret, size);
+ return ret
+ };
+ var ccall = (ident, returnType, argTypes, args, opts) => {
+ var toC = {
+ string: str => {
+ var ret = 0;
+ if (str !== null && str !== undefined && str !== 0) {
+ ret = stringToUTF8OnStack(str)
+ }
+ 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(...cArgs);
+
+ function onDone(ret) {
+ if (stack !== 0) stackRestore(stack);
+ return convertReturnValue(ret)
+ }
+ ret = onDone(ret);
+ return ret
+ };
+ var 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 (...args) => ccall(ident, returnType, argTypes, args, opts)
+ };
+ var uleb128Encode = (n, target) => {
+ if (n < 128) {
+ target.push(n)
+ } else {
+ target.push(n % 128 | 128, n >> 7)
+ }
+ };
+ var sigToWasmTypes = sig => {
+ var typeNames = {
+ i: "i32",
+ j: "i64",
+ f: "f32",
+ d: "f64",
+ e: "externref",
+ p: "i32"
+ };
+ var type = {
+ parameters: [],
+ results: sig[0] == "v" ? [] : [typeNames[sig[0]]]
+ };
+ for (var i = 1; i < sig.length; ++i) {
+ type.parameters.push(typeNames[sig[i]])
+ }
+ return type
+ };
+ var generateFuncType = (sig, target) => {
+ var sigRet = sig.slice(0, 1);
+ var sigParam = sig.slice(1);
+ var typeCodes = {
+ i: 127,
+ p: 127,
+ j: 126,
+ f: 125,
+ d: 124,
+ e: 111
+ };
+ target.push(96);
+ uleb128Encode(sigParam.length, target);
+ for (var paramType of sigParam) {
+ target.push(typeCodes[paramType])
+ }
+ if (sigRet == "v") {
+ target.push(0)
+ } else {
+ target.push(1, typeCodes[sigRet])
+ }
+ };
+ var convertJsFunctionToWasm = (func, sig) => {
+ if (typeof WebAssembly.Function == "function") {
+ return new WebAssembly.Function(sigToWasmTypes(sig), func)
+ }
+ var typeSectionBody = [1];
+ generateFuncType(sig, typeSectionBody);
+ var bytes = [0, 97, 115, 109, 1, 0, 0, 0, 1];
+ uleb128Encode(typeSectionBody.length, bytes);
+ bytes.push(...typeSectionBody);
+ bytes.push(2, 7, 1, 1, 101, 1, 102, 0, 0, 7, 5, 1, 1, 102, 0, 0);
+ var module = new WebAssembly.Module(new Uint8Array(bytes));
+ var instance = new WebAssembly.Instance(module, {
+ e: {
+ f: func
+ }
+ });
+ var wrappedFunc = instance.exports["f"];
+ return wrappedFunc
+ };
+ var updateTableMap = (offset, count) => {
+ if (functionsInTableMap) {
+ for (var i = offset; i < offset + count; i++) {
+ var item = getWasmTableEntry(i);
+ if (item) {
+ functionsInTableMap.set(item, i)
+ }
+ }
+ }
+ };
+ var functionsInTableMap;
+ var getFunctionAddress = func => {
+ if (!functionsInTableMap) {
+ functionsInTableMap = new WeakMap;
+ updateTableMap(0, wasmTable.length)
+ }
+ return functionsInTableMap.get(func) || 0
+ };
+ var freeTableIndexes = [];
+ var getEmptyTableSlot = () => {
+ if (freeTableIndexes.length) {
+ return freeTableIndexes.pop()
+ }
+ try {
+ wasmTable.grow(1)
+ } catch (err) {
+ if (!(err instanceof RangeError)) {
+ throw err
+ }
+ throw "Unable to grow wasm table. Set ALLOW_TABLE_GROWTH."
+ }
+ return wasmTable.length - 1
+ };
+ var setWasmTableEntry = (idx, func) => {
+ wasmTable.set(idx, func);
+ wasmTableMirror[idx] = wasmTable.get(idx)
+ };
+ var addFunction = (func, sig) => {
+ var rtn = getFunctionAddress(func);
+ if (rtn) {
+ return rtn
+ }
+ var ret = getEmptyTableSlot();
+ try {
+ setWasmTableEntry(ret, func)
+ } catch (err) {
+ if (!(err instanceof TypeError)) {
+ throw err
+ }
+ var wrapped = convertJsFunctionToWasm(func, sig);
+ setWasmTableEntry(ret, wrapped)
+ }
+ functionsInTableMap.set(func, ret);
+ return ret
+ };
+ var removeFunction = index => {
+ functionsInTableMap.delete(getWasmTableEntry(index));
+ setWasmTableEntry(index, null);
+ freeTableIndexes.push(index)
+ };
+ FS.createPreloadedFile = FS_createPreloadedFile;
+ FS.staticInit();
+ Module["FS"] = FS;
+ MEMFS.doesNotExistError = new FS.ErrnoError(44);
+ MEMFS.doesNotExistError.stack = ""; {
+ if (Module["noExitRuntime"]) noExitRuntime = Module["noExitRuntime"];
+ if (Module["preloadPlugins"]) preloadPlugins = Module["preloadPlugins"];
+ if (Module["print"]) out = Module["print"];
+ if (Module["printErr"]) err = Module["printErr"];
+ if (Module["wasmBinary"]) wasmBinary = Module["wasmBinary"];
+ if (Module["arguments"]) arguments_ = Module["arguments"];
+ if (Module["thisProgram"]) thisProgram = Module["thisProgram"]
+ }
+ Module["ccall"] = ccall;
+ Module["cwrap"] = cwrap;
+ Module["addFunction"] = addFunction;
+ Module["removeFunction"] = removeFunction;
+ Module["setValue"] = setValue;
+ var _FPDFAnnot_IsSupportedSubtype, _FPDFPage_CreateAnnot, _FPDFPage_GetAnnotCount, _FPDFPage_GetAnnot, _FPDFPage_GetAnnotIndex, _FPDFPage_CloseAnnot, _FPDFPage_RemoveAnnot, _FPDFAnnot_GetSubtype, _FPDFAnnot_IsObjectSupportedSubtype, _FPDFAnnot_UpdateObject, _FPDFAnnot_AddInkStroke, _FPDFAnnot_RemoveInkList, _FPDFAnnot_AppendObject, _FPDFAnnot_GetObjectCount, _FPDFAnnot_GetObject, _FPDFAnnot_RemoveObject, _FPDFAnnot_SetColor, _FPDFAnnot_GetColor, _FPDFAnnot_HasAttachmentPoints, _FPDFAnnot_SetAttachmentPoints, _FPDFAnnot_AppendAttachmentPoints, _FPDFAnnot_CountAttachmentPoints, _FPDFAnnot_GetAttachmentPoints, _FPDFAnnot_SetRect, _FPDFAnnot_GetRect, _FPDFAnnot_GetVertices, _FPDFAnnot_GetInkListCount, _FPDFAnnot_GetInkListPath, _FPDFAnnot_GetLine, _FPDFAnnot_SetBorder, _FPDFAnnot_GetBorder, _FPDFAnnot_HasKey, _FPDFAnnot_GetValueType, _FPDFAnnot_SetStringValue, _FPDFAnnot_GetStringValue, _FPDFAnnot_GetNumberValue, _FPDFAnnot_SetAP, _FPDFAnnot_GetAP, _FPDFAnnot_GetLinkedAnnot, _FPDFAnnot_GetFlags, _FPDFAnnot_SetFlags, _FPDFAnnot_GetFormFieldFlags, _FPDFAnnot_SetFormFieldFlags, _FPDFAnnot_GetFormFieldAtPoint, _FPDFAnnot_GetFormFieldName, _FPDFAnnot_GetFormFieldType, _FPDFAnnot_GetFormAdditionalActionJavaScript, _FPDFAnnot_GetFormFieldAlternateName, _FPDFAnnot_GetFormFieldValue, _FPDFAnnot_GetOptionCount, _FPDFAnnot_GetOptionLabel, _FPDFAnnot_IsOptionSelected, _FPDFAnnot_GetFontSize, _FPDFAnnot_SetFontColor, _FPDFAnnot_GetFontColor, _FPDFAnnot_IsChecked, _FPDFAnnot_SetFocusableSubtypes, _FPDFAnnot_GetFocusableSubtypesCount, _FPDFAnnot_GetFocusableSubtypes, _FPDFAnnot_GetLink, _FPDFAnnot_GetFormControlCount, _FPDFAnnot_GetFormControlIndex, _FPDFAnnot_GetFormFieldExportValue, _FPDFAnnot_SetURI, _FPDFAnnot_GetFileAttachment, _FPDFAnnot_AddFileAttachment, _FPDFDoc_GetAttachmentCount, _FPDFDoc_AddAttachment, _FPDFDoc_GetAttachment, _FPDFDoc_DeleteAttachment, _FPDFAttachment_GetName, _FPDFAttachment_HasKey, _FPDFAttachment_GetValueType, _FPDFAttachment_SetStringValue, _FPDFAttachment_GetStringValue, _FPDFAttachment_SetFile, _FPDFAttachment_GetFile, _FPDFAttachment_GetSubtype, _FPDFCatalog_IsTagged, _FPDFCatalog_SetLanguage, _FPDFAvail_Create, _FPDFAvail_Destroy, _FPDFAvail_IsDocAvail, _FPDFAvail_GetDocument, _FPDFAvail_GetFirstPageNum, _FPDFAvail_IsPageAvail, _FPDFAvail_IsFormAvail, _FPDFAvail_IsLinearized, _FPDFBookmark_GetFirstChild, _FPDFBookmark_GetNextSibling, _FPDFBookmark_GetTitle, _FPDFBookmark_GetCount, _FPDFBookmark_Find, _FPDFBookmark_GetDest, _FPDFBookmark_GetAction, _FPDFAction_GetType, _FPDFAction_GetDest, _FPDFAction_GetFilePath, _FPDFAction_GetURIPath, _FPDFDest_GetDestPageIndex, _FPDFDest_GetView, _FPDFDest_GetLocationInPage, _FPDFLink_GetLinkAtPoint, _FPDFLink_GetLinkZOrderAtPoint, _FPDFLink_GetDest, _FPDFLink_GetAction, _FPDFLink_Enumerate, _FPDFLink_GetAnnot, _FPDFLink_GetAnnotRect, _FPDFLink_CountQuadPoints, _FPDFLink_GetQuadPoints, _FPDF_GetPageAAction, _FPDF_GetFileIdentifier, _FPDF_GetMetaText, _FPDF_GetPageLabel, _FPDFPageObj_NewImageObj, _FPDFImageObj_LoadJpegFile, _FPDFImageObj_LoadJpegFileInline, _FPDFImageObj_SetMatrix, _FPDFImageObj_SetBitmap, _FPDFImageObj_GetBitmap, _FPDFImageObj_GetRenderedBitmap, _FPDFImageObj_GetImageDataDecoded, _FPDFImageObj_GetImageDataRaw, _FPDFImageObj_GetImageFilterCount, _FPDFImageObj_GetImageFilter, _FPDFImageObj_GetImageMetadata, _FPDFImageObj_GetImagePixelSize, _FPDFImageObj_GetIccProfileDataDecoded, _FPDF_CreateNewDocument, _FPDFPage_Delete, _FPDF_MovePages, _FPDFPage_New, _FPDFPage_GetRotation, _FPDFPage_InsertObject, _FPDFPage_InsertObjectAtIndex, _FPDFPage_RemoveObject, _FPDFPage_CountObjects, _FPDFPage_GetObject, _FPDFPage_HasTransparency, _FPDFPageObj_Destroy, _FPDFPageObj_GetMarkedContentID, _FPDFPageObj_CountMarks, _FPDFPageObj_GetMark, _FPDFPageObj_AddMark, _FPDFPageObj_RemoveMark, _FPDFPageObjMark_GetName, _FPDFPageObjMark_CountParams, _FPDFPageObjMark_GetParamKey, _FPDFPageObjMark_GetParamValueType, _FPDFPageObjMark_GetParamIntValue, _FPDFPageObjMark_GetParamStringValue, _FPDFPageObjMark_GetParamBlobValue, _FPDFPageObj_HasTransparency, _FPDFPageObjMark_SetIntParam, _FPDFPageObjMark_SetStringParam, _FPDFPageObjMark_SetBlobParam, _FPDFPageObjMark_RemoveParam, _FPDFPageObj_GetType, _FPDFPageObj_GetIsActive, _FPDFPageObj_SetIsActive, _FPDFPage_GenerateContent, _FPDFPageObj_Transform, _FPDFPageObj_TransformF, _FPDFPageObj_GetMatrix, _FPDFPageObj_SetMatrix, _FPDFPageObj_SetBlendMode, _FPDFPage_TransformAnnots, _FPDFPage_SetRotation, _FPDFPageObj_SetFillColor, _FPDFPageObj_GetFillColor, _FPDFPageObj_GetBounds, _FPDFPageObj_GetRotatedBounds, _FPDFPageObj_SetStrokeColor, _FPDFPageObj_GetStrokeColor, _FPDFPageObj_SetStrokeWidth, _FPDFPageObj_GetStrokeWidth, _FPDFPageObj_GetLineJoin, _FPDFPageObj_SetLineJoin, _FPDFPageObj_GetLineCap, _FPDFPageObj_SetLineCap, _FPDFPageObj_GetDashPhase, _FPDFPageObj_SetDashPhase, _FPDFPageObj_GetDashCount, _FPDFPageObj_GetDashArray, _FPDFPageObj_SetDashArray, _FPDFFormObj_CountObjects, _FPDFFormObj_GetObject, _FPDFFormObj_RemoveObject, _FPDFPageObj_CreateNewPath, _FPDFPageObj_CreateNewRect, _FPDFPath_CountSegments, _FPDFPath_GetPathSegment, _FPDFPath_MoveTo, _FPDFPath_LineTo, _FPDFPath_BezierTo, _FPDFPath_Close, _FPDFPath_SetDrawMode, _FPDFPath_GetDrawMode, _FPDFPathSegment_GetPoint, _FPDFPathSegment_GetType, _FPDFPathSegment_GetClose, _FPDFPageObj_NewTextObj, _FPDFText_SetText, _FPDFText_SetCharcodes, _FPDFText_LoadFont, _FPDFText_LoadStandardFont, _FPDFText_LoadCidType2Font, _FPDFTextObj_GetFontSize, _FPDFTextObj_GetText, _FPDFTextObj_GetRenderedBitmap, _FPDFFont_Close, _FPDFPageObj_CreateTextObj, _FPDFTextObj_GetTextRenderMode, _FPDFTextObj_SetTextRenderMode, _FPDFTextObj_GetFont, _FPDFFont_GetBaseFontName, _FPDFFont_GetFamilyName, _FPDFFont_GetFontData, _FPDFFont_GetIsEmbedded, _FPDFFont_GetFlags, _FPDFFont_GetWeight, _FPDFFont_GetItalicAngle, _FPDFFont_GetAscent, _FPDFFont_GetDescent, _FPDFFont_GetGlyphWidth, _FPDFFont_GetGlyphPath, _FPDFGlyphPath_CountGlyphSegments, _FPDFGlyphPath_GetGlyphPathSegment, _FSDK_SetUnSpObjProcessHandler, _FSDK_SetTimeFunction, _FSDK_SetLocaltimeFunction, _FPDFDoc_GetPageMode, _FPDFPage_Flatten, _FPDFPage_HasFormFieldAtPoint, _FPDFPage_FormFieldZOrderAtPoint, _FPDFDOC_InitFormFillEnvironment, _FPDFDOC_ExitFormFillEnvironment, _FORM_OnMouseMove, _FORM_OnMouseWheel, _FORM_OnFocus, _FORM_OnLButtonDown, _FORM_OnLButtonUp, _FORM_OnLButtonDoubleClick, _FORM_OnRButtonDown, _FORM_OnRButtonUp, _FORM_OnKeyDown, _FORM_OnKeyUp, _FORM_OnChar, _FORM_GetFocusedText, _FORM_GetSelectedText, _FORM_ReplaceAndKeepSelection, _FORM_ReplaceSelection, _FORM_SelectAllText, _FORM_CanUndo, _FORM_CanRedo, _FORM_Undo, _FORM_Redo, _FORM_ForceToKillFocus, _FORM_GetFocusedAnnot, _FORM_SetFocusedAnnot, _FPDF_FFLDraw, _FPDF_SetFormFieldHighlightColor, _FPDF_SetFormFieldHighlightAlpha, _FPDF_RemoveFormFieldHighlight, _FORM_OnAfterLoadPage, _FORM_OnBeforeClosePage, _FORM_DoDocumentJSAction, _FORM_DoDocumentOpenAction, _FORM_DoDocumentAAction, _FORM_DoPageAAction, _FORM_SetIndexSelected, _FORM_IsIndexSelected, _FPDFDoc_GetJavaScriptActionCount, _FPDFDoc_GetJavaScriptAction, _FPDFDoc_CloseJavaScriptAction, _FPDFJavaScriptAction_GetName, _FPDFJavaScriptAction_GetScript, _FPDF_ImportPagesByIndex, _FPDF_ImportPages, _FPDF_ImportNPagesToOne, _FPDF_NewXObjectFromPage, _FPDF_CloseXObject, _FPDF_NewFormObjectFromXObject, _FPDF_CopyViewerPreferences, _FPDF_RenderPageBitmapWithColorScheme_Start, _FPDF_RenderPageBitmap_Start, _FPDF_RenderPage_Continue, _FPDF_RenderPage_Close, _FPDF_SaveAsCopy, _FPDF_SaveWithVersion, _FPDFText_GetCharIndexFromTextIndex, _FPDFText_GetTextIndexFromCharIndex, _FPDF_GetSignatureCount, _FPDF_GetSignatureObject, _FPDFSignatureObj_GetContents, _FPDFSignatureObj_GetByteRange, _FPDFSignatureObj_GetSubFilter, _FPDFSignatureObj_GetReason, _FPDFSignatureObj_GetTime, _FPDFSignatureObj_GetDocMDPPermission, _FPDF_StructTree_GetForPage, _FPDF_StructTree_Close, _FPDF_StructTree_CountChildren, _FPDF_StructTree_GetChildAtIndex, _FPDF_StructElement_GetAltText, _FPDF_StructElement_GetActualText, _FPDF_StructElement_GetID, _FPDF_StructElement_GetLang, _FPDF_StructElement_GetAttributeCount, _FPDF_StructElement_GetAttributeAtIndex, _FPDF_StructElement_GetStringAttribute, _FPDF_StructElement_GetMarkedContentID, _FPDF_StructElement_GetType, _FPDF_StructElement_GetObjType, _FPDF_StructElement_GetTitle, _FPDF_StructElement_CountChildren, _FPDF_StructElement_GetChildAtIndex, _FPDF_StructElement_GetChildMarkedContentID, _FPDF_StructElement_GetParent, _FPDF_StructElement_Attr_GetCount, _FPDF_StructElement_Attr_GetName, _FPDF_StructElement_Attr_GetValue, _FPDF_StructElement_Attr_GetType, _FPDF_StructElement_Attr_GetBooleanValue, _FPDF_StructElement_Attr_GetNumberValue, _FPDF_StructElement_Attr_GetStringValue, _FPDF_StructElement_Attr_GetBlobValue, _FPDF_StructElement_Attr_CountChildren, _FPDF_StructElement_Attr_GetChildAtIndex, _FPDF_StructElement_GetMarkedContentIdCount, _FPDF_StructElement_GetMarkedContentIdAtIndex, _FPDF_AddInstalledFont, _FPDF_SetSystemFontInfo, _FPDF_GetDefaultTTFMap, _FPDF_GetDefaultTTFMapCount, _FPDF_GetDefaultTTFMapEntry, _FPDF_GetDefaultSystemFontInfo, _FPDF_FreeDefaultSystemFontInfo, _FPDFText_LoadPage, _FPDFText_ClosePage, _FPDFText_CountChars, _FPDFText_GetUnicode, _FPDFText_GetTextObject, _FPDFText_IsGenerated, _FPDFText_IsHyphen, _FPDFText_HasUnicodeMapError, _FPDFText_GetFontSize, _FPDFText_GetFontInfo, _FPDFText_GetFontWeight, _FPDFText_GetFillColor, _FPDFText_GetStrokeColor, _FPDFText_GetCharAngle, _FPDFText_GetCharBox, _FPDFText_GetLooseCharBox, _FPDFText_GetMatrix, _FPDFText_GetCharOrigin, _FPDFText_GetCharIndexAtPos, _FPDFText_GetText, _FPDFText_CountRects, _FPDFText_GetRect, _FPDFText_GetBoundedText, _FPDFText_FindStart, _FPDFText_FindNext, _FPDFText_FindPrev, _FPDFText_GetSchResultIndex, _FPDFText_GetSchCount, _FPDFText_FindClose, _FPDFLink_LoadWebLinks, _FPDFLink_CountWebLinks, _FPDFLink_GetURL, _FPDFLink_CountRects, _FPDFLink_GetRect, _FPDFLink_GetTextRange, _FPDFLink_CloseWebLinks, _FPDFPage_GetDecodedThumbnailData, _FPDFPage_GetRawThumbnailData, _FPDFPage_GetThumbnailAsBitmap, _FPDFPage_SetMediaBox, _FPDFPage_SetCropBox, _FPDFPage_SetBleedBox, _FPDFPage_SetTrimBox, _FPDFPage_SetArtBox, _FPDFPage_GetMediaBox, _FPDFPage_GetCropBox, _FPDFPage_GetBleedBox, _FPDFPage_GetTrimBox, _FPDFPage_GetArtBox, _FPDFPage_TransFormWithClip, _FPDFPageObj_TransformClipPath, _FPDFPageObj_GetClipPath, _FPDFClipPath_CountPaths, _FPDFClipPath_CountPathSegments, _FPDFClipPath_GetPathSegment, _FPDF_CreateClipPath, _FPDF_DestroyClipPath, _FPDFPage_InsertClipPath, _FPDF_InitLibrary, _FPDF_InitLibraryWithConfig, _FPDF_DestroyLibrary, _FPDF_SetSandBoxPolicy, _FPDF_LoadDocument, _FPDF_GetFormType, _FPDF_LoadXFA, _FPDF_LoadMemDocument, _FPDF_LoadMemDocument64, _FPDF_LoadCustomDocument, _FPDF_GetFileVersion, _FPDF_DocumentHasValidCrossReferenceTable, _FPDF_GetDocPermissions, _FPDF_GetDocUserPermissions, _FPDF_GetSecurityHandlerRevision, _FPDF_GetPageCount, _FPDF_LoadPage, _FPDF_GetPageWidthF, _FPDF_GetPageWidth, _FPDF_GetPageHeightF, _FPDF_GetPageHeight, _FPDF_GetPageBoundingBox, _FPDF_RenderPageBitmap, _FPDF_RenderPageBitmapWithMatrix, _FPDF_ClosePage, _FPDF_CloseDocument, _FPDF_GetLastError, _FPDF_DeviceToPage, _FPDF_PageToDevice, _FPDFBitmap_Create, _FPDFBitmap_CreateEx, _FPDFBitmap_GetFormat, _FPDFBitmap_FillRect, _FPDFBitmap_GetBuffer, _FPDFBitmap_GetWidth, _FPDFBitmap_GetHeight, _FPDFBitmap_GetStride, _FPDFBitmap_Destroy, _FPDF_GetPageSizeByIndexF, _FPDF_GetPageSizeByIndex, _FPDF_VIEWERREF_GetPrintScaling, _FPDF_VIEWERREF_GetNumCopies, _FPDF_VIEWERREF_GetPrintPageRange, _FPDF_VIEWERREF_GetPrintPageRangeCount, _FPDF_VIEWERREF_GetPrintPageRangeElement, _FPDF_VIEWERREF_GetDuplex, _FPDF_VIEWERREF_GetName, _FPDF_CountNamedDests, _FPDF_GetNamedDestByName, _FPDF_GetNamedDest, _FPDF_GetXFAPacketCount, _FPDF_GetXFAPacketName, _FPDF_GetXFAPacketContent, _FPDF_GetTrailerEnds, _emscripten_builtin_memalign, _malloc, _free, _calloc, _realloc, _setThrew, __emscripten_stack_restore, __emscripten_stack_alloc, _emscripten_stack_get_current;
+
+ function assignWasmExports(wasmExports) {
+ Module["_FPDFAnnot_IsSupportedSubtype"] = _FPDFAnnot_IsSupportedSubtype = wasmExports["FPDFAnnot_IsSupportedSubtype"];
+ Module["_FPDFPage_CreateAnnot"] = _FPDFPage_CreateAnnot = wasmExports["FPDFPage_CreateAnnot"];
+ Module["_FPDFPage_GetAnnotCount"] = _FPDFPage_GetAnnotCount = wasmExports["FPDFPage_GetAnnotCount"];
+ Module["_FPDFPage_GetAnnot"] = _FPDFPage_GetAnnot = wasmExports["FPDFPage_GetAnnot"];
+ Module["_FPDFPage_GetAnnotIndex"] = _FPDFPage_GetAnnotIndex = wasmExports["FPDFPage_GetAnnotIndex"];
+ Module["_FPDFPage_CloseAnnot"] = _FPDFPage_CloseAnnot = wasmExports["FPDFPage_CloseAnnot"];
+ Module["_FPDFPage_RemoveAnnot"] = _FPDFPage_RemoveAnnot = wasmExports["FPDFPage_RemoveAnnot"];
+ Module["_FPDFAnnot_GetSubtype"] = _FPDFAnnot_GetSubtype = wasmExports["FPDFAnnot_GetSubtype"];
+ Module["_FPDFAnnot_IsObjectSupportedSubtype"] = _FPDFAnnot_IsObjectSupportedSubtype = wasmExports["FPDFAnnot_IsObjectSupportedSubtype"];
+ Module["_FPDFAnnot_UpdateObject"] = _FPDFAnnot_UpdateObject = wasmExports["FPDFAnnot_UpdateObject"];
+ Module["_FPDFAnnot_AddInkStroke"] = _FPDFAnnot_AddInkStroke = wasmExports["FPDFAnnot_AddInkStroke"];
+ Module["_FPDFAnnot_RemoveInkList"] = _FPDFAnnot_RemoveInkList = wasmExports["FPDFAnnot_RemoveInkList"];
+ Module["_FPDFAnnot_AppendObject"] = _FPDFAnnot_AppendObject = wasmExports["FPDFAnnot_AppendObject"];
+ Module["_FPDFAnnot_GetObjectCount"] = _FPDFAnnot_GetObjectCount = wasmExports["FPDFAnnot_GetObjectCount"];
+ Module["_FPDFAnnot_GetObject"] = _FPDFAnnot_GetObject = wasmExports["FPDFAnnot_GetObject"];
+ Module["_FPDFAnnot_RemoveObject"] = _FPDFAnnot_RemoveObject = wasmExports["FPDFAnnot_RemoveObject"];
+ Module["_FPDFAnnot_SetColor"] = _FPDFAnnot_SetColor = wasmExports["FPDFAnnot_SetColor"];
+ Module["_FPDFAnnot_GetColor"] = _FPDFAnnot_GetColor = wasmExports["FPDFAnnot_GetColor"];
+ Module["_FPDFAnnot_HasAttachmentPoints"] = _FPDFAnnot_HasAttachmentPoints = wasmExports["FPDFAnnot_HasAttachmentPoints"];
+ Module["_FPDFAnnot_SetAttachmentPoints"] = _FPDFAnnot_SetAttachmentPoints = wasmExports["FPDFAnnot_SetAttachmentPoints"];
+ Module["_FPDFAnnot_AppendAttachmentPoints"] = _FPDFAnnot_AppendAttachmentPoints = wasmExports["FPDFAnnot_AppendAttachmentPoints"];
+ Module["_FPDFAnnot_CountAttachmentPoints"] = _FPDFAnnot_CountAttachmentPoints = wasmExports["FPDFAnnot_CountAttachmentPoints"];
+ Module["_FPDFAnnot_GetAttachmentPoints"] = _FPDFAnnot_GetAttachmentPoints = wasmExports["FPDFAnnot_GetAttachmentPoints"];
+ Module["_FPDFAnnot_SetRect"] = _FPDFAnnot_SetRect = wasmExports["FPDFAnnot_SetRect"];
+ Module["_FPDFAnnot_GetRect"] = _FPDFAnnot_GetRect = wasmExports["FPDFAnnot_GetRect"];
+ Module["_FPDFAnnot_GetVertices"] = _FPDFAnnot_GetVertices = wasmExports["FPDFAnnot_GetVertices"];
+ Module["_FPDFAnnot_GetInkListCount"] = _FPDFAnnot_GetInkListCount = wasmExports["FPDFAnnot_GetInkListCount"];
+ Module["_FPDFAnnot_GetInkListPath"] = _FPDFAnnot_GetInkListPath = wasmExports["FPDFAnnot_GetInkListPath"];
+ Module["_FPDFAnnot_GetLine"] = _FPDFAnnot_GetLine = wasmExports["FPDFAnnot_GetLine"];
+ Module["_FPDFAnnot_SetBorder"] = _FPDFAnnot_SetBorder = wasmExports["FPDFAnnot_SetBorder"];
+ Module["_FPDFAnnot_GetBorder"] = _FPDFAnnot_GetBorder = wasmExports["FPDFAnnot_GetBorder"];
+ Module["_FPDFAnnot_HasKey"] = _FPDFAnnot_HasKey = wasmExports["FPDFAnnot_HasKey"];
+ Module["_FPDFAnnot_GetValueType"] = _FPDFAnnot_GetValueType = wasmExports["FPDFAnnot_GetValueType"];
+ Module["_FPDFAnnot_SetStringValue"] = _FPDFAnnot_SetStringValue = wasmExports["FPDFAnnot_SetStringValue"];
+ Module["_FPDFAnnot_GetStringValue"] = _FPDFAnnot_GetStringValue = wasmExports["FPDFAnnot_GetStringValue"];
+ Module["_FPDFAnnot_GetNumberValue"] = _FPDFAnnot_GetNumberValue = wasmExports["FPDFAnnot_GetNumberValue"];
+ Module["_FPDFAnnot_SetAP"] = _FPDFAnnot_SetAP = wasmExports["FPDFAnnot_SetAP"];
+ Module["_FPDFAnnot_GetAP"] = _FPDFAnnot_GetAP = wasmExports["FPDFAnnot_GetAP"];
+ Module["_FPDFAnnot_GetLinkedAnnot"] = _FPDFAnnot_GetLinkedAnnot = wasmExports["FPDFAnnot_GetLinkedAnnot"];
+ Module["_FPDFAnnot_GetFlags"] = _FPDFAnnot_GetFlags = wasmExports["FPDFAnnot_GetFlags"];
+ Module["_FPDFAnnot_SetFlags"] = _FPDFAnnot_SetFlags = wasmExports["FPDFAnnot_SetFlags"];
+ Module["_FPDFAnnot_GetFormFieldFlags"] = _FPDFAnnot_GetFormFieldFlags = wasmExports["FPDFAnnot_GetFormFieldFlags"];
+ Module["_FPDFAnnot_SetFormFieldFlags"] = _FPDFAnnot_SetFormFieldFlags = wasmExports["FPDFAnnot_SetFormFieldFlags"];
+ Module["_FPDFAnnot_GetFormFieldAtPoint"] = _FPDFAnnot_GetFormFieldAtPoint = wasmExports["FPDFAnnot_GetFormFieldAtPoint"];
+ Module["_FPDFAnnot_GetFormFieldName"] = _FPDFAnnot_GetFormFieldName = wasmExports["FPDFAnnot_GetFormFieldName"];
+ Module["_FPDFAnnot_GetFormFieldType"] = _FPDFAnnot_GetFormFieldType = wasmExports["FPDFAnnot_GetFormFieldType"];
+ Module["_FPDFAnnot_GetFormAdditionalActionJavaScript"] = _FPDFAnnot_GetFormAdditionalActionJavaScript = wasmExports["FPDFAnnot_GetFormAdditionalActionJavaScript"];
+ Module["_FPDFAnnot_GetFormFieldAlternateName"] = _FPDFAnnot_GetFormFieldAlternateName = wasmExports["FPDFAnnot_GetFormFieldAlternateName"];
+ Module["_FPDFAnnot_GetFormFieldValue"] = _FPDFAnnot_GetFormFieldValue = wasmExports["FPDFAnnot_GetFormFieldValue"];
+ Module["_FPDFAnnot_GetOptionCount"] = _FPDFAnnot_GetOptionCount = wasmExports["FPDFAnnot_GetOptionCount"];
+ Module["_FPDFAnnot_GetOptionLabel"] = _FPDFAnnot_GetOptionLabel = wasmExports["FPDFAnnot_GetOptionLabel"];
+ Module["_FPDFAnnot_IsOptionSelected"] = _FPDFAnnot_IsOptionSelected = wasmExports["FPDFAnnot_IsOptionSelected"];
+ Module["_FPDFAnnot_GetFontSize"] = _FPDFAnnot_GetFontSize = wasmExports["FPDFAnnot_GetFontSize"];
+ Module["_FPDFAnnot_SetFontColor"] = _FPDFAnnot_SetFontColor = wasmExports["FPDFAnnot_SetFontColor"];
+ Module["_FPDFAnnot_GetFontColor"] = _FPDFAnnot_GetFontColor = wasmExports["FPDFAnnot_GetFontColor"];
+ Module["_FPDFAnnot_IsChecked"] = _FPDFAnnot_IsChecked = wasmExports["FPDFAnnot_IsChecked"];
+ Module["_FPDFAnnot_SetFocusableSubtypes"] = _FPDFAnnot_SetFocusableSubtypes = wasmExports["FPDFAnnot_SetFocusableSubtypes"];
+ Module["_FPDFAnnot_GetFocusableSubtypesCount"] = _FPDFAnnot_GetFocusableSubtypesCount = wasmExports["FPDFAnnot_GetFocusableSubtypesCount"];
+ Module["_FPDFAnnot_GetFocusableSubtypes"] = _FPDFAnnot_GetFocusableSubtypes = wasmExports["FPDFAnnot_GetFocusableSubtypes"];
+ Module["_FPDFAnnot_GetLink"] = _FPDFAnnot_GetLink = wasmExports["FPDFAnnot_GetLink"];
+ Module["_FPDFAnnot_GetFormControlCount"] = _FPDFAnnot_GetFormControlCount = wasmExports["FPDFAnnot_GetFormControlCount"];
+ Module["_FPDFAnnot_GetFormControlIndex"] = _FPDFAnnot_GetFormControlIndex = wasmExports["FPDFAnnot_GetFormControlIndex"];
+ Module["_FPDFAnnot_GetFormFieldExportValue"] = _FPDFAnnot_GetFormFieldExportValue = wasmExports["FPDFAnnot_GetFormFieldExportValue"];
+ Module["_FPDFAnnot_SetURI"] = _FPDFAnnot_SetURI = wasmExports["FPDFAnnot_SetURI"];
+ Module["_FPDFAnnot_GetFileAttachment"] = _FPDFAnnot_GetFileAttachment = wasmExports["FPDFAnnot_GetFileAttachment"];
+ Module["_FPDFAnnot_AddFileAttachment"] = _FPDFAnnot_AddFileAttachment = wasmExports["FPDFAnnot_AddFileAttachment"];
+ Module["_FPDFDoc_GetAttachmentCount"] = _FPDFDoc_GetAttachmentCount = wasmExports["FPDFDoc_GetAttachmentCount"];
+ Module["_FPDFDoc_AddAttachment"] = _FPDFDoc_AddAttachment = wasmExports["FPDFDoc_AddAttachment"];
+ Module["_FPDFDoc_GetAttachment"] = _FPDFDoc_GetAttachment = wasmExports["FPDFDoc_GetAttachment"];
+ Module["_FPDFDoc_DeleteAttachment"] = _FPDFDoc_DeleteAttachment = wasmExports["FPDFDoc_DeleteAttachment"];
+ Module["_FPDFAttachment_GetName"] = _FPDFAttachment_GetName = wasmExports["FPDFAttachment_GetName"];
+ Module["_FPDFAttachment_HasKey"] = _FPDFAttachment_HasKey = wasmExports["FPDFAttachment_HasKey"];
+ Module["_FPDFAttachment_GetValueType"] = _FPDFAttachment_GetValueType = wasmExports["FPDFAttachment_GetValueType"];
+ Module["_FPDFAttachment_SetStringValue"] = _FPDFAttachment_SetStringValue = wasmExports["FPDFAttachment_SetStringValue"];
+ Module["_FPDFAttachment_GetStringValue"] = _FPDFAttachment_GetStringValue = wasmExports["FPDFAttachment_GetStringValue"];
+ Module["_FPDFAttachment_SetFile"] = _FPDFAttachment_SetFile = wasmExports["FPDFAttachment_SetFile"];
+ Module["_FPDFAttachment_GetFile"] = _FPDFAttachment_GetFile = wasmExports["FPDFAttachment_GetFile"];
+ Module["_FPDFAttachment_GetSubtype"] = _FPDFAttachment_GetSubtype = wasmExports["FPDFAttachment_GetSubtype"];
+ Module["_FPDFCatalog_IsTagged"] = _FPDFCatalog_IsTagged = wasmExports["FPDFCatalog_IsTagged"];
+ Module["_FPDFCatalog_SetLanguage"] = _FPDFCatalog_SetLanguage = wasmExports["FPDFCatalog_SetLanguage"];
+ Module["_FPDFAvail_Create"] = _FPDFAvail_Create = wasmExports["FPDFAvail_Create"];
+ Module["_FPDFAvail_Destroy"] = _FPDFAvail_Destroy = wasmExports["FPDFAvail_Destroy"];
+ Module["_FPDFAvail_IsDocAvail"] = _FPDFAvail_IsDocAvail = wasmExports["FPDFAvail_IsDocAvail"];
+ Module["_FPDFAvail_GetDocument"] = _FPDFAvail_GetDocument = wasmExports["FPDFAvail_GetDocument"];
+ Module["_FPDFAvail_GetFirstPageNum"] = _FPDFAvail_GetFirstPageNum = wasmExports["FPDFAvail_GetFirstPageNum"];
+ Module["_FPDFAvail_IsPageAvail"] = _FPDFAvail_IsPageAvail = wasmExports["FPDFAvail_IsPageAvail"];
+ Module["_FPDFAvail_IsFormAvail"] = _FPDFAvail_IsFormAvail = wasmExports["FPDFAvail_IsFormAvail"];
+ Module["_FPDFAvail_IsLinearized"] = _FPDFAvail_IsLinearized = wasmExports["FPDFAvail_IsLinearized"];
+ Module["_FPDFBookmark_GetFirstChild"] = _FPDFBookmark_GetFirstChild = wasmExports["FPDFBookmark_GetFirstChild"];
+ Module["_FPDFBookmark_GetNextSibling"] = _FPDFBookmark_GetNextSibling = wasmExports["FPDFBookmark_GetNextSibling"];
+ Module["_FPDFBookmark_GetTitle"] = _FPDFBookmark_GetTitle = wasmExports["FPDFBookmark_GetTitle"];
+ Module["_FPDFBookmark_GetCount"] = _FPDFBookmark_GetCount = wasmExports["FPDFBookmark_GetCount"];
+ Module["_FPDFBookmark_Find"] = _FPDFBookmark_Find = wasmExports["FPDFBookmark_Find"];
+ Module["_FPDFBookmark_GetDest"] = _FPDFBookmark_GetDest = wasmExports["FPDFBookmark_GetDest"];
+ Module["_FPDFBookmark_GetAction"] = _FPDFBookmark_GetAction = wasmExports["FPDFBookmark_GetAction"];
+ Module["_FPDFAction_GetType"] = _FPDFAction_GetType = wasmExports["FPDFAction_GetType"];
+ Module["_FPDFAction_GetDest"] = _FPDFAction_GetDest = wasmExports["FPDFAction_GetDest"];
+ Module["_FPDFAction_GetFilePath"] = _FPDFAction_GetFilePath = wasmExports["FPDFAction_GetFilePath"];
+ Module["_FPDFAction_GetURIPath"] = _FPDFAction_GetURIPath = wasmExports["FPDFAction_GetURIPath"];
+ Module["_FPDFDest_GetDestPageIndex"] = _FPDFDest_GetDestPageIndex = wasmExports["FPDFDest_GetDestPageIndex"];
+ Module["_FPDFDest_GetView"] = _FPDFDest_GetView = wasmExports["FPDFDest_GetView"];
+ Module["_FPDFDest_GetLocationInPage"] = _FPDFDest_GetLocationInPage = wasmExports["FPDFDest_GetLocationInPage"];
+ Module["_FPDFLink_GetLinkAtPoint"] = _FPDFLink_GetLinkAtPoint = wasmExports["FPDFLink_GetLinkAtPoint"];
+ Module["_FPDFLink_GetLinkZOrderAtPoint"] = _FPDFLink_GetLinkZOrderAtPoint = wasmExports["FPDFLink_GetLinkZOrderAtPoint"];
+ Module["_FPDFLink_GetDest"] = _FPDFLink_GetDest = wasmExports["FPDFLink_GetDest"];
+ Module["_FPDFLink_GetAction"] = _FPDFLink_GetAction = wasmExports["FPDFLink_GetAction"];
+ Module["_FPDFLink_Enumerate"] = _FPDFLink_Enumerate = wasmExports["FPDFLink_Enumerate"];
+ Module["_FPDFLink_GetAnnot"] = _FPDFLink_GetAnnot = wasmExports["FPDFLink_GetAnnot"];
+ Module["_FPDFLink_GetAnnotRect"] = _FPDFLink_GetAnnotRect = wasmExports["FPDFLink_GetAnnotRect"];
+ Module["_FPDFLink_CountQuadPoints"] = _FPDFLink_CountQuadPoints = wasmExports["FPDFLink_CountQuadPoints"];
+ Module["_FPDFLink_GetQuadPoints"] = _FPDFLink_GetQuadPoints = wasmExports["FPDFLink_GetQuadPoints"];
+ Module["_FPDF_GetPageAAction"] = _FPDF_GetPageAAction = wasmExports["FPDF_GetPageAAction"];
+ Module["_FPDF_GetFileIdentifier"] = _FPDF_GetFileIdentifier = wasmExports["FPDF_GetFileIdentifier"];
+ Module["_FPDF_GetMetaText"] = _FPDF_GetMetaText = wasmExports["FPDF_GetMetaText"];
+ Module["_FPDF_GetPageLabel"] = _FPDF_GetPageLabel = wasmExports["FPDF_GetPageLabel"];
+ Module["_FPDFPageObj_NewImageObj"] = _FPDFPageObj_NewImageObj = wasmExports["FPDFPageObj_NewImageObj"];
+ Module["_FPDFImageObj_LoadJpegFile"] = _FPDFImageObj_LoadJpegFile = wasmExports["FPDFImageObj_LoadJpegFile"];
+ Module["_FPDFImageObj_LoadJpegFileInline"] = _FPDFImageObj_LoadJpegFileInline = wasmExports["FPDFImageObj_LoadJpegFileInline"];
+ Module["_FPDFImageObj_SetMatrix"] = _FPDFImageObj_SetMatrix = wasmExports["FPDFImageObj_SetMatrix"];
+ Module["_FPDFImageObj_SetBitmap"] = _FPDFImageObj_SetBitmap = wasmExports["FPDFImageObj_SetBitmap"];
+ Module["_FPDFImageObj_GetBitmap"] = _FPDFImageObj_GetBitmap = wasmExports["FPDFImageObj_GetBitmap"];
+ Module["_FPDFImageObj_GetRenderedBitmap"] = _FPDFImageObj_GetRenderedBitmap = wasmExports["FPDFImageObj_GetRenderedBitmap"];
+ Module["_FPDFImageObj_GetImageDataDecoded"] = _FPDFImageObj_GetImageDataDecoded = wasmExports["FPDFImageObj_GetImageDataDecoded"];
+ Module["_FPDFImageObj_GetImageDataRaw"] = _FPDFImageObj_GetImageDataRaw = wasmExports["FPDFImageObj_GetImageDataRaw"];
+ Module["_FPDFImageObj_GetImageFilterCount"] = _FPDFImageObj_GetImageFilterCount = wasmExports["FPDFImageObj_GetImageFilterCount"];
+ Module["_FPDFImageObj_GetImageFilter"] = _FPDFImageObj_GetImageFilter = wasmExports["FPDFImageObj_GetImageFilter"];
+ Module["_FPDFImageObj_GetImageMetadata"] = _FPDFImageObj_GetImageMetadata = wasmExports["FPDFImageObj_GetImageMetadata"];
+ Module["_FPDFImageObj_GetImagePixelSize"] = _FPDFImageObj_GetImagePixelSize = wasmExports["FPDFImageObj_GetImagePixelSize"];
+ Module["_FPDFImageObj_GetIccProfileDataDecoded"] = _FPDFImageObj_GetIccProfileDataDecoded = wasmExports["FPDFImageObj_GetIccProfileDataDecoded"];
+ Module["_FPDF_CreateNewDocument"] = _FPDF_CreateNewDocument = wasmExports["FPDF_CreateNewDocument"];
+ Module["_FPDFPage_Delete"] = _FPDFPage_Delete = wasmExports["FPDFPage_Delete"];
+ Module["_FPDF_MovePages"] = _FPDF_MovePages = wasmExports["FPDF_MovePages"];
+ Module["_FPDFPage_New"] = _FPDFPage_New = wasmExports["FPDFPage_New"];
+ Module["_FPDFPage_GetRotation"] = _FPDFPage_GetRotation = wasmExports["FPDFPage_GetRotation"];
+ Module["_FPDFPage_InsertObject"] = _FPDFPage_InsertObject = wasmExports["FPDFPage_InsertObject"];
+ Module["_FPDFPage_InsertObjectAtIndex"] = _FPDFPage_InsertObjectAtIndex = wasmExports["FPDFPage_InsertObjectAtIndex"];
+ Module["_FPDFPage_RemoveObject"] = _FPDFPage_RemoveObject = wasmExports["FPDFPage_RemoveObject"];
+ Module["_FPDFPage_CountObjects"] = _FPDFPage_CountObjects = wasmExports["FPDFPage_CountObjects"];
+ Module["_FPDFPage_GetObject"] = _FPDFPage_GetObject = wasmExports["FPDFPage_GetObject"];
+ Module["_FPDFPage_HasTransparency"] = _FPDFPage_HasTransparency = wasmExports["FPDFPage_HasTransparency"];
+ Module["_FPDFPageObj_Destroy"] = _FPDFPageObj_Destroy = wasmExports["FPDFPageObj_Destroy"];
+ Module["_FPDFPageObj_GetMarkedContentID"] = _FPDFPageObj_GetMarkedContentID = wasmExports["FPDFPageObj_GetMarkedContentID"];
+ Module["_FPDFPageObj_CountMarks"] = _FPDFPageObj_CountMarks = wasmExports["FPDFPageObj_CountMarks"];
+ Module["_FPDFPageObj_GetMark"] = _FPDFPageObj_GetMark = wasmExports["FPDFPageObj_GetMark"];
+ Module["_FPDFPageObj_AddMark"] = _FPDFPageObj_AddMark = wasmExports["FPDFPageObj_AddMark"];
+ Module["_FPDFPageObj_RemoveMark"] = _FPDFPageObj_RemoveMark = wasmExports["FPDFPageObj_RemoveMark"];
+ Module["_FPDFPageObjMark_GetName"] = _FPDFPageObjMark_GetName = wasmExports["FPDFPageObjMark_GetName"];
+ Module["_FPDFPageObjMark_CountParams"] = _FPDFPageObjMark_CountParams = wasmExports["FPDFPageObjMark_CountParams"];
+ Module["_FPDFPageObjMark_GetParamKey"] = _FPDFPageObjMark_GetParamKey = wasmExports["FPDFPageObjMark_GetParamKey"];
+ Module["_FPDFPageObjMark_GetParamValueType"] = _FPDFPageObjMark_GetParamValueType = wasmExports["FPDFPageObjMark_GetParamValueType"];
+ Module["_FPDFPageObjMark_GetParamIntValue"] = _FPDFPageObjMark_GetParamIntValue = wasmExports["FPDFPageObjMark_GetParamIntValue"];
+ Module["_FPDFPageObjMark_GetParamStringValue"] = _FPDFPageObjMark_GetParamStringValue = wasmExports["FPDFPageObjMark_GetParamStringValue"];
+ Module["_FPDFPageObjMark_GetParamBlobValue"] = _FPDFPageObjMark_GetParamBlobValue = wasmExports["FPDFPageObjMark_GetParamBlobValue"];
+ Module["_FPDFPageObj_HasTransparency"] = _FPDFPageObj_HasTransparency = wasmExports["FPDFPageObj_HasTransparency"];
+ Module["_FPDFPageObjMark_SetIntParam"] = _FPDFPageObjMark_SetIntParam = wasmExports["FPDFPageObjMark_SetIntParam"];
+ Module["_FPDFPageObjMark_SetStringParam"] = _FPDFPageObjMark_SetStringParam = wasmExports["FPDFPageObjMark_SetStringParam"];
+ Module["_FPDFPageObjMark_SetBlobParam"] = _FPDFPageObjMark_SetBlobParam = wasmExports["FPDFPageObjMark_SetBlobParam"];
+ Module["_FPDFPageObjMark_RemoveParam"] = _FPDFPageObjMark_RemoveParam = wasmExports["FPDFPageObjMark_RemoveParam"];
+ Module["_FPDFPageObj_GetType"] = _FPDFPageObj_GetType = wasmExports["FPDFPageObj_GetType"];
+ Module["_FPDFPageObj_GetIsActive"] = _FPDFPageObj_GetIsActive = wasmExports["FPDFPageObj_GetIsActive"];
+ Module["_FPDFPageObj_SetIsActive"] = _FPDFPageObj_SetIsActive = wasmExports["FPDFPageObj_SetIsActive"];
+ Module["_FPDFPage_GenerateContent"] = _FPDFPage_GenerateContent = wasmExports["FPDFPage_GenerateContent"];
+ Module["_FPDFPageObj_Transform"] = _FPDFPageObj_Transform = wasmExports["FPDFPageObj_Transform"];
+ Module["_FPDFPageObj_TransformF"] = _FPDFPageObj_TransformF = wasmExports["FPDFPageObj_TransformF"];
+ Module["_FPDFPageObj_GetMatrix"] = _FPDFPageObj_GetMatrix = wasmExports["FPDFPageObj_GetMatrix"];
+ Module["_FPDFPageObj_SetMatrix"] = _FPDFPageObj_SetMatrix = wasmExports["FPDFPageObj_SetMatrix"];
+ Module["_FPDFPageObj_SetBlendMode"] = _FPDFPageObj_SetBlendMode = wasmExports["FPDFPageObj_SetBlendMode"];
+ Module["_FPDFPage_TransformAnnots"] = _FPDFPage_TransformAnnots = wasmExports["FPDFPage_TransformAnnots"];
+ Module["_FPDFPage_SetRotation"] = _FPDFPage_SetRotation = wasmExports["FPDFPage_SetRotation"];
+ Module["_FPDFPageObj_SetFillColor"] = _FPDFPageObj_SetFillColor = wasmExports["FPDFPageObj_SetFillColor"];
+ Module["_FPDFPageObj_GetFillColor"] = _FPDFPageObj_GetFillColor = wasmExports["FPDFPageObj_GetFillColor"];
+ Module["_FPDFPageObj_GetBounds"] = _FPDFPageObj_GetBounds = wasmExports["FPDFPageObj_GetBounds"];
+ Module["_FPDFPageObj_GetRotatedBounds"] = _FPDFPageObj_GetRotatedBounds = wasmExports["FPDFPageObj_GetRotatedBounds"];
+ Module["_FPDFPageObj_SetStrokeColor"] = _FPDFPageObj_SetStrokeColor = wasmExports["FPDFPageObj_SetStrokeColor"];
+ Module["_FPDFPageObj_GetStrokeColor"] = _FPDFPageObj_GetStrokeColor = wasmExports["FPDFPageObj_GetStrokeColor"];
+ Module["_FPDFPageObj_SetStrokeWidth"] = _FPDFPageObj_SetStrokeWidth = wasmExports["FPDFPageObj_SetStrokeWidth"];
+ Module["_FPDFPageObj_GetStrokeWidth"] = _FPDFPageObj_GetStrokeWidth = wasmExports["FPDFPageObj_GetStrokeWidth"];
+ Module["_FPDFPageObj_GetLineJoin"] = _FPDFPageObj_GetLineJoin = wasmExports["FPDFPageObj_GetLineJoin"];
+ Module["_FPDFPageObj_SetLineJoin"] = _FPDFPageObj_SetLineJoin = wasmExports["FPDFPageObj_SetLineJoin"];
+ Module["_FPDFPageObj_GetLineCap"] = _FPDFPageObj_GetLineCap = wasmExports["FPDFPageObj_GetLineCap"];
+ Module["_FPDFPageObj_SetLineCap"] = _FPDFPageObj_SetLineCap = wasmExports["FPDFPageObj_SetLineCap"];
+ Module["_FPDFPageObj_GetDashPhase"] = _FPDFPageObj_GetDashPhase = wasmExports["FPDFPageObj_GetDashPhase"];
+ Module["_FPDFPageObj_SetDashPhase"] = _FPDFPageObj_SetDashPhase = wasmExports["FPDFPageObj_SetDashPhase"];
+ Module["_FPDFPageObj_GetDashCount"] = _FPDFPageObj_GetDashCount = wasmExports["FPDFPageObj_GetDashCount"];
+ Module["_FPDFPageObj_GetDashArray"] = _FPDFPageObj_GetDashArray = wasmExports["FPDFPageObj_GetDashArray"];
+ Module["_FPDFPageObj_SetDashArray"] = _FPDFPageObj_SetDashArray = wasmExports["FPDFPageObj_SetDashArray"];
+ Module["_FPDFFormObj_CountObjects"] = _FPDFFormObj_CountObjects = wasmExports["FPDFFormObj_CountObjects"];
+ Module["_FPDFFormObj_GetObject"] = _FPDFFormObj_GetObject = wasmExports["FPDFFormObj_GetObject"];
+ Module["_FPDFFormObj_RemoveObject"] = _FPDFFormObj_RemoveObject = wasmExports["FPDFFormObj_RemoveObject"];
+ Module["_FPDFPageObj_CreateNewPath"] = _FPDFPageObj_CreateNewPath = wasmExports["FPDFPageObj_CreateNewPath"];
+ Module["_FPDFPageObj_CreateNewRect"] = _FPDFPageObj_CreateNewRect = wasmExports["FPDFPageObj_CreateNewRect"];
+ Module["_FPDFPath_CountSegments"] = _FPDFPath_CountSegments = wasmExports["FPDFPath_CountSegments"];
+ Module["_FPDFPath_GetPathSegment"] = _FPDFPath_GetPathSegment = wasmExports["FPDFPath_GetPathSegment"];
+ Module["_FPDFPath_MoveTo"] = _FPDFPath_MoveTo = wasmExports["FPDFPath_MoveTo"];
+ Module["_FPDFPath_LineTo"] = _FPDFPath_LineTo = wasmExports["FPDFPath_LineTo"];
+ Module["_FPDFPath_BezierTo"] = _FPDFPath_BezierTo = wasmExports["FPDFPath_BezierTo"];
+ Module["_FPDFPath_Close"] = _FPDFPath_Close = wasmExports["FPDFPath_Close"];
+ Module["_FPDFPath_SetDrawMode"] = _FPDFPath_SetDrawMode = wasmExports["FPDFPath_SetDrawMode"];
+ Module["_FPDFPath_GetDrawMode"] = _FPDFPath_GetDrawMode = wasmExports["FPDFPath_GetDrawMode"];
+ Module["_FPDFPathSegment_GetPoint"] = _FPDFPathSegment_GetPoint = wasmExports["FPDFPathSegment_GetPoint"];
+ Module["_FPDFPathSegment_GetType"] = _FPDFPathSegment_GetType = wasmExports["FPDFPathSegment_GetType"];
+ Module["_FPDFPathSegment_GetClose"] = _FPDFPathSegment_GetClose = wasmExports["FPDFPathSegment_GetClose"];
+ Module["_FPDFPageObj_NewTextObj"] = _FPDFPageObj_NewTextObj = wasmExports["FPDFPageObj_NewTextObj"];
+ Module["_FPDFText_SetText"] = _FPDFText_SetText = wasmExports["FPDFText_SetText"];
+ Module["_FPDFText_SetCharcodes"] = _FPDFText_SetCharcodes = wasmExports["FPDFText_SetCharcodes"];
+ Module["_FPDFText_LoadFont"] = _FPDFText_LoadFont = wasmExports["FPDFText_LoadFont"];
+ Module["_FPDFText_LoadStandardFont"] = _FPDFText_LoadStandardFont = wasmExports["FPDFText_LoadStandardFont"];
+ Module["_FPDFText_LoadCidType2Font"] = _FPDFText_LoadCidType2Font = wasmExports["FPDFText_LoadCidType2Font"];
+ Module["_FPDFTextObj_GetFontSize"] = _FPDFTextObj_GetFontSize = wasmExports["FPDFTextObj_GetFontSize"];
+ Module["_FPDFTextObj_GetText"] = _FPDFTextObj_GetText = wasmExports["FPDFTextObj_GetText"];
+ Module["_FPDFTextObj_GetRenderedBitmap"] = _FPDFTextObj_GetRenderedBitmap = wasmExports["FPDFTextObj_GetRenderedBitmap"];
+ Module["_FPDFFont_Close"] = _FPDFFont_Close = wasmExports["FPDFFont_Close"];
+ Module["_FPDFPageObj_CreateTextObj"] = _FPDFPageObj_CreateTextObj = wasmExports["FPDFPageObj_CreateTextObj"];
+ Module["_FPDFTextObj_GetTextRenderMode"] = _FPDFTextObj_GetTextRenderMode = wasmExports["FPDFTextObj_GetTextRenderMode"];
+ Module["_FPDFTextObj_SetTextRenderMode"] = _FPDFTextObj_SetTextRenderMode = wasmExports["FPDFTextObj_SetTextRenderMode"];
+ Module["_FPDFTextObj_GetFont"] = _FPDFTextObj_GetFont = wasmExports["FPDFTextObj_GetFont"];
+ Module["_FPDFFont_GetBaseFontName"] = _FPDFFont_GetBaseFontName = wasmExports["FPDFFont_GetBaseFontName"];
+ Module["_FPDFFont_GetFamilyName"] = _FPDFFont_GetFamilyName = wasmExports["FPDFFont_GetFamilyName"];
+ Module["_FPDFFont_GetFontData"] = _FPDFFont_GetFontData = wasmExports["FPDFFont_GetFontData"];
+ Module["_FPDFFont_GetIsEmbedded"] = _FPDFFont_GetIsEmbedded = wasmExports["FPDFFont_GetIsEmbedded"];
+ Module["_FPDFFont_GetFlags"] = _FPDFFont_GetFlags = wasmExports["FPDFFont_GetFlags"];
+ Module["_FPDFFont_GetWeight"] = _FPDFFont_GetWeight = wasmExports["FPDFFont_GetWeight"];
+ Module["_FPDFFont_GetItalicAngle"] = _FPDFFont_GetItalicAngle = wasmExports["FPDFFont_GetItalicAngle"];
+ Module["_FPDFFont_GetAscent"] = _FPDFFont_GetAscent = wasmExports["FPDFFont_GetAscent"];
+ Module["_FPDFFont_GetDescent"] = _FPDFFont_GetDescent = wasmExports["FPDFFont_GetDescent"];
+ Module["_FPDFFont_GetGlyphWidth"] = _FPDFFont_GetGlyphWidth = wasmExports["FPDFFont_GetGlyphWidth"];
+ Module["_FPDFFont_GetGlyphPath"] = _FPDFFont_GetGlyphPath = wasmExports["FPDFFont_GetGlyphPath"];
+ Module["_FPDFGlyphPath_CountGlyphSegments"] = _FPDFGlyphPath_CountGlyphSegments = wasmExports["FPDFGlyphPath_CountGlyphSegments"];
+ Module["_FPDFGlyphPath_GetGlyphPathSegment"] = _FPDFGlyphPath_GetGlyphPathSegment = wasmExports["FPDFGlyphPath_GetGlyphPathSegment"];
+ Module["_FSDK_SetUnSpObjProcessHandler"] = _FSDK_SetUnSpObjProcessHandler = wasmExports["FSDK_SetUnSpObjProcessHandler"];
+ Module["_FSDK_SetTimeFunction"] = _FSDK_SetTimeFunction = wasmExports["FSDK_SetTimeFunction"];
+ Module["_FSDK_SetLocaltimeFunction"] = _FSDK_SetLocaltimeFunction = wasmExports["FSDK_SetLocaltimeFunction"];
+ Module["_FPDFDoc_GetPageMode"] = _FPDFDoc_GetPageMode = wasmExports["FPDFDoc_GetPageMode"];
+ Module["_FPDFPage_Flatten"] = _FPDFPage_Flatten = wasmExports["FPDFPage_Flatten"];
+ Module["_FPDFPage_HasFormFieldAtPoint"] = _FPDFPage_HasFormFieldAtPoint = wasmExports["FPDFPage_HasFormFieldAtPoint"];
+ Module["_FPDFPage_FormFieldZOrderAtPoint"] = _FPDFPage_FormFieldZOrderAtPoint = wasmExports["FPDFPage_FormFieldZOrderAtPoint"];
+ Module["_FPDFDOC_InitFormFillEnvironment"] = _FPDFDOC_InitFormFillEnvironment = wasmExports["FPDFDOC_InitFormFillEnvironment"];
+ Module["_FPDFDOC_ExitFormFillEnvironment"] = _FPDFDOC_ExitFormFillEnvironment = wasmExports["FPDFDOC_ExitFormFillEnvironment"];
+ Module["_FORM_OnMouseMove"] = _FORM_OnMouseMove = wasmExports["FORM_OnMouseMove"];
+ Module["_FORM_OnMouseWheel"] = _FORM_OnMouseWheel = wasmExports["FORM_OnMouseWheel"];
+ Module["_FORM_OnFocus"] = _FORM_OnFocus = wasmExports["FORM_OnFocus"];
+ Module["_FORM_OnLButtonDown"] = _FORM_OnLButtonDown = wasmExports["FORM_OnLButtonDown"];
+ Module["_FORM_OnLButtonUp"] = _FORM_OnLButtonUp = wasmExports["FORM_OnLButtonUp"];
+ Module["_FORM_OnLButtonDoubleClick"] = _FORM_OnLButtonDoubleClick = wasmExports["FORM_OnLButtonDoubleClick"];
+ Module["_FORM_OnRButtonDown"] = _FORM_OnRButtonDown = wasmExports["FORM_OnRButtonDown"];
+ Module["_FORM_OnRButtonUp"] = _FORM_OnRButtonUp = wasmExports["FORM_OnRButtonUp"];
+ Module["_FORM_OnKeyDown"] = _FORM_OnKeyDown = wasmExports["FORM_OnKeyDown"];
+ Module["_FORM_OnKeyUp"] = _FORM_OnKeyUp = wasmExports["FORM_OnKeyUp"];
+ Module["_FORM_OnChar"] = _FORM_OnChar = wasmExports["FORM_OnChar"];
+ Module["_FORM_GetFocusedText"] = _FORM_GetFocusedText = wasmExports["FORM_GetFocusedText"];
+ Module["_FORM_GetSelectedText"] = _FORM_GetSelectedText = wasmExports["FORM_GetSelectedText"];
+ Module["_FORM_ReplaceAndKeepSelection"] = _FORM_ReplaceAndKeepSelection = wasmExports["FORM_ReplaceAndKeepSelection"];
+ Module["_FORM_ReplaceSelection"] = _FORM_ReplaceSelection = wasmExports["FORM_ReplaceSelection"];
+ Module["_FORM_SelectAllText"] = _FORM_SelectAllText = wasmExports["FORM_SelectAllText"];
+ Module["_FORM_CanUndo"] = _FORM_CanUndo = wasmExports["FORM_CanUndo"];
+ Module["_FORM_CanRedo"] = _FORM_CanRedo = wasmExports["FORM_CanRedo"];
+ Module["_FORM_Undo"] = _FORM_Undo = wasmExports["FORM_Undo"];
+ Module["_FORM_Redo"] = _FORM_Redo = wasmExports["FORM_Redo"];
+ Module["_FORM_ForceToKillFocus"] = _FORM_ForceToKillFocus = wasmExports["FORM_ForceToKillFocus"];
+ Module["_FORM_GetFocusedAnnot"] = _FORM_GetFocusedAnnot = wasmExports["FORM_GetFocusedAnnot"];
+ Module["_FORM_SetFocusedAnnot"] = _FORM_SetFocusedAnnot = wasmExports["FORM_SetFocusedAnnot"];
+ Module["_FPDF_FFLDraw"] = _FPDF_FFLDraw = wasmExports["FPDF_FFLDraw"];
+ Module["_FPDF_SetFormFieldHighlightColor"] = _FPDF_SetFormFieldHighlightColor = wasmExports["FPDF_SetFormFieldHighlightColor"];
+ Module["_FPDF_SetFormFieldHighlightAlpha"] = _FPDF_SetFormFieldHighlightAlpha = wasmExports["FPDF_SetFormFieldHighlightAlpha"];
+ Module["_FPDF_RemoveFormFieldHighlight"] = _FPDF_RemoveFormFieldHighlight = wasmExports["FPDF_RemoveFormFieldHighlight"];
+ Module["_FORM_OnAfterLoadPage"] = _FORM_OnAfterLoadPage = wasmExports["FORM_OnAfterLoadPage"];
+ Module["_FORM_OnBeforeClosePage"] = _FORM_OnBeforeClosePage = wasmExports["FORM_OnBeforeClosePage"];
+ Module["_FORM_DoDocumentJSAction"] = _FORM_DoDocumentJSAction = wasmExports["FORM_DoDocumentJSAction"];
+ Module["_FORM_DoDocumentOpenAction"] = _FORM_DoDocumentOpenAction = wasmExports["FORM_DoDocumentOpenAction"];
+ Module["_FORM_DoDocumentAAction"] = _FORM_DoDocumentAAction = wasmExports["FORM_DoDocumentAAction"];
+ Module["_FORM_DoPageAAction"] = _FORM_DoPageAAction = wasmExports["FORM_DoPageAAction"];
+ Module["_FORM_SetIndexSelected"] = _FORM_SetIndexSelected = wasmExports["FORM_SetIndexSelected"];
+ Module["_FORM_IsIndexSelected"] = _FORM_IsIndexSelected = wasmExports["FORM_IsIndexSelected"];
+ Module["_FPDFDoc_GetJavaScriptActionCount"] = _FPDFDoc_GetJavaScriptActionCount = wasmExports["FPDFDoc_GetJavaScriptActionCount"];
+ Module["_FPDFDoc_GetJavaScriptAction"] = _FPDFDoc_GetJavaScriptAction = wasmExports["FPDFDoc_GetJavaScriptAction"];
+ Module["_FPDFDoc_CloseJavaScriptAction"] = _FPDFDoc_CloseJavaScriptAction = wasmExports["FPDFDoc_CloseJavaScriptAction"];
+ Module["_FPDFJavaScriptAction_GetName"] = _FPDFJavaScriptAction_GetName = wasmExports["FPDFJavaScriptAction_GetName"];
+ Module["_FPDFJavaScriptAction_GetScript"] = _FPDFJavaScriptAction_GetScript = wasmExports["FPDFJavaScriptAction_GetScript"];
+ Module["_FPDF_ImportPagesByIndex"] = _FPDF_ImportPagesByIndex = wasmExports["FPDF_ImportPagesByIndex"];
+ Module["_FPDF_ImportPages"] = _FPDF_ImportPages = wasmExports["FPDF_ImportPages"];
+ Module["_FPDF_ImportNPagesToOne"] = _FPDF_ImportNPagesToOne = wasmExports["FPDF_ImportNPagesToOne"];
+ Module["_FPDF_NewXObjectFromPage"] = _FPDF_NewXObjectFromPage = wasmExports["FPDF_NewXObjectFromPage"];
+ Module["_FPDF_CloseXObject"] = _FPDF_CloseXObject = wasmExports["FPDF_CloseXObject"];
+ Module["_FPDF_NewFormObjectFromXObject"] = _FPDF_NewFormObjectFromXObject = wasmExports["FPDF_NewFormObjectFromXObject"];
+ Module["_FPDF_CopyViewerPreferences"] = _FPDF_CopyViewerPreferences = wasmExports["FPDF_CopyViewerPreferences"];
+ Module["_FPDF_RenderPageBitmapWithColorScheme_Start"] = _FPDF_RenderPageBitmapWithColorScheme_Start = wasmExports["FPDF_RenderPageBitmapWithColorScheme_Start"];
+ Module["_FPDF_RenderPageBitmap_Start"] = _FPDF_RenderPageBitmap_Start = wasmExports["FPDF_RenderPageBitmap_Start"];
+ Module["_FPDF_RenderPage_Continue"] = _FPDF_RenderPage_Continue = wasmExports["FPDF_RenderPage_Continue"];
+ Module["_FPDF_RenderPage_Close"] = _FPDF_RenderPage_Close = wasmExports["FPDF_RenderPage_Close"];
+ Module["_FPDF_SaveAsCopy"] = _FPDF_SaveAsCopy = wasmExports["FPDF_SaveAsCopy"];
+ Module["_FPDF_SaveWithVersion"] = _FPDF_SaveWithVersion = wasmExports["FPDF_SaveWithVersion"];
+ Module["_FPDFText_GetCharIndexFromTextIndex"] = _FPDFText_GetCharIndexFromTextIndex = wasmExports["FPDFText_GetCharIndexFromTextIndex"];
+ Module["_FPDFText_GetTextIndexFromCharIndex"] = _FPDFText_GetTextIndexFromCharIndex = wasmExports["FPDFText_GetTextIndexFromCharIndex"];
+ Module["_FPDF_GetSignatureCount"] = _FPDF_GetSignatureCount = wasmExports["FPDF_GetSignatureCount"];
+ Module["_FPDF_GetSignatureObject"] = _FPDF_GetSignatureObject = wasmExports["FPDF_GetSignatureObject"];
+ Module["_FPDFSignatureObj_GetContents"] = _FPDFSignatureObj_GetContents = wasmExports["FPDFSignatureObj_GetContents"];
+ Module["_FPDFSignatureObj_GetByteRange"] = _FPDFSignatureObj_GetByteRange = wasmExports["FPDFSignatureObj_GetByteRange"];
+ Module["_FPDFSignatureObj_GetSubFilter"] = _FPDFSignatureObj_GetSubFilter = wasmExports["FPDFSignatureObj_GetSubFilter"];
+ Module["_FPDFSignatureObj_GetReason"] = _FPDFSignatureObj_GetReason = wasmExports["FPDFSignatureObj_GetReason"];
+ Module["_FPDFSignatureObj_GetTime"] = _FPDFSignatureObj_GetTime = wasmExports["FPDFSignatureObj_GetTime"];
+ Module["_FPDFSignatureObj_GetDocMDPPermission"] = _FPDFSignatureObj_GetDocMDPPermission = wasmExports["FPDFSignatureObj_GetDocMDPPermission"];
+ Module["_FPDF_StructTree_GetForPage"] = _FPDF_StructTree_GetForPage = wasmExports["FPDF_StructTree_GetForPage"];
+ Module["_FPDF_StructTree_Close"] = _FPDF_StructTree_Close = wasmExports["FPDF_StructTree_Close"];
+ Module["_FPDF_StructTree_CountChildren"] = _FPDF_StructTree_CountChildren = wasmExports["FPDF_StructTree_CountChildren"];
+ Module["_FPDF_StructTree_GetChildAtIndex"] = _FPDF_StructTree_GetChildAtIndex = wasmExports["FPDF_StructTree_GetChildAtIndex"];
+ Module["_FPDF_StructElement_GetAltText"] = _FPDF_StructElement_GetAltText = wasmExports["FPDF_StructElement_GetAltText"];
+ Module["_FPDF_StructElement_GetActualText"] = _FPDF_StructElement_GetActualText = wasmExports["FPDF_StructElement_GetActualText"];
+ Module["_FPDF_StructElement_GetID"] = _FPDF_StructElement_GetID = wasmExports["FPDF_StructElement_GetID"];
+ Module["_FPDF_StructElement_GetLang"] = _FPDF_StructElement_GetLang = wasmExports["FPDF_StructElement_GetLang"];
+ Module["_FPDF_StructElement_GetAttributeCount"] = _FPDF_StructElement_GetAttributeCount = wasmExports["FPDF_StructElement_GetAttributeCount"];
+ Module["_FPDF_StructElement_GetAttributeAtIndex"] = _FPDF_StructElement_GetAttributeAtIndex = wasmExports["FPDF_StructElement_GetAttributeAtIndex"];
+ Module["_FPDF_StructElement_GetStringAttribute"] = _FPDF_StructElement_GetStringAttribute = wasmExports["FPDF_StructElement_GetStringAttribute"];
+ Module["_FPDF_StructElement_GetMarkedContentID"] = _FPDF_StructElement_GetMarkedContentID = wasmExports["FPDF_StructElement_GetMarkedContentID"];
+ Module["_FPDF_StructElement_GetType"] = _FPDF_StructElement_GetType = wasmExports["FPDF_StructElement_GetType"];
+ Module["_FPDF_StructElement_GetObjType"] = _FPDF_StructElement_GetObjType = wasmExports["FPDF_StructElement_GetObjType"];
+ Module["_FPDF_StructElement_GetTitle"] = _FPDF_StructElement_GetTitle = wasmExports["FPDF_StructElement_GetTitle"];
+ Module["_FPDF_StructElement_CountChildren"] = _FPDF_StructElement_CountChildren = wasmExports["FPDF_StructElement_CountChildren"];
+ Module["_FPDF_StructElement_GetChildAtIndex"] = _FPDF_StructElement_GetChildAtIndex = wasmExports["FPDF_StructElement_GetChildAtIndex"];
+ Module["_FPDF_StructElement_GetChildMarkedContentID"] = _FPDF_StructElement_GetChildMarkedContentID = wasmExports["FPDF_StructElement_GetChildMarkedContentID"];
+ Module["_FPDF_StructElement_GetParent"] = _FPDF_StructElement_GetParent = wasmExports["FPDF_StructElement_GetParent"];
+ Module["_FPDF_StructElement_Attr_GetCount"] = _FPDF_StructElement_Attr_GetCount = wasmExports["FPDF_StructElement_Attr_GetCount"];
+ Module["_FPDF_StructElement_Attr_GetName"] = _FPDF_StructElement_Attr_GetName = wasmExports["FPDF_StructElement_Attr_GetName"];
+ Module["_FPDF_StructElement_Attr_GetValue"] = _FPDF_StructElement_Attr_GetValue = wasmExports["FPDF_StructElement_Attr_GetValue"];
+ Module["_FPDF_StructElement_Attr_GetType"] = _FPDF_StructElement_Attr_GetType = wasmExports["FPDF_StructElement_Attr_GetType"];
+ Module["_FPDF_StructElement_Attr_GetBooleanValue"] = _FPDF_StructElement_Attr_GetBooleanValue = wasmExports["FPDF_StructElement_Attr_GetBooleanValue"];
+ Module["_FPDF_StructElement_Attr_GetNumberValue"] = _FPDF_StructElement_Attr_GetNumberValue = wasmExports["FPDF_StructElement_Attr_GetNumberValue"];
+ Module["_FPDF_StructElement_Attr_GetStringValue"] = _FPDF_StructElement_Attr_GetStringValue = wasmExports["FPDF_StructElement_Attr_GetStringValue"];
+ Module["_FPDF_StructElement_Attr_GetBlobValue"] = _FPDF_StructElement_Attr_GetBlobValue = wasmExports["FPDF_StructElement_Attr_GetBlobValue"];
+ Module["_FPDF_StructElement_Attr_CountChildren"] = _FPDF_StructElement_Attr_CountChildren = wasmExports["FPDF_StructElement_Attr_CountChildren"];
+ Module["_FPDF_StructElement_Attr_GetChildAtIndex"] = _FPDF_StructElement_Attr_GetChildAtIndex = wasmExports["FPDF_StructElement_Attr_GetChildAtIndex"];
+ Module["_FPDF_StructElement_GetMarkedContentIdCount"] = _FPDF_StructElement_GetMarkedContentIdCount = wasmExports["FPDF_StructElement_GetMarkedContentIdCount"];
+ Module["_FPDF_StructElement_GetMarkedContentIdAtIndex"] = _FPDF_StructElement_GetMarkedContentIdAtIndex = wasmExports["FPDF_StructElement_GetMarkedContentIdAtIndex"];
+ Module["_FPDF_AddInstalledFont"] = _FPDF_AddInstalledFont = wasmExports["FPDF_AddInstalledFont"];
+ Module["_FPDF_SetSystemFontInfo"] = _FPDF_SetSystemFontInfo = wasmExports["FPDF_SetSystemFontInfo"];
+ Module["_FPDF_GetDefaultTTFMap"] = _FPDF_GetDefaultTTFMap = wasmExports["FPDF_GetDefaultTTFMap"];
+ Module["_FPDF_GetDefaultTTFMapCount"] = _FPDF_GetDefaultTTFMapCount = wasmExports["FPDF_GetDefaultTTFMapCount"];
+ Module["_FPDF_GetDefaultTTFMapEntry"] = _FPDF_GetDefaultTTFMapEntry = wasmExports["FPDF_GetDefaultTTFMapEntry"];
+ Module["_FPDF_GetDefaultSystemFontInfo"] = _FPDF_GetDefaultSystemFontInfo = wasmExports["FPDF_GetDefaultSystemFontInfo"];
+ Module["_FPDF_FreeDefaultSystemFontInfo"] = _FPDF_FreeDefaultSystemFontInfo = wasmExports["FPDF_FreeDefaultSystemFontInfo"];
+ Module["_FPDFText_LoadPage"] = _FPDFText_LoadPage = wasmExports["FPDFText_LoadPage"];
+ Module["_FPDFText_ClosePage"] = _FPDFText_ClosePage = wasmExports["FPDFText_ClosePage"];
+ Module["_FPDFText_CountChars"] = _FPDFText_CountChars = wasmExports["FPDFText_CountChars"];
+ Module["_FPDFText_GetUnicode"] = _FPDFText_GetUnicode = wasmExports["FPDFText_GetUnicode"];
+ Module["_FPDFText_GetTextObject"] = _FPDFText_GetTextObject = wasmExports["FPDFText_GetTextObject"];
+ Module["_FPDFText_IsGenerated"] = _FPDFText_IsGenerated = wasmExports["FPDFText_IsGenerated"];
+ Module["_FPDFText_IsHyphen"] = _FPDFText_IsHyphen = wasmExports["FPDFText_IsHyphen"];
+ Module["_FPDFText_HasUnicodeMapError"] = _FPDFText_HasUnicodeMapError = wasmExports["FPDFText_HasUnicodeMapError"];
+ Module["_FPDFText_GetFontSize"] = _FPDFText_GetFontSize = wasmExports["FPDFText_GetFontSize"];
+ Module["_FPDFText_GetFontInfo"] = _FPDFText_GetFontInfo = wasmExports["FPDFText_GetFontInfo"];
+ Module["_FPDFText_GetFontWeight"] = _FPDFText_GetFontWeight = wasmExports["FPDFText_GetFontWeight"];
+ Module["_FPDFText_GetFillColor"] = _FPDFText_GetFillColor = wasmExports["FPDFText_GetFillColor"];
+ Module["_FPDFText_GetStrokeColor"] = _FPDFText_GetStrokeColor = wasmExports["FPDFText_GetStrokeColor"];
+ Module["_FPDFText_GetCharAngle"] = _FPDFText_GetCharAngle = wasmExports["FPDFText_GetCharAngle"];
+ Module["_FPDFText_GetCharBox"] = _FPDFText_GetCharBox = wasmExports["FPDFText_GetCharBox"];
+ Module["_FPDFText_GetLooseCharBox"] = _FPDFText_GetLooseCharBox = wasmExports["FPDFText_GetLooseCharBox"];
+ Module["_FPDFText_GetMatrix"] = _FPDFText_GetMatrix = wasmExports["FPDFText_GetMatrix"];
+ Module["_FPDFText_GetCharOrigin"] = _FPDFText_GetCharOrigin = wasmExports["FPDFText_GetCharOrigin"];
+ Module["_FPDFText_GetCharIndexAtPos"] = _FPDFText_GetCharIndexAtPos = wasmExports["FPDFText_GetCharIndexAtPos"];
+ Module["_FPDFText_GetText"] = _FPDFText_GetText = wasmExports["FPDFText_GetText"];
+ Module["_FPDFText_CountRects"] = _FPDFText_CountRects = wasmExports["FPDFText_CountRects"];
+ Module["_FPDFText_GetRect"] = _FPDFText_GetRect = wasmExports["FPDFText_GetRect"];
+ Module["_FPDFText_GetBoundedText"] = _FPDFText_GetBoundedText = wasmExports["FPDFText_GetBoundedText"];
+ Module["_FPDFText_FindStart"] = _FPDFText_FindStart = wasmExports["FPDFText_FindStart"];
+ Module["_FPDFText_FindNext"] = _FPDFText_FindNext = wasmExports["FPDFText_FindNext"];
+ Module["_FPDFText_FindPrev"] = _FPDFText_FindPrev = wasmExports["FPDFText_FindPrev"];
+ Module["_FPDFText_GetSchResultIndex"] = _FPDFText_GetSchResultIndex = wasmExports["FPDFText_GetSchResultIndex"];
+ Module["_FPDFText_GetSchCount"] = _FPDFText_GetSchCount = wasmExports["FPDFText_GetSchCount"];
+ Module["_FPDFText_FindClose"] = _FPDFText_FindClose = wasmExports["FPDFText_FindClose"];
+ Module["_FPDFLink_LoadWebLinks"] = _FPDFLink_LoadWebLinks = wasmExports["FPDFLink_LoadWebLinks"];
+ Module["_FPDFLink_CountWebLinks"] = _FPDFLink_CountWebLinks = wasmExports["FPDFLink_CountWebLinks"];
+ Module["_FPDFLink_GetURL"] = _FPDFLink_GetURL = wasmExports["FPDFLink_GetURL"];
+ Module["_FPDFLink_CountRects"] = _FPDFLink_CountRects = wasmExports["FPDFLink_CountRects"];
+ Module["_FPDFLink_GetRect"] = _FPDFLink_GetRect = wasmExports["FPDFLink_GetRect"];
+ Module["_FPDFLink_GetTextRange"] = _FPDFLink_GetTextRange = wasmExports["FPDFLink_GetTextRange"];
+ Module["_FPDFLink_CloseWebLinks"] = _FPDFLink_CloseWebLinks = wasmExports["FPDFLink_CloseWebLinks"];
+ Module["_FPDFPage_GetDecodedThumbnailData"] = _FPDFPage_GetDecodedThumbnailData = wasmExports["FPDFPage_GetDecodedThumbnailData"];
+ Module["_FPDFPage_GetRawThumbnailData"] = _FPDFPage_GetRawThumbnailData = wasmExports["FPDFPage_GetRawThumbnailData"];
+ Module["_FPDFPage_GetThumbnailAsBitmap"] = _FPDFPage_GetThumbnailAsBitmap = wasmExports["FPDFPage_GetThumbnailAsBitmap"];
+ Module["_FPDFPage_SetMediaBox"] = _FPDFPage_SetMediaBox = wasmExports["FPDFPage_SetMediaBox"];
+ Module["_FPDFPage_SetCropBox"] = _FPDFPage_SetCropBox = wasmExports["FPDFPage_SetCropBox"];
+ Module["_FPDFPage_SetBleedBox"] = _FPDFPage_SetBleedBox = wasmExports["FPDFPage_SetBleedBox"];
+ Module["_FPDFPage_SetTrimBox"] = _FPDFPage_SetTrimBox = wasmExports["FPDFPage_SetTrimBox"];
+ Module["_FPDFPage_SetArtBox"] = _FPDFPage_SetArtBox = wasmExports["FPDFPage_SetArtBox"];
+ Module["_FPDFPage_GetMediaBox"] = _FPDFPage_GetMediaBox = wasmExports["FPDFPage_GetMediaBox"];
+ Module["_FPDFPage_GetCropBox"] = _FPDFPage_GetCropBox = wasmExports["FPDFPage_GetCropBox"];
+ Module["_FPDFPage_GetBleedBox"] = _FPDFPage_GetBleedBox = wasmExports["FPDFPage_GetBleedBox"];
+ Module["_FPDFPage_GetTrimBox"] = _FPDFPage_GetTrimBox = wasmExports["FPDFPage_GetTrimBox"];
+ Module["_FPDFPage_GetArtBox"] = _FPDFPage_GetArtBox = wasmExports["FPDFPage_GetArtBox"];
+ Module["_FPDFPage_TransFormWithClip"] = _FPDFPage_TransFormWithClip = wasmExports["FPDFPage_TransFormWithClip"];
+ Module["_FPDFPageObj_TransformClipPath"] = _FPDFPageObj_TransformClipPath = wasmExports["FPDFPageObj_TransformClipPath"];
+ Module["_FPDFPageObj_GetClipPath"] = _FPDFPageObj_GetClipPath = wasmExports["FPDFPageObj_GetClipPath"];
+ Module["_FPDFClipPath_CountPaths"] = _FPDFClipPath_CountPaths = wasmExports["FPDFClipPath_CountPaths"];
+ Module["_FPDFClipPath_CountPathSegments"] = _FPDFClipPath_CountPathSegments = wasmExports["FPDFClipPath_CountPathSegments"];
+ Module["_FPDFClipPath_GetPathSegment"] = _FPDFClipPath_GetPathSegment = wasmExports["FPDFClipPath_GetPathSegment"];
+ Module["_FPDF_CreateClipPath"] = _FPDF_CreateClipPath = wasmExports["FPDF_CreateClipPath"];
+ Module["_FPDF_DestroyClipPath"] = _FPDF_DestroyClipPath = wasmExports["FPDF_DestroyClipPath"];
+ Module["_FPDFPage_InsertClipPath"] = _FPDFPage_InsertClipPath = wasmExports["FPDFPage_InsertClipPath"];
+ Module["_FPDF_InitLibrary"] = _FPDF_InitLibrary = wasmExports["FPDF_InitLibrary"];
+ Module["_FPDF_InitLibraryWithConfig"] = _FPDF_InitLibraryWithConfig = wasmExports["FPDF_InitLibraryWithConfig"];
+ Module["_FPDF_DestroyLibrary"] = _FPDF_DestroyLibrary = wasmExports["FPDF_DestroyLibrary"];
+ Module["_FPDF_SetSandBoxPolicy"] = _FPDF_SetSandBoxPolicy = wasmExports["FPDF_SetSandBoxPolicy"];
+ Module["_FPDF_LoadDocument"] = _FPDF_LoadDocument = wasmExports["FPDF_LoadDocument"];
+ Module["_FPDF_GetFormType"] = _FPDF_GetFormType = wasmExports["FPDF_GetFormType"];
+ Module["_FPDF_LoadXFA"] = _FPDF_LoadXFA = wasmExports["FPDF_LoadXFA"];
+ Module["_FPDF_LoadMemDocument"] = _FPDF_LoadMemDocument = wasmExports["FPDF_LoadMemDocument"];
+ Module["_FPDF_LoadMemDocument64"] = _FPDF_LoadMemDocument64 = wasmExports["FPDF_LoadMemDocument64"];
+ Module["_FPDF_LoadCustomDocument"] = _FPDF_LoadCustomDocument = wasmExports["FPDF_LoadCustomDocument"];
+ Module["_FPDF_GetFileVersion"] = _FPDF_GetFileVersion = wasmExports["FPDF_GetFileVersion"];
+ Module["_FPDF_DocumentHasValidCrossReferenceTable"] = _FPDF_DocumentHasValidCrossReferenceTable = wasmExports["FPDF_DocumentHasValidCrossReferenceTable"];
+ Module["_FPDF_GetDocPermissions"] = _FPDF_GetDocPermissions = wasmExports["FPDF_GetDocPermissions"];
+ Module["_FPDF_GetDocUserPermissions"] = _FPDF_GetDocUserPermissions = wasmExports["FPDF_GetDocUserPermissions"];
+ Module["_FPDF_GetSecurityHandlerRevision"] = _FPDF_GetSecurityHandlerRevision = wasmExports["FPDF_GetSecurityHandlerRevision"];
+ Module["_FPDF_GetPageCount"] = _FPDF_GetPageCount = wasmExports["FPDF_GetPageCount"];
+ Module["_FPDF_LoadPage"] = _FPDF_LoadPage = wasmExports["FPDF_LoadPage"];
+ Module["_FPDF_GetPageWidthF"] = _FPDF_GetPageWidthF = wasmExports["FPDF_GetPageWidthF"];
+ Module["_FPDF_GetPageWidth"] = _FPDF_GetPageWidth = wasmExports["FPDF_GetPageWidth"];
+ Module["_FPDF_GetPageHeightF"] = _FPDF_GetPageHeightF = wasmExports["FPDF_GetPageHeightF"];
+ Module["_FPDF_GetPageHeight"] = _FPDF_GetPageHeight = wasmExports["FPDF_GetPageHeight"];
+ Module["_FPDF_GetPageBoundingBox"] = _FPDF_GetPageBoundingBox = wasmExports["FPDF_GetPageBoundingBox"];
+ Module["_FPDF_RenderPageBitmap"] = _FPDF_RenderPageBitmap = wasmExports["FPDF_RenderPageBitmap"];
+ Module["_FPDF_RenderPageBitmapWithMatrix"] = _FPDF_RenderPageBitmapWithMatrix = wasmExports["FPDF_RenderPageBitmapWithMatrix"];
+ Module["_FPDF_ClosePage"] = _FPDF_ClosePage = wasmExports["FPDF_ClosePage"];
+ Module["_FPDF_CloseDocument"] = _FPDF_CloseDocument = wasmExports["FPDF_CloseDocument"];
+ Module["_FPDF_GetLastError"] = _FPDF_GetLastError = wasmExports["FPDF_GetLastError"];
+ Module["_FPDF_DeviceToPage"] = _FPDF_DeviceToPage = wasmExports["FPDF_DeviceToPage"];
+ Module["_FPDF_PageToDevice"] = _FPDF_PageToDevice = wasmExports["FPDF_PageToDevice"];
+ Module["_FPDFBitmap_Create"] = _FPDFBitmap_Create = wasmExports["FPDFBitmap_Create"];
+ Module["_FPDFBitmap_CreateEx"] = _FPDFBitmap_CreateEx = wasmExports["FPDFBitmap_CreateEx"];
+ Module["_FPDFBitmap_GetFormat"] = _FPDFBitmap_GetFormat = wasmExports["FPDFBitmap_GetFormat"];
+ Module["_FPDFBitmap_FillRect"] = _FPDFBitmap_FillRect = wasmExports["FPDFBitmap_FillRect"];
+ Module["_FPDFBitmap_GetBuffer"] = _FPDFBitmap_GetBuffer = wasmExports["FPDFBitmap_GetBuffer"];
+ Module["_FPDFBitmap_GetWidth"] = _FPDFBitmap_GetWidth = wasmExports["FPDFBitmap_GetWidth"];
+ Module["_FPDFBitmap_GetHeight"] = _FPDFBitmap_GetHeight = wasmExports["FPDFBitmap_GetHeight"];
+ Module["_FPDFBitmap_GetStride"] = _FPDFBitmap_GetStride = wasmExports["FPDFBitmap_GetStride"];
+ Module["_FPDFBitmap_Destroy"] = _FPDFBitmap_Destroy = wasmExports["FPDFBitmap_Destroy"];
+ Module["_FPDF_GetPageSizeByIndexF"] = _FPDF_GetPageSizeByIndexF = wasmExports["FPDF_GetPageSizeByIndexF"];
+ Module["_FPDF_GetPageSizeByIndex"] = _FPDF_GetPageSizeByIndex = wasmExports["FPDF_GetPageSizeByIndex"];
+ Module["_FPDF_VIEWERREF_GetPrintScaling"] = _FPDF_VIEWERREF_GetPrintScaling = wasmExports["FPDF_VIEWERREF_GetPrintScaling"];
+ Module["_FPDF_VIEWERREF_GetNumCopies"] = _FPDF_VIEWERREF_GetNumCopies = wasmExports["FPDF_VIEWERREF_GetNumCopies"];
+ Module["_FPDF_VIEWERREF_GetPrintPageRange"] = _FPDF_VIEWERREF_GetPrintPageRange = wasmExports["FPDF_VIEWERREF_GetPrintPageRange"];
+ Module["_FPDF_VIEWERREF_GetPrintPageRangeCount"] = _FPDF_VIEWERREF_GetPrintPageRangeCount = wasmExports["FPDF_VIEWERREF_GetPrintPageRangeCount"];
+ Module["_FPDF_VIEWERREF_GetPrintPageRangeElement"] = _FPDF_VIEWERREF_GetPrintPageRangeElement = wasmExports["FPDF_VIEWERREF_GetPrintPageRangeElement"];
+ Module["_FPDF_VIEWERREF_GetDuplex"] = _FPDF_VIEWERREF_GetDuplex = wasmExports["FPDF_VIEWERREF_GetDuplex"];
+ Module["_FPDF_VIEWERREF_GetName"] = _FPDF_VIEWERREF_GetName = wasmExports["FPDF_VIEWERREF_GetName"];
+ Module["_FPDF_CountNamedDests"] = _FPDF_CountNamedDests = wasmExports["FPDF_CountNamedDests"];
+ Module["_FPDF_GetNamedDestByName"] = _FPDF_GetNamedDestByName = wasmExports["FPDF_GetNamedDestByName"];
+ Module["_FPDF_GetNamedDest"] = _FPDF_GetNamedDest = wasmExports["FPDF_GetNamedDest"];
+ Module["_FPDF_GetXFAPacketCount"] = _FPDF_GetXFAPacketCount = wasmExports["FPDF_GetXFAPacketCount"];
+ Module["_FPDF_GetXFAPacketName"] = _FPDF_GetXFAPacketName = wasmExports["FPDF_GetXFAPacketName"];
+ Module["_FPDF_GetXFAPacketContent"] = _FPDF_GetXFAPacketContent = wasmExports["FPDF_GetXFAPacketContent"];
+ Module["_FPDF_GetTrailerEnds"] = _FPDF_GetTrailerEnds = wasmExports["FPDF_GetTrailerEnds"];
+ _emscripten_builtin_memalign = wasmExports["emscripten_builtin_memalign"];
+ Module["_malloc"] = _malloc = wasmExports["malloc"];
+ Module["_free"] = _free = wasmExports["free"];
+ Module["_calloc"] = _calloc = wasmExports["calloc"];
+ Module["_realloc"] = _realloc = wasmExports["realloc"];
+ _setThrew = wasmExports["setThrew"];
+ __emscripten_stack_restore = wasmExports["_emscripten_stack_restore"];
+ __emscripten_stack_alloc = wasmExports["_emscripten_stack_alloc"];
+ _emscripten_stack_get_current = wasmExports["emscripten_stack_get_current"]
+ }
+ var wasmImports = {
+ __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,
+ _abort_js: __abort_js,
+ _emscripten_throw_longjmp: __emscripten_throw_longjmp,
+ _gmtime_js: __gmtime_js,
+ _localtime_js: __localtime_js,
+ _tzset_js: __tzset_js,
+ emscripten_date_now: _emscripten_date_now,
+ 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_iii,
+ invoke_iiii,
+ invoke_iiiii,
+ invoke_v,
+ invoke_viii,
+ invoke_viiii
+ };
+ var wasmExports;
+ createWasm();
+
+ 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_ii(index, a1) {
+ var sp = stackSave();
+ try {
+ return getWasmTableEntry(index)(a1)
+ } 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_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_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_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 applySignatureConversions(wasmExports) {
+ wasmExports = Object.assign({}, wasmExports);
+ var makeWrapper_ppp = f => (a0, a1) => f(a0, a1) >>> 0;
+ var makeWrapper_pp = f => a0 => f(a0) >>> 0;
+ var makeWrapper_p = f => () => f() >>> 0;
+ wasmExports["emscripten_builtin_memalign"] = makeWrapper_ppp(wasmExports["emscripten_builtin_memalign"]);
+ wasmExports["malloc"] = makeWrapper_pp(wasmExports["malloc"]);
+ wasmExports["calloc"] = makeWrapper_ppp(wasmExports["calloc"]);
+ wasmExports["realloc"] = makeWrapper_ppp(wasmExports["realloc"]);
+ wasmExports["_emscripten_stack_alloc"] = makeWrapper_pp(wasmExports["_emscripten_stack_alloc"]);
+ wasmExports["emscripten_stack_get_current"] = makeWrapper_p(wasmExports["emscripten_stack_get_current"]);
+ return wasmExports
+ }
+
+ function run() {
+ if (runDependencies > 0) {
+ dependenciesFulfilled = run;
+ return
+ }
+ preRun();
+ if (runDependencies > 0) {
+ dependenciesFulfilled = run;
+ return
+ }
+
+ function doRun() {
+ Module["calledRun"] = true;
+ if (ABORT) return;
+ initRuntime();
+ if (Module["onRuntimeInitialized"]) {
+ Module["onRuntimeInitialized"]();
+ }
+ postRun()
+ }
+ if (Module["setStatus"]) {
+ Module["setStatus"]("Running...");
+ setTimeout(() => {
+ setTimeout(() => Module["setStatus"](""), 1);
+ doRun()
+ }, 1)
+ } else {
+ doRun()
+ }
+ }
+
+ function preInit() {
+ if (Module["preInit"]) {
+ if (typeof Module["preInit"] == "function") Module["preInit"] = [Module["preInit"]];
+ while (Module["preInit"].length > 0) {
+ Module["preInit"].shift()()
+ }
+ }
+ }
+ preInit();
+ 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;
\ No newline at end of file
diff --git a/How to/Line Angle Constraint/wwwroot/ej2-pdfviewer-lib/pdfium.wasm b/How to/Line Angle Constraint/wwwroot/ej2-pdfviewer-lib/pdfium.wasm
new file mode 100644
index 0000000000000000000000000000000000000000..703892557b444cc459fc5c52c8f26ab2e528886f
GIT binary patch
literal 3985982
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%0DG_EY(
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