From cb6cb92cb413fe3fae995e31a8a1b9b650a7b190 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Haz=20=C3=86=2041?= <4405263+hazae41@users.noreply.github.com> Date: Mon, 11 Dec 2023 17:41:13 +0100 Subject: [PATCH] snapppp --- .gitattributes | 5 + .github/workflows/commit.yml | 17 + .gitignore | 3 + .vscode/settings.json | 8 + Dockerfile | 14 + LICENSE.md | 21 + README.md | 44 ++ SECURITY.md | 11 + docker-compose.yml | 7 + package-lock.json | 971 ++++++++++++++++++++++++++++++++++ package.json | 48 ++ patch.js | 29 + rollup.config.js | 64 +++ src/deno/mod.bench.ts | 1 + src/deno/mod.test.ts | 1 + src/deno/mod.ts | 2 + src/deno/mods/mod.ts | 11 + src/node/index.bench.ts | 1 + src/node/index.test.ts | 23 + src/node/index.ts | 1 + src/node/mods/index.ts | 10 + tsconfig.json | 30 ++ wasm/.gitignore | 1 + wasm/Cargo.lock | 170 ++++++ wasm/Cargo.toml | 21 + wasm/LICENSE.md | 21 + wasm/README.md | 1 + wasm/pkg/LICENSE.md | 21 + wasm/pkg/README.md | 1 + wasm/pkg/example.d.ts | 51 ++ wasm/pkg/example.js | 273 ++++++++++ wasm/pkg/example.wasm.d.ts | 1 + wasm/pkg/example.wasm.js | 1 + wasm/pkg/example_bg.wasm | Bin 0 -> 61718 bytes wasm/pkg/example_bg.wasm.d.ts | 10 + wasm/pkg/package.json | 23 + wasm/src/lib.rs | 68 +++ 37 files changed, 1985 insertions(+) create mode 100644 .gitattributes create mode 100644 .github/workflows/commit.yml create mode 100644 .gitignore create mode 100644 .vscode/settings.json create mode 100644 Dockerfile create mode 100644 LICENSE.md create mode 100644 README.md create mode 100644 SECURITY.md create mode 100644 docker-compose.yml create mode 100644 package-lock.json create mode 100644 package.json create mode 100644 patch.js create mode 100644 rollup.config.js create mode 100644 src/deno/mod.bench.ts create mode 100644 src/deno/mod.test.ts create mode 100644 src/deno/mod.ts create mode 100644 src/deno/mods/mod.ts create mode 100644 src/node/index.bench.ts create mode 100644 src/node/index.test.ts create mode 100644 src/node/index.ts create mode 100644 src/node/mods/index.ts create mode 100644 tsconfig.json create mode 100644 wasm/.gitignore create mode 100644 wasm/Cargo.lock create mode 100644 wasm/Cargo.toml create mode 100644 wasm/LICENSE.md create mode 100644 wasm/README.md create mode 100644 wasm/pkg/LICENSE.md create mode 100644 wasm/pkg/README.md create mode 100644 wasm/pkg/example.d.ts create mode 100644 wasm/pkg/example.js create mode 100644 wasm/pkg/example.wasm.d.ts create mode 100644 wasm/pkg/example.wasm.js create mode 100644 wasm/pkg/example_bg.wasm create mode 100644 wasm/pkg/example_bg.wasm.d.ts create mode 100644 wasm/pkg/package.json create mode 100644 wasm/src/lib.rs diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..fb2c4e5 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,5 @@ +* linguist-vendored=true +*.ts linguist-vendored=false +*.rs linguist-vendored=false +dist/* linguist-vendored=true +pkg/* linguist-vendored=true \ No newline at end of file diff --git a/.github/workflows/commit.yml b/.github/workflows/commit.yml new file mode 100644 index 0000000..d75b850 --- /dev/null +++ b/.github/workflows/commit.yml @@ -0,0 +1,17 @@ +on: [push] + +name: commit + +jobs: + check: + name: check + runs-on: ubuntu-22.04 + steps: + - uses: actions/checkout@v3 + - run: 'docker compose up --build' + - run: 'git status --porcelain' + - uses: actions/upload-artifact@v3 + with: + name: pkg + path: ./wasm/pkg/ + - run: '[[ -z $(git status --porcelain) ]]' diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..4fe613c --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +/node_modules +/dist +.DS_Store \ No newline at end of file diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..87d7962 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,8 @@ +{ + "deno.enable": true, + "deno.unstable": true, + "deno.enablePaths": [ + "./src/deno", + "./example/deno" + ] +} \ No newline at end of file diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..3b8c406 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,14 @@ +FROM rust:1.71.0 + +WORKDIR /app + +RUN cargo install wasm-pack + +RUN curl -fsSL https://deb.nodesource.com/setup_20.x | bash +RUN apt-get install -y nodejs +RUN npm config set cache /tmp --global + +RUN chmod -R 777 /usr/local/cargo +RUN chmod -R 777 /root + +CMD npm ci && npm run build \ No newline at end of file diff --git a/LICENSE.md b/LICENSE.md new file mode 100644 index 0000000..555cb19 --- /dev/null +++ b/LICENSE.md @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2023 Haz Æ 41 + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..0879f25 --- /dev/null +++ b/README.md @@ -0,0 +1,44 @@ +# Example Rust Snap + +An example Snap written in Rust + +## Building + +### Unreproducible building + +You need to install [Rust](https://www.rust-lang.org/tools/install) + +Then, install [wasm-pack](https://github.com/rustwasm/wasm-pack) + +```bash +cargo install wasm-pack +``` + +Finally, do a clean install and build + +```bash +npm ci && npm run build +``` + +### Reproducible building + +You can build the exact same bytecode using Docker, just be sure you're on a `linux/amd64` host + +```bash +docker compose up --build +``` + +Then check that all the files are the same using `git status` + +```bash +git status --porcelain +``` + +If the output is empty then the bytecode is the same as the one I commited + +### Automated checks + +Each time I commit to the repository, the GitHub's CI does the following: +- Clone the repository +- Reproduce the build using `docker compose up --build` +- Throw an error if the `git status --porcelain` output is not empty diff --git a/SECURITY.md b/SECURITY.md new file mode 100644 index 0000000..27ceba3 --- /dev/null +++ b/SECURITY.md @@ -0,0 +1,11 @@ +# Security Policy + +## Supported Versions + +| Version | Supported | +| ------- | ------------------ | +| 1.x | :white_check_mark: | + +## Reporting a Vulnerability + +Contact me at 4405263+hazae41@users.noreply.github.com or hazae41@proton.me or on Twitter @hazae41 diff --git a/docker-compose.yml b/docker-compose.yml new file mode 100644 index 0000000..8b84364 --- /dev/null +++ b/docker-compose.yml @@ -0,0 +1,7 @@ +version: "3.8" + +services: + app: + build: . + volumes: + - ".:/app" diff --git a/package-lock.json b/package-lock.json new file mode 100644 index 0000000..ea9416b --- /dev/null +++ b/package-lock.json @@ -0,0 +1,971 @@ +{ + "name": "example", + "version": "1.0.0", + "lockfileVersion": 2, + "requires": true, + "packages": { + "": { + "name": "example", + "version": "1.0.0", + "license": "MIT", + "devDependencies": { + "@hazae41/deimos": "^1.0.6", + "@hazae41/phobos": "^1.0.10", + "@hazae41/rimraf": "^1.0.1", + "@rollup/plugin-typescript": "^11.1.5", + "@types/node": "^20.8.4", + "rollup": "^4.0.2", + "rollup-plugin-dts": "^6.1.0", + "rollup-plugin-node-externals": "^6.1.2", + "typescript": "^5.2.2" + } + }, + "node_modules/@babel/code-frame": { + "version": "7.22.13", + "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.22.13.tgz", + "integrity": "sha512-XktuhWlJ5g+3TJXc5upd9Ks1HutSArik6jf2eAjYFyIOf4ej3RN+184cZbzDvbPnuTJIUhPKKJE3cIsYTiAT3w==", + "dev": true, + "optional": true, + "dependencies": { + "@babel/highlight": "^7.22.13", + "chalk": "^2.4.2" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-identifier": { + "version": "7.22.20", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.22.20.tgz", + "integrity": "sha512-Y4OZ+ytlatR8AI+8KZfKuL5urKp7qey08ha31L8b3BwewJAoJamTzyvxPR/5D+KkdJCGPq/+8TukHBlY10FX9A==", + "dev": true, + "optional": true, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/highlight": { + "version": "7.22.20", + "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.22.20.tgz", + "integrity": "sha512-dkdMCN3py0+ksCgYmGG8jKeGA/8Tk+gJwSYYlFGxG5lmhfKNoAy004YpLxpS1W2J8m/EK2Ew+yOs9pVRwO89mg==", + "dev": true, + "optional": true, + "dependencies": { + "@babel/helper-validator-identifier": "^7.22.20", + "chalk": "^2.4.2", + "js-tokens": "^4.0.0" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@hazae41/deimos": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/@hazae41/deimos/-/deimos-1.0.6.tgz", + "integrity": "sha512-WFPqGe3hVKoUxXSDK+eJpKEpjTBZYfrvBCNlpUAjSyDB/5GrsjcVpgX37QDXZvtJA+Y8fZz1VHxuWGh+I46cIw==", + "dev": true + }, + "node_modules/@hazae41/phobos": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/@hazae41/phobos/-/phobos-1.0.10.tgz", + "integrity": "sha512-ZCZx2YXnRAmMxQhBSg1/GW3wll8UVXGJm8ADWaGk9sJRnXE0zISAHz1mRZIHXHAq+MUBOQF7d6AeCAckc2xYlQ==", + "dev": true + }, + "node_modules/@hazae41/rimraf": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@hazae41/rimraf/-/rimraf-1.0.1.tgz", + "integrity": "sha512-EmzbyXflKMxnfiEAsE2jn84Bo2WeTxPasdasQ0JP4gisCa3n9qrB2tiR9fmRsrkS6wH/H16oBsu4dkyfaJiKQw==", + "dev": true, + "bin": { + "rimraf": "dist/index.mjs" + } + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.4.15", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz", + "integrity": "sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg==", + "dev": true + }, + "node_modules/@rollup/plugin-typescript": { + "version": "11.1.5", + "resolved": "https://registry.npmjs.org/@rollup/plugin-typescript/-/plugin-typescript-11.1.5.tgz", + "integrity": "sha512-rnMHrGBB0IUEv69Q8/JGRD/n4/n6b3nfpufUu26axhUcboUzv/twfZU8fIBbTOphRAe0v8EyxzeDpKXqGHfyDA==", + "dev": true, + "dependencies": { + "@rollup/pluginutils": "^5.0.1", + "resolve": "^1.22.1" + }, + "engines": { + "node": ">=14.0.0" + }, + "peerDependencies": { + "rollup": "^2.14.0||^3.0.0||^4.0.0", + "tslib": "*", + "typescript": ">=3.7.0" + }, + "peerDependenciesMeta": { + "rollup": { + "optional": true + }, + "tslib": { + "optional": true + } + } + }, + "node_modules/@rollup/pluginutils": { + "version": "5.0.5", + "resolved": "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-5.0.5.tgz", + "integrity": "sha512-6aEYR910NyP73oHiJglti74iRyOwgFU4x3meH/H8OJx6Ry0j6cOVZ5X/wTvub7G7Ao6qaHBEaNsV3GLJkSsF+Q==", + "dev": true, + "dependencies": { + "@types/estree": "^1.0.0", + "estree-walker": "^2.0.2", + "picomatch": "^2.3.1" + }, + "engines": { + "node": ">=14.0.0" + }, + "peerDependencies": { + "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0" + }, + "peerDependenciesMeta": { + "rollup": { + "optional": true + } + } + }, + "node_modules/@rollup/rollup-android-arm-eabi": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.0.2.tgz", + "integrity": "sha512-xDvk1pT4vaPU2BOLy0MqHMdYZyntqpaBf8RhBiezlqG9OjY8F50TyctHo8znigYKd+QCFhCmlmXHOL/LoaOl3w==", + "cpu": [ + "arm" + ], + "dev": true, + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-android-arm64": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.0.2.tgz", + "integrity": "sha512-lqCglytY3E6raze27DD9VQJWohbwCxzqs9aSHcj5X/8hJpzZfNdbsr4Ja9Hqp6iPyF53+5PtPx0pKRlkSvlHZg==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-darwin-arm64": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.0.2.tgz", + "integrity": "sha512-nkBKItS6E6CCzvRwgiKad+j+1ibmL7SIInj7oqMWmdkCjiSX6VeVZw2mLlRKIUL+JjsBgpATTfo7BiAXc1v0jA==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-darwin-x64": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.0.2.tgz", + "integrity": "sha512-vX2C8xvWPIbpEgQht95+dY6BReKAvtDgPDGi0XN0kWJKkm4WdNmq5dnwscv/zxvi+n6jUTBhs6GtpkkWT4q8Gg==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-linux-arm-gnueabihf": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.0.2.tgz", + "integrity": "sha512-DVFIfcHOjgmeHOAqji4xNz2wczt1Bmzy9MwBZKBa83SjBVO/i38VHDR+9ixo8QpBOiEagmNw12DucG+v55tCrg==", + "cpu": [ + "arm" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-gnu": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.0.2.tgz", + "integrity": "sha512-GCK/a9ItUxPI0V5hQEJjH4JtOJO90GF2Hja7TO+EZ8rmkGvEi8/ZDMhXmcuDpQT7/PWrTT9RvnG8snMd5SrhBQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-musl": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.0.2.tgz", + "integrity": "sha512-cLuBp7rOjIB1R2j/VazjCmHC7liWUur2e9mFflLJBAWCkrZ+X0+QwHLvOQakIwDymungzAKv6W9kHZnTp/Mqrg==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-gnu": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.0.2.tgz", + "integrity": "sha512-Zqw4iVnJr2naoyQus0yLy7sLtisCQcpdMKUCeXPBjkJtpiflRime/TMojbnl8O3oxUAj92mxr+t7im/RbgA20w==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-musl": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.0.2.tgz", + "integrity": "sha512-jJRU9TyUD/iMqjf8aLAp7XiN3pIj5v6Qcu+cdzBfVTKDD0Fvua4oUoK8eVJ9ZuKBEQKt3WdlcwJXFkpmMLk6kg==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-win32-arm64-msvc": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.0.2.tgz", + "integrity": "sha512-ZkS2NixCxHKC4zbOnw64ztEGGDVIYP6nKkGBfOAxEPW71Sji9v8z3yaHNuae/JHPwXA+14oDefnOuVfxl59SmQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-ia32-msvc": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.0.2.tgz", + "integrity": "sha512-3SKjj+tvnZ0oZq2BKB+fI+DqYI83VrRzk7eed8tJkxeZ4zxJZcLSE8YDQLYGq1tZAnAX+H076RHHB4gTZXsQzw==", + "cpu": [ + "ia32" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-msvc": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.0.2.tgz", + "integrity": "sha512-MBdJIOxRauKkry7t2q+rTHa3aWjVez2eioWg+etRVS3dE4tChhmt5oqZYr48R6bPmcwEhxQr96gVRfeQrLbqng==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@types/estree": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.2.tgz", + "integrity": "sha512-VeiPZ9MMwXjO32/Xu7+OwflfmeoRwkE/qzndw42gGtgJwZopBnzy2gD//NN1+go1mADzkDcqf/KnFRSjTJ8xJA==", + "dev": true + }, + "node_modules/@types/node": { + "version": "20.8.4", + "resolved": "https://registry.npmjs.org/@types/node/-/node-20.8.4.tgz", + "integrity": "sha512-ZVPnqU58giiCjSxjVUESDtdPk4QR5WQhhINbc9UBrKLU68MX5BF6kbQzTrkwbolyr0X8ChBpXfavr5mZFKZQ5A==", + "dev": true, + "dependencies": { + "undici-types": "~5.25.1" + } + }, + "node_modules/ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "dev": true, + "optional": true, + "dependencies": { + "color-convert": "^1.9.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/chalk": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", + "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "dev": true, + "optional": true, + "dependencies": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/color-convert": { + "version": "1.9.3", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz", + "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==", + "dev": true, + "optional": true, + "dependencies": { + "color-name": "1.1.3" + } + }, + "node_modules/color-name": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", + "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==", + "dev": true, + "optional": true + }, + "node_modules/escape-string-regexp": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", + "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==", + "dev": true, + "optional": true, + "engines": { + "node": ">=0.8.0" + } + }, + "node_modules/estree-walker": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz", + "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==", + "dev": true + }, + "node_modules/fsevents": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz", + "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==", + "dev": true, + "hasInstallScript": true, + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/function-bind": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz", + "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==", + "dev": true + }, + "node_modules/has": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz", + "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==", + "dev": true, + "dependencies": { + "function-bind": "^1.1.1" + }, + "engines": { + "node": ">= 0.4.0" + } + }, + "node_modules/has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==", + "dev": true, + "optional": true, + "engines": { + "node": ">=4" + } + }, + "node_modules/is-core-module": { + "version": "2.11.0", + "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.11.0.tgz", + "integrity": "sha512-RRjxlvLDkD1YJwDbroBHMb+cukurkDWNyHx7D3oNB5x9rb5ogcksMC5wHCadcXoo67gVr/+3GFySh3134zi6rw==", + "dev": true, + "dependencies": { + "has": "^1.0.3" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/js-tokens": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz", + "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==", + "dev": true, + "optional": true + }, + "node_modules/magic-string": { + "version": "0.30.4", + "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.4.tgz", + "integrity": "sha512-Q/TKtsC5BPm0kGqgBIF9oXAs/xEf2vRKiIB4wCRQTJOQIByZ1d+NnUOotvJOvNpi5RNIgVOMC3pOuaP1ZTDlVg==", + "dev": true, + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.4.15" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/path-parse": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz", + "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==", + "dev": true + }, + "node_modules/picomatch": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", + "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", + "dev": true, + "engines": { + "node": ">=8.6" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/resolve": { + "version": "1.22.1", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.1.tgz", + "integrity": "sha512-nBpuuYuY5jFsli/JIs1oldw6fOQCBioohqWZg/2hiaOybXOft4lonv85uDOKXdf8rhyK159cxU5cDcK/NKk8zw==", + "dev": true, + "dependencies": { + "is-core-module": "^2.9.0", + "path-parse": "^1.0.7", + "supports-preserve-symlinks-flag": "^1.0.0" + }, + "bin": { + "resolve": "bin/resolve" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/rollup": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.0.2.tgz", + "integrity": "sha512-MCScu4usMPCeVFaiLcgMDaBQeYi1z6vpWxz0r0hq0Hv77Y2YuOTZldkuNJ54BdYBH3e+nkrk6j0Rre/NLDBYzg==", + "dev": true, + "bin": { + "rollup": "dist/bin/rollup" + }, + "engines": { + "node": ">=18.0.0", + "npm": ">=8.0.0" + }, + "optionalDependencies": { + "@rollup/rollup-android-arm-eabi": "4.0.2", + "@rollup/rollup-android-arm64": "4.0.2", + "@rollup/rollup-darwin-arm64": "4.0.2", + "@rollup/rollup-darwin-x64": "4.0.2", + "@rollup/rollup-linux-arm-gnueabihf": "4.0.2", + "@rollup/rollup-linux-arm64-gnu": "4.0.2", + "@rollup/rollup-linux-arm64-musl": "4.0.2", + "@rollup/rollup-linux-x64-gnu": "4.0.2", + "@rollup/rollup-linux-x64-musl": "4.0.2", + "@rollup/rollup-win32-arm64-msvc": "4.0.2", + "@rollup/rollup-win32-ia32-msvc": "4.0.2", + "@rollup/rollup-win32-x64-msvc": "4.0.2", + "fsevents": "~2.3.2" + } + }, + "node_modules/rollup-plugin-dts": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/rollup-plugin-dts/-/rollup-plugin-dts-6.1.0.tgz", + "integrity": "sha512-ijSCPICkRMDKDLBK9torss07+8dl9UpY9z1N/zTeA1cIqdzMlpkV3MOOC7zukyvQfDyxa1s3Dl2+DeiP/G6DOw==", + "dev": true, + "dependencies": { + "magic-string": "^0.30.4" + }, + "engines": { + "node": ">=16" + }, + "funding": { + "url": "https://github.com/sponsors/Swatinem" + }, + "optionalDependencies": { + "@babel/code-frame": "^7.22.13" + }, + "peerDependencies": { + "rollup": "^3.29.4 || ^4", + "typescript": "^4.5 || ^5.0" + } + }, + "node_modules/rollup-plugin-node-externals": { + "version": "6.1.2", + "resolved": "https://registry.npmjs.org/rollup-plugin-node-externals/-/rollup-plugin-node-externals-6.1.2.tgz", + "integrity": "sha512-2TWan0u0/zHcgPrKpIPgKSY8OMqwDAYD380I0hxx7iUQw8mrN34DWwG9sQUMEo5Yy4xd6/5QEAySYgiKN9fdBQ==", + "dev": true, + "engines": { + "node": ">=16.0.0" + }, + "peerDependencies": { + "rollup": "^3.0.0 || ^4.0.0" + } + }, + "node_modules/supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "dev": true, + "optional": true, + "dependencies": { + "has-flag": "^3.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/supports-preserve-symlinks-flag": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz", + "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==", + "dev": true, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/tslib": { + "version": "2.6.2", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.6.2.tgz", + "integrity": "sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q==", + "dev": true, + "optional": true, + "peer": true + }, + "node_modules/typescript": { + "version": "5.2.2", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.2.2.tgz", + "integrity": "sha512-mI4WrpHsbCIcwT9cF4FZvr80QUeKvsUsUvKDoR+X/7XHQH98xYD8YHZg7ANtz2GtZt/CBq2QJ0thkGJMHfqc1w==", + "dev": true, + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + }, + "node_modules/undici-types": { + "version": "5.25.3", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.25.3.tgz", + "integrity": "sha512-Ga1jfYwRn7+cP9v8auvEXN1rX3sWqlayd4HP7OKk4mZWylEmu3KzXDUGrQUN6Ol7qo1gPvB2e5gX6udnyEPgdA==", + "dev": true + } + }, + "dependencies": { + "@babel/code-frame": { + "version": "7.22.13", + "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.22.13.tgz", + "integrity": "sha512-XktuhWlJ5g+3TJXc5upd9Ks1HutSArik6jf2eAjYFyIOf4ej3RN+184cZbzDvbPnuTJIUhPKKJE3cIsYTiAT3w==", + "dev": true, + "optional": true, + "requires": { + "@babel/highlight": "^7.22.13", + "chalk": "^2.4.2" + } + }, + "@babel/helper-validator-identifier": { + "version": "7.22.20", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.22.20.tgz", + "integrity": "sha512-Y4OZ+ytlatR8AI+8KZfKuL5urKp7qey08ha31L8b3BwewJAoJamTzyvxPR/5D+KkdJCGPq/+8TukHBlY10FX9A==", + "dev": true, + "optional": true + }, + "@babel/highlight": { + "version": "7.22.20", + "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.22.20.tgz", + "integrity": "sha512-dkdMCN3py0+ksCgYmGG8jKeGA/8Tk+gJwSYYlFGxG5lmhfKNoAy004YpLxpS1W2J8m/EK2Ew+yOs9pVRwO89mg==", + "dev": true, + "optional": true, + "requires": { + "@babel/helper-validator-identifier": "^7.22.20", + "chalk": "^2.4.2", + "js-tokens": "^4.0.0" + } + }, + "@hazae41/deimos": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/@hazae41/deimos/-/deimos-1.0.6.tgz", + "integrity": "sha512-WFPqGe3hVKoUxXSDK+eJpKEpjTBZYfrvBCNlpUAjSyDB/5GrsjcVpgX37QDXZvtJA+Y8fZz1VHxuWGh+I46cIw==", + "dev": true + }, + "@hazae41/phobos": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/@hazae41/phobos/-/phobos-1.0.10.tgz", + "integrity": "sha512-ZCZx2YXnRAmMxQhBSg1/GW3wll8UVXGJm8ADWaGk9sJRnXE0zISAHz1mRZIHXHAq+MUBOQF7d6AeCAckc2xYlQ==", + "dev": true + }, + "@hazae41/rimraf": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@hazae41/rimraf/-/rimraf-1.0.1.tgz", + "integrity": "sha512-EmzbyXflKMxnfiEAsE2jn84Bo2WeTxPasdasQ0JP4gisCa3n9qrB2tiR9fmRsrkS6wH/H16oBsu4dkyfaJiKQw==", + "dev": true + }, + "@jridgewell/sourcemap-codec": { + "version": "1.4.15", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz", + "integrity": "sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg==", + "dev": true + }, + "@rollup/plugin-typescript": { + "version": "11.1.5", + "resolved": "https://registry.npmjs.org/@rollup/plugin-typescript/-/plugin-typescript-11.1.5.tgz", + "integrity": "sha512-rnMHrGBB0IUEv69Q8/JGRD/n4/n6b3nfpufUu26axhUcboUzv/twfZU8fIBbTOphRAe0v8EyxzeDpKXqGHfyDA==", + "dev": true, + "requires": { + "@rollup/pluginutils": "^5.0.1", + "resolve": "^1.22.1" + } + }, + "@rollup/pluginutils": { + "version": "5.0.5", + "resolved": "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-5.0.5.tgz", + "integrity": "sha512-6aEYR910NyP73oHiJglti74iRyOwgFU4x3meH/H8OJx6Ry0j6cOVZ5X/wTvub7G7Ao6qaHBEaNsV3GLJkSsF+Q==", + "dev": true, + "requires": { + "@types/estree": "^1.0.0", + "estree-walker": "^2.0.2", + "picomatch": "^2.3.1" + } + }, + "@rollup/rollup-android-arm-eabi": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.0.2.tgz", + "integrity": "sha512-xDvk1pT4vaPU2BOLy0MqHMdYZyntqpaBf8RhBiezlqG9OjY8F50TyctHo8znigYKd+QCFhCmlmXHOL/LoaOl3w==", + "dev": true, + "optional": true + }, + "@rollup/rollup-android-arm64": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.0.2.tgz", + "integrity": "sha512-lqCglytY3E6raze27DD9VQJWohbwCxzqs9aSHcj5X/8hJpzZfNdbsr4Ja9Hqp6iPyF53+5PtPx0pKRlkSvlHZg==", + "dev": true, + "optional": true + }, + "@rollup/rollup-darwin-arm64": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.0.2.tgz", + "integrity": "sha512-nkBKItS6E6CCzvRwgiKad+j+1ibmL7SIInj7oqMWmdkCjiSX6VeVZw2mLlRKIUL+JjsBgpATTfo7BiAXc1v0jA==", + "dev": true, + "optional": true + }, + "@rollup/rollup-darwin-x64": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.0.2.tgz", + "integrity": "sha512-vX2C8xvWPIbpEgQht95+dY6BReKAvtDgPDGi0XN0kWJKkm4WdNmq5dnwscv/zxvi+n6jUTBhs6GtpkkWT4q8Gg==", + "dev": true, + "optional": true + }, + "@rollup/rollup-linux-arm-gnueabihf": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.0.2.tgz", + "integrity": "sha512-DVFIfcHOjgmeHOAqji4xNz2wczt1Bmzy9MwBZKBa83SjBVO/i38VHDR+9ixo8QpBOiEagmNw12DucG+v55tCrg==", + "dev": true, + "optional": true + }, + "@rollup/rollup-linux-arm64-gnu": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.0.2.tgz", + "integrity": "sha512-GCK/a9ItUxPI0V5hQEJjH4JtOJO90GF2Hja7TO+EZ8rmkGvEi8/ZDMhXmcuDpQT7/PWrTT9RvnG8snMd5SrhBQ==", + "dev": true, + "optional": true + }, + "@rollup/rollup-linux-arm64-musl": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.0.2.tgz", + "integrity": "sha512-cLuBp7rOjIB1R2j/VazjCmHC7liWUur2e9mFflLJBAWCkrZ+X0+QwHLvOQakIwDymungzAKv6W9kHZnTp/Mqrg==", + "dev": true, + "optional": true + }, + "@rollup/rollup-linux-x64-gnu": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.0.2.tgz", + "integrity": "sha512-Zqw4iVnJr2naoyQus0yLy7sLtisCQcpdMKUCeXPBjkJtpiflRime/TMojbnl8O3oxUAj92mxr+t7im/RbgA20w==", + "dev": true, + "optional": true + }, + "@rollup/rollup-linux-x64-musl": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.0.2.tgz", + "integrity": "sha512-jJRU9TyUD/iMqjf8aLAp7XiN3pIj5v6Qcu+cdzBfVTKDD0Fvua4oUoK8eVJ9ZuKBEQKt3WdlcwJXFkpmMLk6kg==", + "dev": true, + "optional": true + }, + "@rollup/rollup-win32-arm64-msvc": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.0.2.tgz", + "integrity": "sha512-ZkS2NixCxHKC4zbOnw64ztEGGDVIYP6nKkGBfOAxEPW71Sji9v8z3yaHNuae/JHPwXA+14oDefnOuVfxl59SmQ==", + "dev": true, + "optional": true + }, + "@rollup/rollup-win32-ia32-msvc": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.0.2.tgz", + "integrity": "sha512-3SKjj+tvnZ0oZq2BKB+fI+DqYI83VrRzk7eed8tJkxeZ4zxJZcLSE8YDQLYGq1tZAnAX+H076RHHB4gTZXsQzw==", + "dev": true, + "optional": true + }, + "@rollup/rollup-win32-x64-msvc": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.0.2.tgz", + "integrity": "sha512-MBdJIOxRauKkry7t2q+rTHa3aWjVez2eioWg+etRVS3dE4tChhmt5oqZYr48R6bPmcwEhxQr96gVRfeQrLbqng==", + "dev": true, + "optional": true + }, + "@types/estree": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.2.tgz", + "integrity": "sha512-VeiPZ9MMwXjO32/Xu7+OwflfmeoRwkE/qzndw42gGtgJwZopBnzy2gD//NN1+go1mADzkDcqf/KnFRSjTJ8xJA==", + "dev": true + }, + "@types/node": { + "version": "20.8.4", + "resolved": "https://registry.npmjs.org/@types/node/-/node-20.8.4.tgz", + "integrity": "sha512-ZVPnqU58giiCjSxjVUESDtdPk4QR5WQhhINbc9UBrKLU68MX5BF6kbQzTrkwbolyr0X8ChBpXfavr5mZFKZQ5A==", + "dev": true, + "requires": { + "undici-types": "~5.25.1" + } + }, + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "dev": true, + "optional": true, + "requires": { + "color-convert": "^1.9.0" + } + }, + "chalk": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", + "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "dev": true, + "optional": true, + "requires": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + } + }, + "color-convert": { + "version": "1.9.3", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz", + "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==", + "dev": true, + "optional": true, + "requires": { + "color-name": "1.1.3" + } + }, + "color-name": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", + "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==", + "dev": true, + "optional": true + }, + "escape-string-regexp": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", + "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==", + "dev": true, + "optional": true + }, + "estree-walker": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz", + "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==", + "dev": true + }, + "fsevents": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz", + "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==", + "dev": true, + "optional": true + }, + "function-bind": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz", + "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==", + "dev": true + }, + "has": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz", + "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==", + "dev": true, + "requires": { + "function-bind": "^1.1.1" + } + }, + "has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==", + "dev": true, + "optional": true + }, + "is-core-module": { + "version": "2.11.0", + "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.11.0.tgz", + "integrity": "sha512-RRjxlvLDkD1YJwDbroBHMb+cukurkDWNyHx7D3oNB5x9rb5ogcksMC5wHCadcXoo67gVr/+3GFySh3134zi6rw==", + "dev": true, + "requires": { + "has": "^1.0.3" + } + }, + "js-tokens": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz", + "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==", + "dev": true, + "optional": true + }, + "magic-string": { + "version": "0.30.4", + "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.4.tgz", + "integrity": "sha512-Q/TKtsC5BPm0kGqgBIF9oXAs/xEf2vRKiIB4wCRQTJOQIByZ1d+NnUOotvJOvNpi5RNIgVOMC3pOuaP1ZTDlVg==", + "dev": true, + "requires": { + "@jridgewell/sourcemap-codec": "^1.4.15" + } + }, + "path-parse": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz", + "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==", + "dev": true + }, + "picomatch": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", + "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", + "dev": true + }, + "resolve": { + "version": "1.22.1", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.1.tgz", + "integrity": "sha512-nBpuuYuY5jFsli/JIs1oldw6fOQCBioohqWZg/2hiaOybXOft4lonv85uDOKXdf8rhyK159cxU5cDcK/NKk8zw==", + "dev": true, + "requires": { + "is-core-module": "^2.9.0", + "path-parse": "^1.0.7", + "supports-preserve-symlinks-flag": "^1.0.0" + } + }, + "rollup": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.0.2.tgz", + "integrity": "sha512-MCScu4usMPCeVFaiLcgMDaBQeYi1z6vpWxz0r0hq0Hv77Y2YuOTZldkuNJ54BdYBH3e+nkrk6j0Rre/NLDBYzg==", + "dev": true, + "requires": { + "@rollup/rollup-android-arm-eabi": "4.0.2", + "@rollup/rollup-android-arm64": "4.0.2", + "@rollup/rollup-darwin-arm64": "4.0.2", + "@rollup/rollup-darwin-x64": "4.0.2", + "@rollup/rollup-linux-arm-gnueabihf": "4.0.2", + "@rollup/rollup-linux-arm64-gnu": "4.0.2", + "@rollup/rollup-linux-arm64-musl": "4.0.2", + "@rollup/rollup-linux-x64-gnu": "4.0.2", + "@rollup/rollup-linux-x64-musl": "4.0.2", + "@rollup/rollup-win32-arm64-msvc": "4.0.2", + "@rollup/rollup-win32-ia32-msvc": "4.0.2", + "@rollup/rollup-win32-x64-msvc": "4.0.2", + "fsevents": "~2.3.2" + } + }, + "rollup-plugin-dts": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/rollup-plugin-dts/-/rollup-plugin-dts-6.1.0.tgz", + "integrity": "sha512-ijSCPICkRMDKDLBK9torss07+8dl9UpY9z1N/zTeA1cIqdzMlpkV3MOOC7zukyvQfDyxa1s3Dl2+DeiP/G6DOw==", + "dev": true, + "requires": { + "@babel/code-frame": "^7.22.13", + "magic-string": "^0.30.4" + } + }, + "rollup-plugin-node-externals": { + "version": "6.1.2", + "resolved": "https://registry.npmjs.org/rollup-plugin-node-externals/-/rollup-plugin-node-externals-6.1.2.tgz", + "integrity": "sha512-2TWan0u0/zHcgPrKpIPgKSY8OMqwDAYD380I0hxx7iUQw8mrN34DWwG9sQUMEo5Yy4xd6/5QEAySYgiKN9fdBQ==", + "dev": true, + "requires": {} + }, + "supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "dev": true, + "optional": true, + "requires": { + "has-flag": "^3.0.0" + } + }, + "supports-preserve-symlinks-flag": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz", + "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==", + "dev": true + }, + "tslib": { + "version": "2.6.2", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.6.2.tgz", + "integrity": "sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q==", + "dev": true, + "optional": true, + "peer": true + }, + "typescript": { + "version": "5.2.2", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.2.2.tgz", + "integrity": "sha512-mI4WrpHsbCIcwT9cF4FZvr80QUeKvsUsUvKDoR+X/7XHQH98xYD8YHZg7ANtz2GtZt/CBq2QJ0thkGJMHfqc1w==", + "dev": true + }, + "undici-types": { + "version": "5.25.3", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.25.3.tgz", + "integrity": "sha512-Ga1jfYwRn7+cP9v8auvEXN1rX3sWqlayd4HP7OKk4mZWylEmu3KzXDUGrQUN6Ol7qo1gPvB2e5gX6udnyEPgdA==", + "dev": true + } + } +} diff --git a/package.json b/package.json new file mode 100644 index 0000000..79bb586 --- /dev/null +++ b/package.json @@ -0,0 +1,48 @@ +{ + "type": "module", + "name": "example", + "version": "1.0.0", + "description": "Example Snap written in Rust", + "homepage": "https://github.com/example/example", + "repository": "github:example/example", + "author": "hazae41", + "license": "MIT", + "main": "./dist/cjs/src/node/index.cjs", + "module": "./dist/esm/src/node/index.mjs", + "types": "./dist/types/src/node/index.d.ts", + "sideEffects": false, + "files": [ + "./dist/esm", + "./dist/cjs", + "./dist/types" + ], + "scripts": { + "build:wasm": "cd wasm && rimraf pkg && wasm-pack build --target web --release && cd .. && node patch.js", + "build:dist": "rimraf dist && rollup -c", + "build": "npm run build:wasm && npm run build:dist", + "test:node": "node ./dist/test/src/node/index.test.mjs", + "test:deno": "deno run -A --unstable ./src/deno/mod.test.ts", + "test": "npm run test:node && npm run test:deno", + "bench:node": "node ./dist/bench/src/node/index.bench.mjs", + "prepare": "npm run build:dist" + }, + "devDependencies": { + "@hazae41/deimos": "^1.0.6", + "@hazae41/phobos": "^1.0.10", + "@hazae41/rimraf": "^1.0.1", + "@rollup/plugin-typescript": "^11.1.5", + "@types/node": "^20.8.4", + "rollup": "^4.0.2", + "rollup-plugin-dts": "^6.1.0", + "rollup-plugin-node-externals": "^6.1.2", + "typescript": "^5.2.2" + }, + "exports": { + ".": { + "types": "./dist/types/src/node/index.d.ts", + "import": "./dist/esm/src/node/index.mjs", + "require": "./dist/cjs/src/node/index.cjs" + } + }, + "keywords": [] +} diff --git a/patch.js b/patch.js new file mode 100644 index 0000000..9c6dcdd --- /dev/null +++ b/patch.js @@ -0,0 +1,29 @@ +import { readFileSync, rmSync, writeFileSync } from "fs"; + +const wasm = readFileSync("./wasm/pkg/example_bg.wasm") + +writeFileSync(`./wasm/pkg/example.wasm.js`, `export const data = "data:application/wasm;base64,${wasm.toString("base64")}";`); +writeFileSync(`./wasm/pkg/example.wasm.d.ts`, `export const data: string;`); + +const disposableJs = ` [Symbol.dispose]() { + this.free() + } + + free() {` + +const disposableTs = ` [Symbol.dispose](): void + free(): void;` + +const glueJs = readFileSync(`./wasm/pkg/example.js`, "utf8") + .replace("async function __wbg_init", "export async function __wbg_init") + .replace("input = new URL('example_bg.wasm', import.meta.url);", "throw new Error();") + .replaceAll(" free() {", disposableJs) + +const glueTs = readFileSync(`./wasm/pkg/example.d.ts`, "utf8") + .replace("export default function __wbg_init", "export function __wbg_init") + .replaceAll(" free(): void;", disposableTs) + +writeFileSync(`./wasm/pkg/example.js`, glueJs) +writeFileSync(`./wasm/pkg/example.d.ts`, glueTs) + +rmSync(`./wasm/pkg/.gitignore`, { force: true }); \ No newline at end of file diff --git a/rollup.config.js b/rollup.config.js new file mode 100644 index 0000000..5d44676 --- /dev/null +++ b/rollup.config.js @@ -0,0 +1,64 @@ +import ts from "@rollup/plugin-typescript"; +import dts from "rollup-plugin-dts"; +import externals from "rollup-plugin-node-externals"; + +export const config = [ + { + input: "./src/node/index.ts", + output: [{ + dir: "./dist/esm", + format: "esm", + exports: "named", + preserveModules: true, + sourcemap: true, + entryFileNames: "[name].mjs", + }, { + dir: "./dist/cjs", + format: "cjs", + exports: "named", + preserveModules: true, + sourcemap: true, + entryFileNames: "[name].cjs", + }], + plugins: [externals(), ts()] + }, + { + input: "./src/node/index.ts", + output: [{ + dir: "./dist/types", + format: "esm", + exports: "named", + preserveModules: true, + sourcemap: false, + entryFileNames: "[name].d.ts", + }], + plugins: [externals(), ts(), dts()], + external: [/^lib/] + }, + { + input: "./src/node/index.test.ts", + output: [{ + dir: "./dist/test", + format: "esm", + exports: "named", + preserveModules: true, + sourcemap: true, + entryFileNames: "[name].mjs" + }], + plugins: [externals({ devDeps: true }), ts()], + }, + { + input: "./src/node/index.bench.ts", + output: [{ + dir: "./dist/bench", + format: "esm", + exports: "named", + preserveModules: true, + sourcemap: true, + entryFileNames: "[name].mjs" + }], + plugins: [externals({ devDeps: true }), ts()], + }, +] + +export default config \ No newline at end of file diff --git a/src/deno/mod.bench.ts b/src/deno/mod.bench.ts new file mode 100644 index 0000000..8b0173c --- /dev/null +++ b/src/deno/mod.bench.ts @@ -0,0 +1 @@ +console.log("no bench") \ No newline at end of file diff --git a/src/deno/mod.test.ts b/src/deno/mod.test.ts new file mode 100644 index 0000000..736a01f --- /dev/null +++ b/src/deno/mod.test.ts @@ -0,0 +1 @@ +console.log("no test") \ No newline at end of file diff --git a/src/deno/mod.ts b/src/deno/mod.ts new file mode 100644 index 0000000..04646b4 --- /dev/null +++ b/src/deno/mod.ts @@ -0,0 +1,2 @@ +export * from "./mods/mod.ts"; + diff --git a/src/deno/mods/mod.ts b/src/deno/mods/mod.ts new file mode 100644 index 0000000..d8daf77 --- /dev/null +++ b/src/deno/mods/mod.ts @@ -0,0 +1,11 @@ +export * from "../../../wasm/pkg/example.js"; + +// @deno-types="../../../wasm/pkg/example.d.ts" +import { __wbg_init, InitOutput } from "../../../wasm/pkg/example.js"; +import { data } from "../../../wasm/pkg/example.wasm.js"; + +let output: InitOutput | undefined = undefined + +export async function initBundledOnce() { + return output ??= await __wbg_init(data) +} \ No newline at end of file diff --git a/src/node/index.bench.ts b/src/node/index.bench.ts new file mode 100644 index 0000000..8b0173c --- /dev/null +++ b/src/node/index.bench.ts @@ -0,0 +1 @@ +console.log("no bench") \ No newline at end of file diff --git a/src/node/index.test.ts b/src/node/index.test.ts new file mode 100644 index 0000000..e4eb5d4 --- /dev/null +++ b/src/node/index.test.ts @@ -0,0 +1,23 @@ +import { test } from "@hazae41/phobos" +import { Snap, initBundledOnce } from "index.js" + +await test("test", async () => { + await initBundledOnce() + + const snap = new Snap({ + log(text: string) { + console.log("[snap]", text) + } + }) + + function request(data: unknown) { + return JSON.parse(snap.on_request(JSON.stringify(data))) + } + + const response = request({ + method: "hello", + params: ["world"] + }) + + console.log(response) +}) \ No newline at end of file diff --git a/src/node/index.ts b/src/node/index.ts new file mode 100644 index 0000000..6faa640 --- /dev/null +++ b/src/node/index.ts @@ -0,0 +1 @@ +export * from "./mods/index.js"; diff --git a/src/node/mods/index.ts b/src/node/mods/index.ts new file mode 100644 index 0000000..62ee5d2 --- /dev/null +++ b/src/node/mods/index.ts @@ -0,0 +1,10 @@ +export * from "../../../wasm/pkg/example.js"; + +import { InitOutput, __wbg_init } from "../../../wasm/pkg/example.js"; +import { data } from "../../../wasm/pkg/example.wasm.js"; + +let output: InitOutput | undefined = undefined + +export async function initBundledOnce() { + return output ??= await __wbg_init(data) +} \ No newline at end of file diff --git a/tsconfig.json b/tsconfig.json new file mode 100644 index 0000000..82944a8 --- /dev/null +++ b/tsconfig.json @@ -0,0 +1,30 @@ +{ + "compilerOptions": { + "target": "ESNext", + "baseUrl": "./src/node", + "module": "NodeNext", + "moduleResolution": "NodeNext", + "strict": true, + "downlevelIteration": true, + "lib": [ + "DOM", + "ESNext" + ], + "paths": { + "mods/*": [ + "mods/*" + ], + "libs/*": [ + "libs/*" + ], + "tests/*": [ + "tests/*" + ], + } + }, + "include": [ + "./src/node/index.ts", + "./src/node/index.test.ts", + "./src/node/index.bench.ts" + ], +} \ No newline at end of file diff --git a/wasm/.gitignore b/wasm/.gitignore new file mode 100644 index 0000000..1de5659 --- /dev/null +++ b/wasm/.gitignore @@ -0,0 +1 @@ +target \ No newline at end of file diff --git a/wasm/Cargo.lock b/wasm/Cargo.lock new file mode 100644 index 0000000..a98a6e3 --- /dev/null +++ b/wasm/Cargo.lock @@ -0,0 +1,170 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "bumpalo" +version = "3.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0d261e256854913907f67ed06efbc3338dfe6179796deefc1ff763fc1aee5535" + +[[package]] +name = "cfg-if" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" + +[[package]] +name = "example" +version = "1.0.0" +dependencies = [ + "serde_json", + "wasm-bindgen", +] + +[[package]] +name = "itoa" +version = "1.0.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b1a46d1a171d865aa5f83f92695765caa047a9b4cbae2cbf37dbd613a793fd4c" + +[[package]] +name = "log" +version = "0.4.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "once_cell" +version = "1.17.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6f61fba1741ea2b3d6a1e3178721804bb716a68a6aeba1149b5d52e3d464ea66" + +[[package]] +name = "proc-macro2" +version = "1.0.66" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "18fb31db3f9bddb2ea821cde30a9f70117e3f119938b5ee630b7403aa6e2ead9" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quote" +version = "1.0.33" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "ryu" +version = "1.0.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f98d2aa92eebf49b69786be48e4477826b256916e84a57ff2a4f21923b48eb4c" + +[[package]] +name = "serde" +version = "1.0.193" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "25dd9975e68d0cb5aa1120c288333fc98731bd1dd12f561e468ea4728c042b89" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.193" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "43576ca501357b9b071ac53cdc7da8ef0cbd9493d8df094cd821777ea6e894d3" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "serde_json" +version = "1.0.108" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3d1c7e3eac408d115102c4c24ad393e0821bb3a5df4d506a80f85f7a742a526b" +dependencies = [ + "itoa", + "ryu", + "serde", +] + +[[package]] +name = "syn" +version = "2.0.29" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c324c494eba9d92503e6f1ef2e6df781e78f6a7705a0202d9801b198807d518a" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "unicode-ident" +version = "1.0.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "84a22b9f218b40614adcb3f4ff08b703773ad44fa9423e4e0d346d5db86e4ebc" + +[[package]] +name = "wasm-bindgen" +version = "0.2.89" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ed0d4f68a3015cc185aff4db9506a015f4b96f95303897bfa23f846db54064e" +dependencies = [ + "cfg-if", + "wasm-bindgen-macro", +] + +[[package]] +name = "wasm-bindgen-backend" +version = "0.2.89" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b56f625e64f3a1084ded111c4d5f477df9f8c92df113852fa5a374dbda78826" +dependencies = [ + "bumpalo", + "log", + "once_cell", + "proc-macro2", + "quote", + "syn", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-macro" +version = "0.2.89" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0162dbf37223cd2afce98f3d0785506dcb8d266223983e4b5b525859e6e182b2" +dependencies = [ + "quote", + "wasm-bindgen-macro-support", +] + +[[package]] +name = "wasm-bindgen-macro-support" +version = "0.2.89" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0eb82fcb7930ae6219a7ecfd55b217f5f0893484b7a13022ebb2b2bf20b5283" +dependencies = [ + "proc-macro2", + "quote", + "syn", + "wasm-bindgen-backend", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-shared" +version = "0.2.89" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7ab9b36309365056cd639da3134bf87fa8f3d86008abf99e612384a6eecd459f" diff --git a/wasm/Cargo.toml b/wasm/Cargo.toml new file mode 100644 index 0000000..0de3bcf --- /dev/null +++ b/wasm/Cargo.toml @@ -0,0 +1,21 @@ +[package] +name = "example" +version = "1.0.0" +authors = ["hazae41 "] +edition = "2021" + +description = "An example Snap written in Rust" +repository = "https://github.com/example/example" +license = "MIT" + +[lib] +crate-type = ["cdylib"] + +[profile.release] +lto = true +debug = false +opt-level = 3 + +[dependencies] +wasm-bindgen = { version = "0.2.89", default-features = false, features= ["std"] } +serde_json = "1.0" \ No newline at end of file diff --git a/wasm/LICENSE.md b/wasm/LICENSE.md new file mode 100644 index 0000000..e5846bb --- /dev/null +++ b/wasm/LICENSE.md @@ -0,0 +1,21 @@ +This is free and unencumbered software released into the public domain. + +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. + +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +For more information, please refer to diff --git a/wasm/README.md b/wasm/README.md new file mode 100644 index 0000000..a0c1b61 --- /dev/null +++ b/wasm/README.md @@ -0,0 +1 @@ +# wasm diff --git a/wasm/pkg/LICENSE.md b/wasm/pkg/LICENSE.md new file mode 100644 index 0000000..e5846bb --- /dev/null +++ b/wasm/pkg/LICENSE.md @@ -0,0 +1,21 @@ +This is free and unencumbered software released into the public domain. + +Anyone is free to copy, modify, publish, use, compile, sell, or distribute this +software, either in source code form or as a compiled binary, for any purpose, +commercial or non-commercial, and by any means. + +In jurisdictions that recognize copyright laws, the author or authors of this +software dedicate any and all copyright interest in the software to the public +domain. We make this dedication for the benefit of the public at large and to +the detriment of our heirs and successors. We intend this dedication to be an +overt act of relinquishment in perpetuity of all present and future rights to +this software under copyright law. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF +CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +For more information, please refer to diff --git a/wasm/pkg/README.md b/wasm/pkg/README.md new file mode 100644 index 0000000..a0c1b61 --- /dev/null +++ b/wasm/pkg/README.md @@ -0,0 +1 @@ +# wasm diff --git a/wasm/pkg/example.d.ts b/wasm/pkg/example.d.ts new file mode 100644 index 0000000..678502a --- /dev/null +++ b/wasm/pkg/example.d.ts @@ -0,0 +1,51 @@ +/* tslint:disable */ +/* eslint-disable */ +/** +*/ +export class Snap { + [Symbol.dispose](): void + free(): void; +/** +* @param {any} context +*/ + constructor(context: any); +/** +* @param {string} request +* @returns {string} +*/ + on_request(request: string): string; +} + +export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module; + +export interface InitOutput { + readonly memory: WebAssembly.Memory; + readonly __wbg_snap_free: (a: number) => void; + readonly snap_new: (a: number) => number; + readonly snap_on_request: (a: number, b: number, c: number, d: number) => void; + readonly __wbindgen_add_to_stack_pointer: (a: number) => number; + readonly __wbindgen_malloc: (a: number, b: number) => number; + readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number; + readonly __wbindgen_free: (a: number, b: number, c: number) => void; +} + +export type SyncInitInput = BufferSource | WebAssembly.Module; +/** +* Instantiates the given `module`, which can either be bytes or +* a precompiled `WebAssembly.Module`. +* +* @param {SyncInitInput} module +* +* @returns {InitOutput} +*/ +export function initSync(module: SyncInitInput): InitOutput; + +/** +* If `module_or_path` is {RequestInfo} or {URL}, makes a request and +* for everything else, calls `WebAssembly.instantiate` directly. +* +* @param {InitInput | Promise} module_or_path +* +* @returns {Promise} +*/ +export function __wbg_init (module_or_path?: InitInput | Promise): Promise; diff --git a/wasm/pkg/example.js b/wasm/pkg/example.js new file mode 100644 index 0000000..913a438 --- /dev/null +++ b/wasm/pkg/example.js @@ -0,0 +1,273 @@ +let wasm; + +const heap = new Array(128).fill(undefined); + +heap.push(undefined, null, true, false); + +function getObject(idx) { return heap[idx]; } + +let heap_next = heap.length; + +function dropObject(idx) { + if (idx < 132) return; + heap[idx] = heap_next; + heap_next = idx; +} + +function takeObject(idx) { + const ret = getObject(idx); + dropObject(idx); + return ret; +} + +const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } ); + +if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); }; + +let cachedUint8Memory0 = null; + +function getUint8Memory0() { + if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) { + cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer); + } + return cachedUint8Memory0; +} + +function getStringFromWasm0(ptr, len) { + ptr = ptr >>> 0; + return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len)); +} + +function addHeapObject(obj) { + if (heap_next === heap.length) heap.push(heap.length + 1); + const idx = heap_next; + heap_next = heap[idx]; + + heap[idx] = obj; + return idx; +} + +let WASM_VECTOR_LEN = 0; + +const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } ); + +const encodeString = (typeof cachedTextEncoder.encodeInto === 'function' + ? function (arg, view) { + return cachedTextEncoder.encodeInto(arg, view); +} + : function (arg, view) { + const buf = cachedTextEncoder.encode(arg); + view.set(buf); + return { + read: arg.length, + written: buf.length + }; +}); + +function passStringToWasm0(arg, malloc, realloc) { + + if (realloc === undefined) { + const buf = cachedTextEncoder.encode(arg); + const ptr = malloc(buf.length, 1) >>> 0; + getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf); + WASM_VECTOR_LEN = buf.length; + return ptr; + } + + let len = arg.length; + let ptr = malloc(len, 1) >>> 0; + + const mem = getUint8Memory0(); + + let offset = 0; + + for (; offset < len; offset++) { + const code = arg.charCodeAt(offset); + if (code > 0x7F) break; + mem[ptr + offset] = code; + } + + if (offset !== len) { + if (offset !== 0) { + arg = arg.slice(offset); + } + ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0; + const view = getUint8Memory0().subarray(ptr + offset, ptr + len); + const ret = encodeString(arg, view); + + offset += ret.written; + } + + WASM_VECTOR_LEN = offset; + return ptr; +} + +let cachedInt32Memory0 = null; + +function getInt32Memory0() { + if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) { + cachedInt32Memory0 = new Int32Array(wasm.memory.buffer); + } + return cachedInt32Memory0; +} +/** +*/ +export class Snap { + + __destroy_into_raw() { + const ptr = this.__wbg_ptr; + this.__wbg_ptr = 0; + + return ptr; + } + + [Symbol.dispose]() { + this.free() + } + + free() { + const ptr = this.__destroy_into_raw(); + wasm.__wbg_snap_free(ptr); + } + /** + * @param {any} context + */ + constructor(context) { + const ret = wasm.snap_new(addHeapObject(context)); + this.__wbg_ptr = ret >>> 0; + return this; + } + /** + * @param {string} request + * @returns {string} + */ + on_request(request) { + let deferred3_0; + let deferred3_1; + try { + const retptr = wasm.__wbindgen_add_to_stack_pointer(-16); + const ptr0 = passStringToWasm0(request, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + wasm.snap_on_request(retptr, this.__wbg_ptr, ptr0, len0); + var r0 = getInt32Memory0()[retptr / 4 + 0]; + var r1 = getInt32Memory0()[retptr / 4 + 1]; + var r2 = getInt32Memory0()[retptr / 4 + 2]; + var r3 = getInt32Memory0()[retptr / 4 + 3]; + var ptr2 = r0; + var len2 = r1; + if (r3) { + ptr2 = 0; len2 = 0; + throw takeObject(r2); + } + deferred3_0 = ptr2; + deferred3_1 = len2; + return getStringFromWasm0(ptr2, len2); + } finally { + wasm.__wbindgen_add_to_stack_pointer(16); + wasm.__wbindgen_free(deferred3_0, deferred3_1, 1); + } + } +} + +async function __wbg_load(module, imports) { + if (typeof Response === 'function' && module instanceof Response) { + if (typeof WebAssembly.instantiateStreaming === 'function') { + try { + return await WebAssembly.instantiateStreaming(module, imports); + + } catch (e) { + if (module.headers.get('Content-Type') != 'application/wasm') { + console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e); + + } else { + throw e; + } + } + } + + const bytes = await module.arrayBuffer(); + return await WebAssembly.instantiate(bytes, imports); + + } else { + const instance = await WebAssembly.instantiate(module, imports); + + if (instance instanceof WebAssembly.Instance) { + return { instance, module }; + + } else { + return instance; + } + } +} + +function __wbg_get_imports() { + const imports = {}; + imports.wbg = {}; + imports.wbg.__wbindgen_object_drop_ref = function(arg0) { + takeObject(arg0); + }; + imports.wbg.__wbg_log_2cba412808b55be6 = function(arg0, arg1, arg2) { + getObject(arg0).log(getStringFromWasm0(arg1, arg2)); + }; + imports.wbg.__wbindgen_error_new = function(arg0, arg1) { + const ret = new Error(getStringFromWasm0(arg0, arg1)); + return addHeapObject(ret); + }; + imports.wbg.__wbindgen_throw = function(arg0, arg1) { + throw new Error(getStringFromWasm0(arg0, arg1)); + }; + + return imports; +} + +function __wbg_init_memory(imports, maybe_memory) { + +} + +function __wbg_finalize_init(instance, module) { + wasm = instance.exports; + __wbg_init.__wbindgen_wasm_module = module; + cachedInt32Memory0 = null; + cachedUint8Memory0 = null; + + + return wasm; +} + +function initSync(module) { + if (wasm !== undefined) return wasm; + + const imports = __wbg_get_imports(); + + __wbg_init_memory(imports); + + if (!(module instanceof WebAssembly.Module)) { + module = new WebAssembly.Module(module); + } + + const instance = new WebAssembly.Instance(module, imports); + + return __wbg_finalize_init(instance, module); +} + +export async function __wbg_init(input) { + if (wasm !== undefined) return wasm; + + if (typeof input === 'undefined') { + throw new Error(); + } + const imports = __wbg_get_imports(); + + if (typeof input === 'string' || (typeof Request === 'function' && input instanceof Request) || (typeof URL === 'function' && input instanceof URL)) { + input = fetch(input); + } + + __wbg_init_memory(imports); + + const { instance, module } = await __wbg_load(await input, imports); + + return __wbg_finalize_init(instance, module); +} + +export { initSync } +export default __wbg_init; diff --git a/wasm/pkg/example.wasm.d.ts b/wasm/pkg/example.wasm.d.ts new file mode 100644 index 0000000..6e7197d --- /dev/null +++ b/wasm/pkg/example.wasm.d.ts @@ -0,0 +1 @@ +export const data: string; \ No newline at end of file diff --git a/wasm/pkg/example.wasm.js b/wasm/pkg/example.wasm.js new file mode 100644 index 0000000..1d7344f --- /dev/null +++ b/wasm/pkg/example.wasm.js @@ -0,0 +1 @@ +export const data = "data:application/wasm;base64,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"; \ No newline at end of file diff --git a/wasm/pkg/example_bg.wasm b/wasm/pkg/example_bg.wasm new file mode 100644 index 0000000000000000000000000000000000000000..dd8a1c1f5113087bf73936c217866806001db0a5 GIT binary patch literal 61718 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 literal 0 HcmV?d00001 diff --git a/wasm/pkg/example_bg.wasm.d.ts b/wasm/pkg/example_bg.wasm.d.ts new file mode 100644 index 0000000..ea295f5 --- /dev/null +++ b/wasm/pkg/example_bg.wasm.d.ts @@ -0,0 +1,10 @@ +/* tslint:disable */ +/* eslint-disable */ +export const memory: WebAssembly.Memory; +export function __wbg_snap_free(a: number): void; +export function snap_new(a: number): number; +export function snap_on_request(a: number, b: number, c: number, d: number): void; +export function __wbindgen_add_to_stack_pointer(a: number): number; +export function __wbindgen_malloc(a: number, b: number): number; +export function __wbindgen_realloc(a: number, b: number, c: number, d: number): number; +export function __wbindgen_free(a: number, b: number, c: number): void; diff --git a/wasm/pkg/package.json b/wasm/pkg/package.json new file mode 100644 index 0000000..6ffb299 --- /dev/null +++ b/wasm/pkg/package.json @@ -0,0 +1,23 @@ +{ + "name": "example", + "collaborators": [ + "hazae41 " + ], + "description": "An example Snap written in Rust", + "version": "1.0.0", + "license": "MIT", + "repository": { + "type": "git", + "url": "https://github.com/example/example" + }, + "files": [ + "example_bg.wasm", + "example.js", + "example.d.ts" + ], + "module": "example.js", + "types": "example.d.ts", + "sideEffects": [ + "./snippets/*" + ] +} \ No newline at end of file diff --git a/wasm/src/lib.rs b/wasm/src/lib.rs new file mode 100644 index 0000000..80e8c6b --- /dev/null +++ b/wasm/src/lib.rs @@ -0,0 +1,68 @@ +#![no_std] + +extern crate alloc; + +use alloc::{ + format, + string::{String, ToString}, +}; +use serde_json::{json, Value}; +use wasm_bindgen::prelude::*; + +#[wasm_bindgen] +extern "C" { + pub type Context; + + #[wasm_bindgen(method)] + fn log(this: &Context, text: &str); +} + +#[wasm_bindgen] +pub struct Snap { + pub(crate) context: Context, +} + +#[wasm_bindgen] +impl Snap { + #[wasm_bindgen(constructor)] + pub fn new(context: Context) -> Snap { + Snap { context } + } + + #[wasm_bindgen] + pub fn on_request(&self, request: &str) -> Result { + self.context.log(format!("on_request {}", request).as_str()); + + let req = serde_json::from_str::(request)?; + + let method = req + .as_object() + .unwrap_throw() + .get("method") + .unwrap_throw() + .as_str() + .unwrap_throw(); + + match method { + "hello" => Ok(self.on_hello(&req)?.to_string()), + _ => Err(JsError::new("Unknown method")), + } + } + + fn on_hello(&self, req: &Value) -> Result { + let params = req.get("params").unwrap_throw(); + + let message = params + .as_array() + .unwrap_throw() + .get(0) + .unwrap_throw() + .as_str() + .unwrap_throw(); + + match message { + "world" => Ok(json!("Hello world")), + _ => Err(JsError::new("Unknown message")), + } + } +}