diff --git a/.coding-aider-plans/refactor_tools_toolcontent.md b/.coding-aider-plans/refactor_tools_toolcontent.md
deleted file mode 100644
index 997ac4b..0000000
--- a/.coding-aider-plans/refactor_tools_toolcontent.md
+++ /dev/null
@@ -1,20 +0,0 @@
-[Coding Aider Plan]
-
-## Overview
-This plan outlines the refactoring of existing tools to utilize a `ToolContent` component. This will standardize the structure and styling of tool content across the application, improving maintainability and user experience.
-
-## Problem Description
-Currently, some tools directly render their content without using a common `ToolContent` component. This leads to inconsistencies in styling, layout, and overall structure. It also makes it harder to apply global changes or updates to the tool content areas.
-
-## Goals
-- Identify tools that do not currently use `ToolContent`.
-- Implement `ToolContent` in these tools.
-- Ensure consistent styling and layout across all tools.
-
-## Additional Notes and Constraints
-- The `ToolContent` component should be flexible enough to accommodate the different types of content used by each tool.
-- Ensure that the refactoring does not introduce any regressions or break existing functionality.
-- Consider creating a subplan if the number of tools requiring changes is large or if individual tools require complex modifications.
-
-## References
-- Existing tools that already use `ToolContent` can serve as examples.
diff --git a/.coding-aider-plans/refactor_tools_toolcontent_checklist.md b/.coding-aider-plans/refactor_tools_toolcontent_checklist.md
deleted file mode 100644
index 50ef392..0000000
--- a/.coding-aider-plans/refactor_tools_toolcontent_checklist.md
+++ /dev/null
@@ -1,9 +0,0 @@
-[Coding Aider Plan - Checklist]
-
-- [ ] Create `ToolContent` component if it doesn't exist.
-- [ ] Identify tools that do not use `ToolContent`.
-- [x] For each identified tool:
- - [x] Implement `ToolContent` wrapper.
- - [ ] Adjust styling as needed to match existing design.
- - [ ] Test the tool to ensure it functions correctly.
-- [ ] Review all modified tools to ensure consistency.
diff --git a/.coding-aider-plans/refactor_tools_toolcontent_context.yaml b/.coding-aider-plans/refactor_tools_toolcontent_context.yaml
deleted file mode 100644
index 3fba323..0000000
--- a/.coding-aider-plans/refactor_tools_toolcontent_context.yaml
+++ /dev/null
@@ -1,6 +0,0 @@
----
-files:
-- path: src\pages\tools\list\duplicate\index.tsx
- readOnly: false
-- path: src\pages\tools\list\index.ts
- readOnly: false
diff --git a/.idea/workspace.xml b/.idea/workspace.xml
index 27386d7..0e86a3c 100644
--- a/.idea/workspace.xml
+++ b/.idea/workspace.xml
@@ -4,33 +4,10 @@
-
-
-
+
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
@@ -47,7 +24,7 @@
@@ -66,87 +43,94 @@
"state": "OPEN"
}
}
- {
+ "prStates": [
{
- "id": {
- "id": "PR_kwDOMJIfts51PkS9",
- "number": 22
+ "id": {
+ "id": "PR_kwDOMJIfts51PkS9",
+ "number": 22
},
- "lastSeen": 1741207144695
+ "lastSeen": 1741207144695
},
{
- "id": {
- "id": "PR_kwDOMJIfts6NiNYl",
- "number": 32
+ "id": {
+ "id": "PR_kwDOMJIfts6NiNYl",
+ "number": 32
},
- "lastSeen": 1741209723869
+ "lastSeen": 1741209723869
},
{
- "id": {
- "id": "PR_kwDOMJIfts6Nheyd",
- "number": 31
+ "id": {
+ "id": "PR_kwDOMJIfts6Nheyd",
+ "number": 31
},
- "lastSeen": 1741213371410
+ "lastSeen": 1741213371410
},
{
- "id": {
- "id": "PR_kwDOMJIfts6NmRBs",
- "number": 33
+ "id": {
+ "id": "PR_kwDOMJIfts6NmRBs",
+ "number": 33
},
- "lastSeen": 1741282429036
+ "lastSeen": 1741282429036
},
{
- "id": {
- "id": "PR_kwDOMJIfts5zyFTs",
- "number": 15
+ "id": {
+ "id": "PR_kwDOMJIfts5zyFTs",
+ "number": 15
},
- "lastSeen": 1741535540953
+ "lastSeen": 1741535540953
},
{
- "id": {
- "id": "PR_kwDOMJIfts6QQB3c",
- "number": 59
+ "id": {
+ "id": "PR_kwDOMJIfts6QQB3c",
+ "number": 59
},
- "lastSeen": 1743018960900
+ "lastSeen": 1743018960900
},
{
- "id": {
- "id": "PR_kwDOMJIfts6QMPEg",
- "number": 58
+ "id": {
+ "id": "PR_kwDOMJIfts6QMPEg",
+ "number": 58
},
- "lastSeen": 1743019452983
+ "lastSeen": 1743019452983
},
{
- "id": {
- "id": "PR_kwDOMJIfts6QZvRI",
- "number": 61
+ "id": {
+ "id": "PR_kwDOMJIfts6QZvRI",
+ "number": 61
},
- "lastSeen": 1743103196866
+ "lastSeen": 1743103196866
},
{
- "id": {
- "id": "PR_kwDOMJIfts6QqPrQ",
- "number": 73
+ "id": {
+ "id": "PR_kwDOMJIfts6QqPrQ",
+ "number": 73
},
- "lastSeen": 1743265865001
+ "lastSeen": 1743265865001
},
{
- "id": {
- "id": "PR_kwDOMJIfts6Qp5nI",
- "number": 72
+ "id": {
+ "id": "PR_kwDOMJIfts6Qp5nI",
+ "number": 72
},
- "lastSeen": 1743338472110
+ "lastSeen": 1743338472110
},
{
- "id": {
- "id": "PR_kwDOMJIfts6QsjlS",
- "number": 76
+ "id": {
+ "id": "PR_kwDOMJIfts6QsjlS",
+ "number": 76
},
- "lastSeen": 1743352150953
+ "lastSeen": 1743352150953
+ },
+ {
+ "id": {
+ "id": "PR_kwDOMJIfts6Q0JBe",
+ "number": 82
+ },
+ "lastSeen": 1743470267269
}
]
-}]]>
+}
{
"selectedUrlAndAccountId": {
"url": "https://github.com/iib0011/omni-tools.git",
@@ -175,56 +159,56 @@
- {
+ "keyToString": {
+ "ASKED_ADD_EXTERNAL_FILES": "true",
+ "ASKED_SHARE_PROJECT_CONFIGURATION_FILES": "true",
+ "Docker.Dockerfile build.executor": "Run",
+ "Docker.Dockerfile.executor": "Run",
+ "Playwright.Create transparent PNG.should make png color transparent.executor": "Run",
+ "Playwright.JoinText Component.executor": "Run",
+ "Playwright.JoinText Component.should merge text pieces with specified join character.executor": "Run",
+ "RunOnceActivity.OpenProjectViewOnStart": "true",
+ "RunOnceActivity.ShowReadmeOnStart": "true",
+ "RunOnceActivity.git.unshallow": "true",
+ "Vitest.compute function (1).executor": "Run",
+ "Vitest.compute function.executor": "Run",
+ "Vitest.mergeText.executor": "Run",
+ "Vitest.mergeText.should merge lines and preserve blank lines when deleteBlankLines is false.executor": "Run",
+ "Vitest.mergeText.should merge lines, preserve blank lines and trailing spaces when both deleteBlankLines and deleteTrailingSpaces are false.executor": "Run",
+ "Vitest.parsePageRanges.executor": "Run",
+ "Vitest.removeDuplicateLines function.executor": "Run",
+ "Vitest.removeDuplicateLines function.newlines option.executor": "Run",
+ "Vitest.removeDuplicateLines function.newlines option.should filter newlines when newlines is set to filter.executor": "Run",
+ "Vitest.replaceText function (regexp mode).should return the original text when passed an invalid regexp.executor": "Run",
+ "Vitest.replaceText function.executor": "Run",
+ "Vitest.timeBetweenDates.executor": "Run",
+ "git-widget-placeholder": "main",
+ "ignore.virus.scanning.warn.message": "true",
+ "kotlin-language-version-configured": "true",
+ "last_opened_file_path": "C:/Users/Ibrahima/IdeaProjects/omni-tools/src",
+ "node.js.detected.package.eslint": "true",
+ "node.js.detected.package.tslint": "true",
+ "node.js.selected.package.eslint": "(autodetect)",
+ "node.js.selected.package.tslint": "(autodetect)",
+ "nodejs_package_manager_path": "npm",
+ "npm.build.executor": "Run",
+ "npm.dev.executor": "Run",
+ "npm.lint.executor": "Run",
+ "npm.prebuild.executor": "Run",
+ "npm.script:create:tool.executor": "Run",
+ "npm.test.executor": "Run",
+ "npm.test:e2e.executor": "Run",
+ "npm.test:e2e:run.executor": "Run",
+ "prettierjs.PrettierConfiguration.Package": "C:\\Users\\Ibrahima\\IdeaProjects\\omni-tools\\node_modules\\prettier",
+ "project.structure.last.edited": "Problems",
+ "project.structure.proportion": "0.0",
+ "project.structure.side.proportion": "0.2",
+ "settings.editor.selected.configurable": "refactai_advanced_settings",
+ "ts.external.directory.path": "C:\\Users\\Ibrahima\\IdeaProjects\\omni-tools\\node_modules\\typescript\\lib",
+ "vue.rearranger.settings.migration": "true"
}
-}]]>
+}
+
-
+
-
@@ -421,142 +405,13 @@
-
-
-
- 1740619610168
-
-
-
- 1740619610169
-
-
-
- 1740620866551
-
-
-
- 1740620866551
-
-
-
- 1740661424202
-
-
-
- 1740661424202
-
-
-
- 1740661540908
-
-
-
- 1740661540908
-
-
-
- 1740661744828
-
-
-
- 1740661744828
-
-
-
- 1740661864615
-
-
-
- 1740661864615
-
-
-
- 1740662016902
-
-
-
- 1740662016902
-
-
-
- 1740662154978
-
-
-
- 1740662154978
-
-
-
- 1740665609483
-
-
-
- 1740665609483
-
-
-
- 1740680778110
-
-
-
- 1740680778110
-
-
-
- 1740788899030
-
-
-
- 1740788899030
-
-
-
- 1740884332734
-
-
-
- 1740884332735
-
-
-
- 1740884971377
-
-
-
- 1740884971378
-
-
-
- 1740936527951
-
-
-
- 1740936527951
-
-
-
- 1741211604972
-
-
-
- 1741211604972
-
-
-
- 1741414797155
-
-
-
- 1741414797155
-
-
-
- 1741416193639
-
-
-
- 1741416193639
+
+
+
+
+
+
+
@@ -814,7 +669,143 @@
1743355166426
-
+
+
+ 1743385388051
+
+
+
+ 1743385388051
+
+
+
+ 1743385467178
+
+
+
+ 1743385467178
+
+
+
+ 1743385898871
+
+
+
+ 1743385898871
+
+
+
+ 1743459110471
+
+
+
+ 1743459110471
+
+
+
+ 1743459205311
+
+
+
+ 1743459205311
+
+
+
+ 1743470832619
+
+
+
+ 1743470832619
+
+
+
+ 1743644598841
+
+
+
+ 1743644598841
+
+
+
+ 1743644703041
+
+
+
+ 1743644703042
+
+
+
+ 1743644942488
+
+
+
+ 1743644942488
+
+
+
+ 1743645074051
+
+
+
+ 1743645074051
+
+
+
+ 1743647707334
+
+
+
+ 1743647707334
+
+
+
+ 1743691399769
+
+
+
+ 1743691399769
+
+
+
+ 1743691471368
+
+
+
+ 1743691471368
+
+
+
+ 1743705749057
+
+
+
+ 1743705749057
+
+
+
+ 1743710133267
+
+
+
+ 1743710133267
+
+
+
+ 1743710669869
+
+
+
+ 1743710669869
+
+
+
+ 1743811980098
+
+
+
+ 1743811980098
+
+
@@ -861,23 +852,6 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
@@ -886,7 +860,24 @@
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/README.md b/README.md
index 9eca34f..1f693e4 100644
--- a/README.md
+++ b/README.md
@@ -1,7 +1,9 @@
-
+
Welcome to OmniTools, a self-hosted web app offering a variety of online tools to simplify everyday tasks.
-Whether you are coding, manipulating images or crunching numbers, OmniTools has you covered. Please don't forget to
+Whether you are coding, manipulating images/videos, PDFs or crunching numbers, OmniTools has you covered. Please don't
+forget to
star the repo to support us.
Here is the [demo](https://omnitools.app) website.
@@ -110,11 +113,17 @@ npm run dev
### Create a new tool
+```bash
+npm run script:create:tool my-tool-name folder1 # npm run script:create:tool split pdf
+```
+
+For tools located under multiple nested directories, use:
+
```bash
npm run script:create:tool my-tool-name folder1/folder2 # npm run script:create:tool compress image/png
```
-Use `folder1\folder2` on Windows
+Use `folder1\folder2` on Windows.
### Run tests
diff --git a/img.png b/img.png
index b6f04cc..92db6e2 100644
Binary files a/img.png and b/img.png differ
diff --git a/package-lock.json b/package-lock.json
index b2074f9..3e2f349 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -40,6 +40,7 @@
"react-helmet": "^6.1.0",
"react-image-crop": "^11.0.7",
"react-router-dom": "^6.23.1",
+ "tesseract.js": "^6.0.0",
"type-fest": "^4.35.0",
"use-deep-compare-effect": "^1.8.1",
"yup": "^1.4.0"
@@ -6297,6 +6298,12 @@
"node": ">=0.10.0"
}
},
+ "node_modules/idb-keyval": {
+ "version": "6.2.1",
+ "resolved": "https://registry.npmjs.org/idb-keyval/-/idb-keyval-6.2.1.tgz",
+ "integrity": "sha512-8Sb3veuYCyrZL+VBt9LJfZjLUPWVvqn8tG28VqYNFCo43KHcKuq+b4EiXGeuaLAQWL2YmyDgMp2aSpH9JHsEQg==",
+ "license": "Apache-2.0"
+ },
"node_modules/ieee754": {
"version": "1.2.1",
"resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz",
@@ -6817,6 +6824,12 @@
"url": "https://github.com/sponsors/ljharb"
}
},
+ "node_modules/is-url": {
+ "version": "1.2.4",
+ "resolved": "https://registry.npmjs.org/is-url/-/is-url-1.2.4.tgz",
+ "integrity": "sha512-ITvGim8FhRiYe4IQ5uHSkj7pVaPDrCTkNd3yq3cV7iZAcJdHTUMPMEHcqSOy9xZ9qFenQCvi+2wjH9a1nXqHww==",
+ "license": "MIT"
+ },
"node_modules/is-weakmap": {
"version": "2.0.2",
"resolved": "https://registry.npmjs.org/is-weakmap/-/is-weakmap-2.0.2.tgz",
@@ -8102,6 +8115,15 @@
"protobufjs": "^7.2.4"
}
},
+ "node_modules/opencollective-postinstall": {
+ "version": "2.0.3",
+ "resolved": "https://registry.npmjs.org/opencollective-postinstall/-/opencollective-postinstall-2.0.3.tgz",
+ "integrity": "sha512-8AV/sCtuzUeTo8gQK5qDZzARrulB3egtLzFgteqB2tcT4Mw7B8Kt7JcDHmltjz6FOAHsvTevk70gZEbhM4ZS9Q==",
+ "license": "MIT",
+ "bin": {
+ "opencollective-postinstall": "index.js"
+ }
+ },
"node_modules/optionator": {
"version": "0.9.4",
"resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.4.tgz",
@@ -10091,6 +10113,36 @@
"url": "https://github.com/sponsors/ljharb"
}
},
+ "node_modules/tesseract.js": {
+ "version": "6.0.0",
+ "resolved": "https://registry.npmjs.org/tesseract.js/-/tesseract.js-6.0.0.tgz",
+ "integrity": "sha512-tqYCod1HwJzkeZw1l6XWx+ly2hhisGcBtak9MArhYwDAxL0NgeVhLJcUjqPxZMQtpgtVUzWcpZPryi+hnaQGVw==",
+ "hasInstallScript": true,
+ "license": "Apache-2.0",
+ "dependencies": {
+ "bmp-js": "^0.1.0",
+ "idb-keyval": "^6.2.0",
+ "is-url": "^1.2.4",
+ "node-fetch": "^2.6.9",
+ "opencollective-postinstall": "^2.0.3",
+ "regenerator-runtime": "^0.13.3",
+ "tesseract.js-core": "^6.0.0",
+ "wasm-feature-detect": "^1.2.11",
+ "zlibjs": "^0.3.1"
+ }
+ },
+ "node_modules/tesseract.js-core": {
+ "version": "6.0.0",
+ "resolved": "https://registry.npmjs.org/tesseract.js-core/-/tesseract.js-core-6.0.0.tgz",
+ "integrity": "sha512-1Qncm/9oKM7xgrQXZXNB+NRh19qiXGhxlrR8EwFbK5SaUbPZnS5OMtP/ghtqfd23hsr1ZvZbZjeuAGcMxd/ooA==",
+ "license": "Apache-2.0"
+ },
+ "node_modules/tesseract.js/node_modules/regenerator-runtime": {
+ "version": "0.13.11",
+ "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.13.11.tgz",
+ "integrity": "sha512-kY1AZVr2Ra+t+piVaJ4gxaFaReZVH40AKNo7UCX6W+dEwBo/2oZJzqfuN1qLq1oL45o56cPaTXELwrTh8Fpggg==",
+ "license": "MIT"
+ },
"node_modules/text-extensions": {
"version": "2.4.0",
"resolved": "https://registry.npmjs.org/text-extensions/-/text-extensions-2.4.0.tgz",
@@ -10690,6 +10742,12 @@
"node": ">=12.0.0"
}
},
+ "node_modules/wasm-feature-detect": {
+ "version": "1.8.0",
+ "resolved": "https://registry.npmjs.org/wasm-feature-detect/-/wasm-feature-detect-1.8.0.tgz",
+ "integrity": "sha512-zksaLKM2fVlnB5jQQDqKXXwYHLQUVH9es+5TOOHwGOVJOCeRBCiPjwSg+3tN2AdTCzjgli4jijCH290kXb/zWQ==",
+ "license": "Apache-2.0"
+ },
"node_modules/webidl-conversions": {
"version": "7.0.0",
"resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-7.0.0.tgz",
@@ -11103,6 +11161,15 @@
"url": "https://github.com/sponsors/sindresorhus"
}
},
+ "node_modules/zlibjs": {
+ "version": "0.3.1",
+ "resolved": "https://registry.npmjs.org/zlibjs/-/zlibjs-0.3.1.tgz",
+ "integrity": "sha512-+J9RrgTKOmlxFSDHo0pI1xM6BLVUv+o0ZT9ANtCxGkjIVCCUdx9alUF8Gm+dGLKbkkkidWIHFDZHDMpfITt4+w==",
+ "license": "MIT",
+ "engines": {
+ "node": "*"
+ }
+ },
"node_modules/zod": {
"version": "3.24.2",
"resolved": "https://registry.npmjs.org/zod/-/zod-3.24.2.tgz",
diff --git a/package.json b/package.json
index 68dfa2d..c0c605b 100644
--- a/package.json
+++ b/package.json
@@ -57,6 +57,7 @@
"react-helmet": "^6.1.0",
"react-image-crop": "^11.0.7",
"react-router-dom": "^6.23.1",
+ "tesseract.js": "^6.0.0",
"type-fest": "^4.35.0",
"use-deep-compare-effect": "^1.8.1",
"yup": "^1.4.0"
diff --git a/public/gs.js b/public/gs.js
new file mode 100644
index 0000000..3a48571
--- /dev/null
+++ b/public/gs.js
@@ -0,0 +1,39 @@
+// This is a placeholder file for the actual Ghostscript WASM implementation
+// In a real implementation, this would be the compiled Ghostscript WASM module
+
+// You would need to download the actual Ghostscript WASM files from:
+// https://github.com/ochachacha/ps2pdf-wasm or compile it yourself
+
+// This simulates the Module loading process that would occur with the real WASM file
+(function () {
+ // Simulate WASM loading
+ console.log('Loading Ghostscript WASM module...');
+
+ // Expose a simulated Module to the window
+ window.Module = window.Module || {};
+
+ // Simulate filesystem
+ window.FS = {
+ writeFile: function (name, data) {
+ console.log(`[Simulated] Writing file: ${name}`);
+ return true;
+ },
+ readFile: function (name, options) {
+ console.log(`[Simulated] Reading file: ${name}`);
+ // Return a sample Uint8Array that would represent a PDF
+ return new Uint8Array(10);
+ }
+ };
+
+ // Mark module as initialized after a delay to simulate loading
+ setTimeout(function () {
+ window.Module.calledRun = true;
+ console.log('Ghostscript WASM module loaded');
+
+ // Add callMain method for direct calling
+ window.Module.callMain = function (args) {
+ console.log('[Simulated] Running Ghostscript with args:', args);
+ // In a real implementation, this would execute the WASM module with the given arguments
+ };
+ }, 1000);
+})();
diff --git a/src/components/Hero.tsx b/src/components/Hero.tsx
index 58e9e19..6138575 100644
--- a/src/components/Hero.tsx
+++ b/src/components/Hero.tsx
@@ -12,7 +12,7 @@ import { Icon } from '@iconify/react';
const exampleTools: { label: string; url: string }[] = [
{
label: 'Create a transparent image',
- url: '/png/create-transparent'
+ url: '/image-generic/create-transparent'
},
{ label: 'Prettify JSON', url: '/json/prettify' },
{ label: 'Change GIF speed', url: '/gif/change-speed' },
@@ -35,7 +35,7 @@ export default function Hero() {
newInputValue: string
) => {
setInputValue(newInputValue);
- setFilteredTools(_.shuffle(filterTools(tools, newInputValue)));
+ setFilteredTools(filterTools(tools, newInputValue));
};
return (
diff --git a/src/components/Navbar/index.tsx b/src/components/Navbar/index.tsx
index f148df5..8fcf132 100644
--- a/src/components/Navbar/index.tsx
+++ b/src/components/Navbar/index.tsx
@@ -48,7 +48,7 @@ const Navbar: React.FC = ({ onSwitchTheme }) => {
src="https://ghbtns.com/github-btn.html?user=iib0011&repo=omni-tools&type=star&count=true&size=large"
frameBorder="0"
scrolling="0"
- width="130"
+ width="150"
height="30"
title="GitHub"
>,
diff --git a/src/components/ToolHeader.tsx b/src/components/ToolHeader.tsx
index 4db6369..148289c 100644
--- a/src/components/ToolHeader.tsx
+++ b/src/components/ToolHeader.tsx
@@ -5,6 +5,7 @@ import { capitalizeFirstLetter } from '../utils/string';
import Grid from '@mui/material/Grid';
import { Icon, IconifyIcon } from '@iconify/react';
import { categoriesColors } from '../config/uiConfig';
+import { getToolsByCategory } from '@tools/index';
const StyledButton = styled(Button)(({ theme }) => ({
backgroundColor: 'white',
@@ -70,7 +71,9 @@ export default function ToolHeader({
items={[
{ title: 'All tools', link: '/' },
{
- title: capitalizeFirstLetter(type),
+ title: getToolsByCategory().find(
+ (category) => category.type === type
+ )!.rawTitle,
link: '/categories/' + type
},
{ title }
diff --git a/src/components/ToolLayout.tsx b/src/components/ToolLayout.tsx
index fb7caef..3dc1db0 100644
--- a/src/components/ToolLayout.tsx
+++ b/src/components/ToolLayout.tsx
@@ -53,7 +53,10 @@ export default function ToolLayout({
{children}
category.type === type)!
+ .rawTitle
+ )} tools`}
toolCards={otherCategoryTools}
/>
diff --git a/src/components/result/ResultFooter.tsx b/src/components/result/ResultFooter.tsx
index 4de3176..0e96521 100644
--- a/src/components/result/ResultFooter.tsx
+++ b/src/components/result/ResultFooter.tsx
@@ -7,11 +7,13 @@ import React from 'react';
export default function ResultFooter({
handleDownload,
handleCopy,
- disabled
+ disabled,
+ hideCopy
}: {
handleDownload: () => void;
handleCopy: () => void;
disabled?: boolean;
+ hideCopy?: boolean;
}) {
return (
@@ -22,13 +24,15 @@ export default function ResultFooter({
>
Save as
- }
- >
- Copy to clipboard
-
+ {!hideCopy && (
+ }
+ >
+ Copy to clipboard
+
+ )}
);
}
diff --git a/src/components/result/ToolFileResult.tsx b/src/components/result/ToolFileResult.tsx
index 7b07578..b5c18b1 100644
--- a/src/components/result/ToolFileResult.tsx
+++ b/src/components/result/ToolFileResult.tsx
@@ -15,7 +15,7 @@ export default function ToolFileResult({
}: {
title?: string;
value: File | null;
- extension: string;
+ extension?: string;
loading?: boolean;
loadingText?: string;
}) {
@@ -50,9 +50,20 @@ export default function ToolFileResult({
const handleDownload = () => {
if (value) {
- const hasExtension = value.name.includes('.');
- const filename = hasExtension ? value.name : `${value.name}.${extension}`;
-
+ let filename: string = value.name;
+ if (extension) {
+ // Split at the last period to separate filename and extension
+ const parts = filename.split('.');
+ // If there's more than one part (meaning there was a period)
+ if (parts.length > 1) {
+ // Remove the last part (the extension) and add the new extension
+ parts.pop();
+ filename = `${parts.join('.')}.${extension}`;
+ } else {
+ // No extension exists, just add it
+ filename = `${filename}.${extension}`;
+ }
+ }
const blob = new Blob([value], { type: value.type });
const url = window.URL.createObjectURL(blob);
const a = document.createElement('a');
@@ -162,6 +173,7 @@ export default function ToolFileResult({
disabled={!value}
handleCopy={handleCopy}
handleDownload={handleDownload}
+ hideCopy={fileType === 'video' || fileType === 'audio'}
/>
);
diff --git a/src/components/result/ToolTextResult.tsx b/src/components/result/ToolTextResult.tsx
index cefa482..ca2b588 100644
--- a/src/components/result/ToolTextResult.tsx
+++ b/src/components/result/ToolTextResult.tsx
@@ -1,21 +1,24 @@
-import { Box, TextField } from '@mui/material';
+import { Box, CircularProgress, TextField, Typography } from '@mui/material';
import React, { useContext } from 'react';
import { CustomSnackBarContext } from '../../contexts/CustomSnackBarContext';
import InputHeader from '../InputHeader';
import ResultFooter from './ResultFooter';
import { replaceSpecialCharacters } from '@utils/string';
import mime from 'mime';
+import { globalInputHeight } from '../../config/uiConfig';
export default function ToolTextResult({
title = 'Result',
value,
extension = 'txt',
- keepSpecialCharacters
+ keepSpecialCharacters,
+ loading
}: {
title?: string;
value: string;
extension?: string;
keepSpecialCharacters?: boolean;
+ loading?: boolean;
}) {
const { showSnackBar } = useContext(CustomSnackBarContext);
const handleCopy = () => {
@@ -46,18 +49,37 @@ export default function ToolTextResult({
return (
-
+
+
+ Loading... This may take a moment.
+
+
+ ) : (
+
+ fullWidth
+ multiline
+ sx={{
+ '&.MuiTextField-root': {
+ backgroundColor: 'background.paper'
+ }
+ }}
+ rows={10}
+ inputProps={{ 'data-testid': 'text-result' }}
+ />
+ )}
);
diff --git a/src/config/uiConfig.ts b/src/config/uiConfig.ts
index b5bc07e..ef6f148 100644
--- a/src/config/uiConfig.ts
+++ b/src/config/uiConfig.ts
@@ -3,6 +3,7 @@ export const globalDescriptionFontSize = 12;
export const categoriesColors: string[] = [
'#8FBC5D',
'#3CB6E2',
+ '#B17F59',
'#FFD400',
'#AB6993'
];
diff --git a/src/lib/ghostscript/background-worker.js b/src/lib/ghostscript/background-worker.js
new file mode 100644
index 0000000..3bee269
--- /dev/null
+++ b/src/lib/ghostscript/background-worker.js
@@ -0,0 +1,173 @@
+import { COMPRESS_ACTION, PROTECT_ACTION } from './worker-init';
+
+function loadScript() {
+ import('./gs-worker.js');
+}
+
+var Module;
+
+function compressPdf(dataStruct, responseCallback) {
+ const compressionLevel = dataStruct.compressionLevel || 'medium';
+
+ // Set PDF settings based on compression level
+ let pdfSettings;
+ switch (compressionLevel) {
+ case 'low':
+ pdfSettings = '/printer'; // Higher quality, less compression
+ break;
+ case 'medium':
+ pdfSettings = '/ebook'; // Medium quality and compression
+ break;
+ case 'high':
+ pdfSettings = '/screen'; // Lower quality, higher compression
+ break;
+ default:
+ pdfSettings = '/ebook'; // Default to medium
+ }
+ // first download the ps data
+ var xhr = new XMLHttpRequest();
+ xhr.open('GET', dataStruct.psDataURL);
+ xhr.responseType = 'arraybuffer';
+ xhr.onload = function () {
+ console.log('onload');
+ // release the URL
+ self.URL.revokeObjectURL(dataStruct.psDataURL);
+ //set up EMScripten environment
+ Module = {
+ preRun: [
+ function () {
+ self.Module.FS.writeFile('input.pdf', new Uint8Array(xhr.response));
+ }
+ ],
+ postRun: [
+ function () {
+ var uarray = self.Module.FS.readFile('output.pdf', {
+ encoding: 'binary'
+ });
+ var blob = new Blob([uarray], { type: 'application/octet-stream' });
+ var pdfDataURL = self.URL.createObjectURL(blob);
+ responseCallback({
+ pdfDataURL: pdfDataURL,
+ url: dataStruct.url,
+ type: COMPRESS_ACTION
+ });
+ }
+ ],
+ arguments: [
+ '-sDEVICE=pdfwrite',
+ '-dCompatibilityLevel=1.4',
+ `-dPDFSETTINGS=${pdfSettings}`,
+ '-DNOPAUSE',
+ '-dQUIET',
+ '-dBATCH',
+ '-sOutputFile=output.pdf',
+ 'input.pdf'
+ ],
+ print: function (text) {},
+ printErr: function (text) {},
+ totalDependencies: 0,
+ noExitRuntime: 1
+ };
+ // Module.setStatus("Loading Ghostscript...");
+ if (!self.Module) {
+ self.Module = Module;
+ loadScript();
+ } else {
+ self.Module['calledRun'] = false;
+ self.Module['postRun'] = Module.postRun;
+ self.Module['preRun'] = Module.preRun;
+ self.Module.callMain();
+ }
+ };
+ xhr.send();
+}
+
+function protectPdf(dataStruct, responseCallback) {
+ const password = dataStruct.password || '';
+
+ // Validate password
+ if (!password) {
+ responseCallback({
+ error: 'Password is required for encryption',
+ url: dataStruct.url
+ });
+ return;
+ }
+ var xhr = new XMLHttpRequest();
+ xhr.open('GET', dataStruct.psDataURL);
+ xhr.responseType = 'arraybuffer';
+ xhr.onload = function () {
+ console.log('onload');
+ // release the URL
+ self.URL.revokeObjectURL(dataStruct.psDataURL);
+ //set up EMScripten environment
+ Module = {
+ preRun: [
+ function () {
+ self.Module.FS.writeFile('input.pdf', new Uint8Array(xhr.response));
+ }
+ ],
+ postRun: [
+ function () {
+ var uarray = self.Module.FS.readFile('output.pdf', {
+ encoding: 'binary'
+ });
+ var blob = new Blob([uarray], { type: 'application/octet-stream' });
+ var pdfDataURL = self.URL.createObjectURL(blob);
+ responseCallback({
+ pdfDataURL: pdfDataURL,
+ url: dataStruct.url,
+ type: PROTECT_ACTION
+ });
+ }
+ ],
+ arguments: [
+ '-sDEVICE=pdfwrite',
+ '-dCompatibilityLevel=1.4',
+ `-sOwnerPassword=${password}`,
+ `-sUserPassword=${password}`,
+ // Permissions (prevent copying/printing/etc)
+ '-dEncryptionPermissions=-4',
+ '-DNOPAUSE',
+ '-dQUIET',
+ '-dBATCH',
+ '-sOutputFile=output.pdf',
+ 'input.pdf'
+ ],
+ print: function (text) {},
+ printErr: function (text) {},
+ totalDependencies: 0,
+ noExitRuntime: 1
+ };
+ // Module.setStatus("Loading Ghostscript...");
+ if (!self.Module) {
+ self.Module = Module;
+ loadScript();
+ } else {
+ self.Module['calledRun'] = false;
+ self.Module['postRun'] = Module.postRun;
+ self.Module['preRun'] = Module.preRun;
+ self.Module.callMain();
+ }
+ };
+ xhr.send();
+}
+
+self.addEventListener('message', function ({ data: e }) {
+ console.log('message', e);
+ // e.data contains the message sent to the worker.
+ if (e.target !== 'wasm') {
+ return;
+ }
+ console.log('Message received from main script', e.data);
+ const responseCallback = ({ pdfDataURL, type }) => {
+ self.postMessage(pdfDataURL);
+ };
+ if (e.data.type === COMPRESS_ACTION) {
+ compressPdf(e.data, responseCallback);
+ } else if (e.data.type === PROTECT_ACTION) {
+ protectPdf(e.data, responseCallback);
+ }
+});
+
+console.log('Worker ready');
diff --git a/src/lib/ghostscript/gs-worker.js b/src/lib/ghostscript/gs-worker.js
new file mode 100644
index 0000000..85076f7
--- /dev/null
+++ b/src/lib/ghostscript/gs-worker.js
@@ -0,0 +1,5894 @@
+// include: shell.js
+// The Module object: Our interface to the outside world. We import
+// and export values on it. There are various ways Module can be used:
+// 1. Not defined. We create it here
+// 2. A function parameter, function(Module) { ..generated code.. }
+// 3. pre-run appended it, var Module = {}; ..generated code..
+// 4. External script tag defines var Module.
+// We need to check if Module already exists (e.g. case 3 above).
+// Substitution will be replaced with actual code on later stage of the build,
+// this way Closure Compiler will not mangle it (e.g. case 4. above).
+// Note that if you want to run closure, and also to use Module
+// after the generated code, you will need to define var Module = {};
+// before the code. Then that object will be used in the code, and you
+// can continue to use Module afterwards as well.
+var Module =
+ typeof Module != 'undefined' ? Module : self.Module ? self.Module : {};
+
+// --pre-jses are emitted after the Module integration code, so that they can
+// refer to Module (if they choose; they can also define Module)
+
+// Sometimes an existing Module object exists with properties
+// meant to overwrite the default module functionality. Here
+// we collect those properties and reapply _after_ we configure
+// the current environment's defaults to avoid having to be so
+// defensive during initialization.
+var moduleOverrides = Object.assign({}, Module);
+
+var arguments_ = [];
+var thisProgram = './this.program';
+var quit_ = (status, toThrow) => {
+ throw toThrow;
+};
+
+// Determine the runtime environment we are in. You can customize this by
+// setting the ENVIRONMENT setting at compile time (see settings.js).
+
+// Attempt to auto-detect the environment
+var ENVIRONMENT_IS_WEB = typeof window == 'object';
+var ENVIRONMENT_IS_WORKER = typeof importScripts == 'function';
+// N.b. Electron.js environment is simultaneously a NODE-environment, but
+// also a web environment.
+var ENVIRONMENT_IS_NODE =
+ typeof process == 'object' &&
+ typeof process.versions == 'object' &&
+ typeof process.versions.node == 'string';
+var ENVIRONMENT_IS_SHELL =
+ !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
+
+if (Module['ENVIRONMENT']) {
+ throw new Error(
+ 'Module.ENVIRONMENT has been deprecated. To force the environment, use the ENVIRONMENT compile-time option (for example, -sENVIRONMENT=web or -sENVIRONMENT=node)'
+ );
+}
+
+// `/` should be present at the end if `scriptDirectory` is not empty
+var scriptDirectory = '';
+function locateFile(path) {
+ if (Module['locateFile']) {
+ return Module['locateFile'](path, scriptDirectory);
+ }
+ return scriptDirectory + path;
+}
+
+// Hooks that are implemented differently in different runtime environments.
+var read_, readAsync, readBinary;
+
+if (ENVIRONMENT_IS_NODE) {
+ if (
+ typeof process == 'undefined' ||
+ !process.release ||
+ process.release.name !== 'node'
+ )
+ throw new Error(
+ 'not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)'
+ );
+
+ var nodeVersion = process.versions.node;
+ var numericVersion = nodeVersion.split('.').slice(0, 3);
+ numericVersion =
+ numericVersion[0] * 10000 +
+ numericVersion[1] * 100 +
+ numericVersion[2].split('-')[0] * 1;
+ var minVersion = 160000;
+ if (numericVersion < 160000) {
+ throw new Error(
+ 'This emscripten-generated code requires node v16.0.0 (detected v' +
+ nodeVersion +
+ ')'
+ );
+ }
+
+ // `require()` is no-op in an ESM module, use `createRequire()` to construct
+ // the require()` function. This is only necessary for multi-environment
+ // builds, `-sENVIRONMENT=node` emits a static import declaration instead.
+ // TODO: Swap all `require()`'s with `import()`'s?
+ // These modules will usually be used on Node.js. Load them eagerly to avoid
+ // the complexity of lazy-loading.
+ var fs = require('fs');
+ var nodePath = require('path');
+
+ if (ENVIRONMENT_IS_WORKER) {
+ scriptDirectory = nodePath.dirname(scriptDirectory) + '/';
+ } else {
+ scriptDirectory = __dirname + '/';
+ }
+
+ // include: node_shell_read.js
+ read_ = (filename, binary) => {
+ // We need to re-wrap `file://` strings to URLs. Normalizing isn't
+ // necessary in that case, the path should already be absolute.
+ filename = isFileURI(filename)
+ ? new URL(filename)
+ : nodePath.normalize(filename);
+ return fs.readFileSync(filename, binary ? undefined : 'utf8');
+ };
+
+ readBinary = (filename) => {
+ var ret = read_(filename, true);
+ if (!ret.buffer) {
+ ret = new Uint8Array(ret);
+ }
+ assert(ret.buffer);
+ return ret;
+ };
+
+ readAsync = (filename, onload, onerror, binary = true) => {
+ // See the comment in the `read_` function.
+ filename = isFileURI(filename)
+ ? new URL(filename)
+ : nodePath.normalize(filename);
+ fs.readFile(filename, binary ? undefined : 'utf8', (err, data) => {
+ if (err) onerror(err);
+ else onload(binary ? data.buffer : data);
+ });
+ };
+ // end include: node_shell_read.js
+ if (!Module['thisProgram'] && process.argv.length > 1) {
+ thisProgram = process.argv[1].replace(/\\/g, '/');
+ }
+
+ arguments_ = process.argv.slice(2);
+
+ if (typeof module != 'undefined') {
+ module['exports'] = Module;
+ }
+
+ process.on('uncaughtException', (ex) => {
+ // suppress ExitStatus exceptions from showing an error
+ if (
+ ex !== 'unwind' &&
+ !(ex instanceof ExitStatus) &&
+ !(ex.context instanceof ExitStatus)
+ ) {
+ throw ex;
+ }
+ });
+
+ quit_ = (status, toThrow) => {
+ process.exitCode = status;
+ throw toThrow;
+ };
+} else if (ENVIRONMENT_IS_SHELL) {
+ if (
+ (typeof process == 'object' && typeof require === 'function') ||
+ typeof window == 'object' ||
+ typeof importScripts == 'function'
+ )
+ throw new Error(
+ 'not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)'
+ );
+
+ if (typeof read != 'undefined') {
+ read_ = read;
+ }
+
+ readBinary = (f) => {
+ if (typeof readbuffer == 'function') {
+ return new Uint8Array(readbuffer(f));
+ }
+ let data = read(f, 'binary');
+ assert(typeof data == 'object');
+ return data;
+ };
+
+ readAsync = (f, onload, onerror) => {
+ setTimeout(() => onload(readBinary(f)));
+ };
+
+ if (typeof clearTimeout == 'undefined') {
+ globalThis.clearTimeout = (id) => {};
+ }
+
+ if (typeof setTimeout == 'undefined') {
+ // spidermonkey lacks setTimeout but we use it above in readAsync.
+ globalThis.setTimeout = (f) => (typeof f == 'function' ? f() : abort());
+ }
+
+ if (typeof scriptArgs != 'undefined') {
+ arguments_ = scriptArgs;
+ } else if (typeof arguments != 'undefined') {
+ arguments_ = arguments;
+ }
+
+ if (typeof quit == 'function') {
+ quit_ = (status, toThrow) => {
+ // Unlike node which has process.exitCode, d8 has no such mechanism. So we
+ // have no way to set the exit code and then let the program exit with
+ // that code when it naturally stops running (say, when all setTimeouts
+ // have completed). For that reason, we must call `quit` - the only way to
+ // set the exit code - but quit also halts immediately. To increase
+ // consistency with node (and the web) we schedule the actual quit call
+ // using a setTimeout to give the current stack and any exception handlers
+ // a chance to run. This enables features such as addOnPostRun (which
+ // expected to be able to run code after main returns).
+ setTimeout(() => {
+ if (!(toThrow instanceof ExitStatus)) {
+ let toLog = toThrow;
+ if (toThrow && typeof toThrow == 'object' && toThrow.stack) {
+ toLog = [toThrow, toThrow.stack];
+ }
+ err(`exiting due to exception: ${toLog}`);
+ }
+ quit(status);
+ });
+ throw toThrow;
+ };
+ }
+
+ if (typeof print != 'undefined') {
+ // Prefer to use print/printErr where they exist, as they usually work better.
+ if (typeof console == 'undefined') console = /** @type{!Console} */ ({});
+ console.log = /** @type{!function(this:Console, ...*): undefined} */ (
+ print
+ );
+ console.warn = console.error =
+ /** @type{!function(this:Console, ...*): undefined} */ (
+ typeof printErr != 'undefined' ? printErr : print
+ );
+ }
+}
+
+// Note that this includes Node.js workers when relevant (pthreads is enabled).
+// Node.js workers are detected as a combination of ENVIRONMENT_IS_WORKER and
+// ENVIRONMENT_IS_NODE.
+else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
+ if (ENVIRONMENT_IS_WORKER) {
+ // Check worker, not web, since window could be polyfilled
+ scriptDirectory = self.location.href;
+ } else if (typeof document != 'undefined' && document.currentScript) {
+ // web
+ scriptDirectory = document.currentScript.src;
+ }
+ // blob urls look like blob:http://site.com/etc/etc and we cannot infer anything from them.
+ // otherwise, slice off the final part of the url to find the script directory.
+ // if scriptDirectory does not contain a slash, lastIndexOf will return -1,
+ // and scriptDirectory will correctly be replaced with an empty string.
+ // If scriptDirectory contains a query (starting with ?) or a fragment (starting with #),
+ // they are removed because they could contain a slash.
+ if (scriptDirectory.startsWith('blob:')) {
+ scriptDirectory = '';
+ } else {
+ scriptDirectory = scriptDirectory.substr(
+ 0,
+ scriptDirectory.replace(/[?#].*/, '').lastIndexOf('/') + 1
+ );
+ }
+
+ if (!(typeof window == 'object' || typeof importScripts == 'function'))
+ throw new Error(
+ 'not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)'
+ );
+
+ // Differentiate the Web Worker from the Node Worker case, as reading must
+ // be done differently.
+ {
+ // include: web_or_worker_shell_read.js
+ read_ = (url) => {
+ var xhr = new XMLHttpRequest();
+ xhr.open('GET', url, false);
+ xhr.send(null);
+ return xhr.responseText;
+ };
+
+ if (ENVIRONMENT_IS_WORKER) {
+ readBinary = (url) => {
+ var xhr = new XMLHttpRequest();
+ xhr.open('GET', url, false);
+ xhr.responseType = 'arraybuffer';
+ xhr.send(null);
+ return new Uint8Array(/** @type{!ArrayBuffer} */ (xhr.response));
+ };
+ }
+
+ readAsync = (url, onload, onerror) => {
+ var xhr = new XMLHttpRequest();
+ xhr.open('GET', url, true);
+ xhr.responseType = 'arraybuffer';
+ xhr.onload = () => {
+ if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) {
+ // file URLs can return 0
+ onload(xhr.response);
+ return;
+ }
+ onerror();
+ };
+ xhr.onerror = onerror;
+ xhr.send(null);
+ };
+
+ // end include: web_or_worker_shell_read.js
+ }
+} else {
+ throw new Error('environment detection error');
+}
+
+var out = Module['print'] || console.log.bind(console);
+var err = Module['printErr'] || console.error.bind(console);
+
+// Merge back in the overrides
+Object.assign(Module, moduleOverrides);
+// Free the object hierarchy contained in the overrides, this lets the GC
+// reclaim data used.
+moduleOverrides = null;
+checkIncomingModuleAPI();
+
+// Emit code to handle expected values on the Module object. This applies Module.x
+// to the proper local x. This has two benefits: first, we only emit it if it is
+// expected to arrive, and second, by using a local everywhere else that can be
+// minified.
+
+if (Module['arguments']) arguments_ = Module['arguments'];
+legacyModuleProp('arguments', 'arguments_');
+
+if (Module['thisProgram']) thisProgram = Module['thisProgram'];
+legacyModuleProp('thisProgram', 'thisProgram');
+
+if (Module['quit']) quit_ = Module['quit'];
+legacyModuleProp('quit', 'quit_');
+
+// perform assertions in shell.js after we set up out() and err(), as otherwise if an assertion fails it cannot print the message
+// Assertions on removed incoming Module JS APIs.
+assert(
+ typeof Module['memoryInitializerPrefixURL'] == 'undefined',
+ 'Module.memoryInitializerPrefixURL option was removed, use Module.locateFile instead'
+);
+assert(
+ typeof Module['pthreadMainPrefixURL'] == 'undefined',
+ 'Module.pthreadMainPrefixURL option was removed, use Module.locateFile instead'
+);
+assert(
+ typeof Module['cdInitializerPrefixURL'] == 'undefined',
+ 'Module.cdInitializerPrefixURL option was removed, use Module.locateFile instead'
+);
+assert(
+ typeof Module['filePackagePrefixURL'] == 'undefined',
+ 'Module.filePackagePrefixURL option was removed, use Module.locateFile instead'
+);
+assert(
+ typeof Module['read'] == 'undefined',
+ 'Module.read option was removed (modify read_ in JS)'
+);
+assert(
+ typeof Module['readAsync'] == 'undefined',
+ 'Module.readAsync option was removed (modify readAsync in JS)'
+);
+assert(
+ typeof Module['readBinary'] == 'undefined',
+ 'Module.readBinary option was removed (modify readBinary in JS)'
+);
+assert(
+ typeof Module['setWindowTitle'] == 'undefined',
+ 'Module.setWindowTitle option was removed (modify emscripten_set_window_title in JS)'
+);
+assert(
+ typeof Module['TOTAL_MEMORY'] == 'undefined',
+ 'Module.TOTAL_MEMORY has been renamed Module.INITIAL_MEMORY'
+);
+legacyModuleProp('asm', 'wasmExports');
+legacyModuleProp('read', 'read_');
+legacyModuleProp('readAsync', 'readAsync');
+legacyModuleProp('readBinary', 'readBinary');
+legacyModuleProp('setWindowTitle', 'setWindowTitle');
+var IDBFS = 'IDBFS is no longer included by default; build with -lidbfs.js';
+var PROXYFS =
+ 'PROXYFS is no longer included by default; build with -lproxyfs.js';
+var WORKERFS =
+ 'WORKERFS is no longer included by default; build with -lworkerfs.js';
+var FETCHFS =
+ 'FETCHFS is no longer included by default; build with -lfetchfs.js';
+var ICASEFS =
+ 'ICASEFS is no longer included by default; build with -licasefs.js';
+var JSFILEFS =
+ 'JSFILEFS is no longer included by default; build with -ljsfilefs.js';
+var OPFS = 'OPFS is no longer included by default; build with -lopfs.js';
+
+var NODEFS = 'NODEFS is no longer included by default; build with -lnodefs.js';
+
+assert(
+ !ENVIRONMENT_IS_SHELL,
+ 'shell environment detected but not enabled at build time. Add `shell` to `-sENVIRONMENT` to enable.'
+);
+
+// end include: shell.js
+
+// include: preamble.js
+// === Preamble library stuff ===
+
+// Documentation for the public APIs defined in this file must be updated in:
+// site/source/docs/api_reference/preamble.js.rst
+// A prebuilt local version of the documentation is available at:
+// site/build/text/docs/api_reference/preamble.js.txt
+// You can also build docs locally as HTML or other formats in site/
+// An online HTML version (which may be of a different version of Emscripten)
+// is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html
+
+var wasmBinary;
+if (Module['wasmBinary']) wasmBinary = Module['wasmBinary'];
+legacyModuleProp('wasmBinary', 'wasmBinary');
+
+if (typeof WebAssembly != 'object') {
+ err('no native wasm support detected');
+}
+
+// Wasm globals
+
+var wasmMemory;
+
+//========================================
+// Runtime essentials
+//========================================
+
+// whether we are quitting the application. no code should run after this.
+// set in exit() and abort()
+var ABORT = false;
+
+// set by exit() and abort(). Passed to 'onExit' handler.
+// NOTE: This is also used as the process return code code in shell environments
+// but only when noExitRuntime is false.
+var EXITSTATUS;
+
+// In STRICT mode, we only define assert() when ASSERTIONS is set. i.e. we
+// don't define it at all in release modes. This matches the behaviour of
+// MINIMAL_RUNTIME.
+// TODO(sbc): Make this the default even without STRICT enabled.
+/** @type {function(*, string=)} */
+function assert(condition, text) {
+ if (!condition) {
+ abort('Assertion failed' + (text ? ': ' + text : ''));
+ }
+}
+
+// We used to include malloc/free by default in the past. Show a helpful error in
+// builds with assertions.
+
+// Memory management
+
+var HEAP,
+ /** @type {!Int8Array} */
+ HEAP8,
+ /** @type {!Uint8Array} */
+ HEAPU8,
+ /** @type {!Int16Array} */
+ HEAP16,
+ /** @type {!Uint16Array} */
+ HEAPU16,
+ /** @type {!Int32Array} */
+ HEAP32,
+ /** @type {!Uint32Array} */
+ HEAPU32,
+ /** @type {!Float32Array} */
+ HEAPF32,
+ /** @type {!Float64Array} */
+ HEAPF64;
+
+// include: runtime_shared.js
+function updateMemoryViews() {
+ var b = wasmMemory.buffer;
+ Module['HEAP8'] = HEAP8 = new Int8Array(b);
+ Module['HEAP16'] = HEAP16 = new Int16Array(b);
+ Module['HEAPU8'] = HEAPU8 = new Uint8Array(b);
+ Module['HEAPU16'] = HEAPU16 = new Uint16Array(b);
+ Module['HEAP32'] = HEAP32 = new Int32Array(b);
+ Module['HEAPU32'] = HEAPU32 = new Uint32Array(b);
+ Module['HEAPF32'] = HEAPF32 = new Float32Array(b);
+ Module['HEAPF64'] = HEAPF64 = new Float64Array(b);
+}
+// end include: runtime_shared.js
+assert(
+ !Module['STACK_SIZE'],
+ 'STACK_SIZE can no longer be set at runtime. Use -sSTACK_SIZE at link time'
+);
+
+assert(
+ typeof Int32Array != 'undefined' &&
+ typeof Float64Array !== 'undefined' &&
+ Int32Array.prototype.subarray != undefined &&
+ Int32Array.prototype.set != undefined,
+ 'JS engine does not provide full typed array support'
+);
+
+// If memory is defined in wasm, the user can't provide it, or set INITIAL_MEMORY
+assert(
+ !Module['wasmMemory'],
+ 'Use of `wasmMemory` detected. Use -sIMPORTED_MEMORY to define wasmMemory externally'
+);
+assert(
+ !Module['INITIAL_MEMORY'],
+ 'Detected runtime INITIAL_MEMORY setting. Use -sIMPORTED_MEMORY to define wasmMemory dynamically'
+);
+
+// include: runtime_stack_check.js
+// Initializes the stack cookie. Called at the startup of main and at the startup of each thread in pthreads mode.
+function writeStackCookie() {
+ var max = _emscripten_stack_get_end();
+ assert((max & 3) == 0);
+ // If the stack ends at address zero we write our cookies 4 bytes into the
+ // stack. This prevents interference with SAFE_HEAP and ASAN which also
+ // monitor writes to address zero.
+ if (max == 0) {
+ max += 4;
+ }
+ // The stack grow downwards towards _emscripten_stack_get_end.
+ // We write cookies to the final two words in the stack and detect if they are
+ // ever overwritten.
+ HEAPU32[max >> 2] = 0x02135467;
+ HEAPU32[(max + 4) >> 2] = 0x89bacdfe;
+ // Also test the global address 0 for integrity.
+ HEAPU32[0 >> 2] = 1668509029;
+}
+
+function checkStackCookie() {
+ if (ABORT) return;
+ var max = _emscripten_stack_get_end();
+ // See writeStackCookie().
+ if (max == 0) {
+ max += 4;
+ }
+ var cookie1 = HEAPU32[max >> 2];
+ var cookie2 = HEAPU32[(max + 4) >> 2];
+ if (cookie1 != 0x02135467 || cookie2 != 0x89bacdfe) {
+ abort(
+ `Stack overflow! Stack cookie has been overwritten at ${ptrToString(
+ max
+ )}, expected hex dwords 0x89BACDFE and 0x2135467, but received ${ptrToString(
+ cookie2
+ )} ${ptrToString(cookie1)}`
+ );
+ }
+ // Also test the global address 0 for integrity.
+ if (HEAPU32[0 >> 2] != 0x63736d65 /* 'emsc' */) {
+ abort(
+ 'Runtime error: The application has corrupted its heap memory area (address zero)!'
+ );
+ }
+}
+// end include: runtime_stack_check.js
+// include: runtime_assertions.js
+// Endianness check
+(function () {
+ var h16 = new Int16Array(1);
+ var h8 = new Int8Array(h16.buffer);
+ h16[0] = 0x6373;
+ if (h8[0] !== 0x73 || h8[1] !== 0x63)
+ throw 'Runtime error: expected the system to be little-endian! (Run with -sSUPPORT_BIG_ENDIAN to bypass)';
+})();
+
+// end include: runtime_assertions.js
+var __ATPRERUN__ = []; // functions called before the runtime is initialized
+var __ATINIT__ = []; // functions called during startup
+var __ATMAIN__ = []; // functions called when main() is to be run
+var __ATEXIT__ = []; // functions called during shutdown
+var __ATPOSTRUN__ = []; // functions called after the main() is called
+
+var runtimeInitialized = false;
+
+var runtimeExited = false;
+
+function preRun() {
+ if (Module['preRun']) {
+ if (typeof Module['preRun'] == 'function')
+ Module['preRun'] = [Module['preRun']];
+ while (Module['preRun'].length) {
+ addOnPreRun(Module['preRun'].shift());
+ }
+ }
+ callRuntimeCallbacks(__ATPRERUN__);
+}
+
+function initRuntime() {
+ assert(!runtimeInitialized);
+ runtimeInitialized = true;
+
+ checkStackCookie();
+
+ if (!Module['noFSInit'] && !FS.init.initialized) FS.init();
+ FS.ignorePermissions = false;
+
+ TTY.init();
+ callRuntimeCallbacks(__ATINIT__);
+}
+
+function preMain() {
+ checkStackCookie();
+
+ callRuntimeCallbacks(__ATMAIN__);
+}
+
+function exitRuntime() {
+ assert(!runtimeExited);
+ checkStackCookie();
+ ___funcs_on_exit(); // Native atexit() functions
+ callRuntimeCallbacks(__ATEXIT__);
+ FS.quit();
+ TTY.shutdown();
+ runtimeExited = true;
+}
+
+function postRun() {
+ checkStackCookie();
+
+ if (Module['postRun']) {
+ if (typeof Module['postRun'] == 'function')
+ Module['postRun'] = [Module['postRun']];
+ while (Module['postRun'].length) {
+ addOnPostRun(Module['postRun'].shift());
+ }
+ }
+
+ callRuntimeCallbacks(__ATPOSTRUN__);
+}
+
+function addOnPreRun(cb) {
+ __ATPRERUN__.unshift(cb);
+}
+
+function addOnInit(cb) {
+ __ATINIT__.unshift(cb);
+}
+
+function addOnPreMain(cb) {
+ __ATMAIN__.unshift(cb);
+}
+
+function addOnExit(cb) {
+ __ATEXIT__.unshift(cb);
+}
+
+function addOnPostRun(cb) {
+ __ATPOSTRUN__.unshift(cb);
+}
+
+// include: runtime_math.js
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul
+
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/fround
+
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32
+
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc
+
+assert(
+ Math.imul,
+ 'This browser does not support Math.imul(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill'
+);
+assert(
+ Math.fround,
+ 'This browser does not support Math.fround(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill'
+);
+assert(
+ Math.clz32,
+ 'This browser does not support Math.clz32(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill'
+);
+assert(
+ Math.trunc,
+ 'This browser does not support Math.trunc(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill'
+);
+// end include: runtime_math.js
+// A counter of dependencies for calling run(). If we need to
+// do asynchronous work before running, increment this and
+// decrement it. Incrementing must happen in a place like
+// Module.preRun (used by emcc to add file preloading).
+// Note that you can add dependencies in preRun, even though
+// it happens right before run - run will be postponed until
+// the dependencies are met.
+var runDependencies = 0;
+var runDependencyWatcher = null;
+var dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled
+var runDependencyTracking = {};
+
+function getUniqueRunDependency(id) {
+ var orig = id;
+ while (1) {
+ if (!runDependencyTracking[id]) return id;
+ id = orig + Math.random();
+ }
+}
+
+function addRunDependency(id) {
+ runDependencies++;
+
+ Module['monitorRunDependencies']?.(runDependencies);
+
+ if (id) {
+ assert(!runDependencyTracking[id]);
+ runDependencyTracking[id] = 1;
+ if (runDependencyWatcher === null && typeof setInterval != 'undefined') {
+ // Check for missing dependencies every few seconds
+ runDependencyWatcher = setInterval(() => {
+ if (ABORT) {
+ clearInterval(runDependencyWatcher);
+ runDependencyWatcher = null;
+ return;
+ }
+ var shown = false;
+ for (var dep in runDependencyTracking) {
+ if (!shown) {
+ shown = true;
+ err('still waiting on run dependencies:');
+ }
+ err(`dependency: ${dep}`);
+ }
+ if (shown) {
+ err('(end of list)');
+ }
+ }, 10000);
+ }
+ } else {
+ err('warning: run dependency added without ID');
+ }
+}
+
+function removeRunDependency(id) {
+ runDependencies--;
+
+ Module['monitorRunDependencies']?.(runDependencies);
+
+ if (id) {
+ assert(runDependencyTracking[id]);
+ delete runDependencyTracking[id];
+ } else {
+ err('warning: run dependency removed without ID');
+ }
+ if (runDependencies == 0) {
+ if (runDependencyWatcher !== null) {
+ clearInterval(runDependencyWatcher);
+ runDependencyWatcher = null;
+ }
+ if (dependenciesFulfilled) {
+ var callback = dependenciesFulfilled;
+ dependenciesFulfilled = null;
+ callback(); // can add another dependenciesFulfilled
+ }
+ }
+}
+
+/** @param {string|number=} what */
+function abort(what) {
+ Module['onAbort']?.(what);
+
+ what = 'Aborted(' + what + ')';
+ // TODO(sbc): Should we remove printing and leave it up to whoever
+ // catches the exception?
+ err(what);
+
+ ABORT = true;
+ EXITSTATUS = 1;
+
+ // Use a wasm runtime error, because a JS error might be seen as a foreign
+ // exception, which means we'd run destructors on it. We need the error to
+ // simply make the program stop.
+ // FIXME This approach does not work in Wasm EH because it currently does not assume
+ // all RuntimeErrors are from traps; it decides whether a RuntimeError is from
+ // a trap or not based on a hidden field within the object. So at the moment
+ // we don't have a way of throwing a wasm trap from JS. TODO Make a JS API that
+ // allows this in the wasm spec.
+
+ // Suppress closure compiler warning here. Closure compiler's builtin extern
+ // definition for WebAssembly.RuntimeError claims it takes no arguments even
+ // though it can.
+ // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure gets fixed.
+ /** @suppress {checkTypes} */
+ var e = new WebAssembly.RuntimeError(what);
+
+ // Throw the error whether or not MODULARIZE is set because abort is used
+ // in code paths apart from instantiation where an exception is expected
+ // to be thrown when abort is called.
+ throw e;
+}
+
+// include: memoryprofiler.js
+// end include: memoryprofiler.js
+// include: URIUtils.js
+// Prefix of data URIs emitted by SINGLE_FILE and related options.
+var dataURIPrefix = 'data:application/octet-stream;base64,';
+
+/**
+ * Indicates whether filename is a base64 data URI.
+ * @noinline
+ */
+var isDataURI = (filename) => filename.startsWith(dataURIPrefix);
+
+/**
+ * Indicates whether filename is delivered via file protocol (as opposed to http/https)
+ * @noinline
+ */
+var isFileURI = (filename) => filename.startsWith('file://');
+// end include: URIUtils.js
+function createExportWrapper(name) {
+ return (...args) => {
+ assert(
+ runtimeInitialized,
+ `native function \`${name}\` called before runtime initialization`
+ );
+ assert(
+ !runtimeExited,
+ `native function \`${name}\` called after runtime exit (use NO_EXIT_RUNTIME to keep it alive after main() exits)`
+ );
+ var f = wasmExports[name];
+ assert(f, `exported native function \`${name}\` not found`);
+ return f(...args);
+ };
+}
+
+// include: runtime_exceptions.js
+// end include: runtime_exceptions.js
+var wasmBinaryFile;
+wasmBinaryFile = 'https://cdn-wasm.b-cdn.net/gs-worker.wasm';
+// if (!isDataURI(wasmBinaryFile)) {
+// wasmBinaryFile = 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';
+}
+
+function getBinaryPromise(binaryFile) {
+ // If we don't have the binary yet, try to load it asynchronously.
+ // Fetch has some additional restrictions over XHR, like it can't be used on a file:// url.
+ // See https://github.com/github/fetch/pull/92#issuecomment-140665932
+ // Cordova or Electron apps are typically loaded from a file:// url.
+ // So use fetch if it is available and the url is not a file, otherwise fall back to XHR.
+ if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
+ if (typeof fetch == 'function' && !isFileURI(binaryFile)) {
+ return fetch(binaryFile, { credentials: 'same-origin' })
+ .then((response) => {
+ if (!response['ok']) {
+ throw `failed to load wasm binary file at '${binaryFile}'`;
+ }
+ return response['arrayBuffer']();
+ })
+ .catch(() => getBinarySync(binaryFile));
+ } else if (readAsync) {
+ // fetch is not available or url is file => try XHR (readAsync uses XHR internally)
+ return new Promise((resolve, reject) => {
+ readAsync(
+ binaryFile,
+ (response) =>
+ resolve(new Uint8Array(/** @type{!ArrayBuffer} */ (response))),
+ reject
+ );
+ });
+ }
+ }
+
+ // Otherwise, getBinarySync should be able to get it synchronously
+ return Promise.resolve().then(() => getBinarySync(binaryFile));
+}
+
+function instantiateArrayBuffer(binaryFile, imports, receiver) {
+ return getBinaryPromise(binaryFile)
+ .then((binary) => {
+ return WebAssembly.instantiate(binary, imports);
+ })
+ .then(receiver, (reason) => {
+ err(`failed to asynchronously prepare wasm: ${reason}`);
+
+ // Warn on some common problems.
+ if (isFileURI(wasmBinaryFile)) {
+ err(
+ `warning: Loading from a file URI (${wasmBinaryFile}) is not supported in most browsers. See https://emscripten.org/docs/getting_started/FAQ.html#how-do-i-run-a-local-webserver-for-testing-why-does-my-program-stall-in-downloading-or-preparing`
+ );
+ }
+ abort(reason);
+ });
+}
+
+function instantiateAsync(binary, binaryFile, imports, callback) {
+ if (
+ !binary &&
+ typeof WebAssembly.instantiateStreaming == 'function' &&
+ !isDataURI(binaryFile) &&
+ // Don't use streaming for file:// delivered objects in a webview, fetch them synchronously.
+ !isFileURI(binaryFile) &&
+ // Avoid instantiateStreaming() on Node.js environment for now, as while
+ // Node.js v18.1.0 implements it, it does not have a full fetch()
+ // implementation yet.
+ //
+ // Reference:
+ // https://github.com/emscripten-core/emscripten/pull/16917
+ !ENVIRONMENT_IS_NODE &&
+ typeof fetch == 'function'
+ ) {
+ return fetch(binaryFile, { credentials: 'same-origin' }).then(
+ (response) => {
+ // Suppress closure warning here since the upstream definition for
+ // instantiateStreaming only allows Promise rather than
+ // an actual Response.
+ // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure is fixed.
+ /** @suppress {checkTypes} */
+ var result = WebAssembly.instantiateStreaming(response, imports);
+
+ return result.then(callback, function (reason) {
+ // We expect the most common failure cause to be a bad MIME type for the binary,
+ // in which case falling back to ArrayBuffer instantiation should work.
+ err(`wasm streaming compile failed: ${reason}`);
+ err('falling back to ArrayBuffer instantiation');
+ return instantiateArrayBuffer(binaryFile, imports, callback);
+ });
+ }
+ );
+ }
+ return instantiateArrayBuffer(binaryFile, imports, callback);
+}
+
+// Create the wasm instance.
+// Receives the wasm imports, returns the exports.
+function createWasm() {
+ // prepare imports
+ var info = {
+ env: wasmImports,
+ wasi_snapshot_preview1: wasmImports
+ };
+ // Load the wasm module and create an instance of using native support in the JS engine.
+ // handle a generated wasm instance, receiving its exports and
+ // performing other necessary setup
+ /** @param {WebAssembly.Module=} module*/
+ function receiveInstance(instance, module) {
+ wasmExports = instance.exports;
+
+ wasmMemory = wasmExports['memory'];
+
+ assert(wasmMemory, 'memory not found in wasm exports');
+ updateMemoryViews();
+
+ wasmTable = wasmExports['__indirect_function_table'];
+
+ assert(wasmTable, 'table not found in wasm exports');
+
+ addOnInit(wasmExports['__wasm_call_ctors']);
+
+ removeRunDependency('wasm-instantiate');
+ return wasmExports;
+ }
+ // wait for the pthread pool (if any)
+ addRunDependency('wasm-instantiate');
+
+ // Prefer streaming instantiation if available.
+ // Async compilation can be confusing when an error on the page overwrites Module
+ // (for example, if the order of elements is wrong, and the one defining Module is
+ // later), so we save Module and check it later.
+ var trueModule = Module;
+ function receiveInstantiationResult(result) {
+ // 'result' is a ResultObject object which has both the module and instance.
+ // receiveInstance() will swap in the exports (to Module.asm) so they can be called
+ assert(
+ Module === trueModule,
+ 'the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?'
+ );
+ trueModule = null;
+ // TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line.
+ // When the regression is fixed, can restore the above PTHREADS-enabled path.
+ receiveInstance(result['instance']);
+ }
+
+ // User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback
+ // to manually instantiate the Wasm module themselves. This allows pages to
+ // run the instantiation parallel to any other async startup actions they are
+ // performing.
+ // Also pthreads and wasm workers initialize the wasm instance through this
+ // path.
+ if (Module['instantiateWasm']) {
+ try {
+ return Module['instantiateWasm'](info, receiveInstance);
+ } catch (e) {
+ err(`Module.instantiateWasm callback failed with error: ${e}`);
+ return false;
+ }
+ }
+
+ instantiateAsync(
+ wasmBinary,
+ wasmBinaryFile,
+ info,
+ receiveInstantiationResult
+ );
+ return {}; // no exports yet; we'll fill them in later
+}
+
+// Globals used by JS i64 conversions (see makeSetValue)
+var tempDouble;
+var tempI64;
+
+// include: runtime_debug.js
+function legacyModuleProp(prop, newName, incoming = true) {
+ if (!Object.getOwnPropertyDescriptor(Module, prop)) {
+ Object.defineProperty(Module, prop, {
+ configurable: true,
+ get() {
+ let extra = incoming
+ ? ' (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)'
+ : '';
+ abort(`\`Module.${prop}\` has been replaced by \`${newName}\`` + extra);
+ }
+ });
+ }
+}
+
+function ignoredModuleProp(prop) {
+ if (Object.getOwnPropertyDescriptor(Module, prop)) {
+ abort(
+ `\`Module.${prop}\` was supplied but \`${prop}\` not included in INCOMING_MODULE_JS_API`
+ );
+ }
+}
+
+// forcing the filesystem exports a few things by default
+function isExportedByForceFilesystem(name) {
+ return (
+ name === 'FS_createPath' ||
+ name === 'FS_createDataFile' ||
+ name === 'FS_createPreloadedFile' ||
+ name === 'FS_unlink' ||
+ name === 'addRunDependency' ||
+ // The old FS has some functionality that WasmFS lacks.
+ name === 'FS_createLazyFile' ||
+ name === 'FS_createDevice' ||
+ name === 'removeRunDependency'
+ );
+}
+
+function missingGlobal(sym, msg) {
+ if (typeof globalThis !== 'undefined') {
+ Object.defineProperty(globalThis, sym, {
+ configurable: true,
+ get() {
+ warnOnce(`\`${sym}\` is not longer defined by emscripten. ${msg}`);
+ return undefined;
+ }
+ });
+ }
+}
+
+missingGlobal('buffer', 'Please use HEAP8.buffer or wasmMemory.buffer');
+missingGlobal('asm', 'Please use wasmExports instead');
+
+function missingLibrarySymbol(sym) {
+ if (
+ typeof globalThis !== 'undefined' &&
+ !Object.getOwnPropertyDescriptor(globalThis, sym)
+ ) {
+ Object.defineProperty(globalThis, sym, {
+ configurable: true,
+ get() {
+ // Can't `abort()` here because it would break code that does runtime
+ // checks. e.g. `if (typeof SDL === 'undefined')`.
+ var msg = `\`${sym}\` is a library symbol and not included by default; add it to your library.js __deps or to DEFAULT_LIBRARY_FUNCS_TO_INCLUDE on the command line`;
+ // DEFAULT_LIBRARY_FUNCS_TO_INCLUDE requires the name as it appears in
+ // library.js, which means $name for a JS name with no prefix, or name
+ // for a JS name like _name.
+ var librarySymbol = sym;
+ if (!librarySymbol.startsWith('_')) {
+ librarySymbol = '$' + sym;
+ }
+ msg += ` (e.g. -sDEFAULT_LIBRARY_FUNCS_TO_INCLUDE='${librarySymbol}')`;
+ if (isExportedByForceFilesystem(sym)) {
+ msg +=
+ '. Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you';
+ }
+ warnOnce(msg);
+ return undefined;
+ }
+ });
+ }
+ // Any symbol that is not included from the JS library is also (by definition)
+ // not exported on the Module object.
+ unexportedRuntimeSymbol(sym);
+}
+
+function unexportedRuntimeSymbol(sym) {
+ if (!Object.getOwnPropertyDescriptor(Module, sym)) {
+ Object.defineProperty(Module, sym, {
+ configurable: true,
+ get() {
+ var msg = `'${sym}' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the Emscripten FAQ)`;
+ if (isExportedByForceFilesystem(sym)) {
+ msg +=
+ '. Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you';
+ }
+ abort(msg);
+ }
+ });
+ }
+}
+
+// Used by XXXXX_DEBUG settings to output debug messages.
+function dbg(...args) {
+ // TODO(sbc): Make this configurable somehow. Its not always convenient for
+ // logging to show up as warnings.
+ console.warn(...args);
+}
+// end include: runtime_debug.js
+// === Body ===
+// end include: preamble.js
+
+/** @constructor */
+function ExitStatus(status) {
+ this.name = 'ExitStatus';
+ this.message = `Program terminated with exit(${status})`;
+ this.status = status;
+}
+
+var callRuntimeCallbacks = (callbacks) => {
+ while (callbacks.length > 0) {
+ // Pass the module as the first argument.
+ callbacks.shift()(Module);
+ }
+};
+
+/**
+ * @param {number} ptr
+ * @param {string} type
+ */
+function getValue(ptr, type = 'i8') {
+ if (type.endsWith('*')) type = '*';
+ switch (type) {
+ case 'i1':
+ return HEAP8[ptr];
+ case 'i8':
+ return HEAP8[ptr];
+ case 'i16':
+ return HEAP16[ptr >> 1];
+ case 'i32':
+ return HEAP32[ptr >> 2];
+ case 'i64':
+ abort('to do getValue(i64) use WASM_BIGINT');
+ case 'float':
+ return HEAPF32[ptr >> 2];
+ case 'double':
+ return HEAPF64[ptr >> 3];
+ case '*':
+ return HEAPU32[ptr >> 2];
+ default:
+ abort(`invalid type for getValue: ${type}`);
+ }
+}
+
+var noExitRuntime = Module['noExitRuntime'] || false;
+
+var ptrToString = (ptr) => {
+ assert(typeof ptr === 'number');
+ // With CAN_ADDRESS_2GB or MEMORY64, pointers are already unsigned.
+ ptr >>>= 0;
+ return '0x' + ptr.toString(16).padStart(8, '0');
+};
+
+/**
+ * @param {number} ptr
+ * @param {number} value
+ * @param {string} type
+ */
+function setValue(ptr, value, type = 'i8') {
+ if (type.endsWith('*')) type = '*';
+ switch (type) {
+ case 'i1':
+ HEAP8[ptr] = value;
+ break;
+ case 'i8':
+ HEAP8[ptr] = value;
+ break;
+ case 'i16':
+ HEAP16[ptr >> 1] = value;
+ break;
+ case 'i32':
+ HEAP32[ptr >> 2] = value;
+ break;
+ case 'i64':
+ abort('to do setValue(i64) use WASM_BIGINT');
+ case 'float':
+ HEAPF32[ptr >> 2] = value;
+ break;
+ case 'double':
+ HEAPF64[ptr >> 3] = value;
+ break;
+ case '*':
+ HEAPU32[ptr >> 2] = value;
+ break;
+ default:
+ abort(`invalid type for setValue: ${type}`);
+ }
+}
+
+var warnOnce = (text) => {
+ warnOnce.shown ||= {};
+ if (!warnOnce.shown[text]) {
+ warnOnce.shown[text] = 1;
+ if (ENVIRONMENT_IS_NODE) text = 'warning: ' + text;
+ err(text);
+ }
+};
+
+var UTF8Decoder =
+ typeof TextDecoder != 'undefined' ? new TextDecoder('utf8') : undefined;
+
+/**
+ * Given a pointer 'idx' to a null-terminated UTF8-encoded string in the given
+ * array that contains uint8 values, returns a copy of that string as a
+ * Javascript String object.
+ * heapOrArray is either a regular array, or a JavaScript typed array view.
+ * @param {number} idx
+ * @param {number=} maxBytesToRead
+ * @return {string}
+ */
+var UTF8ArrayToString = (heapOrArray, idx, maxBytesToRead) => {
+ var endIdx = idx + maxBytesToRead;
+ var endPtr = idx;
+ // TextDecoder needs to know the byte length in advance, it doesn't stop on
+ // null terminator by itself. Also, use the length info to avoid running tiny
+ // strings through TextDecoder, since .subarray() allocates garbage.
+ // (As a tiny code save trick, compare endPtr against endIdx using a negation,
+ // so that undefined means Infinity)
+ while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr;
+
+ if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
+ return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
+ }
+ var str = '';
+ // If building with TextDecoder, we have already computed the string length
+ // above, so test loop end condition against that
+ while (idx < endPtr) {
+ // For UTF8 byte structure, see:
+ // http://en.wikipedia.org/wiki/UTF-8#Description
+ // https://www.ietf.org/rfc/rfc2279.txt
+ // https://tools.ietf.org/html/rfc3629
+ var u0 = heapOrArray[idx++];
+ if (!(u0 & 0x80)) {
+ str += String.fromCharCode(u0);
+ continue;
+ }
+ var u1 = heapOrArray[idx++] & 63;
+ if ((u0 & 0xe0) == 0xc0) {
+ str += String.fromCharCode(((u0 & 31) << 6) | u1);
+ continue;
+ }
+ var u2 = heapOrArray[idx++] & 63;
+ if ((u0 & 0xf0) == 0xe0) {
+ u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
+ } else {
+ if ((u0 & 0xf8) != 0xf0)
+ warnOnce(
+ 'Invalid UTF-8 leading byte ' +
+ ptrToString(u0) +
+ ' encountered when deserializing a UTF-8 string in wasm memory to a JS string!'
+ );
+ u0 =
+ ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[idx++] & 63);
+ }
+
+ if (u0 < 0x10000) {
+ str += String.fromCharCode(u0);
+ } else {
+ var ch = u0 - 0x10000;
+ str += String.fromCharCode(0xd800 | (ch >> 10), 0xdc00 | (ch & 0x3ff));
+ }
+ }
+ return str;
+};
+
+/**
+ * Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the
+ * emscripten HEAP, returns a copy of that string as a Javascript String object.
+ *
+ * @param {number} ptr
+ * @param {number=} maxBytesToRead - An optional length that specifies the
+ * maximum number of bytes to read. You can omit this parameter to scan the
+ * string until the first 0 byte. If maxBytesToRead is passed, and the string
+ * at [ptr, ptr+maxBytesToReadr[ contains a null byte in the middle, then the
+ * string will cut short at that byte index (i.e. maxBytesToRead will not
+ * produce a string of exact length [ptr, ptr+maxBytesToRead[) N.B. mixing
+ * frequent uses of UTF8ToString() with and without maxBytesToRead may throw
+ * JS JIT optimizations off, so it is worth to consider consistently using one
+ * @return {string}
+ */
+var UTF8ToString = (ptr, maxBytesToRead) => {
+ assert(
+ typeof ptr == 'number',
+ `UTF8ToString expects a number (got ${typeof ptr})`
+ );
+ return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : '';
+};
+var ___assert_fail = (condition, filename, line, func) => {
+ abort(
+ `Assertion failed: ${UTF8ToString(condition)}, at: ` +
+ [
+ filename ? UTF8ToString(filename) : 'unknown filename',
+ line,
+ func ? UTF8ToString(func) : 'unknown function'
+ ]
+ );
+};
+
+var PATH = {
+ isAbs: (path) => path.charAt(0) === '/',
+ splitPath: (filename) => {
+ var splitPathRe =
+ /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
+ return splitPathRe.exec(filename).slice(1);
+ },
+ normalizeArray: (parts, allowAboveRoot) => {
+ // if the path tries to go above the root, `up` ends up > 0
+ 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 the path is allowed to go above the root, restore leading ..s
+ if (allowAboveRoot) {
+ for (; up; up--) {
+ parts.unshift('..');
+ }
+ }
+ return parts;
+ },
+ normalize: (path) => {
+ var isAbsolute = PATH.isAbs(path),
+ trailingSlash = path.substr(-1) === '/';
+ // Normalize the path
+ 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) {
+ // No dirname whatsoever
+ return '.';
+ }
+ if (dir) {
+ // It has a dirname, strip trailing slash
+ dir = dir.substr(0, dir.length - 1);
+ }
+ return root + dir;
+ },
+ basename: (path) => {
+ // EMSCRIPTEN return '/'' for '/', not an empty string
+ if (path === '/') return '/';
+ path = PATH.normalize(path);
+ path = path.replace(/\/$/, '');
+ var lastSlash = path.lastIndexOf('/');
+ if (lastSlash === -1) return path;
+ return path.substr(lastSlash + 1);
+ },
+ join: (...paths) => PATH.normalize(paths.join('/')),
+ join2: (l, r) => PATH.normalize(l + '/' + r)
+};
+
+var initRandomFill = () => {
+ if (
+ typeof crypto == 'object' &&
+ typeof crypto['getRandomValues'] == 'function'
+ ) {
+ // for modern web browsers
+ return (view) => crypto.getRandomValues(view);
+ } else if (ENVIRONMENT_IS_NODE) {
+ // for nodejs with or without crypto support included
+ try {
+ var crypto_module = require('crypto');
+ var randomFillSync = crypto_module['randomFillSync'];
+ if (randomFillSync) {
+ // nodejs with LTS crypto support
+ return (view) => crypto_module['randomFillSync'](view);
+ }
+ // very old nodejs with the original crypto API
+ var randomBytes = crypto_module['randomBytes'];
+ return (view) => (
+ view.set(randomBytes(view.byteLength)),
+ // Return the original view to match modern native implementations.
+ view
+ );
+ } catch (e) {
+ // nodejs doesn't have crypto support
+ }
+ }
+ // we couldn't find a proper implementation, as Math.random() is not suitable for /dev/random, see emscripten-core/emscripten/pull/7096
+ abort(
+ 'no cryptographic support found for randomDevice. consider polyfilling it if you want to use something insecure like Math.random(), e.g. put this in a --pre-js: var crypto = { getRandomValues: (array) => { for (var i = 0; i < array.length; i++) array[i] = (Math.random()*256)|0 } };'
+ );
+};
+var randomFill = (view) => {
+ // Lazily init on the first invocation.
+ return (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();
+ // Skip empty and invalid entries
+ if (typeof path != 'string') {
+ throw new TypeError('Arguments to path.resolve must be strings');
+ } else if (!path) {
+ return ''; // an invalid portion invalidates the whole thing
+ }
+ resolvedPath = path + '/' + resolvedPath;
+ resolvedAbsolute = PATH.isAbs(path);
+ }
+ // At this point the path should be resolved to a full absolute path, but
+ // handle relative paths to be safe (might happen when process.cwd() fails)
+ resolvedPath = PATH.normalizeArray(
+ resolvedPath.split('/').filter((p) => !!p),
+ !resolvedAbsolute
+ ).join('/');
+ return (resolvedAbsolute ? '/' : '') + resolvedPath || '.';
+ },
+ relative: (from, to) => {
+ from = PATH_FS.resolve(from).substr(1);
+ to = PATH_FS.resolve(to).substr(1);
+ function trim(arr) {
+ var start = 0;
+ for (; start < arr.length; start++) {
+ if (arr[start] !== '') break;
+ }
+ var end = arr.length - 1;
+ for (; end >= 0; end--) {
+ if (arr[end] !== '') break;
+ }
+ if (start > end) return [];
+ return arr.slice(start, end - start + 1);
+ }
+ var fromParts = trim(from.split('/'));
+ var toParts = trim(to.split('/'));
+ var length = Math.min(fromParts.length, toParts.length);
+ var samePartsLength = length;
+ for (var i = 0; i < length; i++) {
+ if (fromParts[i] !== toParts[i]) {
+ samePartsLength = i;
+ break;
+ }
+ }
+ var outputParts = [];
+ for (var i = samePartsLength; i < fromParts.length; i++) {
+ outputParts.push('..');
+ }
+ outputParts = outputParts.concat(toParts.slice(samePartsLength));
+ return outputParts.join('/');
+ }
+};
+
+var FS_stdin_getChar_buffer = [];
+
+var lengthBytesUTF8 = (str) => {
+ var len = 0;
+ for (var i = 0; i < str.length; ++i) {
+ // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code
+ // unit, not a Unicode code point of the character! So decode
+ // UTF16->UTF32->UTF8.
+ // See http://unicode.org/faq/utf_bom.html#utf16-3
+ var c = str.charCodeAt(i); // possibly a lead surrogate
+ if (c <= 0x7f) {
+ len++;
+ } else if (c <= 0x7ff) {
+ len += 2;
+ } else if (c >= 0xd800 && c <= 0xdfff) {
+ len += 4;
+ ++i;
+ } else {
+ len += 3;
+ }
+ }
+ return len;
+};
+
+var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => {
+ assert(
+ typeof str === 'string',
+ `stringToUTF8Array expects a string (got ${typeof str})`
+ );
+ // Parameter maxBytesToWrite is not optional. Negative values, 0, null,
+ // undefined and false each don't write out any bytes.
+ if (!(maxBytesToWrite > 0)) return 0;
+
+ var startIdx = outIdx;
+ var endIdx = outIdx + maxBytesToWrite - 1; // -1 for string null terminator.
+ for (var i = 0; i < str.length; ++i) {
+ // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code
+ // unit, not a Unicode code point of the character! So decode
+ // UTF16->UTF32->UTF8.
+ // See http://unicode.org/faq/utf_bom.html#utf16-3
+ // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description
+ // and https://www.ietf.org/rfc/rfc2279.txt
+ // and https://tools.ietf.org/html/rfc3629
+ var u = str.charCodeAt(i); // possibly a lead surrogate
+ if (u >= 0xd800 && u <= 0xdfff) {
+ var u1 = str.charCodeAt(++i);
+ u = (0x10000 + ((u & 0x3ff) << 10)) | (u1 & 0x3ff);
+ }
+ if (u <= 0x7f) {
+ if (outIdx >= endIdx) break;
+ heap[outIdx++] = u;
+ } else if (u <= 0x7ff) {
+ if (outIdx + 1 >= endIdx) break;
+ heap[outIdx++] = 0xc0 | (u >> 6);
+ heap[outIdx++] = 0x80 | (u & 63);
+ } else if (u <= 0xffff) {
+ if (outIdx + 2 >= endIdx) break;
+ heap[outIdx++] = 0xe0 | (u >> 12);
+ heap[outIdx++] = 0x80 | ((u >> 6) & 63);
+ heap[outIdx++] = 0x80 | (u & 63);
+ } else {
+ if (outIdx + 3 >= endIdx) break;
+ if (u > 0x10ffff)
+ warnOnce(
+ 'Invalid Unicode code point ' +
+ ptrToString(u) +
+ ' encountered when serializing a JS string to a UTF-8 string in wasm memory! (Valid unicode code points should be in range 0-0x10FFFF).'
+ );
+ heap[outIdx++] = 0xf0 | (u >> 18);
+ heap[outIdx++] = 0x80 | ((u >> 12) & 63);
+ heap[outIdx++] = 0x80 | ((u >> 6) & 63);
+ heap[outIdx++] = 0x80 | (u & 63);
+ }
+ }
+ // Null-terminate the pointer to the buffer.
+ heap[outIdx] = 0;
+ return outIdx - startIdx;
+};
+/** @type {function(string, boolean=, number=)} */
+function intArrayFromString(stringy, dontAddNull, length) {
+ var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1;
+ var u8array = new Array(len);
+ var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length);
+ if (dontAddNull) u8array.length = numBytesWritten;
+ return u8array;
+}
+var FS_stdin_getChar = () => {
+ if (!FS_stdin_getChar_buffer.length) {
+ var result = null;
+ if (ENVIRONMENT_IS_NODE) {
+ // we will read data by chunks of BUFSIZE
+ var BUFSIZE = 256;
+ var buf = Buffer.alloc(BUFSIZE);
+ var bytesRead = 0;
+
+ // For some reason we must suppress a closure warning here, even though
+ // fd definitely exists on process.stdin, and is even the proper way to
+ // get the fd of stdin,
+ // https://github.com/nodejs/help/issues/2136#issuecomment-523649904
+ // This started to happen after moving this logic out of library_tty.js,
+ // so it is related to the surrounding code in some unclear manner.
+ /** @suppress {missingProperties} */
+ var fd = process.stdin.fd;
+
+ try {
+ bytesRead = fs.readSync(fd, buf);
+ } catch (e) {
+ // Cross-platform differences: on Windows, reading EOF throws an exception, but on other OSes,
+ // reading EOF returns 0. Uniformize behavior by treating the EOF exception to return 0.
+ if (e.toString().includes('EOF')) bytesRead = 0;
+ else throw e;
+ }
+
+ if (bytesRead > 0) {
+ result = buf.slice(0, bytesRead).toString('utf-8');
+ } else {
+ result = null;
+ }
+ } else if (
+ typeof window != 'undefined' &&
+ typeof window.prompt == 'function'
+ ) {
+ // Browser.
+ result = window.prompt('Input: '); // returns null on cancel
+ if (result !== null) {
+ result += '\n';
+ }
+ } else if (typeof readline == 'function') {
+ // Command line.
+ result = readline();
+ if (result !== null) {
+ result += '\n';
+ }
+ }
+ if (!result) {
+ return null;
+ }
+ FS_stdin_getChar_buffer = intArrayFromString(result, true);
+ }
+ return FS_stdin_getChar_buffer.shift();
+};
+var TTY = {
+ ttys: [],
+ init() {
+ // https://github.com/emscripten-core/emscripten/pull/1555
+ // if (ENVIRONMENT_IS_NODE) {
+ // // currently, FS.init does not distinguish if process.stdin is a file or TTY
+ // // device, it always assumes it's a TTY device. because of this, we're forcing
+ // // process.stdin to UTF8 encoding to at least make stdin reading compatible
+ // // with text files until FS.init can be refactored.
+ // process.stdin.setEncoding('utf8');
+ // }
+ },
+ shutdown() {
+ // https://github.com/emscripten-core/emscripten/pull/1555
+ // if (ENVIRONMENT_IS_NODE) {
+ // // inolen: any idea as to why node -e 'process.stdin.read()' wouldn't exit immediately (with process.stdin being a tty)?
+ // // isaacs: because now it's reading from the stream, you've expressed interest in it, so that read() kicks off a _read() which creates a ReadReq operation
+ // // inolen: I thought read() in that case was a synchronous operation that just grabbed some amount of buffered data if it exists?
+ // // isaacs: it is. but it also triggers a _read() call, which calls readStart() on the handle
+ // // isaacs: do process.stdin.pause() and i'd think it'd probably close the pending call
+ // process.stdin.pause();
+ // }
+ },
+ register(dev, ops) {
+ TTY.ttys[dev] = { input: [], output: [], ops: 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) {
+ // flush any pending line data
+ stream.tty.ops.fsync(stream.tty);
+ },
+ fsync(stream) {
+ stream.tty.ops.fsync(stream.tty);
+ },
+ read(stream, buffer, offset, length, pos /* ignored */) {
+ if (!stream.tty || !stream.tty.ops.get_char) {
+ throw new FS.ErrnoError(60);
+ }
+ var bytesRead = 0;
+ for (var i = 0; i < length; i++) {
+ var result;
+ try {
+ result = stream.tty.ops.get_char(stream.tty);
+ } catch (e) {
+ throw new FS.ErrnoError(29);
+ }
+ if (result === undefined && bytesRead === 0) {
+ throw new FS.ErrnoError(6);
+ }
+ if (result === null || result === undefined) break;
+ bytesRead++;
+ buffer[offset + i] = result;
+ }
+ if (bytesRead) {
+ stream.node.timestamp = Date.now();
+ }
+ return bytesRead;
+ },
+ write(stream, buffer, offset, length, pos) {
+ if (!stream.tty || !stream.tty.ops.put_char) {
+ throw new FS.ErrnoError(60);
+ }
+ try {
+ for (var i = 0; i < length; i++) {
+ stream.tty.ops.put_char(stream.tty, buffer[offset + i]);
+ }
+ } catch (e) {
+ throw new FS.ErrnoError(29);
+ }
+ if (length) {
+ stream.node.timestamp = Date.now();
+ }
+ return i;
+ }
+ },
+ default_tty_ops: {
+ get_char(tty) {
+ return FS_stdin_getChar();
+ },
+ put_char(tty, val) {
+ if (val === null || val === 10) {
+ out(UTF8ArrayToString(tty.output, 0));
+ tty.output = [];
+ } else {
+ if (val != 0) tty.output.push(val); // val == 0 would cut text output off in the middle.
+ }
+ },
+ fsync(tty) {
+ if (tty.output && tty.output.length > 0) {
+ out(UTF8ArrayToString(tty.output, 0));
+ tty.output = [];
+ }
+ },
+ ioctl_tcgets(tty) {
+ // typical setting
+ return {
+ c_iflag: 25856,
+ c_oflag: 5,
+ c_cflag: 191,
+ c_lflag: 35387,
+ c_cc: [
+ 0x03, 0x1c, 0x7f, 0x15, 0x04, 0x00, 0x01, 0x00, 0x11, 0x13, 0x1a,
+ 0x00, 0x12, 0x0f, 0x17, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+ ]
+ };
+ },
+ ioctl_tcsets(tty, optional_actions, data) {
+ // currently just ignore
+ return 0;
+ },
+ ioctl_tiocgwinsz(tty) {
+ return [24, 80];
+ }
+ },
+ default_tty1_ops: {
+ put_char(tty, val) {
+ if (val === null || val === 10) {
+ err(UTF8ArrayToString(tty.output, 0));
+ tty.output = [];
+ } else {
+ if (val != 0) tty.output.push(val);
+ }
+ },
+ fsync(tty) {
+ if (tty.output && tty.output.length > 0) {
+ err(UTF8ArrayToString(tty.output, 0));
+ tty.output = [];
+ }
+ }
+ }
+};
+
+var zeroMemory = (address, size) => {
+ HEAPU8.fill(0, address, address + size);
+ return address;
+};
+
+var alignMemory = (size, alignment) => {
+ assert(alignment, 'alignment argument is required');
+ return Math.ceil(size / alignment) * alignment;
+};
+var mmapAlloc = (size) => {
+ abort(
+ 'internal error: mmapAlloc called but `emscripten_builtin_memalign` native symbol not exported'
+ );
+};
+var MEMFS = {
+ ops_table: null,
+ mount(mount) {
+ return MEMFS.createNode(null, '/', 16384 | 511 /* 0777 */, 0);
+ },
+ createNode(parent, name, mode, dev) {
+ if (FS.isBlkdev(mode) || FS.isFIFO(mode)) {
+ // no supported
+ throw new FS.ErrnoError(63);
+ }
+ MEMFS.ops_table ||= {
+ dir: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr,
+ lookup: MEMFS.node_ops.lookup,
+ mknod: MEMFS.node_ops.mknod,
+ rename: MEMFS.node_ops.rename,
+ unlink: MEMFS.node_ops.unlink,
+ rmdir: MEMFS.node_ops.rmdir,
+ readdir: MEMFS.node_ops.readdir,
+ symlink: MEMFS.node_ops.symlink
+ },
+ stream: {
+ llseek: MEMFS.stream_ops.llseek
+ }
+ },
+ file: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr
+ },
+ stream: {
+ llseek: MEMFS.stream_ops.llseek,
+ read: MEMFS.stream_ops.read,
+ write: MEMFS.stream_ops.write,
+ allocate: MEMFS.stream_ops.allocate,
+ mmap: MEMFS.stream_ops.mmap,
+ msync: MEMFS.stream_ops.msync
+ }
+ },
+ link: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr,
+ readlink: MEMFS.node_ops.readlink
+ },
+ stream: {}
+ },
+ chrdev: {
+ node: {
+ getattr: MEMFS.node_ops.getattr,
+ setattr: MEMFS.node_ops.setattr
+ },
+ stream: FS.chrdev_stream_ops
+ }
+ };
+ var node = FS.createNode(parent, name, mode, dev);
+ if (FS.isDir(node.mode)) {
+ node.node_ops = MEMFS.ops_table.dir.node;
+ node.stream_ops = MEMFS.ops_table.dir.stream;
+ node.contents = {};
+ } else if (FS.isFile(node.mode)) {
+ node.node_ops = MEMFS.ops_table.file.node;
+ node.stream_ops = MEMFS.ops_table.file.stream;
+ node.usedBytes = 0; // The actual number of bytes used in the typed array, as opposed to contents.length which gives the whole capacity.
+ // When the byte data of the file is populated, this will point to either a typed array, or a normal JS array. Typed arrays are preferred
+ // for performance, and used by default. However, typed arrays are not resizable like normal JS arrays are, so there is a small disk size
+ // penalty involved for appending file writes that continuously grow a file similar to std::vector capacity vs used -scheme.
+ node.contents = null;
+ } else if (FS.isLink(node.mode)) {
+ node.node_ops = MEMFS.ops_table.link.node;
+ node.stream_ops = MEMFS.ops_table.link.stream;
+ } else if (FS.isChrdev(node.mode)) {
+ node.node_ops = MEMFS.ops_table.chrdev.node;
+ node.stream_ops = MEMFS.ops_table.chrdev.stream;
+ }
+ node.timestamp = Date.now();
+ // add the new node to the parent
+ if (parent) {
+ parent.contents[name] = node;
+ parent.timestamp = node.timestamp;
+ }
+ return node;
+ },
+ getFileDataAsTypedArray(node) {
+ if (!node.contents) return new Uint8Array(0);
+ if (node.contents.subarray)
+ return node.contents.subarray(0, node.usedBytes); // Make sure to not return excess unused bytes.
+ return new Uint8Array(node.contents);
+ },
+ expandFileStorage(node, newCapacity) {
+ var prevCapacity = node.contents ? node.contents.length : 0;
+ if (prevCapacity >= newCapacity) return; // No need to expand, the storage was already large enough.
+ // Don't expand strictly to the given requested limit if it's only a very small increase, but instead geometrically grow capacity.
+ // For small filesizes (<1MB), perform size*2 geometric increase, but for large sizes, do a much more conservative size*1.125 increase to
+ // avoid overshooting the allocation cap by a very large margin.
+ var CAPACITY_DOUBLING_MAX = 1024 * 1024;
+ newCapacity = Math.max(
+ newCapacity,
+ (prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2.0 : 1.125)) >>>
+ 0
+ );
+ if (prevCapacity != 0) newCapacity = Math.max(newCapacity, 256); // At minimum allocate 256b for each file when expanding.
+ var oldContents = node.contents;
+ node.contents = new Uint8Array(newCapacity); // Allocate new storage.
+ if (node.usedBytes > 0)
+ node.contents.set(oldContents.subarray(0, node.usedBytes), 0); // Copy old data over to the new storage.
+ },
+ resizeFileStorage(node, newSize) {
+ if (node.usedBytes == newSize) return;
+ if (newSize == 0) {
+ node.contents = null; // Fully decommit when requesting a resize to zero.
+ node.usedBytes = 0;
+ } else {
+ var oldContents = node.contents;
+ node.contents = new Uint8Array(newSize); // Allocate new storage.
+ if (oldContents) {
+ node.contents.set(
+ oldContents.subarray(0, Math.min(newSize, node.usedBytes))
+ ); // Copy old data over to the new storage.
+ }
+ node.usedBytes = newSize;
+ }
+ },
+ node_ops: {
+ getattr(node) {
+ var attr = {};
+ // device numbers reuse inode numbers.
+ attr.dev = FS.isChrdev(node.mode) ? node.id : 1;
+ attr.ino = node.id;
+ attr.mode = node.mode;
+ attr.nlink = 1;
+ attr.uid = 0;
+ attr.gid = 0;
+ attr.rdev = node.rdev;
+ if (FS.isDir(node.mode)) {
+ attr.size = 4096;
+ } else if (FS.isFile(node.mode)) {
+ attr.size = node.usedBytes;
+ } else if (FS.isLink(node.mode)) {
+ attr.size = node.link.length;
+ } else {
+ attr.size = 0;
+ }
+ attr.atime = new Date(node.timestamp);
+ attr.mtime = new Date(node.timestamp);
+ attr.ctime = new Date(node.timestamp);
+ // NOTE: In our implementation, st_blocks = Math.ceil(st_size/st_blksize),
+ // but this is not required by the standard.
+ attr.blksize = 4096;
+ attr.blocks = Math.ceil(attr.size / attr.blksize);
+ return attr;
+ },
+ setattr(node, attr) {
+ if (attr.mode !== undefined) {
+ node.mode = attr.mode;
+ }
+ if (attr.timestamp !== undefined) {
+ node.timestamp = attr.timestamp;
+ }
+ if (attr.size !== undefined) {
+ MEMFS.resizeFileStorage(node, attr.size);
+ }
+ },
+ lookup(parent, name) {
+ throw FS.genericErrors[44];
+ },
+ mknod(parent, name, mode, dev) {
+ return MEMFS.createNode(parent, name, mode, dev);
+ },
+ rename(old_node, new_dir, new_name) {
+ // if we're overwriting a directory at new_name, make sure it's empty.
+ if (FS.isDir(old_node.mode)) {
+ var new_node;
+ try {
+ new_node = FS.lookupNode(new_dir, new_name);
+ } catch (e) {}
+ if (new_node) {
+ for (var i in new_node.contents) {
+ throw new FS.ErrnoError(55);
+ }
+ }
+ }
+ // do the internal rewiring
+ delete old_node.parent.contents[old_node.name];
+ old_node.parent.timestamp = Date.now();
+ old_node.name = new_name;
+ new_dir.contents[new_name] = old_node;
+ new_dir.timestamp = old_node.parent.timestamp;
+ old_node.parent = new_dir;
+ },
+ unlink(parent, name) {
+ delete parent.contents[name];
+ parent.timestamp = 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.timestamp = Date.now();
+ },
+ readdir(node) {
+ var entries = ['.', '..'];
+ for (var key of Object.keys(node.contents)) {
+ entries.push(key);
+ }
+ return entries;
+ },
+ symlink(parent, newname, oldpath) {
+ var node = MEMFS.createNode(parent, newname, 511 /* 0777 */ | 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);
+ assert(size >= 0);
+ if (size > 8 && contents.subarray) {
+ // non-trivial, and typed array
+ 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) {
+ // The data buffer should be a typed array view
+ assert(!(buffer instanceof ArrayBuffer));
+ // If the buffer is located in main memory (HEAP), and if
+ // memory can grow, we can't hold on to references of the
+ // memory buffer, as they may get invalidated. That means we
+ // need to do copy its contents.
+ if (buffer.buffer === HEAP8.buffer) {
+ canOwn = false;
+ }
+
+ if (!length) return 0;
+ var node = stream.node;
+ node.timestamp = Date.now();
+
+ if (buffer.subarray && (!node.contents || node.contents.subarray)) {
+ // This write is from a typed array to a typed array?
+ if (canOwn) {
+ assert(
+ position === 0,
+ 'canOwn must imply no weird position inside the file'
+ );
+ node.contents = buffer.subarray(offset, offset + length);
+ node.usedBytes = length;
+ return length;
+ } else if (node.usedBytes === 0 && position === 0) {
+ // If this is a simple first write to an empty file, do a fast set since we don't need to care about old data.
+ node.contents = buffer.slice(offset, offset + length);
+ node.usedBytes = length;
+ return length;
+ } else if (position + length <= node.usedBytes) {
+ // Writing to an already allocated and used subrange of the file?
+ node.contents.set(buffer.subarray(offset, offset + length), position);
+ return length;
+ }
+ }
+
+ // Appending to an existing file and we need to reallocate, or source data did not come as a typed array.
+ MEMFS.expandFileStorage(node, position + length);
+ if (node.contents.subarray && buffer.subarray) {
+ // Use typed array write which is available.
+ node.contents.set(buffer.subarray(offset, offset + length), position);
+ } else {
+ for (var i = 0; i < length; i++) {
+ node.contents[position + i] = buffer[offset + i]; // Or fall back to manual write if not.
+ }
+ }
+ 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;
+ },
+ allocate(stream, offset, length) {
+ MEMFS.expandFileStorage(stream.node, offset + length);
+ stream.node.usedBytes = Math.max(stream.node.usedBytes, offset + length);
+ },
+ 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;
+ // Only make a new copy when MAP_PRIVATE is specified.
+ if (!(flags & 2) && contents.buffer === HEAP8.buffer) {
+ // We can't emulate MAP_SHARED when the file is not backed by the
+ // buffer we're mapping to (e.g. the HEAP buffer).
+ allocated = false;
+ ptr = contents.byteOffset;
+ } else {
+ // Try to avoid unnecessary slices.
+ if (position > 0 || position + length < contents.length) {
+ if (contents.subarray) {
+ contents = contents.subarray(position, position + length);
+ } else {
+ contents = Array.prototype.slice.call(
+ contents,
+ position,
+ position + length
+ );
+ }
+ }
+ allocated = true;
+ ptr = mmapAlloc(length);
+ if (!ptr) {
+ throw new FS.ErrnoError(48);
+ }
+ HEAP8.set(contents, ptr);
+ }
+ return { ptr, allocated };
+ },
+ msync(stream, buffer, offset, length, mmapFlags) {
+ MEMFS.stream_ops.write(stream, buffer, 0, length, offset, false);
+ // should we check if bytesWritten and length are the same?
+ return 0;
+ }
+ }
+};
+
+/** @param {boolean=} noRunDep */
+var asyncLoad = (url, onload, onerror, noRunDep) => {
+ var dep = !noRunDep ? getUniqueRunDependency(`al ${url}`) : '';
+ readAsync(
+ url,
+ (arrayBuffer) => {
+ assert(
+ arrayBuffer,
+ `Loading data file "${url}" failed (no arrayBuffer).`
+ );
+ onload(new Uint8Array(arrayBuffer));
+ if (dep) removeRunDependency(dep);
+ },
+ (event) => {
+ if (onerror) {
+ onerror();
+ } else {
+ throw `Loading data file "${url}" failed.`;
+ }
+ }
+ );
+ if (dep) addRunDependency(dep);
+};
+
+var FS_createDataFile = (parent, name, fileData, canRead, canWrite, canOwn) => {
+ FS.createDataFile(parent, name, fileData, canRead, canWrite, canOwn);
+};
+
+var preloadPlugins = Module['preloadPlugins'] || [];
+var FS_handledByPreloadPlugin = (byteArray, fullname, finish, onerror) => {
+ // Ensure plugins are ready.
+ 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
+) => {
+ // TODO we should allow people to just pass in a complete filename instead
+ // of parent and name being that we just join them anyways
+ var fullname = name ? PATH_FS.resolve(PATH.join2(parent, name)) : parent;
+ var dep = getUniqueRunDependency(`cp ${fullname}`); // might have several active requests for the same fullname
+ function processData(byteArray) {
+ function finish(byteArray) {
+ preFinish?.();
+ if (!dontCreateFile) {
+ FS_createDataFile(parent, name, byteArray, canRead, canWrite, canOwn);
+ }
+ onload?.();
+ removeRunDependency(dep);
+ }
+ if (
+ FS_handledByPreloadPlugin(byteArray, fullname, finish, () => {
+ onerror?.();
+ removeRunDependency(dep);
+ })
+ ) {
+ return;
+ }
+ finish(byteArray);
+ }
+ addRunDependency(dep);
+ if (typeof url == 'string') {
+ asyncLoad(url, 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 ERRNO_MESSAGES = {
+ 0: 'Success',
+ 1: 'Arg list too long',
+ 2: 'Permission denied',
+ 3: 'Address already in use',
+ 4: 'Address not available',
+ 5: 'Address family not supported by protocol family',
+ 6: 'No more processes',
+ 7: 'Socket already connected',
+ 8: 'Bad file number',
+ 9: 'Trying to read unreadable message',
+ 10: 'Mount device busy',
+ 11: 'Operation canceled',
+ 12: 'No children',
+ 13: 'Connection aborted',
+ 14: 'Connection refused',
+ 15: 'Connection reset by peer',
+ 16: 'File locking deadlock error',
+ 17: 'Destination address required',
+ 18: 'Math arg out of domain of func',
+ 19: 'Quota exceeded',
+ 20: 'File exists',
+ 21: 'Bad address',
+ 22: 'File too large',
+ 23: 'Host is unreachable',
+ 24: 'Identifier removed',
+ 25: 'Illegal byte sequence',
+ 26: 'Connection already in progress',
+ 27: 'Interrupted system call',
+ 28: 'Invalid argument',
+ 29: 'I/O error',
+ 30: 'Socket is already connected',
+ 31: 'Is a directory',
+ 32: 'Too many symbolic links',
+ 33: 'Too many open files',
+ 34: 'Too many links',
+ 35: 'Message too long',
+ 36: 'Multihop attempted',
+ 37: 'File or path name too long',
+ 38: 'Network interface is not configured',
+ 39: 'Connection reset by network',
+ 40: 'Network is unreachable',
+ 41: 'Too many open files in system',
+ 42: 'No buffer space available',
+ 43: 'No such device',
+ 44: 'No such file or directory',
+ 45: 'Exec format error',
+ 46: 'No record locks available',
+ 47: 'The link has been severed',
+ 48: 'Not enough core',
+ 49: 'No message of desired type',
+ 50: 'Protocol not available',
+ 51: 'No space left on device',
+ 52: 'Function not implemented',
+ 53: 'Socket is not connected',
+ 54: 'Not a directory',
+ 55: 'Directory not empty',
+ 56: 'State not recoverable',
+ 57: 'Socket operation on non-socket',
+ 59: 'Not a typewriter',
+ 60: 'No such device or address',
+ 61: 'Value too large for defined data type',
+ 62: 'Previous owner died',
+ 63: 'Not super-user',
+ 64: 'Broken pipe',
+ 65: 'Protocol error',
+ 66: 'Unknown protocol',
+ 67: 'Protocol wrong type for socket',
+ 68: 'Math result not representable',
+ 69: 'Read only file system',
+ 70: 'Illegal seek',
+ 71: 'No such process',
+ 72: 'Stale file handle',
+ 73: 'Connection timed out',
+ 74: 'Text file busy',
+ 75: 'Cross-device link',
+ 100: 'Device not a stream',
+ 101: 'Bad font file fmt',
+ 102: 'Invalid slot',
+ 103: 'Invalid request code',
+ 104: 'No anode',
+ 105: 'Block device required',
+ 106: 'Channel number out of range',
+ 107: 'Level 3 halted',
+ 108: 'Level 3 reset',
+ 109: 'Link number out of range',
+ 110: 'Protocol driver not attached',
+ 111: 'No CSI structure available',
+ 112: 'Level 2 halted',
+ 113: 'Invalid exchange',
+ 114: 'Invalid request descriptor',
+ 115: 'Exchange full',
+ 116: 'No data (for no delay io)',
+ 117: 'Timer expired',
+ 118: 'Out of streams resources',
+ 119: 'Machine is not on the network',
+ 120: 'Package not installed',
+ 121: 'The object is remote',
+ 122: 'Advertise error',
+ 123: 'Srmount error',
+ 124: 'Communication error on send',
+ 125: 'Cross mount point (not really error)',
+ 126: 'Given log. name not unique',
+ 127: 'f.d. invalid for this operation',
+ 128: 'Remote address changed',
+ 129: 'Can access a needed shared lib',
+ 130: 'Accessing a corrupted shared lib',
+ 131: '.lib section in a.out corrupted',
+ 132: 'Attempting to link in too many libs',
+ 133: 'Attempting to exec a shared library',
+ 135: 'Streams pipe error',
+ 136: 'Too many users',
+ 137: 'Socket type not supported',
+ 138: 'Not supported',
+ 139: 'Protocol family not supported',
+ 140: "Can't send after socket shutdown",
+ 141: 'Too many references',
+ 142: 'Host is down',
+ 148: 'No medium (in tape drive)',
+ 156: 'Level 2 not synchronized'
+};
+
+var ERRNO_CODES = {
+ EPERM: 63,
+ ENOENT: 44,
+ ESRCH: 71,
+ EINTR: 27,
+ EIO: 29,
+ ENXIO: 60,
+ E2BIG: 1,
+ ENOEXEC: 45,
+ EBADF: 8,
+ ECHILD: 12,
+ EAGAIN: 6,
+ EWOULDBLOCK: 6,
+ ENOMEM: 48,
+ EACCES: 2,
+ EFAULT: 21,
+ ENOTBLK: 105,
+ EBUSY: 10,
+ EEXIST: 20,
+ EXDEV: 75,
+ ENODEV: 43,
+ ENOTDIR: 54,
+ EISDIR: 31,
+ EINVAL: 28,
+ ENFILE: 41,
+ EMFILE: 33,
+ ENOTTY: 59,
+ ETXTBSY: 74,
+ EFBIG: 22,
+ ENOSPC: 51,
+ ESPIPE: 70,
+ EROFS: 69,
+ EMLINK: 34,
+ EPIPE: 64,
+ EDOM: 18,
+ ERANGE: 68,
+ ENOMSG: 49,
+ EIDRM: 24,
+ ECHRNG: 106,
+ EL2NSYNC: 156,
+ EL3HLT: 107,
+ EL3RST: 108,
+ ELNRNG: 109,
+ EUNATCH: 110,
+ ENOCSI: 111,
+ EL2HLT: 112,
+ EDEADLK: 16,
+ ENOLCK: 46,
+ EBADE: 113,
+ EBADR: 114,
+ EXFULL: 115,
+ ENOANO: 104,
+ EBADRQC: 103,
+ EBADSLT: 102,
+ EDEADLOCK: 16,
+ EBFONT: 101,
+ ENOSTR: 100,
+ ENODATA: 116,
+ ETIME: 117,
+ ENOSR: 118,
+ ENONET: 119,
+ ENOPKG: 120,
+ EREMOTE: 121,
+ ENOLINK: 47,
+ EADV: 122,
+ ESRMNT: 123,
+ ECOMM: 124,
+ EPROTO: 65,
+ EMULTIHOP: 36,
+ EDOTDOT: 125,
+ EBADMSG: 9,
+ ENOTUNIQ: 126,
+ EBADFD: 127,
+ EREMCHG: 128,
+ ELIBACC: 129,
+ ELIBBAD: 130,
+ ELIBSCN: 131,
+ ELIBMAX: 132,
+ ELIBEXEC: 133,
+ ENOSYS: 52,
+ ENOTEMPTY: 55,
+ ENAMETOOLONG: 37,
+ ELOOP: 32,
+ EOPNOTSUPP: 138,
+ EPFNOSUPPORT: 139,
+ ECONNRESET: 15,
+ ENOBUFS: 42,
+ EAFNOSUPPORT: 5,
+ EPROTOTYPE: 67,
+ ENOTSOCK: 57,
+ ENOPROTOOPT: 50,
+ ESHUTDOWN: 140,
+ ECONNREFUSED: 14,
+ EADDRINUSE: 3,
+ ECONNABORTED: 13,
+ ENETUNREACH: 40,
+ ENETDOWN: 38,
+ ETIMEDOUT: 73,
+ EHOSTDOWN: 142,
+ EHOSTUNREACH: 23,
+ EINPROGRESS: 26,
+ EALREADY: 7,
+ EDESTADDRREQ: 17,
+ EMSGSIZE: 35,
+ EPROTONOSUPPORT: 66,
+ ESOCKTNOSUPPORT: 137,
+ EADDRNOTAVAIL: 4,
+ ENETRESET: 39,
+ EISCONN: 30,
+ ENOTCONN: 53,
+ ETOOMANYREFS: 141,
+ EUSERS: 136,
+ EDQUOT: 19,
+ ESTALE: 72,
+ ENOTSUP: 138,
+ ENOMEDIUM: 148,
+ EILSEQ: 25,
+ EOVERFLOW: 61,
+ ECANCELED: 11,
+ ENOTRECOVERABLE: 56,
+ EOWNERDEAD: 62,
+ ESTRPIPE: 135
+};
+var FS = {
+ root: null,
+ mounts: [],
+ devices: {},
+ streams: [],
+ nextInode: 1,
+ nameTable: null,
+ currentPath: '/',
+ initialized: false,
+ ignorePermissions: true,
+ ErrnoError: class extends Error {
+ // We set the `name` property to be able to identify `FS.ErrnoError`
+ // - the `name` is a standard ECMA-262 property of error objects. Kind of good to have it anyway.
+ // - when using PROXYFS, an error can come from an underlying FS
+ // as different FS objects have their own FS.ErrnoError each,
+ // the test `err instanceof FS.ErrnoError` won't detect an error coming from another filesystem, causing bugs.
+ // we'll use the reliable test `err.name == "ErrnoError"` instead
+ constructor(errno) {
+ super(ERRNO_MESSAGES[errno]);
+ // TODO(sbc): Use the inline member declaration syntax once we
+ // support it in acorn and closure.
+ this.name = 'ErrnoError';
+ this.errno = errno;
+ for (var key in ERRNO_CODES) {
+ if (ERRNO_CODES[key] === errno) {
+ this.code = key;
+ break;
+ }
+ }
+ }
+ },
+ genericErrors: {},
+ filesystems: null,
+ syncFSRequests: 0,
+ FSStream: class {
+ constructor() {
+ // TODO(https://github.com/emscripten-core/emscripten/issues/21414):
+ // Use inline field declarations.
+ this.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 {
+ constructor(parent, name, mode, rdev) {
+ if (!parent) {
+ parent = this; // root node sets parent to itself
+ }
+ this.parent = parent;
+ this.mount = parent.mount;
+ this.mounted = null;
+ this.id = FS.nextInode++;
+ this.name = name;
+ this.mode = mode;
+ this.node_ops = {};
+ this.stream_ops = {};
+ this.rdev = rdev;
+ this.readMode = 292 /*292*/ | 73 /*73*/;
+ this.writeMode = 146 /*146*/;
+ }
+ 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 = {}) {
+ path = PATH_FS.resolve(path);
+
+ if (!path) return { path: '', node: null };
+
+ var defaults = {
+ follow_mount: true,
+ recurse_count: 0
+ };
+ opts = Object.assign(defaults, opts);
+
+ if (opts.recurse_count > 8) {
+ // max recursive lookup of 8
+ throw new FS.ErrnoError(32);
+ }
+
+ // split the absolute path
+ var parts = path.split('/').filter((p) => !!p);
+
+ // start at the root
+ 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) {
+ // stop resolving
+ break;
+ }
+
+ current = FS.lookupNode(current, parts[i]);
+ current_path = PATH.join2(current_path, parts[i]);
+
+ // jump to the mount's root node if this is a mountpoint
+ if (FS.isMountpoint(current)) {
+ if (!islast || (islast && opts.follow_mount)) {
+ current = current.mounted.root;
+ }
+ }
+
+ // by default, lookupPath will not follow a symlink if it is the final path component.
+ // setting opts.follow = true will override this behavior.
+ if (!islast || opts.follow) {
+ var count = 0;
+ while (FS.isLink(current.mode)) {
+ var link = FS.readlink(current_path);
+ current_path = PATH_FS.resolve(PATH.dirname(current_path), link);
+
+ var lookup = FS.lookupPath(current_path, {
+ recurse_count: opts.recurse_count + 1
+ });
+ current = lookup.node;
+
+ if (count++ > 40) {
+ // limit max consecutive symlinks to 40 (SYMLOOP_MAX).
+ throw new FS.ErrnoError(32);
+ }
+ }
+ }
+ }
+
+ return { path: current_path, node: current };
+ },
+ getPath(node) {
+ var path;
+ while (true) {
+ if (FS.isRoot(node)) {
+ var mount = node.mount.mountpoint;
+ if (!path) return mount;
+ return mount[mount.length - 1] !== '/'
+ ? `${mount}/${path}`
+ : mount + path;
+ }
+ path = path ? `${node.name}/${path}` : node.name;
+ node = node.parent;
+ }
+ },
+ hashName(parentid, name) {
+ var hash = 0;
+
+ for (var i = 0; i < name.length; i++) {
+ hash = ((hash << 5) - hash + name.charCodeAt(i)) | 0;
+ }
+ return ((parentid + hash) >>> 0) % FS.nameTable.length;
+ },
+ hashAddNode(node) {
+ var hash = FS.hashName(node.parent.id, node.name);
+ node.name_next = FS.nameTable[hash];
+ FS.nameTable[hash] = node;
+ },
+ hashRemoveNode(node) {
+ var hash = FS.hashName(node.parent.id, node.name);
+ if (FS.nameTable[hash] === node) {
+ FS.nameTable[hash] = node.name_next;
+ } else {
+ var current = FS.nameTable[hash];
+ while (current) {
+ if (current.name_next === node) {
+ current.name_next = node.name_next;
+ break;
+ }
+ current = current.name_next;
+ }
+ }
+ },
+ lookupNode(parent, name) {
+ var errCode = FS.mayLookup(parent);
+ if (errCode) {
+ throw new FS.ErrnoError(errCode);
+ }
+ 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;
+ }
+ }
+ // if we failed to find it in the cache, call into the VFS
+ return FS.lookup(parent, name);
+ },
+ createNode(parent, name, mode, rdev) {
+ assert(typeof parent == 'object');
+ 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;
+ }
+ // return 0 if any user, group or owner bits are set.
+ 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) {
+ 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' || // opening for write
+ flags & 512
+ ) {
+ // TODO: check for O_SEARCH? (== search for dir only)
+ return 31;
+ }
+ }
+ return FS.nodePermissions(node, FS.flagsToPermissionString(flags));
+ },
+ MAX_OPEN_FDS: 4096,
+ nextfd() {
+ for (var fd = 0; fd <= FS.MAX_OPEN_FDS; fd++) {
+ if (!FS.streams[fd]) {
+ return fd;
+ }
+ }
+ throw new FS.ErrnoError(33);
+ },
+ getStreamChecked(fd) {
+ var stream = FS.getStream(fd);
+ if (!stream) {
+ throw new FS.ErrnoError(8);
+ }
+ return stream;
+ },
+ getStream: (fd) => FS.streams[fd],
+ createStream(stream, fd = -1) {
+ // clone it, so we can return an instance of FSStream
+ stream = Object.assign(new FS.FSStream(), stream);
+ if (fd == -1) {
+ fd = FS.nextfd();
+ }
+ stream.fd = fd;
+ FS.streams[fd] = stream;
+ return stream;
+ },
+ closeStream(fd) {
+ FS.streams[fd] = null;
+ },
+ dupStream(origStream, fd = -1) {
+ var stream = FS.createStream(origStream, fd);
+ stream.stream_ops?.dup?.(stream);
+ return stream;
+ },
+ chrdev_stream_ops: {
+ open(stream) {
+ var device = FS.getDevice(stream.node.rdev);
+ // override node's stream ops with the device's
+ stream.stream_ops = device.stream_ops;
+ // forward the open call
+ stream.stream_ops.open?.(stream);
+ },
+ llseek() {
+ throw new FS.ErrnoError(70);
+ }
+ },
+ major: (dev) => dev >> 8,
+ minor: (dev) => dev & 0xff,
+ 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) {
+ assert(FS.syncFSRequests > 0);
+ 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);
+ }
+ }
+
+ // sync all mounts
+ mounts.forEach((mount) => {
+ if (!mount.type.syncfs) {
+ return done(null);
+ }
+ mount.type.syncfs(mount, populate, done);
+ });
+ },
+ mount(type, opts, mountpoint) {
+ if (typeof type == 'string') {
+ // The filesystem was not included, and instead we have an error
+ // message stored in the variable.
+ throw type;
+ }
+ 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; // use the absolute 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: []
+ };
+
+ // create a root node for the fs
+ var mountRoot = type.mount(mount);
+ mountRoot.mount = mount;
+ mount.root = mountRoot;
+
+ if (root) {
+ FS.root = mountRoot;
+ } else if (node) {
+ // set as a mountpoint
+ node.mounted = mount;
+
+ // add the new mount to the current mount's children
+ 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);
+ }
+
+ // destroy the nodes for this mount, and all its child mounts
+ 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;
+ }
+ });
+
+ // no longer a mountpoint
+ node.mounted = null;
+
+ // remove this mount from the child mounts
+ var idx = node.mount.mounts.indexOf(mount);
+ assert(idx !== -1);
+ node.mount.mounts.splice(idx, 1);
+ },
+ lookup(parent, name) {
+ return parent.node_ops.lookup(parent, name);
+ },
+ mknod(path, mode, dev) {
+ var lookup = FS.lookupPath(path, { parent: true });
+ var parent = lookup.node;
+ var name = PATH.basename(path);
+ if (!name || name === '.' || name === '..') {
+ throw new FS.ErrnoError(28);
+ }
+ var errCode = FS.mayCreate(parent, name);
+ if (errCode) {
+ throw new FS.ErrnoError(errCode);
+ }
+ if (!parent.node_ops.mknod) {
+ throw new FS.ErrnoError(63);
+ }
+ return parent.node_ops.mknod(parent, name, mode, dev);
+ },
+ create(path, mode) {
+ mode = mode !== undefined ? mode : 438 /* 0666 */;
+ mode &= 4095;
+ mode |= 32768;
+ return FS.mknod(path, mode, 0);
+ },
+ mkdir(path, mode) {
+ mode = mode !== undefined ? mode : 511 /* 0777 */;
+ mode &= 511 | 512;
+ mode |= 16384;
+ return FS.mknod(path, mode, 0);
+ },
+ mkdirTree(path, mode) {
+ var dirs = path.split('/');
+ var d = '';
+ for (var i = 0; i < dirs.length; ++i) {
+ if (!dirs[i]) continue;
+ d += '/' + dirs[i];
+ try {
+ FS.mkdir(d, mode);
+ } catch (e) {
+ if (e.errno != 20) throw e;
+ }
+ }
+ },
+ mkdev(path, mode, dev) {
+ if (typeof dev == 'undefined') {
+ dev = mode;
+ mode = 438 /* 0666 */;
+ }
+ 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);
+ // parents must exist
+ var lookup, old_dir, new_dir;
+
+ // let the errors from non existent directories percolate up
+ 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);
+ // need to be part of the same mount
+ if (old_dir.mount !== new_dir.mount) {
+ throw new FS.ErrnoError(75);
+ }
+ // source must exist
+ var old_node = FS.lookupNode(old_dir, old_name);
+ // old path should not be an ancestor of the new path
+ var relative = PATH_FS.relative(old_path, new_dirname);
+ if (relative.charAt(0) !== '.') {
+ throw new FS.ErrnoError(28);
+ }
+ // new path should not be an ancestor of the old path
+ relative = PATH_FS.relative(new_path, old_dirname);
+ if (relative.charAt(0) !== '.') {
+ throw new FS.ErrnoError(55);
+ }
+ // see if the new path already exists
+ var new_node;
+ try {
+ new_node = FS.lookupNode(new_dir, new_name);
+ } catch (e) {
+ // not fatal
+ }
+ // early out if nothing needs to change
+ if (old_node === new_node) {
+ return;
+ }
+ // we'll need to delete the old entry
+ var isdir = FS.isDir(old_node.mode);
+ var errCode = FS.mayDelete(old_dir, old_name, isdir);
+ if (errCode) {
+ throw new FS.ErrnoError(errCode);
+ }
+ // need delete permissions if we'll be overwriting.
+ // need create permissions if new doesn't already exist.
+ 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 we are going to change the parent, check write permissions
+ if (new_dir !== old_dir) {
+ errCode = FS.nodePermissions(old_dir, 'w');
+ if (errCode) {
+ throw new FS.ErrnoError(errCode);
+ }
+ }
+ // remove the node from the lookup hash
+ FS.hashRemoveNode(old_node);
+ // do the underlying fs rename
+ try {
+ old_dir.node_ops.rename(old_node, new_dir, new_name);
+ } catch (e) {
+ throw e;
+ } finally {
+ // add the node back to the hash (in case node_ops.rename
+ // changed its name)
+ FS.hashAddNode(old_node);
+ }
+ },
+ rmdir(path) {
+ var lookup = FS.lookupPath(path, { parent: true });
+ var parent = lookup.node;
+ var name = PATH.basename(path);
+ var node = FS.lookupNode(parent, name);
+ var errCode = FS.mayDelete(parent, name, true);
+ if (errCode) {
+ throw new FS.ErrnoError(errCode);
+ }
+ if (!parent.node_ops.rmdir) {
+ throw new FS.ErrnoError(63);
+ }
+ if (FS.isMountpoint(node)) {
+ throw new FS.ErrnoError(10);
+ }
+ parent.node_ops.rmdir(parent, name);
+ FS.destroyNode(node);
+ },
+ readdir(path) {
+ var lookup = FS.lookupPath(path, { follow: true });
+ var node = lookup.node;
+ if (!node.node_ops.readdir) {
+ throw new FS.ErrnoError(54);
+ }
+ return node.node_ops.readdir(node);
+ },
+ unlink(path) {
+ var lookup = FS.lookupPath(path, { parent: true });
+ var parent = lookup.node;
+ if (!parent) {
+ throw new FS.ErrnoError(44);
+ }
+ var name = PATH.basename(path);
+ var node = FS.lookupNode(parent, name);
+ var errCode = FS.mayDelete(parent, name, false);
+ if (errCode) {
+ // According to POSIX, we should map EISDIR to EPERM, but
+ // we instead do what Linux does (and we must, as we use
+ // the musl linux libc).
+ throw new FS.ErrnoError(errCode);
+ }
+ if (!parent.node_ops.unlink) {
+ throw new FS.ErrnoError(63);
+ }
+ if (FS.isMountpoint(node)) {
+ throw new FS.ErrnoError(10);
+ }
+ parent.node_ops.unlink(parent, name);
+ FS.destroyNode(node);
+ },
+ readlink(path) {
+ var lookup = FS.lookupPath(path);
+ var link = lookup.node;
+ if (!link) {
+ throw new FS.ErrnoError(44);
+ }
+ if (!link.node_ops.readlink) {
+ throw new FS.ErrnoError(28);
+ }
+ return PATH_FS.resolve(
+ FS.getPath(link.parent),
+ link.node_ops.readlink(link)
+ );
+ },
+ stat(path, dontFollow) {
+ var lookup = FS.lookupPath(path, { follow: !dontFollow });
+ var node = lookup.node;
+ if (!node) {
+ throw new FS.ErrnoError(44);
+ }
+ if (!node.node_ops.getattr) {
+ throw new FS.ErrnoError(63);
+ }
+ return node.node_ops.getattr(node);
+ },
+ lstat(path) {
+ return FS.stat(path, true);
+ },
+ chmod(path, mode, dontFollow) {
+ var node;
+ if (typeof path == 'string') {
+ var lookup = FS.lookupPath(path, { follow: !dontFollow });
+ node = lookup.node;
+ } else {
+ node = path;
+ }
+ if (!node.node_ops.setattr) {
+ throw new FS.ErrnoError(63);
+ }
+ node.node_ops.setattr(node, {
+ mode: (mode & 4095) | (node.mode & ~4095),
+ timestamp: Date.now()
+ });
+ },
+ lchmod(path, mode) {
+ FS.chmod(path, mode, true);
+ },
+ fchmod(fd, mode) {
+ var stream = FS.getStreamChecked(fd);
+ FS.chmod(stream.node, mode);
+ },
+ chown(path, uid, gid, dontFollow) {
+ var node;
+ if (typeof path == 'string') {
+ var lookup = FS.lookupPath(path, { follow: !dontFollow });
+ node = lookup.node;
+ } else {
+ node = path;
+ }
+ if (!node.node_ops.setattr) {
+ throw new FS.ErrnoError(63);
+ }
+ node.node_ops.setattr(node, {
+ timestamp: Date.now()
+ // we ignore the uid / gid for now
+ });
+ },
+ lchown(path, uid, gid) {
+ FS.chown(path, uid, gid, true);
+ },
+ fchown(fd, uid, gid) {
+ var stream = FS.getStreamChecked(fd);
+ FS.chown(stream.node, uid, gid);
+ },
+ truncate(path, len) {
+ if (len < 0) {
+ throw new FS.ErrnoError(28);
+ }
+ var node;
+ if (typeof path == 'string') {
+ var lookup = FS.lookupPath(path, { follow: true });
+ node = lookup.node;
+ } else {
+ node = path;
+ }
+ if (!node.node_ops.setattr) {
+ throw new FS.ErrnoError(63);
+ }
+ if (FS.isDir(node.mode)) {
+ throw new FS.ErrnoError(31);
+ }
+ if (!FS.isFile(node.mode)) {
+ throw new FS.ErrnoError(28);
+ }
+ var errCode = FS.nodePermissions(node, 'w');
+ if (errCode) {
+ throw new FS.ErrnoError(errCode);
+ }
+ node.node_ops.setattr(node, {
+ size: len,
+ timestamp: Date.now()
+ });
+ },
+ ftruncate(fd, len) {
+ var stream = FS.getStreamChecked(fd);
+ if ((stream.flags & 2097155) === 0) {
+ throw new FS.ErrnoError(28);
+ }
+ FS.truncate(stream.node, len);
+ },
+ utime(path, atime, mtime) {
+ var lookup = FS.lookupPath(path, { follow: true });
+ var node = lookup.node;
+ node.node_ops.setattr(node, {
+ timestamp: Math.max(atime, mtime)
+ });
+ },
+ open(path, flags, mode) {
+ if (path === '') {
+ throw new FS.ErrnoError(44);
+ }
+ flags = typeof flags == 'string' ? FS_modeStringToFlags(flags) : flags;
+ mode = typeof mode == 'undefined' ? 438 /* 0666 */ : mode;
+ if (flags & 64) {
+ mode = (mode & 4095) | 32768;
+ } else {
+ mode = 0;
+ }
+ var node;
+ if (typeof path == 'object') {
+ node = path;
+ } else {
+ path = PATH.normalize(path);
+ try {
+ var lookup = FS.lookupPath(path, {
+ follow: !(flags & 131072)
+ });
+ node = lookup.node;
+ } catch (e) {
+ // ignore
+ }
+ }
+ // perhaps we need to create the node
+ var created = false;
+ if (flags & 64) {
+ if (node) {
+ // if O_CREAT and O_EXCL are set, error out if the node already exists
+ if (flags & 128) {
+ throw new FS.ErrnoError(20);
+ }
+ } else {
+ // node doesn't exist, try to create it
+ node = FS.mknod(path, mode, 0);
+ created = true;
+ }
+ }
+ if (!node) {
+ throw new FS.ErrnoError(44);
+ }
+ // can't truncate a device
+ if (FS.isChrdev(node.mode)) {
+ flags &= ~512;
+ }
+ // if asked only for a directory, then this must be one
+ if (flags & 65536 && !FS.isDir(node.mode)) {
+ throw new FS.ErrnoError(54);
+ }
+ // check permissions, if this is not a file we just created now (it is ok to
+ // create and write to a file with read-only permissions; it is read-only
+ // for later use)
+ if (!created) {
+ var errCode = FS.mayOpen(node, flags);
+ if (errCode) {
+ throw new FS.ErrnoError(errCode);
+ }
+ }
+ // do truncation if necessary
+ if (flags & 512 && !created) {
+ FS.truncate(node, 0);
+ }
+ // we've already handled these, don't pass down to the underlying vfs
+ flags &= ~(128 | 512 | 131072);
+
+ // register the stream with the filesystem
+ var stream = FS.createStream({
+ node,
+ path: FS.getPath(node), // we want the absolute path to the node
+ flags,
+ seekable: true,
+ position: 0,
+ stream_ops: node.stream_ops,
+ // used by the file family libc calls (fopen, fwrite, ferror, etc.)
+ ungotten: [],
+ error: false
+ });
+ // call the new stream's open function
+ if (stream.stream_ops.open) {
+ stream.stream_ops.open(stream);
+ }
+ if (Module['logReadFiles'] && !(flags & 1)) {
+ if (!FS.readFiles) FS.readFiles = {};
+ if (!(path in FS.readFiles)) {
+ FS.readFiles[path] = 1;
+ }
+ }
+ return stream;
+ },
+ close(stream) {
+ if (FS.isClosed(stream)) {
+ throw new FS.ErrnoError(8);
+ }
+ if (stream.getdents) stream.getdents = null; // free readdir state
+ 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) {
+ assert(offset >= 0);
+ 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) {
+ assert(offset >= 0);
+ 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) {
+ // seek to the end before writing in append mode
+ FS.llseek(stream, 0, 2);
+ }
+ var seeking = typeof position != 'undefined';
+ if (!seeking) {
+ position = stream.position;
+ } else if (!stream.seekable) {
+ throw new FS.ErrnoError(70);
+ }
+ var bytesWritten = stream.stream_ops.write(
+ stream,
+ buffer,
+ offset,
+ length,
+ position,
+ canOwn
+ );
+ if (!seeking) stream.position += bytesWritten;
+ return bytesWritten;
+ },
+ allocate(stream, offset, length) {
+ if (FS.isClosed(stream)) {
+ throw new FS.ErrnoError(8);
+ }
+ if (offset < 0 || length <= 0) {
+ throw new FS.ErrnoError(28);
+ }
+ if ((stream.flags & 2097155) === 0) {
+ throw new FS.ErrnoError(8);
+ }
+ if (!FS.isFile(stream.node.mode) && !FS.isDir(stream.node.mode)) {
+ throw new FS.ErrnoError(43);
+ }
+ if (!stream.stream_ops.allocate) {
+ throw new FS.ErrnoError(138);
+ }
+ stream.stream_ops.allocate(stream, offset, length);
+ },
+ mmap(stream, length, position, prot, flags) {
+ // User requests writing to file (prot & PROT_WRITE != 0).
+ // Checking if we have permissions to write to the file unless
+ // MAP_PRIVATE flag is set. According to POSIX spec it is possible
+ // to write to file opened in read-only mode with MAP_PRIVATE flag,
+ // as all modifications will be visible only in the memory of
+ // the current process.
+ if (
+ (prot & 2) !== 0 &&
+ (flags & 2) === 0 &&
+ (stream.flags & 2097155) !== 2
+ ) {
+ throw new FS.ErrnoError(2);
+ }
+ if ((stream.flags & 2097155) === 1) {
+ throw new FS.ErrnoError(2);
+ }
+ if (!stream.stream_ops.mmap) {
+ throw new FS.ErrnoError(43);
+ }
+ return stream.stream_ops.mmap(stream, length, position, prot, flags);
+ },
+ msync(stream, buffer, offset, length, mmapFlags) {
+ assert(offset >= 0);
+ 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 ret;
+ var stream = FS.open(path, opts.flags);
+ var stat = FS.stat(path);
+ var length = stat.size;
+ var buf = new Uint8Array(length);
+ FS.read(stream, buf, 0, length, 0);
+ if (opts.encoding === 'utf8') {
+ ret = UTF8ArrayToString(buf, 0);
+ } else if (opts.encoding === 'binary') {
+ ret = buf;
+ }
+ FS.close(stream);
+ return ret;
+ },
+ writeFile(path, data, opts = {}) {
+ opts.flags = opts.flags || 577;
+ var stream = FS.open(path, opts.flags, opts.mode);
+ if (typeof data == 'string') {
+ var buf = new Uint8Array(lengthBytesUTF8(data) + 1);
+ var actualNumBytes = stringToUTF8Array(data, buf, 0, buf.length);
+ FS.write(stream, buf, 0, actualNumBytes, undefined, opts.canOwn);
+ } else if (ArrayBuffer.isView(data)) {
+ FS.write(stream, data, 0, data.byteLength, undefined, opts.canOwn);
+ } else {
+ throw new Error('Unsupported data type');
+ }
+ FS.close(stream);
+ },
+ cwd: () => FS.currentPath,
+ chdir(path) {
+ var lookup = FS.lookupPath(path, { follow: true });
+ if (lookup.node === null) {
+ throw new FS.ErrnoError(44);
+ }
+ if (!FS.isDir(lookup.node.mode)) {
+ throw new FS.ErrnoError(54);
+ }
+ var errCode = FS.nodePermissions(lookup.node, 'x');
+ if (errCode) {
+ throw new FS.ErrnoError(errCode);
+ }
+ FS.currentPath = lookup.path;
+ },
+ createDefaultDirectories() {
+ FS.mkdir('/tmp');
+ FS.mkdir('/home');
+ FS.mkdir('/home/web_user');
+ },
+ createDefaultDevices() {
+ // create /dev
+ FS.mkdir('/dev');
+ // setup /dev/null
+ FS.registerDevice(FS.makedev(1, 3), {
+ read: () => 0,
+ write: (stream, buffer, offset, length, pos) => length
+ });
+ FS.mkdev('/dev/null', FS.makedev(1, 3));
+ // setup /dev/tty and /dev/tty1
+ // stderr needs to print output using err() rather than out()
+ // so we register a second tty just for it.
+ 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));
+ // setup /dev/[u]random
+ // use a buffer to avoid overhead of individual crypto calls per byte
+ var randomBuffer = new Uint8Array(1024),
+ randomLeft = 0;
+ var randomByte = () => {
+ if (randomLeft === 0) {
+ randomLeft = randomFill(randomBuffer).byteLength;
+ }
+ return randomBuffer[--randomLeft];
+ };
+ FS.createDevice('/dev', 'random', randomByte);
+ FS.createDevice('/dev', 'urandom', randomByte);
+ // we're not going to emulate the actual shm device,
+ // just create the tmp dirs that reside in it commonly
+ FS.mkdir('/dev/shm');
+ FS.mkdir('/dev/shm/tmp');
+ },
+ createSpecialDirectories() {
+ // create /proc/self/fd which allows /proc/self/fd/6 => readlink gives the
+ // name of the stream for fd 6 (see test_unistd_ttyname)
+ FS.mkdir('/proc');
+ var proc_self = FS.mkdir('/proc/self');
+ FS.mkdir('/proc/self/fd');
+ FS.mount(
+ {
+ mount() {
+ var node = FS.createNode(proc_self, 'fd', 16384 | 511 /* 0777 */, 73);
+ 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 }
+ };
+ ret.parent = ret; // make it look like a simple root node
+ return ret;
+ }
+ };
+ return node;
+ }
+ },
+ {},
+ '/proc/self/fd'
+ );
+ },
+ createStandardStreams() {
+ // TODO deprecate the old functionality of a single
+ // input / output callback and that utilizes FS.createDevice
+ // and instead require a unique set of stream ops
+
+ // by default, we symlink the standard streams to the
+ // default tty devices. however, if the standard streams
+ // have been overwritten we create a unique device for
+ // them instead.
+ if (Module['stdin']) {
+ FS.createDevice('/dev', 'stdin', Module['stdin']);
+ } else {
+ FS.symlink('/dev/tty', '/dev/stdin');
+ }
+ if (Module['stdout']) {
+ FS.createDevice('/dev', 'stdout', null, Module['stdout']);
+ } else {
+ FS.symlink('/dev/tty', '/dev/stdout');
+ }
+ if (Module['stderr']) {
+ FS.createDevice('/dev', 'stderr', null, Module['stderr']);
+ } else {
+ FS.symlink('/dev/tty1', '/dev/stderr');
+ }
+
+ // open default streams for the stdin, stdout and stderr devices
+ var stdin = FS.open('/dev/stdin', 0);
+ var stdout = FS.open('/dev/stdout', 1);
+ var stderr = FS.open('/dev/stderr', 1);
+ assert(stdin.fd === 0, `invalid handle for stdin (${stdin.fd})`);
+ assert(stdout.fd === 1, `invalid handle for stdout (${stdout.fd})`);
+ assert(stderr.fd === 2, `invalid handle for stderr (${stderr.fd})`);
+ },
+ staticInit() {
+ // Some errors may happen quite a bit, to avoid overhead we reuse them (and suffer a lack of stack info)
+ [44].forEach((code) => {
+ FS.genericErrors[code] = new FS.ErrnoError(code);
+ FS.genericErrors[code].stack = '';
+ });
+
+ FS.nameTable = new Array(4096);
+
+ FS.mount(MEMFS, {}, '/');
+
+ FS.createDefaultDirectories();
+ FS.createDefaultDevices();
+ FS.createSpecialDirectories();
+
+ FS.filesystems = {
+ MEMFS: MEMFS
+ };
+ },
+ init(input, output, error) {
+ assert(
+ !FS.init.initialized,
+ 'FS.init was previously called. If you want to initialize later with custom parameters, remove any earlier calls (note that one is automatically added to the generated code)'
+ );
+ FS.init.initialized = true;
+
+ // Allow Module.stdin etc. to provide defaults, if none explicitly passed to us here
+ Module['stdin'] = input || Module['stdin'];
+ Module['stdout'] = output || Module['stdout'];
+ Module['stderr'] = error || Module['stderr'];
+
+ FS.createStandardStreams();
+ },
+ quit() {
+ FS.init.initialized = false;
+ // force-flush all streams, so we get musl std streams printed out
+ _fflush(0);
+ // close all of our streams
+ for (var i = 0; i < FS.streams.length; i++) {
+ var stream = FS.streams[i];
+ if (!stream) {
+ continue;
+ }
+ FS.close(stream);
+ }
+ },
+ findObject(path, dontResolveLastLink) {
+ var ret = FS.analyzePath(path, dontResolveLastLink);
+ if (!ret.exists) {
+ return null;
+ }
+ return ret.object;
+ },
+ analyzePath(path, dontResolveLastLink) {
+ // operate from within the context of the symlink's target
+ 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) {
+ // ignore EEXIST
+ }
+ 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;
+ }
+ // make sure we can write to the file
+ 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);
+ if (!FS.createDevice.major) FS.createDevice.major = 64;
+ var dev = FS.makedev(FS.createDevice.major++, 0);
+ // Create a fake device that a set of stream ops to emulate
+ // the old behavior.
+ FS.registerDevice(dev, {
+ open(stream) {
+ stream.seekable = false;
+ },
+ close(stream) {
+ // flush any pending line data
+ if (output?.buffer?.length) {
+ output(10);
+ }
+ },
+ read(stream, buffer, offset, length, pos /* ignored */) {
+ var bytesRead = 0;
+ for (var i = 0; i < length; i++) {
+ var result;
+ try {
+ result = input();
+ } catch (e) {
+ throw new FS.ErrnoError(29);
+ }
+ if (result === undefined && bytesRead === 0) {
+ throw new FS.ErrnoError(6);
+ }
+ if (result === null || result === undefined) break;
+ bytesRead++;
+ buffer[offset + i] = result;
+ }
+ if (bytesRead) {
+ stream.node.timestamp = Date.now();
+ }
+ return bytesRead;
+ },
+ write(stream, buffer, offset, length, pos) {
+ for (var i = 0; i < length; i++) {
+ try {
+ output(buffer[offset + i]);
+ } catch (e) {
+ throw new FS.ErrnoError(29);
+ }
+ }
+ if (length) {
+ stream.node.timestamp = Date.now();
+ }
+ return i;
+ }
+ });
+ return FS.mkdev(path, mode, dev);
+ },
+ forceLoadFile(obj) {
+ if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true;
+ if (typeof XMLHttpRequest != 'undefined') {
+ throw new Error(
+ 'Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.'
+ );
+ } else if (read_) {
+ // Command-line.
+ try {
+ // WARNING: Can't read binary files in V8's d8 or tracemonkey's js, as
+ // read() will try to parse UTF8.
+ obj.contents = intArrayFromString(read_(obj.url), true);
+ obj.usedBytes = obj.contents.length;
+ } catch (e) {
+ throw new FS.ErrnoError(29);
+ }
+ } else {
+ throw new Error('Cannot load without read() or XMLHttpRequest.');
+ }
+ },
+ createLazyFile(parent, name, url, canRead, canWrite) {
+ // Lazy chunked Uint8Array (implements get and length from Uint8Array).
+ // Actual getting is abstracted away for eventual reuse.
+ class LazyUint8Array {
+ constructor() {
+ this.lengthKnown = false;
+ this.chunks = []; // Loaded chunks. Index is the chunk number
+ }
+ 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() {
+ // Find length
+ 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; // Chunk size in bytes
+
+ if (!hasByteServing) chunkSize = datalength;
+
+ // Function to get a range from the remote URL.
+ 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!'
+ );
+
+ // TODO: Use mozResponseArrayBuffer, responseStream, etc. if available.
+ var xhr = new XMLHttpRequest();
+ xhr.open('GET', url, false);
+ if (datalength !== chunkSize)
+ xhr.setRequestHeader('Range', 'bytes=' + from + '-' + to);
+
+ // Some hints to the browser that we want binary data.
+ 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(
+ /** @type{Array} */ (xhr.response || [])
+ );
+ }
+ return intArrayFromString(xhr.responseText || '', true);
+ };
+ var lazyArray = this;
+ lazyArray.setDataGetter((chunkNum) => {
+ var start = chunkNum * chunkSize;
+ var end = (chunkNum + 1) * chunkSize - 1; // including this byte
+ end = Math.min(end, datalength - 1); // if datalength-1 is selected, this is the last block
+ 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) {
+ // if the server uses gzip or doesn't supply the length, we have to download the whole file to get the (uncompressed) length
+ chunkSize = datalength = 1; // this will force getter(0)/doXHR do download the whole file
+ 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: url };
+ }
+
+ var node = FS.createFile(parent, name, properties, canRead, canWrite);
+ // This is a total hack, but I want to get this lazy file code out of the
+ // core of MEMFS. If we want to keep this lazy file concept I feel it should
+ // be its own thin LAZYFS proxying calls to MEMFS.
+ if (properties.contents) {
+ node.contents = properties.contents;
+ } else if (properties.url) {
+ node.contents = null;
+ node.url = properties.url;
+ }
+ // Add a function that defers querying the file size until it is asked the first time.
+ Object.defineProperties(node, {
+ usedBytes: {
+ get: function () {
+ return this.contents.length;
+ }
+ }
+ });
+ // override each stream op with one that tries to force load the lazy file first
+ 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);
+ assert(size >= 0);
+ if (contents.slice) {
+ // normal array
+ for (var i = 0; i < size; i++) {
+ buffer[offset + i] = contents[position + i];
+ }
+ } else {
+ for (var i = 0; i < size; i++) {
+ // LazyUint8Array from sync binary XHR
+ buffer[offset + i] = contents.get(position + i);
+ }
+ }
+ return size;
+ }
+ // use a custom read function
+ stream_ops.read = (stream, buffer, offset, length, position) => {
+ FS.forceLoadFile(node);
+ return writeChunks(stream, buffer, offset, length, position);
+ };
+ // use a custom mmap function
+ 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;
+ },
+ absolutePath() {
+ abort('FS.absolutePath has been removed; use PATH_FS.resolve instead');
+ },
+ createFolder() {
+ abort('FS.createFolder has been removed; use FS.mkdir instead');
+ },
+ createLink() {
+ abort('FS.createLink has been removed; use FS.symlink instead');
+ },
+ joinPath() {
+ abort('FS.joinPath has been removed; use PATH.join instead');
+ },
+ mmapAlloc() {
+ abort('FS.mmapAlloc has been replaced by the top level function mmapAlloc');
+ },
+ standardizePath() {
+ abort('FS.standardizePath has been removed; use PATH.normalize instead');
+ }
+};
+
+var SYSCALLS = {
+ DEFAULT_POLLMASK: 5,
+ calculateAt(dirfd, path, allowEmpty) {
+ if (PATH.isAbs(path)) {
+ return path;
+ }
+ // relative path
+ var dir;
+ if (dirfd === -100) {
+ dir = FS.cwd();
+ } else {
+ var dirstream = SYSCALLS.getStreamFromFD(dirfd);
+ dir = dirstream.path;
+ }
+ if (path.length == 0) {
+ if (!allowEmpty) {
+ throw new FS.ErrnoError(44);
+ }
+ return dir;
+ }
+ return PATH.join2(dir, path);
+ },
+ doStat(func, path, buf) {
+ var stat = func(path);
+ HEAP32[buf >> 2] = stat.dev;
+ HEAP32[(buf + 4) >> 2] = stat.mode;
+ HEAPU32[(buf + 8) >> 2] = stat.nlink;
+ HEAP32[(buf + 12) >> 2] = stat.uid;
+ HEAP32[(buf + 16) >> 2] = stat.gid;
+ HEAP32[(buf + 20) >> 2] = stat.rdev;
+ (tempI64 = [
+ stat.size >>> 0,
+ ((tempDouble = stat.size),
+ +Math.abs(tempDouble) >= 1.0
+ ? tempDouble > 0.0
+ ? +Math.floor(tempDouble / 4294967296.0) >>> 0
+ : ~~+Math.ceil(
+ (tempDouble - +(~~tempDouble >>> 0)) / 4294967296.0
+ ) >>> 0
+ : 0)
+ ]),
+ (HEAP32[(buf + 24) >> 2] = tempI64[0]),
+ (HEAP32[(buf + 28) >> 2] = tempI64[1]);
+ HEAP32[(buf + 32) >> 2] = 4096;
+ HEAP32[(buf + 36) >> 2] = stat.blocks;
+ var atime = stat.atime.getTime();
+ var mtime = stat.mtime.getTime();
+ var ctime = stat.ctime.getTime();
+ (tempI64 = [
+ Math.floor(atime / 1000) >>> 0,
+ ((tempDouble = Math.floor(atime / 1000)),
+ +Math.abs(tempDouble) >= 1.0
+ ? tempDouble > 0.0
+ ? +Math.floor(tempDouble / 4294967296.0) >>> 0
+ : ~~+Math.ceil(
+ (tempDouble - +(~~tempDouble >>> 0)) / 4294967296.0
+ ) >>> 0
+ : 0)
+ ]),
+ (HEAP32[(buf + 40) >> 2] = tempI64[0]),
+ (HEAP32[(buf + 44) >> 2] = tempI64[1]);
+ HEAPU32[(buf + 48) >> 2] = (atime % 1000) * 1000;
+ (tempI64 = [
+ Math.floor(mtime / 1000) >>> 0,
+ ((tempDouble = Math.floor(mtime / 1000)),
+ +Math.abs(tempDouble) >= 1.0
+ ? tempDouble > 0.0
+ ? +Math.floor(tempDouble / 4294967296.0) >>> 0
+ : ~~+Math.ceil(
+ (tempDouble - +(~~tempDouble >>> 0)) / 4294967296.0
+ ) >>> 0
+ : 0)
+ ]),
+ (HEAP32[(buf + 56) >> 2] = tempI64[0]),
+ (HEAP32[(buf + 60) >> 2] = tempI64[1]);
+ HEAPU32[(buf + 64) >> 2] = (mtime % 1000) * 1000;
+ (tempI64 = [
+ Math.floor(ctime / 1000) >>> 0,
+ ((tempDouble = Math.floor(ctime / 1000)),
+ +Math.abs(tempDouble) >= 1.0
+ ? tempDouble > 0.0
+ ? +Math.floor(tempDouble / 4294967296.0) >>> 0
+ : ~~+Math.ceil(
+ (tempDouble - +(~~tempDouble >>> 0)) / 4294967296.0
+ ) >>> 0
+ : 0)
+ ]),
+ (HEAP32[(buf + 72) >> 2] = tempI64[0]),
+ (HEAP32[(buf + 76) >> 2] = tempI64[1]);
+ HEAPU32[(buf + 80) >> 2] = (ctime % 1000) * 1000;
+ (tempI64 = [
+ stat.ino >>> 0,
+ ((tempDouble = stat.ino),
+ +Math.abs(tempDouble) >= 1.0
+ ? tempDouble > 0.0
+ ? +Math.floor(tempDouble / 4294967296.0) >>> 0
+ : ~~+Math.ceil(
+ (tempDouble - +(~~tempDouble >>> 0)) / 4294967296.0
+ ) >>> 0
+ : 0)
+ ]),
+ (HEAP32[(buf + 88) >> 2] = tempI64[0]),
+ (HEAP32[(buf + 92) >> 2] = tempI64[1]);
+ return 0;
+ },
+ doMsync(addr, stream, len, flags, offset) {
+ if (!FS.isFile(stream.node.mode)) {
+ throw new FS.ErrnoError(43);
+ }
+ if (flags & 2) {
+ // MAP_PRIVATE calls need not to be synced back to underlying fs
+ return 0;
+ }
+ var buffer = HEAPU8.slice(addr, addr + len);
+ FS.msync(stream, buffer, offset, len, flags);
+ },
+ varargs: undefined,
+ get() {
+ assert(SYSCALLS.varargs != undefined);
+ // the `+` prepended here is necessary to convince the JSCompiler that varargs is indeed a number.
+ var ret = HEAP32[+SYSCALLS.varargs >> 2];
+ SYSCALLS.varargs += 4;
+ return ret;
+ },
+ getp() {
+ return SYSCALLS.get();
+ },
+ getStr(ptr) {
+ var ret = UTF8ToString(ptr);
+ return ret;
+ },
+ getStreamFromFD(fd) {
+ var stream = FS.getStreamChecked(fd);
+ return stream;
+ }
+};
+function ___syscall_dup(fd) {
+ try {
+ var old = SYSCALLS.getStreamFromFD(fd);
+ return FS.dupStream(old).fd;
+ } catch (e) {
+ if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+ return -e.errno;
+ }
+}
+
+function ___syscall_dup3(fd, newfd, flags) {
+ try {
+ var old = SYSCALLS.getStreamFromFD(fd);
+ assert(!flags);
+ if (old.fd === newfd) return -28;
+ var existing = FS.getStream(newfd);
+ if (existing) FS.close(existing);
+ return FS.dupStream(old, newfd).fd;
+ } catch (e) {
+ if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+ return -e.errno;
+ }
+}
+
+function ___syscall_fcntl64(fd, cmd, varargs) {
+ SYSCALLS.varargs = varargs;
+ try {
+ var stream = SYSCALLS.getStreamFromFD(fd);
+ switch (cmd) {
+ case 0: {
+ var arg = SYSCALLS.get();
+ if (arg < 0) {
+ return -28;
+ }
+ while (FS.streams[arg]) {
+ arg++;
+ }
+ var newStream;
+ newStream = FS.dupStream(stream, arg);
+ return newStream.fd;
+ }
+ case 1:
+ case 2:
+ return 0; // FD_CLOEXEC makes no sense for a single process.
+ case 3:
+ return stream.flags;
+ case 4: {
+ var arg = SYSCALLS.get();
+ stream.flags |= arg;
+ return 0;
+ }
+ case 12: {
+ var arg = SYSCALLS.getp();
+ var offset = 0;
+ // We're always unlocked.
+ HEAP16[(arg + offset) >> 1] = 2;
+ return 0;
+ }
+ case 13:
+ case 14:
+ return 0; // Pretend that the locking is successful.
+ }
+ return -28;
+ } catch (e) {
+ if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+ return -e.errno;
+ }
+}
+
+function ___syscall_fstat64(fd, buf) {
+ try {
+ var stream = SYSCALLS.getStreamFromFD(fd);
+ return SYSCALLS.doStat(FS.stat, stream.path, buf);
+ } catch (e) {
+ if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+ return -e.errno;
+ }
+}
+
+var stringToUTF8 = (str, outPtr, maxBytesToWrite) => {
+ assert(
+ typeof maxBytesToWrite == 'number',
+ 'stringToUTF8(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!'
+ );
+ return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
+};
+
+function ___syscall_getdents64(fd, dirp, count) {
+ try {
+ var stream = SYSCALLS.getStreamFromFD(fd);
+ stream.getdents ||= FS.readdir(stream.path);
+
+ var struct_size = 280;
+ var pos = 0;
+ var off = FS.llseek(stream, 0, 1);
+
+ var idx = Math.floor(off / struct_size);
+
+ while (idx < stream.getdents.length && pos + struct_size <= count) {
+ var id;
+ var type;
+ var name = stream.getdents[idx];
+ if (name === '.') {
+ id = stream.node.id;
+ type = 4; // DT_DIR
+ } else if (name === '..') {
+ var lookup = FS.lookupPath(stream.path, { parent: true });
+ id = lookup.node.id;
+ type = 4; // DT_DIR
+ } else {
+ var child = FS.lookupNode(stream.node, name);
+ id = child.id;
+ type = FS.isChrdev(child.mode)
+ ? 2 // DT_CHR, character device.
+ : FS.isDir(child.mode)
+ ? 4 // DT_DIR, directory.
+ : FS.isLink(child.mode)
+ ? 10 // DT_LNK, symbolic link.
+ : 8; // DT_REG, regular file.
+ }
+ assert(id);
+ (tempI64 = [
+ id >>> 0,
+ ((tempDouble = id),
+ +Math.abs(tempDouble) >= 1.0
+ ? tempDouble > 0.0
+ ? +Math.floor(tempDouble / 4294967296.0) >>> 0
+ : ~~+Math.ceil(
+ (tempDouble - +(~~tempDouble >>> 0)) / 4294967296.0
+ ) >>> 0
+ : 0)
+ ]),
+ (HEAP32[(dirp + pos) >> 2] = tempI64[0]),
+ (HEAP32[(dirp + pos + 4) >> 2] = tempI64[1]);
+ (tempI64 = [
+ ((idx + 1) * struct_size) >>> 0,
+ ((tempDouble = (idx + 1) * struct_size),
+ +Math.abs(tempDouble) >= 1.0
+ ? tempDouble > 0.0
+ ? +Math.floor(tempDouble / 4294967296.0) >>> 0
+ : ~~+Math.ceil(
+ (tempDouble - +(~~tempDouble >>> 0)) / 4294967296.0
+ ) >>> 0
+ : 0)
+ ]),
+ (HEAP32[(dirp + pos + 8) >> 2] = tempI64[0]),
+ (HEAP32[(dirp + pos + 12) >> 2] = tempI64[1]);
+ HEAP16[(dirp + pos + 16) >> 1] = 280;
+ HEAP8[dirp + pos + 18] = type;
+ stringToUTF8(name, dirp + pos + 19, 256);
+ pos += struct_size;
+ idx += 1;
+ }
+ FS.llseek(stream, idx * struct_size, 0);
+ return pos;
+ } catch (e) {
+ if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+ return -e.errno;
+ }
+}
+
+function ___syscall_ioctl(fd, op, varargs) {
+ SYSCALLS.varargs = varargs;
+ try {
+ var stream = SYSCALLS.getStreamFromFD(fd);
+ switch (op) {
+ case 21509: {
+ 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 = SYSCALLS.getp();
+ HEAP32[argp >> 2] = termios.c_iflag || 0;
+ HEAP32[(argp + 4) >> 2] = termios.c_oflag || 0;
+ HEAP32[(argp + 8) >> 2] = termios.c_cflag || 0;
+ HEAP32[(argp + 12) >> 2] = termios.c_lflag || 0;
+ for (var i = 0; i < 32; i++) {
+ HEAP8[argp + i + 17] = termios.c_cc[i] || 0;
+ }
+ return 0;
+ }
+ return 0;
+ }
+ case 21510:
+ case 21511:
+ case 21512: {
+ if (!stream.tty) return -59;
+ return 0; // no-op, not actually adjusting terminal settings
+ }
+ case 21506:
+ case 21507:
+ case 21508: {
+ if (!stream.tty) return -59;
+ if (stream.tty.ops.ioctl_tcsets) {
+ var argp = SYSCALLS.getp();
+ var c_iflag = HEAP32[argp >> 2];
+ var c_oflag = HEAP32[(argp + 4) >> 2];
+ var c_cflag = HEAP32[(argp + 8) >> 2];
+ var c_lflag = HEAP32[(argp + 12) >> 2];
+ var c_cc = [];
+ for (var i = 0; i < 32; i++) {
+ c_cc.push(HEAP8[argp + i + 17]);
+ }
+ return stream.tty.ops.ioctl_tcsets(stream.tty, op, {
+ c_iflag,
+ c_oflag,
+ c_cflag,
+ c_lflag,
+ c_cc
+ });
+ }
+ return 0; // no-op, not actually adjusting terminal settings
+ }
+ case 21519: {
+ if (!stream.tty) return -59;
+ var argp = SYSCALLS.getp();
+ HEAP32[argp >> 2] = 0;
+ return 0;
+ }
+ case 21520: {
+ if (!stream.tty) return -59;
+ return -28; // not supported
+ }
+ case 21531: {
+ var argp = SYSCALLS.getp();
+ return FS.ioctl(stream, op, argp);
+ }
+ case 21523: {
+ // TODO: in theory we should write to the winsize struct that gets
+ // passed in, but for now musl doesn't read anything on it
+ if (!stream.tty) return -59;
+ if (stream.tty.ops.ioctl_tiocgwinsz) {
+ var winsize = stream.tty.ops.ioctl_tiocgwinsz(stream.tty);
+ var argp = SYSCALLS.getp();
+ HEAP16[argp >> 1] = winsize[0];
+ HEAP16[(argp + 2) >> 1] = winsize[1];
+ }
+ return 0;
+ }
+ case 21524: {
+ // TODO: technically, this ioctl call should change the window size.
+ // but, since emscripten doesn't have any concept of a terminal window
+ // yet, we'll just silently throw it away as we do TIOCGWINSZ
+ if (!stream.tty) return -59;
+ return 0;
+ }
+ case 21515: {
+ if (!stream.tty) return -59;
+ return 0;
+ }
+ default:
+ return -28; // not supported
+ }
+ } catch (e) {
+ if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+ return -e.errno;
+ }
+}
+
+function ___syscall_lstat64(path, buf) {
+ try {
+ path = SYSCALLS.getStr(path);
+ return SYSCALLS.doStat(FS.lstat, path, buf);
+ } catch (e) {
+ if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+ return -e.errno;
+ }
+}
+
+function ___syscall_newfstatat(dirfd, path, buf, flags) {
+ try {
+ path = SYSCALLS.getStr(path);
+ var nofollow = flags & 256;
+ var allowEmpty = flags & 4096;
+ flags = flags & ~6400;
+ assert(!flags, `unknown flags in __syscall_newfstatat: ${flags}`);
+ path = SYSCALLS.calculateAt(dirfd, path, allowEmpty);
+ return SYSCALLS.doStat(nofollow ? FS.lstat : FS.stat, path, buf);
+ } catch (e) {
+ if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+ return -e.errno;
+ }
+}
+
+function ___syscall_openat(dirfd, path, flags, varargs) {
+ SYSCALLS.varargs = varargs;
+ try {
+ path = SYSCALLS.getStr(path);
+ path = SYSCALLS.calculateAt(dirfd, path);
+ var mode = varargs ? SYSCALLS.get() : 0;
+ return FS.open(path, flags, mode).fd;
+ } catch (e) {
+ if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+ return -e.errno;
+ }
+}
+
+function ___syscall_renameat(olddirfd, oldpath, newdirfd, newpath) {
+ try {
+ oldpath = SYSCALLS.getStr(oldpath);
+ newpath = SYSCALLS.getStr(newpath);
+ oldpath = SYSCALLS.calculateAt(olddirfd, oldpath);
+ newpath = SYSCALLS.calculateAt(newdirfd, newpath);
+ FS.rename(oldpath, newpath);
+ return 0;
+ } catch (e) {
+ if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+ return -e.errno;
+ }
+}
+
+function ___syscall_rmdir(path) {
+ try {
+ path = SYSCALLS.getStr(path);
+ FS.rmdir(path);
+ return 0;
+ } catch (e) {
+ if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+ return -e.errno;
+ }
+}
+
+function ___syscall_stat64(path, buf) {
+ try {
+ path = SYSCALLS.getStr(path);
+ return SYSCALLS.doStat(FS.stat, path, buf);
+ } catch (e) {
+ if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+ return -e.errno;
+ }
+}
+
+function ___syscall_unlinkat(dirfd, path, flags) {
+ try {
+ path = SYSCALLS.getStr(path);
+ path = SYSCALLS.calculateAt(dirfd, path);
+ if (flags === 0) {
+ FS.unlink(path);
+ } else if (flags === 512) {
+ FS.rmdir(path);
+ } else {
+ abort('Invalid flags passed to unlinkat');
+ }
+ return 0;
+ } catch (e) {
+ if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+ return -e.errno;
+ }
+}
+
+var nowIsMonotonic = 1;
+var __emscripten_get_now_is_monotonic = () => nowIsMonotonic;
+
+var __emscripten_throw_longjmp = () => {
+ throw Infinity;
+};
+
+var convertI32PairToI53Checked = (lo, hi) => {
+ assert(lo == lo >>> 0 || lo == (lo | 0)); // lo should either be a i32 or a u32
+ assert(hi === (hi | 0)); // hi should be a i32
+ return (hi + 0x200000) >>> 0 < 0x400001 - !!lo
+ ? (lo >>> 0) + hi * 4294967296
+ : NaN;
+};
+function __gmtime_js(time_low, time_high, tmPtr) {
+ var time = convertI32PairToI53Checked(time_low, time_high);
+
+ var date = new Date(time * 1000);
+ HEAP32[tmPtr >> 2] = date.getUTCSeconds();
+ HEAP32[(tmPtr + 4) >> 2] = date.getUTCMinutes();
+ HEAP32[(tmPtr + 8) >> 2] = date.getUTCHours();
+ HEAP32[(tmPtr + 12) >> 2] = date.getUTCDate();
+ HEAP32[(tmPtr + 16) >> 2] = date.getUTCMonth();
+ HEAP32[(tmPtr + 20) >> 2] = date.getUTCFullYear() - 1900;
+ HEAP32[(tmPtr + 24) >> 2] = date.getUTCDay();
+ var start = Date.UTC(date.getUTCFullYear(), 0, 1, 0, 0, 0, 0);
+ var yday = ((date.getTime() - start) / (1000 * 60 * 60 * 24)) | 0;
+ HEAP32[(tmPtr + 28) >> 2] = yday;
+}
+
+var isLeapYear = (year) =>
+ year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+
+var MONTH_DAYS_LEAP_CUMULATIVE = [
+ 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335
+];
+
+var MONTH_DAYS_REGULAR_CUMULATIVE = [
+ 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334
+];
+var ydayFromDate = (date) => {
+ var leap = isLeapYear(date.getFullYear());
+ var monthDaysCumulative = leap
+ ? MONTH_DAYS_LEAP_CUMULATIVE
+ : MONTH_DAYS_REGULAR_CUMULATIVE;
+ var yday = monthDaysCumulative[date.getMonth()] + date.getDate() - 1; // -1 since it's days since Jan 1
+
+ return yday;
+};
+
+function __localtime_js(time_low, time_high, tmPtr) {
+ var time = convertI32PairToI53Checked(time_low, time_high);
+
+ var date = new Date(time * 1000);
+ HEAP32[tmPtr >> 2] = date.getSeconds();
+ HEAP32[(tmPtr + 4) >> 2] = date.getMinutes();
+ HEAP32[(tmPtr + 8) >> 2] = date.getHours();
+ HEAP32[(tmPtr + 12) >> 2] = date.getDate();
+ HEAP32[(tmPtr + 16) >> 2] = date.getMonth();
+ HEAP32[(tmPtr + 20) >> 2] = date.getFullYear() - 1900;
+ HEAP32[(tmPtr + 24) >> 2] = date.getDay();
+
+ var yday = ydayFromDate(date) | 0;
+ HEAP32[(tmPtr + 28) >> 2] = yday;
+ HEAP32[(tmPtr + 36) >> 2] = -(date.getTimezoneOffset() * 60);
+
+ // Attention: DST is in December in South, and some regions don't have DST at all.
+ var start = new Date(date.getFullYear(), 0, 1);
+ var summerOffset = new Date(date.getFullYear(), 6, 1).getTimezoneOffset();
+ var winterOffset = start.getTimezoneOffset();
+ var dst =
+ (summerOffset != winterOffset &&
+ date.getTimezoneOffset() == Math.min(winterOffset, summerOffset)) | 0;
+ HEAP32[(tmPtr + 32) >> 2] = dst;
+}
+
+var __mktime_js = function (tmPtr) {
+ var ret = (() => {
+ var date = new Date(
+ HEAP32[(tmPtr + 20) >> 2] + 1900,
+ HEAP32[(tmPtr + 16) >> 2],
+ HEAP32[(tmPtr + 12) >> 2],
+ HEAP32[(tmPtr + 8) >> 2],
+ HEAP32[(tmPtr + 4) >> 2],
+ HEAP32[tmPtr >> 2],
+ 0
+ );
+
+ // There's an ambiguous hour when the time goes back; the tm_isdst field is
+ // used to disambiguate it. Date() basically guesses, so we fix it up if it
+ // guessed wrong, or fill in tm_isdst with the guess if it's -1.
+ var dst = HEAP32[(tmPtr + 32) >> 2];
+ var guessedOffset = date.getTimezoneOffset();
+ var start = new Date(date.getFullYear(), 0, 1);
+ var summerOffset = new Date(date.getFullYear(), 6, 1).getTimezoneOffset();
+ var winterOffset = start.getTimezoneOffset();
+ var dstOffset = Math.min(winterOffset, summerOffset); // DST is in December in South
+ if (dst < 0) {
+ // Attention: some regions don't have DST at all.
+ HEAP32[(tmPtr + 32) >> 2] = Number(
+ summerOffset != winterOffset && dstOffset == guessedOffset
+ );
+ } else if (dst > 0 != (dstOffset == guessedOffset)) {
+ var nonDstOffset = Math.max(winterOffset, summerOffset);
+ var trueOffset = dst > 0 ? dstOffset : nonDstOffset;
+ // Don't try setMinutes(date.getMinutes() + ...) -- it's messed up.
+ date.setTime(date.getTime() + (trueOffset - guessedOffset) * 60000);
+ }
+
+ HEAP32[(tmPtr + 24) >> 2] = date.getDay();
+ var yday = ydayFromDate(date) | 0;
+ HEAP32[(tmPtr + 28) >> 2] = yday;
+ // To match expected behavior, update fields from date
+ HEAP32[tmPtr >> 2] = date.getSeconds();
+ HEAP32[(tmPtr + 4) >> 2] = date.getMinutes();
+ HEAP32[(tmPtr + 8) >> 2] = date.getHours();
+ HEAP32[(tmPtr + 12) >> 2] = date.getDate();
+ HEAP32[(tmPtr + 16) >> 2] = date.getMonth();
+ HEAP32[(tmPtr + 20) >> 2] = date.getYear();
+
+ var timeMs = date.getTime();
+ if (isNaN(timeMs)) {
+ return -1;
+ }
+ // Return time in microseconds
+ return timeMs / 1000;
+ })();
+ return (
+ setTempRet0(
+ ((tempDouble = ret),
+ +Math.abs(tempDouble) >= 1.0
+ ? tempDouble > 0.0
+ ? +Math.floor(tempDouble / 4294967296.0) >>> 0
+ : ~~+Math.ceil(
+ (tempDouble - +(~~tempDouble >>> 0)) / 4294967296.0
+ ) >>> 0
+ : 0)
+ ),
+ ret >>> 0
+ );
+};
+
+var __tzset_js = (timezone, daylight, std_name, dst_name) => {
+ // TODO: Use (malleable) environment variables instead of system settings.
+ 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();
+
+ // Local standard timezone offset. Local standard time is not adjusted for
+ // daylight savings. This code uses the fact that getTimezoneOffset returns
+ // a greater value during Standard Time versus Daylight Saving Time (DST).
+ // Thus it determines the expected output during Standard Time, and it
+ // compares whether the output of the given date the same (Standard) or less
+ // (DST).
+ var stdTimezoneOffset = Math.max(winterOffset, summerOffset);
+
+ // timezone is specified as seconds west of UTC ("The external variable
+ // `timezone` shall be set to the difference, in seconds, between
+ // Coordinated Universal Time (UTC) and local standard time."), the same
+ // as returned by stdTimezoneOffset.
+ // See http://pubs.opengroup.org/onlinepubs/009695399/functions/tzset.html
+ HEAPU32[timezone >> 2] = stdTimezoneOffset * 60;
+
+ HEAP32[daylight >> 2] = Number(winterOffset != summerOffset);
+
+ function extractZone(date) {
+ var match = date.toTimeString().match(/\(([A-Za-z ]+)\)$/);
+ return match ? match[1] : 'GMT';
+ }
+ var winterName = extractZone(winter);
+ var summerName = extractZone(summer);
+ if (summerOffset < winterOffset) {
+ // Northern hemisphere
+ stringToUTF8(winterName, std_name, 7);
+ stringToUTF8(summerName, dst_name, 7);
+ } else {
+ stringToUTF8(winterName, dst_name, 7);
+ stringToUTF8(summerName, std_name, 7);
+ }
+};
+
+var _emscripten_date_now = () => Date.now();
+
+var _emscripten_get_now;
+// Modern environment where performance.now() is supported:
+// N.B. a shorter form "_emscripten_get_now = performance.now;" is
+// unfortunately not allowed even in current browsers (e.g. FF Nightly 75).
+_emscripten_get_now = () => performance.now();
+var _emscripten_memcpy_js = (dest, src, num) =>
+ HEAPU8.copyWithin(dest, src, src + num);
+
+var getHeapMax = () =>
+ // Stay one Wasm page short of 4GB: while e.g. Chrome is able to allocate
+ // full 4GB Wasm memories, the size will wrap back to 0 bytes in Wasm side
+ // for any code that deals with heap sizes, which would require special
+ // casing all heap size related code to treat 0 specially.
+ 2147483648;
+
+var growMemory = (size) => {
+ var b = wasmMemory.buffer;
+ var pages = (size - b.byteLength + 65535) / 65536;
+ try {
+ // round size grow request up to wasm page size (fixed 64KB per spec)
+ wasmMemory.grow(pages); // .grow() takes a delta compared to the previous size
+ updateMemoryViews();
+ return 1 /*success*/;
+ } catch (e) {
+ err(
+ `growMemory: Attempted to grow heap from ${b.byteLength} bytes to ${size} bytes, but got error: ${e}`
+ );
+ }
+ // implicit 0 return to save code size (caller will cast "undefined" into 0
+ // anyhow)
+};
+var _emscripten_resize_heap = (requestedSize) => {
+ var oldSize = HEAPU8.length;
+ // With CAN_ADDRESS_2GB or MEMORY64, pointers are already unsigned.
+ requestedSize >>>= 0;
+ // With multithreaded builds, races can happen (another thread might increase the size
+ // in between), so return a failure, and let the caller retry.
+ assert(requestedSize > oldSize);
+
+ // Memory resize rules:
+ // 1. Always increase heap size to at least the requested size, rounded up
+ // to next page multiple.
+ // 2a. If MEMORY_GROWTH_LINEAR_STEP == -1, excessively resize the heap
+ // geometrically: increase the heap size according to
+ // MEMORY_GROWTH_GEOMETRIC_STEP factor (default +20%), At most
+ // overreserve by MEMORY_GROWTH_GEOMETRIC_CAP bytes (default 96MB).
+ // 2b. If MEMORY_GROWTH_LINEAR_STEP != -1, excessively resize the heap
+ // linearly: increase the heap size by at least
+ // MEMORY_GROWTH_LINEAR_STEP bytes.
+ // 3. Max size for the heap is capped at 2048MB-WASM_PAGE_SIZE, or by
+ // MAXIMUM_MEMORY, or by ASAN limit, depending on which is smallest
+ // 4. If we were unable to allocate as much memory, it may be due to
+ // over-eager decision to excessively reserve due to (3) above.
+ // Hence if an allocation fails, cut down on the amount of excess
+ // growth, in an attempt to succeed to perform a smaller allocation.
+
+ // A limit is set for how much we can grow. We should not exceed that
+ // (the wasm binary specifies it, so if we tried, we'd fail anyhow).
+ var maxHeapSize = getHeapMax();
+ if (requestedSize > maxHeapSize) {
+ err(
+ `Cannot enlarge memory, requested ${requestedSize} bytes, but the limit is ${maxHeapSize} bytes!`
+ );
+ return false;
+ }
+
+ var alignUp = (x, multiple) => x + ((multiple - (x % multiple)) % multiple);
+
+ // Loop through potential heap size increases. If we attempt a too eager
+ // reservation that fails, cut down on the attempted size and reserve a
+ // smaller bump instead. (max 3 times, chosen somewhat arbitrarily)
+ for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
+ var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown); // ensure geometric growth
+ // but limit overreserving (default to capping at +96MB overgrowth at most)
+ overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
+
+ var newSize = Math.min(
+ maxHeapSize,
+ alignUp(Math.max(requestedSize, overGrownHeapSize), 65536)
+ );
+
+ var replacement = growMemory(newSize);
+ if (replacement) {
+ return true;
+ }
+ }
+ err(
+ `Failed to grow the heap from ${oldSize} bytes to ${newSize} bytes, not enough memory!`
+ );
+ return false;
+};
+
+var ENV = {};
+
+var getExecutableName = () => {
+ return thisProgram || './this.program';
+};
+var getEnvStrings = () => {
+ if (!getEnvStrings.strings) {
+ // Default values.
+ // Browser language detection #8751
+ var lang =
+ (
+ (typeof navigator == 'object' &&
+ navigator.languages &&
+ navigator.languages[0]) ||
+ 'C'
+ ).replace('-', '_') + '.UTF-8';
+ var env = {
+ USER: 'web_user',
+ LOGNAME: 'web_user',
+ PATH: '/',
+ PWD: '/',
+ HOME: '/home/web_user',
+ LANG: lang,
+ _: getExecutableName()
+ };
+ // Apply the user-provided values, if any.
+ for (var x in ENV) {
+ // x is a key in ENV; if ENV[x] is undefined, that means it was
+ // explicitly set to be so. We allow user code to do that to
+ // force variables with default values to remain unset.
+ if (ENV[x] === undefined) delete env[x];
+ else env[x] = ENV[x];
+ }
+ var strings = [];
+ for (var x in env) {
+ strings.push(`${x}=${env[x]}`);
+ }
+ getEnvStrings.strings = strings;
+ }
+ return getEnvStrings.strings;
+};
+
+var stringToAscii = (str, buffer) => {
+ for (var i = 0; i < str.length; ++i) {
+ assert(str.charCodeAt(i) === (str.charCodeAt(i) & 0xff));
+ HEAP8[buffer++] = str.charCodeAt(i);
+ }
+ // Null-terminate the string
+ HEAP8[buffer] = 0;
+};
+var _environ_get = (__environ, environ_buf) => {
+ var bufSize = 0;
+ getEnvStrings().forEach((string, i) => {
+ var ptr = environ_buf + bufSize;
+ HEAPU32[(__environ + i * 4) >> 2] = ptr;
+ stringToAscii(string, ptr);
+ bufSize += string.length + 1;
+ });
+ return 0;
+};
+
+var _environ_sizes_get = (penviron_count, penviron_buf_size) => {
+ var strings = getEnvStrings();
+ HEAPU32[penviron_count >> 2] = strings.length;
+ var bufSize = 0;
+ strings.forEach((string) => (bufSize += string.length + 1));
+ HEAPU32[penviron_buf_size >> 2] = bufSize;
+ return 0;
+};
+
+var runtimeKeepaliveCounter = 0;
+var keepRuntimeAlive = () => noExitRuntime || runtimeKeepaliveCounter > 0;
+var _proc_exit = (code) => {
+ EXITSTATUS = code;
+ if (!keepRuntimeAlive()) {
+ Module['onExit']?.(code);
+ ABORT = true;
+ }
+ quit_(code, new ExitStatus(code));
+};
+
+/** @suppress {duplicate } */
+/** @param {boolean|number=} implicit */
+var exitJS = (status, implicit) => {
+ EXITSTATUS = status;
+
+ if (!keepRuntimeAlive()) {
+ exitRuntime();
+ }
+
+ // if exit() was called explicitly, warn the user if the runtime isn't actually being shut down
+ if (keepRuntimeAlive() && !implicit) {
+ var msg = `program exited (with status: ${status}), but keepRuntimeAlive() is set (counter=${runtimeKeepaliveCounter}) due to an async operation, so halting execution but not exiting the runtime or preventing further async execution (you can use emscripten_force_exit, if you want to force a true shutdown)`;
+ err(msg);
+ }
+
+ _proc_exit(status);
+};
+var _exit = exitJS;
+
+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;
+ }
+}
+
+/** @param {number=} offset */
+var doReadv = (stream, iov, iovcnt, offset) => {
+ var ret = 0;
+ for (var i = 0; i < iovcnt; i++) {
+ var ptr = HEAPU32[iov >> 2];
+ var len = HEAPU32[(iov + 4) >> 2];
+ iov += 8;
+ var curr = FS.read(stream, HEAP8, ptr, len, offset);
+ if (curr < 0) return -1;
+ ret += curr;
+ if (curr < len) break; // nothing more to read
+ if (typeof offset !== 'undefined') {
+ offset += curr;
+ }
+ }
+ return ret;
+};
+
+function _fd_pread(fd, iov, iovcnt, offset_low, offset_high, pnum) {
+ var offset = convertI32PairToI53Checked(offset_low, offset_high);
+
+ try {
+ if (isNaN(offset)) return 61;
+ var stream = SYSCALLS.getStreamFromFD(fd);
+ var num = doReadv(stream, iov, iovcnt, offset);
+ HEAPU32[pnum >> 2] = num;
+ return 0;
+ } catch (e) {
+ if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+ return e.errno;
+ }
+}
+
+/** @param {number=} offset */
+var doWritev = (stream, iov, iovcnt, offset) => {
+ var ret = 0;
+ for (var i = 0; i < iovcnt; i++) {
+ var ptr = HEAPU32[iov >> 2];
+ var len = HEAPU32[(iov + 4) >> 2];
+ iov += 8;
+ var curr = FS.write(stream, HEAP8, ptr, len, offset);
+ if (curr < 0) return -1;
+ ret += curr;
+ if (typeof offset !== 'undefined') {
+ offset += curr;
+ }
+ }
+ return ret;
+};
+
+function _fd_pwrite(fd, iov, iovcnt, offset_low, offset_high, pnum) {
+ var offset = convertI32PairToI53Checked(offset_low, offset_high);
+
+ try {
+ if (isNaN(offset)) return 61;
+ var stream = SYSCALLS.getStreamFromFD(fd);
+ var num = doWritev(stream, iov, iovcnt, offset);
+ HEAPU32[pnum >> 2] = num;
+ return 0;
+ } catch (e) {
+ if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+ return e.errno;
+ }
+}
+
+function _fd_read(fd, iov, iovcnt, pnum) {
+ try {
+ var stream = SYSCALLS.getStreamFromFD(fd);
+ var num = doReadv(stream, iov, iovcnt);
+ HEAPU32[pnum >> 2] = num;
+ return 0;
+ } catch (e) {
+ if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+ return e.errno;
+ }
+}
+
+function _fd_seek(fd, offset_low, offset_high, whence, newOffset) {
+ var offset = convertI32PairToI53Checked(offset_low, offset_high);
+
+ try {
+ if (isNaN(offset)) return 61;
+ var stream = SYSCALLS.getStreamFromFD(fd);
+ FS.llseek(stream, offset, whence);
+ (tempI64 = [
+ stream.position >>> 0,
+ ((tempDouble = stream.position),
+ +Math.abs(tempDouble) >= 1.0
+ ? tempDouble > 0.0
+ ? +Math.floor(tempDouble / 4294967296.0) >>> 0
+ : ~~+Math.ceil(
+ (tempDouble - +(~~tempDouble >>> 0)) / 4294967296.0
+ ) >>> 0
+ : 0)
+ ]),
+ (HEAP32[newOffset >> 2] = tempI64[0]),
+ (HEAP32[(newOffset + 4) >> 2] = tempI64[1]);
+ if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null; // reset readdir state
+ return 0;
+ } catch (e) {
+ if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+ return e.errno;
+ }
+}
+
+function _fd_write(fd, iov, iovcnt, pnum) {
+ try {
+ var stream = SYSCALLS.getStreamFromFD(fd);
+ var num = doWritev(stream, iov, iovcnt);
+ HEAPU32[pnum >> 2] = num;
+ return 0;
+ } catch (e) {
+ if (typeof FS == 'undefined' || !(e.name === 'ErrnoError')) throw e;
+ return e.errno;
+ }
+}
+
+var handleException = (e) => {
+ // Certain exception types we do not treat as errors since they are used for
+ // internal control flow.
+ // 1. ExitStatus, which is thrown by exit()
+ // 2. "unwind", which is thrown by emscripten_unwind_to_js_event_loop() and others
+ // that wish to return to JS event loop.
+ if (e instanceof ExitStatus || e == 'unwind') {
+ return EXITSTATUS;
+ }
+ checkStackCookie();
+ if (e instanceof WebAssembly.RuntimeError) {
+ if (_emscripten_stack_get_current() <= 0) {
+ err(
+ 'Stack overflow detected. You can try increasing -sSTACK_SIZE (currently set to 65536)'
+ );
+ }
+ }
+ quit_(1, e);
+};
+
+var stringToUTF8OnStack = (str) => {
+ var size = lengthBytesUTF8(str) + 1;
+ var ret = stackAlloc(size);
+ stringToUTF8(str, ret, size);
+ return ret;
+};
+
+var wasmTableMirror = [];
+
+var wasmTable;
+var getWasmTableEntry = (funcPtr) => {
+ var func = wasmTableMirror[funcPtr];
+ if (!func) {
+ if (funcPtr >= wasmTableMirror.length) wasmTableMirror.length = funcPtr + 1;
+ wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr);
+ }
+ assert(
+ wasmTable.get(funcPtr) == func,
+ 'JavaScript-side Wasm function table mirror is out of date!'
+ );
+ return func;
+};
+
+FS.createPreloadedFile = FS_createPreloadedFile;
+FS.staticInit();
+function checkIncomingModuleAPI() {
+ ignoredModuleProp('fetchSettings');
+}
+var wasmImports = {
+ /** @export */
+ __assert_fail: ___assert_fail,
+ /** @export */
+ __syscall_dup: ___syscall_dup,
+ /** @export */
+ __syscall_dup3: ___syscall_dup3,
+ /** @export */
+ __syscall_fcntl64: ___syscall_fcntl64,
+ /** @export */
+ __syscall_fstat64: ___syscall_fstat64,
+ /** @export */
+ __syscall_getdents64: ___syscall_getdents64,
+ /** @export */
+ __syscall_ioctl: ___syscall_ioctl,
+ /** @export */
+ __syscall_lstat64: ___syscall_lstat64,
+ /** @export */
+ __syscall_newfstatat: ___syscall_newfstatat,
+ /** @export */
+ __syscall_openat: ___syscall_openat,
+ /** @export */
+ __syscall_renameat: ___syscall_renameat,
+ /** @export */
+ __syscall_rmdir: ___syscall_rmdir,
+ /** @export */
+ __syscall_stat64: ___syscall_stat64,
+ /** @export */
+ __syscall_unlinkat: ___syscall_unlinkat,
+ /** @export */
+ _emscripten_get_now_is_monotonic: __emscripten_get_now_is_monotonic,
+ /** @export */
+ _emscripten_throw_longjmp: __emscripten_throw_longjmp,
+ /** @export */
+ _gmtime_js: __gmtime_js,
+ /** @export */
+ _localtime_js: __localtime_js,
+ /** @export */
+ _mktime_js: __mktime_js,
+ /** @export */
+ _tzset_js: __tzset_js,
+ /** @export */
+ emscripten_date_now: _emscripten_date_now,
+ /** @export */
+ emscripten_get_now: _emscripten_get_now,
+ /** @export */
+ emscripten_memcpy_js: _emscripten_memcpy_js,
+ /** @export */
+ emscripten_resize_heap: _emscripten_resize_heap,
+ /** @export */
+ environ_get: _environ_get,
+ /** @export */
+ environ_sizes_get: _environ_sizes_get,
+ /** @export */
+ exit: _exit,
+ /** @export */
+ fd_close: _fd_close,
+ /** @export */
+ fd_pread: _fd_pread,
+ /** @export */
+ fd_pwrite: _fd_pwrite,
+ /** @export */
+ fd_read: _fd_read,
+ /** @export */
+ fd_seek: _fd_seek,
+ /** @export */
+ fd_write: _fd_write,
+ /** @export */
+ invoke_ii: invoke_ii,
+ /** @export */
+ invoke_iii: invoke_iii,
+ /** @export */
+ invoke_iiii: invoke_iiii,
+ /** @export */
+ invoke_iiiii: invoke_iiiii,
+ /** @export */
+ invoke_vi: invoke_vi,
+ /** @export */
+ invoke_vii: invoke_vii,
+ /** @export */
+ invoke_viii: invoke_viii,
+ /** @export */
+ invoke_viiii: invoke_viiii
+};
+var wasmExports = createWasm();
+var ___wasm_call_ctors = createExportWrapper('__wasm_call_ctors');
+var _main = (Module['_main'] = createExportWrapper('__main_argc_argv'));
+var _malloc = createExportWrapper('malloc');
+var setTempRet0 = createExportWrapper('setTempRet0');
+var _free = createExportWrapper('free');
+var _fflush = createExportWrapper('fflush');
+var ___funcs_on_exit = createExportWrapper('__funcs_on_exit');
+var _setThrew = createExportWrapper('setThrew');
+var _emscripten_stack_init = () =>
+ (_emscripten_stack_init = wasmExports['emscripten_stack_init'])();
+var _emscripten_stack_get_free = () =>
+ (_emscripten_stack_get_free = wasmExports['emscripten_stack_get_free'])();
+var _emscripten_stack_get_base = () =>
+ (_emscripten_stack_get_base = wasmExports['emscripten_stack_get_base'])();
+var _emscripten_stack_get_end = () =>
+ (_emscripten_stack_get_end = wasmExports['emscripten_stack_get_end'])();
+var stackSave = createExportWrapper('stackSave');
+var stackRestore = createExportWrapper('stackRestore');
+var stackAlloc = createExportWrapper('stackAlloc');
+var _emscripten_stack_get_current = () =>
+ (_emscripten_stack_get_current =
+ wasmExports['emscripten_stack_get_current'])();
+var dynCall_jii = (Module['dynCall_jii'] = createExportWrapper('dynCall_jii'));
+var dynCall_iiji = (Module['dynCall_iiji'] =
+ createExportWrapper('dynCall_iiji'));
+var dynCall_iiiiiij = (Module['dynCall_iiiiiij'] =
+ createExportWrapper('dynCall_iiiiiij'));
+var dynCall_iiiiiiijjii = (Module['dynCall_iiiiiiijjii'] = createExportWrapper(
+ 'dynCall_iiiiiiijjii'
+));
+var dynCall_iiiiiiiiiijj = (Module['dynCall_iiiiiiiiiijj'] =
+ createExportWrapper('dynCall_iiiiiiiiiijj'));
+var dynCall_jiiiii = (Module['dynCall_jiiiii'] =
+ createExportWrapper('dynCall_jiiiii'));
+var dynCall_iiiiiiiiiiji = (Module['dynCall_iiiiiiiiiiji'] =
+ createExportWrapper('dynCall_iiiiiiiiiiji'));
+var dynCall_iiiijii = (Module['dynCall_iiiijii'] =
+ createExportWrapper('dynCall_iiiijii'));
+var dynCall_iiiiijiii = (Module['dynCall_iiiiijiii'] =
+ createExportWrapper('dynCall_iiiiijiii'));
+var dynCall_viiiiiiiiiiiiiiiiiiiiiiiiiiiiiiijiiiiii = (Module[
+ 'dynCall_viiiiiiiiiiiiiiiiiiiiiiiiiiiiiiijiiiiii'
+] = createExportWrapper('dynCall_viiiiiiiiiiiiiiiiiiiiiiiiiiiiiiijiiiiii'));
+var dynCall_viiiiiiiiiiiiiijiiiii = (Module['dynCall_viiiiiiiiiiiiiijiiiii'] =
+ createExportWrapper('dynCall_viiiiiiiiiiiiiijiiiii'));
+var dynCall_vijii = (Module['dynCall_vijii'] =
+ createExportWrapper('dynCall_vijii'));
+var dynCall_jji = (Module['dynCall_jji'] = createExportWrapper('dynCall_jji'));
+var dynCall_iji = (Module['dynCall_iji'] = createExportWrapper('dynCall_iji'));
+var dynCall_jiji = (Module['dynCall_jiji'] =
+ createExportWrapper('dynCall_jiji'));
+var dynCall_iij = (Module['dynCall_iij'] = createExportWrapper('dynCall_iij'));
+var dynCall_ji = (Module['dynCall_ji'] = createExportWrapper('dynCall_ji'));
+var dynCall_iijii = (Module['dynCall_iijii'] =
+ createExportWrapper('dynCall_iijii'));
+var dynCall_iijj = (Module['dynCall_iijj'] =
+ createExportWrapper('dynCall_iijj'));
+var dynCall_iijjjjjj = (Module['dynCall_iijjjjjj'] =
+ createExportWrapper('dynCall_iijjjjjj'));
+var dynCall_viiiiiiiiijiiii = (Module['dynCall_viiiiiiiiijiiii'] =
+ createExportWrapper('dynCall_viiiiiiiiijiiii'));
+
+function invoke_vi(index, a1) {
+ var sp = stackSave();
+ try {
+ getWasmTableEntry(index)(a1);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+}
+
+function invoke_ii(index, a1) {
+ var sp = stackSave();
+ try {
+ return getWasmTableEntry(index)(a1);
+ } catch (e) {
+ stackRestore(sp);
+ if (e !== e + 0) throw e;
+ _setThrew(1, 0);
+ }
+}
+
+function invoke_vii(index, a1, a2) {
+ var sp = stackSave();
+ try {
+ getWasmTableEntry(index)(a1, a2);
+ } 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_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_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);
+ }
+}
+
+// include: postamble.js
+// === Auto-generated postamble setup entry stuff ===
+
+Module['FS'] = FS;
+Module['run'] = run;
+var missingLibrarySymbols = [
+ 'writeI53ToI64',
+ 'writeI53ToI64Clamped',
+ 'writeI53ToI64Signaling',
+ 'writeI53ToU64Clamped',
+ 'writeI53ToU64Signaling',
+ 'readI53FromI64',
+ 'readI53FromU64',
+ 'convertI32PairToI53',
+ 'convertU32PairToI53',
+ 'arraySum',
+ 'addDays',
+ 'inetPton4',
+ 'inetNtop4',
+ 'inetPton6',
+ 'inetNtop6',
+ 'readSockaddr',
+ 'writeSockaddr',
+ 'getCallstack',
+ 'emscriptenLog',
+ 'convertPCtoSourceLocation',
+ 'readEmAsmArgs',
+ 'jstoi_q',
+ 'listenOnce',
+ 'autoResumeAudioContext',
+ 'dynCallLegacy',
+ 'getDynCaller',
+ 'dynCall',
+ 'runtimeKeepalivePush',
+ 'runtimeKeepalivePop',
+ 'callUserCallback',
+ 'maybeExit',
+ 'asmjsMangle',
+ 'HandleAllocator',
+ 'getNativeTypeSize',
+ 'STACK_SIZE',
+ 'STACK_ALIGN',
+ 'POINTER_SIZE',
+ 'ASSERTIONS',
+ 'getCFunc',
+ 'ccall',
+ 'cwrap',
+ 'uleb128Encode',
+ 'sigToWasmTypes',
+ 'generateFuncType',
+ 'convertJsFunctionToWasm',
+ 'getEmptyTableSlot',
+ 'updateTableMap',
+ 'getFunctionAddress',
+ 'addFunction',
+ 'removeFunction',
+ 'reallyNegative',
+ 'unSign',
+ 'strLen',
+ 'reSign',
+ 'formatString',
+ 'intArrayToString',
+ 'AsciiToString',
+ 'UTF16ToString',
+ 'stringToUTF16',
+ 'lengthBytesUTF16',
+ 'UTF32ToString',
+ 'stringToUTF32',
+ 'lengthBytesUTF32',
+ 'stringToNewUTF8',
+ 'writeArrayToMemory',
+ 'registerKeyEventCallback',
+ 'maybeCStringToJsString',
+ 'findEventTarget',
+ 'getBoundingClientRect',
+ 'fillMouseEventData',
+ 'registerMouseEventCallback',
+ 'registerWheelEventCallback',
+ 'registerUiEventCallback',
+ 'registerFocusEventCallback',
+ 'fillDeviceOrientationEventData',
+ 'registerDeviceOrientationEventCallback',
+ 'fillDeviceMotionEventData',
+ 'registerDeviceMotionEventCallback',
+ 'screenOrientation',
+ 'fillOrientationChangeEventData',
+ 'registerOrientationChangeEventCallback',
+ 'fillFullscreenChangeEventData',
+ 'registerFullscreenChangeEventCallback',
+ 'JSEvents_requestFullscreen',
+ 'JSEvents_resizeCanvasForFullscreen',
+ 'registerRestoreOldStyle',
+ 'hideEverythingExceptGivenElement',
+ 'restoreHiddenElements',
+ 'setLetterbox',
+ 'softFullscreenResizeWebGLRenderTarget',
+ 'doRequestFullscreen',
+ 'fillPointerlockChangeEventData',
+ 'registerPointerlockChangeEventCallback',
+ 'registerPointerlockErrorEventCallback',
+ 'requestPointerLock',
+ 'fillVisibilityChangeEventData',
+ 'registerVisibilityChangeEventCallback',
+ 'registerTouchEventCallback',
+ 'fillGamepadEventData',
+ 'registerGamepadEventCallback',
+ 'registerBeforeUnloadEventCallback',
+ 'fillBatteryEventData',
+ 'battery',
+ 'registerBatteryEventCallback',
+ 'setCanvasElementSize',
+ 'getCanvasElementSize',
+ 'jsStackTrace',
+ 'stackTrace',
+ 'checkWasiClock',
+ 'wasiRightsToMuslOFlags',
+ 'wasiOFlagsToMuslOFlags',
+ 'createDyncallWrapper',
+ 'safeSetTimeout',
+ 'setImmediateWrapped',
+ 'clearImmediateWrapped',
+ 'polyfillSetImmediate',
+ 'getPromise',
+ 'makePromise',
+ 'idsToPromises',
+ 'makePromiseCallback',
+ 'ExceptionInfo',
+ 'findMatchingCatch',
+ 'Browser_asyncPrepareDataCounter',
+ 'setMainLoop',
+ 'getSocketFromFD',
+ 'getSocketAddress',
+ 'FS_unlink',
+ 'FS_mkdirTree',
+ '_setNetworkCallback',
+ 'heapObjectForWebGLType',
+ 'toTypedArrayIndex',
+ 'webgl_enable_ANGLE_instanced_arrays',
+ 'webgl_enable_OES_vertex_array_object',
+ 'webgl_enable_WEBGL_draw_buffers',
+ 'webgl_enable_WEBGL_multi_draw',
+ 'emscriptenWebGLGet',
+ 'computeUnpackAlignedImageSize',
+ 'colorChannelsInGlTextureFormat',
+ 'emscriptenWebGLGetTexPixelData',
+ 'emscriptenWebGLGetUniform',
+ 'webglGetUniformLocation',
+ 'webglPrepareUniformLocationsBeforeFirstUse',
+ 'webglGetLeftBracePos',
+ 'emscriptenWebGLGetVertexAttrib',
+ '__glGetActiveAttribOrUniform',
+ 'writeGLArray',
+ 'registerWebGlEventCallback',
+ 'runAndAbortIfError',
+ 'ALLOC_NORMAL',
+ 'ALLOC_STACK',
+ 'allocate',
+ 'writeStringToMemory',
+ 'writeAsciiToMemory',
+ 'setErrNo',
+ 'demangle'
+];
+missingLibrarySymbols.forEach(missingLibrarySymbol);
+
+var unexportedSymbols = [
+ 'run',
+ 'addOnPreRun',
+ 'addOnInit',
+ 'addOnPreMain',
+ 'addOnExit',
+ 'addOnPostRun',
+ 'addRunDependency',
+ 'removeRunDependency',
+ 'FS_createFolder',
+ 'FS_createPath',
+ 'FS_createLazyFile',
+ 'FS_createLink',
+ 'FS_createDevice',
+ 'FS_readFile',
+ 'out',
+ 'err',
+ 'callMain',
+ 'abort',
+ 'wasmMemory',
+ 'wasmExports',
+ 'stackAlloc',
+ 'stackSave',
+ 'stackRestore',
+ 'getTempRet0',
+ 'setTempRet0',
+ 'writeStackCookie',
+ 'checkStackCookie',
+ 'convertI32PairToI53Checked',
+ 'ptrToString',
+ 'zeroMemory',
+ 'exitJS',
+ 'getHeapMax',
+ 'growMemory',
+ 'ENV',
+ 'MONTH_DAYS_REGULAR',
+ 'MONTH_DAYS_LEAP',
+ 'MONTH_DAYS_REGULAR_CUMULATIVE',
+ 'MONTH_DAYS_LEAP_CUMULATIVE',
+ 'isLeapYear',
+ 'ydayFromDate',
+ 'ERRNO_CODES',
+ 'ERRNO_MESSAGES',
+ 'DNS',
+ 'Protocols',
+ 'Sockets',
+ 'initRandomFill',
+ 'randomFill',
+ 'timers',
+ 'warnOnce',
+ 'UNWIND_CACHE',
+ 'readEmAsmArgsArray',
+ 'jstoi_s',
+ 'getExecutableName',
+ 'handleException',
+ 'keepRuntimeAlive',
+ 'asyncLoad',
+ 'alignMemory',
+ 'mmapAlloc',
+ 'wasmTable',
+ 'noExitRuntime',
+ 'freeTableIndexes',
+ 'functionsInTableMap',
+ 'setValue',
+ 'getValue',
+ 'PATH',
+ 'PATH_FS',
+ 'UTF8Decoder',
+ 'UTF8ArrayToString',
+ 'UTF8ToString',
+ 'stringToUTF8Array',
+ 'stringToUTF8',
+ 'lengthBytesUTF8',
+ 'intArrayFromString',
+ 'stringToAscii',
+ 'UTF16Decoder',
+ 'stringToUTF8OnStack',
+ 'JSEvents',
+ 'specialHTMLTargets',
+ 'findCanvasEventTarget',
+ 'currentFullscreenStrategy',
+ 'restoreOldWindowedStyle',
+ 'ExitStatus',
+ 'getEnvStrings',
+ 'doReadv',
+ 'doWritev',
+ 'promiseMap',
+ 'uncaughtExceptionCount',
+ 'exceptionLast',
+ 'exceptionCaught',
+ 'Browser',
+ 'getPreloadedImageData__data',
+ 'wget',
+ 'SYSCALLS',
+ 'preloadPlugins',
+ 'FS_createPreloadedFile',
+ 'FS_modeStringToFlags',
+ 'FS_getMode',
+ 'FS_stdin_getChar_buffer',
+ 'FS_stdin_getChar',
+ 'FS',
+ 'FS_createDataFile',
+ 'MEMFS',
+ 'TTY',
+ 'PIPEFS',
+ 'SOCKFS',
+ 'tempFixedLengthArray',
+ 'miniTempWebGLFloatBuffers',
+ 'miniTempWebGLIntBuffers',
+ 'GL',
+ 'AL',
+ 'GLUT',
+ 'EGL',
+ 'GLEW',
+ 'IDBStore',
+ 'SDL',
+ 'SDL_gfx',
+ 'allocateUTF8',
+ 'allocateUTF8OnStack'
+];
+unexportedSymbols.forEach(unexportedRuntimeSymbol);
+
+var calledRun;
+
+dependenciesFulfilled = function runCaller() {
+ // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false)
+ if (!calledRun) run();
+ if (!calledRun) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled
+};
+
+function callMain(args = []) {
+ assert(
+ runDependencies == 0,
+ 'cannot call main when async dependencies remain! (listen on Module["onRuntimeInitialized"])'
+ );
+ assert(
+ __ATPRERUN__.length == 0,
+ 'cannot call main when preRun functions remain to be called'
+ );
+
+ var entryFunction = _main;
+
+ args.unshift(thisProgram);
+
+ var argc = args.length;
+ var argv = stackAlloc((argc + 1) * 4);
+ var argv_ptr = argv;
+ args.forEach((arg) => {
+ HEAPU32[argv_ptr >> 2] = stringToUTF8OnStack(arg);
+ argv_ptr += 4;
+ });
+ HEAPU32[argv_ptr >> 2] = 0;
+
+ try {
+ var ret = entryFunction(argc, argv);
+
+ // if we're not running an evented main loop, it's time to exit
+ exitJS(ret, /* implicit = */ true);
+ return ret;
+ } catch (e) {
+ return handleException(e);
+ }
+}
+
+function stackCheckInit() {
+ // This is normally called automatically during __wasm_call_ctors but need to
+ // get these values before even running any of the ctors so we call it redundantly
+ // here.
+ _emscripten_stack_init();
+ // TODO(sbc): Move writeStackCookie to native to to avoid this.
+ writeStackCookie();
+}
+
+function run(args = arguments_) {
+ if (runDependencies > 0) {
+ return;
+ }
+
+ stackCheckInit();
+
+ preRun();
+
+ // a preRun added a dependency, run will be called later
+ if (runDependencies > 0) {
+ return;
+ }
+
+ function doRun() {
+ // run may have just been called through dependencies being fulfilled just in this very frame,
+ // or while the async setStatus time below was happening
+ if (calledRun) return;
+ calledRun = true;
+ Module['calledRun'] = true;
+
+ if (ABORT) return;
+
+ initRuntime();
+
+ preMain();
+
+ if (Module['onRuntimeInitialized']) Module['onRuntimeInitialized']();
+
+ if (shouldRunNow) callMain(args);
+
+ postRun();
+ }
+
+ if (Module['setStatus']) {
+ Module['setStatus']('Running...');
+ setTimeout(function () {
+ setTimeout(function () {
+ Module['setStatus']('');
+ }, 1);
+ doRun();
+ }, 1);
+ } else {
+ doRun();
+ }
+ checkStackCookie();
+}
+
+if (Module['preInit']) {
+ if (typeof Module['preInit'] == 'function')
+ Module['preInit'] = [Module['preInit']];
+ while (Module['preInit'].length > 0) {
+ Module['preInit'].pop()();
+ }
+}
+
+// shouldRunNow refers to calling main(), not run().
+var shouldRunNow = true;
+
+if (Module['noInitialRun']) shouldRunNow = false;
+
+run();
+
+var workerResponded = false,
+ workerCallbackId = -1;
+
+(function () {
+ var messageBuffer = null,
+ buffer = 0,
+ bufferSize = 0;
+
+ function flushMessages() {
+ if (!messageBuffer) return;
+ if (runtimeInitialized) {
+ var temp = messageBuffer;
+ messageBuffer = null;
+ temp.forEach(function (message) {
+ onmessage(message);
+ });
+ }
+ }
+
+ function messageResender() {
+ flushMessages();
+ if (messageBuffer) {
+ setTimeout(messageResender, 100); // still more to do
+ }
+ }
+
+ onmessage = (msg) => {
+ // if main has not yet been called (mem init file, other async things), buffer messages
+ if (!runtimeInitialized) {
+ if (!messageBuffer) {
+ messageBuffer = [];
+ setTimeout(messageResender, 100);
+ }
+ messageBuffer.push(msg);
+ return;
+ }
+ flushMessages();
+
+ var func = Module['_' + msg.data['funcName']];
+ if (!func) throw 'invalid worker function to call: ' + msg.data['funcName'];
+ var data = msg.data['data'];
+ if (data) {
+ if (!data.byteLength) data = new Uint8Array(data);
+ if (!buffer || bufferSize < data.length) {
+ if (buffer) _free(buffer);
+ bufferSize = data.length;
+ buffer = _malloc(data.length);
+ }
+ HEAPU8.set(data, buffer);
+ }
+
+ workerResponded = false;
+ workerCallbackId = msg.data['callbackId'];
+ if (data) {
+ func(buffer, data.length);
+ } else {
+ func(0, 0);
+ }
+ };
+})();
+
+// end include: postamble.js
diff --git a/src/lib/ghostscript/worker-init.ts b/src/lib/ghostscript/worker-init.ts
new file mode 100644
index 0000000..9fad88f
--- /dev/null
+++ b/src/lib/ghostscript/worker-init.ts
@@ -0,0 +1,41 @@
+export const COMPRESS_ACTION = 'compress-pdf';
+export const PROTECT_ACTION = 'protect-pdf';
+
+export async function compressWithGhostScript(dataStruct: {
+ psDataURL: string;
+}): Promise {
+ const worker = getWorker();
+ worker.postMessage({
+ data: { ...dataStruct, type: COMPRESS_ACTION },
+ target: 'wasm'
+ });
+ return getListener(worker);
+}
+
+export async function protectWithGhostScript(dataStruct: {
+ psDataURL: string;
+}): Promise {
+ const worker = getWorker();
+ worker.postMessage({
+ data: { ...dataStruct, type: PROTECT_ACTION },
+ target: 'wasm'
+ });
+ return getListener(worker);
+}
+
+const getListener = (worker: Worker): Promise => {
+ return new Promise((resolve, reject) => {
+ const listener = (e: MessageEvent) => {
+ resolve(e.data);
+ worker.removeEventListener('message', listener);
+ setTimeout(() => worker.terminate(), 0);
+ };
+ worker.addEventListener('message', listener);
+ });
+};
+
+const getWorker = () => {
+ return new Worker(new URL('./background-worker.js', import.meta.url), {
+ type: 'module'
+ });
+};
diff --git a/src/pages/tools-by-category/index.tsx b/src/pages/tools-by-category/index.tsx
index 33a0d9f..5549fde 100644
--- a/src/pages/tools-by-category/index.tsx
+++ b/src/pages/tools-by-category/index.tsx
@@ -1,8 +1,8 @@
-import { Box, Divider, Stack, useTheme } from '@mui/material';
+import { Box, Divider, Stack, TextField, useTheme } from '@mui/material';
import Grid from '@mui/material/Grid';
import Typography from '@mui/material/Typography';
import { Link, useNavigate, useParams } from 'react-router-dom';
-import { getToolsByCategory } from '../../tools';
+import { filterTools, getToolsByCategory } from '../../tools';
import Hero from 'components/Hero';
import { capitalizeFirstLetter } from '@utils/string';
import { Icon } from '@iconify/react';
@@ -12,12 +12,14 @@ import IconButton from '@mui/material/IconButton';
import { ArrowBack } from '@mui/icons-material';
import BackButton from '@components/BackButton';
import ArrowBackIcon from '@mui/icons-material/ArrowBack';
+import SearchIcon from '@mui/icons-material/Search';
-export default function Home() {
+export default function ToolsByCategory() {
const navigate = useNavigate();
const theme = useTheme();
const mainContentRef = React.useRef(null);
const { categoryName } = useParams();
+ const [searchTerm, setSearchTerm] = React.useState('');
useEffect(() => {
if (mainContentRef.current) {
@@ -39,61 +41,81 @@ export default function Home() {
-
- navigate('/')}>
-
-
- {`All ${capitalizeFirstLetter(categoryName)} Tools`}
+
+
+ navigate('/')}>
+
+
+ {`All ${
+ getToolsByCategory().find(
+ (category) => category.type === categoryName
+ )!.rawTitle
+ } Tools`}
+
+ ,
+ sx: {
+ borderRadius: 4,
+ backgroundColor: 'background.paper',
+ maxWidth: 400
+ }
+ }}
+ onChange={(event) => setSearchTerm(event.target.value)}
+ />
- {getToolsByCategory()
- .find(({ type }) => type === categoryName)
- ?.tools?.map((tool, index) => (
-
- navigate('/' + tool.path)}
- direction={'row'}
- alignItems={'center'}
- spacing={2}
- padding={2}
- border={`1px solid ${theme.palette.background.default}`}
- borderRadius={2}
- >
-
-
-
- {tool.name}
-
-
- {tool.shortDescription}
-
-
-
-
- ))}
+ {filterTools(
+ getToolsByCategory().find(({ type }) => type === categoryName)
+ ?.tools ?? [],
+ searchTerm
+ ).map((tool, index) => (
+
+ navigate('/' + tool.path)}
+ direction={'row'}
+ alignItems={'center'}
+ spacing={2}
+ padding={2}
+ border={`1px solid ${theme.palette.background.default}`}
+ borderRadius={2}
+ >
+
+
+
+ {tool.name}
+
+
+ {tool.shortDescription}
+
+
+
+
+ ))}
diff --git a/src/pages/tools/csv/swap-csv-columns/meta.ts b/src/pages/tools/csv/swap-csv-columns/meta.ts
index 50fd3bc..3a2f378 100644
--- a/src/pages/tools/csv/swap-csv-columns/meta.ts
+++ b/src/pages/tools/csv/swap-csv-columns/meta.ts
@@ -7,7 +7,7 @@ export const tool = defineTool('csv', {
icon: 'eva:swap-outline',
description:
'Just upload your CSV file in the form below, specify the columns to swap, and the tool will automatically change the positions of the specified columns in the output file. In the tool options, you can specify the column positions or names that you want to swap, as well as fix incomplete data and optionally remove empty records and records that have been commented out.',
- shortDescription: 'Convert CSV data to TSV format',
+ shortDescription: 'Reorder CSV columns',
longDescription:
'This tool reorganizes CSV data by swapping the positions of its columns. Swapping columns can enhance the readability of a CSV file by placing frequently used data together or in the front for easier data comparison and editing. For example, you can swap the first column with the last or swap the second column with the third. To swap columns based on their positions, select the "Set Column Position" mode and enter the numbers of the "from" and "to" columns to be swapped in the first and second blocks of options. For example, if you have a CSV file with four columns "1, 2, 3, 4" and swap columns with positions "2" and "4", the output CSV will have columns in the order: "1, 4, 3, 2".As an alternative to positions, you can swap columns by specifying their headers (column names on the first row of data). If you enable this mode in the options, then you can enter the column names like "location" and "city", and the program will swap these two columns. If any of the specified columns have incomplete data (some fields are missing), you can choose to skip such data or fill the missing fields with empty values or custom values (specified in the options). Additionally, you can specify the symbol used for comments in the CSV data, such as "#" or "//". If you do not need the commented lines in the output, you can remove them by using the "Delete Comments" checkbox. You can also activate the checkbox "Delete Empty Lines" to get rid of empty lines that contain no visible information. Csv-abulous!',
keywords: ['csv', 'swap', 'columns'],
diff --git a/src/pages/tools/image/png/change-colors-in-png/index.tsx b/src/pages/tools/image/generic/change-colors/index.tsx
similarity index 57%
rename from src/pages/tools/image/png/change-colors-in-png/index.tsx
rename to src/pages/tools/image/generic/change-colors/index.tsx
index 2916e1d..1eb5745 100644
--- a/src/pages/tools/image/png/change-colors-in-png/index.tsx
+++ b/src/pages/tools/image/generic/change-colors/index.tsx
@@ -6,10 +6,10 @@ import { GetGroupsType } from '@components/options/ToolOptions';
import ColorSelector from '@components/options/ColorSelector';
import Color from 'color';
import TextFieldWithDesc from 'components/options/TextFieldWithDesc';
-import { areColorsSimilar } from 'utils/color';
import ToolContent from '@components/ToolContent';
import { ToolComponentProps } from '@tools/defineTool';
import ToolImageInput from '@components/input/ToolImageInput';
+import { processImage } from './service';
const initialValues = {
fromColor: 'white',
@@ -19,7 +19,7 @@ const initialValues = {
const validationSchema = Yup.object({
// splitSeparator: Yup.string().required('The separator is required')
});
-export default function ChangeColorsInPng({ title }: ToolComponentProps) {
+export default function ChangeColorsInImage({ title }: ToolComponentProps) {
const [input, setInput] = useState(null);
const [result, setResult] = useState(null);
@@ -36,54 +36,10 @@ export default function ChangeColorsInPng({ title }: ToolComponentProps) {
} catch (err) {
return;
}
- const processImage = async (
- file: File,
- fromColor: [number, number, number],
- toColor: [number, number, number],
- similarity: number
- ) => {
- const canvas = document.createElement('canvas');
- const ctx = canvas.getContext('2d');
- if (ctx == null) return;
- const img = new Image();
- img.src = URL.createObjectURL(file);
- await img.decode();
-
- canvas.width = img.width;
- canvas.height = img.height;
- ctx.drawImage(img, 0, 0);
-
- const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
- const data: Uint8ClampedArray = imageData.data;
-
- for (let i = 0; i < data.length; i += 4) {
- const currentColor: [number, number, number] = [
- data[i],
- data[i + 1],
- data[i + 2]
- ];
- if (areColorsSimilar(currentColor, fromColor, similarity)) {
- data[i] = toColor[0]; // Red
- data[i + 1] = toColor[1]; // Green
- data[i + 2] = toColor[2]; // Blue
- }
- }
-
- ctx.putImageData(imageData, 0, 0);
-
- canvas.toBlob((blob) => {
- if (blob) {
- const newFile = new File([blob], file.name, {
- type: 'image/png'
- });
- setResult(newFile);
- }
- }, 'image/png');
- };
-
- processImage(input, fromRgb, toRgb, Number(similarity));
+ processImage(input, fromRgb, toRgb, Number(similarity), setResult);
};
+
const getGroups: GetGroupsType = ({
values,
updateField
@@ -127,22 +83,11 @@ export default function ChangeColorsInPng({ title }: ToolComponentProps) {
}
- resultComponent={
-
- }
- toolInfo={{
- title: 'Make Colors Transparent',
- description:
- 'This tool allows you to make specific colors in a PNG image transparent. You can select the color to replace and adjust the similarity threshold to include similar colors.'
- }}
+ resultComponent={}
/>
);
}
diff --git a/src/pages/tools/image/generic/change-colors/meta.ts b/src/pages/tools/image/generic/change-colors/meta.ts
new file mode 100644
index 0000000..287a327
--- /dev/null
+++ b/src/pages/tools/image/generic/change-colors/meta.ts
@@ -0,0 +1,13 @@
+import { defineTool } from '@tools/defineTool';
+import { lazy } from 'react';
+
+export const tool = defineTool('image-generic', {
+ name: 'Change colors in image',
+ path: 'change-colors',
+ icon: 'cil:color-fill',
+ description:
+ "World's simplest online Image color changer. Just import your image (JPG, PNG, SVG) in the editor on the left, select which colors to change, and you'll instantly get a new image with the new colors on the right. Free, quick, and very powerful. Import an image – replace its colors.",
+ shortDescription: 'Quickly swap colors in a image',
+ keywords: ['change', 'colors', 'in', 'png', 'image', 'jpg'],
+ component: lazy(() => import('./index'))
+});
diff --git a/src/pages/tools/image/generic/change-colors/service.ts b/src/pages/tools/image/generic/change-colors/service.ts
new file mode 100644
index 0000000..a35ed1d
--- /dev/null
+++ b/src/pages/tools/image/generic/change-colors/service.ts
@@ -0,0 +1,169 @@
+import { areColorsSimilar } from '@utils/color';
+
+export const processImage = async (
+ file: File,
+ fromColor: [number, number, number],
+ toColor: [number, number, number],
+ similarity: number,
+ setResult: (result: File | null) => void
+): Promise => {
+ if (file.type === 'image/svg+xml') {
+ const reader = new FileReader();
+ reader.onload = (e) => {
+ if (!e.target?.result) return;
+
+ let svgContent = e.target.result as string;
+ const toColorHex = rgbToHex(toColor[0], toColor[1], toColor[2]);
+
+ // Replace hex colors with various formats (#fff, #ffffff)
+ const hexRegexShort = new RegExp(`#[0-9a-f]{3}\\b`, 'gi');
+ const hexRegexLong = new RegExp(`#[0-9a-f]{6}\\b`, 'gi');
+
+ svgContent = svgContent.replace(hexRegexShort, (match) => {
+ // Expand short hex to full form for comparison
+ const expanded =
+ '#' + match[1] + match[1] + match[2] + match[2] + match[3] + match[3];
+ const matchRgb = hexToRgb(expanded);
+ if (matchRgb && areColorsSimilar(matchRgb, fromColor, similarity)) {
+ return toColorHex;
+ }
+ return match;
+ });
+
+ svgContent = svgContent.replace(hexRegexLong, (match) => {
+ const matchRgb = hexToRgb(match);
+ if (matchRgb && areColorsSimilar(matchRgb, fromColor, similarity)) {
+ return toColorHex;
+ }
+ return match;
+ });
+
+ // Replace RGB colors
+ const rgbRegex = new RegExp(
+ `rgb\\(\\s*(\\d+)\\s*,\\s*(\\d+)\\s*,\\s*(\\d+)\\s*\\)`,
+ 'gi'
+ );
+ svgContent = svgContent.replace(rgbRegex, (match, r, g, b) => {
+ const matchRgb: [number, number, number] = [
+ parseInt(r),
+ parseInt(g),
+ parseInt(b)
+ ];
+ if (areColorsSimilar(matchRgb, fromColor, similarity)) {
+ return `rgb(${toColor[0]}, ${toColor[1]}, ${toColor[2]})`;
+ }
+ return match;
+ });
+
+ // Replace RGBA colors (preserving alpha)
+ const rgbaRegex = new RegExp(
+ `rgba\\(\\s*(\\d+)\\s*,\\s*(\\d+)\\s*,\\s*(\\d+)\\s*,\\s*([\\d.]+)\\s*\\)`,
+ 'gi'
+ );
+ svgContent = svgContent.replace(rgbaRegex, (match, r, g, b, a) => {
+ const matchRgb: [number, number, number] = [
+ parseInt(r),
+ parseInt(g),
+ parseInt(b)
+ ];
+ if (areColorsSimilar(matchRgb, fromColor, similarity)) {
+ return `rgba(${toColor[0]}, ${toColor[1]}, ${toColor[2]}, ${a})`;
+ }
+ return match;
+ });
+
+ // Replace named SVG colors if they match our target color
+ const namedColors = {
+ red: [255, 0, 0],
+ green: [0, 128, 0],
+ blue: [0, 0, 255],
+ black: [0, 0, 0],
+ white: [255, 255, 255]
+ // Add more named colors as needed
+ };
+
+ Object.entries(namedColors).forEach(([name, rgb]) => {
+ if (
+ areColorsSimilar(
+ rgb as [number, number, number],
+ fromColor,
+ similarity
+ )
+ ) {
+ const colorRegex = new RegExp(`\\b${name}\\b`, 'gi');
+ svgContent = svgContent.replace(colorRegex, toColorHex);
+ }
+ });
+
+ // Create new file with modified content
+ const newFile = new File([svgContent], file.name, {
+ type: 'image/svg+xml'
+ });
+ setResult(newFile);
+ };
+ reader.readAsText(file);
+ return;
+ }
+ const canvas = document.createElement('canvas');
+ const ctx = canvas.getContext('2d');
+ if (ctx == null) return;
+ const img = new Image();
+
+ img.src = URL.createObjectURL(file);
+ await img.decode();
+
+ canvas.width = img.width;
+ canvas.height = img.height;
+ ctx.drawImage(img, 0, 0);
+
+ const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+ const data: Uint8ClampedArray = imageData.data;
+
+ for (let i = 0; i < data.length; i += 4) {
+ const currentColor: [number, number, number] = [
+ data[i],
+ data[i + 1],
+ data[i + 2]
+ ];
+ if (areColorsSimilar(currentColor, fromColor, similarity)) {
+ data[i] = toColor[0]; // Red
+ data[i + 1] = toColor[1]; // Green
+ data[i + 2] = toColor[2]; // Blue
+ }
+ }
+
+ ctx.putImageData(imageData, 0, 0);
+
+ canvas.toBlob((blob) => {
+ if (blob) {
+ const newFile = new File([blob], file.name, {
+ type: file.type
+ });
+ setResult(newFile);
+ }
+ }, file.type);
+};
+
+const rgbToHex = (r: number, g: number, b: number): string => {
+ return (
+ '#' +
+ [r, g, b]
+ .map((x) => {
+ const hex = x.toString(16);
+ return hex.length === 1 ? '0' + hex : hex;
+ })
+ .join('')
+ );
+};
+
+// Helper function to parse hex to RGB
+const hexToRgb = (hex: string): [number, number, number] | null => {
+ const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+ return result
+ ? [
+ parseInt(result[1], 16),
+ parseInt(result[2], 16),
+ parseInt(result[3], 16)
+ ]
+ : null;
+};
diff --git a/src/pages/tools/image/png/change-opacity/index.tsx b/src/pages/tools/image/generic/change-opacity/index.tsx
similarity index 96%
rename from src/pages/tools/image/png/change-opacity/index.tsx
rename to src/pages/tools/image/generic/change-opacity/index.tsx
index 8fc425d..5aaa995 100644
--- a/src/pages/tools/image/png/change-opacity/index.tsx
+++ b/src/pages/tools/image/generic/change-opacity/index.tsx
@@ -1,4 +1,4 @@
-import React, { useEffect, useState } from 'react';
+import React, { useState } from 'react';
import ToolImageInput from '@components/input/ToolImageInput';
import ToolFileResult from '@components/result/ToolFileResult';
import { changeOpacity } from './service';
@@ -97,16 +97,12 @@ export default function ChangeOpacity({ title }: ToolComponentProps) {
}
resultComponent={
-
+
}
initialValues={initialValues}
// exampleCards={exampleCards}
diff --git a/src/pages/tools/image/generic/change-opacity/meta.ts b/src/pages/tools/image/generic/change-opacity/meta.ts
new file mode 100644
index 0000000..81ef77f
--- /dev/null
+++ b/src/pages/tools/image/generic/change-opacity/meta.ts
@@ -0,0 +1,13 @@
+import { defineTool } from '@tools/defineTool';
+import { lazy } from 'react';
+
+export const tool = defineTool('image-generic', {
+ name: 'Change image Opacity',
+ path: 'change-opacity',
+ icon: 'material-symbols:opacity',
+ description:
+ 'Easily adjust the transparency of your images. Simply upload your image, use the slider to set the desired opacity level between 0 (fully transparent) and 1 (fully opaque), and download the modified image.',
+ shortDescription: 'Adjust transparency of images',
+ keywords: ['opacity', 'transparency', 'png', 'alpha', 'jpg', 'jpeg', 'image'],
+ component: lazy(() => import('./index'))
+});
diff --git a/src/pages/tools/image/png/change-opacity/service.ts b/src/pages/tools/image/generic/change-opacity/service.ts
similarity index 91%
rename from src/pages/tools/image/png/change-opacity/service.ts
rename to src/pages/tools/image/generic/change-opacity/service.ts
index bea3a73..efcecaf 100644
--- a/src/pages/tools/image/png/change-opacity/service.ts
+++ b/src/pages/tools/image/generic/change-opacity/service.ts
@@ -9,7 +9,10 @@ interface OpacityOptions {
areaHeight: number;
}
-export async function changeOpacity(file: File, options: OpacityOptions): Promise {
+export async function changeOpacity(
+ file: File,
+ options: OpacityOptions
+): Promise {
return new Promise((resolve, reject) => {
const reader = new FileReader();
reader.onload = (event) => {
@@ -32,12 +35,12 @@ export async function changeOpacity(file: File, options: OpacityOptions): Promis
canvas.toBlob((blob) => {
if (blob) {
- const newFile = new File([blob], file.name, { type: 'image/png' });
+ const newFile = new File([blob], file.name, { type: file.type });
resolve(newFile);
} else {
reject(new Error('Failed to generate image blob'));
}
- }, 'image/png');
+ }, file.type);
};
img.onerror = () => reject(new Error('Failed to load image'));
img.src = event.target?.result as string;
@@ -67,9 +70,10 @@ function applyGradientOpacity(
ctx.clearRect(0, 0, ctx.canvas.width, ctx.canvas.height);
ctx.drawImage(img, 0, 0);
- const gradient = options.gradientType === 'linear'
- ? createLinearGradient(ctx, options)
- : createRadialGradient(ctx, options);
+ const gradient =
+ options.gradientType === 'linear'
+ ? createLinearGradient(ctx, options)
+ : createRadialGradient(ctx, options);
ctx.fillStyle = gradient;
ctx.fillRect(areaLeft, areaTop, areaWidth, areaHeight);
diff --git a/src/pages/tools/image/generic/compress/index.tsx b/src/pages/tools/image/generic/compress/index.tsx
new file mode 100644
index 0000000..1fa537c
--- /dev/null
+++ b/src/pages/tools/image/generic/compress/index.tsx
@@ -0,0 +1,121 @@
+import React, { useContext, useState } from 'react';
+import { InitialValuesType } from './types';
+import { compressImage } from './service';
+import ToolContent from '@components/ToolContent';
+import ToolImageInput from '@components/input/ToolImageInput';
+import { ToolComponentProps } from '@tools/defineTool';
+import ToolFileResult from '@components/result/ToolFileResult';
+import TextFieldWithDesc from '@components/options/TextFieldWithDesc';
+import { Box } from '@mui/material';
+import Typography from '@mui/material/Typography';
+import { CustomSnackBarContext } from '../../../../../contexts/CustomSnackBarContext';
+import { updateNumberField } from '@utils/string';
+
+const initialValues: InitialValuesType = {
+ maxFileSizeInMB: 1.0,
+ quality: 80
+};
+
+export default function CompressImage({ title }: ToolComponentProps) {
+ const [input, setInput] = useState(null);
+ const [result, setResult] = useState(null);
+ const [isProcessing, setIsProcessing] = useState(false);
+ const [originalSize, setOriginalSize] = useState(null); // Store original file size
+ const [compressedSize, setCompressedSize] = useState(null); // Store compressed file size
+ const { showSnackBar } = useContext(CustomSnackBarContext);
+
+ const compute = async (values: InitialValuesType, input: File | null) => {
+ if (!input) return;
+
+ setOriginalSize(input.size);
+ try {
+ setIsProcessing(true);
+
+ const compressed = await compressImage(input, values);
+
+ if (compressed) {
+ setResult(compressed);
+ setCompressedSize(compressed.size);
+ } else {
+ showSnackBar('Failed to compress image. Please try again.', 'error');
+ }
+ } catch (err) {
+ console.error('Error in compression:', err);
+ } finally {
+ setIsProcessing(false);
+ }
+ };
+
+ return (
+
+ }
+ resultComponent={
+
+ }
+ initialValues={initialValues}
+ getGroups={({ values, updateField }) => [
+ {
+ title: 'Compression options',
+ component: (
+
+
+ updateNumberField(value, 'maxFileSizeInMB', updateField)
+ }
+ value={values.maxFileSizeInMB}
+ />
+
+ updateNumberField(value, 'quality', updateField)
+ }
+ value={values.quality}
+ />
+
+ )
+ },
+ {
+ title: 'File sizes',
+ component: (
+
+
+ {originalSize !== null && (
+
+ Original Size: {(originalSize / 1024).toFixed(2)} KB
+
+ )}
+ {compressedSize !== null && (
+
+ Compressed Size: {(compressedSize / 1024).toFixed(2)} KB
+
+ )}
+
+
+ )
+ }
+ ]}
+ compute={compute}
+ setInput={setInput}
+ />
+ );
+}
diff --git a/src/pages/tools/image/generic/compress/meta.ts b/src/pages/tools/image/generic/compress/meta.ts
new file mode 100644
index 0000000..fb34481
--- /dev/null
+++ b/src/pages/tools/image/generic/compress/meta.ts
@@ -0,0 +1,14 @@
+import { defineTool } from '@tools/defineTool';
+import { lazy } from 'react';
+
+export const tool = defineTool('image-generic', {
+ name: 'Compress Image',
+ path: 'compress',
+ component: lazy(() => import('./index')),
+ icon: 'material-symbols-light:compress-rounded',
+ description:
+ 'Compress images to reduce file size while maintaining reasonable quality.',
+ shortDescription:
+ 'Compress images to reduce file size while maintaining reasonable quality.',
+ keywords: ['image', 'compress', 'reduce', 'quality']
+});
diff --git a/src/pages/tools/image/generic/compress/service.ts b/src/pages/tools/image/generic/compress/service.ts
new file mode 100644
index 0000000..b1a6f80
--- /dev/null
+++ b/src/pages/tools/image/generic/compress/service.ts
@@ -0,0 +1,30 @@
+import { InitialValuesType } from './types';
+import imageCompression from 'browser-image-compression';
+
+export const compressImage = async (
+ file: File,
+ options: InitialValuesType
+): Promise => {
+ try {
+ const { maxFileSizeInMB, quality } = options;
+
+ // Configuration for the compression library
+ const compressionOptions = {
+ maxSizeMB: maxFileSizeInMB,
+ maxWidthOrHeight: 1920, // Reasonable default for most use cases
+ useWebWorker: true,
+ initialQuality: quality / 100 // Convert percentage to decimal
+ };
+
+ // Compress the image
+ const compressedFile = await imageCompression(file, compressionOptions);
+
+ // Create a new file with the original name
+ return new File([compressedFile], file.name, {
+ type: compressedFile.type
+ });
+ } catch (error) {
+ console.error('Error compressing image:', error);
+ return null;
+ }
+};
diff --git a/src/pages/tools/image/generic/compress/types.ts b/src/pages/tools/image/generic/compress/types.ts
new file mode 100644
index 0000000..15e8381
--- /dev/null
+++ b/src/pages/tools/image/generic/compress/types.ts
@@ -0,0 +1,4 @@
+export interface InitialValuesType {
+ maxFileSizeInMB: number;
+ quality: number;
+}
diff --git a/src/pages/tools/image/png/create-transparent/create-transparent.e2e.spec.ts b/src/pages/tools/image/generic/create-transparent/create-transparent.e2e.spec.ts
similarity index 95%
rename from src/pages/tools/image/png/create-transparent/create-transparent.e2e.spec.ts
rename to src/pages/tools/image/generic/create-transparent/create-transparent.e2e.spec.ts
index 9f8042a..364c0ae 100644
--- a/src/pages/tools/image/png/create-transparent/create-transparent.e2e.spec.ts
+++ b/src/pages/tools/image/generic/create-transparent/create-transparent.e2e.spec.ts
@@ -5,7 +5,7 @@ import Jimp from 'jimp';
test.describe('Create transparent PNG', () => {
test.beforeEach(async ({ page }) => {
- await page.goto('/png/create-transparent');
+ await page.goto('/image-generic/create-transparent');
});
//TODO check why failing
diff --git a/src/pages/tools/image/png/create-transparent/index.tsx b/src/pages/tools/image/generic/create-transparent/index.tsx
similarity index 94%
rename from src/pages/tools/image/png/create-transparent/index.tsx
rename to src/pages/tools/image/generic/create-transparent/index.tsx
index 45ed0b3..ce91a07 100644
--- a/src/pages/tools/image/png/create-transparent/index.tsx
+++ b/src/pages/tools/image/generic/create-transparent/index.tsx
@@ -112,8 +112,8 @@ export default function CreateTransparent({ title }: ToolComponentProps) {
}
resultComponent={
@@ -131,7 +131,7 @@ export default function CreateTransparent({ title }: ToolComponentProps) {
toolInfo={{
title: 'Create Transparent PNG',
description:
- 'This tool allows you to make specific colors in a PNG image transparent. You can select the color to replace and adjust the similarity threshold to include similar colors.'
+ 'This tool allows you to make specific colors in an image transparent. You can select the color to replace and adjust the similarity threshold to include similar colors.'
}}
/>
);
diff --git a/src/pages/tools/image/png/create-transparent/meta.ts b/src/pages/tools/image/generic/create-transparent/meta.ts
similarity index 53%
rename from src/pages/tools/image/png/create-transparent/meta.ts
rename to src/pages/tools/image/generic/create-transparent/meta.ts
index 3ee1a9a..d606dfb 100644
--- a/src/pages/tools/image/png/create-transparent/meta.ts
+++ b/src/pages/tools/image/generic/create-transparent/meta.ts
@@ -1,13 +1,13 @@
import { defineTool } from '@tools/defineTool';
import { lazy } from 'react';
-export const tool = defineTool('png', {
+export const tool = defineTool('image-generic', {
name: 'Create transparent PNG',
path: 'create-transparent',
icon: 'mdi:circle-transparent',
- shortDescription: 'Quickly make a PNG image transparent',
+ shortDescription: 'Quickly make an image transparent',
description:
- "World's simplest online Portable Network Graphics transparency maker. Just import your PNG image in the editor on the left and you will instantly get a transparent PNG on the right. Free, quick, and very powerful. Import a PNG – get a transparent PNG.",
+ "World's simplest online Portable Network Graphics transparency maker. Just import your image in the editor on the left and you will instantly get a transparent PNG on the right. Free, quick, and very powerful. Import an image – get a transparent PNG.",
keywords: ['create', 'transparent'],
component: lazy(() => import('./index'))
});
diff --git a/src/pages/tools/image/png/change-colors-in-png/test.png b/src/pages/tools/image/generic/create-transparent/test.png
similarity index 100%
rename from src/pages/tools/image/png/change-colors-in-png/test.png
rename to src/pages/tools/image/generic/create-transparent/test.png
diff --git a/src/pages/tools/image/png/crop/index.tsx b/src/pages/tools/image/generic/crop/index.tsx
similarity index 91%
rename from src/pages/tools/image/png/crop/index.tsx
rename to src/pages/tools/image/generic/crop/index.tsx
index 2b4ec22..5f07eb5 100644
--- a/src/pages/tools/image/png/crop/index.tsx
+++ b/src/pages/tools/image/generic/crop/index.tsx
@@ -32,7 +32,7 @@ const validationSchema = Yup.object({
.required('Height is required')
});
-export default function CropPng({ title }: ToolComponentProps) {
+export default function CropImage({ title }: ToolComponentProps) {
const [input, setInput] = useState(null);
const [result, setResult] = useState(null);
@@ -101,11 +101,11 @@ export default function CropPng({ title }: ToolComponentProps) {
destCanvas.toBlob((blob) => {
if (blob) {
const newFile = new File([blob], file.name, {
- type: 'image/png'
+ type: file.type
});
setResult(newFile);
}
- }, 'image/png');
+ }, file.type);
};
processImage(input, x, y, width, height, isCircular);
@@ -180,13 +180,13 @@ export default function CropPng({ title }: ToolComponentProps) {
updateField('cropShape', 'rectangular')}
checked={values.cropShape == 'rectangular'}
- description={'Crop a rectangular fragment from a PNG.'}
+ description={'Crop a rectangular fragment from an image.'}
title={'Rectangular Crop Shape'}
/>
updateField('cropShape', 'circular')}
checked={values.cropShape == 'circular'}
- description={'Crop a circular fragment from a PNG.'}
+ description={'Crop a circular fragment from an image.'}
title={'Circular Crop Shape'}
/>
@@ -200,8 +200,8 @@ export default function CropPng({ title }: ToolComponentProps) {
+
}
toolInfo={{
- title: 'Crop PNG Image',
+ title: 'Crop Image',
description:
- 'This tool allows you to crop a PNG image by specifying the position, size, and shape of the crop area. You can choose between rectangular or circular cropping.'
+ 'This tool allows you to crop an image by specifying the position, size, and shape of the crop area. You can choose between rectangular or circular cropping.'
}}
/>
);
diff --git a/src/pages/tools/image/png/crop/meta.ts b/src/pages/tools/image/generic/crop/meta.ts
similarity index 88%
rename from src/pages/tools/image/png/crop/meta.ts
rename to src/pages/tools/image/generic/crop/meta.ts
index d10b27b..897eeeb 100644
--- a/src/pages/tools/image/png/crop/meta.ts
+++ b/src/pages/tools/image/generic/crop/meta.ts
@@ -1,7 +1,7 @@
import { defineTool } from '@tools/defineTool';
import { lazy } from 'react';
-export const tool = defineTool('png', {
+export const tool = defineTool('image-generic', {
name: 'Crop',
path: 'crop',
icon: 'mdi:crop', // Iconify icon as a string
diff --git a/src/pages/tools/image/generic/image-to-text/index.tsx b/src/pages/tools/image/generic/image-to-text/index.tsx
new file mode 100644
index 0000000..a56917e
--- /dev/null
+++ b/src/pages/tools/image/generic/image-to-text/index.tsx
@@ -0,0 +1,108 @@
+import { Box } from '@mui/material';
+import React, { useContext, useState } from 'react';
+import * as Yup from 'yup';
+import ToolImageInput from '@components/input/ToolImageInput';
+import ToolTextResult from '@components/result/ToolTextResult';
+import { GetGroupsType } from '@components/options/ToolOptions';
+import ToolContent from '@components/ToolContent';
+import { ToolComponentProps } from '@tools/defineTool';
+import SelectWithDesc from '@components/options/SelectWithDesc';
+import CheckboxWithDesc from '@components/options/CheckboxWithDesc';
+import CircularProgress from '@mui/material/CircularProgress';
+import { extractTextFromImage, getAvailableLanguages } from './service';
+import { InitialValuesType } from './types';
+import { CustomSnackBarContext } from '../../../../../contexts/CustomSnackBarContext';
+
+const initialValues: InitialValuesType = {
+ language: 'eng',
+ detectParagraphs: true
+};
+
+const validationSchema = Yup.object({
+ language: Yup.string().required('Language is required')
+});
+
+export default function ImageToText({ title }: ToolComponentProps) {
+ const [input, setInput] = useState(null);
+ const [result, setResult] = useState('');
+ const [isProcessing, setIsProcessing] = useState(false);
+ const { showSnackBar } = useContext(CustomSnackBarContext);
+ const compute = async (optionsValues: InitialValuesType, input: any) => {
+ if (!input) return;
+
+ setIsProcessing(true);
+
+ try {
+ const extractedText = await extractTextFromImage(input, optionsValues);
+ setResult(extractedText);
+ } catch (err: any) {
+ showSnackBar(
+ err.message || 'An error occurred while processing the image',
+ 'error'
+ );
+ setResult('');
+ } finally {
+ setIsProcessing(false);
+ }
+ };
+
+ const getGroups: GetGroupsType = ({
+ values,
+ updateField
+ }) => [
+ {
+ title: 'OCR Options',
+ component: (
+
+ updateField('language', val)}
+ description={
+ 'Select the primary language in the image for better accuracy'
+ }
+ options={getAvailableLanguages()}
+ />
+ updateField('detectParagraphs', value)}
+ description={
+ 'Attempt to preserve paragraph structure in the extracted text'
+ }
+ title={'Detect Paragraphs'}
+ />
+
+ )
+ }
+ ];
+
+ return (
+
+ }
+ resultComponent={
+
+ }
+ toolInfo={{
+ title: 'Image to Text (OCR)',
+ description:
+ 'This tool extracts text from images using Optical Character Recognition (OCR). Upload an image containing text, select the primary language, and get the extracted text. For best results, use clear images with good contrast.'
+ }}
+ />
+ );
+}
diff --git a/src/pages/tools/image/generic/image-to-text/meta.ts b/src/pages/tools/image/generic/image-to-text/meta.ts
new file mode 100644
index 0000000..d35c89d
--- /dev/null
+++ b/src/pages/tools/image/generic/image-to-text/meta.ts
@@ -0,0 +1,22 @@
+import { defineTool } from '@tools/defineTool';
+import { lazy } from 'react';
+
+export const tool = defineTool('image-generic', {
+ name: 'Image to Text (OCR)',
+ path: 'image-to-text',
+ icon: 'mdi:text-recognition', // Iconify icon as a string
+ description:
+ 'Extract text from images (JPG, PNG) using optical character recognition (OCR).',
+ shortDescription: 'Extract text from images using OCR.',
+ keywords: [
+ 'ocr',
+ 'optical character recognition',
+ 'image to text',
+ 'extract text',
+ 'scan',
+ 'tesseract',
+ 'jpg',
+ 'png'
+ ],
+ component: lazy(() => import('./index'))
+});
diff --git a/src/pages/tools/image/generic/image-to-text/service.ts b/src/pages/tools/image/generic/image-to-text/service.ts
new file mode 100644
index 0000000..79d3333
--- /dev/null
+++ b/src/pages/tools/image/generic/image-to-text/service.ts
@@ -0,0 +1,56 @@
+import { createWorker } from 'tesseract.js';
+import { InitialValuesType } from './types';
+
+export const extractTextFromImage = async (
+ file: File,
+ options: InitialValuesType
+): Promise => {
+ try {
+ const { language, detectParagraphs } = options;
+
+ // Create a Tesseract worker
+ const worker = await createWorker(language);
+
+ // Convert file to URL
+ const imageUrl = URL.createObjectURL(file);
+
+ // Recognize text
+ const { data } = await worker.recognize(imageUrl);
+
+ // Clean up
+ URL.revokeObjectURL(imageUrl);
+ await worker.terminate();
+
+ // Process the result based on options
+ if (detectParagraphs) {
+ // Return text with paragraph structure preserved
+ return data.text;
+ } else {
+ // Return plain text with basic formatting
+ return data.text;
+ }
+ } catch (error) {
+ console.error('Error extracting text from image:', error);
+ throw new Error(
+ 'Failed to extract text from image. Please try again with a clearer image.'
+ );
+ }
+};
+
+// Helper function to get available languages
+export const getAvailableLanguages = (): { value: string; label: string }[] => {
+ return [
+ { value: 'eng', label: 'English' },
+ { value: 'fra', label: 'French' },
+ { value: 'deu', label: 'German' },
+ { value: 'spa', label: 'Spanish' },
+ { value: 'ita', label: 'Italian' },
+ { value: 'por', label: 'Portuguese' },
+ { value: 'rus', label: 'Russian' },
+ { value: 'jpn', label: 'Japanese' },
+ { value: 'chi_sim', label: 'Chinese (Simplified)' },
+ { value: 'chi_tra', label: 'Chinese (Traditional)' },
+ { value: 'kor', label: 'Korean' },
+ { value: 'ara', label: 'Arabic' }
+ ];
+};
diff --git a/src/pages/tools/image/generic/image-to-text/types.ts b/src/pages/tools/image/generic/image-to-text/types.ts
new file mode 100644
index 0000000..d9db33d
--- /dev/null
+++ b/src/pages/tools/image/generic/image-to-text/types.ts
@@ -0,0 +1,4 @@
+export type InitialValuesType = {
+ language: string;
+ detectParagraphs: boolean;
+};
diff --git a/src/pages/tools/image/generic/index.ts b/src/pages/tools/image/generic/index.ts
new file mode 100644
index 0000000..fc18106
--- /dev/null
+++ b/src/pages/tools/image/generic/index.ts
@@ -0,0 +1,19 @@
+import { tool as resizeImage } from './resize/meta';
+import { tool as compressImage } from './compress/meta';
+import { tool as changeColors } from './change-colors/meta';
+import { tool as removeBackground } from './remove-background/meta';
+import { tool as cropImage } from './crop/meta';
+import { tool as changeOpacity } from './change-opacity/meta';
+import { tool as createTransparent } from './create-transparent/meta';
+import { tool as imageToText } from './image-to-text/meta';
+
+export const imageGenericTools = [
+ resizeImage,
+ compressImage,
+ removeBackground,
+ cropImage,
+ changeOpacity,
+ changeColors,
+ createTransparent,
+ imageToText
+];
diff --git a/src/pages/tools/image/png/remove-background/index.tsx b/src/pages/tools/image/generic/remove-background/index.tsx
similarity index 90%
rename from src/pages/tools/image/png/remove-background/index.tsx
rename to src/pages/tools/image/generic/remove-background/index.tsx
index 96115db..8c70633 100644
--- a/src/pages/tools/image/png/remove-background/index.tsx
+++ b/src/pages/tools/image/generic/remove-background/index.tsx
@@ -1,4 +1,3 @@
-import { Box, CircularProgress, Typography } from '@mui/material';
import React, { useState } from 'react';
import * as Yup from 'yup';
import ToolFileResult from '@components/result/ToolFileResult';
@@ -11,7 +10,9 @@ const initialValues = {};
const validationSchema = Yup.object({});
-export default function RemoveBackgroundFromPng({ title }: ToolComponentProps) {
+export default function RemoveBackgroundFromImage({
+ title
+}: ToolComponentProps) {
const [input, setInput] = useState(null);
const [result, setResult] = useState(null);
const [isProcessing, setIsProcessing] = useState(false);
@@ -64,7 +65,7 @@ export default function RemoveBackgroundFromPng({ title }: ToolComponentProps) {
}
@@ -78,7 +79,7 @@ export default function RemoveBackgroundFromPng({ title }: ToolComponentProps) {
/>
}
toolInfo={{
- title: 'Remove Background from PNG',
+ title: 'Remove Background from Image',
description:
'This tool uses AI to automatically remove the background from your images, creating a transparent PNG. Perfect for product photos, profile pictures, and design assets.'
}}
diff --git a/src/pages/tools/image/generic/remove-background/meta.ts b/src/pages/tools/image/generic/remove-background/meta.ts
new file mode 100644
index 0000000..fe13bbd
--- /dev/null
+++ b/src/pages/tools/image/generic/remove-background/meta.ts
@@ -0,0 +1,21 @@
+import { defineTool } from '@tools/defineTool';
+import { lazy } from 'react';
+
+export const tool = defineTool('image-generic', {
+ name: 'Remove Background from Image',
+ path: 'remove-background',
+ icon: 'mdi:image-remove',
+ description:
+ "World's simplest online tool to remove backgrounds from images. Just upload your image and our AI-powered tool will automatically remove the background, giving you a transparent PNG. Perfect for product photos, profile pictures, and design assets.",
+ shortDescription: 'Automatically remove backgrounds from images',
+ keywords: [
+ 'remove',
+ 'background',
+ 'png',
+ 'transparent',
+ 'image',
+ 'ai',
+ 'jpg'
+ ],
+ component: lazy(() => import('./index'))
+});
diff --git a/src/pages/tools/image/generic/resize/index.tsx b/src/pages/tools/image/generic/resize/index.tsx
new file mode 100644
index 0000000..f3df9f5
--- /dev/null
+++ b/src/pages/tools/image/generic/resize/index.tsx
@@ -0,0 +1,203 @@
+import { Box } from '@mui/material';
+import React, { useState } from 'react';
+import * as Yup from 'yup';
+import ToolImageInput from '@components/input/ToolImageInput';
+import ToolFileResult from '@components/result/ToolFileResult';
+import { GetGroupsType } from '@components/options/ToolOptions';
+import TextFieldWithDesc from '@components/options/TextFieldWithDesc';
+import ToolContent from '@components/ToolContent';
+import { ToolComponentProps } from '@tools/defineTool';
+import SimpleRadio from '@components/options/SimpleRadio';
+import CheckboxWithDesc from '@components/options/CheckboxWithDesc';
+import { processImage } from './service';
+import { InitialValuesType } from './types';
+
+const initialValues: InitialValuesType = {
+ resizeMethod: 'pixels' as 'pixels' | 'percentage',
+ dimensionType: 'width' as 'width' | 'height',
+ width: '800',
+ height: '600',
+ percentage: '50',
+ maintainAspectRatio: true
+};
+
+const validationSchema = Yup.object({
+ width: Yup.number().when('resizeMethod', {
+ is: 'pixels',
+ then: (schema) =>
+ schema.min(1, 'Width must be at least 1px').required('Width is required')
+ }),
+ height: Yup.number().when('resizeMethod', {
+ is: 'pixels',
+ then: (schema) =>
+ schema
+ .min(1, 'Height must be at least 1px')
+ .required('Height is required')
+ }),
+ percentage: Yup.number().when('resizeMethod', {
+ is: 'percentage',
+ then: (schema) =>
+ schema
+ .min(1, 'Percentage must be at least 1%')
+ .max(1000, 'Percentage must be at most 1000%')
+ .required('Percentage is required')
+ })
+});
+
+export default function ResizeImage({ title }: ToolComponentProps) {
+ const [input, setInput] = useState(null);
+ const [result, setResult] = useState(null);
+
+ const compute = async (optionsValues: InitialValuesType, input: any) => {
+ if (!input) return;
+ setResult(await processImage(input, optionsValues));
+ };
+
+ const getGroups: GetGroupsType = ({
+ values,
+ updateField
+ }) => [
+ {
+ title: 'Resize Method',
+ component: (
+
+ updateField('resizeMethod', 'pixels')}
+ checked={values.resizeMethod === 'pixels'}
+ description={'Resize by specifying dimensions in pixels.'}
+ title={'Resize by Pixels'}
+ />
+ updateField('resizeMethod', 'percentage')}
+ checked={values.resizeMethod === 'percentage'}
+ description={
+ 'Resize by specifying a percentage of the original size.'
+ }
+ title={'Resize by Percentage'}
+ />
+
+ )
+ },
+ ...(values.resizeMethod === 'pixels'
+ ? [
+ {
+ title: 'Dimension Type',
+ component: (
+
+
+ updateField('maintainAspectRatio', value)
+ }
+ description={
+ 'Maintain the original aspect ratio of the image.'
+ }
+ title={'Maintain Aspect Ratio'}
+ />
+ {values.maintainAspectRatio && (
+
+ updateField('dimensionType', 'width')}
+ checked={values.dimensionType === 'width'}
+ description={
+ 'Specify the width in pixels and calculate height based on aspect ratio.'
+ }
+ title={'Set Width'}
+ />
+ updateField('dimensionType', 'height')}
+ checked={values.dimensionType === 'height'}
+ description={
+ 'Specify the height in pixels and calculate width based on aspect ratio.'
+ }
+ title={'Set Height'}
+ />
+
+ )}
+ updateField('width', val)}
+ description={'Width (in pixels)'}
+ disabled={
+ values.maintainAspectRatio &&
+ values.dimensionType === 'height'
+ }
+ inputProps={{
+ 'data-testid': 'width-input',
+ type: 'number',
+ min: 1
+ }}
+ />
+ updateField('height', val)}
+ description={'Height (in pixels)'}
+ disabled={
+ values.maintainAspectRatio &&
+ values.dimensionType === 'width'
+ }
+ inputProps={{
+ 'data-testid': 'height-input',
+ type: 'number',
+ min: 1
+ }}
+ />
+
+ )
+ }
+ ]
+ : [
+ {
+ title: 'Percentage',
+ component: (
+
+ updateField('percentage', val)}
+ description={
+ 'Percentage of original size (e.g., 50 for half size, 200 for double size)'
+ }
+ inputProps={{
+ 'data-testid': 'percentage-input',
+ type: 'number',
+ min: 1,
+ max: 1000
+ }}
+ />
+
+ )
+ }
+ ])
+ ];
+
+ return (
+
+ }
+ resultComponent={
+
+ }
+ toolInfo={{
+ title: 'Resize Image',
+ description:
+ 'This tool allows you to resize JPG, PNG, SVG, or GIF images. You can resize by specifying dimensions in pixels or by percentage, with options to maintain the original aspect ratio.'
+ }}
+ />
+ );
+}
diff --git a/src/pages/tools/image/generic/resize/meta.ts b/src/pages/tools/image/generic/resize/meta.ts
new file mode 100644
index 0000000..8be266a
--- /dev/null
+++ b/src/pages/tools/image/generic/resize/meta.ts
@@ -0,0 +1,22 @@
+import { defineTool } from '@tools/defineTool';
+import { lazy } from 'react';
+
+export const tool = defineTool('image-generic', {
+ name: 'Resize Image',
+ path: 'resize',
+ icon: 'mdi:resize', // Iconify icon as a string
+ description:
+ 'Resize JPG, PNG, SVG or GIF images by pixels or percentage while maintaining aspect ratio or not.',
+ shortDescription: 'Resize images easily.',
+ keywords: [
+ 'resize',
+ 'image',
+ 'scale',
+ 'jpg',
+ 'png',
+ 'svg',
+ 'gif',
+ 'dimensions'
+ ],
+ component: lazy(() => import('./index'))
+});
diff --git a/src/pages/tools/image/generic/resize/service.ts b/src/pages/tools/image/generic/resize/service.ts
new file mode 100644
index 0000000..00f4f7a
--- /dev/null
+++ b/src/pages/tools/image/generic/resize/service.ts
@@ -0,0 +1,218 @@
+import { InitialValuesType } from './types';
+import { FFmpeg } from '@ffmpeg/ffmpeg';
+import { fetchFile, toBlobURL } from '@ffmpeg/util';
+
+export const processImage = async (
+ file: File,
+ options: InitialValuesType
+): Promise => {
+ const {
+ width,
+ height,
+ resizeMethod,
+ percentage,
+ dimensionType,
+ maintainAspectRatio
+ } = options;
+ if (file.type === 'image/svg+xml') {
+ try {
+ // Read the SVG file
+ const fileText = await file.text();
+ const parser = new DOMParser();
+ const svgDoc = parser.parseFromString(fileText, 'image/svg+xml');
+ const svgElement = svgDoc.documentElement;
+
+ // Get original dimensions
+ const viewBox = svgElement.getAttribute('viewBox');
+ let originalWidth: string | number | null =
+ svgElement.getAttribute('width');
+ let originalHeight: string | number | null =
+ svgElement.getAttribute('height');
+
+ // Parse viewBox if available and width/height are not explicitly set
+ let viewBoxValues = null;
+ if (viewBox) {
+ viewBoxValues = viewBox.split(' ').map(Number);
+ }
+
+ // Determine original dimensions from viewBox if not explicitly set
+ if (!originalWidth && viewBoxValues && viewBoxValues.length === 4) {
+ originalWidth = String(viewBoxValues[2]);
+ }
+ if (!originalHeight && viewBoxValues && viewBoxValues.length === 4) {
+ originalHeight = String(viewBoxValues[3]);
+ }
+
+ // Default dimensions if still not available
+ originalWidth = originalWidth ? parseFloat(originalWidth) : 300;
+ originalHeight = originalHeight ? parseFloat(originalHeight) : 150;
+
+ // Calculate new dimensions
+ let newWidth = originalWidth;
+ let newHeight = originalHeight;
+
+ if (resizeMethod === 'pixels') {
+ if (dimensionType === 'width') {
+ newWidth = parseInt(width);
+ if (maintainAspectRatio) {
+ newHeight = Math.round((newWidth / originalWidth) * originalHeight);
+ } else {
+ newHeight = parseInt(height);
+ }
+ } else {
+ // height
+ newHeight = parseInt(height);
+ if (maintainAspectRatio) {
+ newWidth = Math.round((newHeight / originalHeight) * originalWidth);
+ } else {
+ newWidth = parseInt(width);
+ }
+ }
+ } else {
+ // percentage
+ const scale = parseInt(percentage) / 100;
+ newWidth = Math.round(originalWidth * scale);
+ newHeight = Math.round(originalHeight * scale);
+ }
+
+ // Update SVG attributes
+ svgElement.setAttribute('width', String(newWidth));
+ svgElement.setAttribute('height', String(newHeight));
+
+ // If viewBox isn't already set, add it to preserve scaling
+ if (!viewBox) {
+ svgElement.setAttribute(
+ 'viewBox',
+ `0 0 ${originalWidth} ${originalHeight}`
+ );
+ }
+
+ // Serialize the modified SVG document
+ const serializer = new XMLSerializer();
+ const svgString = serializer.serializeToString(svgDoc);
+
+ // Create a new file
+ return new File([svgString], file.name, {
+ type: 'image/svg+xml'
+ });
+ } catch (error) {
+ console.error('Error processing SVG:', error);
+ // Fall back to canvas method if SVG processing fails
+ }
+ } else if (file.type === 'image/gif') {
+ try {
+ const ffmpeg = new FFmpeg();
+
+ await ffmpeg.load({
+ wasmURL:
+ 'https://cdn.jsdelivr.net/npm/@ffmpeg/core@0.12.9/dist/esm/ffmpeg-core.wasm'
+ });
+
+ // Write the input file to memory
+ await ffmpeg.writeFile('input.gif', await fetchFile(file));
+
+ // Calculate new dimensions
+ let newWidth = 0;
+ let newHeight = 0;
+ let scaleFilter = '';
+
+ if (resizeMethod === 'pixels') {
+ if (dimensionType === 'width') {
+ newWidth = parseInt(width);
+ if (maintainAspectRatio) {
+ scaleFilter = `scale=${newWidth}:-1`;
+ } else {
+ newHeight = parseInt(height);
+ scaleFilter = `scale=${newWidth}:${newHeight}`;
+ }
+ } else {
+ // height
+ newHeight = parseInt(height);
+ if (maintainAspectRatio) {
+ scaleFilter = `scale=-1:${newHeight}`;
+ } else {
+ newWidth = parseInt(width);
+ scaleFilter = `scale=${newWidth}:${newHeight}`;
+ }
+ }
+ } else {
+ // percentage
+ const scale = parseInt(percentage) / 100;
+ scaleFilter = `scale=iw*${scale}:ih*${scale}`;
+ }
+
+ // Run FFmpeg command
+ await ffmpeg.exec(['-i', 'input.gif', '-vf', scaleFilter, 'output.gif']);
+
+ // Read the output file
+ const data = await ffmpeg.readFile('output.gif');
+
+ // Create a new File object
+ return new File([data], file.name, { type: 'image/gif' });
+ } catch (error) {
+ console.error('Error processing GIF with FFmpeg:', error);
+ // Fall back to canvas method if FFmpeg processing fails
+ }
+ }
+ // Create canvas
+ const canvas = document.createElement('canvas');
+ const ctx = canvas.getContext('2d');
+ if (ctx == null) return null;
+
+ // Load image
+ const img = new Image();
+ img.src = URL.createObjectURL(file);
+ await img.decode();
+
+ // Calculate new dimensions
+ let newWidth = img.width;
+ let newHeight = img.height;
+
+ if (resizeMethod === 'pixels') {
+ if (dimensionType === 'width') {
+ newWidth = parseInt(width);
+ if (maintainAspectRatio) {
+ newHeight = Math.round((newWidth / img.width) * img.height);
+ } else {
+ newHeight = parseInt(height);
+ }
+ } else {
+ // height
+ newHeight = parseInt(height);
+ if (maintainAspectRatio) {
+ newWidth = Math.round((newHeight / img.height) * img.width);
+ } else {
+ newWidth = parseInt(width);
+ }
+ }
+ } else {
+ // percentage
+ const scale = parseInt(percentage) / 100;
+ newWidth = Math.round(img.width * scale);
+ newHeight = Math.round(img.height * scale);
+ }
+
+ // Set canvas dimensions
+ canvas.width = newWidth;
+ canvas.height = newHeight;
+
+ // Draw resized image
+ ctx.drawImage(img, 0, 0, newWidth, newHeight);
+
+ // Determine output type based on input file
+ let outputType = 'image/png';
+ if (file.type) {
+ outputType = file.type;
+ }
+
+ // Convert canvas to blob and create file
+ return new Promise((resolve) => {
+ canvas.toBlob((blob) => {
+ if (blob) {
+ resolve(new File([blob], file.name, { type: outputType }));
+ } else {
+ resolve(null);
+ }
+ }, outputType);
+ });
+};
diff --git a/src/pages/tools/image/generic/resize/types.ts b/src/pages/tools/image/generic/resize/types.ts
new file mode 100644
index 0000000..fe7595e
--- /dev/null
+++ b/src/pages/tools/image/generic/resize/types.ts
@@ -0,0 +1,8 @@
+export type InitialValuesType = {
+ resizeMethod: 'pixels' | 'percentage';
+ dimensionType: 'width' | 'height';
+ width: string;
+ height: string;
+ percentage: string;
+ maintainAspectRatio: boolean;
+};
diff --git a/src/pages/tools/image/index.ts b/src/pages/tools/image/index.ts
index db1cb6b..8ede982 100644
--- a/src/pages/tools/image/index.ts
+++ b/src/pages/tools/image/index.ts
@@ -1,3 +1,4 @@
import { pngTools } from './png';
+import { imageGenericTools } from './generic';
-export const imageTools = [...pngTools];
+export const imageTools = [...imageGenericTools, ...pngTools];
diff --git a/src/pages/tools/image/png/change-colors-in-png/change-colors-in-png.e2e.spec.ts b/src/pages/tools/image/png/change-colors-in-png/change-colors-in-png.e2e.spec.ts
deleted file mode 100644
index 2fb228a..0000000
--- a/src/pages/tools/image/png/change-colors-in-png/change-colors-in-png.e2e.spec.ts
+++ /dev/null
@@ -1,43 +0,0 @@
-import { expect, test } from '@playwright/test';
-import { Buffer } from 'buffer';
-import path from 'path';
-import Jimp from 'jimp';
-import { convertHexToRGBA } from '@utils/color';
-
-test.describe('Change colors in png', () => {
- test.beforeEach(async ({ page }) => {
- await page.goto('/png/change-colors-in-png');
- });
-
- // test('should change pixel color', async ({ page }) => {
- // // Upload image
- // const fileInput = page.locator('input[type="file"]');
- // const imagePath = path.join(__dirname, 'test.png');
- // await fileInput?.setInputFiles(imagePath);
- //
- // await page.getByTestId('from-color-input').fill('#FF0000');
- // const toColor = '#0000FF';
- // await page.getByTestId('to-color-input').fill(toColor);
- //
- // // Click on download
- // const downloadPromise = page.waitForEvent('download');
- // await page.getByText('Save as').click();
- //
- // // Intercept and read downloaded PNG
- // const download = await downloadPromise;
- // const downloadStream = await download.createReadStream();
- //
- // const chunks = [];
- // for await (const chunk of downloadStream) {
- // chunks.push(chunk);
- // }
- // const fileContent = Buffer.concat(chunks);
- //
- // expect(fileContent.length).toBeGreaterThan(0);
- //
- // // Check that the first pixel is transparent
- // const image = await Jimp.read(fileContent);
- // const color = image.getPixelColor(0, 0);
- // expect(color).toBe(convertHexToRGBA(toColor));
- // });
-});
diff --git a/src/pages/tools/image/png/change-colors-in-png/meta.ts b/src/pages/tools/image/png/change-colors-in-png/meta.ts
deleted file mode 100644
index d2e92ef..0000000
--- a/src/pages/tools/image/png/change-colors-in-png/meta.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-import { defineTool } from '@tools/defineTool';
-import { lazy } from 'react';
-
-export const tool = defineTool('png', {
- name: 'Change colors in png',
- path: 'change-colors-in-png',
- icon: 'cil:color-fill',
- description:
- "World's simplest online Portable Network Graphics (PNG) color changer. Just import your PNG image in the editor on the left, select which colors to change, and you'll instantly get a new PNG with the new colors on the right. Free, quick, and very powerful. Import a PNG – replace its colors.",
- shortDescription: 'Quickly swap colors in a PNG image',
- keywords: ['change', 'colors', 'in', 'png'],
- component: lazy(() => import('./index'))
-});
diff --git a/src/pages/tools/image/png/change-opacity/meta.ts b/src/pages/tools/image/png/change-opacity/meta.ts
deleted file mode 100644
index 1be290d..0000000
--- a/src/pages/tools/image/png/change-opacity/meta.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-import { defineTool } from '@tools/defineTool';
-import { lazy } from 'react';
-
-export const tool = defineTool('png', {
- name: 'Change PNG Opacity',
- path: 'change-opacity',
- icon: 'material-symbols:opacity',
- description: 'Easily adjust the transparency of your PNG images. Simply upload your PNG file, use the slider to set the desired opacity level between 0 (fully transparent) and 1 (fully opaque), and download the modified image.',
- shortDescription: 'Adjust transparency of PNG images',
- keywords: ['opacity', 'transparency', 'png', 'alpha'],
- component: lazy(() => import('./index'))
-});
diff --git a/src/pages/tools/image/png/compress-png/meta.ts b/src/pages/tools/image/png/compress-png/meta.ts
index 1e84c1f..4ed8009 100644
--- a/src/pages/tools/image/png/compress-png/meta.ts
+++ b/src/pages/tools/image/png/compress-png/meta.ts
@@ -8,7 +8,7 @@ export const tool = defineTool('png', {
icon: 'material-symbols-light:compress',
description:
'This is a program that compresses PNG pictures. As soon as you paste your PNG picture in the input area, the program will compress it and show the result in the output area. In the options, you can adjust the compression level, as well as find the old and new picture file sizes.',
- shortDescription: 'Quicly compress a PNG',
+ shortDescription: 'Quickly compress a PNG',
keywords: ['compress', 'png'],
component: lazy(() => import('./index'))
});
diff --git a/src/pages/tools/image/png/create-transparent/test.png b/src/pages/tools/image/png/create-transparent/test.png
deleted file mode 100644
index e08bfef..0000000
Binary files a/src/pages/tools/image/png/create-transparent/test.png and /dev/null differ
diff --git a/src/pages/tools/image/png/index.ts b/src/pages/tools/image/png/index.ts
index f248619..744e5f6 100644
--- a/src/pages/tools/image/png/index.ts
+++ b/src/pages/tools/image/png/index.ts
@@ -1,17 +1,4 @@
-import { tool as pngCrop } from './crop/meta';
import { tool as pngCompressPng } from './compress-png/meta';
import { tool as convertJgpToPng } from './convert-jgp-to-png/meta';
-import { tool as pngCreateTransparent } from './create-transparent/meta';
-import { tool as changeColorsInPng } from './change-colors-in-png/meta';
-import { tool as changeOpacity } from './change-opacity/meta';
-import { tool as removeBackground } from './remove-background/meta';
-export const pngTools = [
- pngCompressPng,
- pngCreateTransparent,
- changeColorsInPng,
- convertJgpToPng,
- changeOpacity,
- pngCrop,
- removeBackground
-];
+export const pngTools = [pngCompressPng, convertJgpToPng];
diff --git a/src/pages/tools/image/png/remove-background/meta.ts b/src/pages/tools/image/png/remove-background/meta.ts
deleted file mode 100644
index 1ae19e7..0000000
--- a/src/pages/tools/image/png/remove-background/meta.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-import { defineTool } from '@tools/defineTool';
-import { lazy } from 'react';
-
-export const tool = defineTool('png', {
- name: 'Remove Background from PNG',
- path: 'remove-background',
- icon: 'mdi:image-remove',
- description:
- "World's simplest online tool to remove backgrounds from PNG images. Just upload your image and our AI-powered tool will automatically remove the background, giving you a transparent PNG. Perfect for product photos, profile pictures, and design assets.",
- shortDescription: 'Automatically remove backgrounds from images',
- keywords: ['remove', 'background', 'png', 'transparent', 'image', 'ai'],
- component: lazy(() => import('./index'))
-});
diff --git a/src/pages/tools/pdf/compress-pdf/index.tsx b/src/pages/tools/pdf/compress-pdf/index.tsx
new file mode 100644
index 0000000..c5a8b2c
--- /dev/null
+++ b/src/pages/tools/pdf/compress-pdf/index.tsx
@@ -0,0 +1,222 @@
+import { Box, Typography } from '@mui/material';
+import React, { useContext, useEffect, useState } from 'react';
+import ToolContent from '@components/ToolContent';
+import { ToolComponentProps } from '@tools/defineTool';
+import ToolPdfInput from '@components/input/ToolPdfInput';
+import ToolFileResult from '@components/result/ToolFileResult';
+import { CardExampleType } from '@components/examples/ToolExamples';
+import { PDFDocument } from 'pdf-lib';
+import { CompressionLevel, InitialValuesType } from './types';
+import { compressPdf } from './service';
+import SimpleRadio from '@components/options/SimpleRadio';
+import { CustomSnackBarContext } from '../../../../contexts/CustomSnackBarContext';
+
+const initialValues: InitialValuesType = {
+ compressionLevel: 'medium'
+};
+
+const exampleCards: CardExampleType[] = [
+ {
+ title: 'Low Compression',
+ description: 'Slightly reduce file size with minimal quality loss',
+ sampleText: '',
+ sampleResult: '',
+ sampleOptions: {
+ compressionLevel: 'low'
+ }
+ },
+ {
+ title: 'Medium Compression',
+ description: 'Balance between file size and quality',
+ sampleText: '',
+ sampleResult: '',
+ sampleOptions: {
+ compressionLevel: 'medium'
+ }
+ },
+ {
+ title: 'High Compression',
+ description: 'Maximum file size reduction with some quality loss',
+ sampleText: '',
+ sampleResult: '',
+ sampleOptions: {
+ compressionLevel: 'high'
+ }
+ }
+];
+
+export default function CompressPdf({
+ title,
+ longDescription
+}: ToolComponentProps) {
+ const [input, setInput] = useState(null);
+ const [result, setResult] = useState(null);
+ const [resultSize, setResultSize] = useState('');
+ const [isProcessing, setIsProcessing] = useState(false);
+ const [fileInfo, setFileInfo] = useState<{
+ size: string;
+ pages: number;
+ } | null>(null);
+ const { showSnackBar } = useContext(CustomSnackBarContext);
+
+ // Get the PDF info when a file is uploaded
+ useEffect(() => {
+ const getPdfInfo = async () => {
+ if (!input) {
+ setFileInfo(null);
+ return;
+ }
+
+ try {
+ const arrayBuffer = await input.arrayBuffer();
+ const pdf = await PDFDocument.load(arrayBuffer);
+ const pages = pdf.getPageCount();
+ const size = formatFileSize(input.size);
+
+ setFileInfo({ size, pages });
+ } catch (error) {
+ console.error('Error getting PDF info:', error);
+ setFileInfo(null);
+ showSnackBar(
+ 'Error reading PDF file. Please make sure it is a valid PDF.',
+ 'error'
+ );
+ }
+ };
+
+ getPdfInfo();
+ }, [input]);
+
+ const formatFileSize = (bytes: number): string => {
+ if (bytes === 0) return '0 Bytes';
+
+ const k = 1024;
+ const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+ const i = Math.floor(Math.log(bytes) / Math.log(k));
+
+ return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+ };
+
+ const compute = async (values: InitialValuesType, input: File | null) => {
+ if (!input) return;
+
+ try {
+ setIsProcessing(true);
+ const compressedPdf = await compressPdf(input, values);
+ setResult(compressedPdf);
+
+ // Log compression results
+ const compressionRatio = (compressedPdf.size / input.size) * 100;
+ console.log(`Compression Ratio: ${compressionRatio.toFixed(2)}%`);
+ setResultSize(formatFileSize(compressedPdf.size));
+ } catch (error) {
+ console.error('Error compressing PDF:', error);
+ showSnackBar(
+ `Failed to compress PDF: ${
+ error instanceof Error ? error.message : String(error)
+ }`,
+ 'error'
+ );
+ setResult(null);
+ } finally {
+ setIsProcessing(false);
+ }
+ };
+
+ const compressionOptions: {
+ value: CompressionLevel;
+ label: string;
+ description: string;
+ }[] = [
+ {
+ value: 'low',
+ label: 'Low Compression',
+ description: 'Slightly reduce file size with minimal quality loss'
+ },
+ {
+ value: 'medium',
+ label: 'Medium Compression',
+ description: 'Balance between file size and quality'
+ },
+ {
+ value: 'high',
+ label: 'High Compression',
+ description: 'Maximum file size reduction with some quality loss'
+ }
+ ];
+
+ return (
+
+ }
+ resultComponent={
+
+ }
+ getGroups={({ values, updateField }) => [
+ {
+ title: 'Compression Settings',
+ component: (
+
+
+
+ Compression Level
+
+
+ {compressionOptions.map((option) => (
+ {
+ updateField('compressionLevel', option.value);
+ }}
+ />
+ ))}
+
+ {fileInfo && (
+
+
+ File size: {fileInfo.size}
+
+
+ Pages: {fileInfo.pages}
+
+ {resultSize && (
+
+ Compressed file size: {resultSize}
+
+ )}
+
+ )}
+
+ )
+ }
+ ]}
+ />
+ );
+}
diff --git a/src/pages/tools/pdf/compress-pdf/meta.ts b/src/pages/tools/pdf/compress-pdf/meta.ts
new file mode 100644
index 0000000..cbd608a
--- /dev/null
+++ b/src/pages/tools/pdf/compress-pdf/meta.ts
@@ -0,0 +1,28 @@
+import { defineTool } from '@tools/defineTool';
+import { lazy } from 'react';
+
+export const tool = defineTool('pdf', {
+ name: 'Compress PDF',
+ path: 'compress-pdf',
+ icon: 'material-symbols:compress',
+ description:
+ 'Reduce PDF file size while maintaining quality using Ghostscript',
+ shortDescription: 'Compress PDF files securely in your browser',
+ keywords: [
+ 'pdf',
+ 'compress',
+ 'reduce',
+ 'size',
+ 'optimize',
+ 'shrink',
+ 'file size',
+ 'ghostscript',
+ 'secure',
+ 'private',
+ 'browser',
+ 'webassembly'
+ ],
+ longDescription:
+ 'Compress PDF files securely in your browser using Ghostscript. Your files never leave your device, ensuring complete privacy while reducing file sizes for email sharing, uploading to websites, or saving storage space. Powered by WebAssembly technology.',
+ component: lazy(() => import('./index'))
+});
diff --git a/src/pages/tools/pdf/compress-pdf/service.ts b/src/pages/tools/pdf/compress-pdf/service.ts
new file mode 100644
index 0000000..29b5ab4
--- /dev/null
+++ b/src/pages/tools/pdf/compress-pdf/service.ts
@@ -0,0 +1,28 @@
+import { InitialValuesType } from './types';
+import { compressWithGhostScript } from '../../../../lib/ghostscript/worker-init';
+import { loadPDFData } from '../utils';
+
+/**
+ * Compresses a PDF file using either Ghostscript WASM (preferred)
+ * or falls back to pdf-lib if WASM fails
+ *
+ * @param pdfFile - The PDF file to compress
+ * @param options - Compression options including compression level
+ * @returns A Promise that resolves to a compressed PDF File
+ */
+export async function compressPdf(
+ pdfFile: File,
+ options: InitialValuesType
+): Promise {
+ // Check if file is a PDF
+ if (pdfFile.type !== 'application/pdf') {
+ throw new Error('The provided file is not a PDF');
+ }
+
+ const dataObject = {
+ psDataURL: URL.createObjectURL(pdfFile),
+ compressionLevel: options.compressionLevel
+ };
+ const compressedFileUrl: string = await compressWithGhostScript(dataObject);
+ return await loadPDFData(compressedFileUrl, pdfFile.name);
+}
diff --git a/src/pages/tools/pdf/compress-pdf/types.ts b/src/pages/tools/pdf/compress-pdf/types.ts
new file mode 100644
index 0000000..8b6f155
--- /dev/null
+++ b/src/pages/tools/pdf/compress-pdf/types.ts
@@ -0,0 +1,5 @@
+export type CompressionLevel = 'low' | 'medium' | 'high';
+
+export type InitialValuesType = {
+ compressionLevel: CompressionLevel;
+};
diff --git a/src/pages/tools/pdf/index.ts b/src/pages/tools/pdf/index.ts
index 380e593..4b74428 100644
--- a/src/pages/tools/pdf/index.ts
+++ b/src/pages/tools/pdf/index.ts
@@ -1,5 +1,12 @@
import { tool as pdfRotatePdf } from './rotate-pdf/meta';
import { meta as splitPdfMeta } from './split-pdf/meta';
+import { tool as compressPdfTool } from './compress-pdf/meta';
+import { tool as protectPdfTool } from './protect-pdf/meta';
import { DefinedTool } from '@tools/defineTool';
-export const pdfTools: DefinedTool[] = [splitPdfMeta, pdfRotatePdf];
+export const pdfTools: DefinedTool[] = [
+ splitPdfMeta,
+ pdfRotatePdf,
+ compressPdfTool,
+ protectPdfTool
+];
diff --git a/src/pages/tools/pdf/protect-pdf/index.tsx b/src/pages/tools/pdf/protect-pdf/index.tsx
new file mode 100644
index 0000000..7692695
--- /dev/null
+++ b/src/pages/tools/pdf/protect-pdf/index.tsx
@@ -0,0 +1,110 @@
+import { Box } from '@mui/material';
+import React, { useContext, useState } from 'react';
+import ToolContent from '@components/ToolContent';
+import { ToolComponentProps } from '@tools/defineTool';
+import ToolPdfInput from '@components/input/ToolPdfInput';
+import ToolFileResult from '@components/result/ToolFileResult';
+import { InitialValuesType } from './types';
+import { protectPdf } from './service';
+import TextFieldWithDesc from '@components/options/TextFieldWithDesc';
+import { CustomSnackBarContext } from '../../../../contexts/CustomSnackBarContext';
+
+const initialValues: InitialValuesType = {
+ password: '',
+ confirmPassword: ''
+};
+
+export default function ProtectPdf({
+ title,
+ longDescription
+}: ToolComponentProps) {
+ const [input, setInput] = useState(null);
+ const [result, setResult] = useState(null);
+ const [isProcessing, setIsProcessing] = useState(false);
+ const { showSnackBar } = useContext(CustomSnackBarContext);
+
+ const compute = async (values: InitialValuesType, input: File | null) => {
+ if (!input) return;
+
+ try {
+ // Validate passwords match
+ if (values.password !== values.confirmPassword) {
+ showSnackBar('Passwords do not match', 'error');
+ return;
+ }
+
+ // Validate password is not empty
+ if (!values.password) {
+ showSnackBar('Password cannot be empty', 'error');
+ return;
+ }
+
+ setIsProcessing(true);
+ const protectedPdf = await protectPdf(input, values);
+ setResult(protectedPdf);
+ } catch (error) {
+ console.error('Error protecting PDF:', error);
+ showSnackBar(
+ `Failed to protect PDF: ${
+ error instanceof Error ? error.message : String(error)
+ }`,
+ 'error'
+ );
+ setResult(null);
+ } finally {
+ setIsProcessing(false);
+ }
+ };
+
+ return (
+
+ }
+ resultComponent={
+
+ }
+ getGroups={({ values, updateField }) => [
+ {
+ title: 'Password Settings',
+ component: (
+
+ updateField('password', value)}
+ />
+ updateField('confirmPassword', value)}
+ />
+
+ )
+ }
+ ]}
+ />
+ );
+}
diff --git a/src/pages/tools/pdf/protect-pdf/meta.ts b/src/pages/tools/pdf/protect-pdf/meta.ts
new file mode 100644
index 0000000..51ecd53
--- /dev/null
+++ b/src/pages/tools/pdf/protect-pdf/meta.ts
@@ -0,0 +1,27 @@
+import { defineTool } from '@tools/defineTool';
+import { lazy } from 'react';
+
+export const tool = defineTool('pdf', {
+ name: 'Protect PDF',
+ path: 'protect-pdf',
+ icon: 'material-symbols:lock',
+ description:
+ 'Add password protection to your PDF files securely in your browser',
+ shortDescription: 'Password protect PDF files securely',
+ keywords: [
+ 'pdf',
+ 'protect',
+ 'password',
+ 'secure',
+ 'encrypt',
+ 'lock',
+ 'private',
+ 'confidential',
+ 'security',
+ 'browser',
+ 'encryption'
+ ],
+ longDescription:
+ 'Add password protection to your PDF files securely in your browser. Your files never leave your device, ensuring complete privacy while securing your documents with password encryption. Perfect for protecting sensitive information, confidential documents, or personal data.',
+ component: lazy(() => import('./index'))
+});
diff --git a/src/pages/tools/pdf/protect-pdf/service.ts b/src/pages/tools/pdf/protect-pdf/service.ts
new file mode 100644
index 0000000..6619a50
--- /dev/null
+++ b/src/pages/tools/pdf/protect-pdf/service.ts
@@ -0,0 +1,45 @@
+import { PDFDocument } from 'pdf-lib';
+import { InitialValuesType } from './types';
+import {
+ compressWithGhostScript,
+ protectWithGhostScript
+} from '../../../../lib/ghostscript/worker-init';
+import { loadPDFData } from '../utils';
+
+/**
+ * Protects a PDF file with a password
+ *
+ * @param pdfFile - The PDF file to protect
+ * @param options - Protection options including password and protection type
+ * @returns A Promise that resolves to a password-protected PDF File
+ */
+export async function protectPdf(
+ pdfFile: File,
+ options: InitialValuesType
+): Promise {
+ // Check if file is a PDF
+ if (pdfFile.type !== 'application/pdf') {
+ throw new Error('The provided file is not a PDF');
+ }
+
+ // Check if passwords match
+ if (options.password !== options.confirmPassword) {
+ throw new Error('Passwords do not match');
+ }
+
+ // Check if password is empty
+ if (!options.password) {
+ throw new Error('Password cannot be empty');
+ }
+
+ const dataObject = {
+ psDataURL: URL.createObjectURL(pdfFile),
+ password: options.password
+ };
+ const protectedFileUrl: string = await protectWithGhostScript(dataObject);
+ console.log('protected', protectedFileUrl);
+ return await loadPDFData(
+ protectedFileUrl,
+ pdfFile.name.replace('.pdf', '-protected.pdf')
+ );
+}
diff --git a/src/pages/tools/pdf/protect-pdf/types.ts b/src/pages/tools/pdf/protect-pdf/types.ts
new file mode 100644
index 0000000..a029070
--- /dev/null
+++ b/src/pages/tools/pdf/protect-pdf/types.ts
@@ -0,0 +1,6 @@
+export type ProtectionType = 'owner' | 'user';
+
+export type InitialValuesType = {
+ password: string;
+ confirmPassword: string;
+};
diff --git a/src/pages/tools/pdf/utils.ts b/src/pages/tools/pdf/utils.ts
new file mode 100644
index 0000000..98fe7e5
--- /dev/null
+++ b/src/pages/tools/pdf/utils.ts
@@ -0,0 +1,16 @@
+export function loadPDFData(url: string, filename: string): Promise {
+ return new Promise((resolve) => {
+ const xhr = new XMLHttpRequest();
+ xhr.open('GET', url);
+ xhr.responseType = 'arraybuffer';
+ xhr.onload = function () {
+ window.URL.revokeObjectURL(url);
+ const blob = new Blob([xhr.response], { type: 'application/pdf' });
+ const newFile = new File([blob], filename, {
+ type: 'application/pdf'
+ });
+ resolve(newFile);
+ };
+ xhr.send();
+ });
+}
diff --git a/src/tools/defineTool.tsx b/src/tools/defineTool.tsx
index 5263c6f..ace53b4 100644
--- a/src/tools/defineTool.tsx
+++ b/src/tools/defineTool.tsx
@@ -23,8 +23,8 @@ export type ToolCategory =
| 'json'
| 'time'
| 'csv'
- | 'time'
- | 'pdf';
+ | 'pdf'
+ | 'image-generic';
export interface DefinedTool {
type: ToolCategory;
diff --git a/src/tools/index.ts b/src/tools/index.ts
index 401cbb3..08a2cf8 100644
--- a/src/tools/index.ts
+++ b/src/tools/index.ts
@@ -12,6 +12,19 @@ import { timeTools } from '../pages/tools/time';
import { IconifyIcon } from '@iconify/react';
import { pdfTools } from '../pages/tools/pdf';
+const toolCategoriesOrder: ToolCategory[] = [
+ 'image-generic',
+ 'string',
+ 'json',
+ 'pdf',
+ 'video',
+ 'list',
+ 'csv',
+ 'number',
+ 'png',
+ 'time',
+ 'gif'
+];
export const tools: DefinedTool[] = [
...imageTools,
...stringTools,
@@ -95,6 +108,13 @@ const categoriesConfig: {
icon: 'fluent-mdl2:date-time',
value:
'Tools for working with time and date – draw clocks and calendars, generate time and date sequences, calculate average time, convert between time zones, and much more.'
+ },
+ {
+ type: 'image-generic',
+ title: 'Image',
+ icon: 'material-symbols-light:image-outline-rounded',
+ value:
+ 'Tools for working with pictures – compress, resize, crop, convert to JPG, rotate, remove background and much more.'
}
];
// use for changelogs
@@ -123,20 +143,22 @@ export const filterTools = (
export const getToolsByCategory = (): {
title: string;
+ rawTitle: string;
description: string;
icon: IconifyIcon | string;
- type: string;
+ type: ToolCategory;
example: { title: string; path: string };
tools: DefinedTool[];
}[] => {
const groupedByType: Partial> =
Object.groupBy(tools, ({ type }) => type);
- return (Object.entries(groupedByType) as Entries).map(
- ([type, tools]) => {
+ return (Object.entries(groupedByType) as Entries)
+ .map(([type, tools]) => {
const categoryConfig = categoriesConfig.find(
(config) => config.type === type
);
return {
+ rawTitle: categoryConfig?.title ?? capitalizeFirstLetter(type),
title: `${categoryConfig?.title ?? capitalizeFirstLetter(type)} Tools`,
description: categoryConfig?.value ?? '',
type,
@@ -146,6 +168,10 @@ export const getToolsByCategory = (): {
? { title: tools[0].name, path: tools[0].path }
: { title: '', path: '' }
};
- }
- );
+ })
+ .sort(
+ (a, b) =>
+ toolCategoriesOrder.indexOf(a.type) -
+ toolCategoriesOrder.indexOf(b.type)
+ );
};
diff --git a/vite.config.ts b/vite.config.ts
index ac5243e..e6faab7 100644
--- a/vite.config.ts
+++ b/vite.config.ts
@@ -17,5 +17,6 @@ export default defineConfig({
environment: 'happy-dom',
setupFiles: '.vitest/setup',
include: ['**/*.test.{ts,tsx}']
- }
+ },
+ worker: { format: 'es' }
});
