commit c975fb87ea80e5ef9bbddf16b7b404394f90e26b Author: Hatmos Date: Thu Jul 30 23:04:01 2026 +0200 premiere distribution de la page web diff --git a/README.md b/README.md new file mode 100644 index 0000000..e69de29 diff --git a/client/index.html b/client/index.html new file mode 100644 index 0000000..204e2f4 --- /dev/null +++ b/client/index.html @@ -0,0 +1,11 @@ + + + + + Ma page + + +

Bonjour !

Ceci est une page statique servie par Express.

+ + diff --git a/client/node_modules/.bin/nanoid b/client/node_modules/.bin/nanoid new file mode 120000 index 0000000..e2be547 --- /dev/null +++ b/client/node_modules/.bin/nanoid @@ -0,0 +1 @@ +../nanoid/bin/nanoid.cjs \ No newline at end of file diff --git a/client/node_modules/.bin/rolldown b/client/node_modules/.bin/rolldown new file mode 120000 index 0000000..7725012 --- /dev/null +++ b/client/node_modules/.bin/rolldown @@ -0,0 +1 @@ +../rolldown/bin/cli.mjs \ No newline at end of file diff --git a/client/node_modules/.bin/vite b/client/node_modules/.bin/vite new file mode 120000 index 0000000..6d1e3be --- /dev/null +++ b/client/node_modules/.bin/vite @@ -0,0 +1 @@ +../vite/bin/vite.js \ No newline at end of file diff --git a/client/node_modules/.package-lock.json b/client/node_modules/.package-lock.json new file mode 100644 index 0000000..651805b --- /dev/null +++ b/client/node_modules/.package-lock.json @@ -0,0 +1,424 @@ +{ + "name": "client", + "lockfileVersion": 3, + "requires": true, + "packages": { + "node_modules/@emnapi/core": { + "version": "2.0.0-alpha.3", + "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-2.0.0-alpha.3.tgz", + "integrity": "sha512-AZypUeJ/yByuxyS7BlSNRDOMLMlROYtjYdIAuBmJssVz1UJDSeYxLrdizhXCFYhedC5bqd/ASy8EuNXbVVXp9g==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "@emnapi/wasi-threads": "2.0.1", + "tslib": "^2.4.0" + } + }, + "node_modules/@emnapi/runtime": { + "version": "2.0.0-alpha.3", + "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-2.0.0-alpha.3.tgz", + "integrity": "sha512-hFPAhMUjJD9BSyCANEISPOogeXC9Zo9ZQl7L6vKnaVsMkCtzznaW/naYypeyl0Gv5rYfWYsZbpixTMpjDJzQeA==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "tslib": "^2.4.0" + } + }, + "node_modules/@emnapi/wasi-threads": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/@emnapi/wasi-threads/-/wasi-threads-2.0.1.tgz", + "integrity": "sha512-9DsSk+o5NBX0CCJT8s0EROGSGxjR/tKu6aBTaVyq+SjAEQH4XcdcRxPBRzsBLizTTJ49MJjF+jgu3qnO9GLQcQ==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "tslib": "^2.4.0" + } + }, + "node_modules/@napi-rs/wasm-runtime": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/@napi-rs/wasm-runtime/-/wasm-runtime-1.2.1.tgz", + "integrity": "sha512-KjZdi8Q1wh89gsVmghvbrMgWl6ZWmRmHV6wjB7/g4Zf0dyO+hH3neZUtuDNPO00qq5YE5RITVWvrIZKRaAmzGQ==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "@tybys/wasm-util": "^0.10.3" + }, + "engines": { + "node": "^20.19.0 || ^22.13.0 || >=23.5.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/Brooooooklyn" + }, + "peerDependencies": { + "@emnapi/core": "^1.7.1 || ^2.0.0-alpha.3", + "@emnapi/runtime": "^1.7.1 || ^2.0.0-alpha.3" + } + }, + "node_modules/@oxc-project/types": { + "version": "0.142.0", + "resolved": "https://registry.npmjs.org/@oxc-project/types/-/types-0.142.0.tgz", + "integrity": "sha512-7W+2q5AKQVU36fkaryontrHn3YDt1RyUYXatw9i5H8ocYe2sPKSFB6eS8WNPeRKiN1qAWWZUPm7gwFzJGrccqQ==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/Boshen" + } + }, + "node_modules/@rolldown/binding-linux-x64-gnu": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-gnu/-/binding-linux-x64-gnu-1.2.1.tgz", + "integrity": "sha512-/Orga1fZYkLc/56jBICcHrKchl8Z2UKdDSr3LG9ToWO1lQ6a4Livk9Xz+9WN91zsz5QR3XQz2NNoSDEvP6qadw==", + "cpu": [ + "x64" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-wasm32-wasi": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/@rolldown/binding-wasm32-wasi/-/binding-wasm32-wasi-1.2.1.tgz", + "integrity": "sha512-/TX0SoRGojHzSAHpfVBbavRVSazg5U3h3Y3VXfcc0cdugq6kxdqw8LPGFiPr+/7gE/60zRcsOY2Vi9b9eT0jww==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "@emnapi/core": "2.0.0-alpha.3", + "@emnapi/runtime": "2.0.0-alpha.3", + "@napi-rs/wasm-runtime": "^1.2.0" + }, + "engines": { + "node": "^20.19.0 || ^22.13.0 || >=23.5.0" + } + }, + "node_modules/@rolldown/pluginutils": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.1.tgz", + "integrity": "sha512-2j9bGt5Jh8hj+vPtgzPtl72j0yRxHAyumoo6TNfAjsLB04UtpSvPbPcDcBMxz7n+9CYB0c1GxQFxYRg2jimqGw==", + "dev": true, + "license": "MIT" + }, + "node_modules/@tybys/wasm-util": { + "version": "0.10.3", + "resolved": "https://registry.npmjs.org/@tybys/wasm-util/-/wasm-util-0.10.3.tgz", + "integrity": "sha512-F3fo1MYrRJYL3zER0OUOmkutjr1Vp23m7OsSgp7nq4SP6OqX6C/56XFIPAl5bt3zaBRjmW7SGz3u/6LwFpYcOg==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "tslib": "^2.4.0" + } + }, + "node_modules/detect-libc": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz", + "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=8" + } + }, + "node_modules/fdir": { + "version": "6.5.0", + "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz", + "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12.0.0" + }, + "peerDependencies": { + "picomatch": "^3 || ^4" + }, + "peerDependenciesMeta": { + "picomatch": { + "optional": true + } + } + }, + "node_modules/lightningcss": { + "version": "1.33.0", + "resolved": "https://registry.npmjs.org/lightningcss/-/lightningcss-1.33.0.tgz", + "integrity": "sha512-WkUDrojuJs0xkgGf2udWxa3yGBRxPtxUkB79i6aCZLRgc7PM8fZe9TosfPDcvEpQZbuFASnHYmRLBLUbmLOIIA==", + "dev": true, + "license": "MPL-2.0", + "dependencies": { + "detect-libc": "^2.0.3" + }, + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + }, + "optionalDependencies": { + "lightningcss-android-arm64": "1.33.0", + "lightningcss-darwin-arm64": "1.33.0", + "lightningcss-darwin-x64": "1.33.0", + "lightningcss-freebsd-x64": "1.33.0", + "lightningcss-linux-arm-gnueabihf": "1.33.0", + "lightningcss-linux-arm64-gnu": "1.33.0", + "lightningcss-linux-arm64-musl": "1.33.0", + "lightningcss-linux-x64-gnu": "1.33.0", + "lightningcss-linux-x64-musl": "1.33.0", + "lightningcss-win32-arm64-msvc": "1.33.0", + "lightningcss-win32-x64-msvc": "1.33.0" + } + }, + "node_modules/lightningcss-linux-x64-gnu": { + "version": "1.33.0", + "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-gnu/-/lightningcss-linux-x64-gnu-1.33.0.tgz", + "integrity": "sha512-ar+Ju7LmcN0Jo4FpL4hpFybwNG9/3A/Br5KW2n2jyODg3MEZXaDYADdemoNS+BDNfMgKvylJLj4S5tyRActuAg==", + "cpu": [ + "x64" + ], + "dev": true, + "libc": [ + "glibc" + ], + "license": "MPL-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/nanoid": { + "version": "3.3.16", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.16.tgz", + "integrity": "sha512-bzlKTyNJ7+LdGIIwy8ijFpIqEQIvafahV7eYykJ8Cvh42EdJeODoJ6gUJXpQJvej1BddH8OqTXZNE/KfbWAu8Q==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "bin": { + "nanoid": "bin/nanoid.cjs" + }, + "engines": { + "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" + } + }, + "node_modules/picocolors": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz", + "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==", + "dev": true, + "license": "ISC" + }, + "node_modules/picomatch": { + "version": "4.0.5", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.5.tgz", + "integrity": "sha512-RvwwcruNjI1ncT5xRakeyS9Lf8lcItv34KD+aif+VH9kduAyfYBipGh12274xtenIPZ119/R9BdTBa8gAwSh0A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/postcss": { + "version": "8.5.25", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.25.tgz", + "integrity": "sha512-DTPx3RWSSnWyzLxQnlH0rJP+EW5ekl16ZU4/psbIhA0e53kJfdgaN5vKM+xP7yJtXVu+nfdVFmlgFDEKAe4Pyw==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/postcss" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "nanoid": "^3.3.16", + "picocolors": "^1.1.1", + "source-map-js": "^1.2.1" + }, + "engines": { + "node": "^10 || ^12 || >=14" + } + }, + "node_modules/rolldown": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/rolldown/-/rolldown-1.2.1.tgz", + "integrity": "sha512-4FKJhg8d3OiyQOA6Q1Q0hoFFpW9/OoX+VsHzpECsdsIZoOArrAK90gl59YK/Z+gnDel45bgJZK03ozH/9bCqEw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@oxc-project/types": "=0.142.0", + "@rolldown/pluginutils": "^1.0.0" + }, + "bin": { + "rolldown": "bin/cli.mjs" + }, + "engines": { + "node": "^20.19.0 || >=22.12.0" + }, + "optionalDependencies": { + "@rolldown/binding-android-arm64": "1.2.1", + "@rolldown/binding-darwin-arm64": "1.2.1", + "@rolldown/binding-darwin-x64": "1.2.1", + "@rolldown/binding-freebsd-x64": "1.2.1", + "@rolldown/binding-linux-arm-gnueabihf": "1.2.1", + "@rolldown/binding-linux-arm64-gnu": "1.2.1", + "@rolldown/binding-linux-arm64-musl": "1.2.1", + "@rolldown/binding-linux-ppc64-gnu": "1.2.1", + "@rolldown/binding-linux-s390x-gnu": "1.2.1", + "@rolldown/binding-linux-x64-gnu": "1.2.1", + "@rolldown/binding-linux-x64-musl": "1.2.1", + "@rolldown/binding-openharmony-arm64": "1.2.1", + "@rolldown/binding-wasm32-wasi": "1.2.1", + "@rolldown/binding-win32-arm64-msvc": "1.2.1", + "@rolldown/binding-win32-x64-msvc": "1.2.1" + } + }, + "node_modules/source-map-js": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz", + "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/tinyglobby": { + "version": "0.2.17", + "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.17.tgz", + "integrity": "sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g==", + "dev": true, + "license": "MIT", + "dependencies": { + "fdir": "^6.5.0", + "picomatch": "^4.0.4" + }, + "engines": { + "node": ">=12.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/SuperchupuDev" + } + }, + "node_modules/tslib": { + "version": "2.8.1", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz", + "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==", + "dev": true, + "license": "0BSD", + "optional": true + }, + "node_modules/vite": { + "version": "8.2.0", + "resolved": "https://registry.npmjs.org/vite/-/vite-8.2.0.tgz", + "integrity": "sha512-pn+CFpM0lwDeKwmOq1ZaBK/9sjorZcgqxki6MbY/jPEVd9vichIlmlD4HmQ5wdP5EgqQCFRaACBxMC7uEGc6lQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "lightningcss": "^1.33.0", + "picomatch": "^4.0.5", + "postcss": "^8.5.23", + "rolldown": "~1.2.0", + "tinyglobby": "^0.2.17" + }, + "bin": { + "vite": "bin/vite.js" + }, + "engines": { + "node": "^20.19.0 || >=22.12.0" + }, + "funding": { + "url": "https://github.com/vitejs/vite?sponsor=1" + }, + "optionalDependencies": { + "fsevents": "~2.3.3" + }, + "peerDependencies": { + "@types/node": "^20.19.0 || >=22.12.0", + "@vitejs/devtools": "^0.4.0", + "esbuild": "^0.27.0 || ^0.28.0", + "jiti": ">=1.21.0", + "less": "^4.0.0", + "sass": "^1.70.0", + "sass-embedded": "^1.70.0", + "stylus": ">=0.54.8", + "sugarss": "^5.0.0", + "terser": "^5.16.0", + "tsx": "^4.8.1", + "yaml": "^2.4.2" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + }, + "@vitejs/devtools": { + "optional": true + }, + "esbuild": { + "optional": true + }, + "jiti": { + "optional": true + }, + "less": { + "optional": true + }, + "sass": { + "optional": true + }, + "sass-embedded": { + "optional": true + }, + "stylus": { + "optional": true + }, + "sugarss": { + "optional": true + }, + "terser": { + "optional": true + }, + "tsx": { + "optional": true + }, + "yaml": { + "optional": true + } + } + } + } +} diff --git a/client/node_modules/@emnapi/core/LICENSE b/client/node_modules/@emnapi/core/LICENSE new file mode 100644 index 0000000..05a5944 --- /dev/null +++ b/client/node_modules/@emnapi/core/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2021-present Toyobayashi + +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. diff --git a/client/node_modules/@emnapi/core/README.md b/client/node_modules/@emnapi/core/README.md new file mode 100644 index 0000000..c98dddc --- /dev/null +++ b/client/node_modules/@emnapi/core/README.md @@ -0,0 +1 @@ +See [https://github.com/toyobayashi/emnapi](https://github.com/toyobayashi/emnapi) diff --git a/client/node_modules/@emnapi/core/dist/emnapi-core.d.ts b/client/node_modules/@emnapi/core/dist/emnapi-core.d.ts new file mode 100644 index 0000000..06d8a7e --- /dev/null +++ b/client/node_modules/@emnapi/core/dist/emnapi-core.d.ts @@ -0,0 +1,366 @@ +import type { Context } from '@emnapi/runtime'; +import type { ReferenceOwnership } from '@emnapi/runtime'; +import type { Worker as Worker_2 } from 'worker_threads'; + +/** @public */ +export declare type BaseCreateOptions = { + filename?: string + nodeBinding?: NodeBinding + reuseWorker?: ThreadManagerOptionsMain['reuseWorker'] + asyncWorkPoolSize?: number + waitThreadStart?: MainThreadBaseOptions['waitThreadStart'] + onCreateWorker?: (info: CreateWorkerInfo) => any + print?: (str: string) => void + printErr?: (str: string) => void + postMessage?: (msg: any) => any + plugins?: (PluginFactory | EmnapiPlugin)[] +} + +export declare interface BaseOptions { + wasi: WASIInstance; + version?: 'preview1'; + wasm64?: boolean; +} + +export declare interface ChildThreadOptions extends BaseOptions { + childThread: true; + postMessage?: (data: any) => void; +} + +export declare interface CleanupThreadPayload { + tid: number; +} + +export declare interface CommandInfo { + type: T; + payload: CommandPayloadMap[T]; +} + +export declare interface CommandPayloadMap { + load: LoadPayload; + loaded: LoadedPayload; + start: StartPayload; + 'cleanup-thread': CleanupThreadPayload; + 'terminate-all-threads': TerminateAllThreadsPayload; + 'spawn-thread': SpawnThreadPayload; +} + +export declare type CommandType = keyof CommandPayloadMap; + +export declare function createInstanceProxy(instance: WebAssembly.Instance, memory?: WebAssembly.Memory | (() => WebAssembly.Memory)): WebAssembly.Instance; + +/** @public */ +export declare function createNapiModule ( +options: CreateOptions +): NapiModule + +/** @public */ +export declare type CreateOptions = BaseCreateOptions & ({ + context: Context + childThread?: boolean +} | { + context?: Context + childThread: true +}) + +/** @public */ +export declare interface CreateWorkerInfo { + type: 'thread' | 'async-work' + name: string +} + +/** @public */ +export declare interface EmnapiPlugin { + importObject?: (originalImports: WebAssembly.Imports) => (WebAssembly.Imports | void) +} + +/** @public */ +export declare interface InitOptions { + instance: WebAssembly.Instance + module: WebAssembly.Module + memory?: WebAssembly.Memory + table?: WebAssembly.Table +} + +export declare type InputType = string | URL | Response | BufferSource | WebAssembly.Module; + +export declare interface InstantiatedSource extends LoadedSource { + napiModule: NapiModule; +} + +export declare function instantiateNapiModule(wasmInput: InputType | Promise, options: InstantiateOptions): Promise; + +export declare function instantiateNapiModuleSync(wasmInput: BufferSource | WebAssembly.Module, options: InstantiateOptions): InstantiatedSource; + +export declare type InstantiateOptions = CreateOptions & LoadOptions; + +export declare function isSharedArrayBuffer(value: any): value is SharedArrayBuffer; + +export declare function isTrapError(e: Error): e is WebAssembly.RuntimeError; + +export declare interface LoadedPayload { +} + +export declare interface LoadedSource extends WebAssembly.WebAssemblyInstantiatedSource { + usedInstance: WebAssembly.Instance; +} + +export declare function loadNapiModule(napiModule: NapiModule, wasmInput: InputType | Promise, options?: LoadOptions): Promise; + +export declare function loadNapiModuleSync(napiModule: NapiModule, wasmInput: BufferSource | WebAssembly.Module, options?: LoadOptions): LoadedSource; + +export declare interface LoadOptions { + wasi?: WASIInstance; + overwriteImports?: (importObject: WebAssembly.Imports) => WebAssembly.Imports; + beforeInit?: (source: WebAssembly.WebAssemblyInstantiatedSource) => void; + getMemory?: (exports: WebAssembly.Exports) => WebAssembly.Memory; + getTable?: (exports: WebAssembly.Exports) => WebAssembly.Table; +} + +export declare interface LoadPayload { + wasmModule: WebAssembly.Module; + wasmMemory: WebAssembly.Memory; + sab?: Int32Array; +} + +export declare interface MainThreadBaseOptions extends BaseOptions { + waitThreadStart?: boolean | number; +} + +export declare type MainThreadOptions = MainThreadOptionsWithThreadManager | MainThreadOptionsCreateThreadManager; + +export declare interface MainThreadOptionsCreateThreadManager extends MainThreadBaseOptions, ThreadManagerOptionsMain { +} + +export declare interface MainThreadOptionsWithThreadManager extends MainThreadBaseOptions { + threadManager?: ThreadManager | (() => ThreadManager); +} + +export declare interface MessageEventData { + __emnapi__: CommandInfo; +} + +export declare class MessageHandler extends ThreadMessageHandler { + napiModule: NapiModule | undefined; + constructor(options: MessageHandlerOptions); + instantiate(data: LoadPayload): InstantiatedSource | PromiseLike; + handle(e: WorkerMessageEvent): void; +} + +export declare interface MessageHandlerOptions extends ThreadMessageHandlerOptions { + onLoad: (data: LoadPayload) => InstantiatedSource | PromiseLike; +} + +/** @public */ +export declare interface NapiModule { + imports: { + env: any + napi: any + emnapi: any + } + exports: any + loaded: boolean + filename: string + childThread: boolean + emnapi: { + /** + * Synchronize data between the wasm memory and an ArrayBuffer / view. + * + * Note: when a non-shared wasm memory has grown, a view over the + * detached old buffer is re-created over the current buffer through the + * intrinsic base-class constructor, so for view inputs the returned view + * may be a base-class instance (e.g. `Uint8Array` or `DataView`) + * instead of the subclass that was passed in. + */ + syncMemory ( + js_to_wasm: boolean, + arrayBufferOrView: T, + offset?: number, + len?: number + ): T extends ArrayBufferView ? ArrayBufferView : T + getMemoryAddress (arrayBufferOrView: ArrayBuffer | ArrayBufferView): PointerInfo + addSendListener (worker: any): boolean + } + + init (options: InitOptions): any + initWorker (arg: number, func: [number, number]): void + postMessage?: (msg: any) => any + + waitThreadStart: boolean | number + /* Excluded from this release type: PThread */} + +/** @public */ +export declare interface NodeBinding { + node: { + emitAsyncInit: Function + emitAsyncDestroy: Function + makeCallback: Function + } + napi: { + asyncInit: Function + asyncDestroy: Function + makeCallback: Function + } +} + +/** @public */ +export declare type PluginContext = any + +/** @public */ +export declare type PluginFactory = (ctx: PluginContext) => EmnapiPlugin + +/** @public */ +export declare interface PointerInfo { + address: number + ownership: ReferenceOwnership + runtimeAllocated: 0 | 1 +} + +export declare interface ReuseWorkerOptions { + size: number; + strict?: boolean; +} + +export declare interface SpawnThreadPayload { + startArg: number; + errorOrTid: number; +} + +export declare interface StartPayload { + tid: number; + arg: number; + sab?: Int32Array; +} + +export declare interface StartResult { + exitCode: number; + instance: WebAssembly.Instance; +} + +export declare interface TerminateAllThreadsPayload { +} + +export declare class ThreadManager { + unusedWorkers: WorkerLike[]; + pthreads: Record; + get nextWorkerID(): number; + wasmModule: WebAssembly.Module | null; + wasmMemory: WebAssembly.Memory | null; + private readonly messageEvents; + private readonly _childThread; + private readonly _onCreateWorker; + private readonly _reuseWorker; + private readonly _beforeLoad?; + readonly printErr: (message: string) => void; + threadSpawn?: ((startArg: number, errorOrTid?: number) => number); + constructor(options: ThreadManagerOptions); + init(): void; + initMainThread(): void; + private preparePool; + shouldPreloadWorkers(): boolean; + loadWasmModuleToAllWorkers(): Promise; + preloadWorkers(): Promise; + setup(wasmModule: WebAssembly.Module, wasmMemory: WebAssembly.Memory): void; + markId(worker: WorkerLike): number; + returnWorkerToPool(worker: WorkerLike): void; + loadWasmModuleToWorker(worker: WorkerLike, sab?: Int32Array): Promise; + allocateUnusedWorker(): WorkerLike; + getNewWorker(sab?: Int32Array): WorkerLike | undefined; + cleanThread(worker: WorkerLike, tid: number, force?: boolean): void; + terminateWorker(worker: WorkerLike): void; + terminateAllThreads(): void; + addMessageEventListener(worker: WorkerLike, onMessage: (e: WorkerMessageEvent) => void): () => void; + fireMessageEvent(worker: WorkerLike, e: WorkerMessageEvent): void; +} + +export declare type ThreadManagerOptions = ThreadManagerOptionsMain | ThreadManagerOptionsChild; + +export declare interface ThreadManagerOptionsBase { + printErr?: (message: string) => void; + threadSpawn?: (startArg: number, errorOrTid?: number) => number; +} + +export declare interface ThreadManagerOptionsChild extends ThreadManagerOptionsBase { + childThread: true; +} + +export declare interface ThreadManagerOptionsMain extends ThreadManagerOptionsBase { + beforeLoad?: (worker: WorkerLike) => any; + reuseWorker?: boolean | number | ReuseWorkerOptions; + onCreateWorker: WorkerFactory; + childThread?: false; +} + +export declare class ThreadMessageHandler { + protected instance: WebAssembly.Instance | undefined; + private messagesBeforeLoad; + protected postMessage: (message: any) => void; + protected onLoad?: (data: LoadPayload) => WebAssembly.WebAssemblyInstantiatedSource | PromiseLike; + protected onError: (error: Error, type: WorkerMessageType) => void; + constructor(options?: ThreadMessageHandlerOptions); + instantiate(data: LoadPayload): WebAssembly.WebAssemblyInstantiatedSource | PromiseLike; + handle(e: WorkerMessageEvent>): void; + private _load; + private _start; + protected _loaded(err: Error | null, source: WebAssembly.WebAssemblyInstantiatedSource | null, payload: LoadPayload): void; + protected handleAfterLoad(e: E, f: (e: E) => void): void; +} + +export declare interface ThreadMessageHandlerOptions { + onLoad?: (data: LoadPayload) => WebAssembly.WebAssemblyInstantiatedSource | PromiseLike; + onError?: (error: Error, type: WorkerMessageType) => void; + postMessage?: (message: any) => void; +} + +export declare const version: string; + +export declare interface WASIInstance { + readonly wasiImport?: Record; + initialize(instance: object): void; + start(instance: object): number; + getImportObject?(): any; +} + +export declare class WASIThreads { + PThread: ThreadManager | undefined; + private wasmMemory; + private wasmInstance; + private readonly threadSpawn; + readonly childThread: boolean; + private readonly postMessage; + readonly wasi: WASIInstance; + constructor(options: WASIThreadsOptions); + getImportObject(): { + wasi: WASIThreadsImports; + }; + setup(wasmInstance: WebAssembly.Instance, wasmModule: WebAssembly.Module, wasmMemory?: WebAssembly.Memory): void; + preloadWorkers(): Promise; + initialize(instance: WebAssembly.Instance, module: WebAssembly.Module, memory?: WebAssembly.Memory): WebAssembly.Instance; + start(instance: WebAssembly.Instance, module: WebAssembly.Module, memory?: WebAssembly.Memory): StartResult; + terminateAllThreads(): void; +} + +export declare interface WASIThreadsImports { + 'thread-spawn': (startArg: number, errorOrTid?: number) => number; +} + +export declare type WASIThreadsOptions = MainThreadOptions | ChildThreadOptions; + +export declare type WorkerFactory = (ctx: { + type: string; + name: string; +}) => WorkerLike; + +export declare type WorkerLike = (Worker | Worker_2) & { + whenLoaded?: Promise; + loaded?: boolean; + __emnapi_tid?: number; +}; + +export declare interface WorkerMessageEvent { + data: T; +} + +export declare type WorkerMessageType = 'load' | 'start'; + +export { } diff --git a/client/node_modules/@emnapi/core/dist/emnapi-core.full.d.ts b/client/node_modules/@emnapi/core/dist/emnapi-core.full.d.ts new file mode 100644 index 0000000..06d8a7e --- /dev/null +++ b/client/node_modules/@emnapi/core/dist/emnapi-core.full.d.ts @@ -0,0 +1,366 @@ +import type { Context } from '@emnapi/runtime'; +import type { ReferenceOwnership } from '@emnapi/runtime'; +import type { Worker as Worker_2 } from 'worker_threads'; + +/** @public */ +export declare type BaseCreateOptions = { + filename?: string + nodeBinding?: NodeBinding + reuseWorker?: ThreadManagerOptionsMain['reuseWorker'] + asyncWorkPoolSize?: number + waitThreadStart?: MainThreadBaseOptions['waitThreadStart'] + onCreateWorker?: (info: CreateWorkerInfo) => any + print?: (str: string) => void + printErr?: (str: string) => void + postMessage?: (msg: any) => any + plugins?: (PluginFactory | EmnapiPlugin)[] +} + +export declare interface BaseOptions { + wasi: WASIInstance; + version?: 'preview1'; + wasm64?: boolean; +} + +export declare interface ChildThreadOptions extends BaseOptions { + childThread: true; + postMessage?: (data: any) => void; +} + +export declare interface CleanupThreadPayload { + tid: number; +} + +export declare interface CommandInfo { + type: T; + payload: CommandPayloadMap[T]; +} + +export declare interface CommandPayloadMap { + load: LoadPayload; + loaded: LoadedPayload; + start: StartPayload; + 'cleanup-thread': CleanupThreadPayload; + 'terminate-all-threads': TerminateAllThreadsPayload; + 'spawn-thread': SpawnThreadPayload; +} + +export declare type CommandType = keyof CommandPayloadMap; + +export declare function createInstanceProxy(instance: WebAssembly.Instance, memory?: WebAssembly.Memory | (() => WebAssembly.Memory)): WebAssembly.Instance; + +/** @public */ +export declare function createNapiModule ( +options: CreateOptions +): NapiModule + +/** @public */ +export declare type CreateOptions = BaseCreateOptions & ({ + context: Context + childThread?: boolean +} | { + context?: Context + childThread: true +}) + +/** @public */ +export declare interface CreateWorkerInfo { + type: 'thread' | 'async-work' + name: string +} + +/** @public */ +export declare interface EmnapiPlugin { + importObject?: (originalImports: WebAssembly.Imports) => (WebAssembly.Imports | void) +} + +/** @public */ +export declare interface InitOptions { + instance: WebAssembly.Instance + module: WebAssembly.Module + memory?: WebAssembly.Memory + table?: WebAssembly.Table +} + +export declare type InputType = string | URL | Response | BufferSource | WebAssembly.Module; + +export declare interface InstantiatedSource extends LoadedSource { + napiModule: NapiModule; +} + +export declare function instantiateNapiModule(wasmInput: InputType | Promise, options: InstantiateOptions): Promise; + +export declare function instantiateNapiModuleSync(wasmInput: BufferSource | WebAssembly.Module, options: InstantiateOptions): InstantiatedSource; + +export declare type InstantiateOptions = CreateOptions & LoadOptions; + +export declare function isSharedArrayBuffer(value: any): value is SharedArrayBuffer; + +export declare function isTrapError(e: Error): e is WebAssembly.RuntimeError; + +export declare interface LoadedPayload { +} + +export declare interface LoadedSource extends WebAssembly.WebAssemblyInstantiatedSource { + usedInstance: WebAssembly.Instance; +} + +export declare function loadNapiModule(napiModule: NapiModule, wasmInput: InputType | Promise, options?: LoadOptions): Promise; + +export declare function loadNapiModuleSync(napiModule: NapiModule, wasmInput: BufferSource | WebAssembly.Module, options?: LoadOptions): LoadedSource; + +export declare interface LoadOptions { + wasi?: WASIInstance; + overwriteImports?: (importObject: WebAssembly.Imports) => WebAssembly.Imports; + beforeInit?: (source: WebAssembly.WebAssemblyInstantiatedSource) => void; + getMemory?: (exports: WebAssembly.Exports) => WebAssembly.Memory; + getTable?: (exports: WebAssembly.Exports) => WebAssembly.Table; +} + +export declare interface LoadPayload { + wasmModule: WebAssembly.Module; + wasmMemory: WebAssembly.Memory; + sab?: Int32Array; +} + +export declare interface MainThreadBaseOptions extends BaseOptions { + waitThreadStart?: boolean | number; +} + +export declare type MainThreadOptions = MainThreadOptionsWithThreadManager | MainThreadOptionsCreateThreadManager; + +export declare interface MainThreadOptionsCreateThreadManager extends MainThreadBaseOptions, ThreadManagerOptionsMain { +} + +export declare interface MainThreadOptionsWithThreadManager extends MainThreadBaseOptions { + threadManager?: ThreadManager | (() => ThreadManager); +} + +export declare interface MessageEventData { + __emnapi__: CommandInfo; +} + +export declare class MessageHandler extends ThreadMessageHandler { + napiModule: NapiModule | undefined; + constructor(options: MessageHandlerOptions); + instantiate(data: LoadPayload): InstantiatedSource | PromiseLike; + handle(e: WorkerMessageEvent): void; +} + +export declare interface MessageHandlerOptions extends ThreadMessageHandlerOptions { + onLoad: (data: LoadPayload) => InstantiatedSource | PromiseLike; +} + +/** @public */ +export declare interface NapiModule { + imports: { + env: any + napi: any + emnapi: any + } + exports: any + loaded: boolean + filename: string + childThread: boolean + emnapi: { + /** + * Synchronize data between the wasm memory and an ArrayBuffer / view. + * + * Note: when a non-shared wasm memory has grown, a view over the + * detached old buffer is re-created over the current buffer through the + * intrinsic base-class constructor, so for view inputs the returned view + * may be a base-class instance (e.g. `Uint8Array` or `DataView`) + * instead of the subclass that was passed in. + */ + syncMemory ( + js_to_wasm: boolean, + arrayBufferOrView: T, + offset?: number, + len?: number + ): T extends ArrayBufferView ? ArrayBufferView : T + getMemoryAddress (arrayBufferOrView: ArrayBuffer | ArrayBufferView): PointerInfo + addSendListener (worker: any): boolean + } + + init (options: InitOptions): any + initWorker (arg: number, func: [number, number]): void + postMessage?: (msg: any) => any + + waitThreadStart: boolean | number + /* Excluded from this release type: PThread */} + +/** @public */ +export declare interface NodeBinding { + node: { + emitAsyncInit: Function + emitAsyncDestroy: Function + makeCallback: Function + } + napi: { + asyncInit: Function + asyncDestroy: Function + makeCallback: Function + } +} + +/** @public */ +export declare type PluginContext = any + +/** @public */ +export declare type PluginFactory = (ctx: PluginContext) => EmnapiPlugin + +/** @public */ +export declare interface PointerInfo { + address: number + ownership: ReferenceOwnership + runtimeAllocated: 0 | 1 +} + +export declare interface ReuseWorkerOptions { + size: number; + strict?: boolean; +} + +export declare interface SpawnThreadPayload { + startArg: number; + errorOrTid: number; +} + +export declare interface StartPayload { + tid: number; + arg: number; + sab?: Int32Array; +} + +export declare interface StartResult { + exitCode: number; + instance: WebAssembly.Instance; +} + +export declare interface TerminateAllThreadsPayload { +} + +export declare class ThreadManager { + unusedWorkers: WorkerLike[]; + pthreads: Record; + get nextWorkerID(): number; + wasmModule: WebAssembly.Module | null; + wasmMemory: WebAssembly.Memory | null; + private readonly messageEvents; + private readonly _childThread; + private readonly _onCreateWorker; + private readonly _reuseWorker; + private readonly _beforeLoad?; + readonly printErr: (message: string) => void; + threadSpawn?: ((startArg: number, errorOrTid?: number) => number); + constructor(options: ThreadManagerOptions); + init(): void; + initMainThread(): void; + private preparePool; + shouldPreloadWorkers(): boolean; + loadWasmModuleToAllWorkers(): Promise; + preloadWorkers(): Promise; + setup(wasmModule: WebAssembly.Module, wasmMemory: WebAssembly.Memory): void; + markId(worker: WorkerLike): number; + returnWorkerToPool(worker: WorkerLike): void; + loadWasmModuleToWorker(worker: WorkerLike, sab?: Int32Array): Promise; + allocateUnusedWorker(): WorkerLike; + getNewWorker(sab?: Int32Array): WorkerLike | undefined; + cleanThread(worker: WorkerLike, tid: number, force?: boolean): void; + terminateWorker(worker: WorkerLike): void; + terminateAllThreads(): void; + addMessageEventListener(worker: WorkerLike, onMessage: (e: WorkerMessageEvent) => void): () => void; + fireMessageEvent(worker: WorkerLike, e: WorkerMessageEvent): void; +} + +export declare type ThreadManagerOptions = ThreadManagerOptionsMain | ThreadManagerOptionsChild; + +export declare interface ThreadManagerOptionsBase { + printErr?: (message: string) => void; + threadSpawn?: (startArg: number, errorOrTid?: number) => number; +} + +export declare interface ThreadManagerOptionsChild extends ThreadManagerOptionsBase { + childThread: true; +} + +export declare interface ThreadManagerOptionsMain extends ThreadManagerOptionsBase { + beforeLoad?: (worker: WorkerLike) => any; + reuseWorker?: boolean | number | ReuseWorkerOptions; + onCreateWorker: WorkerFactory; + childThread?: false; +} + +export declare class ThreadMessageHandler { + protected instance: WebAssembly.Instance | undefined; + private messagesBeforeLoad; + protected postMessage: (message: any) => void; + protected onLoad?: (data: LoadPayload) => WebAssembly.WebAssemblyInstantiatedSource | PromiseLike; + protected onError: (error: Error, type: WorkerMessageType) => void; + constructor(options?: ThreadMessageHandlerOptions); + instantiate(data: LoadPayload): WebAssembly.WebAssemblyInstantiatedSource | PromiseLike; + handle(e: WorkerMessageEvent>): void; + private _load; + private _start; + protected _loaded(err: Error | null, source: WebAssembly.WebAssemblyInstantiatedSource | null, payload: LoadPayload): void; + protected handleAfterLoad(e: E, f: (e: E) => void): void; +} + +export declare interface ThreadMessageHandlerOptions { + onLoad?: (data: LoadPayload) => WebAssembly.WebAssemblyInstantiatedSource | PromiseLike; + onError?: (error: Error, type: WorkerMessageType) => void; + postMessage?: (message: any) => void; +} + +export declare const version: string; + +export declare interface WASIInstance { + readonly wasiImport?: Record; + initialize(instance: object): void; + start(instance: object): number; + getImportObject?(): any; +} + +export declare class WASIThreads { + PThread: ThreadManager | undefined; + private wasmMemory; + private wasmInstance; + private readonly threadSpawn; + readonly childThread: boolean; + private readonly postMessage; + readonly wasi: WASIInstance; + constructor(options: WASIThreadsOptions); + getImportObject(): { + wasi: WASIThreadsImports; + }; + setup(wasmInstance: WebAssembly.Instance, wasmModule: WebAssembly.Module, wasmMemory?: WebAssembly.Memory): void; + preloadWorkers(): Promise; + initialize(instance: WebAssembly.Instance, module: WebAssembly.Module, memory?: WebAssembly.Memory): WebAssembly.Instance; + start(instance: WebAssembly.Instance, module: WebAssembly.Module, memory?: WebAssembly.Memory): StartResult; + terminateAllThreads(): void; +} + +export declare interface WASIThreadsImports { + 'thread-spawn': (startArg: number, errorOrTid?: number) => number; +} + +export declare type WASIThreadsOptions = MainThreadOptions | ChildThreadOptions; + +export declare type WorkerFactory = (ctx: { + type: string; + name: string; +}) => WorkerLike; + +export declare type WorkerLike = (Worker | Worker_2) & { + whenLoaded?: Promise; + loaded?: boolean; + __emnapi_tid?: number; +}; + +export declare interface WorkerMessageEvent { + data: T; +} + +export declare type WorkerMessageType = 'load' | 'start'; + +export { } diff --git a/client/node_modules/@emnapi/core/dist/emnapi-core.full.js b/client/node_modules/@emnapi/core/dist/emnapi-core.full.js new file mode 100644 index 0000000..e1df365 --- /dev/null +++ b/client/node_modules/@emnapi/core/dist/emnapi-core.full.js @@ -0,0 +1,8142 @@ +//#region src/util.ts +const _WebAssembly$1 = typeof WebAssembly !== 'undefined' + ? WebAssembly + : typeof WXWebAssembly !== 'undefined' + ? WXWebAssembly + : undefined; +function validateImports(imports) { + if (imports && typeof imports !== 'object') { + throw new TypeError('imports must be an object or undefined'); + } + return true; +} +function load(wasmInput, imports) { + if (!wasmInput) + throw new TypeError('Invalid wasm source'); + validateImports(imports); + imports = imports ?? {}; + try { + const then = typeof wasmInput === 'object' && wasmInput !== null && 'then' in wasmInput ? wasmInput.then : undefined; + if (typeof then === 'function') { + return then.call(wasmInput, (input) => load(input, imports)); + } + } + catch (_) { } + if (wasmInput instanceof ArrayBuffer || ArrayBuffer.isView(wasmInput)) { + return _WebAssembly$1.instantiate(wasmInput, imports); + } + if (wasmInput instanceof _WebAssembly$1.Module) { + return _WebAssembly$1.instantiate(wasmInput, imports).then((instance) => { + return { instance, module: wasmInput }; + }); + } + if (typeof Response !== 'undefined' && wasmInput instanceof Response) { + return wasmInput.arrayBuffer().then(buffer => { + return _WebAssembly$1.instantiate(buffer, imports); + }); + } + const inputIsString = typeof wasmInput === 'string'; + if (inputIsString || (typeof URL !== 'undefined' && wasmInput instanceof URL)) { + if (inputIsString && typeof wx !== 'undefined' && typeof __wxConfig !== 'undefined') { + return _WebAssembly$1.instantiate(wasmInput, imports); + } + if (typeof fetch !== 'function') { + throw new TypeError('wasm source can not be a string or URL in this environment'); + } + if (typeof _WebAssembly$1.instantiateStreaming === 'function') { + try { + return _WebAssembly$1.instantiateStreaming(fetch(wasmInput), imports).catch(() => { + return load(fetch(wasmInput), imports); + }); + } + catch (_) { + return load(fetch(wasmInput), imports); + } + } + else { + return load(fetch(wasmInput), imports); + } + } + throw new TypeError('Invalid wasm source'); +} +function loadSync(wasmInput, imports) { + if (!wasmInput) + throw new TypeError('Invalid wasm source'); + validateImports(imports); + imports = imports ?? {}; + let module; + if ((wasmInput instanceof ArrayBuffer) || ArrayBuffer.isView(wasmInput)) { + module = new _WebAssembly$1.Module(wasmInput); + } + else if (wasmInput instanceof WebAssembly.Module) { + module = wasmInput; + } + else { + throw new TypeError('Invalid wasm source'); + } + const instance = new _WebAssembly$1.Instance(module, imports); + const source = { instance, module }; + return source; +} + +//#endregion src/util.ts + +//#region dist/wasi-threads.js +//#region src/util.ts +const _WebAssembly = typeof WebAssembly !== 'undefined' + ? WebAssembly + : typeof WXWebAssembly !== 'undefined' + ? WXWebAssembly + : undefined; +const ENVIRONMENT_IS_NODE = typeof process === 'object' && process !== null && + typeof process.versions === 'object' && process.versions !== null && + typeof process.versions.node === 'string'; +function getPostMessage(options) { + return typeof options?.postMessage === 'function' + ? options.postMessage + : typeof postMessage === 'function' + ? postMessage + : undefined; +} +function serizeErrorToBuffer(sab, code, error) { + const i32array = new Int32Array(sab); + Atomics.store(i32array, 0, code); + if (code > 1 && error) { + const name = error.name; + const message = error.message; + const stack = error.stack; + const nameBuffer = new TextEncoder().encode(name); + const messageBuffer = new TextEncoder().encode(message); + const stackBuffer = new TextEncoder().encode(stack); + Atomics.store(i32array, 1, nameBuffer.length); + Atomics.store(i32array, 2, messageBuffer.length); + Atomics.store(i32array, 3, stackBuffer.length); + const buffer = new Uint8Array(sab); + buffer.set(nameBuffer, 16); + buffer.set(messageBuffer, 16 + nameBuffer.length); + buffer.set(stackBuffer, 16 + nameBuffer.length + messageBuffer.length); + } +} +function deserizeErrorFromBuffer(sab) { + const i32array = new Int32Array(sab); + const status = Atomics.load(i32array, 0); + if (status <= 1) { + return null; + } + const nameLength = Atomics.load(i32array, 1); + const messageLength = Atomics.load(i32array, 2); + const stackLength = Atomics.load(i32array, 3); + const buffer = new Uint8Array(sab); + const nameBuffer = buffer.slice(16, 16 + nameLength); + const messageBuffer = buffer.slice(16 + nameLength, 16 + nameLength + messageLength); + const stackBuffer = buffer.slice(16 + nameLength + messageLength, 16 + nameLength + messageLength + stackLength); + const name = new TextDecoder().decode(nameBuffer); + const message = new TextDecoder().decode(messageBuffer); + const stack = new TextDecoder().decode(stackBuffer); + const ErrorConstructor = globalThis[name] ?? (name === 'RuntimeError' ? (_WebAssembly.RuntimeError ?? Error) : Error); + const error = new ErrorConstructor(message); + Object.defineProperty(error, 'stack', { + value: stack, + writable: true, + enumerable: false, + configurable: true + }); + return error; +} +function isSharedArrayBuffer(value) { + return ((typeof SharedArrayBuffer === 'function' && value instanceof SharedArrayBuffer) || + (Object.prototype.toString.call(value) === '[object SharedArrayBuffer]')); +} +function isTrapError(e) { + try { + return e instanceof _WebAssembly.RuntimeError; + } + catch (_) { + return false; + } +} + +//#endregion src/util.ts + +//#region src/command.ts +function createMessage(type, payload) { + return { + __emnapi__: { + type, + payload + } + }; +} + +//#endregion src/command.ts + +//#region src/thread-manager.ts +const WASI_THREADS_MAX_TID = 0x1FFFFFFF; +function checkSharedWasmMemory(wasmMemory) { + if (wasmMemory) { + if (!isSharedArrayBuffer(wasmMemory.buffer)) { + throw new Error('Multithread features require shared wasm memory. ' + + 'Try to compile with `-matomics -mbulk-memory` and use `--import-memory --shared-memory` during linking, ' + + 'then create WebAssembly.Memory with `shared: true` option'); + } + } + else { + if (typeof SharedArrayBuffer === 'undefined') { + throw new Error('Current environment does not support SharedArrayBuffer, threads are not available!'); + } + } +} +function getReuseWorker(value) { + if (typeof value === 'boolean') { + return value ? { size: 0, strict: false } : false; + } + if (typeof value === 'number') { + if (!(value >= 0)) { + throw new RangeError('reuseWorker: size must be a non-negative integer'); + } + return { size: value, strict: false }; + } + if (!value) { + return false; + } + const size = Number(value.size) || 0; + const strict = Boolean(value.strict); + if (!(size > 0) && strict) { + throw new RangeError('reuseWorker: size must be set to positive integer if strict is set to true'); + } + return { size, strict }; +} +let nextWorkerID = 0; +class ThreadManager { + get nextWorkerID() { return nextWorkerID; } + constructor(options) { + this.unusedWorkers = []; + this.pthreads = Object.create(null); + this.wasmModule = null; + this.wasmMemory = null; + this.messageEvents = new WeakMap(); + if (!options) { + throw new TypeError('ThreadManager(): options is not provided'); + } + if ('childThread' in options) { + this._childThread = Boolean(options.childThread); + } + else { + this._childThread = false; + } + if (this._childThread) { + this._onCreateWorker = undefined; + this._reuseWorker = false; + this._beforeLoad = undefined; + } + else { + this._onCreateWorker = options.onCreateWorker; + this._reuseWorker = getReuseWorker(options.reuseWorker); + this._beforeLoad = options.beforeLoad; + } + this.printErr = options.printErr ?? console.error.bind(console); + this.threadSpawn = options.threadSpawn; + } + init() { + if (!this._childThread) { + this.initMainThread(); + } + } + initMainThread() { + this.preparePool(); + } + preparePool() { + if (this._reuseWorker) { + if (this._reuseWorker.size) { + let pthreadPoolSize = this._reuseWorker.size; + while (pthreadPoolSize--) { + const worker = this.allocateUnusedWorker(); + if (ENVIRONMENT_IS_NODE) { + worker.once('message', () => { }); + worker.unref(); + } + } + } + } + } + shouldPreloadWorkers() { + return !this._childThread && this._reuseWorker && this._reuseWorker.size > 0; + } + loadWasmModuleToAllWorkers() { + const promises = Array(this.unusedWorkers.length); + for (let i = 0; i < this.unusedWorkers.length; ++i) { + const worker = this.unusedWorkers[i]; + if (ENVIRONMENT_IS_NODE) + worker.ref(); + promises[i] = this.loadWasmModuleToWorker(worker).then((w) => { + if (ENVIRONMENT_IS_NODE) + worker.unref(); + return w; + }, (e) => { + if (ENVIRONMENT_IS_NODE) + worker.unref(); + throw e; + }); + } + return Promise.all(promises).catch((err) => { + this.terminateAllThreads(); + throw err; + }); + } + preloadWorkers() { + if (this.shouldPreloadWorkers()) { + return this.loadWasmModuleToAllWorkers(); + } + return Promise.resolve([]); + } + setup(wasmModule, wasmMemory) { + this.wasmModule = wasmModule; + this.wasmMemory = wasmMemory; + } + markId(worker) { + if (worker.__emnapi_tid) + return worker.__emnapi_tid; + const tid = nextWorkerID + 43; + nextWorkerID = (nextWorkerID + 1) % (WASI_THREADS_MAX_TID - 42); + this.pthreads[tid] = worker; + worker.__emnapi_tid = tid; + return tid; + } + returnWorkerToPool(worker) { + var tid = worker.__emnapi_tid; + if (tid !== undefined) { + delete this.pthreads[tid]; + } + this.unusedWorkers.push(worker); + delete worker.__emnapi_tid; + if (ENVIRONMENT_IS_NODE) { + worker.unref(); + } + } + loadWasmModuleToWorker(worker, sab) { + if (worker.whenLoaded) + return worker.whenLoaded; + const err = this.printErr; + const beforeLoad = this._beforeLoad; + const _this = this; + worker.whenLoaded = new Promise((resolve, reject) => { + const handleError = function (e) { + let message = 'worker sent an error!'; + if (worker.__emnapi_tid !== undefined) { + message = 'worker (tid = ' + worker.__emnapi_tid + ') sent an error!'; + } + if ('message' in e) { + err(message + ' ' + e.message); + if (e.message.indexOf('RuntimeError') !== -1 || e.message.indexOf('unreachable') !== -1) { + try { + _this.terminateAllThreads(); + } + catch (_) { } + } + } + else { + err(message); + } + reject(e); + throw e; + }; + const handleMessage = (data) => { + if (data.__emnapi__) { + const type = data.__emnapi__.type; + const payload = data.__emnapi__.payload; + if (type === 'loaded') { + worker.loaded = true; + if (ENVIRONMENT_IS_NODE && !worker.__emnapi_tid) { + worker.unref(); + } + resolve(worker); + } + else if (type === 'cleanup-thread') { + if (payload.tid in this.pthreads) { + this.cleanThread(worker, payload.tid); + } + } + else if (type === 'spawn-thread') { + this.threadSpawn(payload.startArg, payload.errorOrTid); + } + else if (type === 'terminate-all-threads') { + this.terminateAllThreads(); + } + } + }; + worker.onmessage = (e) => { + handleMessage(e.data); + this.fireMessageEvent(worker, e); + }; + worker.onerror = handleError; + if (ENVIRONMENT_IS_NODE) { + worker.on('message', function (data) { + worker.onmessage?.({ + data + }); + }); + worker.on('error', function (e) { + worker.onerror?.(e); + }); + worker.on('detachedExit', function () { }); + } + if (typeof beforeLoad === 'function') { + beforeLoad(worker); + } + try { + worker.postMessage(createMessage('load', { + wasmModule: this.wasmModule, + wasmMemory: this.wasmMemory, + sab + })); + } + catch (err) { + checkSharedWasmMemory(this.wasmMemory); + throw err; + } + }); + return worker.whenLoaded; + } + allocateUnusedWorker() { + const _onCreateWorker = this._onCreateWorker; + if (typeof _onCreateWorker !== 'function') { + throw new TypeError('`options.onCreateWorker` is not provided'); + } + const worker = _onCreateWorker({ type: 'thread', name: 'emnapi-pthread' }); + this.unusedWorkers.push(worker); + return worker; + } + getNewWorker(sab) { + if (this._reuseWorker) { + if (this.unusedWorkers.length === 0) { + if (this._reuseWorker.strict) { + if (!ENVIRONMENT_IS_NODE) { + const err = this.printErr; + err('Tried to spawn a new thread, but the thread pool is exhausted.\n' + + 'This might result in a deadlock unless some threads eventually exit or the code explicitly breaks out to the event loop.'); + return; + } + } + const worker = this.allocateUnusedWorker(); + this.loadWasmModuleToWorker(worker, sab); + } + return this.unusedWorkers.pop(); + } + const worker = this.allocateUnusedWorker(); + this.loadWasmModuleToWorker(worker, sab); + return this.unusedWorkers.pop(); + } + cleanThread(worker, tid, force) { + if (!force && this._reuseWorker) { + this.returnWorkerToPool(worker); + } + else { + delete this.pthreads[tid]; + this.terminateWorker(worker); + delete worker.__emnapi_tid; + } + } + terminateWorker(worker) { + const tid = worker.__emnapi_tid; + worker.terminate(); + this.messageEvents.get(worker)?.clear(); + this.messageEvents.delete(worker); + worker.onmessage = (e) => { + if (e.data.__emnapi__) { + const err = this.printErr; + err('received "' + e.data.__emnapi__.type + '" command from terminated worker: ' + tid); + } + }; + } + terminateAllThreads() { + const runningWorkers = Object.values(this.pthreads); + for (let i = 0; i < runningWorkers.length; ++i) { + this.terminateWorker(runningWorkers[i]); + } + for (let i = 0; i < this.unusedWorkers.length; ++i) { + this.terminateWorker(this.unusedWorkers[i]); + } + this.unusedWorkers = []; + this.pthreads = Object.create(null); + this.preparePool(); + } + addMessageEventListener(worker, onMessage) { + let listeners = this.messageEvents.get(worker); + if (!listeners) { + listeners = new Set(); + this.messageEvents.set(worker, listeners); + } + listeners.add(onMessage); + return () => { + listeners?.delete(onMessage); + }; + } + fireMessageEvent(worker, e) { + const listeners = this.messageEvents.get(worker); + if (!listeners) + return; + const err = this.printErr; + listeners.forEach((listener) => { + try { + listener(e); + } + catch (e) { + err(e.stack); + } + }); + } +} + +//#endregion src/thread-manager.ts + +//#region src/proxy.ts +const kIsProxy = Symbol('kIsProxy'); +function createInstanceProxy(instance, memory) { + if (instance[kIsProxy]) + return instance; + const originalExports = instance.exports; + const createHandler = function (target) { + const handlers = [ + 'apply', + 'construct', + 'defineProperty', + 'deleteProperty', + 'get', + 'getOwnPropertyDescriptor', + 'getPrototypeOf', + 'has', + 'isExtensible', + 'ownKeys', + 'preventExtensions', + 'set', + 'setPrototypeOf' + ]; + const handler = {}; + for (let i = 0; i < handlers.length; i++) { + const name = handlers[i]; + handler[name] = function () { + const args = Array.prototype.slice.call(arguments, 1); + args.unshift(target); + return Reflect[name].apply(Reflect, args); + }; + } + return handler; + }; + const handler = createHandler(originalExports); + const _initialize = () => { }; + const _start = () => 0; + handler.get = function (_target, p, receiver) { + if (p === 'memory') { + return (typeof memory === 'function' ? memory() : memory) ?? Reflect.get(originalExports, p, receiver); + } + if (p === '_initialize') { + return p in originalExports ? _initialize : undefined; + } + if (p === '_start') { + return p in originalExports ? _start : undefined; + } + return Reflect.get(originalExports, p, receiver); + }; + handler.has = function (_target, p) { + if (p === 'memory') + return true; + return Reflect.has(originalExports, p); + }; + const exportsProxy = new Proxy(Object.create(null), handler); + return new Proxy(instance, { + get(target, p, receiver) { + if (p === 'exports') { + return exportsProxy; + } + if (p === kIsProxy) { + return true; + } + return Reflect.get(target, p, receiver); + } + }); +} + +//#endregion src/proxy.ts + +//#region src/wasi-threads.ts +const patchedWasiInstances = new WeakMap(); +const THREAD_SPAWN_RESULT_SIZE = Int32Array.BYTES_PER_ELEMENT * 2; +const sharedArrayBufferByteLength = typeof SharedArrayBuffer === 'function' + ? Object.getOwnPropertyDescriptor(SharedArrayBuffer.prototype, 'byteLength').get + : undefined; +function isConclusivelySharedArrayBuffer(buffer) { + if (sharedArrayBufferByteLength === undefined) + return false; + try { + sharedArrayBufferByteLength.call(buffer); + return true; + } + catch (_) { + return false; + } +} +function getThreadSpawnResultView(memory, address, wasm64) { + const offset = typeof address === 'bigint' ? Number(address) : address >>> 0; + let buffer = memory.buffer; + if (offset + THREAD_SPAWN_RESULT_SIZE > buffer.byteLength && + isConclusivelySharedArrayBuffer(buffer)) { + if (wasm64) { + memory.grow(BigInt(0)); + } + else { + memory.grow(0); + } + buffer = memory.buffer; + } + return new Int32Array(buffer, offset, 2); +} +class WASIThreads { + constructor(options) { + if (!options) { + throw new TypeError('WASIThreads(): options is not provided'); + } + if (!options.wasi) { + throw new TypeError('WASIThreads(): options.wasi is not provided'); + } + patchedWasiInstances.set(this, new WeakSet()); + const wasi = options.wasi; + patchWasiInstance(this, wasi); + this.wasi = wasi; + if ('childThread' in options) { + this.childThread = Boolean(options.childThread); + } + else { + this.childThread = false; + } + this.PThread = undefined; + if ('threadManager' in options) { + if (typeof options.threadManager === 'function') { + this.PThread = options.threadManager(); + } + else { + this.PThread = options.threadManager; + } + } + else { + if (!this.childThread) { + this.PThread = new ThreadManager(options); + this.PThread.init(); + } + } + let waitThreadStart = false; + if ('waitThreadStart' in options) { + waitThreadStart = typeof options.waitThreadStart === 'number' ? options.waitThreadStart : Boolean(options.waitThreadStart); + } + const postMessage = getPostMessage(options); + if (this.childThread && typeof postMessage !== 'function') { + throw new TypeError('options.postMessage is not a function'); + } + this.postMessage = postMessage; + const wasm64 = Boolean(options.wasm64); + const threadSpawn = (startArg, errorOrTid) => { + const EAGAIN = 6; + const isNewABI = errorOrTid !== undefined; + try { + checkSharedWasmMemory(this.wasmMemory); + } + catch (err) { + this.PThread?.printErr(err.stack); + if (isNewABI) { + const struct = getThreadSpawnResultView(this.wasmMemory, errorOrTid, wasm64); + Atomics.store(struct, 0, 1); + Atomics.store(struct, 1, EAGAIN); + Atomics.notify(struct, 1); + return 1; + } + else { + return -EAGAIN; + } + } + if (!isNewABI) { + const malloc = this.wasmInstance.exports.malloc; + errorOrTid = wasm64 ? Number(malloc(BigInt(8))) : (malloc(8) >>> 0); + if (!errorOrTid) { + return -48; + } + } + const _free = this.wasmInstance.exports.free; + const free = wasm64 ? (ptr) => { _free(BigInt(ptr)); } : _free; + const struct = getThreadSpawnResultView(this.wasmMemory, errorOrTid, wasm64); + Atomics.store(struct, 0, 0); + Atomics.store(struct, 1, 0); + if (this.childThread) { + postMessage(createMessage('spawn-thread', { + startArg, + errorOrTid: errorOrTid + })); + Atomics.wait(struct, 1, 0); + const isError = Atomics.load(struct, 0); + const result = Atomics.load(struct, 1); + if (isNewABI) { + return isError; + } + free(errorOrTid); + return isError ? -result : result; + } + const shouldWait = waitThreadStart || (waitThreadStart === 0); + let sab; + if (shouldWait) { + sab = new Int32Array(new SharedArrayBuffer(16 + 8192)); + Atomics.store(sab, 0, 0); + } + let worker; + let tid; + const PThread = this.PThread; + try { + worker = PThread.getNewWorker(sab); + if (!worker) { + throw new Error('failed to get new worker'); + } + tid = PThread.markId(worker); + if (ENVIRONMENT_IS_NODE) { + worker.unref(); + } + worker.postMessage(createMessage('start', { + tid, + arg: startArg, + sab + })); + if (shouldWait) { + if (typeof waitThreadStart === 'number') { + const waitResult = Atomics.wait(sab, 0, 0, waitThreadStart); + if (waitResult === 'timed-out') { + throw new Error('Spawning thread timed out. Please check if the worker is created successfully and if message is handled properly in the worker.'); + } + } + else { + Atomics.wait(sab, 0, 0); + } + const r = Atomics.load(sab, 0); + if (r > 1) { + throw deserizeErrorFromBuffer(sab.buffer); + } + } + } + catch (e) { + if (worker !== undefined && tid !== undefined) { + try { + PThread.cleanThread(worker, tid, true); + } + catch (_) { } + } + Atomics.store(struct, 0, 1); + Atomics.store(struct, 1, EAGAIN); + Atomics.notify(struct, 1); + PThread?.printErr(e.stack); + if (isNewABI) { + return 1; + } + free(errorOrTid); + return -EAGAIN; + } + Atomics.store(struct, 0, 0); + Atomics.store(struct, 1, tid); + Atomics.notify(struct, 1); + if (!shouldWait) { + worker.whenLoaded.catch((err) => { + delete worker.whenLoaded; + PThread.cleanThread(worker, tid, true); + throw err; + }); + } + if (isNewABI) { + return 0; + } + free(errorOrTid); + return tid; + }; + this.threadSpawn = threadSpawn; + if (this.PThread) { + this.PThread.threadSpawn = threadSpawn; + } + } + getImportObject() { + return { + wasi: { + 'thread-spawn': this.threadSpawn + } + }; + } + setup(wasmInstance, wasmModule, wasmMemory) { + wasmMemory ??= wasmInstance.exports.memory; + this.wasmInstance = wasmInstance; + this.wasmMemory = wasmMemory; + if (this.PThread) { + this.PThread.setup(wasmModule, wasmMemory); + } + } + preloadWorkers() { + if (this.PThread) { + return this.PThread.preloadWorkers(); + } + return Promise.resolve([]); + } + initialize(instance, module, memory) { + const exports = instance.exports; + memory ??= exports.memory; + if (this.childThread) { + instance = createInstanceProxy(instance, memory); + } + this.setup(instance, module, memory); + const wasi = this.wasi; + if (('_start' in exports) && (typeof exports._start === 'function')) { + if (this.childThread) { + wasi.start(instance); + try { + const kStarted = getWasiSymbol(wasi, 'kStarted'); + wasi[kStarted] = false; + } + catch (_) { } + } + else { + setupInstance(wasi, instance); + } + } + else { + wasi.initialize(instance); + } + return instance; + } + start(instance, module, memory) { + const exports = instance.exports; + memory ??= exports.memory; + if (this.childThread) { + instance = createInstanceProxy(instance, memory); + } + this.setup(instance, module, memory); + const exitCode = this.wasi.start(instance); + return { exitCode, instance }; + } + terminateAllThreads() { + if (!this.childThread) { + this.PThread?.terminateAllThreads(); + } + else { + this.postMessage(createMessage('terminate-all-threads', {})); + } + } +} +function patchWasiInstance(wasiThreads, wasi) { + const patched = patchedWasiInstances.get(wasiThreads); + if (patched.has(wasi)) { + return; + } + const _this = wasiThreads; + const wasiImport = wasi.wasiImport; + if (wasiImport) { + const proc_exit = wasiImport.proc_exit; + wasiImport.proc_exit = function (code) { + _this.terminateAllThreads(); + return proc_exit.call(this, code); + }; + } + if (!_this.childThread) { + const start = wasi.start; + if (typeof start === 'function') { + wasi.start = function (instance) { + try { + return start.call(this, instance); + } + catch (err) { + if (isTrapError(err)) { + _this.terminateAllThreads(); + } + throw err; + } + }; + } + } + patched.add(wasi); +} +function getWasiSymbol(wasi, description) { + const symbols = Object.getOwnPropertySymbols(wasi); + const selectDescription = (description) => (s) => { + if (s.description) { + return s.description === description; + } + return s.toString() === `Symbol(${description})`; + }; + if (Array.isArray(description)) { + return description.map(d => symbols.filter(selectDescription(d))[0]); + } + return symbols.filter(selectDescription(description))[0]; +} +function setupInstance(wasi, instance) { + const [kInstance, kSetMemory] = getWasiSymbol(wasi, ['kInstance', 'kSetMemory']); + wasi[kInstance] = instance; + wasi[kSetMemory](instance.exports.memory); +} + +//#endregion src/wasi-threads.ts + +//#region src/worker.ts +class ThreadMessageHandler { + constructor(options) { + const postMsg = getPostMessage(options); + if (typeof postMsg !== 'function') { + throw new TypeError('options.postMessage is not a function'); + } + this.postMessage = postMsg; + this.onLoad = options?.onLoad; + this.onError = typeof options?.onError === 'function' ? options.onError : (_type, err) => { throw err; }; + this.instance = undefined; + this.messagesBeforeLoad = []; + } + instantiate(data) { + if (typeof this.onLoad === 'function') { + return this.onLoad(data); + } + throw new Error('ThreadMessageHandler.prototype.instantiate is not implemented'); + } + handle(e) { + if (e?.data?.__emnapi__) { + const type = e.data.__emnapi__.type; + const payload = e.data.__emnapi__.payload; + try { + if (type === 'load') { + this._load(payload); + } + else if (type === 'start') { + this.handleAfterLoad(e, () => { + this._start(payload); + }); + } + } + catch (err) { + this.onError(err, type); + } + } + } + _load(payload) { + if (this.instance !== undefined) + return; + let source; + try { + source = this.instantiate(payload); + } + catch (err) { + this._loaded(err, null, payload); + return; + } + const then = source && 'then' in source ? source.then : undefined; + if (typeof then === 'function') { + then.call(source, (source) => { this._loaded(null, source, payload); }, (err) => { this._loaded(err, null, payload); }); + } + else { + this._loaded(null, source, payload); + } + } + _start(payload) { + const wasi_thread_start = this.instance.exports.wasi_thread_start; + if (typeof wasi_thread_start !== 'function') { + const err = new TypeError('wasi_thread_start is not exported'); + notifyPthreadCreateResult(payload.sab, 2, err); + throw err; + } + const postMessage = this.postMessage; + const tid = payload.tid; + const startArg = payload.arg; + notifyPthreadCreateResult(payload.sab, 1); + try { + wasi_thread_start(tid, startArg); + } + catch (err) { + if (err !== 'unwind') { + throw err; + } + else { + return; + } + } + postMessage(createMessage('cleanup-thread', { tid })); + } + _loaded(err, source, payload) { + if (err) { + notifyPthreadCreateResult(payload.sab, 2, err); + throw err; + } + if (source == null) { + const err = new TypeError('onLoad should return an object'); + notifyPthreadCreateResult(payload.sab, 2, err); + throw err; + } + const instance = source.instance; + if (!instance) { + const err = new TypeError('onLoad should return an object which includes "instance"'); + notifyPthreadCreateResult(payload.sab, 2, err); + throw err; + } + this.instance = instance; + const postMessage = this.postMessage; + postMessage(createMessage('loaded', {})); + const messages = this.messagesBeforeLoad; + this.messagesBeforeLoad = []; + for (let i = 0; i < messages.length; i++) { + const data = messages[i]; + this.handle({ data }); + } + } + handleAfterLoad(e, f) { + if (this.instance !== undefined) { + f.call(this, e); + } + else { + this.messagesBeforeLoad.push(e.data); + } + } +} +function notifyPthreadCreateResult(sab, result, error) { + if (sab) { + serizeErrorToBuffer(sab.buffer, result, error); + Atomics.notify(sab, 0); + } +} + +//#endregion dist/wasi-threads.js + +//#region src/emnapi/index.js + +function createNapiModule (options) { + var napiModule = (function () { + + //#region src/core/addfunction.ts + // This gives correct answers for everything less than 2^{14} = 16384 + // I hope nobody is contemplating functions with 16384 arguments... + function uleb128EncodeWithLen(arr) { + const n = arr.length; + // Note: this LEB128 length encoding produces extra byte for n < 128, + // but we don't care as it's only used in a temporary representation. + return [(n % 128) | 128, n >> 7, ...arr]; + } + // Converts a signature like 'vii' into a description of the wasm types, like + // { parameters: ['i32', 'i32'], results: [] }. + function sigToWasmTypes(sig) { + const typeNames = { + i: 'i32', + j: 'i64', + f: 'f32', + d: 'f64', + e: 'externref', + p: 'i32', + }; + const type = { + parameters: [], + results: sig[0] === 'v' ? [] : [typeNames[sig[0]]] + }; + for (let i = 1; i < sig.length; ++i) { + type.parameters.push(typeNames[sig[i]]); + } + return type; + } + // Note: using template literal here instead of plain object + // because jsify serializes objects w/o quotes and Closure will then + // incorrectly mangle the properties. + const wasmTypeCodes = (function () { + const map = { + i: 0x7f, // i32 + p: 0x7f, + j: 0x7e, // i64 + f: 0x7d, // f32 + d: 0x7c, // f64 + e: 0x6f, // externref + }; + return map; + })(); + function generateTypePack(types) { + return uleb128EncodeWithLen(Array.from(types, (type) => { + const code = wasmTypeCodes[type]; + return code; + })); + } + function convertJsFunctionToWasm(func, sig) { + if (_WebAssembly$1.Function) { + return new _WebAssembly$1.Function(sigToWasmTypes(sig), func); + } + // Rest of the module is static + const bytes = Uint8Array.of(0x00, 0x61, 0x73, 0x6d, // magic ("\0asm") + 0x01, 0x00, 0x00, 0x00, // version: 1 + 0x01, // Type section code + // The module is static, with the exception of the type section, which is + // generated based on the signature passed in. + ...uleb128EncodeWithLen([ + 0x01, // count: 1 + 0x60 /* form: func */, + // param types + ...generateTypePack(sig.slice(1)), + // return types (for now only supporting [] if `void` and single [T] otherwise) + ...generateTypePack(sig[0] === 'v' ? '' : sig[0]) + ]), + // The rest of the module is static + 0x02, 0x07, // import section + // (import "e" "f" (func 0 (type 0))) + 0x01, 0x01, 0x65, 0x01, 0x66, 0x00, 0x00, 0x07, 0x05, // export section + // (export "f" (func 0 (type 0))) + 0x01, 0x01, 0x66, 0x00, 0x00); + // We can compile this wasm module synchronously because it is very small. + // This accepts an import (at "e.f"), that it reroutes to an export (at "f") + const module = new _WebAssembly$1.Module(bytes); + const instance = new _WebAssembly$1.Instance(module, { e: { f: func } }); + const wrappedFunc = instance.exports['f']; + return wrappedFunc; + } + const freeTableIndexes = []; + // Weak map of functions in the table to their indexes, created on first use. + let functionsInTableMap; + function getEmptyTableSlot() { + // Reuse a free index if there is one, otherwise grow. + if (freeTableIndexes.length) { + return freeTableIndexes.pop(); + } + try { + // Grow the table + return wasmTable.grow(1); + } + catch (err) { + if (!(err instanceof RangeError)) { + throw err; + } + throw new Error('Unable to grow wasm table. Specify `--growable-table` for wasm-ld.'); + } + } + function updateTableMap(offset, count) { + if (functionsInTableMap) { + for (let i = offset; i < offset + count; i++) { + const item = getWasmTableEntry(i); + // Ignore null values. + if (item) { + functionsInTableMap.set(item, i); + } + } + } + } + function getFunctionAddress(func) { + // First, create the map if this is the first use. + if (!functionsInTableMap) { + functionsInTableMap = new WeakMap(); + let count = wasmTable.length; + count >>>= 0; + updateTableMap(0, count); + } + return functionsInTableMap.get(func) || 0; + } + /** + * Add a function to the table. + * 'sig' parameter is required if the function being added is a JS function. + */ + function addFunction(func, sig) { + // Check if the function is already in the table, to ensure each function + // gets a unique index. + let rtn = getFunctionAddress(func); + if (rtn) { + return rtn; + } + // It's not in the table, add it now. + const ret = getEmptyTableSlot(); + // Set the new value. + try { + // Attempting to call this with JS function will cause table.set() to fail + setWasmTableEntry(ret, func); + } + catch (err) { + if (!(err instanceof TypeError)) { + throw err; + } + if (!sig) { + throw new Error('Missing signature argument to addFunction: ' + func); + } + const wrapped = convertJsFunctionToWasm(func, sig); + setWasmTableEntry(ret, wrapped); + } + functionsInTableMap.set(func, ret); + return ret; + } + function removeFunction(index) { + if (!functionsInTableMap) + return; + functionsInTableMap.delete(getWasmTableEntry(index)); + setWasmTableEntry(index, null); + freeTableIndexes.push(index); + } + + //#endregion src/core/addfunction.ts + + //#region src/core/init.ts + var ENVIRONMENT_IS_NODE = typeof process === 'object' && process !== null && typeof process.versions === 'object' && process.versions !== null && typeof process.versions.node === 'string'; + var ENVIRONMENT_IS_PTHREAD = Boolean(options.childThread); + var waitThreadStart = typeof options.waitThreadStart === 'number' ? options.waitThreadStart : Boolean(options.waitThreadStart); + var wasmInstance; + var wasmModule; + var wasmMemory; + var wasmTable; + var _malloc; + var _free; + var _emnapi_create_env; + var _emnapi_delete_env; + function abort(msg) { + if (typeof _WebAssembly$1.RuntimeError === 'function') { + throw new _WebAssembly$1.RuntimeError(msg); + } + throw Error(msg); + } + function runtimeKeepalivePush() { } + function runtimeKeepalivePop() { } + function getWasmTableEntry(index) { + return wasmTable.get(index); + } + function setWasmTableEntry(index, func) { + wasmTable.set(index, func); + } + function setLastError(env, error_code, engine_error_code, engine_reserved) { + env >>>= 0; + env -= 8; + engine_reserved >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt32(env + 40 /* NapiEnvOffset32.last_error_error_code */, error_code, true); + GET_HEAP_DATA_VIEW().setUint32(env + 36 /* NapiEnvOffset32.last_error_engine_error_code */, engine_error_code, true); + GET_HEAP_DATA_VIEW().setUint32(env + 32 /* NapiEnvOffset32.last_error_engine_reserved */, engine_reserved, true); + return error_code; + } + var napiModule = { + imports: { + env: {}, + napi: {}, + emnapi: {} + }, + exports: {}, + emnapi: {}, + loaded: false, + filename: '', + childThread: ENVIRONMENT_IS_PTHREAD, + initWorker: undefined, + waitThreadStart, + PThread: undefined, + init(options) { + if (napiModule.loaded) + return napiModule.exports; + if (!options) + throw new TypeError('Invalid napi init options'); + const instance = options.instance; + if (!instance?.exports) + throw new TypeError('Invalid wasm instance'); + wasmInstance = instance; + const exports = instance.exports; + const module = options.module; + const memory = options.memory || exports.memory; + const table = options.table || exports.__indirect_function_table; + if (!(module instanceof _WebAssembly$1.Module)) + throw new TypeError('Invalid wasm module'); + if (!(memory instanceof _WebAssembly$1.Memory)) + throw new TypeError('Invalid wasm memory'); + if (!(table instanceof _WebAssembly$1.Table)) + throw new TypeError('Invalid wasm table'); + wasmModule = module; + wasmMemory = memory; + wasmTable = table; + if (typeof exports.malloc !== 'function') + throw new TypeError('malloc is not exported'); + if (typeof exports.free !== 'function') + throw new TypeError('free is not exported'); + _malloc = exports.malloc; + _free = exports.free; + _emnapi_create_env = exports.emnapi_create_env; + _emnapi_delete_env = exports.emnapi_delete_env; + if (!napiModule.childThread) { + // main thread only + const NODE_MODULE_VERSION = 127 /* Version.NODE_MODULE_VERSION */; + const nodeRegisterModuleSymbol = `node_register_module_v${NODE_MODULE_VERSION}`; + if (typeof instance.exports[nodeRegisterModuleSymbol] === 'function') { + const scope = emnapiCtx.isolate.openScope(); + try { + const exports = napiModule.exports; + const exportsHandle = scope.add(exports); + const moduleHandle = scope.add(napiModule); + instance.exports[nodeRegisterModuleSymbol](exportsHandle, moduleHandle, 5); + } + catch (err) { + if (err !== 'unwind') { + throw err; + } + } + finally { + emnapiCtx.isolate.closeScope(scope); + } + napiModule.loaded = true; + delete napiModule.envObject; + return napiModule.exports; + } + const find = Object.keys(instance.exports).filter(k => k.startsWith('node_register_module_v')); + if (find.length > 0) { + throw new Error(`The module${napiModule.filename ? ` '${napiModule.filename}'` : ''} + was compiled against a different Node.js version using + NODE_MODULE_VERSION ${find[0].slice(22)}. This version of Node.js requires + NODE_MODULE_VERSION ${NODE_MODULE_VERSION}.`); + } + let moduleApiVersion = 8 /* Version.NODE_API_DEFAULT_MODULE_API_VERSION */; + const node_api_module_get_api_version_v1 = instance.exports.node_api_module_get_api_version_v1; + if (typeof node_api_module_get_api_version_v1 === 'function') { + moduleApiVersion = node_api_module_get_api_version_v1(); + } + const envObject = napiModule.envObject || (() => { + let address = _emnapi_create_env(); + address >>>= 0; + address += 8; + const envObject = napiModule.envObject = emnapiEnv = emnapiCtx.createEnv(napiModule.filename, moduleApiVersion, { + address, + deleteEnv: (ptr) => { + _emnapi_delete_env(ptr - 8); + }, + setLastError, + makeDynCall_vppp: (cb) => (wasmTable.get(cb)), + makeDynCall_vp: (cb) => (wasmTable.get(cb)), + abort, + }, emnapiNodeBinding); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(address - 8 + 24 /* NapiEnvOffset32.id */, envObject.id, true); + return envObject; + })(); + const scope = emnapiCtx.openScope(envObject); + try { + envObject.callIntoModule((_envObject) => { + const exports = napiModule.exports; + const env = envObject.bridge.address; + const exportsHandle = scope.add(exports); + const napi_register_wasm_v1 = instance.exports.napi_register_wasm_v1; + const napiValue = napi_register_wasm_v1(env, exportsHandle); + napiModule.exports = (!napiValue) ? exports : emnapiCtx.jsValueFromNapiValue(napiValue); + }); + } + catch (e) { + if (e !== 'unwind') { + throw e; + } + } + finally { + emnapiCtx.closeScope(envObject, scope); + } + napiModule.loaded = true; + delete napiModule.envObject; + return napiModule.exports; + } + } + }; + var emnapiCtx; + var emnapiEnv; + var emnapiNodeBinding; + var onCreateWorker = undefined; + var out; + var err; + if (!ENVIRONMENT_IS_PTHREAD) { + const context = options.context; + if (typeof context !== 'object' || context === null) { + throw new TypeError("Invalid `options.context`. Use `import { getDefaultContext } from '@emnapi/runtime'`"); + } + emnapiCtx = context; + } + else { + emnapiCtx = options?.context; + const postMsg = typeof options.postMessage === 'function' + ? options.postMessage + : typeof postMessage === 'function' + ? postMessage + : undefined; + if (typeof postMsg !== 'function') { + throw new TypeError('No postMessage found'); + } + napiModule.postMessage = postMsg; + } + if (typeof options.filename === 'string') { + napiModule.filename = options.filename; + } + if (typeof options.onCreateWorker === 'function') { + onCreateWorker = options.onCreateWorker; + } + if (typeof options.print === 'function') { + out = options.print; + } + else { + out = console.log.bind(console); + } + if (typeof options.printErr === 'function') { + err = options.printErr; + } + else { + err = console.warn.bind(console); + } + if ('nodeBinding' in options) { + const nodeBinding = options.nodeBinding; + if (typeof nodeBinding !== 'object' || nodeBinding === null) { + throw new TypeError('Invalid `options.nodeBinding`. Use @emnapi/node-binding package'); + } + emnapiNodeBinding = nodeBinding; + } + var emnapiAsyncWorkPoolSize = 0; + if ('asyncWorkPoolSize' in options) { + if (typeof options.asyncWorkPoolSize !== 'number') { + throw new TypeError('options.asyncWorkPoolSize must be a integer'); + } + emnapiAsyncWorkPoolSize = options.asyncWorkPoolSize >> 0; + if (emnapiAsyncWorkPoolSize > 1024) { + emnapiAsyncWorkPoolSize = 1024; + } + else if (emnapiAsyncWorkPoolSize < -1024) { + emnapiAsyncWorkPoolSize = -1024; + } + } + var singleThreadAsyncWork = ENVIRONMENT_IS_PTHREAD ? false : (emnapiAsyncWorkPoolSize <= 0); + function _emnapi_async_work_pool_size() { + return Math.abs(emnapiAsyncWorkPoolSize); + } + napiModule.imports.env._emnapi_async_work_pool_size = _emnapi_async_work_pool_size; + // ------------------------------ pthread ------------------------------- + function emnapiAddSendListener(worker) { + if (!worker) + return false; + if (worker._emnapiSendListener) + return true; + const handler = function (e) { + const data = ENVIRONMENT_IS_NODE ? e : e.data; + const __emnapi__ = data.__emnapi__; + if (__emnapi__ && __emnapi__.type === 'async-send') { + if (ENVIRONMENT_IS_PTHREAD) { + const postMessage = napiModule.postMessage; + postMessage({ __emnapi__ }); + } + else { + const callback = __emnapi__.payload.callback; + (wasmTable.get(callback))(__emnapi__.payload.data); + } + } + }; + const dispose = function () { + if (ENVIRONMENT_IS_NODE) { + worker.off('message', handler); + } + else { + worker.removeEventListener('message', handler, false); + } + delete worker._emnapiSendListener; + }; + worker._emnapiSendListener = { handler, dispose }; + if (ENVIRONMENT_IS_NODE) { + worker.on('message', handler); + } + else { + worker.addEventListener('message', handler, false); + } + return true; + } + napiModule.emnapi.addSendListener = emnapiAddSendListener; + var PThread = new ThreadManager(ENVIRONMENT_IS_PTHREAD + ? { + printErr: err, + childThread: true + } + : { + printErr: err, + beforeLoad: (worker) => { + emnapiAddSendListener(worker); + }, + reuseWorker: options.reuseWorker, + onCreateWorker: onCreateWorker + }); + napiModule.PThread = PThread; + + //#endregion src/core/init.ts + + var initMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + ENVIRONMENT_IS_NODE: ENVIRONMENT_IS_NODE, + ENVIRONMENT_IS_PTHREAD: ENVIRONMENT_IS_PTHREAD, + PThread: PThread, + _emnapi_async_work_pool_size: _emnapi_async_work_pool_size, + get _emnapi_create_env () { return _emnapi_create_env; }, + get _emnapi_delete_env () { return _emnapi_delete_env; }, + get _free () { return _free; }, + get _malloc () { return _malloc; }, + abort: abort, + addFunction: addFunction, + get emnapiAsyncWorkPoolSize () { return emnapiAsyncWorkPoolSize; }, + get emnapiCtx () { return emnapiCtx; }, + get emnapiEnv () { return emnapiEnv; }, + get emnapiNodeBinding () { return emnapiNodeBinding; }, + get err () { return err; }, + getWasmTableEntry: getWasmTableEntry, + napiModule: napiModule, + get onCreateWorker () { return onCreateWorker; }, + get out () { return out; }, + removeFunction: removeFunction, + runtimeKeepalivePop: runtimeKeepalivePop, + runtimeKeepalivePush: runtimeKeepalivePush, + setWasmTableEntry: setWasmTableEntry, + singleThreadAsyncWork: singleThreadAsyncWork, + waitThreadStart: waitThreadStart, + get wasmInstance () { return wasmInstance; }, + get wasmMemory () { return wasmMemory; }, + get wasmModule () { return wasmModule; }, + get wasmTable () { return wasmTable; } + }); + + //#region src/util.ts + // /** + // * @__sig ipp + // */ + // export function napi_get_last_error_info (env: napi_env, result: void_pp): napi_status { + // return emnapiRuntimeModuleExports.napi_get_last_error_info(env, result) + // } + /** @__sig p */ + function _emnapi_get_node_api_js_vtable() { + return 0; + } + /** @__sig p */ + function _emnapi_get_node_api_module_vtable() { + return 0; + } + /** + * @__sig vppp + */ + function _emnapi_get_node_version(major, minor, patch) { + major >>>= 0; + minor >>>= 0; + patch >>>= 0; + const versions = (typeof process === 'object' && process !== null && + typeof process.versions === 'object' && process.versions !== null && + typeof process.versions.node === 'string') + ? process.versions.node.split('.').map((n) => Number(n)) + : [0, 0, 0]; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(major, versions[0], true); + GET_HEAP_DATA_VIEW().setUint32(minor, versions[1], true); + GET_HEAP_DATA_VIEW().setUint32(patch, versions[2], true); + } + /** + * @__sig v + * @__deps $runtimeKeepalivePush + */ + function _emnapi_runtime_keepalive_push() { + } + /** + * @__sig v + * @__deps $runtimeKeepalivePop + */ + function _emnapi_runtime_keepalive_pop() { + } + /** + * @__sig vpp + */ + function _emnapi_set_immediate(callback, data) { + emnapiCtx.features.setImmediate(() => { + (wasmTable.get(callback))(data); + }); + } + /** + * @__sig vpp + */ + function _emnapi_next_tick(callback, data) { + Promise.resolve().then(() => { + (wasmTable.get(callback))(data); + }); + } + /** + * @__sig vipppi + */ + function _emnapi_callback_into_module(forceUncaught, env, callback, data, close_scope_if_throw) { + const envObject = emnapiEnv; + const scope = emnapiCtx.openScope(envObject); + try { + envObject.callbackIntoModule(Boolean(forceUncaught), () => { + (wasmTable.get(callback))(env, data); + }); + } + catch (err) { + emnapiCtx.closeScope(envObject, scope); + if (close_scope_if_throw) { + emnapiCtx.closeScope(envObject); + } + throw err; + } + emnapiCtx.closeScope(envObject, scope); + } + /** + * @__sig vipppp + */ + function _emnapi_call_finalizer(forceUncaught, env, callback, data, hint) { + const envObject = emnapiEnv; + callback >>>= 0; + envObject.callFinalizerInternal(forceUncaught, callback, data, hint); + } + /** + * @__sig v + */ + function _emnapi_ctx_increase_waiting_request_counter() { + emnapiCtx.increaseWaitingRequestCounter(); + } + /** + * @__sig v + */ + function _emnapi_ctx_decrease_waiting_request_counter() { + emnapiCtx.decreaseWaitingRequestCounter(); + } + /** + * @__sig i + */ + function _emnapi_is_main_runtime_thread() { + return ENVIRONMENT_IS_PTHREAD ? 0 : 1; + } + /** + * @__sig i + */ + function _emnapi_is_main_browser_thread() { + return (typeof window !== 'undefined' && typeof document !== 'undefined' && !ENVIRONMENT_IS_NODE) ? 1 : 0; + } + /** + * @__sig v + */ + function _emnapi_unwind() { + throw 'unwind'; + } + /** + * @__sig d + */ + function _emnapi_get_now() { + return performance.timeOrigin + performance.now(); + } + function $emnapiSetValueI64(result, numberValue) { + let tempDouble; + const tempI64 = [ + numberValue >>> 0, + (tempDouble = numberValue, +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0) + ]; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt32(result, tempI64[0], true); + GET_HEAP_DATA_VIEW().setInt32(result + 4, tempI64[1], true); + } + /** + * @__deps $emnapiCtx + * @__sig p + */ + function _emnapi_open_handle_scope() { + return emnapiCtx.isolate.openScope().id; + } + /** + * @__deps $emnapiCtx + * @__sig vp + */ + function _emnapi_close_handle_scope(_scope) { + return emnapiCtx.isolate.closeScope(); + } + + //#endregion src/util.ts + + var utilMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + $emnapiSetValueI64: $emnapiSetValueI64, + _emnapi_call_finalizer: _emnapi_call_finalizer, + _emnapi_callback_into_module: _emnapi_callback_into_module, + _emnapi_close_handle_scope: _emnapi_close_handle_scope, + _emnapi_ctx_decrease_waiting_request_counter: _emnapi_ctx_decrease_waiting_request_counter, + _emnapi_ctx_increase_waiting_request_counter: _emnapi_ctx_increase_waiting_request_counter, + _emnapi_get_node_api_js_vtable: _emnapi_get_node_api_js_vtable, + _emnapi_get_node_api_module_vtable: _emnapi_get_node_api_module_vtable, + _emnapi_get_node_version: _emnapi_get_node_version, + _emnapi_get_now: _emnapi_get_now, + _emnapi_is_main_browser_thread: _emnapi_is_main_browser_thread, + _emnapi_is_main_runtime_thread: _emnapi_is_main_runtime_thread, + _emnapi_next_tick: _emnapi_next_tick, + _emnapi_open_handle_scope: _emnapi_open_handle_scope, + _emnapi_runtime_keepalive_pop: _emnapi_runtime_keepalive_pop, + _emnapi_runtime_keepalive_push: _emnapi_runtime_keepalive_push, + _emnapi_set_immediate: _emnapi_set_immediate, + _emnapi_unwind: _emnapi_unwind + }); + + //#region src/core/async.ts + function emnapiGetWorkerByPthreadPtr(pthreadPtr) { + const view = new DataView(wasmMemory.buffer); + /** + * wasi-sdk-20.0+threads + * + * struct pthread { + * struct pthread *self; // 0 + * struct pthread *prev, *next; // 4, 8 + * uintptr_t sysinfo; // 12 + * uintptr_t canary; // 16 + * int tid; // 20 + * // ... + * } + */ + const tidOffset = 20; + const tid = view.getInt32(pthreadPtr + tidOffset, true); + const worker = PThread.pthreads[tid]; + return worker; + } + /** @__sig vp */ + function _emnapi_worker_ref(pthreadPtr) { + if (ENVIRONMENT_IS_PTHREAD) + return; + pthreadPtr >>>= 0; + const worker = emnapiGetWorkerByPthreadPtr(pthreadPtr); + if (worker && typeof worker.ref === 'function') { + worker.ref(); + } + } + /** @__sig vp */ + function _emnapi_worker_unref(pthreadPtr) { + if (ENVIRONMENT_IS_PTHREAD) + return; + pthreadPtr >>>= 0; + const worker = emnapiGetWorkerByPthreadPtr(pthreadPtr); + if (worker && typeof worker.unref === 'function') { + worker.unref(); + } + } + /** @__sig vipp */ + function _emnapi_async_send_js(type, callback, data) { + if (ENVIRONMENT_IS_PTHREAD) { + const postMessage = napiModule.postMessage; + postMessage({ + __emnapi__: { + type: 'async-send', + payload: { + callback, + data + } + } + }); + } + else { + switch (type) { + case 0: + _emnapi_set_immediate(callback, data); + break; + case 1: + _emnapi_next_tick(callback, data); + break; + } + } + } + // function ptrToString (ptr: number): string { + // return '0x' + ('00000000' + ptr.toString(16)).slice(-8) + // } + var uvThreadpoolReadyResolve; + var uvThreadpoolReady = new Promise((resolve) => { + uvThreadpoolReadyResolve = function () { + uvThreadpoolReady.ready = true; + resolve(); + }; + }); + uvThreadpoolReady.ready = false; + /** @__sig vppi */ + function _emnapi_after_uvthreadpool_ready(callback, q, type) { + if (uvThreadpoolReady.ready) { + (wasmTable.get(callback))(q, type); + } + else { + uvThreadpoolReady.then(() => { + (wasmTable.get(callback))(q, type); + }); + } + } + /** @__sig vpi */ + function _emnapi_tell_js_uvthreadpool(threads, size) { + const p = []; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + for (let i = 0; i < size; i++) { + const pthreadPtr = GET_HEAP_DATA_VIEW().getUint32(threads + i * 4, true); + const worker = emnapiGetWorkerByPthreadPtr(pthreadPtr); + p.push(new Promise((resolve) => { + const handler = function (e) { + const data = ENVIRONMENT_IS_NODE ? e : e.data; + const __emnapi__ = data.__emnapi__; + if (__emnapi__ && __emnapi__.type === 'async-thread-ready') { + resolve(); + if (worker && typeof worker.unref === 'function') { + worker.unref(); + } + if (ENVIRONMENT_IS_NODE) { + worker.off('message', handler); + } + else { + worker.removeEventListener('message', handler); + } + } + }; + if (ENVIRONMENT_IS_NODE) { + worker.on('message', handler); + } + else { + worker.addEventListener('message', handler); + } + })); + } + Promise.all(p).then(uvThreadpoolReadyResolve); + } + /** @__sig v */ + function _emnapi_emit_async_thread_ready() { + if (!ENVIRONMENT_IS_PTHREAD) + return; + const postMessage = napiModule.postMessage; + postMessage({ + __emnapi__: { + type: 'async-thread-ready', + payload: {} + } + }); + } + + //#endregion src/core/async.ts + + var asyncMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + _emnapi_after_uvthreadpool_ready: _emnapi_after_uvthreadpool_ready, + _emnapi_async_send_js: _emnapi_async_send_js, + _emnapi_emit_async_thread_ready: _emnapi_emit_async_thread_ready, + _emnapi_tell_js_uvthreadpool: _emnapi_tell_js_uvthreadpool, + _emnapi_worker_ref: _emnapi_worker_ref, + _emnapi_worker_unref: _emnapi_worker_unref + }); + + //#region src/macro.ts + + //#endregion src/macro.ts + + //#region src/core/memory.ts + /** @__sig ipjp */ + function napi_adjust_external_memory(env, change_in_bytes, adjusted_value) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + const envObject = emnapiEnv; + if (!adjusted_value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + let adjusted_memory = emnapiCtx.adjustAmountOfExternalAllocatedMemory(change_in_bytes); + adjusted_value >>>= 0; + if (emnapiCtx.features.BigInt) { + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setBigInt64(adjusted_value, BigInt(adjusted_memory), true); + } + else { + $emnapiSetValueI64(adjusted_value, Number(adjusted_memory)); + } + return envObject.clearLastError(); + } + + //#endregion src/core/memory.ts + + var memoryMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + napi_adjust_external_memory: napi_adjust_external_memory + }); + + //#region src/memory.ts + /** + * @__deps malloc + * @__deps free + * @__postset + * ``` + * emnapiExternalMemory.init(); + * ``` + */ + const emnapiExternalMemory = { + registry: typeof FinalizationRegistry === 'function' ? new FinalizationRegistry(function (_pointer) { _free(_pointer); }) : undefined, + table: new WeakMap(), + wasmMemoryViewTable: new WeakMap(), + // populated by init(): live intrinsic function references must not exist at + // library definition time — the emscripten jsifier re-serializes this object + // and native functions do not stringify to parseable source + intrinsics: undefined, + init: function () { + emnapiExternalMemory.registry = typeof FinalizationRegistry === 'function' ? new FinalizationRegistry(function (_pointer) { _free(_pointer); }) : undefined; + emnapiExternalMemory.table = new WeakMap(); + emnapiExternalMemory.wasmMemoryViewTable = new WeakMap(); + const sharedArrayBufferByteLength = typeof SharedArrayBuffer === 'function' + ? Object.getOwnPropertyDescriptor(SharedArrayBuffer.prototype, 'byteLength')?.get + : undefined; + // cached intrinsic prototype getters and element-type constructors: they + // read the internal slots directly like native Node-API does, so user + // accessors and user subclass constructors can never run inside get-info + // metadata reads, descriptor registration or view reconstruction, and they + // work for instances from any realm + emnapiExternalMemory.intrinsics = { + // ArrayBuffer.isView ignores its `this`, so a bare cached reference is + // safe and cannot be swapped out by user code replacing the global + isView: ArrayBuffer.isView, + typedArray: { + buffer: Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Uint8Array.prototype), 'buffer').get, + byteOffset: Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Uint8Array.prototype), 'byteOffset').get, + length: Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Uint8Array.prototype), 'length').get, + tag: Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Uint8Array.prototype), Symbol.toStringTag).get + }, + dataView: { + buffer: Object.getOwnPropertyDescriptor(DataView.prototype, 'buffer').get, + byteOffset: Object.getOwnPropertyDescriptor(DataView.prototype, 'byteOffset').get, + byteLength: Object.getOwnPropertyDescriptor(DataView.prototype, 'byteLength').get + }, + arrayBuffer: { + byteLength: Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, 'byteLength').get + }, + // a SharedArrayBuffer polyfill may lack the byteLength accessor: degrade + // to the hidden-global classification path instead of throwing here + sharedArrayBuffer: sharedArrayBufferByteLength !== undefined + ? { + byteLength: sharedArrayBufferByteLength + } + : undefined, + ctors: { + Int8Array, + Uint8Array, + Uint8ClampedArray, + Int16Array, + Uint16Array, + Int32Array, + Uint32Array, + Float16Array: typeof Float16Array === 'function' ? Float16Array : undefined, + Float32Array, + Float64Array, + BigInt64Array, + BigUint64Array + }, + bufferFrom: undefined + }; + }, + isSharedArrayBuffer(value) { + const sharedArrayBuffer = emnapiExternalMemory.intrinsics.sharedArrayBuffer; + if (sharedArrayBuffer !== undefined) { + if (typeof SharedArrayBuffer === 'function' && value instanceof SharedArrayBuffer) + return true; + // the intrinsic byteLength getter reads the internal slot: it accepts + // SharedArrayBuffer instances from any realm and throws for anything + // else, without consulting user-controllable properties + try { + sharedArrayBuffer.byteLength.call(value); + return true; + } + catch (_) { + return false; + } + } + // hidden-global environment (see #143): the SharedArrayBuffer global was + // absent at init time, but the engine can still hand out genuine SABs + // (e.g. a shared WebAssembly.Memory buffer). A genuine ArrayBuffer + // answers the intrinsic byteLength probe, settling the common case + // without the (spoofable, user-JS-running) toString tag read below. + try { + emnapiExternalMemory.intrinsics.arrayBuffer.byteLength.call(value); + return false; + } + catch (_) { } + return Object.prototype.toString.call(value) === '[object SharedArrayBuffer]'; + }, + isDetachedArrayBuffer: function (arrayBuffer) { + if (emnapiExternalMemory.bufferByteLength(arrayBuffer) === 0) { + try { + // eslint-disable-next-line no-new + new Uint8Array(arrayBuffer); + } + catch (_) { + return true; + } + } + return false; + }, + bufferByteLength: function (buffer) { + const intrinsics = emnapiExternalMemory.intrinsics; + try { + return intrinsics.arrayBuffer.byteLength.call(buffer); + } + catch (err) { + const sharedArrayBuffer = intrinsics.sharedArrayBuffer; + if (sharedArrayBuffer !== undefined) { + return sharedArrayBuffer.byteLength.call(buffer); + } + // hidden-global environment (see isSharedArrayBuffer): no SAB getter + // was capturable at init, recover it from the instance's own prototype + // (for a genuine SAB that is the hidden SharedArrayBuffer.prototype) + const proto = Object.getPrototypeOf(buffer); + const get = proto !== null && proto !== undefined + ? Object.getOwnPropertyDescriptor(proto, 'byteLength')?.get + : undefined; + if (get === undefined) + throw err; + return get.call(buffer); + } + }, + viewBuffer: function (view) { + const intrinsics = emnapiExternalMemory.intrinsics; + return intrinsics.typedArray.tag.call(view) === undefined + ? intrinsics.dataView.buffer.call(view) + : intrinsics.typedArray.buffer.call(view); + }, + viewByteOffset: function (view) { + const intrinsics = emnapiExternalMemory.intrinsics; + return intrinsics.typedArray.tag.call(view) === undefined + ? intrinsics.dataView.byteOffset.call(view) + : intrinsics.typedArray.byteOffset.call(view); + }, + // element count for typed arrays, byteLength for DataViews (the unit used + // by the napi_get_typedarray_info / napi_get_dataview_info length outputs + // and by the view constructors at reconstruction) + viewLength: function (view) { + const intrinsics = emnapiExternalMemory.intrinsics; + return intrinsics.typedArray.tag.call(view) === undefined + ? intrinsics.dataView.byteLength.call(view) + : intrinsics.typedArray.length.call(view); + }, + // Buffer descriptors are only ever created by emnapi's own buffer creation + // paths; capturing Buffer.from the first time one is created snapshots the + // legitimate function before any later reconstruction, so a user replacing + // Buffer.from afterwards cannot influence a refreshed view + getBufferFrom: function () { + return emnapiExternalMemory.intrinsics.bufferFrom ?? + (emnapiExternalMemory.intrinsics.bufferFrom = emnapiCtx.features.Buffer.from); + }, + getArrayBufferPointer: function (arrayBuffer, shouldCopy) { + const info = { + address: 0, + ownership: 0 /* ReferenceOwnership.kRuntime */, + runtimeAllocated: 0 + }; + if (arrayBuffer === wasmMemory.buffer) { + return info; + } + const isDetached = emnapiExternalMemory.isDetachedArrayBuffer(arrayBuffer); + if (emnapiExternalMemory.table.has(arrayBuffer)) { + const cachedInfo = emnapiExternalMemory.table.get(arrayBuffer); + if (isDetached) { + cachedInfo.address = 0; + return cachedInfo; + } + if (shouldCopy && cachedInfo.ownership === 0 /* ReferenceOwnership.kRuntime */ && cachedInfo.runtimeAllocated === 1) { + new Uint8Array(wasmMemory.buffer).set(new Uint8Array(arrayBuffer), cachedInfo.address); + } + return cachedInfo; + } + const byteLength = emnapiExternalMemory.bufferByteLength(arrayBuffer); + if (isDetached || (byteLength === 0)) { + return info; + } + if (!shouldCopy) { + return info; + } + let pointer = _malloc(byteLength); + if (!pointer) + throw new Error('Out of memory'); + pointer >>>= 0; + new Uint8Array(wasmMemory.buffer).set(new Uint8Array(arrayBuffer), pointer); + info.address = pointer; + info.ownership = emnapiExternalMemory.registry ? 0 /* ReferenceOwnership.kRuntime */ : 1 /* ReferenceOwnership.kUserland */; + info.runtimeAllocated = 1; + emnapiExternalMemory.table.set(arrayBuffer, info); + emnapiExternalMemory.registry?.register(arrayBuffer, pointer); + return info; + }, + getOrUpdateMemoryView: function (view) { + // classify and read the view state through the cached intrinsic + // prototype getters only: own accessors on the instance could otherwise + // run user JS that grows (and detaches) a non-shared memory in the + // middle of registration, poisoning the stored descriptor; the intrinsic + // reads return primitives from the internal slots and run zero user JS. + // The @@toStringTag slot getter classifies views from any realm: it + // returns the element-type name for typed arrays (seeing through user + // subclasses) and undefined for DataViews + const intrinsics = emnapiExternalMemory.intrinsics; + const tag = intrinsics.typedArray.tag.call(view); + const isDataView = tag === undefined; + const buffer = isDataView ? intrinsics.dataView.buffer.call(view) : intrinsics.typedArray.buffer.call(view); + if (buffer === wasmMemory.buffer) { + if (!emnapiExternalMemory.wasmMemoryViewTable.has(view)) { + emnapiExternalMemory.wasmMemoryViewTable.set(view, { + // store the intrinsic element-type constructor keyed by the + // @@toStringTag slot (never view.constructor and never a + // user-definable Buffer @@hasInstance check): reconstruction after a + // memory growth must not run any user code, because it could grow + // again after the fresh buffer was captured as an argument. Buffers + // are tagged 'Uint8Array' and reconstruct as base Uint8Array views + Ctor: isDataView ? DataView : intrinsics.ctors[tag], + address: isDataView ? intrinsics.dataView.byteOffset.call(view) : intrinsics.typedArray.byteOffset.call(view), + length: isDataView ? intrinsics.dataView.byteLength.call(view) : intrinsics.typedArray.length.call(view), + ownership: 1 /* ReferenceOwnership.kUserland */, + runtimeAllocated: 0 + }); + } + return view; + } + const maybeOldWasmMemory = emnapiExternalMemory.isDetachedArrayBuffer(buffer) || emnapiExternalMemory.isSharedArrayBuffer(buffer); + if (maybeOldWasmMemory && emnapiExternalMemory.wasmMemoryViewTable.has(view)) { + const info = emnapiExternalMemory.wasmMemoryViewTable.get(view); + const Ctor = info.Ctor; + let newView; + const Buffer = emnapiCtx.features.Buffer; + if (typeof Buffer === 'function' && Ctor === Buffer) { + // reconstruct through the Buffer.from captured at creation time + newView = emnapiExternalMemory.getBufferFrom()(wasmMemory.buffer, info.address, info.length); + } + else { + newView = new Ctor(wasmMemory.buffer, info.address, info.length); + } + emnapiExternalMemory.wasmMemoryViewTable.set(newView, info); + return newView; + } + return view; + }, + getViewPointer: function (view, shouldCopy) { + view = emnapiExternalMemory.getOrUpdateMemoryView(view); + const buffer = emnapiExternalMemory.viewBuffer(view); + if (buffer === wasmMemory.buffer) { + if (emnapiExternalMemory.wasmMemoryViewTable.has(view)) { + const { address, ownership, runtimeAllocated } = emnapiExternalMemory.wasmMemoryViewTable.get(view); + return { address, ownership, runtimeAllocated, view }; + } + return { address: emnapiExternalMemory.viewByteOffset(view), ownership: 1 /* ReferenceOwnership.kUserland */, runtimeAllocated: 0, view }; + } + const { address, ownership, runtimeAllocated } = emnapiExternalMemory.getArrayBufferPointer(buffer, shouldCopy); + return { address: address === 0 ? 0 : (address + emnapiExternalMemory.viewByteOffset(view)), ownership, runtimeAllocated, view }; + } + }; + /** + * Metadata layout in wasm shared memory (allocated with _malloc): + * offset 0: refcount (int32, 4 bytes - for Atomics) + * offset POINTER_SIZE: external_data (pointer) + * offset 2*POINTER_SIZE: byte_length (size_t) + * offset 3*POINTER_SIZE: finalize_cb (pointer) + * offset 4*POINTER_SIZE: finalize_data (pointer) + * offset 5*POINTER_SIZE: finalize_hint (pointer) + * Total: 6 * POINTER_SIZE bytes + */ + /** + * @__postset + * ``` + * emnapiExternalSAB.init(); + * ``` + */ + const emnapiExternalSAB = { + registry: undefined, + handleTable: new WeakMap(), + init: function () { + emnapiExternalSAB.handleTable = new WeakMap(); + emnapiExternalSAB.registry = typeof FinalizationRegistry === 'function' + ? new FinalizationRegistry(function (metaPtr) { + emnapiExternalSAB.release(metaPtr); + }) + : undefined; + }, + allocMeta: function (external_data, byte_length, finalize_cb, finalize_data, finalize_hint) { + const size = 4 * 6; + let metaPtr = _malloc(size); + if (!metaPtr) + throw new Error('Out of memory'); + metaPtr >>>= 0; + // refcount = 1 + Atomics.store(new Int32Array(wasmMemory.buffer, metaPtr, 1), 0, 1); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(metaPtr + 4, external_data, true); + GET_HEAP_DATA_VIEW().setUint32(metaPtr + 8, byte_length, true); + GET_HEAP_DATA_VIEW().setUint32(metaPtr + 12, finalize_cb, true); + GET_HEAP_DATA_VIEW().setUint32(metaPtr + 16, finalize_data, true); + GET_HEAP_DATA_VIEW().setUint32(metaPtr + 20, finalize_hint, true); + return metaPtr; + }, + readMeta: function (metaPtr) { + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + const external_data = GET_HEAP_DATA_VIEW().getUint32(metaPtr + 4, true); + const byte_length = GET_HEAP_DATA_VIEW().getUint32(metaPtr + 8, true); + const finalize_cb = GET_HEAP_DATA_VIEW().getUint32(metaPtr + 12, true); + const finalize_data = GET_HEAP_DATA_VIEW().getUint32(metaPtr + 16, true); + const finalize_hint = GET_HEAP_DATA_VIEW().getUint32(metaPtr + 20, true); + return { external_data, byte_length, finalize_cb, finalize_data, finalize_hint }; + }, + release: function (metaPtr) { + const oldRefcount = Atomics.sub(new Int32Array(wasmMemory.buffer, metaPtr, 1), 0, 1); + if (oldRefcount === 1) { + // refcount reached 0, we are the last holder + const info = emnapiExternalSAB.readMeta(metaPtr); + const finalize_cb = info.finalize_cb; + if (finalize_cb) { + const finalize_data = info.finalize_data; + const finalize_hint = info.finalize_hint; + (wasmTable.get(finalize_cb))(finalize_data, finalize_hint); + } + _free(metaPtr); + } + } + }; + + //#endregion src/memory.ts + + //#region src/string.ts + /* eslint-disable @stylistic/indent */ + /** + * @__postset + * ``` + * emnapiString.init(); + * ``` + */ + var emnapiString = { + utf8Decoder: undefined, + utf16Decoder: undefined, + init() { + const fallbackDecoder = { + decode(bytes) { + let inputIndex = 0; + const pendingSize = Math.min(0x1000, bytes.length + 1); + const pending = new Uint16Array(pendingSize); + const chunks = []; + let pendingIndex = 0; + for (;;) { + const more = inputIndex < bytes.length; + if (!more || (pendingIndex >= pendingSize - 1)) { + const subarray = pending.subarray(0, pendingIndex); + const arraylike = subarray; + chunks.push(String.fromCharCode.apply(null, arraylike)); + if (!more) { + return chunks.join(''); + } + bytes = bytes.subarray(inputIndex); + inputIndex = 0; + pendingIndex = 0; + } + const byte1 = bytes[inputIndex++]; + if ((byte1 & 0x80) === 0) { + pending[pendingIndex++] = byte1; + } + else if ((byte1 & 0xe0) === 0xc0) { + const byte2 = bytes[inputIndex++] & 0x3f; + pending[pendingIndex++] = ((byte1 & 0x1f) << 6) | byte2; + } + else if ((byte1 & 0xf0) === 0xe0) { + const byte2 = bytes[inputIndex++] & 0x3f; + const byte3 = bytes[inputIndex++] & 0x3f; + pending[pendingIndex++] = ((byte1 & 0x1f) << 12) | (byte2 << 6) | byte3; + } + else if ((byte1 & 0xf8) === 0xf0) { + const byte2 = bytes[inputIndex++] & 0x3f; + const byte3 = bytes[inputIndex++] & 0x3f; + const byte4 = bytes[inputIndex++] & 0x3f; + let codepoint = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0c) | (byte3 << 0x06) | byte4; + if (codepoint > 0xffff) { + codepoint -= 0x10000; + pending[pendingIndex++] = (codepoint >>> 10) & 0x3ff | 0xd800; + codepoint = 0xdc00 | codepoint & 0x3ff; + } + pending[pendingIndex++] = codepoint; + } + else ; + } + } + }; + let utf8Decoder; + utf8Decoder = typeof TextDecoder === 'function' ? new TextDecoder() : fallbackDecoder; + emnapiString.utf8Decoder = utf8Decoder; + const fallbackDecoder2 = { + decode(input) { + const bytes = new Uint16Array(input.buffer, input.byteOffset, input.byteLength / 2); + if (bytes.length <= 0x1000) { + return String.fromCharCode.apply(null, bytes); + } + const chunks = []; + let i = 0; + let len = 0; + for (; i < bytes.length; i += len) { + len = Math.min(0x1000, bytes.length - i); + chunks.push(String.fromCharCode.apply(null, bytes.subarray(i, i + len))); + } + return chunks.join(''); + } + }; + let utf16Decoder; + utf16Decoder = typeof TextDecoder === 'function' ? new TextDecoder('utf-16le') : fallbackDecoder2; + emnapiString.utf16Decoder = utf16Decoder; + }, + lengthBytesUTF8(str) { + let c; + let len = 0; + for (let i = 0; i < str.length; ++i) { + c = str.charCodeAt(i); + if (c <= 0x7F) { + len++; + } + else if (c <= 0x7FF) { + len += 2; + } + else if (c >= 0xD800 && c <= 0xDFFF) { + len += 4; + ++i; + } + else { + len += 3; + } + } + return len; + }, + UTF8ToString(ptr, length) { + if (!ptr || !length) + return ''; + ptr >>>= 0; + const HEAPU8 = new Uint8Array(wasmMemory.buffer); + let end = ptr; + if (length === -1 || length === 4294967295) { + for (; HEAPU8[end];) + ++end; + } + else { + end = ptr + (length >>> 0); + } + length = end - ptr; + if (length <= 16) { + let idx = ptr; + var str = ''; + while (idx < end) { + var u0 = HEAPU8[idx++]; + if (!(u0 & 0x80)) { + str += String.fromCharCode(u0); + continue; + } + var u1 = HEAPU8[idx++] & 63; + if ((u0 & 0xE0) === 0xC0) { + str += String.fromCharCode(((u0 & 31) << 6) | u1); + continue; + } + var u2 = HEAPU8[idx++] & 63; + if ((u0 & 0xF0) === 0xE0) { + u0 = ((u0 & 15) << 12) | (u1 << 6) | u2; + } + else { + u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (HEAPU8[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; + } + return emnapiString.utf8Decoder.decode(((typeof SharedArrayBuffer === "function" && HEAPU8.buffer instanceof SharedArrayBuffer) || (Object.prototype.toString.call(HEAPU8.buffer) === "[object SharedArrayBuffer]")) ? HEAPU8.slice(ptr, end) : HEAPU8.subarray(ptr, end)); + }, + stringToUTF8(str, outPtr, maxBytesToWrite) { + const HEAPU8 = new Uint8Array(wasmMemory.buffer); + let outIdx = outPtr; + outIdx >>>= 0; + if (!(maxBytesToWrite > 0)) { + return 0; + } + var startIdx = outIdx; + var endIdx = outIdx + maxBytesToWrite - 1; + for (var i = 0; i < str.length; ++i) { + var u = str.charCodeAt(i); + if (u >= 0xD800 && u <= 0xDFFF) { + var u1 = str.charCodeAt(++i); + u = 0x10000 + ((u & 0x3FF) << 10) | (u1 & 0x3FF); + } + if (u <= 0x7F) { + if (outIdx >= endIdx) + break; + HEAPU8[outIdx++] = u; + } + else if (u <= 0x7FF) { + if (outIdx + 1 >= endIdx) + break; + HEAPU8[outIdx++] = 0xC0 | (u >> 6); + HEAPU8[outIdx++] = 0x80 | (u & 63); + } + else if (u <= 0xFFFF) { + if (outIdx + 2 >= endIdx) + break; + HEAPU8[outIdx++] = 0xE0 | (u >> 12); + HEAPU8[outIdx++] = 0x80 | ((u >> 6) & 63); + HEAPU8[outIdx++] = 0x80 | (u & 63); + } + else { + if (outIdx + 3 >= endIdx) + break; + HEAPU8[outIdx++] = 0xF0 | (u >> 18); + HEAPU8[outIdx++] = 0x80 | ((u >> 12) & 63); + HEAPU8[outIdx++] = 0x80 | ((u >> 6) & 63); + HEAPU8[outIdx++] = 0x80 | (u & 63); + } + } + HEAPU8[outIdx] = 0; + return outIdx - startIdx; + }, + UTF16ToString(ptr, length) { + if (!ptr || !length) + return ''; + ptr >>>= 0; + let end = ptr; + if (length === -1 || length === 4294967295) { + let idx = end >>> 1; + const HEAPU16 = new Uint16Array(wasmMemory.buffer); + while (HEAPU16[idx]) + ++idx; + end = (idx << 1) >>> 0; + } + else { + end = ptr + (length >>> 0) * 2; + } + length = end - ptr; + if (length <= 32) { + return String.fromCharCode.apply(null, new Uint16Array(wasmMemory.buffer, ptr, length / 2)); + } + const HEAPU8 = new Uint8Array(wasmMemory.buffer); + return emnapiString.utf16Decoder.decode(((typeof SharedArrayBuffer === "function" && HEAPU8.buffer instanceof SharedArrayBuffer) || (Object.prototype.toString.call(HEAPU8.buffer) === "[object SharedArrayBuffer]")) ? HEAPU8.slice(ptr, end) : HEAPU8.subarray(ptr, end)); + }, + stringToUTF16(str, outPtr, maxBytesToWrite) { + if (maxBytesToWrite === undefined) { + maxBytesToWrite = 0x7FFFFFFF; + } + if (maxBytesToWrite < 2) + return 0; + maxBytesToWrite -= 2; + var startPtr = outPtr; + var numCharsToWrite = (maxBytesToWrite < str.length * 2) ? (maxBytesToWrite / 2) : str.length; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + for (var i = 0; i < numCharsToWrite; ++i) { + var codeUnit = str.charCodeAt(i); + GET_HEAP_DATA_VIEW().setInt16(outPtr, codeUnit, true); + outPtr += 2; + } + GET_HEAP_DATA_VIEW().setInt16(outPtr, 0, true); + return outPtr - startPtr; + }, + newString(env, str, length, result, stringMaker) { + length >>>= 0; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + const autoLength = length === -1 || length === 4294967295; + const sizelength = length >>> 0; + if (length !== 0) { + if (!str) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!(autoLength || (sizelength <= 2147483647))) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + str >>>= 0; + const strValue = stringMaker(str, autoLength, sizelength); + result >>>= 0; + const value = emnapiCtx.napiValueFromJsValue(strValue); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return envObject.clearLastError(); + }, + newExternalString(env, str, length, finalize_callback, finalize_hint, result, copied, createApi, stringMaker) { + length >>>= 0; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + const autoLength = length === -1 || length === 4294967295; + const sizelength = length >>> 0; + if (length !== 0) { + if (!str) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!(autoLength || (sizelength <= 2147483647))) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const status = createApi(env, str, length, result); + if (status === 0 /* napi_status.napi_ok */) { + if (copied) { + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(copied, 1, true); + } + if (finalize_callback) { + envObject.callFinalizer(finalize_callback, str, finalize_hint); + } + } + return status; + }, + encode(str, autoLength, sizeLength, convert) { + let latin1String = ''; + let len = 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + if (autoLength) { + while (true) { + const ch = GET_HEAP_DATA_VIEW().getUint8(str, true); + if (!ch) + break; + latin1String += convert(ch); + str++; + } + } + else { + while (len < sizeLength) { + const ch = GET_HEAP_DATA_VIEW().getUint8(str, true); + if (!ch) + break; + latin1String += convert(ch); + len++; + str++; + } + } + return latin1String; + } + }; + + //#endregion src/string.ts + + //#region src/value/convert2c.ts + /** + * @__sig ippp + */ + function napi_get_array_length(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + if (!Array.isArray(jsValue)) { + return envObject.setLastError(8 /* napi_status.napi_array_expected */); + } + result >>>= 0; + const v = jsValue.length >>> 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, v, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ipppp + */ + function napi_get_arraybuffer_info(env, arraybuffer, data, byte_length) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!arraybuffer) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(arraybuffer); + if (!(jsValue instanceof ArrayBuffer) && !emnapiExternalMemory.isSharedArrayBuffer(jsValue)) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + // metadata is read through cached intrinsic getters (internal slots, like + // native Node-API): no user JS can run inside this call. Only emnapi's own + // getArrayBufferPointer() can still grow the memory (malloc for the copy of + // an external buffer), which detaches the previous non-shared buffer, so + // each value is resolved into a local BEFORE its makeSetValue write (the + // store target is evaluated before the RHS). + if (data) { + data >>>= 0; + const p = emnapiExternalMemory.getArrayBufferPointer(jsValue, true).address; + GET_HEAP_DATA_VIEW().setUint32(data, p, true); + } + if (byte_length) { + byte_length >>>= 0; + const len = emnapiExternalMemory.bufferByteLength(jsValue); + GET_HEAP_DATA_VIEW().setUint32(byte_length, len, true); + } + return envObject.clearLastError(); + } + /** + * @__sig ippp + */ + function node_api_set_prototype(env, object, value) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const obj = emnapiCtx.jsValueFromNapiValue(object); + if (obj == null) { + throw new TypeError('Cannot convert undefined or null to object'); + } + const type = typeof obj; + let v; + try { + v = (type === 'object' && obj !== null) || type === 'function' ? obj : Object(obj); + } + catch (_) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + const val = emnapiCtx.jsValueFromNapiValue(value); + Object.setPrototypeOf(v, val); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ippp + */ + function napi_get_prototype(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + if (jsValue == null) { + throw new TypeError('Cannot convert undefined or null to object'); + } + const type = typeof jsValue; + let v; + try { + v = (type === 'object' && jsValue !== null) || type === 'function' ? jsValue : Object(jsValue); + } + catch (_) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + result >>>= 0; + const p = emnapiCtx.napiValueFromJsValue(Object.getPrototypeOf(v)); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, p, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ippppppp + */ + function napi_get_typedarray_info(env, typedarray, type, length, data, arraybuffer, byte_offset) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!typedarray) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(typedarray); + if (!(emnapiExternalMemory.intrinsics.isView(jsValue))) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + let v = jsValue; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + // all view metadata (kind, buffer, byteOffset, length) is read through + // cached intrinsic prototype getters: like native Node-API they read the + // internal slots, never consult user accessors (no user JS can run inside + // this call) and work for instances from any realm. Only emnapi's own + // getViewPointer() can still grow the memory (malloc for the copy of an + // external buffer), which detaches the previous non-shared buffer, so each + // value is resolved into a local BEFORE its makeSetValue write (the store + // target is evaluated before the RHS). + if (type) { + type >>>= 0; + let t; + switch (emnapiExternalMemory.intrinsics.typedArray.tag.call(v)) { + case 'Int8Array': + t = 0 /* napi_typedarray_type.napi_int8_array */; + break; + case 'Uint8Array': + t = 1 /* napi_typedarray_type.napi_uint8_array */; + break; + case 'Uint8ClampedArray': + t = 2 /* napi_typedarray_type.napi_uint8_clamped_array */; + break; + case 'Int16Array': + t = 3 /* napi_typedarray_type.napi_int16_array */; + break; + case 'Uint16Array': + t = 4 /* napi_typedarray_type.napi_uint16_array */; + break; + case 'Int32Array': + t = 5 /* napi_typedarray_type.napi_int32_array */; + break; + case 'Uint32Array': + t = 6 /* napi_typedarray_type.napi_uint32_array */; + break; + case 'Float16Array': + t = 11 /* napi_typedarray_type.napi_float16_array */; + break; + case 'Float32Array': + t = 7 /* napi_typedarray_type.napi_float32_array */; + break; + case 'Float64Array': + t = 8 /* napi_typedarray_type.napi_float64_array */; + break; + case 'BigInt64Array': + t = 9 /* napi_typedarray_type.napi_bigint64_array */; + break; + case 'BigUint64Array': + t = 10 /* napi_typedarray_type.napi_biguint64_array */; + break; + default: + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + GET_HEAP_DATA_VIEW().setInt32(type, t, true); + } + v = emnapiExternalMemory.getOrUpdateMemoryView(v); + if (length) { + length >>>= 0; + const len = emnapiExternalMemory.viewLength(v); + GET_HEAP_DATA_VIEW().setUint32(length, len, true); + } + if (data || arraybuffer) { + if (data) { + data >>>= 0; + const vp = emnapiExternalMemory.getViewPointer(v, true); + v = vp.view; + const p = vp.address; + GET_HEAP_DATA_VIEW().setUint32(data, p, true); + } + if (arraybuffer) { + arraybuffer >>>= 0; + const ab = emnapiCtx.napiValueFromJsValue(emnapiExternalMemory.viewBuffer(v)); + GET_HEAP_DATA_VIEW().setUint32(arraybuffer, ab, true); + } + } + if (byte_offset) { + byte_offset >>>= 0; + const offset = emnapiExternalMemory.viewByteOffset(v); + GET_HEAP_DATA_VIEW().setUint32(byte_offset, offset, true); + } + return envObject.clearLastError(); + } + /** + * @__sig ipppp + */ + function napi_get_buffer_info(env, buffer, data, length) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!buffer) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(buffer); + const Buffer = emnapiCtx.features.Buffer; + const bool = (emnapiExternalMemory.intrinsics.isView(jsValue) || (typeof Buffer === 'function' && Buffer.isBuffer(jsValue))); + if (!bool) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + // any-realm slot-based classification: the intrinsic @@toStringTag getter + // returns undefined exactly for DataViews among ArrayBuffer views + if (emnapiExternalMemory.intrinsics.typedArray.tag.call(jsValue) === undefined) { + return napi_get_dataview_info(env, buffer, length, data, 0, 0); + } + return napi_get_typedarray_info(env, buffer, 0, length, data, 0, 0); + } + /** + * @__sig ipppppp + */ + function napi_get_dataview_info(env, dataview, byte_length, data, arraybuffer, byte_offset) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!dataview) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(dataview); + // any-realm slot-based classification (see napi_get_buffer_info) + if (!(emnapiExternalMemory.intrinsics.isView(jsValue)) || emnapiExternalMemory.intrinsics.typedArray.tag.call(jsValue) !== undefined) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + let v = emnapiExternalMemory.getOrUpdateMemoryView(jsValue); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + // all view metadata is read through cached intrinsic prototype getters: + // like native Node-API they read the internal slots, never consult user + // accessors (no user JS can run inside this call) and work for instances + // from any realm. Only emnapi's own getViewPointer() can still grow the + // memory (malloc for the copy of an external buffer), which detaches the + // previous non-shared buffer, so each value is resolved into a local + // BEFORE its makeSetValue write (the store target is evaluated before + // the RHS). + if (byte_length) { + byte_length >>>= 0; + const len = emnapiExternalMemory.viewLength(v); + GET_HEAP_DATA_VIEW().setUint32(byte_length, len, true); + } + if (data || arraybuffer) { + if (data) { + data >>>= 0; + const vp = emnapiExternalMemory.getViewPointer(v, true); + v = vp.view; + const p = vp.address; + GET_HEAP_DATA_VIEW().setUint32(data, p, true); + } + if (arraybuffer) { + arraybuffer >>>= 0; + const ab = emnapiCtx.napiValueFromJsValue(emnapiExternalMemory.viewBuffer(v)); + GET_HEAP_DATA_VIEW().setUint32(arraybuffer, ab, true); + } + } + if (byte_offset) { + byte_offset >>>= 0; + const offset = emnapiExternalMemory.viewByteOffset(v); + GET_HEAP_DATA_VIEW().setUint32(byte_offset, offset, true); + } + return envObject.clearLastError(); + } + /** + * @__sig ippp + */ + function napi_get_date_value(env, value, result) { + let v; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + if (!(jsValue instanceof Date)) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + result >>>= 0; + v = jsValue.valueOf(); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setFloat64(result, v, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ippp + */ + function napi_get_value_bool(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + if (typeof jsValue !== 'boolean') { + return envObject.setLastError(7 /* napi_status.napi_boolean_expected */); + } + result >>>= 0; + const r = jsValue ? 1 : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(result, r, true); + return envObject.clearLastError(); + } + /** + * @__sig ippp + */ + function napi_get_value_double(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + if (typeof jsValue !== 'number') { + return envObject.setLastError(6 /* napi_status.napi_number_expected */); + } + result >>>= 0; + const r = jsValue; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setFloat64(result, r, true); + return envObject.clearLastError(); + } + /** + * @__sig ipppp + */ + function napi_get_value_bigint_int64(env, value, result, lossless) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!emnapiCtx.features.BigInt) { + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!lossless) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + let numberValue = emnapiCtx.jsValueFromNapiValue(value); + if (typeof numberValue !== 'bigint') { + return envObject.setLastError(6 /* napi_status.napi_number_expected */); + } + lossless >>>= 0; + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + if ((numberValue >= (BigInt(-1) * (BigInt(1) << BigInt(63)))) && (numberValue < (BigInt(1) << BigInt(63)))) { + GET_HEAP_DATA_VIEW().setInt8(lossless, 1, true); + } + else { + GET_HEAP_DATA_VIEW().setInt8(lossless, 0, true); + numberValue = numberValue & ((BigInt(1) << BigInt(64)) - BigInt(1)); + if (numberValue >= (BigInt(1) << BigInt(63))) { + numberValue = numberValue - (BigInt(1) << BigInt(64)); + } + } + const low = Number(numberValue & BigInt(0xffffffff)); + const high = Number(numberValue >> BigInt(32)); + GET_HEAP_DATA_VIEW().setInt32(result, low, true); + GET_HEAP_DATA_VIEW().setInt32(result + 4, high, true); + return envObject.clearLastError(); + } + /** + * @__sig ipppp + */ + function napi_get_value_bigint_uint64(env, value, result, lossless) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!emnapiCtx.features.BigInt) { + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!lossless) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + let numberValue = emnapiCtx.jsValueFromNapiValue(value); + if (typeof numberValue !== 'bigint') { + return envObject.setLastError(6 /* napi_status.napi_number_expected */); + } + lossless >>>= 0; + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + if ((numberValue >= BigInt(0)) && (numberValue < (BigInt(1) << BigInt(64)))) { + GET_HEAP_DATA_VIEW().setInt8(lossless, 1, true); + } + else { + GET_HEAP_DATA_VIEW().setInt8(lossless, 0, true); + numberValue = numberValue & ((BigInt(1) << BigInt(64)) - BigInt(1)); + } + const low = Number(numberValue & BigInt(0xffffffff)); + const high = Number(numberValue >> BigInt(32)); + GET_HEAP_DATA_VIEW().setUint32(result, low, true); + GET_HEAP_DATA_VIEW().setUint32(result + 4, high, true); + return envObject.clearLastError(); + } + /** + * @__sig ippppp + */ + function napi_get_value_bigint_words(env, value, sign_bit, word_count, words) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!emnapiCtx.features.BigInt) { + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!word_count) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + if (typeof jsValue !== 'bigint') { + return envObject.setLastError(17 /* napi_status.napi_bigint_expected */); + } + const isMinus = jsValue < BigInt(0); + sign_bit >>>= 0; + words >>>= 0; + word_count >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + let word_count_int = GET_HEAP_DATA_VIEW().getUint32(word_count, true); + word_count_int >>>= 0; + let wordCount = 0; + let bigintValue = isMinus ? (jsValue * BigInt(-1)) : jsValue; + while (bigintValue !== BigInt(0)) { + wordCount++; + bigintValue = bigintValue >> BigInt(64); + } + bigintValue = isMinus ? (jsValue * BigInt(-1)) : jsValue; + if (!sign_bit && !words) { + word_count_int = wordCount; + GET_HEAP_DATA_VIEW().setUint32(word_count, word_count_int, true); + } + else { + if (!sign_bit) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!words) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const wordsArr = []; + while (bigintValue !== BigInt(0)) { + const uint64 = bigintValue & ((BigInt(1) << BigInt(64)) - BigInt(1)); + wordsArr.push(uint64); + bigintValue = bigintValue >> BigInt(64); + } + const len = Math.min(word_count_int, wordsArr.length); + for (let i = 0; i < len; i++) { + const low = Number(wordsArr[i] & BigInt(0xffffffff)); + const high = Number(wordsArr[i] >> BigInt(32)); + GET_HEAP_DATA_VIEW().setUint32(words + i * 8, low, true); + GET_HEAP_DATA_VIEW().setUint32(words + (i * 8 + 4), high, true); + } + GET_HEAP_DATA_VIEW().setInt32(sign_bit, isMinus ? 1 : 0, true); + GET_HEAP_DATA_VIEW().setUint32(word_count, len, true); + } + return envObject.clearLastError(); + } + /** + * @__sig ippp + */ + function napi_get_value_external(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + if (!emnapiCtx.isExternal(jsValue)) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + result >>>= 0; + const p = emnapiCtx.getExternalValue(jsValue); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, p, true); + return envObject.clearLastError(); + } + /** + * @__sig ippp + */ + function napi_get_value_int32(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + if (typeof jsValue !== 'number') { + return envObject.setLastError(6 /* napi_status.napi_number_expected */); + } + result >>>= 0; + const v = new Int32Array([jsValue])[0]; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt32(result, v, true); + return envObject.clearLastError(); + } + /** + * @__sig ippp + */ + function napi_get_value_int64(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + if (typeof jsValue !== 'number') { + return envObject.setLastError(6 /* napi_status.napi_number_expected */); + } + const numberValue = jsValue; + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + if (numberValue === Number.POSITIVE_INFINITY || numberValue === Number.NEGATIVE_INFINITY || isNaN(numberValue)) { + GET_HEAP_DATA_VIEW().setInt32(result, 0, true); + GET_HEAP_DATA_VIEW().setInt32(result + 4, 0, true); + } + else if (numberValue < /* INT64_RANGE_NEGATIVE */ -9223372036854776e3) { + GET_HEAP_DATA_VIEW().setInt32(result, 0, true); + GET_HEAP_DATA_VIEW().setInt32(result + 4, 2147483648, true); + } + else if (numberValue >= /* INT64_RANGE_POSITIVE */ 9223372036854776000) { + GET_HEAP_DATA_VIEW().setUint32(result, 4294967295, true); + GET_HEAP_DATA_VIEW().setUint32(result + 4, 2147483647, true); + } + else { + $emnapiSetValueI64(result, Math.trunc(numberValue)); + } + return envObject.clearLastError(); + } + /** + * @__sig ippppp + */ + function napi_get_value_string_latin1(env, value, buf, buf_size, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + result >>>= 0; + buf >>>= 0; + buf_size >>>= 0; + buf_size = buf_size >>> 0; + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + if (typeof jsValue !== 'string') { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + if (!buf) { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + GET_HEAP_DATA_VIEW().setUint32(result, jsValue.length, true); + } + else if (buf_size !== 0) { + let copied = 0; + let v; + for (let i = 0; i < buf_size - 1; ++i) { + v = jsValue.charCodeAt(i) & 0xff; + GET_HEAP_DATA_VIEW().setUint8(buf + i, v, true); + copied++; + } + GET_HEAP_DATA_VIEW().setUint8(buf + copied, 0, true); + if (result) { + GET_HEAP_DATA_VIEW().setUint32(result, copied, true); + } + } + else if (result) { + GET_HEAP_DATA_VIEW().setUint32(result, 0, true); + } + return envObject.clearLastError(); + } + /** + * @__sig ippppp + */ + function napi_get_value_string_utf8(env, value, buf, buf_size, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + result >>>= 0; + buf >>>= 0; + buf_size >>>= 0; + buf_size = buf_size >>> 0; + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + if (typeof jsValue !== 'string') { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + if (!buf) { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const strLength = emnapiString.lengthBytesUTF8(jsValue); + GET_HEAP_DATA_VIEW().setUint32(result, strLength, true); + } + else if (buf_size !== 0) { + const copied = emnapiString.stringToUTF8(jsValue, buf, buf_size); + if (result) { + GET_HEAP_DATA_VIEW().setUint32(result, copied, true); + } + } + else if (result) { + GET_HEAP_DATA_VIEW().setUint32(result, 0, true); + } + return envObject.clearLastError(); + } + /** + * @__sig ippppp + */ + function napi_get_value_string_utf16(env, value, buf, buf_size, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + result >>>= 0; + buf >>>= 0; + buf_size >>>= 0; + buf_size = buf_size >>> 0; + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + if (typeof jsValue !== 'string') { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + if (!buf) { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + GET_HEAP_DATA_VIEW().setUint32(result, jsValue.length, true); + } + else if (buf_size !== 0) { + const copied = emnapiString.stringToUTF16(jsValue, buf, buf_size * 2); + if (result) { + GET_HEAP_DATA_VIEW().setUint32(result, copied / 2, true); + } + } + else if (result) { + GET_HEAP_DATA_VIEW().setUint32(result, 0, true); + } + return envObject.clearLastError(); + } + /** + * @__sig ippp + */ + function napi_get_value_uint32(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + if (typeof jsValue !== 'number') { + return envObject.setLastError(6 /* napi_status.napi_number_expected */); + } + result >>>= 0; + const v = new Uint32Array([jsValue])[0]; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, v, true); + return envObject.clearLastError(); + } + + //#endregion src/value/convert2c.ts + + var convert2cMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + napi_get_array_length: napi_get_array_length, + napi_get_arraybuffer_info: napi_get_arraybuffer_info, + napi_get_buffer_info: napi_get_buffer_info, + napi_get_dataview_info: napi_get_dataview_info, + napi_get_date_value: napi_get_date_value, + napi_get_prototype: napi_get_prototype, + napi_get_typedarray_info: napi_get_typedarray_info, + napi_get_value_bigint_int64: napi_get_value_bigint_int64, + napi_get_value_bigint_uint64: napi_get_value_bigint_uint64, + napi_get_value_bigint_words: napi_get_value_bigint_words, + napi_get_value_bool: napi_get_value_bool, + napi_get_value_double: napi_get_value_double, + napi_get_value_external: napi_get_value_external, + napi_get_value_int32: napi_get_value_int32, + napi_get_value_int64: napi_get_value_int64, + napi_get_value_string_latin1: napi_get_value_string_latin1, + napi_get_value_string_utf16: napi_get_value_string_utf16, + napi_get_value_string_utf8: napi_get_value_string_utf8, + napi_get_value_uint32: napi_get_value_uint32, + node_api_set_prototype: node_api_set_prototype + }); + + //#region src/value/convert2napi.ts + /** + * @__sig ipip + */ + function napi_create_int32(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + result >>>= 0; + const v = emnapiCtx.napiValueFromJsValue(value); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, v, true); + return envObject.clearLastError(); + } + /** + * @__sig ipip + */ + function napi_create_uint32(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + result >>>= 0; + const v = emnapiCtx.napiValueFromJsValue(value >>> 0); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, v, true); + return envObject.clearLastError(); + } + /** + * @__sig ipjp + */ + function napi_create_int64(env, low, high, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + let value; + if (!high) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + value = Number(low); + const v1 = emnapiCtx.napiValueFromJsValue(value); + high >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(high, v1, true); + return envObject.clearLastError(); + } + /** + * @__sig ipdp + */ + function napi_create_double(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + result >>>= 0; + const v = emnapiCtx.napiValueFromJsValue(value); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, v, true); + return envObject.clearLastError(); + } + /** + * @__sig ipppp + */ + function napi_create_string_latin1(env, str, length, result) { + return emnapiString.newString(env, str, length, result, (str, autoLength, sizeLength) => { + return emnapiString.encode(str, autoLength, sizeLength, (c) => String.fromCharCode(c)); + }); + } + /** + * @__sig ipppp + */ + function napi_create_string_utf16(env, str, length, result) { + return emnapiString.newString(env, str, length, result, (str) => { + return emnapiString.UTF16ToString(str, length); + }); + } + /** + * @__sig ipppp + */ + function napi_create_string_utf8(env, str, length, result) { + return emnapiString.newString(env, str, length, result, (str) => { + return emnapiString.UTF8ToString(str, length); + }); + } + /** + * @__sig ippppppp + */ + function node_api_create_external_string_latin1(env, str, length, finalize_callback, finalize_hint, result, copied) { + return emnapiString.newExternalString(env, str, length, finalize_callback, finalize_hint, result, copied, napi_create_string_latin1, undefined); + } + /** + * @__sig ippppppp + */ + function node_api_create_external_string_utf16(env, str, length, finalize_callback, finalize_hint, result, copied) { + return emnapiString.newExternalString(env, str, length, finalize_callback, finalize_hint, result, copied, napi_create_string_utf16, undefined); + } + /** + * @__sig ipppp + */ + function node_api_create_property_key_latin1(env, str, length, result) { + return napi_create_string_latin1(env, str, length, result); + } + /** + * @__sig ipppp + */ + function node_api_create_property_key_utf8(env, str, length, result) { + return napi_create_string_utf8(env, str, length, result); + } + /** + * @__sig ipppp + */ + function node_api_create_property_key_utf16(env, str, length, result) { + return napi_create_string_utf16(env, str, length, result); + } + /** + * @__sig ipjp + */ + function napi_create_bigint_int64(env, low, high, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!emnapiCtx.features.BigInt) { + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + let value; + if (!high) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + value = low; + const v1 = emnapiCtx.napiValueFromJsValue(value); + high >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(high, v1, true); + return envObject.clearLastError(); + } + /** + * @__sig ipjp + */ + function napi_create_bigint_uint64(env, low, high, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!emnapiCtx.features.BigInt) { + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + let value; + if (!high) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + value = low & ((BigInt(1) << BigInt(64)) - BigInt(1)); + const v1 = emnapiCtx.napiValueFromJsValue(value); + high >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(high, v1, true); + return envObject.clearLastError(); + } + /** + * @__sig ipippp + */ + function napi_create_bigint_words(env, sign_bit, word_count, words, result) { + let v, i; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!emnapiCtx.features.BigInt) { + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + words >>>= 0; + word_count >>>= 0; + word_count = word_count >>> 0; + if (word_count > 2147483647) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + if (word_count > (1024 * 1024 / (4 * 8) / 2)) { + throw new RangeError('Maximum BigInt size exceeded'); + } + let value = BigInt(0); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + for (i = 0; i < word_count; i++) { + const low = GET_HEAP_DATA_VIEW().getUint32(words + i * 8, true); + const high = GET_HEAP_DATA_VIEW().getUint32(words + (i * 8 + 4), true); + const wordi = BigInt(low) | (BigInt(high) << BigInt(32)); + value += wordi << BigInt(64 * i); + } + value *= ((BigInt(sign_bit) % BigInt(2) === BigInt(0)) ? BigInt(1) : BigInt(-1)); + result >>>= 0; + v = emnapiCtx.napiValueFromJsValue(value); + GET_HEAP_DATA_VIEW().setUint32(result, v, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + + //#endregion src/value/convert2napi.ts + + var convert2napiMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + napi_create_bigint_int64: napi_create_bigint_int64, + napi_create_bigint_uint64: napi_create_bigint_uint64, + napi_create_bigint_words: napi_create_bigint_words, + napi_create_double: napi_create_double, + napi_create_int32: napi_create_int32, + napi_create_int64: napi_create_int64, + napi_create_string_latin1: napi_create_string_latin1, + napi_create_string_utf16: napi_create_string_utf16, + napi_create_string_utf8: napi_create_string_utf8, + napi_create_uint32: napi_create_uint32, + node_api_create_external_string_latin1: node_api_create_external_string_latin1, + node_api_create_external_string_utf16: node_api_create_external_string_utf16, + node_api_create_property_key_latin1: node_api_create_property_key_latin1, + node_api_create_property_key_utf16: node_api_create_property_key_utf16, + node_api_create_property_key_utf8: node_api_create_property_key_utf8 + }); + + //#region src/internal.ts + function emnapiCreateFunction(envObject, utf8name, length, cb, data) { + utf8name >>>= 0; + const functionName = (!utf8name || !length) ? '' : (emnapiString.UTF8ToString(utf8name, length)); + let dynamicExecution; + dynamicExecution = true; + if (!functionName) { + return { + status: 0 /* napi_status.napi_ok */, + f: emnapiCtx.createFunction(envObject, (wasmTable.get(cb)), data, functionName, dynamicExecution) + }; + } + if (!(/^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(functionName))) { + return { status: 1 /* napi_status.napi_invalid_arg */, f: undefined }; + } + return { + status: 0 /* napi_status.napi_ok */, + f: emnapiCtx.createFunction(envObject, (wasmTable.get(cb)), data, functionName, dynamicExecution) + }; + } + function emnapiDefineProperty(envObject, obj, propertyName, method, getter, setter, value, attributes, data) { + if (getter || setter) { + let localGetter; + let localSetter; + if (getter) { + localGetter = emnapiCreateFunction(envObject, 0, 0, getter, data).f; + } + if (setter) { + localSetter = emnapiCreateFunction(envObject, 0, 0, setter, data).f; + } + const desc = { + configurable: (attributes & 4 /* napi_property_attributes.napi_configurable */) !== 0, + enumerable: (attributes & 2 /* napi_property_attributes.napi_enumerable */) !== 0, + get: localGetter, + set: localSetter + }; + Object.defineProperty(obj, propertyName, desc); + } + else if (method) { + const localMethod = emnapiCreateFunction(envObject, 0, 0, method, data).f; + const desc = { + configurable: (attributes & 4 /* napi_property_attributes.napi_configurable */) !== 0, + enumerable: (attributes & 2 /* napi_property_attributes.napi_enumerable */) !== 0, + writable: (attributes & 1 /* napi_property_attributes.napi_writable */) !== 0, + value: localMethod + }; + Object.defineProperty(obj, propertyName, desc); + } + else { + const desc = { + configurable: (attributes & 4 /* napi_property_attributes.napi_configurable */) !== 0, + enumerable: (attributes & 2 /* napi_property_attributes.napi_enumerable */) !== 0, + writable: (attributes & 1 /* napi_property_attributes.napi_writable */) !== 0, + value: emnapiCtx.jsValueFromNapiValue(value) + }; + Object.defineProperty(obj, propertyName, desc); + } + } + function emnapiGetHandle(js_object) { + let jsValue = emnapiCtx.jsValueFromNapiValue(js_object); + const type = typeof jsValue; + if (!((type === 'object' && jsValue !== null) || type === 'function')) { + return { status: 1 /* napi_status.napi_invalid_arg */ }; + } + if (typeof emnapiExternalMemory !== 'undefined' && ArrayBuffer.isView(jsValue)) { + if (emnapiExternalMemory.wasmMemoryViewTable.has(jsValue)) { + jsValue = emnapiExternalMemory.wasmMemoryViewTable.get(jsValue); + } + } + return { status: 0 /* napi_status.napi_ok */, value: jsValue }; + } + function emnapiWrap(env, js_object, native_object, finalize_cb, finalize_hint, result) { + let referenceId; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!emnapiCtx.features.finalizer) { + if (finalize_cb) { + throw emnapiCtx.createNotSupportWeakRefError('napi_wrap', 'Parameter "finalize_cb" must be 0(NULL)'); + } + if (result) { + throw emnapiCtx.createNotSupportWeakRefError('napi_wrap', 'Parameter "result" must be 0(NULL)'); + } + } + if (!js_object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const handleResult = emnapiGetHandle(js_object); + if (handleResult.status !== 0 /* napi_status.napi_ok */) { + return envObject.setLastError(handleResult.status); + } + const v = handleResult.value; + if (envObject.getObjectBinding(v).wrapped !== 0) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + const id = emnapiCtx.napiValueFromJsValue(v); + let reference; + if (result) { + if (!finalize_cb) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + reference = emnapiCtx.createReferenceWithFinalizer(envObject, id, 0, 1 /* ReferenceOwnership.kUserland */, finalize_cb, native_object, finalize_hint); + result >>>= 0; + referenceId = reference.id; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, referenceId, true); + } + else { + if (finalize_cb) { + reference = emnapiCtx.createReferenceWithFinalizer(envObject, id, 0, 0 /* ReferenceOwnership.kRuntime */, finalize_cb, native_object, finalize_hint); + } + else { + reference = emnapiCtx.createReferenceWithData(envObject, id, 0, 0 /* ReferenceOwnership.kRuntime */, native_object); + } + } + envObject.getObjectBinding(v).wrapped = reference.id; + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + function emnapiUnwrap(env, js_object, result, action) { + let data; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!js_object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (action === 0 /* UnwrapAction.KeepWrap */) { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + const value = emnapiCtx.jsValueFromNapiValue(js_object); + const type = typeof value; + if (!((type === 'object' && value !== null) || type === 'function')) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + const binding = envObject.getObjectBinding(value); + const referenceId = binding.wrapped; + const ref = emnapiCtx.getRef(referenceId); + if (!ref) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (result) { + result >>>= 0; + data = ref.data(); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, data, true); + } + if (action === 1 /* UnwrapAction.RemoveWrap */) { + binding.wrapped = 0; + if (ref.ownership() === 1 /* ReferenceOwnership.kUserland */) { + // When the wrap is been removed, the finalizer should be reset. + ref.resetFinalizer(); + } + else { + ref.dispose(); + } + } + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + + //#endregion src/internal.ts + + //#region src/wrap.ts + /** + * @__sig ipppppppp + */ + function napi_define_class(env, utf8name, length, constructor, callback_data, property_count, properties, result) { + let propPtr, valueHandleId, attributes; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!constructor) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + length >>>= 0; + properties >>>= 0; + property_count >>>= 0; + property_count = property_count >>> 0; + if (property_count > 0) { + if (!properties) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + if (!((length >= -1 && length <= 2147483647) || length === 4294967295) || (!utf8name)) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + const fresult = emnapiCreateFunction(envObject, utf8name, length, constructor, callback_data); + if (fresult.status !== 0 /* napi_status.napi_ok */) + return envObject.setLastError(fresult.status); + const F = fresult.f; + let propertyName; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + for (let i = 0; i < property_count; i++) { + propPtr = properties + (i * (4 * 8)); + const utf8Name = GET_HEAP_DATA_VIEW().getUint32(propPtr, true); + const name = GET_HEAP_DATA_VIEW().getUint32(propPtr + 4, true); + const method = GET_HEAP_DATA_VIEW().getUint32(propPtr + 8, true); + const getter = GET_HEAP_DATA_VIEW().getUint32(propPtr + 12, true); + const setter = GET_HEAP_DATA_VIEW().getUint32(propPtr + 16, true); + const value = GET_HEAP_DATA_VIEW().getUint32(propPtr + 20, true); + attributes = GET_HEAP_DATA_VIEW().getInt32(propPtr + 24, true); + attributes >>>= 0; + const data = GET_HEAP_DATA_VIEW().getUint32(propPtr + 28, true); + if (utf8Name) { + propertyName = emnapiString.UTF8ToString(utf8Name, -1); + } + else { + if (!name) { + return envObject.setLastError(4 /* napi_status.napi_name_expected */); + } + propertyName = emnapiCtx.jsValueFromNapiValue(name); + if (typeof propertyName !== 'string' && typeof propertyName !== 'symbol') { + return envObject.setLastError(4 /* napi_status.napi_name_expected */); + } + } + if ((attributes & 1024 /* napi_property_attributes.napi_static */) !== 0) { + emnapiDefineProperty(envObject, F, propertyName, method, getter, setter, value, attributes, data); + continue; + } + emnapiDefineProperty(envObject, F.prototype, propertyName, method, getter, setter, value, attributes, data); + } + valueHandleId = emnapiCtx.napiValueFromJsValue(F); + result >>>= 0; + GET_HEAP_DATA_VIEW().setUint32(result, valueHandleId, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ipppppp + */ + function napi_wrap(env, js_object, native_object, finalize_cb, finalize_hint, result) { + return emnapiWrap(env, js_object, native_object, finalize_cb, finalize_hint, result); + } + /** + * @__sig ippp + */ + function napi_unwrap(env, js_object, result) { + return emnapiUnwrap(env, js_object, result, 0 /* UnwrapAction.KeepWrap */); + } + /** + * @__sig ippp + */ + function napi_remove_wrap(env, js_object, result) { + return emnapiUnwrap(env, js_object, result, 1 /* UnwrapAction.RemoveWrap */); + } + /** + * @__sig ippp + */ + function napi_type_tag_object(env, object, type_tag) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!object) { + return envObject.setLastError(!envObject.lastException.isEmpty() ? 10 /* napi_status.napi_pending_exception */ : 1 /* napi_status.napi_invalid_arg */); + } + const value = emnapiCtx.jsValueFromNapiValue(object); + const type = typeof value; + if (!((type === 'object' && value !== null) || type === 'function')) { + return envObject.setLastError(!envObject.lastException.isEmpty() ? 10 /* napi_status.napi_pending_exception */ : 2 /* napi_status.napi_object_expected */); + } + type_tag >>>= 0; + if (!type_tag) { + return envObject.setLastError(!envObject.lastException.isEmpty() ? 10 /* napi_status.napi_pending_exception */ : 1 /* napi_status.napi_invalid_arg */); + } + const binding = envObject.getObjectBinding(value); + if (binding.tag !== null) { + return envObject.setLastError(!envObject.lastException.isEmpty() ? 10 /* napi_status.napi_pending_exception */ : 1 /* napi_status.napi_invalid_arg */); + } + const tag = new Uint8Array(16); + tag.set(new Uint8Array(wasmMemory.buffer, type_tag, 16)); + binding.tag = new Uint32Array(tag.buffer); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ipppp + */ + function napi_check_object_type_tag(env, object, type_tag, result) { + // eslint-disable-next-line one-var + let ret = true; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!object) { + return envObject.setLastError(!envObject.lastException.isEmpty() ? 10 /* napi_status.napi_pending_exception */ : 1 /* napi_status.napi_invalid_arg */); + } + const value = emnapiCtx.jsValueFromNapiValue(object); + const type = typeof value; + if (!((type === 'object' && value !== null) || type === 'function')) { + return envObject.setLastError(!envObject.lastException.isEmpty() ? 10 /* napi_status.napi_pending_exception */ : 2 /* napi_status.napi_object_expected */); + } + if (!type_tag) { + return envObject.setLastError(!envObject.lastException.isEmpty() ? 10 /* napi_status.napi_pending_exception */ : 1 /* napi_status.napi_invalid_arg */); + } + if (!result) { + return envObject.setLastError(!envObject.lastException.isEmpty() ? 10 /* napi_status.napi_pending_exception */ : 1 /* napi_status.napi_invalid_arg */); + } + const binding = envObject.getObjectBinding(value); + if (binding.tag !== null) { + type_tag >>>= 0; + const tag = binding.tag; + const typeTag = new Uint32Array(wasmMemory.buffer, type_tag, 4); + ret = (tag[0] === typeTag[0] && + tag[1] === typeTag[1] && + tag[2] === typeTag[2] && + tag[3] === typeTag[3]); + } + else { + ret = false; + } + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(result, ret ? 1 : 0, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ipppppp + */ + function napi_add_finalizer(env, js_object, finalize_data, finalize_cb, finalize_hint, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!emnapiCtx.features.finalizer) { + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + if (!js_object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!finalize_cb) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const handleResult = emnapiGetHandle(js_object); + if (handleResult.status !== 0 /* napi_status.napi_ok */) { + return envObject.setLastError(handleResult.status); + } + const id = emnapiCtx.napiValueFromJsValue(handleResult.value); + const ownership = !result ? 0 /* ReferenceOwnership.kRuntime */ : 1 /* ReferenceOwnership.kUserland */; + finalize_data >>>= 0; + finalize_cb >>>= 0; + finalize_hint >>>= 0; + const reference = emnapiCtx.createReferenceWithFinalizer(envObject, id, 0, ownership, finalize_cb, finalize_data, finalize_hint); + if (result) { + result >>>= 0; + const referenceId = reference.id; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, referenceId, true); + } + return envObject.clearLastError(); + } + /** + * @__sig ipppp + */ + function node_api_post_finalizer(env, finalize_cb, finalize_data, finalize_hint) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + const envObject = emnapiEnv; + envObject.enqueueFinalizer(emnapiCtx.createTrackedFinalizer(envObject, finalize_cb, finalize_data, finalize_hint)); + return envObject.clearLastError(); + } + + //#endregion src/wrap.ts + + var wrapMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + napi_add_finalizer: napi_add_finalizer, + napi_check_object_type_tag: napi_check_object_type_tag, + napi_define_class: napi_define_class, + napi_remove_wrap: napi_remove_wrap, + napi_type_tag_object: napi_type_tag_object, + napi_unwrap: napi_unwrap, + napi_wrap: napi_wrap, + node_api_post_finalizer: node_api_post_finalizer + }); + + //#region src/emnapi.ts + /** + * @__sig vpippi + */ + function emnapi_debug(file, lineno, str, ptr, type) { + str >>>= 0; + file >>>= 0; + const string = str ? emnapiString.UTF8ToString(str, -1) : ''; + const message = `[emnapi_debug] ${emnapiString.UTF8ToString(file, -1)}:${lineno} ${string} ${ptr}`; + const logArgs = [message]; + if (ptr) { + logArgs.push(type === 1 ? emnapiCtx.isolate.getRef(ptr) : emnapiCtx.jsValueFromNapiValue(ptr)); + } + console.log(...logArgs); + // eslint-disable-next-line no-debugger + debugger; + } + /** + * @__sig ipippppp + */ + function emnapi_create_memory_view(env, typedarray_type, external_data, byte_length, finalize_cb, finalize_hint, result) { + let value; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + byte_length >>>= 0; + external_data >>>= 0; + result >>>= 0; + byte_length = byte_length >>> 0; + if (!external_data) { + byte_length = 0; + } + if (byte_length > 2147483647) { + throw new RangeError('Cannot create a memory view larger than 2147483647 bytes'); + } + if ((external_data + byte_length) > wasmMemory.buffer.byteLength) { + throw new RangeError('Memory out of range'); + } + if (!emnapiCtx.features.finalizer && finalize_cb) { + throw emnapiCtx.createNotSupportWeakRefError('emnapi_create_memory_view', 'Parameter "finalize_cb" must be 0(NULL)'); + } + let viewDescriptor; + switch (typedarray_type) { + case 0 /* emnapi_memory_view_type.emnapi_int8_array */: + viewDescriptor = { Ctor: Int8Array, address: external_data, length: byte_length, ownership: 1 /* ReferenceOwnership.kUserland */, runtimeAllocated: 0 }; + break; + case 1 /* emnapi_memory_view_type.emnapi_uint8_array */: + viewDescriptor = { Ctor: Uint8Array, address: external_data, length: byte_length, ownership: 1 /* ReferenceOwnership.kUserland */, runtimeAllocated: 0 }; + break; + case 2 /* emnapi_memory_view_type.emnapi_uint8_clamped_array */: + viewDescriptor = { Ctor: Uint8ClampedArray, address: external_data, length: byte_length, ownership: 1 /* ReferenceOwnership.kUserland */, runtimeAllocated: 0 }; + break; + case 3 /* emnapi_memory_view_type.emnapi_int16_array */: + viewDescriptor = { Ctor: Int16Array, address: external_data, length: byte_length >> 1, ownership: 1 /* ReferenceOwnership.kUserland */, runtimeAllocated: 0 }; + break; + case 4 /* emnapi_memory_view_type.emnapi_uint16_array */: + viewDescriptor = { Ctor: Uint16Array, address: external_data, length: byte_length >> 1, ownership: 1 /* ReferenceOwnership.kUserland */, runtimeAllocated: 0 }; + break; + case 5 /* emnapi_memory_view_type.emnapi_int32_array */: + viewDescriptor = { Ctor: Int32Array, address: external_data, length: byte_length >> 2, ownership: 1 /* ReferenceOwnership.kUserland */, runtimeAllocated: 0 }; + break; + case 6 /* emnapi_memory_view_type.emnapi_uint32_array */: + viewDescriptor = { Ctor: Uint32Array, address: external_data, length: byte_length >> 2, ownership: 1 /* ReferenceOwnership.kUserland */, runtimeAllocated: 0 }; + break; + case 7 /* emnapi_memory_view_type.emnapi_float32_array */: + viewDescriptor = { Ctor: Float32Array, address: external_data, length: byte_length >> 2, ownership: 1 /* ReferenceOwnership.kUserland */, runtimeAllocated: 0 }; + break; + case 8 /* emnapi_memory_view_type.emnapi_float64_array */: + viewDescriptor = { Ctor: Float64Array, address: external_data, length: byte_length >> 3, ownership: 1 /* ReferenceOwnership.kUserland */, runtimeAllocated: 0 }; + break; + case 9 /* emnapi_memory_view_type.emnapi_bigint64_array */: + viewDescriptor = { Ctor: BigInt64Array, address: external_data, length: byte_length >> 3, ownership: 1 /* ReferenceOwnership.kUserland */, runtimeAllocated: 0 }; + break; + case 10 /* emnapi_memory_view_type.emnapi_biguint64_array */: + viewDescriptor = { Ctor: BigUint64Array, address: external_data, length: byte_length >> 3, ownership: 1 /* ReferenceOwnership.kUserland */, runtimeAllocated: 0 }; + break; + case -1 /* emnapi_memory_view_type.emnapi_data_view */: + viewDescriptor = { Ctor: DataView, address: external_data, length: byte_length, ownership: 1 /* ReferenceOwnership.kUserland */, runtimeAllocated: 0 }; + break; + case 11 /* emnapi_memory_view_type.emnapi_float16_array */: + if (typeof Float16Array !== 'function') { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + viewDescriptor = { Ctor: Float16Array, address: external_data, length: byte_length >> 1, ownership: 1 /* ReferenceOwnership.kUserland */, runtimeAllocated: 0 }; + break; + case -2 /* emnapi_memory_view_type.emnapi_buffer */: { + if (!emnapiCtx.features.Buffer) { + throw emnapiCtx.createNotSupportBufferError('emnapi_create_memory_view', ''); + } + viewDescriptor = { Ctor: emnapiCtx.features.Buffer, address: external_data, length: byte_length, ownership: 1 /* ReferenceOwnership.kUserland */, runtimeAllocated: 0 }; + break; + } + default: return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + const Ctor = viewDescriptor.Ctor; + const typedArray = typedarray_type === -2 /* emnapi_memory_view_type.emnapi_buffer */ + // capture Buffer.from at creation so a later refreshed view uses it + ? emnapiExternalMemory.getBufferFrom()(wasmMemory.buffer, viewDescriptor.address, viewDescriptor.length) + : new Ctor(wasmMemory.buffer, viewDescriptor.address, viewDescriptor.length); + value = emnapiCtx.napiValueFromJsValue(typedArray); + emnapiExternalMemory.wasmMemoryViewTable.set(typedArray, viewDescriptor); + if (finalize_cb) { + const status = napi_add_finalizer(env, value, external_data, finalize_cb, finalize_hint, /* NULL */ 0); + if (status === 10 /* napi_status.napi_pending_exception */) { + const err = envObject.lastException.deref(); + envObject.clearLastError(); + envObject.lastException.reset(); + throw err; + } + else if (status !== 0 /* napi_status.napi_ok */) { + return envObject.setLastError(status); + } + } + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig i + */ + function emnapi_is_support_weakref() { + return emnapiCtx.features.finalizer ? 1 : 0; + } + /** + * @__sig i + */ + function emnapi_is_support_bigint() { + return emnapiCtx.features.BigInt ? 1 : 0; + } + /** + * @__sig i + */ + function emnapi_is_node_binding_available() { + return emnapiNodeBinding ? 1 : 0; + } + /** + * Synchronize data between the wasm memory and an ArrayBuffer / view. + * + * Note: when a non-shared wasm memory has grown, a view over the detached + * old buffer is re-created over the current buffer through the intrinsic + * base-class constructor, so for view inputs the returned view may be a + * base-class instance (e.g. `Uint8Array` or `DataView`) instead of the + * subclass that was passed in. + */ + function $emnapiSyncMemory(js_to_wasm, arrayBufferOrView, offset, len) { + offset = offset ?? 0; + offset = offset >>> 0; + let view; + if (arrayBufferOrView instanceof ArrayBuffer || emnapiExternalMemory.isSharedArrayBuffer(arrayBufferOrView)) { + const pointer = emnapiExternalMemory.getArrayBufferPointer(arrayBufferOrView, false).address; + if (!pointer) + throw new Error('Unknown ArrayBuffer address'); + if (typeof len !== 'number' || len === -1 || len === 4294967295) { + len = arrayBufferOrView.byteLength - offset; + } + len = len >>> 0; + if (len === 0) + return arrayBufferOrView; + view = new Uint8Array(arrayBufferOrView, offset, len); + const wasmMemoryU8 = new Uint8Array(wasmMemory.buffer); + if (!js_to_wasm) { + view.set(wasmMemoryU8.subarray(pointer, pointer + len)); + } + else { + wasmMemoryU8.set(view, pointer); + } + return arrayBufferOrView; + } + if (ArrayBuffer.isView(arrayBufferOrView)) { + const viewPointerInfo = emnapiExternalMemory.getViewPointer(arrayBufferOrView, false); + const latestView = viewPointerInfo.view; + const pointer = viewPointerInfo.address; + if (!pointer) + throw new Error('Unknown ArrayBuffer address'); + if (typeof len !== 'number' || len === -1 || len === 4294967295) { + len = latestView.byteLength - offset; + } + len = len >>> 0; + if (len === 0) + return latestView; + view = new Uint8Array(latestView.buffer, latestView.byteOffset + offset, len); + const wasmMemoryU8 = new Uint8Array(wasmMemory.buffer); + if (!js_to_wasm) { + view.set(wasmMemoryU8.subarray(pointer, pointer + len)); + } + else { + wasmMemoryU8.set(view, pointer); + } + return latestView; + } + throw new TypeError('emnapiSyncMemory expect ArrayBuffer or ArrayBufferView as first parameter'); + } + /** + * @__sig ipippp + */ + function emnapi_sync_memory(env, js_to_wasm, arraybuffer_or_view, offset, len) { + let v; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!arraybuffer_or_view) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + arraybuffer_or_view >>>= 0; + offset >>>= 0; + len >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + const id = GET_HEAP_DATA_VIEW().getUint32(arraybuffer_or_view, true); + const jsValue = emnapiCtx.jsValueFromNapiValue(id); + const isArrayBuffer = jsValue instanceof ArrayBuffer; + const isDataView = jsValue instanceof DataView; + const isTypedArray = ArrayBuffer.isView(jsValue) && !isDataView; + if (!isArrayBuffer && !isTypedArray && !isDataView && !emnapiExternalMemory.isSharedArrayBuffer(jsValue)) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + const ret = $emnapiSyncMemory(Boolean(js_to_wasm), jsValue, offset, len); + if (jsValue !== ret) { + arraybuffer_or_view >>>= 0; + v = emnapiCtx.napiValueFromJsValue(ret); + GET_HEAP_DATA_VIEW().setUint32(arraybuffer_or_view, v, true); + } + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + function $emnapiGetMemoryAddress(arrayBufferOrView) { + const isArrayBuffer = arrayBufferOrView instanceof ArrayBuffer; + const isDataView = arrayBufferOrView instanceof DataView; + const isTypedArray = ArrayBuffer.isView(arrayBufferOrView) && !isDataView; + if (!isArrayBuffer && !isTypedArray && !isDataView && !emnapiExternalMemory.isSharedArrayBuffer(arrayBufferOrView)) { + throw new TypeError('emnapiGetMemoryAddress expect ArrayBuffer or ArrayBufferView as first parameter'); + } + let info; + if (isArrayBuffer) { + info = emnapiExternalMemory.getArrayBufferPointer(arrayBufferOrView, false); + } + else { + info = emnapiExternalMemory.getViewPointer(arrayBufferOrView, false); + } + return { + address: info.address, + ownership: info.ownership, + runtimeAllocated: info.runtimeAllocated + }; + } + /** + * @__sig ipppp + */ + function emnapi_get_memory_address(env, arraybuffer_or_view, address, ownership, runtime_allocated) { + let p, runtimeAllocated, ownershipOut; + let info; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!arraybuffer_or_view) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!address && !ownership && !runtime_allocated) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + const value = emnapiCtx.jsValueFromNapiValue(arraybuffer_or_view); + info = $emnapiGetMemoryAddress(value); + p = info.address; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + if (address) { + address >>>= 0; + GET_HEAP_DATA_VIEW().setUint32(address, p, true); + } + if (ownership) { + ownership >>>= 0; + ownershipOut = info.ownership; + GET_HEAP_DATA_VIEW().setInt32(ownership, ownershipOut, true); + } + if (runtime_allocated) { + runtime_allocated >>>= 0; + runtimeAllocated = info.runtimeAllocated; + GET_HEAP_DATA_VIEW().setInt8(runtime_allocated, runtimeAllocated, true); + } + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ipp + */ + function emnapi_get_runtime_version(env, version) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + const envObject = emnapiEnv; + if (!version) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + let runtimeVersion; + try { + runtimeVersion = emnapiCtx.getRuntimeVersions().version; + } + catch (_) { + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + const versions = runtimeVersion.split('.') + .map((n) => Number(n)); + version >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(version, versions[0], true); + GET_HEAP_DATA_VIEW().setUint32(version + 4, versions[1], true); + GET_HEAP_DATA_VIEW().setUint32(version + 8, versions[2], true); + return envObject.clearLastError(); + } + /** + * Get the handle for an external SharedArrayBuffer. + * Must be called on the emnapi main thread. + * @__sig ippp + */ + function emnapi_get_external_sharedarraybuffer_handle(env, sharedarraybuffer, handle) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!sharedarraybuffer) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!handle) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + handle >>>= 0; + const jsValue = emnapiCtx.jsValueFromNapiValue(sharedarraybuffer); + if (!emnapiExternalMemory.isSharedArrayBuffer(jsValue)) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + const metaPtr = emnapiExternalSAB.handleTable.get(jsValue); + if (metaPtr === undefined) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + let p = metaPtr; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(handle, p, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * Acquire a reference to an external SharedArrayBuffer. + * Can be called on any thread. + * @__sig vp + */ + function emnapi_acquire_external_sharedarraybuffer(handle) { + handle >>>= 0; + Atomics.add(new Int32Array(wasmMemory.buffer, handle, 1), 0, 1); + } + /** + * Release a reference to an external SharedArrayBuffer. + * Can be called on any thread. + * @__sig vp + */ + function emnapi_release_external_sharedarraybuffer(handle) { + handle >>>= 0; + emnapiExternalSAB.release(handle); + } + /** + * Acquire a reference to an external SharedArrayBuffer on the current thread. + * Can be called on any thread. Increments refcount and registers in + * the current thread's FinalizationRegistry. + * Exposed as Module.emnapiAcquireExternalSharedArrayBuffer (emscripten) or + * napiModule.emnapi.acquireExternalSharedArrayBuffer (core). + */ + function $emnapiAcquireExternalSharedArrayBuffer(handle, sab) { + if (sab != null && !emnapiExternalMemory.isSharedArrayBuffer(sab)) { + throw new TypeError('Expected a SharedArrayBuffer'); + } + if (!emnapiExternalSAB.registry) { + throw new Error('FinalizationRegistry is not supported in this environment'); + } + handle >>>= 0; + const meta = emnapiExternalSAB.readMeta(handle); + let external_data = meta.external_data; + external_data >>>= 0; + if (sab == null) { + sab = new SharedArrayBuffer(meta.byte_length); + new Uint8Array(sab).set(new Uint8Array(wasmMemory.buffer, external_data, meta.byte_length)); + } + else { + if (emnapiExternalSAB.handleTable.has(sab)) { + return sab; + } + } + // Increment refcount atomically + Atomics.add(new Int32Array(wasmMemory.buffer, handle, 1), 0, 1); + // Register in emnapiExternalMemory.table for emnapi_sync_memory support + if (!emnapiExternalMemory.table.has(sab)) { + if (external_data) { + emnapiExternalMemory.table.set(sab, { + address: external_data, + ownership: 1 /* ReferenceOwnership.kUserland */, + runtimeAllocated: 0 + }); + } + } + // Register in handleTable and FinalizationRegistry for this thread + emnapiExternalSAB.handleTable.set(sab, handle); + emnapiExternalSAB.registry.register(sab, handle); + return sab; + } + + //#endregion src/emnapi.ts + + var emnapiMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + $emnapiAcquireExternalSharedArrayBuffer: $emnapiAcquireExternalSharedArrayBuffer, + $emnapiGetMemoryAddress: $emnapiGetMemoryAddress, + $emnapiSyncMemory: $emnapiSyncMemory, + emnapi_acquire_external_sharedarraybuffer: emnapi_acquire_external_sharedarraybuffer, + emnapi_create_memory_view: emnapi_create_memory_view, + emnapi_debug: emnapi_debug, + emnapi_get_external_sharedarraybuffer_handle: emnapi_get_external_sharedarraybuffer_handle, + emnapi_get_memory_address: emnapi_get_memory_address, + emnapi_get_runtime_version: emnapi_get_runtime_version, + emnapi_is_node_binding_available: emnapi_is_node_binding_available, + emnapi_is_support_bigint: emnapi_is_support_bigint, + emnapi_is_support_weakref: emnapi_is_support_weakref, + emnapi_release_external_sharedarraybuffer: emnapi_release_external_sharedarraybuffer, + emnapi_sync_memory: emnapi_sync_memory + }); + + //#region src/value/create.ts + /** + * @__sig ipp + */ + function napi_create_array(env, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + result >>>= 0; + const value = emnapiCtx.napiValueFromJsValue([]); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return envObject.clearLastError(); + } + /** + * @__sig ippp + */ + function napi_create_array_with_length(env, length, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + length >>>= 0; + result >>>= 0; + length = length >>> 0; + const value = emnapiCtx.napiValueFromJsValue(new Array(length)); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return envObject.clearLastError(); + } + function emnapiCreateArrayBuffer(byte_length, data, shared) { + byte_length >>>= 0; + byte_length = byte_length >>> 0; + const arrayBuffer = shared ? new SharedArrayBuffer(byte_length) : new ArrayBuffer(byte_length); + if (data) { + data >>>= 0; + const p = emnapiExternalMemory.getArrayBufferPointer(arrayBuffer, true).address; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(data, p, true); + } + return arrayBuffer; + } + /** + * @__sig ipppp + */ + function napi_create_arraybuffer(env, byte_length, data, result) { + let value; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + result >>>= 0; + const arrayBuffer = emnapiCreateArrayBuffer(byte_length, data, false); + value = emnapiCtx.napiValueFromJsValue(arrayBuffer); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ipppp + */ + function node_api_create_sharedarraybuffer(env, byte_length, data, result) { + let value; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + result >>>= 0; + const arrayBuffer = emnapiCreateArrayBuffer(byte_length, data, true); + value = emnapiCtx.napiValueFromJsValue(arrayBuffer); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ipdp + */ + function napi_create_date(env, time, result) { + let value; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + result >>>= 0; + value = emnapiCtx.napiValueFromJsValue(new Date(time)); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ippppp + */ + function napi_create_external(env, data, finalize_cb, finalize_hint, result) { + let value; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!emnapiCtx.features.finalizer && finalize_cb) { + throw emnapiCtx.createNotSupportWeakRefError('napi_create_external', 'Parameter "finalize_cb" must be 0(NULL)'); + } + value = emnapiCtx.getCurrentScope().addExternal(data); + if (finalize_cb) { + emnapiCtx.createReferenceWithFinalizer(envObject, value, 0, 0 /* ReferenceOwnership.kRuntime */, finalize_cb, data, finalize_hint); + } + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return envObject.clearLastError(); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ipppppp + */ + function napi_create_external_arraybuffer(env, external_data, byte_length, finalize_cb, finalize_hint, result) { + let value; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + byte_length >>>= 0; + external_data >>>= 0; + result >>>= 0; + byte_length = byte_length >>> 0; + if (!external_data) { + byte_length = 0; + } + if ((external_data + byte_length) > wasmMemory.buffer.byteLength) { + throw new RangeError('Memory out of range'); + } + if (!emnapiCtx.features.finalizer && finalize_cb) { + throw emnapiCtx.createNotSupportWeakRefError('napi_create_external_arraybuffer', 'Parameter "finalize_cb" must be 0(NULL)'); + } + const arrayBuffer = new ArrayBuffer(byte_length); + if (byte_length === 0) { + try { + const MessageChannel = emnapiCtx.features.MessageChannel; + const messageChannel = new MessageChannel(); + messageChannel.port1.postMessage(arrayBuffer, [arrayBuffer]); + } + catch (_) { } + } + else { + const u8arr = new Uint8Array(arrayBuffer); + u8arr.set(new Uint8Array(wasmMemory.buffer).subarray(external_data, external_data + byte_length)); + emnapiExternalMemory.table.set(arrayBuffer, { + address: external_data, + ownership: 1 /* ReferenceOwnership.kUserland */, + runtimeAllocated: 0 + }); + } + value = emnapiCtx.napiValueFromJsValue(arrayBuffer); + if (finalize_cb) { + const status = napi_add_finalizer(env, value, external_data, finalize_cb, finalize_hint, /* NULL */ 0); + if (status === 10 /* napi_status.napi_pending_exception */) { + const err = envObject.lastException.deref(); + envObject.clearLastError(); + envObject.lastException.reset(); + throw err; + } + else if (status !== 0 /* napi_status.napi_ok */) { + return envObject.setLastError(status); + } + } + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ipppppp + */ + function node_api_create_external_sharedarraybuffer(env, external_data, byte_length, finalize_cb, finalize_hint, result) { + let value; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + byte_length >>>= 0; + external_data >>>= 0; + result >>>= 0; + byte_length = byte_length >>> 0; + if (!external_data) { + byte_length = 0; + } + if ((external_data + byte_length) > wasmMemory.buffer.byteLength) { + throw new RangeError('Memory out of range'); + } + if (!emnapiExternalSAB.registry && finalize_cb) { + throw emnapiCtx.createNotSupportWeakRefError('node_api_create_external_sharedarraybuffer', 'Parameter "finalize_cb" must be 0(NULL)'); + } + const sharedArrayBuffer = new SharedArrayBuffer(byte_length); + if (byte_length !== 0) { + const u8arr = new Uint8Array(sharedArrayBuffer); + u8arr.set(new Uint8Array(wasmMemory.buffer).subarray(external_data, external_data + byte_length)); + emnapiExternalMemory.table.set(sharedArrayBuffer, { + address: external_data, + ownership: 1 /* ReferenceOwnership.kUserland */, + runtimeAllocated: 0 + }); + } + value = emnapiCtx.napiValueFromJsValue(sharedArrayBuffer); + if (finalize_cb) { + finalize_cb >>>= 0; + finalize_hint >>>= 0; + const metaPtr = emnapiExternalSAB.allocMeta(external_data, byte_length, finalize_cb, external_data, finalize_hint); + emnapiExternalSAB.handleTable.set(sharedArrayBuffer, metaPtr); + emnapiExternalSAB.registry.register(sharedArrayBuffer, metaPtr); + } + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ipp + */ + function napi_create_object(env, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + result >>>= 0; + const value = emnapiCtx.napiValueFromJsValue({}); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return envObject.clearLastError(); + } + /** + * @__sig ipppppp + */ + function node_api_create_object_with_properties(env, prototype_or_null, property_names, property_values, property_count, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + property_count >>>= 0; + property_count = property_count >>> 0; + if (property_count > 0) { + if (!property_names) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!property_values) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + const v8_prototype_or_null = prototype_or_null + ? emnapiCtx.jsValueFromNapiValue(prototype_or_null) + : null; + const properties = {}; + property_names >>>= 0; + property_values >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + for (let i = 0; i < property_count; i++) { + const name_value = emnapiCtx.jsValueFromNapiValue(GET_HEAP_DATA_VIEW().getUint32(property_names + i * 4, true)); + if (!(typeof name_value === "string" || typeof name_value === "symbol")) + return envObject.setLastError(4 /* napi_status.napi_name_expected */); + properties[name_value] = { + value: emnapiCtx.jsValueFromNapiValue(GET_HEAP_DATA_VIEW().getUint32(property_values + i * 4, true)), + writable: true, + enumerable: true, + configurable: true + }; + } + let obj; + try { + obj = Object.defineProperties(Object.create(v8_prototype_or_null), properties); + } + catch (_) { + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + const value = emnapiCtx.napiValueFromJsValue(obj); + result >>>= 0; + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return envObject.clearLastError(); + } + /** + * @__sig ippp + */ + function napi_create_symbol(env, description, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + if (!description) { + // eslint-disable-next-line symbol-description + const value = emnapiCtx.napiValueFromJsValue(Symbol()); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + } + else { + const desc = emnapiCtx.jsValueFromNapiValue(description); + if (typeof desc !== 'string') { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + const v = emnapiCtx.napiValueFromJsValue(Symbol(desc)); + GET_HEAP_DATA_VIEW().setUint32(result, v, true); + } + return envObject.clearLastError(); + } + /** + * @__sig ipipppp + */ + function napi_create_typedarray(env, type, length, arraybuffer, byte_offset, result) { + let value; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!arraybuffer) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const buffer = emnapiCtx.jsValueFromNapiValue(arraybuffer); + byte_offset >>>= 0; + length >>>= 0; + const createTypedArray = function (envObject, Type, size_of_element, buffer, byte_offset, length) { + byte_offset = byte_offset >>> 0; + length = length >>> 0; + if (size_of_element > 1) { + if ((byte_offset) % (size_of_element) !== 0) { + const err = new RangeError(`start offset of ${Type.name ?? ''} should be a multiple of ${size_of_element}`); + err.code = 'ERR_NAPI_INVALID_TYPEDARRAY_ALIGNMENT'; + envObject.lastException.resetTo(err); + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + } + if (((length * size_of_element) + byte_offset) > buffer.byteLength) { + const err = new RangeError('Invalid typed array length'); + err.code = 'ERR_NAPI_INVALID_TYPEDARRAY_LENGTH'; + envObject.lastException.resetTo(err); + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + const out = new Type(buffer, byte_offset, length); + if (buffer === wasmMemory.buffer) { + if (!emnapiExternalMemory.wasmMemoryViewTable.has(out)) { + emnapiExternalMemory.wasmMemoryViewTable.set(out, { + Ctor: Type, + address: byte_offset, + length, + ownership: 1 /* ReferenceOwnership.kUserland */, + runtimeAllocated: 0 + }); + } + } + result >>>= 0; + value = emnapiCtx.napiValueFromJsValue(out); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return (0 /* napi_status.napi_ok */); + }; + if (buffer instanceof ArrayBuffer || emnapiExternalMemory.isSharedArrayBuffer(buffer)) { + switch (type) { + case 0 /* napi_typedarray_type.napi_int8_array */: + return createTypedArray(envObject, Int8Array, 1, buffer, byte_offset, length); + case 1 /* napi_typedarray_type.napi_uint8_array */: + return createTypedArray(envObject, Uint8Array, 1, buffer, byte_offset, length); + case 2 /* napi_typedarray_type.napi_uint8_clamped_array */: + return createTypedArray(envObject, Uint8ClampedArray, 1, buffer, byte_offset, length); + case 3 /* napi_typedarray_type.napi_int16_array */: + return createTypedArray(envObject, Int16Array, 2, buffer, byte_offset, length); + case 4 /* napi_typedarray_type.napi_uint16_array */: + return createTypedArray(envObject, Uint16Array, 2, buffer, byte_offset, length); + case 5 /* napi_typedarray_type.napi_int32_array */: + return createTypedArray(envObject, Int32Array, 4, buffer, byte_offset, length); + case 6 /* napi_typedarray_type.napi_uint32_array */: + return createTypedArray(envObject, Uint32Array, 4, buffer, byte_offset, length); + case 7 /* napi_typedarray_type.napi_float32_array */: + return createTypedArray(envObject, Float32Array, 4, buffer, byte_offset, length); + case 8 /* napi_typedarray_type.napi_float64_array */: + return createTypedArray(envObject, Float64Array, 8, buffer, byte_offset, length); + case 9 /* napi_typedarray_type.napi_bigint64_array */: + return createTypedArray(envObject, BigInt64Array, 8, buffer, byte_offset, length); + case 10 /* napi_typedarray_type.napi_biguint64_array */: + return createTypedArray(envObject, BigUint64Array, 8, buffer, byte_offset, length); + case 11 /* napi_typedarray_type.napi_float16_array */: + if (typeof Float16Array !== 'function') { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + return createTypedArray(envObject, Float16Array, 2, buffer, byte_offset, length); + default: + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + } + else { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__deps malloc + * @__sig ippp + */ + function napi_create_buffer(env, size, data, result) { + let value, pointer; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const Buffer = emnapiCtx.features.Buffer; + if (!Buffer) { + throw emnapiCtx.createNotSupportBufferError('napi_create_buffer', ''); + } + result >>>= 0; + let buffer; + size >>>= 0; + size = size >>> 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + if (!data || (size === 0)) { + buffer = Buffer.alloc(size); + value = emnapiCtx.napiValueFromJsValue(buffer); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + } + else { + pointer = _malloc(size); + if (!pointer) + throw new Error('Out of memory'); + pointer >>>= 0; + new Uint8Array(wasmMemory.buffer).subarray(pointer, pointer + size).fill(0); + // capture Buffer.from at creation so a later refreshed view uses it + const buffer = emnapiExternalMemory.getBufferFrom()(wasmMemory.buffer, pointer, size); + const viewDescriptor = { + Ctor: Buffer, + address: pointer, + length: size, + ownership: emnapiExternalMemory.registry ? 0 /* ReferenceOwnership.kRuntime */ : 1 /* ReferenceOwnership.kUserland */, + runtimeAllocated: 1 + }; + emnapiExternalMemory.wasmMemoryViewTable.set(buffer, viewDescriptor); + emnapiExternalMemory.registry?.register(viewDescriptor, pointer); + value = emnapiCtx.napiValueFromJsValue(buffer); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + data >>>= 0; + GET_HEAP_DATA_VIEW().setUint32(data, pointer, true); + } + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ippppp + */ + function napi_create_buffer_copy(env, length, data, result_data, result) { + let value; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const Buffer = emnapiCtx.features.Buffer; + if (!Buffer) { + throw emnapiCtx.createNotSupportBufferError('napi_create_buffer_copy', ''); + } + const arrayBuffer = emnapiCreateArrayBuffer(length, result_data, false); + const buffer = Buffer.from(arrayBuffer); + data >>>= 0; + length >>>= 0; + buffer.set(new Uint8Array(wasmMemory.buffer).subarray(data, data + length)); + value = emnapiCtx.napiValueFromJsValue(buffer); + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ipppppp + */ + function napi_create_external_buffer(env, length, data, finalize_cb, finalize_hint, result) { + return emnapi_create_memory_view(env, -2 /* emnapi_memory_view_type.emnapi_buffer */, data, length, finalize_cb, finalize_hint, result); + } + /** + * @__sig ippppp + */ + function node_api_create_buffer_from_arraybuffer(env, arraybuffer, byte_offset, byte_length, result) { + let value; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!arraybuffer) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + byte_offset >>>= 0; + byte_length >>>= 0; + byte_offset = byte_offset >>> 0; + byte_length = byte_length >>> 0; + const buffer = emnapiCtx.jsValueFromNapiValue(arraybuffer); + if (!(buffer instanceof ArrayBuffer)) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + if ((byte_length + byte_offset) > buffer.byteLength) { + const err = new RangeError('The byte offset + length is out of range'); + err.code = 'ERR_OUT_OF_RANGE'; + throw err; + } + const Buffer = emnapiCtx.features.Buffer; + if (!Buffer) { + throw emnapiCtx.createNotSupportBufferError('node_api_create_buffer_from_arraybuffer', ''); + } + // capture Buffer.from at creation so a later refreshed view uses it + const out = emnapiExternalMemory.getBufferFrom()(buffer, byte_offset, byte_length); + if (buffer === wasmMemory.buffer) { + if (!emnapiExternalMemory.wasmMemoryViewTable.has(out)) { + emnapiExternalMemory.wasmMemoryViewTable.set(out, { + Ctor: Buffer, + address: byte_offset, + length: byte_length, + ownership: 1 /* ReferenceOwnership.kUserland */, + runtimeAllocated: 0 + }); + } + } + result >>>= 0; + value = emnapiCtx.napiValueFromJsValue(out); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ippppp + */ + function napi_create_dataview(env, byte_length, arraybuffer, byte_offset, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!arraybuffer) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + byte_length >>>= 0; + byte_offset >>>= 0; + byte_length = byte_length >>> 0; + byte_offset = byte_offset >>> 0; + const value = emnapiCtx.jsValueFromNapiValue(arraybuffer); + const createDataview = (buffer) => { + if ((byte_length + byte_offset) > buffer.byteLength) { + const err = new RangeError('byte_offset + byte_length should be less than or equal to the size in bytes of the array passed in'); + err.code = 'ERR_NAPI_INVALID_DATAVIEW_ARGS'; + throw err; + } + const dataview = new DataView(buffer, byte_offset, byte_length); + if (buffer === wasmMemory.buffer) { + if (!emnapiExternalMemory.wasmMemoryViewTable.has(dataview)) { + emnapiExternalMemory.wasmMemoryViewTable.set(dataview, { + Ctor: DataView, + address: byte_offset, + length: byte_length, + ownership: 1 /* ReferenceOwnership.kUserland */, + runtimeAllocated: 0 + }); + } + } + result >>>= 0; + let v = emnapiCtx.napiValueFromJsValue(dataview); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, v, true); + return (0 /* napi_status.napi_ok */); + }; + if (value instanceof ArrayBuffer || emnapiExternalMemory.isSharedArrayBuffer(value)) { + return createDataview(value); + } + else { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ipppp + */ + function node_api_symbol_for(env, utf8description, length, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + length >>>= 0; + utf8description >>>= 0; + result >>>= 0; + const autoLength = length === -1 || length === 4294967295; + const sizelength = length >>> 0; + if (length !== 0) { + if (!utf8description) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + if (!(autoLength || (sizelength <= 2147483647))) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + const descriptionString = emnapiString.UTF8ToString(utf8description, length); + const value = emnapiCtx.napiValueFromJsValue(Symbol.for(descriptionString)); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return envObject.clearLastError(); + } + + //#endregion src/value/create.ts + + var createMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + napi_create_array: napi_create_array, + napi_create_array_with_length: napi_create_array_with_length, + napi_create_arraybuffer: napi_create_arraybuffer, + napi_create_buffer: napi_create_buffer, + napi_create_buffer_copy: napi_create_buffer_copy, + napi_create_dataview: napi_create_dataview, + napi_create_date: napi_create_date, + napi_create_external: napi_create_external, + napi_create_external_arraybuffer: napi_create_external_arraybuffer, + napi_create_external_buffer: napi_create_external_buffer, + napi_create_object: napi_create_object, + napi_create_symbol: napi_create_symbol, + napi_create_typedarray: napi_create_typedarray, + node_api_create_buffer_from_arraybuffer: node_api_create_buffer_from_arraybuffer, + node_api_create_external_sharedarraybuffer: node_api_create_external_sharedarraybuffer, + node_api_create_object_with_properties: node_api_create_object_with_properties, + node_api_create_sharedarraybuffer: node_api_create_sharedarraybuffer, + node_api_symbol_for: node_api_symbol_for + }); + + //#region src/value/global.ts + /** @__sig ipip */ + function napi_get_boolean(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + result >>>= 0; + const v = value === 0 ? 4 /* Constant.FALSE */ : 5 /* Constant.TRUE */; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, v, true); + return envObject.clearLastError(); + } + /** @__sig ipp */ + function napi_get_global(env, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + result >>>= 0; + const value = 6 /* Constant.GLOBAL */; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return envObject.clearLastError(); + } + /** @__sig ipp */ + function napi_get_null(env, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + result >>>= 0; + const value = 3 /* Constant.NULL */; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return envObject.clearLastError(); + } + /** @__sig ipp */ + function napi_get_undefined(env, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + result >>>= 0; + const value = 2 /* Constant.UNDEFINED */; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return envObject.clearLastError(); + } + + //#endregion src/value/global.ts + + var globalMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + napi_get_boolean: napi_get_boolean, + napi_get_global: napi_get_global, + napi_get_null: napi_get_null, + napi_get_undefined: napi_get_undefined + }); + + //#region src/env.ts + /** @__sig ipppp */ + function napi_set_instance_data(env, data, finalize_cb, finalize_hint) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + const envObject = emnapiEnv; + data >>>= 0; + finalize_cb >>>= 0; + finalize_hint >>>= 0; + envObject.setInstanceData(data, finalize_cb, finalize_hint); + return envObject.clearLastError(); + } + /** @__sig ipp */ + function napi_get_instance_data(env, data) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + const envObject = emnapiEnv; + if (!data) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + data >>>= 0; + const value = envObject.getInstanceData(); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(data, value, true); + return envObject.clearLastError(); + } + + //#endregion src/env.ts + + var envMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + napi_get_instance_data: napi_get_instance_data, + napi_set_instance_data: napi_set_instance_data + }); + + //#region src/error.ts + /** @__sig ipp */ + function napi_throw(env, error) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!error) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + envObject.lastException.resetTo(emnapiCtx.jsValueFromNapiValue(error)); + return envObject.clearLastError(); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippp */ + function napi_throw_error(env, code, msg) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!msg) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + code >>>= 0; + msg >>>= 0; + const error = new Error(emnapiString.UTF8ToString(msg, -1)); + if (code) + error.code = emnapiString.UTF8ToString(code, -1); + envObject.lastException.resetTo(error); + return envObject.clearLastError(); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippp */ + function napi_throw_type_error(env, code, msg) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!msg) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + code >>>= 0; + msg >>>= 0; + const error = new TypeError(emnapiString.UTF8ToString(msg, -1)); + if (code) + error.code = emnapiString.UTF8ToString(code, -1); + envObject.lastException.resetTo(error); + return envObject.clearLastError(); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippp */ + function napi_throw_range_error(env, code, msg) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!msg) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + code >>>= 0; + msg >>>= 0; + const error = new RangeError(emnapiString.UTF8ToString(msg, -1)); + if (code) + error.code = emnapiString.UTF8ToString(code, -1); + envObject.lastException.resetTo(error); + return envObject.clearLastError(); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippp */ + function node_api_throw_syntax_error(env, code, msg) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!msg) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + code >>>= 0; + msg >>>= 0; + const error = new SyntaxError(emnapiString.UTF8ToString(msg, -1)); + if (code) + error.code = emnapiString.UTF8ToString(code, -1); + envObject.lastException.resetTo(error); + return envObject.clearLastError(); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipp */ + function napi_is_exception_pending(env, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const r = !envObject.lastException.isEmpty(); + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(result, r ? 1 : 0, true); + return envObject.clearLastError(); + } + /** @__sig ipppp */ + function napi_create_error(env, code, msg, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!msg) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const msgValue = emnapiCtx.jsValueFromNapiValue(msg); + if (typeof msgValue !== 'string') { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + const error = new Error(msgValue); + if (code) { + const codeValue = emnapiCtx.jsValueFromNapiValue(code); + if (typeof codeValue !== 'string') { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + error.code = codeValue; + } + result >>>= 0; + const value = emnapiCtx.napiValueFromJsValue(error); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return envObject.clearLastError(); + } + /** @__sig ipppp */ + function napi_create_type_error(env, code, msg, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!msg) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const msgValue = emnapiCtx.jsValueFromNapiValue(msg); + if (typeof msgValue !== 'string') { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + const error = new TypeError(msgValue); + if (code) { + const codeValue = emnapiCtx.jsValueFromNapiValue(code); + if (typeof codeValue !== 'string') { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + error.code = codeValue; + } + result >>>= 0; + const value = emnapiCtx.napiValueFromJsValue(error); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return envObject.clearLastError(); + } + /** @__sig ipppp */ + function napi_create_range_error(env, code, msg, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!msg) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const msgValue = emnapiCtx.jsValueFromNapiValue(msg); + if (typeof msgValue !== 'string') { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + const error = new RangeError(msgValue); + if (code) { + const codeValue = emnapiCtx.jsValueFromNapiValue(code); + if (typeof codeValue !== 'string') { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + error.code = codeValue; + } + result >>>= 0; + const value = emnapiCtx.napiValueFromJsValue(error); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return envObject.clearLastError(); + } + /** @__sig ipppp */ + function node_api_create_syntax_error(env, code, msg, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!msg) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const msgValue = emnapiCtx.jsValueFromNapiValue(msg); + if (typeof msgValue !== 'string') { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + const error = new SyntaxError(msgValue); + if (code) { + const codeValue = emnapiCtx.jsValueFromNapiValue(code); + if (typeof codeValue !== 'string') { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + error.code = codeValue; + } + result >>>= 0; + const value = emnapiCtx.napiValueFromJsValue(error); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return envObject.clearLastError(); + } + /** @__sig ipp */ + function napi_get_and_clear_last_exception(env, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + if (envObject.lastException.isEmpty()) { + GET_HEAP_DATA_VIEW().setUint32(result, 1, true); // ID_UNDEFINED + return envObject.clearLastError(); + } + else { + const err = envObject.lastException.deref(); + const value = emnapiCtx.napiValueFromJsValue(err); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + envObject.lastException.reset(); + } + return envObject.clearLastError(); + } + /** @__sig vpppp */ + function napi_fatal_error(location, location_len, message, message_len) { + location >>>= 0; + location_len >>>= 0; + message >>>= 0; + message_len >>>= 0; + const locationStr = emnapiString.UTF8ToString(location, location_len); + const messageStr = emnapiString.UTF8ToString(message, message_len); + if (emnapiNodeBinding) { + emnapiNodeBinding.napi.fatalError(locationStr, messageStr); + } + else { + abort('FATAL ERROR: ' + locationStr + ' ' + messageStr); + } + } + /** @__sig ipp */ + function napi_fatal_exception(env, err) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!err) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const error = emnapiCtx.jsValueFromNapiValue(err); + try { + envObject.triggerFatalException(error); + } + catch (_) { + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + return envObject.clearLastError(); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + + //#endregion src/error.ts + + var errorMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + napi_create_error: napi_create_error, + napi_create_range_error: napi_create_range_error, + napi_create_type_error: napi_create_type_error, + napi_fatal_error: napi_fatal_error, + napi_fatal_exception: napi_fatal_exception, + napi_get_and_clear_last_exception: napi_get_and_clear_last_exception, + napi_is_exception_pending: napi_is_exception_pending, + napi_throw: napi_throw, + napi_throw_error: napi_throw_error, + napi_throw_range_error: napi_throw_range_error, + napi_throw_type_error: napi_throw_type_error, + node_api_create_syntax_error: node_api_create_syntax_error, + node_api_throw_syntax_error: node_api_throw_syntax_error + }); + + //#region src/function.ts + /** @__sig ippppp */ + function _emnapi_create_function(utf8name, length, cb, data, result) { + length >>>= 0; + const fresult = emnapiCreateFunction(emnapiEnv, utf8name, length, cb, data); + if (fresult.status !== 0 /* napi_status.napi_ok */) + return emnapiEnv.setLastError(fresult.status); + const f = fresult.f; + const value = emnapiCtx.napiValueFromJsValue(f); + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return (0 /* napi_status.napi_ok */); + } + /** @__sig ipppppp */ + function napi_create_function(env, utf8name, length, cb, data, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!cb) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + return _emnapi_create_function(utf8name, length, cb, data, result); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipppppp */ + function napi_get_cb_info(env, cbinfo, argc, argv, this_arg, data) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + const envObject = emnapiEnv; + if (!cbinfo) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const cbinfoValue = emnapiCtx.getCallbackInfo(cbinfo); + argc >>>= 0; + argv >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + if (argv) { + if (!argc) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + let argcValue = GET_HEAP_DATA_VIEW().getUint32(argc, true); + argcValue >>>= 0; + const len = cbinfoValue.args.length; + const arrlen = argcValue < len ? argcValue : len; + let i = 0; + for (; i < arrlen; i++) { + const argVal = emnapiCtx.napiValueFromJsValue(cbinfoValue.args[i]); + GET_HEAP_DATA_VIEW().setUint32(argv + i * 4, argVal, true); + } + if (i < argcValue) { + for (; i < argcValue; i++) { + GET_HEAP_DATA_VIEW().setUint32(argv + i * 4, 1, true); + } + } + } + if (argc) { + GET_HEAP_DATA_VIEW().setUint32(argc, cbinfoValue.args.length, true); + } + if (this_arg) { + this_arg >>>= 0; + const v = emnapiCtx.napiValueFromJsValue(cbinfoValue.thiz); + GET_HEAP_DATA_VIEW().setUint32(this_arg, v, true); + } + if (data) { + data >>>= 0; + GET_HEAP_DATA_VIEW().setUint32(data, cbinfoValue.data, true); + } + return envObject.clearLastError(); + } + /** @__sig ipppppp */ + function napi_call_function(env, recv, func, argc, argv, result) { + let i = 0; + let v; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!recv) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + argc >>>= 0; + argv >>>= 0; + result >>>= 0; + argc = argc >>> 0; + if (argc > 0) { + if (!argv) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + const v8recv = emnapiCtx.jsValueFromNapiValue(recv); + if (!func) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const v8func = emnapiCtx.jsValueFromNapiValue(func); + if (typeof v8func !== 'function') + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const args = []; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + for (; i < argc; i++) { + const argVal = GET_HEAP_DATA_VIEW().getUint32(argv + i * 4, true); + args.push(emnapiCtx.jsValueFromNapiValue(argVal)); + } + const ret = v8func.apply(v8recv, args); + if (result) { + // resolving v BEFORE the write matters: the store target is evaluated + // before the RHS, so an RHS running user JS could otherwise write + // through a stale heap view after a growth + v = emnapiCtx.napiValueFromJsValue(ret); + GET_HEAP_DATA_VIEW().setUint32(result, v, true); + } + return envObject.clearLastError(); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippppp */ + function napi_new_instance(env, constructor, argc, argv, result) { + let i; + let v; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!constructor) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + argc >>>= 0; + argv >>>= 0; + result >>>= 0; + argc = argc >>> 0; + if (argc > 0) { + if (!argv) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const Ctor = emnapiCtx.jsValueFromNapiValue(constructor); + if (typeof Ctor !== 'function') + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + let ret; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + if (emnapiCtx.features.Reflect) { + const argList = Array(argc); + for (i = 0; i < argc; i++) { + const argVal = GET_HEAP_DATA_VIEW().getUint32(argv + i * 4, true); + argList[i] = emnapiCtx.jsValueFromNapiValue(argVal); + } + ret = emnapiCtx.features.Reflect.construct(Ctor, argList, Ctor); + } + else { + const args = Array(argc + 1); + args[0] = undefined; + for (i = 0; i < argc; i++) { + const argVal = GET_HEAP_DATA_VIEW().getUint32(argv + i * 4, true); + args[i + 1] = emnapiCtx.jsValueFromNapiValue(argVal); + } + const BoundCtor = Ctor.bind.apply(Ctor, args); + ret = new BoundCtor(); + } + if (result) { + // see napi_call_function: resolve v before the write + v = emnapiCtx.napiValueFromJsValue(ret); + GET_HEAP_DATA_VIEW().setUint32(result, v, true); + } + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippp */ + function napi_get_new_target(env, cbinfo, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!cbinfo) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + result >>>= 0; + const cbinfoValue = emnapiCtx.getCallbackInfo(cbinfo); + const { thiz, fn } = cbinfoValue; + const value = thiz == null || thiz.constructor == null + ? 0 + : thiz instanceof fn + ? emnapiCtx.napiValueFromJsValue(thiz.constructor) + : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return envObject.clearLastError(); + } + + //#endregion src/function.ts + + var functionMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + _emnapi_create_function: _emnapi_create_function, + napi_call_function: napi_call_function, + napi_create_function: napi_create_function, + napi_get_cb_info: napi_get_cb_info, + napi_get_new_target: napi_get_new_target, + napi_new_instance: napi_new_instance + }); + + //#region src/life.ts + /** @__sig ipp */ + function napi_open_handle_scope(env, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const scope = emnapiCtx.openScope(envObject); + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, scope.id, true); + return envObject.clearLastError(); + } + /** @__sig ipp */ + function napi_close_handle_scope(env, scope) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!scope) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if ((envObject.openHandleScopes === 0)) { + return 13 /* napi_status.napi_handle_scope_mismatch */; + } + emnapiCtx.closeScope(envObject); + return envObject.clearLastError(); + } + /** @__sig ipp */ + function napi_open_escapable_handle_scope(env, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const scope = emnapiCtx.openScope(envObject); + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, scope.id, true); + return envObject.clearLastError(); + } + /** @__sig ipp */ + function napi_close_escapable_handle_scope(env, scope) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!scope) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if ((envObject.openHandleScopes === 0)) { + return 13 /* napi_status.napi_handle_scope_mismatch */; + } + emnapiCtx.closeScope(envObject); + return envObject.clearLastError(); + } + /** @__sig ipppp */ + function napi_escape_handle(env, scope, escapee, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!scope) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!escapee) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const scopeObject = emnapiCtx.getHandleScope(scope); + if (!scopeObject.escapeCalled()) { + escapee >>>= 0; + result >>>= 0; + const newHandle = scopeObject.escape(escapee); + const value = newHandle; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return envObject.clearLastError(); + } + return envObject.setLastError(12 /* napi_status.napi_escape_called_twice */); + } + /** @__sig ippip */ + function napi_create_reference(env, value, initial_refcount, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + const type = typeof jsValue; + if (envObject.moduleApiVersion < 10) { + if (!((type === 'object' && jsValue !== null) || type === 'function' || typeof jsValue === 'symbol')) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + } + const ref = emnapiCtx.createReference(envObject, value, initial_refcount >>> 0, 1 /* ReferenceOwnership.kUserland */); + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, ref.id, true); + return envObject.clearLastError(); + } + /** @__sig ipp */ + function napi_delete_reference(env, ref) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + const envObject = emnapiEnv; + if (!ref) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + emnapiCtx.getRef(ref).dispose(); + return envObject.clearLastError(); + } + /** @__sig ippp */ + function napi_reference_ref(env, ref, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!ref) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const count = emnapiCtx.getRef(ref).ref(); + if (result) { + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, count, true); + } + return envObject.clearLastError(); + } + /** @__sig ippp */ + function napi_reference_unref(env, ref, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!ref) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const reference = emnapiCtx.getRef(ref); + const refcount = reference.refcount(); + if (refcount === 0) { + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + const count = reference.unref(); + if (result) { + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, count, true); + } + return envObject.clearLastError(); + } + /** @__sig ippp */ + function napi_get_reference_value(env, ref, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!ref) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const reference = emnapiCtx.getRef(ref); + const id = reference.get(); + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, id, true); + return envObject.clearLastError(); + } + /** @__sig ippp */ + function napi_add_env_cleanup_hook(env, fun, arg) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + const envObject = emnapiEnv; + if (!fun) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + fun >>>= 0; + arg >>>= 0; + emnapiCtx.addCleanupHook(envObject, fun, arg); + return 0 /* napi_status.napi_ok */; + } + /** @__sig ippp */ + function napi_remove_env_cleanup_hook(env, fun, arg) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + const envObject = emnapiEnv; + if (!fun) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + fun >>>= 0; + arg >>>= 0; + emnapiCtx.removeCleanupHook(envObject, fun, arg); + return 0 /* napi_status.napi_ok */; + } + /** @__sig vp */ + function _emnapi_env_ref(env) { + const envObject = emnapiEnv; + envObject.ref(); + } + /** @__sig vp */ + function _emnapi_env_unref(env) { + const envObject = emnapiEnv; + envObject.unref(); + } + + //#endregion src/life.ts + + var lifeMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + _emnapi_env_ref: _emnapi_env_ref, + _emnapi_env_unref: _emnapi_env_unref, + napi_add_env_cleanup_hook: napi_add_env_cleanup_hook, + napi_close_escapable_handle_scope: napi_close_escapable_handle_scope, + napi_close_handle_scope: napi_close_handle_scope, + napi_create_reference: napi_create_reference, + napi_delete_reference: napi_delete_reference, + napi_escape_handle: napi_escape_handle, + napi_get_reference_value: napi_get_reference_value, + napi_open_escapable_handle_scope: napi_open_escapable_handle_scope, + napi_open_handle_scope: napi_open_handle_scope, + napi_reference_ref: napi_reference_ref, + napi_reference_unref: napi_reference_unref, + napi_remove_env_cleanup_hook: napi_remove_env_cleanup_hook + }); + + //#region src/miscellaneous.ts + /** @__sig ippi */ + function _emnapi_get_filename(env, buf, len) { + const envObject = emnapiEnv; + const filename = envObject.filename; + if (!buf) { + return emnapiString.lengthBytesUTF8(filename); + } + buf >>>= 0; + return emnapiString.stringToUTF8(filename, buf, len); + } + + //#endregion src/miscellaneous.ts + + var miscellaneousMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + _emnapi_get_filename: _emnapi_get_filename + }); + + //#region src/node.ts + /** @__sig vppdp */ + function _emnapi_node_emit_async_init(async_resource, async_resource_name, trigger_async_id, result) { + if (!emnapiNodeBinding) + return; + const resource = emnapiCtx.jsValueFromNapiValue(async_resource); + const resource_name = emnapiCtx.jsValueFromNapiValue(async_resource_name); + const asyncContext = emnapiNodeBinding.node.emitAsyncInit(resource, resource_name, trigger_async_id); + const asyncId = asyncContext.asyncId; + const triggerAsyncId = asyncContext.triggerAsyncId; + if (result) { + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setFloat64(result, asyncId, true); + GET_HEAP_DATA_VIEW().setFloat64(result + 8, triggerAsyncId, true); + } + } + /** @__sig vdd */ + function _emnapi_node_emit_async_destroy(async_id, trigger_async_id) { + if (!emnapiNodeBinding) + return; + emnapiNodeBinding.node.emitAsyncDestroy({ + asyncId: async_id, + triggerAsyncId: trigger_async_id + }); + } + /* vpddp export function _emnapi_node_open_callback_scope (async_resource: napi_value, async_id: double, trigger_async_id: double, result: Pointer): void { + if (!emnapiNodeBinding || !result) return + const resource = emnapiCtx.jsValueFromNapiValue(async_resource)! + // eslint-disable-next-line @typescript-eslint/no-unused-vars + const nativeCallbackScopePointer = emnapiNodeBinding.node.openCallbackScope(resource, { + asyncId: async_id, + triggerAsyncId: trigger_async_id + }) + + from64('result') + $_TODO_makeSetValue('result', 0, 'nativeCallbackScopePointer', 'i64') + } + + vp + export function _emnapi_node_close_callback_scope (scope: Pointer): void { + if (!emnapiNodeBinding || !scope) return + from64('scope') + const nativeCallbackScopePointer = $_TODO_makeGetValue('scope', 0, 'i64') + emnapiNodeBinding.node.closeCallbackScope(BigInt(nativeCallbackScopePointer)) + } */ + /** @__sig ipppppddp */ + function _emnapi_node_make_callback(env, async_resource, cb, argv, size, async_id, trigger_async_id, result) { + let i = 0; + let v; + if (!emnapiNodeBinding) + return; + const resource = emnapiCtx.jsValueFromNapiValue(async_resource); + const callback = emnapiCtx.jsValueFromNapiValue(cb); + argv >>>= 0; + size >>>= 0; + size = size >>> 0; + const arr = Array(size); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + for (; i < size; i++) { + const argVal = GET_HEAP_DATA_VIEW().getUint32(argv + i * 4, true); + arr[i] = emnapiCtx.jsValueFromNapiValue(argVal); + } + const ret = emnapiNodeBinding.node.makeCallback(resource, callback, arr, { + asyncId: async_id, + triggerAsyncId: trigger_async_id + }); + if (result) { + result >>>= 0; + v = emnapiCtx.napiValueFromJsValue(ret); + GET_HEAP_DATA_VIEW().setUint32(result, v, true); + } + } + /** @__sig ippp */ + function _emnapi_async_init_js(async_resource, async_resource_name, result) { + if (!emnapiNodeBinding) { + return 9 /* napi_status.napi_generic_failure */; + } + let resource; + if (async_resource) { + resource = Object(emnapiCtx.jsValueFromNapiValue(async_resource)); + } + const name = emnapiCtx.jsValueFromNapiValue(async_resource_name); + const ret = emnapiNodeBinding.napi.asyncInit(resource, name); + if (ret.status !== 0) + return ret.status; + let numberValue = ret.value; + if (!((numberValue >= (BigInt(-1) * (BigInt(1) << BigInt(63)))) && (numberValue < (BigInt(1) << BigInt(63))))) { + numberValue = numberValue & ((BigInt(1) << BigInt(64)) - BigInt(1)); + if (numberValue >= (BigInt(1) << BigInt(63))) { + numberValue = numberValue - (BigInt(1) << BigInt(64)); + } + } + const low = Number(numberValue & BigInt(0xffffffff)); + const high = Number(numberValue >> BigInt(32)); + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt32(result, low, true); + GET_HEAP_DATA_VIEW().setInt32(result + 4, high, true); + return 0 /* napi_status.napi_ok */; + } + /** @__sig ip */ + function _emnapi_async_destroy_js(async_context) { + if (!emnapiNodeBinding) { + return 9 /* napi_status.napi_generic_failure */; + } + async_context >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + const low = GET_HEAP_DATA_VIEW().getInt32(async_context, true); + const high = GET_HEAP_DATA_VIEW().getInt32(async_context + 4, true); + const pointer = BigInt(low >>> 0) | (BigInt(high) << BigInt(32)); + const ret = emnapiNodeBinding.napi.asyncDestroy(pointer); + if (ret.status !== 0) + return ret.status; + return 0 /* napi_status.napi_ok */; + } + // https://github.com/nodejs/node-addon-api/pull/1283 + /** @__sig ipppp */ + function napi_open_callback_scope(env, ignored, async_context_handle, result) { + throw new Error('napi_open_callback_scope has not been implemented yet'); + } + /** @__sig ipp */ + function napi_close_callback_scope(env, scope) { + throw new Error('napi_close_callback_scope has not been implemented yet'); + } + /** @__sig ippppppp */ + function napi_make_callback(env, async_context, recv, func, argc, argv, result) { + let i = 0; + let v; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!emnapiNodeBinding) { + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + if (!recv) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (argc > 0) { + if (!argv) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + const v8recv = Object(emnapiCtx.jsValueFromNapiValue(recv)); + const v8func = emnapiCtx.jsValueFromNapiValue(func); + if (typeof v8func !== 'function') { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + async_context >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + const low = GET_HEAP_DATA_VIEW().getInt32(async_context, true); + const high = GET_HEAP_DATA_VIEW().getInt32(async_context + 4, true); + const ctx = BigInt(low >>> 0) | (BigInt(high) << BigInt(32)); + argv >>>= 0; + argc >>>= 0; + argc = argc >>> 0; + const arr = Array(argc); + for (; i < argc; i++) { + const argVal = GET_HEAP_DATA_VIEW().getUint32(argv + i * 4, true); + arr[i] = emnapiCtx.jsValueFromNapiValue(argVal); + } + const ret = emnapiNodeBinding.napi.makeCallback(ctx, v8recv, v8func, arr); + if (ret.error) { + throw ret.error; + } + if (ret.status !== 0 /* napi_status.napi_ok */) + return envObject.setLastError(ret.status); + if (result) { + result >>>= 0; + // The makeCallback call into JS above may have grown wasm memory: + // resolve v before the write (the store target is evaluated before the + // RHS, so an RHS running user JS could write through a stale heap view) + v = emnapiCtx.napiValueFromJsValue(ret.value); + GET_HEAP_DATA_VIEW().setUint32(result, v, true); + } + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig vp */ + function _emnapi_env_check_gc_access(env) { + const envObject = emnapiEnv; + envObject.checkGCAccess(); + } + + //#endregion src/node.ts + + var nodeMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + _emnapi_async_destroy_js: _emnapi_async_destroy_js, + _emnapi_async_init_js: _emnapi_async_init_js, + _emnapi_env_check_gc_access: _emnapi_env_check_gc_access, + _emnapi_node_emit_async_destroy: _emnapi_node_emit_async_destroy, + _emnapi_node_emit_async_init: _emnapi_node_emit_async_init, + _emnapi_node_make_callback: _emnapi_node_make_callback, + napi_close_callback_scope: napi_close_callback_scope, + napi_make_callback: napi_make_callback, + napi_open_callback_scope: napi_open_callback_scope + }); + + //#region src/promise.ts + /** @__sig ippp */ + function napi_create_promise(env, deferred, promise) { + let deferredObjectId, value; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!deferred) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!promise) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const resolver = emnapiCtx.createResolver(); + deferredObjectId = emnapiCtx.isolate.createReference(resolver).id; + deferred >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(deferred, deferredObjectId, true); + value = emnapiCtx.napiValueFromJsValue(resolver.promise); + promise >>>= 0; + GET_HEAP_DATA_VIEW().setUint32(promise, value, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippp */ + function napi_resolve_deferred(env, deferred, resolution) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!deferred) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!resolution) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const deferredRef = emnapiCtx.isolate.getRef(deferred); + const resolver = deferredRef.deref(); + resolver.resolve(emnapiCtx.jsValueFromNapiValue(resolution)); + deferredRef.dispose(); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippp */ + function napi_reject_deferred(env, deferred, resolution) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!deferred) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!resolution) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const deferredRef = emnapiCtx.isolate.getRef(deferred); + const resolver = deferredRef.deref(); + resolver.reject(emnapiCtx.jsValueFromNapiValue(resolution)); + deferredRef.dispose(); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippp */ + function napi_is_promise(env, value, is_promise) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!is_promise) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const promise = emnapiCtx.jsValueFromNapiValue(value); + is_promise >>>= 0; + const r = promise instanceof Promise ? 1 : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(is_promise, r, true); + return envObject.clearLastError(); + } + + //#endregion src/promise.ts + + var promiseMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + napi_create_promise: napi_create_promise, + napi_is_promise: napi_is_promise, + napi_reject_deferred: napi_reject_deferred, + napi_resolve_deferred: napi_resolve_deferred + }); + + //#region src/property.ts + /** @__sig ippiiip */ + function napi_get_all_property_names(env, object, key_mode, key_filter, key_conversion, result) { + let value; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(object); + if (jsValue == null) { + throw new TypeError('Cannot convert undefined or null to object'); + } + const type = typeof jsValue; + let obj; + try { + obj = (type === 'object' && jsValue !== null) || type === 'function' ? jsValue : Object(jsValue); + } + catch (_) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + if (key_mode !== 0 /* napi_key_collection_mode.napi_key_include_prototypes */ && key_mode !== 1 /* napi_key_collection_mode.napi_key_own_only */) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + if (key_conversion !== 0 /* napi_key_conversion.napi_key_keep_numbers */ && key_conversion !== 1 /* napi_key_conversion.napi_key_numbers_to_strings */) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + const props = []; + let names; + let symbols; + let i; + let own = true; + const integerIndiceRegex = /^(0|[1-9][0-9]*)$/; + do { + names = Object.getOwnPropertyNames(obj); + symbols = Object.getOwnPropertySymbols(obj); + for (i = 0; i < names.length; i++) { + props.push({ + name: integerIndiceRegex.test(names[i]) ? Number(names[i]) : names[i], + desc: Object.getOwnPropertyDescriptor(obj, names[i]), + own + }); + } + for (i = 0; i < symbols.length; i++) { + props.push({ + name: symbols[i], + desc: Object.getOwnPropertyDescriptor(obj, symbols[i]), + own + }); + } + if (key_mode === 1 /* napi_key_collection_mode.napi_key_own_only */) { + break; + } + obj = Object.getPrototypeOf(obj); + own = false; + } while (obj); + const ret = []; + const addName = function (ret, name, key_filter, conversion_mode) { + if (ret.indexOf(name) !== -1) + return; + if (conversion_mode === 0 /* napi_key_conversion.napi_key_keep_numbers */) { + ret.push(name); + } + else if (conversion_mode === 1 /* napi_key_conversion.napi_key_numbers_to_strings */) { + const realName = typeof name === 'number' ? String(name) : name; + if (typeof realName === 'string') { + if (!(key_filter & 8 /* napi_key_filter.napi_key_skip_strings */)) { + ret.push(realName); + } + } + else { + ret.push(realName); + } + } + }; + for (i = 0; i < props.length; i++) { + const prop = props[i]; + const name = prop.name; + const desc = prop.desc; + if (key_filter === 0 /* napi_key_filter.napi_key_all_properties */) { + addName(ret, name, key_filter, key_conversion); + } + else { + if (key_filter & 8 /* napi_key_filter.napi_key_skip_strings */ && typeof name === 'string') { + continue; + } + if (key_filter & 16 /* napi_key_filter.napi_key_skip_symbols */ && typeof name === 'symbol') { + continue; + } + let shouldAdd = true; + switch (key_filter & 7) { + case 1 /* napi_key_filter.napi_key_writable */: { + shouldAdd = Boolean(desc.writable); + break; + } + case 2 /* napi_key_filter.napi_key_enumerable */: { + shouldAdd = Boolean(desc.enumerable); + break; + } + case (1 /* napi_key_filter.napi_key_writable */ | 2 /* napi_key_filter.napi_key_enumerable */): { + shouldAdd = Boolean(desc.writable && desc.enumerable); + break; + } + case 4 /* napi_key_filter.napi_key_configurable */: { + shouldAdd = Boolean(desc.configurable); + break; + } + case (4 /* napi_key_filter.napi_key_configurable */ | 1 /* napi_key_filter.napi_key_writable */): { + shouldAdd = Boolean(desc.configurable && desc.writable); + break; + } + case (4 /* napi_key_filter.napi_key_configurable */ | 2 /* napi_key_filter.napi_key_enumerable */): { + shouldAdd = Boolean(desc.configurable && desc.enumerable); + break; + } + case (4 /* napi_key_filter.napi_key_configurable */ | 2 /* napi_key_filter.napi_key_enumerable */ | 1 /* napi_key_filter.napi_key_writable */): { + shouldAdd = Boolean(desc.configurable && desc.enumerable && desc.writable); + break; + } + } + if (shouldAdd) { + addName(ret, name, key_filter, key_conversion); + } + } + } + result >>>= 0; + value = emnapiCtx.napiValueFromJsValue(ret); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippp */ + function napi_get_property_names(env, object, result) { + return napi_get_all_property_names(env, object, 0 /* napi_key_collection_mode.napi_key_include_prototypes */, 2 /* napi_key_filter.napi_key_enumerable */ | 16 /* napi_key_filter.napi_key_skip_symbols */, 1 /* napi_key_conversion.napi_key_numbers_to_strings */, result); + } + /** @__sig ipppp */ + function napi_set_property(env, object, key, value) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!key) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(object); + const type = typeof jsValue; + if (!((type === 'object' && jsValue !== null) || type === 'function')) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + jsValue[emnapiCtx.jsValueFromNapiValue(key)] = emnapiCtx.jsValueFromNapiValue(value); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipppp */ + function napi_has_property(env, object, key, result) { + let r; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!key) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(object); + if (jsValue == null) { + throw new TypeError('Cannot convert undefined or null to object'); + } + const type = typeof jsValue; + let v; + try { + v = (type === 'object' && jsValue !== null) || type === 'function' ? jsValue : Object(jsValue); + } + catch (_) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + result >>>= 0; + r = (emnapiCtx.jsValueFromNapiValue(key) in v) ? 1 : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(result, r, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipppp */ + function napi_get_property(env, object, key, result) { + let value; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!key) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(object); + if (jsValue == null) { + throw new TypeError('Cannot convert undefined or null to object'); + } + const type = typeof jsValue; + let v; + try { + v = (type === 'object' && jsValue !== null) || type === 'function' ? jsValue : Object(jsValue); + } + catch (_) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + result >>>= 0; + value = emnapiCtx.napiValueFromJsValue(v[emnapiCtx.jsValueFromNapiValue(key)]); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipppp */ + function napi_delete_property(env, object, key, result) { + let r; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!key) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(object); + const type = typeof jsValue; + if (!((type === 'object' && jsValue !== null) || type === 'function')) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + const propertyKey = emnapiCtx.jsValueFromNapiValue(key); + if (emnapiCtx.features.Reflect) { + r = emnapiCtx.features.Reflect.deleteProperty(jsValue, propertyKey); + } + else { + try { + r = delete jsValue[propertyKey]; + } + catch (_) { + r = false; + } + } + if (result) { + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(result, r ? 1 : 0, true); + } + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipppp */ + function napi_has_own_property(env, object, key, result) { + let r; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!key) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(object); + if (jsValue == null) { + throw new TypeError('Cannot convert undefined or null to object'); + } + const type = typeof jsValue; + let v; + try { + v = ((type === 'object' && jsValue !== null) || type !== 'function') ? jsValue : Object(jsValue); + } + catch (_) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + const prop = emnapiCtx.jsValueFromNapiValue(key); + if (typeof prop !== 'string' && typeof prop !== 'symbol') { + return envObject.setLastError(4 /* napi_status.napi_name_expected */); + } + r = Object.prototype.hasOwnProperty.call(v, emnapiCtx.jsValueFromNapiValue(key)); + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(result, r ? 1 : 0, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipppp */ + function napi_set_named_property(env, object, cname, value) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(object); + const type = typeof jsValue; + if (!(((type === 'object' && jsValue !== null) || type === 'function'))) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + if (!cname) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + cname >>>= 0; + emnapiCtx.jsValueFromNapiValue(object)[emnapiString.UTF8ToString(cname, -1)] = emnapiCtx.jsValueFromNapiValue(value); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipppp */ + function napi_has_named_property(env, object, utf8name, result) { + let r; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!utf8name) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + const jsValue = emnapiCtx.jsValueFromNapiValue(object); + if (jsValue == null) { + throw new TypeError('Cannot convert undefined or null to object'); + } + const type = typeof jsValue; + let v; + try { + v = ((type === 'object' && jsValue !== null) || type === 'function') ? jsValue : Object(jsValue); + } + catch (_) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + utf8name >>>= 0; + result >>>= 0; + r = emnapiString.UTF8ToString(utf8name, -1) in v; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(result, r ? 1 : 0, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipppp */ + function napi_get_named_property(env, object, utf8name, result) { + let value; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!utf8name) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + const jsValue = emnapiCtx.jsValueFromNapiValue(object); + if (jsValue == null) { + throw new TypeError('Cannot convert undefined or null to object'); + } + const type = typeof jsValue; + let v; + try { + v = ((type === 'object' && jsValue !== null) || type === 'function') ? jsValue : Object(jsValue); + } + catch (_) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + utf8name >>>= 0; + result >>>= 0; + value = emnapiCtx.napiValueFromJsValue(v[emnapiString.UTF8ToString(utf8name, -1)]); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippip */ + function napi_set_element(env, object, index, value) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(object); + const type = typeof jsValue; + if (!(((type === 'object' && jsValue !== null) || type === 'function'))) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + jsValue[index >>> 0] = emnapiCtx.jsValueFromNapiValue(value); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippip */ + function napi_has_element(env, object, index, result) { + let r; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(object); + if (jsValue == null) { + throw new TypeError('Cannot convert undefined or null to object'); + } + let v; + const type = typeof jsValue; + try { + v = ((type === 'object' && jsValue !== null) || type === 'function') ? jsValue : Object(jsValue); + } + catch (_) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + result >>>= 0; + r = ((index >>> 0) in v) ? 1 : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(result, r, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippip */ + function napi_get_element(env, object, index, result) { + let value; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(object); + if (jsValue == null) { + throw new TypeError('Cannot convert undefined or null to object'); + } + const type = typeof jsValue; + let v; + try { + v = ((type === 'object' && jsValue !== null) || type === 'function') ? jsValue : Object(jsValue); + } + catch (_) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + result >>>= 0; + value = emnapiCtx.napiValueFromJsValue(v[index >>> 0]); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippip */ + function napi_delete_element(env, object, index, result) { + let r; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(object); + const type = typeof jsValue; + if (!(((type === 'object' && jsValue !== null) || type === 'function'))) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + if (emnapiCtx.features.Reflect) { + r = emnapiCtx.features.Reflect.deleteProperty(jsValue, index >>> 0); + } + else { + try { + r = delete jsValue[index >>> 0]; + } + catch (_) { + r = false; + } + } + if (result) { + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(result, r ? 1 : 0, true); + } + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipppp */ + function napi_define_properties(env, object, property_count, properties) { + let propPtr, attributes; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + properties >>>= 0; + property_count >>>= 0; + property_count = property_count >>> 0; + if (property_count > 0) { + if (!properties) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const maybeObject = emnapiCtx.jsValueFromNapiValue(object); + const type = typeof maybeObject; + if (!((type === 'object' && maybeObject !== null) || type === 'function')) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + let propertyName; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + for (let i = 0; i < property_count; i++) { + propPtr = properties + (i * (4 * 8)); + const utf8Name = GET_HEAP_DATA_VIEW().getUint32(propPtr, true); + const name = GET_HEAP_DATA_VIEW().getUint32(propPtr + 4, true); + const method = GET_HEAP_DATA_VIEW().getUint32(propPtr + 8, true); + const getter = GET_HEAP_DATA_VIEW().getUint32(propPtr + 12, true); + const setter = GET_HEAP_DATA_VIEW().getUint32(propPtr + 16, true); + const value = GET_HEAP_DATA_VIEW().getUint32(propPtr + 20, true); + attributes = GET_HEAP_DATA_VIEW().getInt32(propPtr + 24, true); + attributes >>>= 0; + const data = GET_HEAP_DATA_VIEW().getUint32(propPtr + 28, true); + if (utf8Name) { + propertyName = emnapiString.UTF8ToString(utf8Name, -1); + } + else { + if (!name) { + return envObject.setLastError(4 /* napi_status.napi_name_expected */); + } + propertyName = emnapiCtx.jsValueFromNapiValue(name); + if (typeof propertyName !== 'string' && typeof propertyName !== 'symbol') { + return envObject.setLastError(4 /* napi_status.napi_name_expected */); + } + } + emnapiDefineProperty(envObject, maybeObject, propertyName, method, getter, setter, value, attributes, data); + } + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipp */ + function napi_object_freeze(env, object) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const maybeObject = emnapiCtx.jsValueFromNapiValue(object); + const type = typeof maybeObject; + if (!(((type === 'object' && maybeObject !== null) || type === 'function'))) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + Object.freeze(maybeObject); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipp */ + function napi_object_seal(env, object) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const maybeObject = emnapiCtx.jsValueFromNapiValue(object); + const type = typeof maybeObject; + if (!(((type === 'object' && maybeObject !== null) || type === 'function'))) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + Object.seal(maybeObject); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + + //#endregion src/property.ts + + var propertyMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + napi_define_properties: napi_define_properties, + napi_delete_element: napi_delete_element, + napi_delete_property: napi_delete_property, + napi_get_all_property_names: napi_get_all_property_names, + napi_get_element: napi_get_element, + napi_get_named_property: napi_get_named_property, + napi_get_property: napi_get_property, + napi_get_property_names: napi_get_property_names, + napi_has_element: napi_has_element, + napi_has_named_property: napi_has_named_property, + napi_has_own_property: napi_has_own_property, + napi_has_property: napi_has_property, + napi_object_freeze: napi_object_freeze, + napi_object_seal: napi_object_seal, + napi_set_element: napi_set_element, + napi_set_named_property: napi_set_named_property, + napi_set_property: napi_set_property + }); + + //#region src/script.ts + /** + * @__sig ippp + */ + function napi_run_script(env, script, result) { + let status; + let value; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!script) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const v8Script = emnapiCtx.jsValueFromNapiValue(script); + if (typeof v8Script !== 'string') { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + const g = emnapiCtx.jsValueFromNapiValue(6 /* Constant.GLOBAL */); + const ret = g.eval(v8Script); + result >>>= 0; + value = emnapiCtx.napiValueFromJsValue(ret); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + status = (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + return status; + } + + //#endregion src/script.ts + + var scriptMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + napi_run_script: napi_run_script + }); + + //#region src/value-operation.ts + /** @__sig ippp */ + function napi_typeof(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const v = emnapiCtx.jsValueFromNapiValue(value); + const type = typeof v; + result >>>= 0; + let r; + if (type === 'number') { + r = 3 /* napi_valuetype.napi_number */; + } + else if (type === 'bigint') { + r = 9 /* napi_valuetype.napi_bigint */; + } + else if (type === 'string') { + r = 4 /* napi_valuetype.napi_string */; + } + else if (type === 'function') { + // This test has to come before IsObject because IsFunction + // implies IsObject + r = 7 /* napi_valuetype.napi_function */; + } + else if (emnapiCtx.isExternal(v)) { + // This test has to come before IsObject because IsExternal + // implies IsObject + r = 8 /* napi_valuetype.napi_external */; + } + else if (type === 'object' && v !== null) { + r = 6 /* napi_valuetype.napi_object */; + } + else if (type === 'boolean') { + r = 2 /* napi_valuetype.napi_boolean */; + } + else if (type === 'undefined') { + r = 0 /* napi_valuetype.napi_undefined */; + } + else if (type === 'symbol') { + r = 5 /* napi_valuetype.napi_symbol */; + } + else if (v === null) { + r = 1 /* napi_valuetype.napi_null */; + } + else { + // Should not get here unless V8 has added some new kind of value. + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt32(result, r, true); + return envObject.clearLastError(); + } + /** @__sig ippp */ + function napi_coerce_to_bool(env, value, result) { + let v; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + result >>>= 0; + v = jsValue ? 5 /* Constant.TRUE */ : 4 /* Constant.FALSE */; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, v, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippp */ + function napi_coerce_to_number(env, value, result) { + let v; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + if (typeof jsValue === 'bigint') { + throw new TypeError('Cannot convert a BigInt value to a number'); + } + result >>>= 0; + v = emnapiCtx.napiValueFromJsValue(Number(jsValue)); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, v, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippp */ + function napi_coerce_to_object(env, value, result) { + let v; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + if (jsValue == null) { + throw new TypeError('Cannot convert undefined or null to object'); + } + result >>>= 0; + v = emnapiCtx.napiValueFromJsValue(Object(jsValue)); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, v, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippp */ + function napi_coerce_to_string(env, value, result) { + let v; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + if (typeof jsValue === 'symbol') { + throw new TypeError('Cannot convert a Symbol value to a string'); + } + result >>>= 0; + v = emnapiCtx.napiValueFromJsValue(String(jsValue)); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, v, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipppp */ + function napi_instanceof(env, object, constructor, result) { + let r; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!constructor) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(result, 0, true); + const ctor = emnapiCtx.jsValueFromNapiValue(constructor); + if (typeof ctor !== 'function') { + return envObject.setLastError(5 /* napi_status.napi_function_expected */); + } + const val = emnapiCtx.jsValueFromNapiValue(object); + const ret = val instanceof ctor; + r = ret ? 1 : 0; + GET_HEAP_DATA_VIEW().setInt8(result, r, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippp */ + function napi_is_array(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + result >>>= 0; + const r = Array.isArray(jsValue) ? 1 : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(result, r, true); + return envObject.clearLastError(); + } + /** @__sig ippp */ + function napi_is_arraybuffer(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const h = emnapiCtx.jsValueFromNapiValue(value); + result >>>= 0; + const r = h instanceof ArrayBuffer ? 1 : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(result, r, true); + return envObject.clearLastError(); + } + /** @__sig ippp */ + function node_api_is_sharedarraybuffer(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const h = emnapiCtx.jsValueFromNapiValue(value); + result >>>= 0; + const r = ((typeof SharedArrayBuffer === 'function' && h instanceof SharedArrayBuffer) || + (Object.prototype.toString.call(h) === '[object SharedArrayBuffer]')) + ? 1 + : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(result, r, true); + return envObject.clearLastError(); + } + /** @__sig ippp */ + function napi_is_date(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const h = emnapiCtx.jsValueFromNapiValue(value); + result >>>= 0; + const r = h instanceof Date ? 1 : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(result, r, true); + return envObject.clearLastError(); + } + /** @__sig ippp */ + function napi_is_error(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const val = emnapiCtx.jsValueFromNapiValue(value); + result >>>= 0; + const r = (val instanceof Error) ? 1 : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(result, r, true); + return envObject.clearLastError(); + } + /** @__sig ippp */ + function napi_is_typedarray(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const h = emnapiCtx.jsValueFromNapiValue(value); + result >>>= 0; + const r = (ArrayBuffer.isView(h)) && !(h instanceof DataView) ? 1 : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(result, r, true); + return envObject.clearLastError(); + } + /** @__sig ippp */ + function napi_is_buffer(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const h = emnapiCtx.jsValueFromNapiValue(value); + result >>>= 0; + const Buffer = emnapiCtx.features.Buffer; + const r = (ArrayBuffer.isView(h) || (typeof Buffer === 'function' && Buffer.isBuffer(h))) ? 1 : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(result, r, true); + return envObject.clearLastError(); + } + /** @__sig ippp */ + function napi_is_dataview(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const h = emnapiCtx.jsValueFromNapiValue(value); + result >>>= 0; + const r = h instanceof DataView ? 1 : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(result, r, true); + return envObject.clearLastError(); + } + /** @__sig ipppp */ + function napi_strict_equals(env, lhs, rhs, result) { + let r; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!lhs) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!rhs) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const lv = emnapiCtx.jsValueFromNapiValue(lhs); + const rv = emnapiCtx.jsValueFromNapiValue(rhs); + result >>>= 0; + r = (lv === rv) ? 1 : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(result, r, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipp */ + function napi_detach_arraybuffer(env, arraybuffer) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!arraybuffer) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const value = emnapiCtx.jsValueFromNapiValue(arraybuffer); + if (!(value instanceof ArrayBuffer)) { + if (typeof SharedArrayBuffer === 'function' && (value instanceof SharedArrayBuffer)) { + return envObject.setLastError(20 /* napi_status.napi_detachable_arraybuffer_expected */); + } + return envObject.setLastError(19 /* napi_status.napi_arraybuffer_expected */); + } + try { + const MessageChannel = emnapiCtx.features.MessageChannel; + const messageChannel = new MessageChannel(); + messageChannel.port1.postMessage(value, [value]); + } + catch (_) { + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + return envObject.clearLastError(); + } + /** @__sig ippp */ + function napi_is_detached_arraybuffer(env, arraybuffer, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!arraybuffer) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const h = emnapiCtx.jsValueFromNapiValue(arraybuffer); + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + if (h instanceof ArrayBuffer && h.byteLength === 0) { + try { + // eslint-disable-next-line no-new + new Uint8Array(h); + } + catch (_) { + GET_HEAP_DATA_VIEW().setInt8(result, 1, true); + return (0 /* napi_status.napi_ok */); + } + } + GET_HEAP_DATA_VIEW().setInt8(result, 0, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + + //#endregion src/value-operation.ts + + var valueOperationMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + napi_coerce_to_bool: napi_coerce_to_bool, + napi_coerce_to_number: napi_coerce_to_number, + napi_coerce_to_object: napi_coerce_to_object, + napi_coerce_to_string: napi_coerce_to_string, + napi_detach_arraybuffer: napi_detach_arraybuffer, + napi_instanceof: napi_instanceof, + napi_is_array: napi_is_array, + napi_is_arraybuffer: napi_is_arraybuffer, + napi_is_buffer: napi_is_buffer, + napi_is_dataview: napi_is_dataview, + napi_is_date: napi_is_date, + napi_is_detached_arraybuffer: napi_is_detached_arraybuffer, + napi_is_error: napi_is_error, + napi_is_typedarray: napi_is_typedarray, + napi_strict_equals: napi_strict_equals, + napi_typeof: napi_typeof, + node_api_is_sharedarraybuffer: node_api_is_sharedarraybuffer + }); + + //#region src/version.ts + /** @__sig ipp */ + function napi_get_version(env, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + const envObject = emnapiEnv; + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const NODE_API_SUPPORTED_VERSION_MAX = 10 /* Version.NODE_API_SUPPORTED_VERSION_MAX */; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, NODE_API_SUPPORTED_VERSION_MAX, true); + return envObject.clearLastError(); + } + + //#endregion src/version.ts + + var versionMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + napi_get_version: napi_get_version + }); + + //#region src/core/index.ts + emnapiExternalMemory.init(); + emnapiExternalSAB.init(); + emnapiString.init(); + // emnapiTSFN.init() + PThread.init(); + napiModule.emnapi.syncMemory = $emnapiSyncMemory; + napiModule.emnapi.getMemoryAddress = $emnapiGetMemoryAddress; + napiModule.emnapi.acquireExternalSharedArrayBuffer = $emnapiAcquireExternalSharedArrayBuffer; + function addImports(mod) { + const keys = Object.keys(mod); + for (let i = 0; i < keys.length; ++i) { + const k = keys[i]; + if (k.indexOf('$') === 0) + continue; + if (k.indexOf('emnapi_') === 0) { + napiModule.imports.emnapi[k] = mod[k]; + } + else if (k.indexOf('_emnapi_') === 0 || k.indexOf('_v8_') === 0 || k === 'napi_set_last_error' || k === 'napi_clear_last_error') { + napiModule.imports.env[k] = mod[k]; + } + else { + napiModule.imports.napi[k] = mod[k]; + } + } + } + addImports(asyncMod); + addImports(memoryMod); + addImports(utilMod); + addImports(convert2cMod); + addImports(convert2napiMod); + addImports(createMod); + addImports(globalMod); + addImports(wrapMod); + addImports(envMod); + addImports(emnapiMod); + addImports(errorMod); + addImports(functionMod); + addImports(lifeMod); + addImports(miscellaneousMod); + addImports(nodeMod); + addImports(promiseMod); + addImports(propertyMod); + addImports(scriptMod); + addImports(valueOperationMod); + addImports(versionMod); + // napiModule.imports.napi.napi_create_threadsafe_function = napi_create_threadsafe_function + // napiModule.imports.napi.napi_get_threadsafe_function_context = napi_get_threadsafe_function_context + // napiModule.imports.napi.napi_call_threadsafe_function = napi_call_threadsafe_function + // napiModule.imports.napi.napi_acquire_threadsafe_function = napi_acquire_threadsafe_function + // napiModule.imports.napi.napi_release_threadsafe_function = napi_release_threadsafe_function + // napiModule.imports.napi.napi_unref_threadsafe_function = napi_unref_threadsafe_function + // napiModule.imports.napi.napi_ref_threadsafe_function = napi_ref_threadsafe_function + const pluginCtx = { + emnapiString + }; + Object.keys(initMod).forEach(k => { + Object.defineProperty(pluginCtx, k, { + get: () => initMod[k], + enumerable: true, + configurable: true + }); + }); + Object.keys(nodeMod).forEach(k => { + Object.defineProperty(pluginCtx, k, { + get: () => nodeMod[k], + enumerable: true, + configurable: true + }); + }); + Object.keys(utilMod).forEach(k => { + Object.defineProperty(pluginCtx, k, { + get: () => utilMod[k], + enumerable: true, + configurable: true + }); + }); + napiModule.plugins = (options.plugins ?? []).map((plugin) => { + if (typeof plugin === 'function') { + return plugin(pluginCtx); + } + if (typeof plugin === 'object' && plugin !== null) { + return plugin; + } + throw new TypeError('Invalid plugin'); + }); + napiModule.plugins.forEach((plugin) => { + if (typeof plugin.importObject === 'function') { + const importObject = plugin.importObject(napiModule.imports); + if (importObject) { + napiModule.imports = importObject; + } + } + }); + var index = napiModule; + + //#endregion src/core/index.ts + + return index; + +})(); + return napiModule; +} + +//#endregion src/emnapi/index.js + +//#region src/load.ts +function loadNapiModuleImpl(loadFn, userNapiModule, wasmInput, options) { + options = options ?? {}; + const getMemory = options.getMemory; + const getTable = options.getTable; + const beforeInit = options.beforeInit; + if (getMemory != null && typeof getMemory !== 'function') { + throw new TypeError('options.getMemory is not a function'); + } + if (getTable != null && typeof getTable !== 'function') { + throw new TypeError('options.getTable is not a function'); + } + if (beforeInit != null && typeof beforeInit !== 'function') { + throw new TypeError('options.beforeInit is not a function'); + } + let napiModule; + const isLoad = typeof userNapiModule === 'object' && userNapiModule !== null; + if (isLoad) { + if (userNapiModule.loaded) { + throw new Error('napiModule has already loaded'); + } + napiModule = userNapiModule; + } + else { + napiModule = createNapiModule(options); + } + const wasi = options.wasi; + let wasiThreads; + let importObject = { + env: napiModule.imports.env, + napi: napiModule.imports.napi, + emnapi: napiModule.imports.emnapi + }; + if (wasi) { + wasiThreads = new WASIThreads(napiModule.childThread + ? { + wasi, + childThread: true, + postMessage: napiModule.postMessage + } + : { + wasi, + threadManager: napiModule.PThread, + waitThreadStart: napiModule.waitThreadStart + }); + Object.assign(importObject, typeof wasi.getImportObject === 'function' + ? wasi.getImportObject() + : { wasi_snapshot_preview1: wasi.wasiImport }); + Object.assign(importObject, wasiThreads.getImportObject()); + } + const overwriteImports = options.overwriteImports; + if (typeof overwriteImports === 'function') { + const newImportObject = overwriteImports(importObject); + if (typeof newImportObject === 'object' && newImportObject !== null) { + importObject = newImportObject; + } + } + return loadFn(wasmInput, importObject, (err, source) => { + if (err) { + throw err; + } + const originalInstance = source.instance; + let instance = originalInstance; + const originalExports = originalInstance.exports; + const exportMemory = 'memory' in originalExports; + const importMemory = 'memory' in importObject.env; + const memory = getMemory + ? getMemory(originalExports) + : exportMemory + ? originalExports.memory + : importMemory + ? importObject.env.memory + : undefined; + if (!memory) { + throw new Error('memory is neither exported nor imported'); + } + const table = getTable ? getTable(originalExports) : originalExports.__indirect_function_table; + if (wasi && !exportMemory) { + const exports = Object.create(null); + Object.assign(exports, originalExports, { memory }); + instance = { exports }; + } + const module = source.module; + if (wasi) { + instance = wasiThreads.initialize(instance, module, memory); + } + else { + napiModule.PThread.setup(module, memory); + } + const emnapiInit = () => { + if (beforeInit) { + beforeInit({ + instance: originalInstance, + module + }); + } + napiModule.init({ + instance, + module, + memory, + table + }); + const ret = { + instance: originalInstance, + module, + usedInstance: instance + }; + if (!isLoad) { + ret.napiModule = napiModule; + } + return ret; + }; + if (napiModule.PThread.shouldPreloadWorkers()) { + const poolReady = napiModule.PThread.loadWasmModuleToAllWorkers(); + if (loadFn === loadCallback) { + return poolReady.then(emnapiInit); + } + else { + throw new Error('Synchronous loading is not supported with worker pool (reuseWorker.size > 0)'); + } + } + return emnapiInit(); + }); +} +function loadCallback(wasmInput, importObject, callback) { + return load(wasmInput, importObject).then((source) => { + return callback(null, source); + }, err => { + return callback(err); + }); +} +function loadSyncCallback(wasmInput, importObject, callback) { + let source; + try { + source = loadSync(wasmInput, importObject); + } + catch (err) { + return callback(err); + } + return callback(null, source); +} +function loadNapiModule(napiModule, wasmInput, options) { + if (typeof napiModule !== 'object' || napiModule === null) { + throw new TypeError('Invalid napiModule'); + } + return loadNapiModuleImpl(loadCallback, napiModule, wasmInput, options); +} +function loadNapiModuleSync(napiModule, wasmInput, options) { + if (typeof napiModule !== 'object' || napiModule === null) { + throw new TypeError('Invalid napiModule'); + } + return loadNapiModuleImpl(loadSyncCallback, napiModule, wasmInput, options); +} +function instantiateNapiModule(wasmInput, options) { + return loadNapiModuleImpl(loadCallback, undefined, wasmInput, options); +} +function instantiateNapiModuleSync(wasmInput, options) { + return loadNapiModuleImpl(loadSyncCallback, undefined, wasmInput, options); +} + +//#endregion src/load.ts + +//#region src/worker.ts +class MessageHandler extends ThreadMessageHandler { + constructor(options) { + if (typeof options.onLoad !== 'function') { + throw new TypeError('options.onLoad is not a function'); + } + const userOnError = options.onError; + super({ + ...options, + onError: (err, type) => { + const emnapi_thread_crashed = this.instance?.exports.emnapi_thread_crashed; + if (typeof emnapi_thread_crashed === 'function') { + emnapi_thread_crashed(); + } + if (typeof userOnError === 'function') { + userOnError(err, type); + } + else { + throw err; + } + } + }); + this.napiModule = undefined; + } + instantiate(data) { + const source = this.onLoad(data); + const then = source.then; + if (typeof then === 'function') { + return source.then((result) => { + this.napiModule = result.napiModule; + return result; + }); + } + this.napiModule = source.napiModule; + return source; + } + handle(e) { + super.handle(e); + if (e?.data?.__emnapi__) { + const type = e.data.__emnapi__.type; + const payload = e.data.__emnapi__.payload; + try { + if (type === 'async-worker-init') { + this.handleAfterLoad(e, () => { + this.napiModule.initWorker(payload.arg, payload.func); + }); + } + } + catch (err) { + this.onError(err, type); + } + } + } +} + +//#endregion src/worker.ts + +//#region src/index.ts +const version = "2.0.0-alpha.3"; + +//#endregion src/index.ts + +export { MessageHandler, ThreadManager, ThreadMessageHandler, WASIThreads, createInstanceProxy, createNapiModule, instantiateNapiModule, instantiateNapiModuleSync, isSharedArrayBuffer, isTrapError, loadNapiModule, loadNapiModuleSync, version }; diff --git a/client/node_modules/@emnapi/core/dist/emnapi-core.js b/client/node_modules/@emnapi/core/dist/emnapi-core.js new file mode 100644 index 0000000..f205746 --- /dev/null +++ b/client/node_modules/@emnapi/core/dist/emnapi-core.js @@ -0,0 +1,7227 @@ +import { ThreadManager, WASIThreads, ThreadMessageHandler } from '@emnapi/wasi-threads'; +export * from '@emnapi/wasi-threads'; + +//#region src/util.ts +const _WebAssembly = typeof WebAssembly !== 'undefined' + ? WebAssembly + : typeof WXWebAssembly !== 'undefined' + ? WXWebAssembly + : undefined; +function validateImports(imports) { + if (imports && typeof imports !== 'object') { + throw new TypeError('imports must be an object or undefined'); + } + return true; +} +function load(wasmInput, imports) { + if (!wasmInput) + throw new TypeError('Invalid wasm source'); + validateImports(imports); + imports = imports ?? {}; + try { + const then = typeof wasmInput === 'object' && wasmInput !== null && 'then' in wasmInput ? wasmInput.then : undefined; + if (typeof then === 'function') { + return then.call(wasmInput, (input) => load(input, imports)); + } + } + catch (_) { } + if (wasmInput instanceof ArrayBuffer || ArrayBuffer.isView(wasmInput)) { + return _WebAssembly.instantiate(wasmInput, imports); + } + if (wasmInput instanceof _WebAssembly.Module) { + return _WebAssembly.instantiate(wasmInput, imports).then((instance) => { + return { instance, module: wasmInput }; + }); + } + if (typeof Response !== 'undefined' && wasmInput instanceof Response) { + return wasmInput.arrayBuffer().then(buffer => { + return _WebAssembly.instantiate(buffer, imports); + }); + } + const inputIsString = typeof wasmInput === 'string'; + if (inputIsString || (typeof URL !== 'undefined' && wasmInput instanceof URL)) { + if (inputIsString && typeof wx !== 'undefined' && typeof __wxConfig !== 'undefined') { + return _WebAssembly.instantiate(wasmInput, imports); + } + if (typeof fetch !== 'function') { + throw new TypeError('wasm source can not be a string or URL in this environment'); + } + if (typeof _WebAssembly.instantiateStreaming === 'function') { + try { + return _WebAssembly.instantiateStreaming(fetch(wasmInput), imports).catch(() => { + return load(fetch(wasmInput), imports); + }); + } + catch (_) { + return load(fetch(wasmInput), imports); + } + } + else { + return load(fetch(wasmInput), imports); + } + } + throw new TypeError('Invalid wasm source'); +} +function loadSync(wasmInput, imports) { + if (!wasmInput) + throw new TypeError('Invalid wasm source'); + validateImports(imports); + imports = imports ?? {}; + let module; + if ((wasmInput instanceof ArrayBuffer) || ArrayBuffer.isView(wasmInput)) { + module = new _WebAssembly.Module(wasmInput); + } + else if (wasmInput instanceof WebAssembly.Module) { + module = wasmInput; + } + else { + throw new TypeError('Invalid wasm source'); + } + const instance = new _WebAssembly.Instance(module, imports); + const source = { instance, module }; + return source; +} + +//#endregion src/util.ts + +//#region src/emnapi/index.js + +function createNapiModule (options) { + var napiModule = (function () { + + //#region src/core/addfunction.ts + // This gives correct answers for everything less than 2^{14} = 16384 + // I hope nobody is contemplating functions with 16384 arguments... + function uleb128EncodeWithLen(arr) { + const n = arr.length; + // Note: this LEB128 length encoding produces extra byte for n < 128, + // but we don't care as it's only used in a temporary representation. + return [(n % 128) | 128, n >> 7, ...arr]; + } + // Converts a signature like 'vii' into a description of the wasm types, like + // { parameters: ['i32', 'i32'], results: [] }. + function sigToWasmTypes(sig) { + const typeNames = { + i: 'i32', + j: 'i64', + f: 'f32', + d: 'f64', + e: 'externref', + p: 'i32', + }; + const type = { + parameters: [], + results: sig[0] === 'v' ? [] : [typeNames[sig[0]]] + }; + for (let i = 1; i < sig.length; ++i) { + type.parameters.push(typeNames[sig[i]]); + } + return type; + } + // Note: using template literal here instead of plain object + // because jsify serializes objects w/o quotes and Closure will then + // incorrectly mangle the properties. + const wasmTypeCodes = (function () { + const map = { + i: 0x7f, // i32 + p: 0x7f, + j: 0x7e, // i64 + f: 0x7d, // f32 + d: 0x7c, // f64 + e: 0x6f, // externref + }; + return map; + })(); + function generateTypePack(types) { + return uleb128EncodeWithLen(Array.from(types, (type) => { + const code = wasmTypeCodes[type]; + return code; + })); + } + function convertJsFunctionToWasm(func, sig) { + if (_WebAssembly.Function) { + return new _WebAssembly.Function(sigToWasmTypes(sig), func); + } + // Rest of the module is static + const bytes = Uint8Array.of(0x00, 0x61, 0x73, 0x6d, // magic ("\0asm") + 0x01, 0x00, 0x00, 0x00, // version: 1 + 0x01, // Type section code + // The module is static, with the exception of the type section, which is + // generated based on the signature passed in. + ...uleb128EncodeWithLen([ + 0x01, // count: 1 + 0x60 /* form: func */, + // param types + ...generateTypePack(sig.slice(1)), + // return types (for now only supporting [] if `void` and single [T] otherwise) + ...generateTypePack(sig[0] === 'v' ? '' : sig[0]) + ]), + // The rest of the module is static + 0x02, 0x07, // import section + // (import "e" "f" (func 0 (type 0))) + 0x01, 0x01, 0x65, 0x01, 0x66, 0x00, 0x00, 0x07, 0x05, // export section + // (export "f" (func 0 (type 0))) + 0x01, 0x01, 0x66, 0x00, 0x00); + // We can compile this wasm module synchronously because it is very small. + // This accepts an import (at "e.f"), that it reroutes to an export (at "f") + const module = new _WebAssembly.Module(bytes); + const instance = new _WebAssembly.Instance(module, { e: { f: func } }); + const wrappedFunc = instance.exports['f']; + return wrappedFunc; + } + const freeTableIndexes = []; + // Weak map of functions in the table to their indexes, created on first use. + let functionsInTableMap; + function getEmptyTableSlot() { + // Reuse a free index if there is one, otherwise grow. + if (freeTableIndexes.length) { + return freeTableIndexes.pop(); + } + try { + // Grow the table + return wasmTable.grow(1); + } + catch (err) { + if (!(err instanceof RangeError)) { + throw err; + } + throw new Error('Unable to grow wasm table. Specify `--growable-table` for wasm-ld.'); + } + } + function updateTableMap(offset, count) { + if (functionsInTableMap) { + for (let i = offset; i < offset + count; i++) { + const item = getWasmTableEntry(i); + // Ignore null values. + if (item) { + functionsInTableMap.set(item, i); + } + } + } + } + function getFunctionAddress(func) { + // First, create the map if this is the first use. + if (!functionsInTableMap) { + functionsInTableMap = new WeakMap(); + let count = wasmTable.length; + count >>>= 0; + updateTableMap(0, count); + } + return functionsInTableMap.get(func) || 0; + } + /** + * Add a function to the table. + * 'sig' parameter is required if the function being added is a JS function. + */ + function addFunction(func, sig) { + // Check if the function is already in the table, to ensure each function + // gets a unique index. + let rtn = getFunctionAddress(func); + if (rtn) { + return rtn; + } + // It's not in the table, add it now. + const ret = getEmptyTableSlot(); + // Set the new value. + try { + // Attempting to call this with JS function will cause table.set() to fail + setWasmTableEntry(ret, func); + } + catch (err) { + if (!(err instanceof TypeError)) { + throw err; + } + if (!sig) { + throw new Error('Missing signature argument to addFunction: ' + func); + } + const wrapped = convertJsFunctionToWasm(func, sig); + setWasmTableEntry(ret, wrapped); + } + functionsInTableMap.set(func, ret); + return ret; + } + function removeFunction(index) { + if (!functionsInTableMap) + return; + functionsInTableMap.delete(getWasmTableEntry(index)); + setWasmTableEntry(index, null); + freeTableIndexes.push(index); + } + + //#endregion src/core/addfunction.ts + + //#region src/core/init.ts + var ENVIRONMENT_IS_NODE = typeof process === 'object' && process !== null && typeof process.versions === 'object' && process.versions !== null && typeof process.versions.node === 'string'; + var ENVIRONMENT_IS_PTHREAD = Boolean(options.childThread); + var waitThreadStart = typeof options.waitThreadStart === 'number' ? options.waitThreadStart : Boolean(options.waitThreadStart); + var wasmInstance; + var wasmModule; + var wasmMemory; + var wasmTable; + var _malloc; + var _free; + var _emnapi_create_env; + var _emnapi_delete_env; + function abort(msg) { + if (typeof _WebAssembly.RuntimeError === 'function') { + throw new _WebAssembly.RuntimeError(msg); + } + throw Error(msg); + } + function runtimeKeepalivePush() { } + function runtimeKeepalivePop() { } + function getWasmTableEntry(index) { + return wasmTable.get(index); + } + function setWasmTableEntry(index, func) { + wasmTable.set(index, func); + } + function setLastError(env, error_code, engine_error_code, engine_reserved) { + env >>>= 0; + env -= 8; + engine_reserved >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt32(env + 40 /* NapiEnvOffset32.last_error_error_code */, error_code, true); + GET_HEAP_DATA_VIEW().setUint32(env + 36 /* NapiEnvOffset32.last_error_engine_error_code */, engine_error_code, true); + GET_HEAP_DATA_VIEW().setUint32(env + 32 /* NapiEnvOffset32.last_error_engine_reserved */, engine_reserved, true); + return error_code; + } + var napiModule = { + imports: { + env: {}, + napi: {}, + emnapi: {} + }, + exports: {}, + emnapi: {}, + loaded: false, + filename: '', + childThread: ENVIRONMENT_IS_PTHREAD, + initWorker: undefined, + waitThreadStart, + PThread: undefined, + init(options) { + if (napiModule.loaded) + return napiModule.exports; + if (!options) + throw new TypeError('Invalid napi init options'); + const instance = options.instance; + if (!instance?.exports) + throw new TypeError('Invalid wasm instance'); + wasmInstance = instance; + const exports = instance.exports; + const module = options.module; + const memory = options.memory || exports.memory; + const table = options.table || exports.__indirect_function_table; + if (!(module instanceof _WebAssembly.Module)) + throw new TypeError('Invalid wasm module'); + if (!(memory instanceof _WebAssembly.Memory)) + throw new TypeError('Invalid wasm memory'); + if (!(table instanceof _WebAssembly.Table)) + throw new TypeError('Invalid wasm table'); + wasmModule = module; + wasmMemory = memory; + wasmTable = table; + if (typeof exports.malloc !== 'function') + throw new TypeError('malloc is not exported'); + if (typeof exports.free !== 'function') + throw new TypeError('free is not exported'); + _malloc = exports.malloc; + _free = exports.free; + _emnapi_create_env = exports.emnapi_create_env; + _emnapi_delete_env = exports.emnapi_delete_env; + if (!napiModule.childThread) { + // main thread only + const NODE_MODULE_VERSION = 127 /* Version.NODE_MODULE_VERSION */; + const nodeRegisterModuleSymbol = `node_register_module_v${NODE_MODULE_VERSION}`; + if (typeof instance.exports[nodeRegisterModuleSymbol] === 'function') { + const scope = emnapiCtx.isolate.openScope(); + try { + const exports = napiModule.exports; + const exportsHandle = scope.add(exports); + const moduleHandle = scope.add(napiModule); + instance.exports[nodeRegisterModuleSymbol](exportsHandle, moduleHandle, 5); + } + catch (err) { + if (err !== 'unwind') { + throw err; + } + } + finally { + emnapiCtx.isolate.closeScope(scope); + } + napiModule.loaded = true; + delete napiModule.envObject; + return napiModule.exports; + } + const find = Object.keys(instance.exports).filter(k => k.startsWith('node_register_module_v')); + if (find.length > 0) { + throw new Error(`The module${napiModule.filename ? ` '${napiModule.filename}'` : ''} + was compiled against a different Node.js version using + NODE_MODULE_VERSION ${find[0].slice(22)}. This version of Node.js requires + NODE_MODULE_VERSION ${NODE_MODULE_VERSION}.`); + } + let moduleApiVersion = 8 /* Version.NODE_API_DEFAULT_MODULE_API_VERSION */; + const node_api_module_get_api_version_v1 = instance.exports.node_api_module_get_api_version_v1; + if (typeof node_api_module_get_api_version_v1 === 'function') { + moduleApiVersion = node_api_module_get_api_version_v1(); + } + const envObject = napiModule.envObject || (() => { + let address = _emnapi_create_env(); + address >>>= 0; + address += 8; + const envObject = napiModule.envObject = emnapiEnv = emnapiCtx.createEnv(napiModule.filename, moduleApiVersion, { + address, + deleteEnv: (ptr) => { + _emnapi_delete_env(ptr - 8); + }, + setLastError, + makeDynCall_vppp: (cb) => (wasmTable.get(cb)), + makeDynCall_vp: (cb) => (wasmTable.get(cb)), + abort, + }, emnapiNodeBinding); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(address - 8 + 24 /* NapiEnvOffset32.id */, envObject.id, true); + return envObject; + })(); + const scope = emnapiCtx.openScope(envObject); + try { + envObject.callIntoModule((_envObject) => { + const exports = napiModule.exports; + const env = envObject.bridge.address; + const exportsHandle = scope.add(exports); + const napi_register_wasm_v1 = instance.exports.napi_register_wasm_v1; + const napiValue = napi_register_wasm_v1(env, exportsHandle); + napiModule.exports = (!napiValue) ? exports : emnapiCtx.jsValueFromNapiValue(napiValue); + }); + } + catch (e) { + if (e !== 'unwind') { + throw e; + } + } + finally { + emnapiCtx.closeScope(envObject, scope); + } + napiModule.loaded = true; + delete napiModule.envObject; + return napiModule.exports; + } + } + }; + var emnapiCtx; + var emnapiEnv; + var emnapiNodeBinding; + var onCreateWorker = undefined; + var out; + var err; + if (!ENVIRONMENT_IS_PTHREAD) { + const context = options.context; + if (typeof context !== 'object' || context === null) { + throw new TypeError("Invalid `options.context`. Use `import { getDefaultContext } from '@emnapi/runtime'`"); + } + emnapiCtx = context; + } + else { + emnapiCtx = options?.context; + const postMsg = typeof options.postMessage === 'function' + ? options.postMessage + : typeof postMessage === 'function' + ? postMessage + : undefined; + if (typeof postMsg !== 'function') { + throw new TypeError('No postMessage found'); + } + napiModule.postMessage = postMsg; + } + if (typeof options.filename === 'string') { + napiModule.filename = options.filename; + } + if (typeof options.onCreateWorker === 'function') { + onCreateWorker = options.onCreateWorker; + } + if (typeof options.print === 'function') { + out = options.print; + } + else { + out = console.log.bind(console); + } + if (typeof options.printErr === 'function') { + err = options.printErr; + } + else { + err = console.warn.bind(console); + } + if ('nodeBinding' in options) { + const nodeBinding = options.nodeBinding; + if (typeof nodeBinding !== 'object' || nodeBinding === null) { + throw new TypeError('Invalid `options.nodeBinding`. Use @emnapi/node-binding package'); + } + emnapiNodeBinding = nodeBinding; + } + var emnapiAsyncWorkPoolSize = 0; + if ('asyncWorkPoolSize' in options) { + if (typeof options.asyncWorkPoolSize !== 'number') { + throw new TypeError('options.asyncWorkPoolSize must be a integer'); + } + emnapiAsyncWorkPoolSize = options.asyncWorkPoolSize >> 0; + if (emnapiAsyncWorkPoolSize > 1024) { + emnapiAsyncWorkPoolSize = 1024; + } + else if (emnapiAsyncWorkPoolSize < -1024) { + emnapiAsyncWorkPoolSize = -1024; + } + } + var singleThreadAsyncWork = ENVIRONMENT_IS_PTHREAD ? false : (emnapiAsyncWorkPoolSize <= 0); + function _emnapi_async_work_pool_size() { + return Math.abs(emnapiAsyncWorkPoolSize); + } + napiModule.imports.env._emnapi_async_work_pool_size = _emnapi_async_work_pool_size; + // ------------------------------ pthread ------------------------------- + function emnapiAddSendListener(worker) { + if (!worker) + return false; + if (worker._emnapiSendListener) + return true; + const handler = function (e) { + const data = ENVIRONMENT_IS_NODE ? e : e.data; + const __emnapi__ = data.__emnapi__; + if (__emnapi__ && __emnapi__.type === 'async-send') { + if (ENVIRONMENT_IS_PTHREAD) { + const postMessage = napiModule.postMessage; + postMessage({ __emnapi__ }); + } + else { + const callback = __emnapi__.payload.callback; + (wasmTable.get(callback))(__emnapi__.payload.data); + } + } + }; + const dispose = function () { + if (ENVIRONMENT_IS_NODE) { + worker.off('message', handler); + } + else { + worker.removeEventListener('message', handler, false); + } + delete worker._emnapiSendListener; + }; + worker._emnapiSendListener = { handler, dispose }; + if (ENVIRONMENT_IS_NODE) { + worker.on('message', handler); + } + else { + worker.addEventListener('message', handler, false); + } + return true; + } + napiModule.emnapi.addSendListener = emnapiAddSendListener; + var PThread = new ThreadManager(ENVIRONMENT_IS_PTHREAD + ? { + printErr: err, + childThread: true + } + : { + printErr: err, + beforeLoad: (worker) => { + emnapiAddSendListener(worker); + }, + reuseWorker: options.reuseWorker, + onCreateWorker: onCreateWorker + }); + napiModule.PThread = PThread; + + //#endregion src/core/init.ts + + var initMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + ENVIRONMENT_IS_NODE: ENVIRONMENT_IS_NODE, + ENVIRONMENT_IS_PTHREAD: ENVIRONMENT_IS_PTHREAD, + PThread: PThread, + _emnapi_async_work_pool_size: _emnapi_async_work_pool_size, + get _emnapi_create_env () { return _emnapi_create_env; }, + get _emnapi_delete_env () { return _emnapi_delete_env; }, + get _free () { return _free; }, + get _malloc () { return _malloc; }, + abort: abort, + addFunction: addFunction, + get emnapiAsyncWorkPoolSize () { return emnapiAsyncWorkPoolSize; }, + get emnapiCtx () { return emnapiCtx; }, + get emnapiEnv () { return emnapiEnv; }, + get emnapiNodeBinding () { return emnapiNodeBinding; }, + get err () { return err; }, + getWasmTableEntry: getWasmTableEntry, + napiModule: napiModule, + get onCreateWorker () { return onCreateWorker; }, + get out () { return out; }, + removeFunction: removeFunction, + runtimeKeepalivePop: runtimeKeepalivePop, + runtimeKeepalivePush: runtimeKeepalivePush, + setWasmTableEntry: setWasmTableEntry, + singleThreadAsyncWork: singleThreadAsyncWork, + waitThreadStart: waitThreadStart, + get wasmInstance () { return wasmInstance; }, + get wasmMemory () { return wasmMemory; }, + get wasmModule () { return wasmModule; }, + get wasmTable () { return wasmTable; } + }); + + //#region src/util.ts + // /** + // * @__sig ipp + // */ + // export function napi_get_last_error_info (env: napi_env, result: void_pp): napi_status { + // return emnapiRuntimeModuleExports.napi_get_last_error_info(env, result) + // } + /** @__sig p */ + function _emnapi_get_node_api_js_vtable() { + return 0; + } + /** @__sig p */ + function _emnapi_get_node_api_module_vtable() { + return 0; + } + /** + * @__sig vppp + */ + function _emnapi_get_node_version(major, minor, patch) { + major >>>= 0; + minor >>>= 0; + patch >>>= 0; + const versions = (typeof process === 'object' && process !== null && + typeof process.versions === 'object' && process.versions !== null && + typeof process.versions.node === 'string') + ? process.versions.node.split('.').map((n) => Number(n)) + : [0, 0, 0]; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(major, versions[0], true); + GET_HEAP_DATA_VIEW().setUint32(minor, versions[1], true); + GET_HEAP_DATA_VIEW().setUint32(patch, versions[2], true); + } + /** + * @__sig v + * @__deps $runtimeKeepalivePush + */ + function _emnapi_runtime_keepalive_push() { + } + /** + * @__sig v + * @__deps $runtimeKeepalivePop + */ + function _emnapi_runtime_keepalive_pop() { + } + /** + * @__sig vpp + */ + function _emnapi_set_immediate(callback, data) { + emnapiCtx.features.setImmediate(() => { + (wasmTable.get(callback))(data); + }); + } + /** + * @__sig vpp + */ + function _emnapi_next_tick(callback, data) { + Promise.resolve().then(() => { + (wasmTable.get(callback))(data); + }); + } + /** + * @__sig vipppi + */ + function _emnapi_callback_into_module(forceUncaught, env, callback, data, close_scope_if_throw) { + const envObject = emnapiEnv; + const scope = emnapiCtx.openScope(envObject); + try { + envObject.callbackIntoModule(Boolean(forceUncaught), () => { + (wasmTable.get(callback))(env, data); + }); + } + catch (err) { + emnapiCtx.closeScope(envObject, scope); + if (close_scope_if_throw) { + emnapiCtx.closeScope(envObject); + } + throw err; + } + emnapiCtx.closeScope(envObject, scope); + } + /** + * @__sig vipppp + */ + function _emnapi_call_finalizer(forceUncaught, env, callback, data, hint) { + const envObject = emnapiEnv; + callback >>>= 0; + envObject.callFinalizerInternal(forceUncaught, callback, data, hint); + } + /** + * @__sig v + */ + function _emnapi_ctx_increase_waiting_request_counter() { + emnapiCtx.increaseWaitingRequestCounter(); + } + /** + * @__sig v + */ + function _emnapi_ctx_decrease_waiting_request_counter() { + emnapiCtx.decreaseWaitingRequestCounter(); + } + /** + * @__sig i + */ + function _emnapi_is_main_runtime_thread() { + return ENVIRONMENT_IS_PTHREAD ? 0 : 1; + } + /** + * @__sig i + */ + function _emnapi_is_main_browser_thread() { + return (typeof window !== 'undefined' && typeof document !== 'undefined' && !ENVIRONMENT_IS_NODE) ? 1 : 0; + } + /** + * @__sig v + */ + function _emnapi_unwind() { + throw 'unwind'; + } + /** + * @__sig d + */ + function _emnapi_get_now() { + return performance.timeOrigin + performance.now(); + } + function $emnapiSetValueI64(result, numberValue) { + let tempDouble; + const tempI64 = [ + numberValue >>> 0, + (tempDouble = numberValue, +Math.abs(tempDouble) >= 1 ? tempDouble > 0 ? (Math.min(+Math.floor(tempDouble / 4294967296), 4294967295) | 0) >>> 0 : ~~+Math.ceil((tempDouble - +(~~tempDouble >>> 0)) / 4294967296) >>> 0 : 0) + ]; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt32(result, tempI64[0], true); + GET_HEAP_DATA_VIEW().setInt32(result + 4, tempI64[1], true); + } + /** + * @__deps $emnapiCtx + * @__sig p + */ + function _emnapi_open_handle_scope() { + return emnapiCtx.isolate.openScope().id; + } + /** + * @__deps $emnapiCtx + * @__sig vp + */ + function _emnapi_close_handle_scope(_scope) { + return emnapiCtx.isolate.closeScope(); + } + + //#endregion src/util.ts + + var utilMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + $emnapiSetValueI64: $emnapiSetValueI64, + _emnapi_call_finalizer: _emnapi_call_finalizer, + _emnapi_callback_into_module: _emnapi_callback_into_module, + _emnapi_close_handle_scope: _emnapi_close_handle_scope, + _emnapi_ctx_decrease_waiting_request_counter: _emnapi_ctx_decrease_waiting_request_counter, + _emnapi_ctx_increase_waiting_request_counter: _emnapi_ctx_increase_waiting_request_counter, + _emnapi_get_node_api_js_vtable: _emnapi_get_node_api_js_vtable, + _emnapi_get_node_api_module_vtable: _emnapi_get_node_api_module_vtable, + _emnapi_get_node_version: _emnapi_get_node_version, + _emnapi_get_now: _emnapi_get_now, + _emnapi_is_main_browser_thread: _emnapi_is_main_browser_thread, + _emnapi_is_main_runtime_thread: _emnapi_is_main_runtime_thread, + _emnapi_next_tick: _emnapi_next_tick, + _emnapi_open_handle_scope: _emnapi_open_handle_scope, + _emnapi_runtime_keepalive_pop: _emnapi_runtime_keepalive_pop, + _emnapi_runtime_keepalive_push: _emnapi_runtime_keepalive_push, + _emnapi_set_immediate: _emnapi_set_immediate, + _emnapi_unwind: _emnapi_unwind + }); + + //#region src/core/async.ts + function emnapiGetWorkerByPthreadPtr(pthreadPtr) { + const view = new DataView(wasmMemory.buffer); + /** + * wasi-sdk-20.0+threads + * + * struct pthread { + * struct pthread *self; // 0 + * struct pthread *prev, *next; // 4, 8 + * uintptr_t sysinfo; // 12 + * uintptr_t canary; // 16 + * int tid; // 20 + * // ... + * } + */ + const tidOffset = 20; + const tid = view.getInt32(pthreadPtr + tidOffset, true); + const worker = PThread.pthreads[tid]; + return worker; + } + /** @__sig vp */ + function _emnapi_worker_ref(pthreadPtr) { + if (ENVIRONMENT_IS_PTHREAD) + return; + pthreadPtr >>>= 0; + const worker = emnapiGetWorkerByPthreadPtr(pthreadPtr); + if (worker && typeof worker.ref === 'function') { + worker.ref(); + } + } + /** @__sig vp */ + function _emnapi_worker_unref(pthreadPtr) { + if (ENVIRONMENT_IS_PTHREAD) + return; + pthreadPtr >>>= 0; + const worker = emnapiGetWorkerByPthreadPtr(pthreadPtr); + if (worker && typeof worker.unref === 'function') { + worker.unref(); + } + } + /** @__sig vipp */ + function _emnapi_async_send_js(type, callback, data) { + if (ENVIRONMENT_IS_PTHREAD) { + const postMessage = napiModule.postMessage; + postMessage({ + __emnapi__: { + type: 'async-send', + payload: { + callback, + data + } + } + }); + } + else { + switch (type) { + case 0: + _emnapi_set_immediate(callback, data); + break; + case 1: + _emnapi_next_tick(callback, data); + break; + } + } + } + // function ptrToString (ptr: number): string { + // return '0x' + ('00000000' + ptr.toString(16)).slice(-8) + // } + var uvThreadpoolReadyResolve; + var uvThreadpoolReady = new Promise((resolve) => { + uvThreadpoolReadyResolve = function () { + uvThreadpoolReady.ready = true; + resolve(); + }; + }); + uvThreadpoolReady.ready = false; + /** @__sig vppi */ + function _emnapi_after_uvthreadpool_ready(callback, q, type) { + if (uvThreadpoolReady.ready) { + (wasmTable.get(callback))(q, type); + } + else { + uvThreadpoolReady.then(() => { + (wasmTable.get(callback))(q, type); + }); + } + } + /** @__sig vpi */ + function _emnapi_tell_js_uvthreadpool(threads, size) { + const p = []; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + for (let i = 0; i < size; i++) { + const pthreadPtr = GET_HEAP_DATA_VIEW().getUint32(threads + i * 4, true); + const worker = emnapiGetWorkerByPthreadPtr(pthreadPtr); + p.push(new Promise((resolve) => { + const handler = function (e) { + const data = ENVIRONMENT_IS_NODE ? e : e.data; + const __emnapi__ = data.__emnapi__; + if (__emnapi__ && __emnapi__.type === 'async-thread-ready') { + resolve(); + if (worker && typeof worker.unref === 'function') { + worker.unref(); + } + if (ENVIRONMENT_IS_NODE) { + worker.off('message', handler); + } + else { + worker.removeEventListener('message', handler); + } + } + }; + if (ENVIRONMENT_IS_NODE) { + worker.on('message', handler); + } + else { + worker.addEventListener('message', handler); + } + })); + } + Promise.all(p).then(uvThreadpoolReadyResolve); + } + /** @__sig v */ + function _emnapi_emit_async_thread_ready() { + if (!ENVIRONMENT_IS_PTHREAD) + return; + const postMessage = napiModule.postMessage; + postMessage({ + __emnapi__: { + type: 'async-thread-ready', + payload: {} + } + }); + } + + //#endregion src/core/async.ts + + var asyncMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + _emnapi_after_uvthreadpool_ready: _emnapi_after_uvthreadpool_ready, + _emnapi_async_send_js: _emnapi_async_send_js, + _emnapi_emit_async_thread_ready: _emnapi_emit_async_thread_ready, + _emnapi_tell_js_uvthreadpool: _emnapi_tell_js_uvthreadpool, + _emnapi_worker_ref: _emnapi_worker_ref, + _emnapi_worker_unref: _emnapi_worker_unref + }); + + //#region src/macro.ts + + //#endregion src/macro.ts + + //#region src/core/memory.ts + /** @__sig ipjp */ + function napi_adjust_external_memory(env, change_in_bytes, adjusted_value) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + const envObject = emnapiEnv; + if (!adjusted_value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + let adjusted_memory = emnapiCtx.adjustAmountOfExternalAllocatedMemory(change_in_bytes); + adjusted_value >>>= 0; + if (emnapiCtx.features.BigInt) { + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setBigInt64(adjusted_value, BigInt(adjusted_memory), true); + } + else { + $emnapiSetValueI64(adjusted_value, Number(adjusted_memory)); + } + return envObject.clearLastError(); + } + + //#endregion src/core/memory.ts + + var memoryMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + napi_adjust_external_memory: napi_adjust_external_memory + }); + + //#region src/memory.ts + /** + * @__deps malloc + * @__deps free + * @__postset + * ``` + * emnapiExternalMemory.init(); + * ``` + */ + const emnapiExternalMemory = { + registry: typeof FinalizationRegistry === 'function' ? new FinalizationRegistry(function (_pointer) { _free(_pointer); }) : undefined, + table: new WeakMap(), + wasmMemoryViewTable: new WeakMap(), + // populated by init(): live intrinsic function references must not exist at + // library definition time — the emscripten jsifier re-serializes this object + // and native functions do not stringify to parseable source + intrinsics: undefined, + init: function () { + emnapiExternalMemory.registry = typeof FinalizationRegistry === 'function' ? new FinalizationRegistry(function (_pointer) { _free(_pointer); }) : undefined; + emnapiExternalMemory.table = new WeakMap(); + emnapiExternalMemory.wasmMemoryViewTable = new WeakMap(); + const sharedArrayBufferByteLength = typeof SharedArrayBuffer === 'function' + ? Object.getOwnPropertyDescriptor(SharedArrayBuffer.prototype, 'byteLength')?.get + : undefined; + // cached intrinsic prototype getters and element-type constructors: they + // read the internal slots directly like native Node-API does, so user + // accessors and user subclass constructors can never run inside get-info + // metadata reads, descriptor registration or view reconstruction, and they + // work for instances from any realm + emnapiExternalMemory.intrinsics = { + // ArrayBuffer.isView ignores its `this`, so a bare cached reference is + // safe and cannot be swapped out by user code replacing the global + isView: ArrayBuffer.isView, + typedArray: { + buffer: Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Uint8Array.prototype), 'buffer').get, + byteOffset: Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Uint8Array.prototype), 'byteOffset').get, + length: Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Uint8Array.prototype), 'length').get, + tag: Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Uint8Array.prototype), Symbol.toStringTag).get + }, + dataView: { + buffer: Object.getOwnPropertyDescriptor(DataView.prototype, 'buffer').get, + byteOffset: Object.getOwnPropertyDescriptor(DataView.prototype, 'byteOffset').get, + byteLength: Object.getOwnPropertyDescriptor(DataView.prototype, 'byteLength').get + }, + arrayBuffer: { + byteLength: Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, 'byteLength').get + }, + // a SharedArrayBuffer polyfill may lack the byteLength accessor: degrade + // to the hidden-global classification path instead of throwing here + sharedArrayBuffer: sharedArrayBufferByteLength !== undefined + ? { + byteLength: sharedArrayBufferByteLength + } + : undefined, + ctors: { + Int8Array, + Uint8Array, + Uint8ClampedArray, + Int16Array, + Uint16Array, + Int32Array, + Uint32Array, + Float16Array: typeof Float16Array === 'function' ? Float16Array : undefined, + Float32Array, + Float64Array, + BigInt64Array, + BigUint64Array + }, + bufferFrom: undefined + }; + }, + isSharedArrayBuffer(value) { + const sharedArrayBuffer = emnapiExternalMemory.intrinsics.sharedArrayBuffer; + if (sharedArrayBuffer !== undefined) { + if (typeof SharedArrayBuffer === 'function' && value instanceof SharedArrayBuffer) + return true; + // the intrinsic byteLength getter reads the internal slot: it accepts + // SharedArrayBuffer instances from any realm and throws for anything + // else, without consulting user-controllable properties + try { + sharedArrayBuffer.byteLength.call(value); + return true; + } + catch (_) { + return false; + } + } + // hidden-global environment (see #143): the SharedArrayBuffer global was + // absent at init time, but the engine can still hand out genuine SABs + // (e.g. a shared WebAssembly.Memory buffer). A genuine ArrayBuffer + // answers the intrinsic byteLength probe, settling the common case + // without the (spoofable, user-JS-running) toString tag read below. + try { + emnapiExternalMemory.intrinsics.arrayBuffer.byteLength.call(value); + return false; + } + catch (_) { } + return Object.prototype.toString.call(value) === '[object SharedArrayBuffer]'; + }, + isDetachedArrayBuffer: function (arrayBuffer) { + if (emnapiExternalMemory.bufferByteLength(arrayBuffer) === 0) { + try { + // eslint-disable-next-line no-new + new Uint8Array(arrayBuffer); + } + catch (_) { + return true; + } + } + return false; + }, + bufferByteLength: function (buffer) { + const intrinsics = emnapiExternalMemory.intrinsics; + try { + return intrinsics.arrayBuffer.byteLength.call(buffer); + } + catch (err) { + const sharedArrayBuffer = intrinsics.sharedArrayBuffer; + if (sharedArrayBuffer !== undefined) { + return sharedArrayBuffer.byteLength.call(buffer); + } + // hidden-global environment (see isSharedArrayBuffer): no SAB getter + // was capturable at init, recover it from the instance's own prototype + // (for a genuine SAB that is the hidden SharedArrayBuffer.prototype) + const proto = Object.getPrototypeOf(buffer); + const get = proto !== null && proto !== undefined + ? Object.getOwnPropertyDescriptor(proto, 'byteLength')?.get + : undefined; + if (get === undefined) + throw err; + return get.call(buffer); + } + }, + viewBuffer: function (view) { + const intrinsics = emnapiExternalMemory.intrinsics; + return intrinsics.typedArray.tag.call(view) === undefined + ? intrinsics.dataView.buffer.call(view) + : intrinsics.typedArray.buffer.call(view); + }, + viewByteOffset: function (view) { + const intrinsics = emnapiExternalMemory.intrinsics; + return intrinsics.typedArray.tag.call(view) === undefined + ? intrinsics.dataView.byteOffset.call(view) + : intrinsics.typedArray.byteOffset.call(view); + }, + // element count for typed arrays, byteLength for DataViews (the unit used + // by the napi_get_typedarray_info / napi_get_dataview_info length outputs + // and by the view constructors at reconstruction) + viewLength: function (view) { + const intrinsics = emnapiExternalMemory.intrinsics; + return intrinsics.typedArray.tag.call(view) === undefined + ? intrinsics.dataView.byteLength.call(view) + : intrinsics.typedArray.length.call(view); + }, + // Buffer descriptors are only ever created by emnapi's own buffer creation + // paths; capturing Buffer.from the first time one is created snapshots the + // legitimate function before any later reconstruction, so a user replacing + // Buffer.from afterwards cannot influence a refreshed view + getBufferFrom: function () { + return emnapiExternalMemory.intrinsics.bufferFrom ?? + (emnapiExternalMemory.intrinsics.bufferFrom = emnapiCtx.features.Buffer.from); + }, + getArrayBufferPointer: function (arrayBuffer, shouldCopy) { + const info = { + address: 0, + ownership: 0 /* ReferenceOwnership.kRuntime */, + runtimeAllocated: 0 + }; + if (arrayBuffer === wasmMemory.buffer) { + return info; + } + const isDetached = emnapiExternalMemory.isDetachedArrayBuffer(arrayBuffer); + if (emnapiExternalMemory.table.has(arrayBuffer)) { + const cachedInfo = emnapiExternalMemory.table.get(arrayBuffer); + if (isDetached) { + cachedInfo.address = 0; + return cachedInfo; + } + if (shouldCopy && cachedInfo.ownership === 0 /* ReferenceOwnership.kRuntime */ && cachedInfo.runtimeAllocated === 1) { + new Uint8Array(wasmMemory.buffer).set(new Uint8Array(arrayBuffer), cachedInfo.address); + } + return cachedInfo; + } + const byteLength = emnapiExternalMemory.bufferByteLength(arrayBuffer); + if (isDetached || (byteLength === 0)) { + return info; + } + if (!shouldCopy) { + return info; + } + let pointer = _malloc(byteLength); + if (!pointer) + throw new Error('Out of memory'); + pointer >>>= 0; + new Uint8Array(wasmMemory.buffer).set(new Uint8Array(arrayBuffer), pointer); + info.address = pointer; + info.ownership = emnapiExternalMemory.registry ? 0 /* ReferenceOwnership.kRuntime */ : 1 /* ReferenceOwnership.kUserland */; + info.runtimeAllocated = 1; + emnapiExternalMemory.table.set(arrayBuffer, info); + emnapiExternalMemory.registry?.register(arrayBuffer, pointer); + return info; + }, + getOrUpdateMemoryView: function (view) { + // classify and read the view state through the cached intrinsic + // prototype getters only: own accessors on the instance could otherwise + // run user JS that grows (and detaches) a non-shared memory in the + // middle of registration, poisoning the stored descriptor; the intrinsic + // reads return primitives from the internal slots and run zero user JS. + // The @@toStringTag slot getter classifies views from any realm: it + // returns the element-type name for typed arrays (seeing through user + // subclasses) and undefined for DataViews + const intrinsics = emnapiExternalMemory.intrinsics; + const tag = intrinsics.typedArray.tag.call(view); + const isDataView = tag === undefined; + const buffer = isDataView ? intrinsics.dataView.buffer.call(view) : intrinsics.typedArray.buffer.call(view); + if (buffer === wasmMemory.buffer) { + if (!emnapiExternalMemory.wasmMemoryViewTable.has(view)) { + emnapiExternalMemory.wasmMemoryViewTable.set(view, { + // store the intrinsic element-type constructor keyed by the + // @@toStringTag slot (never view.constructor and never a + // user-definable Buffer @@hasInstance check): reconstruction after a + // memory growth must not run any user code, because it could grow + // again after the fresh buffer was captured as an argument. Buffers + // are tagged 'Uint8Array' and reconstruct as base Uint8Array views + Ctor: isDataView ? DataView : intrinsics.ctors[tag], + address: isDataView ? intrinsics.dataView.byteOffset.call(view) : intrinsics.typedArray.byteOffset.call(view), + length: isDataView ? intrinsics.dataView.byteLength.call(view) : intrinsics.typedArray.length.call(view), + ownership: 1 /* ReferenceOwnership.kUserland */, + runtimeAllocated: 0 + }); + } + return view; + } + const maybeOldWasmMemory = emnapiExternalMemory.isDetachedArrayBuffer(buffer) || emnapiExternalMemory.isSharedArrayBuffer(buffer); + if (maybeOldWasmMemory && emnapiExternalMemory.wasmMemoryViewTable.has(view)) { + const info = emnapiExternalMemory.wasmMemoryViewTable.get(view); + const Ctor = info.Ctor; + let newView; + const Buffer = emnapiCtx.features.Buffer; + if (typeof Buffer === 'function' && Ctor === Buffer) { + // reconstruct through the Buffer.from captured at creation time + newView = emnapiExternalMemory.getBufferFrom()(wasmMemory.buffer, info.address, info.length); + } + else { + newView = new Ctor(wasmMemory.buffer, info.address, info.length); + } + emnapiExternalMemory.wasmMemoryViewTable.set(newView, info); + return newView; + } + return view; + }, + getViewPointer: function (view, shouldCopy) { + view = emnapiExternalMemory.getOrUpdateMemoryView(view); + const buffer = emnapiExternalMemory.viewBuffer(view); + if (buffer === wasmMemory.buffer) { + if (emnapiExternalMemory.wasmMemoryViewTable.has(view)) { + const { address, ownership, runtimeAllocated } = emnapiExternalMemory.wasmMemoryViewTable.get(view); + return { address, ownership, runtimeAllocated, view }; + } + return { address: emnapiExternalMemory.viewByteOffset(view), ownership: 1 /* ReferenceOwnership.kUserland */, runtimeAllocated: 0, view }; + } + const { address, ownership, runtimeAllocated } = emnapiExternalMemory.getArrayBufferPointer(buffer, shouldCopy); + return { address: address === 0 ? 0 : (address + emnapiExternalMemory.viewByteOffset(view)), ownership, runtimeAllocated, view }; + } + }; + /** + * Metadata layout in wasm shared memory (allocated with _malloc): + * offset 0: refcount (int32, 4 bytes - for Atomics) + * offset POINTER_SIZE: external_data (pointer) + * offset 2*POINTER_SIZE: byte_length (size_t) + * offset 3*POINTER_SIZE: finalize_cb (pointer) + * offset 4*POINTER_SIZE: finalize_data (pointer) + * offset 5*POINTER_SIZE: finalize_hint (pointer) + * Total: 6 * POINTER_SIZE bytes + */ + /** + * @__postset + * ``` + * emnapiExternalSAB.init(); + * ``` + */ + const emnapiExternalSAB = { + registry: undefined, + handleTable: new WeakMap(), + init: function () { + emnapiExternalSAB.handleTable = new WeakMap(); + emnapiExternalSAB.registry = typeof FinalizationRegistry === 'function' + ? new FinalizationRegistry(function (metaPtr) { + emnapiExternalSAB.release(metaPtr); + }) + : undefined; + }, + allocMeta: function (external_data, byte_length, finalize_cb, finalize_data, finalize_hint) { + const size = 4 * 6; + let metaPtr = _malloc(size); + if (!metaPtr) + throw new Error('Out of memory'); + metaPtr >>>= 0; + // refcount = 1 + Atomics.store(new Int32Array(wasmMemory.buffer, metaPtr, 1), 0, 1); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(metaPtr + 4, external_data, true); + GET_HEAP_DATA_VIEW().setUint32(metaPtr + 8, byte_length, true); + GET_HEAP_DATA_VIEW().setUint32(metaPtr + 12, finalize_cb, true); + GET_HEAP_DATA_VIEW().setUint32(metaPtr + 16, finalize_data, true); + GET_HEAP_DATA_VIEW().setUint32(metaPtr + 20, finalize_hint, true); + return metaPtr; + }, + readMeta: function (metaPtr) { + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + const external_data = GET_HEAP_DATA_VIEW().getUint32(metaPtr + 4, true); + const byte_length = GET_HEAP_DATA_VIEW().getUint32(metaPtr + 8, true); + const finalize_cb = GET_HEAP_DATA_VIEW().getUint32(metaPtr + 12, true); + const finalize_data = GET_HEAP_DATA_VIEW().getUint32(metaPtr + 16, true); + const finalize_hint = GET_HEAP_DATA_VIEW().getUint32(metaPtr + 20, true); + return { external_data, byte_length, finalize_cb, finalize_data, finalize_hint }; + }, + release: function (metaPtr) { + const oldRefcount = Atomics.sub(new Int32Array(wasmMemory.buffer, metaPtr, 1), 0, 1); + if (oldRefcount === 1) { + // refcount reached 0, we are the last holder + const info = emnapiExternalSAB.readMeta(metaPtr); + const finalize_cb = info.finalize_cb; + if (finalize_cb) { + const finalize_data = info.finalize_data; + const finalize_hint = info.finalize_hint; + (wasmTable.get(finalize_cb))(finalize_data, finalize_hint); + } + _free(metaPtr); + } + } + }; + + //#endregion src/memory.ts + + //#region src/string.ts + /* eslint-disable @stylistic/indent */ + /** + * @__postset + * ``` + * emnapiString.init(); + * ``` + */ + var emnapiString = { + utf8Decoder: undefined, + utf16Decoder: undefined, + init() { + const fallbackDecoder = { + decode(bytes) { + let inputIndex = 0; + const pendingSize = Math.min(0x1000, bytes.length + 1); + const pending = new Uint16Array(pendingSize); + const chunks = []; + let pendingIndex = 0; + for (;;) { + const more = inputIndex < bytes.length; + if (!more || (pendingIndex >= pendingSize - 1)) { + const subarray = pending.subarray(0, pendingIndex); + const arraylike = subarray; + chunks.push(String.fromCharCode.apply(null, arraylike)); + if (!more) { + return chunks.join(''); + } + bytes = bytes.subarray(inputIndex); + inputIndex = 0; + pendingIndex = 0; + } + const byte1 = bytes[inputIndex++]; + if ((byte1 & 0x80) === 0) { + pending[pendingIndex++] = byte1; + } + else if ((byte1 & 0xe0) === 0xc0) { + const byte2 = bytes[inputIndex++] & 0x3f; + pending[pendingIndex++] = ((byte1 & 0x1f) << 6) | byte2; + } + else if ((byte1 & 0xf0) === 0xe0) { + const byte2 = bytes[inputIndex++] & 0x3f; + const byte3 = bytes[inputIndex++] & 0x3f; + pending[pendingIndex++] = ((byte1 & 0x1f) << 12) | (byte2 << 6) | byte3; + } + else if ((byte1 & 0xf8) === 0xf0) { + const byte2 = bytes[inputIndex++] & 0x3f; + const byte3 = bytes[inputIndex++] & 0x3f; + const byte4 = bytes[inputIndex++] & 0x3f; + let codepoint = ((byte1 & 0x07) << 0x12) | (byte2 << 0x0c) | (byte3 << 0x06) | byte4; + if (codepoint > 0xffff) { + codepoint -= 0x10000; + pending[pendingIndex++] = (codepoint >>> 10) & 0x3ff | 0xd800; + codepoint = 0xdc00 | codepoint & 0x3ff; + } + pending[pendingIndex++] = codepoint; + } + else ; + } + } + }; + let utf8Decoder; + utf8Decoder = typeof TextDecoder === 'function' ? new TextDecoder() : fallbackDecoder; + emnapiString.utf8Decoder = utf8Decoder; + const fallbackDecoder2 = { + decode(input) { + const bytes = new Uint16Array(input.buffer, input.byteOffset, input.byteLength / 2); + if (bytes.length <= 0x1000) { + return String.fromCharCode.apply(null, bytes); + } + const chunks = []; + let i = 0; + let len = 0; + for (; i < bytes.length; i += len) { + len = Math.min(0x1000, bytes.length - i); + chunks.push(String.fromCharCode.apply(null, bytes.subarray(i, i + len))); + } + return chunks.join(''); + } + }; + let utf16Decoder; + utf16Decoder = typeof TextDecoder === 'function' ? new TextDecoder('utf-16le') : fallbackDecoder2; + emnapiString.utf16Decoder = utf16Decoder; + }, + lengthBytesUTF8(str) { + let c; + let len = 0; + for (let i = 0; i < str.length; ++i) { + c = str.charCodeAt(i); + if (c <= 0x7F) { + len++; + } + else if (c <= 0x7FF) { + len += 2; + } + else if (c >= 0xD800 && c <= 0xDFFF) { + len += 4; + ++i; + } + else { + len += 3; + } + } + return len; + }, + UTF8ToString(ptr, length) { + if (!ptr || !length) + return ''; + ptr >>>= 0; + const HEAPU8 = new Uint8Array(wasmMemory.buffer); + let end = ptr; + if (length === -1 || length === 4294967295) { + for (; HEAPU8[end];) + ++end; + } + else { + end = ptr + (length >>> 0); + } + length = end - ptr; + if (length <= 16) { + let idx = ptr; + var str = ''; + while (idx < end) { + var u0 = HEAPU8[idx++]; + if (!(u0 & 0x80)) { + str += String.fromCharCode(u0); + continue; + } + var u1 = HEAPU8[idx++] & 63; + if ((u0 & 0xE0) === 0xC0) { + str += String.fromCharCode(((u0 & 31) << 6) | u1); + continue; + } + var u2 = HEAPU8[idx++] & 63; + if ((u0 & 0xF0) === 0xE0) { + u0 = ((u0 & 15) << 12) | (u1 << 6) | u2; + } + else { + u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (HEAPU8[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; + } + return emnapiString.utf8Decoder.decode(((typeof SharedArrayBuffer === "function" && HEAPU8.buffer instanceof SharedArrayBuffer) || (Object.prototype.toString.call(HEAPU8.buffer) === "[object SharedArrayBuffer]")) ? HEAPU8.slice(ptr, end) : HEAPU8.subarray(ptr, end)); + }, + stringToUTF8(str, outPtr, maxBytesToWrite) { + const HEAPU8 = new Uint8Array(wasmMemory.buffer); + let outIdx = outPtr; + outIdx >>>= 0; + if (!(maxBytesToWrite > 0)) { + return 0; + } + var startIdx = outIdx; + var endIdx = outIdx + maxBytesToWrite - 1; + for (var i = 0; i < str.length; ++i) { + var u = str.charCodeAt(i); + if (u >= 0xD800 && u <= 0xDFFF) { + var u1 = str.charCodeAt(++i); + u = 0x10000 + ((u & 0x3FF) << 10) | (u1 & 0x3FF); + } + if (u <= 0x7F) { + if (outIdx >= endIdx) + break; + HEAPU8[outIdx++] = u; + } + else if (u <= 0x7FF) { + if (outIdx + 1 >= endIdx) + break; + HEAPU8[outIdx++] = 0xC0 | (u >> 6); + HEAPU8[outIdx++] = 0x80 | (u & 63); + } + else if (u <= 0xFFFF) { + if (outIdx + 2 >= endIdx) + break; + HEAPU8[outIdx++] = 0xE0 | (u >> 12); + HEAPU8[outIdx++] = 0x80 | ((u >> 6) & 63); + HEAPU8[outIdx++] = 0x80 | (u & 63); + } + else { + if (outIdx + 3 >= endIdx) + break; + HEAPU8[outIdx++] = 0xF0 | (u >> 18); + HEAPU8[outIdx++] = 0x80 | ((u >> 12) & 63); + HEAPU8[outIdx++] = 0x80 | ((u >> 6) & 63); + HEAPU8[outIdx++] = 0x80 | (u & 63); + } + } + HEAPU8[outIdx] = 0; + return outIdx - startIdx; + }, + UTF16ToString(ptr, length) { + if (!ptr || !length) + return ''; + ptr >>>= 0; + let end = ptr; + if (length === -1 || length === 4294967295) { + let idx = end >>> 1; + const HEAPU16 = new Uint16Array(wasmMemory.buffer); + while (HEAPU16[idx]) + ++idx; + end = (idx << 1) >>> 0; + } + else { + end = ptr + (length >>> 0) * 2; + } + length = end - ptr; + if (length <= 32) { + return String.fromCharCode.apply(null, new Uint16Array(wasmMemory.buffer, ptr, length / 2)); + } + const HEAPU8 = new Uint8Array(wasmMemory.buffer); + return emnapiString.utf16Decoder.decode(((typeof SharedArrayBuffer === "function" && HEAPU8.buffer instanceof SharedArrayBuffer) || (Object.prototype.toString.call(HEAPU8.buffer) === "[object SharedArrayBuffer]")) ? HEAPU8.slice(ptr, end) : HEAPU8.subarray(ptr, end)); + }, + stringToUTF16(str, outPtr, maxBytesToWrite) { + if (maxBytesToWrite === undefined) { + maxBytesToWrite = 0x7FFFFFFF; + } + if (maxBytesToWrite < 2) + return 0; + maxBytesToWrite -= 2; + var startPtr = outPtr; + var numCharsToWrite = (maxBytesToWrite < str.length * 2) ? (maxBytesToWrite / 2) : str.length; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + for (var i = 0; i < numCharsToWrite; ++i) { + var codeUnit = str.charCodeAt(i); + GET_HEAP_DATA_VIEW().setInt16(outPtr, codeUnit, true); + outPtr += 2; + } + GET_HEAP_DATA_VIEW().setInt16(outPtr, 0, true); + return outPtr - startPtr; + }, + newString(env, str, length, result, stringMaker) { + length >>>= 0; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + const autoLength = length === -1 || length === 4294967295; + const sizelength = length >>> 0; + if (length !== 0) { + if (!str) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!(autoLength || (sizelength <= 2147483647))) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + str >>>= 0; + const strValue = stringMaker(str, autoLength, sizelength); + result >>>= 0; + const value = emnapiCtx.napiValueFromJsValue(strValue); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return envObject.clearLastError(); + }, + newExternalString(env, str, length, finalize_callback, finalize_hint, result, copied, createApi, stringMaker) { + length >>>= 0; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + const autoLength = length === -1 || length === 4294967295; + const sizelength = length >>> 0; + if (length !== 0) { + if (!str) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!(autoLength || (sizelength <= 2147483647))) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const status = createApi(env, str, length, result); + if (status === 0 /* napi_status.napi_ok */) { + if (copied) { + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(copied, 1, true); + } + if (finalize_callback) { + envObject.callFinalizer(finalize_callback, str, finalize_hint); + } + } + return status; + }, + encode(str, autoLength, sizeLength, convert) { + let latin1String = ''; + let len = 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + if (autoLength) { + while (true) { + const ch = GET_HEAP_DATA_VIEW().getUint8(str, true); + if (!ch) + break; + latin1String += convert(ch); + str++; + } + } + else { + while (len < sizeLength) { + const ch = GET_HEAP_DATA_VIEW().getUint8(str, true); + if (!ch) + break; + latin1String += convert(ch); + len++; + str++; + } + } + return latin1String; + } + }; + + //#endregion src/string.ts + + //#region src/value/convert2c.ts + /** + * @__sig ippp + */ + function napi_get_array_length(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + if (!Array.isArray(jsValue)) { + return envObject.setLastError(8 /* napi_status.napi_array_expected */); + } + result >>>= 0; + const v = jsValue.length >>> 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, v, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ipppp + */ + function napi_get_arraybuffer_info(env, arraybuffer, data, byte_length) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!arraybuffer) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(arraybuffer); + if (!(jsValue instanceof ArrayBuffer) && !emnapiExternalMemory.isSharedArrayBuffer(jsValue)) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + // metadata is read through cached intrinsic getters (internal slots, like + // native Node-API): no user JS can run inside this call. Only emnapi's own + // getArrayBufferPointer() can still grow the memory (malloc for the copy of + // an external buffer), which detaches the previous non-shared buffer, so + // each value is resolved into a local BEFORE its makeSetValue write (the + // store target is evaluated before the RHS). + if (data) { + data >>>= 0; + const p = emnapiExternalMemory.getArrayBufferPointer(jsValue, true).address; + GET_HEAP_DATA_VIEW().setUint32(data, p, true); + } + if (byte_length) { + byte_length >>>= 0; + const len = emnapiExternalMemory.bufferByteLength(jsValue); + GET_HEAP_DATA_VIEW().setUint32(byte_length, len, true); + } + return envObject.clearLastError(); + } + /** + * @__sig ippp + */ + function node_api_set_prototype(env, object, value) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const obj = emnapiCtx.jsValueFromNapiValue(object); + if (obj == null) { + throw new TypeError('Cannot convert undefined or null to object'); + } + const type = typeof obj; + let v; + try { + v = (type === 'object' && obj !== null) || type === 'function' ? obj : Object(obj); + } + catch (_) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + const val = emnapiCtx.jsValueFromNapiValue(value); + Object.setPrototypeOf(v, val); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ippp + */ + function napi_get_prototype(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + if (jsValue == null) { + throw new TypeError('Cannot convert undefined or null to object'); + } + const type = typeof jsValue; + let v; + try { + v = (type === 'object' && jsValue !== null) || type === 'function' ? jsValue : Object(jsValue); + } + catch (_) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + result >>>= 0; + const p = emnapiCtx.napiValueFromJsValue(Object.getPrototypeOf(v)); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, p, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ippppppp + */ + function napi_get_typedarray_info(env, typedarray, type, length, data, arraybuffer, byte_offset) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!typedarray) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(typedarray); + if (!(emnapiExternalMemory.intrinsics.isView(jsValue))) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + let v = jsValue; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + // all view metadata (kind, buffer, byteOffset, length) is read through + // cached intrinsic prototype getters: like native Node-API they read the + // internal slots, never consult user accessors (no user JS can run inside + // this call) and work for instances from any realm. Only emnapi's own + // getViewPointer() can still grow the memory (malloc for the copy of an + // external buffer), which detaches the previous non-shared buffer, so each + // value is resolved into a local BEFORE its makeSetValue write (the store + // target is evaluated before the RHS). + if (type) { + type >>>= 0; + let t; + switch (emnapiExternalMemory.intrinsics.typedArray.tag.call(v)) { + case 'Int8Array': + t = 0 /* napi_typedarray_type.napi_int8_array */; + break; + case 'Uint8Array': + t = 1 /* napi_typedarray_type.napi_uint8_array */; + break; + case 'Uint8ClampedArray': + t = 2 /* napi_typedarray_type.napi_uint8_clamped_array */; + break; + case 'Int16Array': + t = 3 /* napi_typedarray_type.napi_int16_array */; + break; + case 'Uint16Array': + t = 4 /* napi_typedarray_type.napi_uint16_array */; + break; + case 'Int32Array': + t = 5 /* napi_typedarray_type.napi_int32_array */; + break; + case 'Uint32Array': + t = 6 /* napi_typedarray_type.napi_uint32_array */; + break; + case 'Float16Array': + t = 11 /* napi_typedarray_type.napi_float16_array */; + break; + case 'Float32Array': + t = 7 /* napi_typedarray_type.napi_float32_array */; + break; + case 'Float64Array': + t = 8 /* napi_typedarray_type.napi_float64_array */; + break; + case 'BigInt64Array': + t = 9 /* napi_typedarray_type.napi_bigint64_array */; + break; + case 'BigUint64Array': + t = 10 /* napi_typedarray_type.napi_biguint64_array */; + break; + default: + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + GET_HEAP_DATA_VIEW().setInt32(type, t, true); + } + v = emnapiExternalMemory.getOrUpdateMemoryView(v); + if (length) { + length >>>= 0; + const len = emnapiExternalMemory.viewLength(v); + GET_HEAP_DATA_VIEW().setUint32(length, len, true); + } + if (data || arraybuffer) { + if (data) { + data >>>= 0; + const vp = emnapiExternalMemory.getViewPointer(v, true); + v = vp.view; + const p = vp.address; + GET_HEAP_DATA_VIEW().setUint32(data, p, true); + } + if (arraybuffer) { + arraybuffer >>>= 0; + const ab = emnapiCtx.napiValueFromJsValue(emnapiExternalMemory.viewBuffer(v)); + GET_HEAP_DATA_VIEW().setUint32(arraybuffer, ab, true); + } + } + if (byte_offset) { + byte_offset >>>= 0; + const offset = emnapiExternalMemory.viewByteOffset(v); + GET_HEAP_DATA_VIEW().setUint32(byte_offset, offset, true); + } + return envObject.clearLastError(); + } + /** + * @__sig ipppp + */ + function napi_get_buffer_info(env, buffer, data, length) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!buffer) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(buffer); + const Buffer = emnapiCtx.features.Buffer; + const bool = (emnapiExternalMemory.intrinsics.isView(jsValue) || (typeof Buffer === 'function' && Buffer.isBuffer(jsValue))); + if (!bool) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + // any-realm slot-based classification: the intrinsic @@toStringTag getter + // returns undefined exactly for DataViews among ArrayBuffer views + if (emnapiExternalMemory.intrinsics.typedArray.tag.call(jsValue) === undefined) { + return napi_get_dataview_info(env, buffer, length, data, 0, 0); + } + return napi_get_typedarray_info(env, buffer, 0, length, data, 0, 0); + } + /** + * @__sig ipppppp + */ + function napi_get_dataview_info(env, dataview, byte_length, data, arraybuffer, byte_offset) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!dataview) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(dataview); + // any-realm slot-based classification (see napi_get_buffer_info) + if (!(emnapiExternalMemory.intrinsics.isView(jsValue)) || emnapiExternalMemory.intrinsics.typedArray.tag.call(jsValue) !== undefined) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + let v = emnapiExternalMemory.getOrUpdateMemoryView(jsValue); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + // all view metadata is read through cached intrinsic prototype getters: + // like native Node-API they read the internal slots, never consult user + // accessors (no user JS can run inside this call) and work for instances + // from any realm. Only emnapi's own getViewPointer() can still grow the + // memory (malloc for the copy of an external buffer), which detaches the + // previous non-shared buffer, so each value is resolved into a local + // BEFORE its makeSetValue write (the store target is evaluated before + // the RHS). + if (byte_length) { + byte_length >>>= 0; + const len = emnapiExternalMemory.viewLength(v); + GET_HEAP_DATA_VIEW().setUint32(byte_length, len, true); + } + if (data || arraybuffer) { + if (data) { + data >>>= 0; + const vp = emnapiExternalMemory.getViewPointer(v, true); + v = vp.view; + const p = vp.address; + GET_HEAP_DATA_VIEW().setUint32(data, p, true); + } + if (arraybuffer) { + arraybuffer >>>= 0; + const ab = emnapiCtx.napiValueFromJsValue(emnapiExternalMemory.viewBuffer(v)); + GET_HEAP_DATA_VIEW().setUint32(arraybuffer, ab, true); + } + } + if (byte_offset) { + byte_offset >>>= 0; + const offset = emnapiExternalMemory.viewByteOffset(v); + GET_HEAP_DATA_VIEW().setUint32(byte_offset, offset, true); + } + return envObject.clearLastError(); + } + /** + * @__sig ippp + */ + function napi_get_date_value(env, value, result) { + let v; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + if (!(jsValue instanceof Date)) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + result >>>= 0; + v = jsValue.valueOf(); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setFloat64(result, v, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ippp + */ + function napi_get_value_bool(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + if (typeof jsValue !== 'boolean') { + return envObject.setLastError(7 /* napi_status.napi_boolean_expected */); + } + result >>>= 0; + const r = jsValue ? 1 : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(result, r, true); + return envObject.clearLastError(); + } + /** + * @__sig ippp + */ + function napi_get_value_double(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + if (typeof jsValue !== 'number') { + return envObject.setLastError(6 /* napi_status.napi_number_expected */); + } + result >>>= 0; + const r = jsValue; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setFloat64(result, r, true); + return envObject.clearLastError(); + } + /** + * @__sig ipppp + */ + function napi_get_value_bigint_int64(env, value, result, lossless) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!emnapiCtx.features.BigInt) { + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!lossless) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + let numberValue = emnapiCtx.jsValueFromNapiValue(value); + if (typeof numberValue !== 'bigint') { + return envObject.setLastError(6 /* napi_status.napi_number_expected */); + } + lossless >>>= 0; + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + if ((numberValue >= (BigInt(-1) * (BigInt(1) << BigInt(63)))) && (numberValue < (BigInt(1) << BigInt(63)))) { + GET_HEAP_DATA_VIEW().setInt8(lossless, 1, true); + } + else { + GET_HEAP_DATA_VIEW().setInt8(lossless, 0, true); + numberValue = numberValue & ((BigInt(1) << BigInt(64)) - BigInt(1)); + if (numberValue >= (BigInt(1) << BigInt(63))) { + numberValue = numberValue - (BigInt(1) << BigInt(64)); + } + } + const low = Number(numberValue & BigInt(0xffffffff)); + const high = Number(numberValue >> BigInt(32)); + GET_HEAP_DATA_VIEW().setInt32(result, low, true); + GET_HEAP_DATA_VIEW().setInt32(result + 4, high, true); + return envObject.clearLastError(); + } + /** + * @__sig ipppp + */ + function napi_get_value_bigint_uint64(env, value, result, lossless) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!emnapiCtx.features.BigInt) { + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!lossless) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + let numberValue = emnapiCtx.jsValueFromNapiValue(value); + if (typeof numberValue !== 'bigint') { + return envObject.setLastError(6 /* napi_status.napi_number_expected */); + } + lossless >>>= 0; + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + if ((numberValue >= BigInt(0)) && (numberValue < (BigInt(1) << BigInt(64)))) { + GET_HEAP_DATA_VIEW().setInt8(lossless, 1, true); + } + else { + GET_HEAP_DATA_VIEW().setInt8(lossless, 0, true); + numberValue = numberValue & ((BigInt(1) << BigInt(64)) - BigInt(1)); + } + const low = Number(numberValue & BigInt(0xffffffff)); + const high = Number(numberValue >> BigInt(32)); + GET_HEAP_DATA_VIEW().setUint32(result, low, true); + GET_HEAP_DATA_VIEW().setUint32(result + 4, high, true); + return envObject.clearLastError(); + } + /** + * @__sig ippppp + */ + function napi_get_value_bigint_words(env, value, sign_bit, word_count, words) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!emnapiCtx.features.BigInt) { + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!word_count) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + if (typeof jsValue !== 'bigint') { + return envObject.setLastError(17 /* napi_status.napi_bigint_expected */); + } + const isMinus = jsValue < BigInt(0); + sign_bit >>>= 0; + words >>>= 0; + word_count >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + let word_count_int = GET_HEAP_DATA_VIEW().getUint32(word_count, true); + word_count_int >>>= 0; + let wordCount = 0; + let bigintValue = isMinus ? (jsValue * BigInt(-1)) : jsValue; + while (bigintValue !== BigInt(0)) { + wordCount++; + bigintValue = bigintValue >> BigInt(64); + } + bigintValue = isMinus ? (jsValue * BigInt(-1)) : jsValue; + if (!sign_bit && !words) { + word_count_int = wordCount; + GET_HEAP_DATA_VIEW().setUint32(word_count, word_count_int, true); + } + else { + if (!sign_bit) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!words) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const wordsArr = []; + while (bigintValue !== BigInt(0)) { + const uint64 = bigintValue & ((BigInt(1) << BigInt(64)) - BigInt(1)); + wordsArr.push(uint64); + bigintValue = bigintValue >> BigInt(64); + } + const len = Math.min(word_count_int, wordsArr.length); + for (let i = 0; i < len; i++) { + const low = Number(wordsArr[i] & BigInt(0xffffffff)); + const high = Number(wordsArr[i] >> BigInt(32)); + GET_HEAP_DATA_VIEW().setUint32(words + i * 8, low, true); + GET_HEAP_DATA_VIEW().setUint32(words + (i * 8 + 4), high, true); + } + GET_HEAP_DATA_VIEW().setInt32(sign_bit, isMinus ? 1 : 0, true); + GET_HEAP_DATA_VIEW().setUint32(word_count, len, true); + } + return envObject.clearLastError(); + } + /** + * @__sig ippp + */ + function napi_get_value_external(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + if (!emnapiCtx.isExternal(jsValue)) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + result >>>= 0; + const p = emnapiCtx.getExternalValue(jsValue); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, p, true); + return envObject.clearLastError(); + } + /** + * @__sig ippp + */ + function napi_get_value_int32(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + if (typeof jsValue !== 'number') { + return envObject.setLastError(6 /* napi_status.napi_number_expected */); + } + result >>>= 0; + const v = new Int32Array([jsValue])[0]; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt32(result, v, true); + return envObject.clearLastError(); + } + /** + * @__sig ippp + */ + function napi_get_value_int64(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + if (typeof jsValue !== 'number') { + return envObject.setLastError(6 /* napi_status.napi_number_expected */); + } + const numberValue = jsValue; + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + if (numberValue === Number.POSITIVE_INFINITY || numberValue === Number.NEGATIVE_INFINITY || isNaN(numberValue)) { + GET_HEAP_DATA_VIEW().setInt32(result, 0, true); + GET_HEAP_DATA_VIEW().setInt32(result + 4, 0, true); + } + else if (numberValue < /* INT64_RANGE_NEGATIVE */ -9223372036854776e3) { + GET_HEAP_DATA_VIEW().setInt32(result, 0, true); + GET_HEAP_DATA_VIEW().setInt32(result + 4, 2147483648, true); + } + else if (numberValue >= /* INT64_RANGE_POSITIVE */ 9223372036854776000) { + GET_HEAP_DATA_VIEW().setUint32(result, 4294967295, true); + GET_HEAP_DATA_VIEW().setUint32(result + 4, 2147483647, true); + } + else { + $emnapiSetValueI64(result, Math.trunc(numberValue)); + } + return envObject.clearLastError(); + } + /** + * @__sig ippppp + */ + function napi_get_value_string_latin1(env, value, buf, buf_size, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + result >>>= 0; + buf >>>= 0; + buf_size >>>= 0; + buf_size = buf_size >>> 0; + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + if (typeof jsValue !== 'string') { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + if (!buf) { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + GET_HEAP_DATA_VIEW().setUint32(result, jsValue.length, true); + } + else if (buf_size !== 0) { + let copied = 0; + let v; + for (let i = 0; i < buf_size - 1; ++i) { + v = jsValue.charCodeAt(i) & 0xff; + GET_HEAP_DATA_VIEW().setUint8(buf + i, v, true); + copied++; + } + GET_HEAP_DATA_VIEW().setUint8(buf + copied, 0, true); + if (result) { + GET_HEAP_DATA_VIEW().setUint32(result, copied, true); + } + } + else if (result) { + GET_HEAP_DATA_VIEW().setUint32(result, 0, true); + } + return envObject.clearLastError(); + } + /** + * @__sig ippppp + */ + function napi_get_value_string_utf8(env, value, buf, buf_size, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + result >>>= 0; + buf >>>= 0; + buf_size >>>= 0; + buf_size = buf_size >>> 0; + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + if (typeof jsValue !== 'string') { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + if (!buf) { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const strLength = emnapiString.lengthBytesUTF8(jsValue); + GET_HEAP_DATA_VIEW().setUint32(result, strLength, true); + } + else if (buf_size !== 0) { + const copied = emnapiString.stringToUTF8(jsValue, buf, buf_size); + if (result) { + GET_HEAP_DATA_VIEW().setUint32(result, copied, true); + } + } + else if (result) { + GET_HEAP_DATA_VIEW().setUint32(result, 0, true); + } + return envObject.clearLastError(); + } + /** + * @__sig ippppp + */ + function napi_get_value_string_utf16(env, value, buf, buf_size, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + result >>>= 0; + buf >>>= 0; + buf_size >>>= 0; + buf_size = buf_size >>> 0; + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + if (typeof jsValue !== 'string') { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + if (!buf) { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + GET_HEAP_DATA_VIEW().setUint32(result, jsValue.length, true); + } + else if (buf_size !== 0) { + const copied = emnapiString.stringToUTF16(jsValue, buf, buf_size * 2); + if (result) { + GET_HEAP_DATA_VIEW().setUint32(result, copied / 2, true); + } + } + else if (result) { + GET_HEAP_DATA_VIEW().setUint32(result, 0, true); + } + return envObject.clearLastError(); + } + /** + * @__sig ippp + */ + function napi_get_value_uint32(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + if (typeof jsValue !== 'number') { + return envObject.setLastError(6 /* napi_status.napi_number_expected */); + } + result >>>= 0; + const v = new Uint32Array([jsValue])[0]; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, v, true); + return envObject.clearLastError(); + } + + //#endregion src/value/convert2c.ts + + var convert2cMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + napi_get_array_length: napi_get_array_length, + napi_get_arraybuffer_info: napi_get_arraybuffer_info, + napi_get_buffer_info: napi_get_buffer_info, + napi_get_dataview_info: napi_get_dataview_info, + napi_get_date_value: napi_get_date_value, + napi_get_prototype: napi_get_prototype, + napi_get_typedarray_info: napi_get_typedarray_info, + napi_get_value_bigint_int64: napi_get_value_bigint_int64, + napi_get_value_bigint_uint64: napi_get_value_bigint_uint64, + napi_get_value_bigint_words: napi_get_value_bigint_words, + napi_get_value_bool: napi_get_value_bool, + napi_get_value_double: napi_get_value_double, + napi_get_value_external: napi_get_value_external, + napi_get_value_int32: napi_get_value_int32, + napi_get_value_int64: napi_get_value_int64, + napi_get_value_string_latin1: napi_get_value_string_latin1, + napi_get_value_string_utf16: napi_get_value_string_utf16, + napi_get_value_string_utf8: napi_get_value_string_utf8, + napi_get_value_uint32: napi_get_value_uint32, + node_api_set_prototype: node_api_set_prototype + }); + + //#region src/value/convert2napi.ts + /** + * @__sig ipip + */ + function napi_create_int32(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + result >>>= 0; + const v = emnapiCtx.napiValueFromJsValue(value); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, v, true); + return envObject.clearLastError(); + } + /** + * @__sig ipip + */ + function napi_create_uint32(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + result >>>= 0; + const v = emnapiCtx.napiValueFromJsValue(value >>> 0); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, v, true); + return envObject.clearLastError(); + } + /** + * @__sig ipjp + */ + function napi_create_int64(env, low, high, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + let value; + if (!high) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + value = Number(low); + const v1 = emnapiCtx.napiValueFromJsValue(value); + high >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(high, v1, true); + return envObject.clearLastError(); + } + /** + * @__sig ipdp + */ + function napi_create_double(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + result >>>= 0; + const v = emnapiCtx.napiValueFromJsValue(value); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, v, true); + return envObject.clearLastError(); + } + /** + * @__sig ipppp + */ + function napi_create_string_latin1(env, str, length, result) { + return emnapiString.newString(env, str, length, result, (str, autoLength, sizeLength) => { + return emnapiString.encode(str, autoLength, sizeLength, (c) => String.fromCharCode(c)); + }); + } + /** + * @__sig ipppp + */ + function napi_create_string_utf16(env, str, length, result) { + return emnapiString.newString(env, str, length, result, (str) => { + return emnapiString.UTF16ToString(str, length); + }); + } + /** + * @__sig ipppp + */ + function napi_create_string_utf8(env, str, length, result) { + return emnapiString.newString(env, str, length, result, (str) => { + return emnapiString.UTF8ToString(str, length); + }); + } + /** + * @__sig ippppppp + */ + function node_api_create_external_string_latin1(env, str, length, finalize_callback, finalize_hint, result, copied) { + return emnapiString.newExternalString(env, str, length, finalize_callback, finalize_hint, result, copied, napi_create_string_latin1, undefined); + } + /** + * @__sig ippppppp + */ + function node_api_create_external_string_utf16(env, str, length, finalize_callback, finalize_hint, result, copied) { + return emnapiString.newExternalString(env, str, length, finalize_callback, finalize_hint, result, copied, napi_create_string_utf16, undefined); + } + /** + * @__sig ipppp + */ + function node_api_create_property_key_latin1(env, str, length, result) { + return napi_create_string_latin1(env, str, length, result); + } + /** + * @__sig ipppp + */ + function node_api_create_property_key_utf8(env, str, length, result) { + return napi_create_string_utf8(env, str, length, result); + } + /** + * @__sig ipppp + */ + function node_api_create_property_key_utf16(env, str, length, result) { + return napi_create_string_utf16(env, str, length, result); + } + /** + * @__sig ipjp + */ + function napi_create_bigint_int64(env, low, high, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!emnapiCtx.features.BigInt) { + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + let value; + if (!high) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + value = low; + const v1 = emnapiCtx.napiValueFromJsValue(value); + high >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(high, v1, true); + return envObject.clearLastError(); + } + /** + * @__sig ipjp + */ + function napi_create_bigint_uint64(env, low, high, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!emnapiCtx.features.BigInt) { + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + let value; + if (!high) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + value = low & ((BigInt(1) << BigInt(64)) - BigInt(1)); + const v1 = emnapiCtx.napiValueFromJsValue(value); + high >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(high, v1, true); + return envObject.clearLastError(); + } + /** + * @__sig ipippp + */ + function napi_create_bigint_words(env, sign_bit, word_count, words, result) { + let v, i; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!emnapiCtx.features.BigInt) { + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + words >>>= 0; + word_count >>>= 0; + word_count = word_count >>> 0; + if (word_count > 2147483647) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + if (word_count > (1024 * 1024 / (4 * 8) / 2)) { + throw new RangeError('Maximum BigInt size exceeded'); + } + let value = BigInt(0); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + for (i = 0; i < word_count; i++) { + const low = GET_HEAP_DATA_VIEW().getUint32(words + i * 8, true); + const high = GET_HEAP_DATA_VIEW().getUint32(words + (i * 8 + 4), true); + const wordi = BigInt(low) | (BigInt(high) << BigInt(32)); + value += wordi << BigInt(64 * i); + } + value *= ((BigInt(sign_bit) % BigInt(2) === BigInt(0)) ? BigInt(1) : BigInt(-1)); + result >>>= 0; + v = emnapiCtx.napiValueFromJsValue(value); + GET_HEAP_DATA_VIEW().setUint32(result, v, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + + //#endregion src/value/convert2napi.ts + + var convert2napiMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + napi_create_bigint_int64: napi_create_bigint_int64, + napi_create_bigint_uint64: napi_create_bigint_uint64, + napi_create_bigint_words: napi_create_bigint_words, + napi_create_double: napi_create_double, + napi_create_int32: napi_create_int32, + napi_create_int64: napi_create_int64, + napi_create_string_latin1: napi_create_string_latin1, + napi_create_string_utf16: napi_create_string_utf16, + napi_create_string_utf8: napi_create_string_utf8, + napi_create_uint32: napi_create_uint32, + node_api_create_external_string_latin1: node_api_create_external_string_latin1, + node_api_create_external_string_utf16: node_api_create_external_string_utf16, + node_api_create_property_key_latin1: node_api_create_property_key_latin1, + node_api_create_property_key_utf16: node_api_create_property_key_utf16, + node_api_create_property_key_utf8: node_api_create_property_key_utf8 + }); + + //#region src/internal.ts + function emnapiCreateFunction(envObject, utf8name, length, cb, data) { + utf8name >>>= 0; + const functionName = (!utf8name || !length) ? '' : (emnapiString.UTF8ToString(utf8name, length)); + let dynamicExecution; + dynamicExecution = true; + if (!functionName) { + return { + status: 0 /* napi_status.napi_ok */, + f: emnapiCtx.createFunction(envObject, (wasmTable.get(cb)), data, functionName, dynamicExecution) + }; + } + if (!(/^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(functionName))) { + return { status: 1 /* napi_status.napi_invalid_arg */, f: undefined }; + } + return { + status: 0 /* napi_status.napi_ok */, + f: emnapiCtx.createFunction(envObject, (wasmTable.get(cb)), data, functionName, dynamicExecution) + }; + } + function emnapiDefineProperty(envObject, obj, propertyName, method, getter, setter, value, attributes, data) { + if (getter || setter) { + let localGetter; + let localSetter; + if (getter) { + localGetter = emnapiCreateFunction(envObject, 0, 0, getter, data).f; + } + if (setter) { + localSetter = emnapiCreateFunction(envObject, 0, 0, setter, data).f; + } + const desc = { + configurable: (attributes & 4 /* napi_property_attributes.napi_configurable */) !== 0, + enumerable: (attributes & 2 /* napi_property_attributes.napi_enumerable */) !== 0, + get: localGetter, + set: localSetter + }; + Object.defineProperty(obj, propertyName, desc); + } + else if (method) { + const localMethod = emnapiCreateFunction(envObject, 0, 0, method, data).f; + const desc = { + configurable: (attributes & 4 /* napi_property_attributes.napi_configurable */) !== 0, + enumerable: (attributes & 2 /* napi_property_attributes.napi_enumerable */) !== 0, + writable: (attributes & 1 /* napi_property_attributes.napi_writable */) !== 0, + value: localMethod + }; + Object.defineProperty(obj, propertyName, desc); + } + else { + const desc = { + configurable: (attributes & 4 /* napi_property_attributes.napi_configurable */) !== 0, + enumerable: (attributes & 2 /* napi_property_attributes.napi_enumerable */) !== 0, + writable: (attributes & 1 /* napi_property_attributes.napi_writable */) !== 0, + value: emnapiCtx.jsValueFromNapiValue(value) + }; + Object.defineProperty(obj, propertyName, desc); + } + } + function emnapiGetHandle(js_object) { + let jsValue = emnapiCtx.jsValueFromNapiValue(js_object); + const type = typeof jsValue; + if (!((type === 'object' && jsValue !== null) || type === 'function')) { + return { status: 1 /* napi_status.napi_invalid_arg */ }; + } + if (typeof emnapiExternalMemory !== 'undefined' && ArrayBuffer.isView(jsValue)) { + if (emnapiExternalMemory.wasmMemoryViewTable.has(jsValue)) { + jsValue = emnapiExternalMemory.wasmMemoryViewTable.get(jsValue); + } + } + return { status: 0 /* napi_status.napi_ok */, value: jsValue }; + } + function emnapiWrap(env, js_object, native_object, finalize_cb, finalize_hint, result) { + let referenceId; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!emnapiCtx.features.finalizer) { + if (finalize_cb) { + throw emnapiCtx.createNotSupportWeakRefError('napi_wrap', 'Parameter "finalize_cb" must be 0(NULL)'); + } + if (result) { + throw emnapiCtx.createNotSupportWeakRefError('napi_wrap', 'Parameter "result" must be 0(NULL)'); + } + } + if (!js_object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const handleResult = emnapiGetHandle(js_object); + if (handleResult.status !== 0 /* napi_status.napi_ok */) { + return envObject.setLastError(handleResult.status); + } + const v = handleResult.value; + if (envObject.getObjectBinding(v).wrapped !== 0) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + const id = emnapiCtx.napiValueFromJsValue(v); + let reference; + if (result) { + if (!finalize_cb) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + reference = emnapiCtx.createReferenceWithFinalizer(envObject, id, 0, 1 /* ReferenceOwnership.kUserland */, finalize_cb, native_object, finalize_hint); + result >>>= 0; + referenceId = reference.id; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, referenceId, true); + } + else { + if (finalize_cb) { + reference = emnapiCtx.createReferenceWithFinalizer(envObject, id, 0, 0 /* ReferenceOwnership.kRuntime */, finalize_cb, native_object, finalize_hint); + } + else { + reference = emnapiCtx.createReferenceWithData(envObject, id, 0, 0 /* ReferenceOwnership.kRuntime */, native_object); + } + } + envObject.getObjectBinding(v).wrapped = reference.id; + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + function emnapiUnwrap(env, js_object, result, action) { + let data; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!js_object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (action === 0 /* UnwrapAction.KeepWrap */) { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + const value = emnapiCtx.jsValueFromNapiValue(js_object); + const type = typeof value; + if (!((type === 'object' && value !== null) || type === 'function')) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + const binding = envObject.getObjectBinding(value); + const referenceId = binding.wrapped; + const ref = emnapiCtx.getRef(referenceId); + if (!ref) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (result) { + result >>>= 0; + data = ref.data(); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, data, true); + } + if (action === 1 /* UnwrapAction.RemoveWrap */) { + binding.wrapped = 0; + if (ref.ownership() === 1 /* ReferenceOwnership.kUserland */) { + // When the wrap is been removed, the finalizer should be reset. + ref.resetFinalizer(); + } + else { + ref.dispose(); + } + } + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + + //#endregion src/internal.ts + + //#region src/wrap.ts + /** + * @__sig ipppppppp + */ + function napi_define_class(env, utf8name, length, constructor, callback_data, property_count, properties, result) { + let propPtr, valueHandleId, attributes; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!constructor) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + length >>>= 0; + properties >>>= 0; + property_count >>>= 0; + property_count = property_count >>> 0; + if (property_count > 0) { + if (!properties) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + if (!((length >= -1 && length <= 2147483647) || length === 4294967295) || (!utf8name)) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + const fresult = emnapiCreateFunction(envObject, utf8name, length, constructor, callback_data); + if (fresult.status !== 0 /* napi_status.napi_ok */) + return envObject.setLastError(fresult.status); + const F = fresult.f; + let propertyName; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + for (let i = 0; i < property_count; i++) { + propPtr = properties + (i * (4 * 8)); + const utf8Name = GET_HEAP_DATA_VIEW().getUint32(propPtr, true); + const name = GET_HEAP_DATA_VIEW().getUint32(propPtr + 4, true); + const method = GET_HEAP_DATA_VIEW().getUint32(propPtr + 8, true); + const getter = GET_HEAP_DATA_VIEW().getUint32(propPtr + 12, true); + const setter = GET_HEAP_DATA_VIEW().getUint32(propPtr + 16, true); + const value = GET_HEAP_DATA_VIEW().getUint32(propPtr + 20, true); + attributes = GET_HEAP_DATA_VIEW().getInt32(propPtr + 24, true); + attributes >>>= 0; + const data = GET_HEAP_DATA_VIEW().getUint32(propPtr + 28, true); + if (utf8Name) { + propertyName = emnapiString.UTF8ToString(utf8Name, -1); + } + else { + if (!name) { + return envObject.setLastError(4 /* napi_status.napi_name_expected */); + } + propertyName = emnapiCtx.jsValueFromNapiValue(name); + if (typeof propertyName !== 'string' && typeof propertyName !== 'symbol') { + return envObject.setLastError(4 /* napi_status.napi_name_expected */); + } + } + if ((attributes & 1024 /* napi_property_attributes.napi_static */) !== 0) { + emnapiDefineProperty(envObject, F, propertyName, method, getter, setter, value, attributes, data); + continue; + } + emnapiDefineProperty(envObject, F.prototype, propertyName, method, getter, setter, value, attributes, data); + } + valueHandleId = emnapiCtx.napiValueFromJsValue(F); + result >>>= 0; + GET_HEAP_DATA_VIEW().setUint32(result, valueHandleId, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ipppppp + */ + function napi_wrap(env, js_object, native_object, finalize_cb, finalize_hint, result) { + return emnapiWrap(env, js_object, native_object, finalize_cb, finalize_hint, result); + } + /** + * @__sig ippp + */ + function napi_unwrap(env, js_object, result) { + return emnapiUnwrap(env, js_object, result, 0 /* UnwrapAction.KeepWrap */); + } + /** + * @__sig ippp + */ + function napi_remove_wrap(env, js_object, result) { + return emnapiUnwrap(env, js_object, result, 1 /* UnwrapAction.RemoveWrap */); + } + /** + * @__sig ippp + */ + function napi_type_tag_object(env, object, type_tag) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!object) { + return envObject.setLastError(!envObject.lastException.isEmpty() ? 10 /* napi_status.napi_pending_exception */ : 1 /* napi_status.napi_invalid_arg */); + } + const value = emnapiCtx.jsValueFromNapiValue(object); + const type = typeof value; + if (!((type === 'object' && value !== null) || type === 'function')) { + return envObject.setLastError(!envObject.lastException.isEmpty() ? 10 /* napi_status.napi_pending_exception */ : 2 /* napi_status.napi_object_expected */); + } + type_tag >>>= 0; + if (!type_tag) { + return envObject.setLastError(!envObject.lastException.isEmpty() ? 10 /* napi_status.napi_pending_exception */ : 1 /* napi_status.napi_invalid_arg */); + } + const binding = envObject.getObjectBinding(value); + if (binding.tag !== null) { + return envObject.setLastError(!envObject.lastException.isEmpty() ? 10 /* napi_status.napi_pending_exception */ : 1 /* napi_status.napi_invalid_arg */); + } + const tag = new Uint8Array(16); + tag.set(new Uint8Array(wasmMemory.buffer, type_tag, 16)); + binding.tag = new Uint32Array(tag.buffer); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ipppp + */ + function napi_check_object_type_tag(env, object, type_tag, result) { + // eslint-disable-next-line one-var + let ret = true; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!object) { + return envObject.setLastError(!envObject.lastException.isEmpty() ? 10 /* napi_status.napi_pending_exception */ : 1 /* napi_status.napi_invalid_arg */); + } + const value = emnapiCtx.jsValueFromNapiValue(object); + const type = typeof value; + if (!((type === 'object' && value !== null) || type === 'function')) { + return envObject.setLastError(!envObject.lastException.isEmpty() ? 10 /* napi_status.napi_pending_exception */ : 2 /* napi_status.napi_object_expected */); + } + if (!type_tag) { + return envObject.setLastError(!envObject.lastException.isEmpty() ? 10 /* napi_status.napi_pending_exception */ : 1 /* napi_status.napi_invalid_arg */); + } + if (!result) { + return envObject.setLastError(!envObject.lastException.isEmpty() ? 10 /* napi_status.napi_pending_exception */ : 1 /* napi_status.napi_invalid_arg */); + } + const binding = envObject.getObjectBinding(value); + if (binding.tag !== null) { + type_tag >>>= 0; + const tag = binding.tag; + const typeTag = new Uint32Array(wasmMemory.buffer, type_tag, 4); + ret = (tag[0] === typeTag[0] && + tag[1] === typeTag[1] && + tag[2] === typeTag[2] && + tag[3] === typeTag[3]); + } + else { + ret = false; + } + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(result, ret ? 1 : 0, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ipppppp + */ + function napi_add_finalizer(env, js_object, finalize_data, finalize_cb, finalize_hint, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!emnapiCtx.features.finalizer) { + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + if (!js_object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!finalize_cb) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const handleResult = emnapiGetHandle(js_object); + if (handleResult.status !== 0 /* napi_status.napi_ok */) { + return envObject.setLastError(handleResult.status); + } + const id = emnapiCtx.napiValueFromJsValue(handleResult.value); + const ownership = !result ? 0 /* ReferenceOwnership.kRuntime */ : 1 /* ReferenceOwnership.kUserland */; + finalize_data >>>= 0; + finalize_cb >>>= 0; + finalize_hint >>>= 0; + const reference = emnapiCtx.createReferenceWithFinalizer(envObject, id, 0, ownership, finalize_cb, finalize_data, finalize_hint); + if (result) { + result >>>= 0; + const referenceId = reference.id; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, referenceId, true); + } + return envObject.clearLastError(); + } + /** + * @__sig ipppp + */ + function node_api_post_finalizer(env, finalize_cb, finalize_data, finalize_hint) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + const envObject = emnapiEnv; + envObject.enqueueFinalizer(emnapiCtx.createTrackedFinalizer(envObject, finalize_cb, finalize_data, finalize_hint)); + return envObject.clearLastError(); + } + + //#endregion src/wrap.ts + + var wrapMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + napi_add_finalizer: napi_add_finalizer, + napi_check_object_type_tag: napi_check_object_type_tag, + napi_define_class: napi_define_class, + napi_remove_wrap: napi_remove_wrap, + napi_type_tag_object: napi_type_tag_object, + napi_unwrap: napi_unwrap, + napi_wrap: napi_wrap, + node_api_post_finalizer: node_api_post_finalizer + }); + + //#region src/emnapi.ts + /** + * @__sig vpippi + */ + function emnapi_debug(file, lineno, str, ptr, type) { + str >>>= 0; + file >>>= 0; + const string = str ? emnapiString.UTF8ToString(str, -1) : ''; + const message = `[emnapi_debug] ${emnapiString.UTF8ToString(file, -1)}:${lineno} ${string} ${ptr}`; + const logArgs = [message]; + if (ptr) { + logArgs.push(type === 1 ? emnapiCtx.isolate.getRef(ptr) : emnapiCtx.jsValueFromNapiValue(ptr)); + } + console.log(...logArgs); + // eslint-disable-next-line no-debugger + debugger; + } + /** + * @__sig ipippppp + */ + function emnapi_create_memory_view(env, typedarray_type, external_data, byte_length, finalize_cb, finalize_hint, result) { + let value; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + byte_length >>>= 0; + external_data >>>= 0; + result >>>= 0; + byte_length = byte_length >>> 0; + if (!external_data) { + byte_length = 0; + } + if (byte_length > 2147483647) { + throw new RangeError('Cannot create a memory view larger than 2147483647 bytes'); + } + if ((external_data + byte_length) > wasmMemory.buffer.byteLength) { + throw new RangeError('Memory out of range'); + } + if (!emnapiCtx.features.finalizer && finalize_cb) { + throw emnapiCtx.createNotSupportWeakRefError('emnapi_create_memory_view', 'Parameter "finalize_cb" must be 0(NULL)'); + } + let viewDescriptor; + switch (typedarray_type) { + case 0 /* emnapi_memory_view_type.emnapi_int8_array */: + viewDescriptor = { Ctor: Int8Array, address: external_data, length: byte_length, ownership: 1 /* ReferenceOwnership.kUserland */, runtimeAllocated: 0 }; + break; + case 1 /* emnapi_memory_view_type.emnapi_uint8_array */: + viewDescriptor = { Ctor: Uint8Array, address: external_data, length: byte_length, ownership: 1 /* ReferenceOwnership.kUserland */, runtimeAllocated: 0 }; + break; + case 2 /* emnapi_memory_view_type.emnapi_uint8_clamped_array */: + viewDescriptor = { Ctor: Uint8ClampedArray, address: external_data, length: byte_length, ownership: 1 /* ReferenceOwnership.kUserland */, runtimeAllocated: 0 }; + break; + case 3 /* emnapi_memory_view_type.emnapi_int16_array */: + viewDescriptor = { Ctor: Int16Array, address: external_data, length: byte_length >> 1, ownership: 1 /* ReferenceOwnership.kUserland */, runtimeAllocated: 0 }; + break; + case 4 /* emnapi_memory_view_type.emnapi_uint16_array */: + viewDescriptor = { Ctor: Uint16Array, address: external_data, length: byte_length >> 1, ownership: 1 /* ReferenceOwnership.kUserland */, runtimeAllocated: 0 }; + break; + case 5 /* emnapi_memory_view_type.emnapi_int32_array */: + viewDescriptor = { Ctor: Int32Array, address: external_data, length: byte_length >> 2, ownership: 1 /* ReferenceOwnership.kUserland */, runtimeAllocated: 0 }; + break; + case 6 /* emnapi_memory_view_type.emnapi_uint32_array */: + viewDescriptor = { Ctor: Uint32Array, address: external_data, length: byte_length >> 2, ownership: 1 /* ReferenceOwnership.kUserland */, runtimeAllocated: 0 }; + break; + case 7 /* emnapi_memory_view_type.emnapi_float32_array */: + viewDescriptor = { Ctor: Float32Array, address: external_data, length: byte_length >> 2, ownership: 1 /* ReferenceOwnership.kUserland */, runtimeAllocated: 0 }; + break; + case 8 /* emnapi_memory_view_type.emnapi_float64_array */: + viewDescriptor = { Ctor: Float64Array, address: external_data, length: byte_length >> 3, ownership: 1 /* ReferenceOwnership.kUserland */, runtimeAllocated: 0 }; + break; + case 9 /* emnapi_memory_view_type.emnapi_bigint64_array */: + viewDescriptor = { Ctor: BigInt64Array, address: external_data, length: byte_length >> 3, ownership: 1 /* ReferenceOwnership.kUserland */, runtimeAllocated: 0 }; + break; + case 10 /* emnapi_memory_view_type.emnapi_biguint64_array */: + viewDescriptor = { Ctor: BigUint64Array, address: external_data, length: byte_length >> 3, ownership: 1 /* ReferenceOwnership.kUserland */, runtimeAllocated: 0 }; + break; + case -1 /* emnapi_memory_view_type.emnapi_data_view */: + viewDescriptor = { Ctor: DataView, address: external_data, length: byte_length, ownership: 1 /* ReferenceOwnership.kUserland */, runtimeAllocated: 0 }; + break; + case 11 /* emnapi_memory_view_type.emnapi_float16_array */: + if (typeof Float16Array !== 'function') { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + viewDescriptor = { Ctor: Float16Array, address: external_data, length: byte_length >> 1, ownership: 1 /* ReferenceOwnership.kUserland */, runtimeAllocated: 0 }; + break; + case -2 /* emnapi_memory_view_type.emnapi_buffer */: { + if (!emnapiCtx.features.Buffer) { + throw emnapiCtx.createNotSupportBufferError('emnapi_create_memory_view', ''); + } + viewDescriptor = { Ctor: emnapiCtx.features.Buffer, address: external_data, length: byte_length, ownership: 1 /* ReferenceOwnership.kUserland */, runtimeAllocated: 0 }; + break; + } + default: return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + const Ctor = viewDescriptor.Ctor; + const typedArray = typedarray_type === -2 /* emnapi_memory_view_type.emnapi_buffer */ + // capture Buffer.from at creation so a later refreshed view uses it + ? emnapiExternalMemory.getBufferFrom()(wasmMemory.buffer, viewDescriptor.address, viewDescriptor.length) + : new Ctor(wasmMemory.buffer, viewDescriptor.address, viewDescriptor.length); + value = emnapiCtx.napiValueFromJsValue(typedArray); + emnapiExternalMemory.wasmMemoryViewTable.set(typedArray, viewDescriptor); + if (finalize_cb) { + const status = napi_add_finalizer(env, value, external_data, finalize_cb, finalize_hint, /* NULL */ 0); + if (status === 10 /* napi_status.napi_pending_exception */) { + const err = envObject.lastException.deref(); + envObject.clearLastError(); + envObject.lastException.reset(); + throw err; + } + else if (status !== 0 /* napi_status.napi_ok */) { + return envObject.setLastError(status); + } + } + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig i + */ + function emnapi_is_support_weakref() { + return emnapiCtx.features.finalizer ? 1 : 0; + } + /** + * @__sig i + */ + function emnapi_is_support_bigint() { + return emnapiCtx.features.BigInt ? 1 : 0; + } + /** + * @__sig i + */ + function emnapi_is_node_binding_available() { + return emnapiNodeBinding ? 1 : 0; + } + /** + * Synchronize data between the wasm memory and an ArrayBuffer / view. + * + * Note: when a non-shared wasm memory has grown, a view over the detached + * old buffer is re-created over the current buffer through the intrinsic + * base-class constructor, so for view inputs the returned view may be a + * base-class instance (e.g. `Uint8Array` or `DataView`) instead of the + * subclass that was passed in. + */ + function $emnapiSyncMemory(js_to_wasm, arrayBufferOrView, offset, len) { + offset = offset ?? 0; + offset = offset >>> 0; + let view; + if (arrayBufferOrView instanceof ArrayBuffer || emnapiExternalMemory.isSharedArrayBuffer(arrayBufferOrView)) { + const pointer = emnapiExternalMemory.getArrayBufferPointer(arrayBufferOrView, false).address; + if (!pointer) + throw new Error('Unknown ArrayBuffer address'); + if (typeof len !== 'number' || len === -1 || len === 4294967295) { + len = arrayBufferOrView.byteLength - offset; + } + len = len >>> 0; + if (len === 0) + return arrayBufferOrView; + view = new Uint8Array(arrayBufferOrView, offset, len); + const wasmMemoryU8 = new Uint8Array(wasmMemory.buffer); + if (!js_to_wasm) { + view.set(wasmMemoryU8.subarray(pointer, pointer + len)); + } + else { + wasmMemoryU8.set(view, pointer); + } + return arrayBufferOrView; + } + if (ArrayBuffer.isView(arrayBufferOrView)) { + const viewPointerInfo = emnapiExternalMemory.getViewPointer(arrayBufferOrView, false); + const latestView = viewPointerInfo.view; + const pointer = viewPointerInfo.address; + if (!pointer) + throw new Error('Unknown ArrayBuffer address'); + if (typeof len !== 'number' || len === -1 || len === 4294967295) { + len = latestView.byteLength - offset; + } + len = len >>> 0; + if (len === 0) + return latestView; + view = new Uint8Array(latestView.buffer, latestView.byteOffset + offset, len); + const wasmMemoryU8 = new Uint8Array(wasmMemory.buffer); + if (!js_to_wasm) { + view.set(wasmMemoryU8.subarray(pointer, pointer + len)); + } + else { + wasmMemoryU8.set(view, pointer); + } + return latestView; + } + throw new TypeError('emnapiSyncMemory expect ArrayBuffer or ArrayBufferView as first parameter'); + } + /** + * @__sig ipippp + */ + function emnapi_sync_memory(env, js_to_wasm, arraybuffer_or_view, offset, len) { + let v; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!arraybuffer_or_view) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + arraybuffer_or_view >>>= 0; + offset >>>= 0; + len >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + const id = GET_HEAP_DATA_VIEW().getUint32(arraybuffer_or_view, true); + const jsValue = emnapiCtx.jsValueFromNapiValue(id); + const isArrayBuffer = jsValue instanceof ArrayBuffer; + const isDataView = jsValue instanceof DataView; + const isTypedArray = ArrayBuffer.isView(jsValue) && !isDataView; + if (!isArrayBuffer && !isTypedArray && !isDataView && !emnapiExternalMemory.isSharedArrayBuffer(jsValue)) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + const ret = $emnapiSyncMemory(Boolean(js_to_wasm), jsValue, offset, len); + if (jsValue !== ret) { + arraybuffer_or_view >>>= 0; + v = emnapiCtx.napiValueFromJsValue(ret); + GET_HEAP_DATA_VIEW().setUint32(arraybuffer_or_view, v, true); + } + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + function $emnapiGetMemoryAddress(arrayBufferOrView) { + const isArrayBuffer = arrayBufferOrView instanceof ArrayBuffer; + const isDataView = arrayBufferOrView instanceof DataView; + const isTypedArray = ArrayBuffer.isView(arrayBufferOrView) && !isDataView; + if (!isArrayBuffer && !isTypedArray && !isDataView && !emnapiExternalMemory.isSharedArrayBuffer(arrayBufferOrView)) { + throw new TypeError('emnapiGetMemoryAddress expect ArrayBuffer or ArrayBufferView as first parameter'); + } + let info; + if (isArrayBuffer) { + info = emnapiExternalMemory.getArrayBufferPointer(arrayBufferOrView, false); + } + else { + info = emnapiExternalMemory.getViewPointer(arrayBufferOrView, false); + } + return { + address: info.address, + ownership: info.ownership, + runtimeAllocated: info.runtimeAllocated + }; + } + /** + * @__sig ipppp + */ + function emnapi_get_memory_address(env, arraybuffer_or_view, address, ownership, runtime_allocated) { + let p, runtimeAllocated, ownershipOut; + let info; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!arraybuffer_or_view) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!address && !ownership && !runtime_allocated) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + const value = emnapiCtx.jsValueFromNapiValue(arraybuffer_or_view); + info = $emnapiGetMemoryAddress(value); + p = info.address; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + if (address) { + address >>>= 0; + GET_HEAP_DATA_VIEW().setUint32(address, p, true); + } + if (ownership) { + ownership >>>= 0; + ownershipOut = info.ownership; + GET_HEAP_DATA_VIEW().setInt32(ownership, ownershipOut, true); + } + if (runtime_allocated) { + runtime_allocated >>>= 0; + runtimeAllocated = info.runtimeAllocated; + GET_HEAP_DATA_VIEW().setInt8(runtime_allocated, runtimeAllocated, true); + } + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ipp + */ + function emnapi_get_runtime_version(env, version) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + const envObject = emnapiEnv; + if (!version) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + let runtimeVersion; + try { + runtimeVersion = emnapiCtx.getRuntimeVersions().version; + } + catch (_) { + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + const versions = runtimeVersion.split('.') + .map((n) => Number(n)); + version >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(version, versions[0], true); + GET_HEAP_DATA_VIEW().setUint32(version + 4, versions[1], true); + GET_HEAP_DATA_VIEW().setUint32(version + 8, versions[2], true); + return envObject.clearLastError(); + } + /** + * Get the handle for an external SharedArrayBuffer. + * Must be called on the emnapi main thread. + * @__sig ippp + */ + function emnapi_get_external_sharedarraybuffer_handle(env, sharedarraybuffer, handle) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!sharedarraybuffer) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!handle) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + handle >>>= 0; + const jsValue = emnapiCtx.jsValueFromNapiValue(sharedarraybuffer); + if (!emnapiExternalMemory.isSharedArrayBuffer(jsValue)) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + const metaPtr = emnapiExternalSAB.handleTable.get(jsValue); + if (metaPtr === undefined) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + let p = metaPtr; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(handle, p, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * Acquire a reference to an external SharedArrayBuffer. + * Can be called on any thread. + * @__sig vp + */ + function emnapi_acquire_external_sharedarraybuffer(handle) { + handle >>>= 0; + Atomics.add(new Int32Array(wasmMemory.buffer, handle, 1), 0, 1); + } + /** + * Release a reference to an external SharedArrayBuffer. + * Can be called on any thread. + * @__sig vp + */ + function emnapi_release_external_sharedarraybuffer(handle) { + handle >>>= 0; + emnapiExternalSAB.release(handle); + } + /** + * Acquire a reference to an external SharedArrayBuffer on the current thread. + * Can be called on any thread. Increments refcount and registers in + * the current thread's FinalizationRegistry. + * Exposed as Module.emnapiAcquireExternalSharedArrayBuffer (emscripten) or + * napiModule.emnapi.acquireExternalSharedArrayBuffer (core). + */ + function $emnapiAcquireExternalSharedArrayBuffer(handle, sab) { + if (sab != null && !emnapiExternalMemory.isSharedArrayBuffer(sab)) { + throw new TypeError('Expected a SharedArrayBuffer'); + } + if (!emnapiExternalSAB.registry) { + throw new Error('FinalizationRegistry is not supported in this environment'); + } + handle >>>= 0; + const meta = emnapiExternalSAB.readMeta(handle); + let external_data = meta.external_data; + external_data >>>= 0; + if (sab == null) { + sab = new SharedArrayBuffer(meta.byte_length); + new Uint8Array(sab).set(new Uint8Array(wasmMemory.buffer, external_data, meta.byte_length)); + } + else { + if (emnapiExternalSAB.handleTable.has(sab)) { + return sab; + } + } + // Increment refcount atomically + Atomics.add(new Int32Array(wasmMemory.buffer, handle, 1), 0, 1); + // Register in emnapiExternalMemory.table for emnapi_sync_memory support + if (!emnapiExternalMemory.table.has(sab)) { + if (external_data) { + emnapiExternalMemory.table.set(sab, { + address: external_data, + ownership: 1 /* ReferenceOwnership.kUserland */, + runtimeAllocated: 0 + }); + } + } + // Register in handleTable and FinalizationRegistry for this thread + emnapiExternalSAB.handleTable.set(sab, handle); + emnapiExternalSAB.registry.register(sab, handle); + return sab; + } + + //#endregion src/emnapi.ts + + var emnapiMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + $emnapiAcquireExternalSharedArrayBuffer: $emnapiAcquireExternalSharedArrayBuffer, + $emnapiGetMemoryAddress: $emnapiGetMemoryAddress, + $emnapiSyncMemory: $emnapiSyncMemory, + emnapi_acquire_external_sharedarraybuffer: emnapi_acquire_external_sharedarraybuffer, + emnapi_create_memory_view: emnapi_create_memory_view, + emnapi_debug: emnapi_debug, + emnapi_get_external_sharedarraybuffer_handle: emnapi_get_external_sharedarraybuffer_handle, + emnapi_get_memory_address: emnapi_get_memory_address, + emnapi_get_runtime_version: emnapi_get_runtime_version, + emnapi_is_node_binding_available: emnapi_is_node_binding_available, + emnapi_is_support_bigint: emnapi_is_support_bigint, + emnapi_is_support_weakref: emnapi_is_support_weakref, + emnapi_release_external_sharedarraybuffer: emnapi_release_external_sharedarraybuffer, + emnapi_sync_memory: emnapi_sync_memory + }); + + //#region src/value/create.ts + /** + * @__sig ipp + */ + function napi_create_array(env, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + result >>>= 0; + const value = emnapiCtx.napiValueFromJsValue([]); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return envObject.clearLastError(); + } + /** + * @__sig ippp + */ + function napi_create_array_with_length(env, length, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + length >>>= 0; + result >>>= 0; + length = length >>> 0; + const value = emnapiCtx.napiValueFromJsValue(new Array(length)); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return envObject.clearLastError(); + } + function emnapiCreateArrayBuffer(byte_length, data, shared) { + byte_length >>>= 0; + byte_length = byte_length >>> 0; + const arrayBuffer = shared ? new SharedArrayBuffer(byte_length) : new ArrayBuffer(byte_length); + if (data) { + data >>>= 0; + const p = emnapiExternalMemory.getArrayBufferPointer(arrayBuffer, true).address; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(data, p, true); + } + return arrayBuffer; + } + /** + * @__sig ipppp + */ + function napi_create_arraybuffer(env, byte_length, data, result) { + let value; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + result >>>= 0; + const arrayBuffer = emnapiCreateArrayBuffer(byte_length, data, false); + value = emnapiCtx.napiValueFromJsValue(arrayBuffer); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ipppp + */ + function node_api_create_sharedarraybuffer(env, byte_length, data, result) { + let value; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + result >>>= 0; + const arrayBuffer = emnapiCreateArrayBuffer(byte_length, data, true); + value = emnapiCtx.napiValueFromJsValue(arrayBuffer); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ipdp + */ + function napi_create_date(env, time, result) { + let value; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + result >>>= 0; + value = emnapiCtx.napiValueFromJsValue(new Date(time)); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ippppp + */ + function napi_create_external(env, data, finalize_cb, finalize_hint, result) { + let value; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!emnapiCtx.features.finalizer && finalize_cb) { + throw emnapiCtx.createNotSupportWeakRefError('napi_create_external', 'Parameter "finalize_cb" must be 0(NULL)'); + } + value = emnapiCtx.getCurrentScope().addExternal(data); + if (finalize_cb) { + emnapiCtx.createReferenceWithFinalizer(envObject, value, 0, 0 /* ReferenceOwnership.kRuntime */, finalize_cb, data, finalize_hint); + } + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return envObject.clearLastError(); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ipppppp + */ + function napi_create_external_arraybuffer(env, external_data, byte_length, finalize_cb, finalize_hint, result) { + let value; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + byte_length >>>= 0; + external_data >>>= 0; + result >>>= 0; + byte_length = byte_length >>> 0; + if (!external_data) { + byte_length = 0; + } + if ((external_data + byte_length) > wasmMemory.buffer.byteLength) { + throw new RangeError('Memory out of range'); + } + if (!emnapiCtx.features.finalizer && finalize_cb) { + throw emnapiCtx.createNotSupportWeakRefError('napi_create_external_arraybuffer', 'Parameter "finalize_cb" must be 0(NULL)'); + } + const arrayBuffer = new ArrayBuffer(byte_length); + if (byte_length === 0) { + try { + const MessageChannel = emnapiCtx.features.MessageChannel; + const messageChannel = new MessageChannel(); + messageChannel.port1.postMessage(arrayBuffer, [arrayBuffer]); + } + catch (_) { } + } + else { + const u8arr = new Uint8Array(arrayBuffer); + u8arr.set(new Uint8Array(wasmMemory.buffer).subarray(external_data, external_data + byte_length)); + emnapiExternalMemory.table.set(arrayBuffer, { + address: external_data, + ownership: 1 /* ReferenceOwnership.kUserland */, + runtimeAllocated: 0 + }); + } + value = emnapiCtx.napiValueFromJsValue(arrayBuffer); + if (finalize_cb) { + const status = napi_add_finalizer(env, value, external_data, finalize_cb, finalize_hint, /* NULL */ 0); + if (status === 10 /* napi_status.napi_pending_exception */) { + const err = envObject.lastException.deref(); + envObject.clearLastError(); + envObject.lastException.reset(); + throw err; + } + else if (status !== 0 /* napi_status.napi_ok */) { + return envObject.setLastError(status); + } + } + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ipppppp + */ + function node_api_create_external_sharedarraybuffer(env, external_data, byte_length, finalize_cb, finalize_hint, result) { + let value; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + byte_length >>>= 0; + external_data >>>= 0; + result >>>= 0; + byte_length = byte_length >>> 0; + if (!external_data) { + byte_length = 0; + } + if ((external_data + byte_length) > wasmMemory.buffer.byteLength) { + throw new RangeError('Memory out of range'); + } + if (!emnapiExternalSAB.registry && finalize_cb) { + throw emnapiCtx.createNotSupportWeakRefError('node_api_create_external_sharedarraybuffer', 'Parameter "finalize_cb" must be 0(NULL)'); + } + const sharedArrayBuffer = new SharedArrayBuffer(byte_length); + if (byte_length !== 0) { + const u8arr = new Uint8Array(sharedArrayBuffer); + u8arr.set(new Uint8Array(wasmMemory.buffer).subarray(external_data, external_data + byte_length)); + emnapiExternalMemory.table.set(sharedArrayBuffer, { + address: external_data, + ownership: 1 /* ReferenceOwnership.kUserland */, + runtimeAllocated: 0 + }); + } + value = emnapiCtx.napiValueFromJsValue(sharedArrayBuffer); + if (finalize_cb) { + finalize_cb >>>= 0; + finalize_hint >>>= 0; + const metaPtr = emnapiExternalSAB.allocMeta(external_data, byte_length, finalize_cb, external_data, finalize_hint); + emnapiExternalSAB.handleTable.set(sharedArrayBuffer, metaPtr); + emnapiExternalSAB.registry.register(sharedArrayBuffer, metaPtr); + } + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ipp + */ + function napi_create_object(env, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + result >>>= 0; + const value = emnapiCtx.napiValueFromJsValue({}); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return envObject.clearLastError(); + } + /** + * @__sig ipppppp + */ + function node_api_create_object_with_properties(env, prototype_or_null, property_names, property_values, property_count, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + property_count >>>= 0; + property_count = property_count >>> 0; + if (property_count > 0) { + if (!property_names) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!property_values) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + const v8_prototype_or_null = prototype_or_null + ? emnapiCtx.jsValueFromNapiValue(prototype_or_null) + : null; + const properties = {}; + property_names >>>= 0; + property_values >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + for (let i = 0; i < property_count; i++) { + const name_value = emnapiCtx.jsValueFromNapiValue(GET_HEAP_DATA_VIEW().getUint32(property_names + i * 4, true)); + if (!(typeof name_value === "string" || typeof name_value === "symbol")) + return envObject.setLastError(4 /* napi_status.napi_name_expected */); + properties[name_value] = { + value: emnapiCtx.jsValueFromNapiValue(GET_HEAP_DATA_VIEW().getUint32(property_values + i * 4, true)), + writable: true, + enumerable: true, + configurable: true + }; + } + let obj; + try { + obj = Object.defineProperties(Object.create(v8_prototype_or_null), properties); + } + catch (_) { + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + const value = emnapiCtx.napiValueFromJsValue(obj); + result >>>= 0; + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return envObject.clearLastError(); + } + /** + * @__sig ippp + */ + function napi_create_symbol(env, description, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + if (!description) { + // eslint-disable-next-line symbol-description + const value = emnapiCtx.napiValueFromJsValue(Symbol()); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + } + else { + const desc = emnapiCtx.jsValueFromNapiValue(description); + if (typeof desc !== 'string') { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + const v = emnapiCtx.napiValueFromJsValue(Symbol(desc)); + GET_HEAP_DATA_VIEW().setUint32(result, v, true); + } + return envObject.clearLastError(); + } + /** + * @__sig ipipppp + */ + function napi_create_typedarray(env, type, length, arraybuffer, byte_offset, result) { + let value; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!arraybuffer) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const buffer = emnapiCtx.jsValueFromNapiValue(arraybuffer); + byte_offset >>>= 0; + length >>>= 0; + const createTypedArray = function (envObject, Type, size_of_element, buffer, byte_offset, length) { + byte_offset = byte_offset >>> 0; + length = length >>> 0; + if (size_of_element > 1) { + if ((byte_offset) % (size_of_element) !== 0) { + const err = new RangeError(`start offset of ${Type.name ?? ''} should be a multiple of ${size_of_element}`); + err.code = 'ERR_NAPI_INVALID_TYPEDARRAY_ALIGNMENT'; + envObject.lastException.resetTo(err); + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + } + if (((length * size_of_element) + byte_offset) > buffer.byteLength) { + const err = new RangeError('Invalid typed array length'); + err.code = 'ERR_NAPI_INVALID_TYPEDARRAY_LENGTH'; + envObject.lastException.resetTo(err); + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + const out = new Type(buffer, byte_offset, length); + if (buffer === wasmMemory.buffer) { + if (!emnapiExternalMemory.wasmMemoryViewTable.has(out)) { + emnapiExternalMemory.wasmMemoryViewTable.set(out, { + Ctor: Type, + address: byte_offset, + length, + ownership: 1 /* ReferenceOwnership.kUserland */, + runtimeAllocated: 0 + }); + } + } + result >>>= 0; + value = emnapiCtx.napiValueFromJsValue(out); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return (0 /* napi_status.napi_ok */); + }; + if (buffer instanceof ArrayBuffer || emnapiExternalMemory.isSharedArrayBuffer(buffer)) { + switch (type) { + case 0 /* napi_typedarray_type.napi_int8_array */: + return createTypedArray(envObject, Int8Array, 1, buffer, byte_offset, length); + case 1 /* napi_typedarray_type.napi_uint8_array */: + return createTypedArray(envObject, Uint8Array, 1, buffer, byte_offset, length); + case 2 /* napi_typedarray_type.napi_uint8_clamped_array */: + return createTypedArray(envObject, Uint8ClampedArray, 1, buffer, byte_offset, length); + case 3 /* napi_typedarray_type.napi_int16_array */: + return createTypedArray(envObject, Int16Array, 2, buffer, byte_offset, length); + case 4 /* napi_typedarray_type.napi_uint16_array */: + return createTypedArray(envObject, Uint16Array, 2, buffer, byte_offset, length); + case 5 /* napi_typedarray_type.napi_int32_array */: + return createTypedArray(envObject, Int32Array, 4, buffer, byte_offset, length); + case 6 /* napi_typedarray_type.napi_uint32_array */: + return createTypedArray(envObject, Uint32Array, 4, buffer, byte_offset, length); + case 7 /* napi_typedarray_type.napi_float32_array */: + return createTypedArray(envObject, Float32Array, 4, buffer, byte_offset, length); + case 8 /* napi_typedarray_type.napi_float64_array */: + return createTypedArray(envObject, Float64Array, 8, buffer, byte_offset, length); + case 9 /* napi_typedarray_type.napi_bigint64_array */: + return createTypedArray(envObject, BigInt64Array, 8, buffer, byte_offset, length); + case 10 /* napi_typedarray_type.napi_biguint64_array */: + return createTypedArray(envObject, BigUint64Array, 8, buffer, byte_offset, length); + case 11 /* napi_typedarray_type.napi_float16_array */: + if (typeof Float16Array !== 'function') { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + return createTypedArray(envObject, Float16Array, 2, buffer, byte_offset, length); + default: + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + } + else { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__deps malloc + * @__sig ippp + */ + function napi_create_buffer(env, size, data, result) { + let value, pointer; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const Buffer = emnapiCtx.features.Buffer; + if (!Buffer) { + throw emnapiCtx.createNotSupportBufferError('napi_create_buffer', ''); + } + result >>>= 0; + let buffer; + size >>>= 0; + size = size >>> 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + if (!data || (size === 0)) { + buffer = Buffer.alloc(size); + value = emnapiCtx.napiValueFromJsValue(buffer); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + } + else { + pointer = _malloc(size); + if (!pointer) + throw new Error('Out of memory'); + pointer >>>= 0; + new Uint8Array(wasmMemory.buffer).subarray(pointer, pointer + size).fill(0); + // capture Buffer.from at creation so a later refreshed view uses it + const buffer = emnapiExternalMemory.getBufferFrom()(wasmMemory.buffer, pointer, size); + const viewDescriptor = { + Ctor: Buffer, + address: pointer, + length: size, + ownership: emnapiExternalMemory.registry ? 0 /* ReferenceOwnership.kRuntime */ : 1 /* ReferenceOwnership.kUserland */, + runtimeAllocated: 1 + }; + emnapiExternalMemory.wasmMemoryViewTable.set(buffer, viewDescriptor); + emnapiExternalMemory.registry?.register(viewDescriptor, pointer); + value = emnapiCtx.napiValueFromJsValue(buffer); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + data >>>= 0; + GET_HEAP_DATA_VIEW().setUint32(data, pointer, true); + } + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ippppp + */ + function napi_create_buffer_copy(env, length, data, result_data, result) { + let value; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const Buffer = emnapiCtx.features.Buffer; + if (!Buffer) { + throw emnapiCtx.createNotSupportBufferError('napi_create_buffer_copy', ''); + } + const arrayBuffer = emnapiCreateArrayBuffer(length, result_data, false); + const buffer = Buffer.from(arrayBuffer); + data >>>= 0; + length >>>= 0; + buffer.set(new Uint8Array(wasmMemory.buffer).subarray(data, data + length)); + value = emnapiCtx.napiValueFromJsValue(buffer); + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ipppppp + */ + function napi_create_external_buffer(env, length, data, finalize_cb, finalize_hint, result) { + return emnapi_create_memory_view(env, -2 /* emnapi_memory_view_type.emnapi_buffer */, data, length, finalize_cb, finalize_hint, result); + } + /** + * @__sig ippppp + */ + function node_api_create_buffer_from_arraybuffer(env, arraybuffer, byte_offset, byte_length, result) { + let value; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!arraybuffer) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + byte_offset >>>= 0; + byte_length >>>= 0; + byte_offset = byte_offset >>> 0; + byte_length = byte_length >>> 0; + const buffer = emnapiCtx.jsValueFromNapiValue(arraybuffer); + if (!(buffer instanceof ArrayBuffer)) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + if ((byte_length + byte_offset) > buffer.byteLength) { + const err = new RangeError('The byte offset + length is out of range'); + err.code = 'ERR_OUT_OF_RANGE'; + throw err; + } + const Buffer = emnapiCtx.features.Buffer; + if (!Buffer) { + throw emnapiCtx.createNotSupportBufferError('node_api_create_buffer_from_arraybuffer', ''); + } + // capture Buffer.from at creation so a later refreshed view uses it + const out = emnapiExternalMemory.getBufferFrom()(buffer, byte_offset, byte_length); + if (buffer === wasmMemory.buffer) { + if (!emnapiExternalMemory.wasmMemoryViewTable.has(out)) { + emnapiExternalMemory.wasmMemoryViewTable.set(out, { + Ctor: Buffer, + address: byte_offset, + length: byte_length, + ownership: 1 /* ReferenceOwnership.kUserland */, + runtimeAllocated: 0 + }); + } + } + result >>>= 0; + value = emnapiCtx.napiValueFromJsValue(out); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ippppp + */ + function napi_create_dataview(env, byte_length, arraybuffer, byte_offset, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!arraybuffer) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + byte_length >>>= 0; + byte_offset >>>= 0; + byte_length = byte_length >>> 0; + byte_offset = byte_offset >>> 0; + const value = emnapiCtx.jsValueFromNapiValue(arraybuffer); + const createDataview = (buffer) => { + if ((byte_length + byte_offset) > buffer.byteLength) { + const err = new RangeError('byte_offset + byte_length should be less than or equal to the size in bytes of the array passed in'); + err.code = 'ERR_NAPI_INVALID_DATAVIEW_ARGS'; + throw err; + } + const dataview = new DataView(buffer, byte_offset, byte_length); + if (buffer === wasmMemory.buffer) { + if (!emnapiExternalMemory.wasmMemoryViewTable.has(dataview)) { + emnapiExternalMemory.wasmMemoryViewTable.set(dataview, { + Ctor: DataView, + address: byte_offset, + length: byte_length, + ownership: 1 /* ReferenceOwnership.kUserland */, + runtimeAllocated: 0 + }); + } + } + result >>>= 0; + let v = emnapiCtx.napiValueFromJsValue(dataview); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, v, true); + return (0 /* napi_status.napi_ok */); + }; + if (value instanceof ArrayBuffer || emnapiExternalMemory.isSharedArrayBuffer(value)) { + return createDataview(value); + } + else { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** + * @__sig ipppp + */ + function node_api_symbol_for(env, utf8description, length, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + length >>>= 0; + utf8description >>>= 0; + result >>>= 0; + const autoLength = length === -1 || length === 4294967295; + const sizelength = length >>> 0; + if (length !== 0) { + if (!utf8description) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + if (!(autoLength || (sizelength <= 2147483647))) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + const descriptionString = emnapiString.UTF8ToString(utf8description, length); + const value = emnapiCtx.napiValueFromJsValue(Symbol.for(descriptionString)); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return envObject.clearLastError(); + } + + //#endregion src/value/create.ts + + var createMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + napi_create_array: napi_create_array, + napi_create_array_with_length: napi_create_array_with_length, + napi_create_arraybuffer: napi_create_arraybuffer, + napi_create_buffer: napi_create_buffer, + napi_create_buffer_copy: napi_create_buffer_copy, + napi_create_dataview: napi_create_dataview, + napi_create_date: napi_create_date, + napi_create_external: napi_create_external, + napi_create_external_arraybuffer: napi_create_external_arraybuffer, + napi_create_external_buffer: napi_create_external_buffer, + napi_create_object: napi_create_object, + napi_create_symbol: napi_create_symbol, + napi_create_typedarray: napi_create_typedarray, + node_api_create_buffer_from_arraybuffer: node_api_create_buffer_from_arraybuffer, + node_api_create_external_sharedarraybuffer: node_api_create_external_sharedarraybuffer, + node_api_create_object_with_properties: node_api_create_object_with_properties, + node_api_create_sharedarraybuffer: node_api_create_sharedarraybuffer, + node_api_symbol_for: node_api_symbol_for + }); + + //#region src/value/global.ts + /** @__sig ipip */ + function napi_get_boolean(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + result >>>= 0; + const v = value === 0 ? 4 /* Constant.FALSE */ : 5 /* Constant.TRUE */; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, v, true); + return envObject.clearLastError(); + } + /** @__sig ipp */ + function napi_get_global(env, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + result >>>= 0; + const value = 6 /* Constant.GLOBAL */; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return envObject.clearLastError(); + } + /** @__sig ipp */ + function napi_get_null(env, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + result >>>= 0; + const value = 3 /* Constant.NULL */; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return envObject.clearLastError(); + } + /** @__sig ipp */ + function napi_get_undefined(env, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + result >>>= 0; + const value = 2 /* Constant.UNDEFINED */; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return envObject.clearLastError(); + } + + //#endregion src/value/global.ts + + var globalMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + napi_get_boolean: napi_get_boolean, + napi_get_global: napi_get_global, + napi_get_null: napi_get_null, + napi_get_undefined: napi_get_undefined + }); + + //#region src/env.ts + /** @__sig ipppp */ + function napi_set_instance_data(env, data, finalize_cb, finalize_hint) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + const envObject = emnapiEnv; + data >>>= 0; + finalize_cb >>>= 0; + finalize_hint >>>= 0; + envObject.setInstanceData(data, finalize_cb, finalize_hint); + return envObject.clearLastError(); + } + /** @__sig ipp */ + function napi_get_instance_data(env, data) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + const envObject = emnapiEnv; + if (!data) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + data >>>= 0; + const value = envObject.getInstanceData(); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(data, value, true); + return envObject.clearLastError(); + } + + //#endregion src/env.ts + + var envMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + napi_get_instance_data: napi_get_instance_data, + napi_set_instance_data: napi_set_instance_data + }); + + //#region src/error.ts + /** @__sig ipp */ + function napi_throw(env, error) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!error) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + envObject.lastException.resetTo(emnapiCtx.jsValueFromNapiValue(error)); + return envObject.clearLastError(); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippp */ + function napi_throw_error(env, code, msg) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!msg) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + code >>>= 0; + msg >>>= 0; + const error = new Error(emnapiString.UTF8ToString(msg, -1)); + if (code) + error.code = emnapiString.UTF8ToString(code, -1); + envObject.lastException.resetTo(error); + return envObject.clearLastError(); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippp */ + function napi_throw_type_error(env, code, msg) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!msg) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + code >>>= 0; + msg >>>= 0; + const error = new TypeError(emnapiString.UTF8ToString(msg, -1)); + if (code) + error.code = emnapiString.UTF8ToString(code, -1); + envObject.lastException.resetTo(error); + return envObject.clearLastError(); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippp */ + function napi_throw_range_error(env, code, msg) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!msg) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + code >>>= 0; + msg >>>= 0; + const error = new RangeError(emnapiString.UTF8ToString(msg, -1)); + if (code) + error.code = emnapiString.UTF8ToString(code, -1); + envObject.lastException.resetTo(error); + return envObject.clearLastError(); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippp */ + function node_api_throw_syntax_error(env, code, msg) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!msg) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + code >>>= 0; + msg >>>= 0; + const error = new SyntaxError(emnapiString.UTF8ToString(msg, -1)); + if (code) + error.code = emnapiString.UTF8ToString(code, -1); + envObject.lastException.resetTo(error); + return envObject.clearLastError(); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipp */ + function napi_is_exception_pending(env, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const r = !envObject.lastException.isEmpty(); + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(result, r ? 1 : 0, true); + return envObject.clearLastError(); + } + /** @__sig ipppp */ + function napi_create_error(env, code, msg, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!msg) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const msgValue = emnapiCtx.jsValueFromNapiValue(msg); + if (typeof msgValue !== 'string') { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + const error = new Error(msgValue); + if (code) { + const codeValue = emnapiCtx.jsValueFromNapiValue(code); + if (typeof codeValue !== 'string') { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + error.code = codeValue; + } + result >>>= 0; + const value = emnapiCtx.napiValueFromJsValue(error); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return envObject.clearLastError(); + } + /** @__sig ipppp */ + function napi_create_type_error(env, code, msg, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!msg) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const msgValue = emnapiCtx.jsValueFromNapiValue(msg); + if (typeof msgValue !== 'string') { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + const error = new TypeError(msgValue); + if (code) { + const codeValue = emnapiCtx.jsValueFromNapiValue(code); + if (typeof codeValue !== 'string') { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + error.code = codeValue; + } + result >>>= 0; + const value = emnapiCtx.napiValueFromJsValue(error); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return envObject.clearLastError(); + } + /** @__sig ipppp */ + function napi_create_range_error(env, code, msg, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!msg) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const msgValue = emnapiCtx.jsValueFromNapiValue(msg); + if (typeof msgValue !== 'string') { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + const error = new RangeError(msgValue); + if (code) { + const codeValue = emnapiCtx.jsValueFromNapiValue(code); + if (typeof codeValue !== 'string') { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + error.code = codeValue; + } + result >>>= 0; + const value = emnapiCtx.napiValueFromJsValue(error); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return envObject.clearLastError(); + } + /** @__sig ipppp */ + function node_api_create_syntax_error(env, code, msg, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!msg) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const msgValue = emnapiCtx.jsValueFromNapiValue(msg); + if (typeof msgValue !== 'string') { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + const error = new SyntaxError(msgValue); + if (code) { + const codeValue = emnapiCtx.jsValueFromNapiValue(code); + if (typeof codeValue !== 'string') { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + error.code = codeValue; + } + result >>>= 0; + const value = emnapiCtx.napiValueFromJsValue(error); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return envObject.clearLastError(); + } + /** @__sig ipp */ + function napi_get_and_clear_last_exception(env, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + if (envObject.lastException.isEmpty()) { + GET_HEAP_DATA_VIEW().setUint32(result, 1, true); // ID_UNDEFINED + return envObject.clearLastError(); + } + else { + const err = envObject.lastException.deref(); + const value = emnapiCtx.napiValueFromJsValue(err); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + envObject.lastException.reset(); + } + return envObject.clearLastError(); + } + /** @__sig vpppp */ + function napi_fatal_error(location, location_len, message, message_len) { + location >>>= 0; + location_len >>>= 0; + message >>>= 0; + message_len >>>= 0; + const locationStr = emnapiString.UTF8ToString(location, location_len); + const messageStr = emnapiString.UTF8ToString(message, message_len); + if (emnapiNodeBinding) { + emnapiNodeBinding.napi.fatalError(locationStr, messageStr); + } + else { + abort('FATAL ERROR: ' + locationStr + ' ' + messageStr); + } + } + /** @__sig ipp */ + function napi_fatal_exception(env, err) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!err) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const error = emnapiCtx.jsValueFromNapiValue(err); + try { + envObject.triggerFatalException(error); + } + catch (_) { + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + return envObject.clearLastError(); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + + //#endregion src/error.ts + + var errorMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + napi_create_error: napi_create_error, + napi_create_range_error: napi_create_range_error, + napi_create_type_error: napi_create_type_error, + napi_fatal_error: napi_fatal_error, + napi_fatal_exception: napi_fatal_exception, + napi_get_and_clear_last_exception: napi_get_and_clear_last_exception, + napi_is_exception_pending: napi_is_exception_pending, + napi_throw: napi_throw, + napi_throw_error: napi_throw_error, + napi_throw_range_error: napi_throw_range_error, + napi_throw_type_error: napi_throw_type_error, + node_api_create_syntax_error: node_api_create_syntax_error, + node_api_throw_syntax_error: node_api_throw_syntax_error + }); + + //#region src/function.ts + /** @__sig ippppp */ + function _emnapi_create_function(utf8name, length, cb, data, result) { + length >>>= 0; + const fresult = emnapiCreateFunction(emnapiEnv, utf8name, length, cb, data); + if (fresult.status !== 0 /* napi_status.napi_ok */) + return emnapiEnv.setLastError(fresult.status); + const f = fresult.f; + const value = emnapiCtx.napiValueFromJsValue(f); + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return (0 /* napi_status.napi_ok */); + } + /** @__sig ipppppp */ + function napi_create_function(env, utf8name, length, cb, data, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!cb) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + return _emnapi_create_function(utf8name, length, cb, data, result); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipppppp */ + function napi_get_cb_info(env, cbinfo, argc, argv, this_arg, data) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + const envObject = emnapiEnv; + if (!cbinfo) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const cbinfoValue = emnapiCtx.getCallbackInfo(cbinfo); + argc >>>= 0; + argv >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + if (argv) { + if (!argc) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + let argcValue = GET_HEAP_DATA_VIEW().getUint32(argc, true); + argcValue >>>= 0; + const len = cbinfoValue.args.length; + const arrlen = argcValue < len ? argcValue : len; + let i = 0; + for (; i < arrlen; i++) { + const argVal = emnapiCtx.napiValueFromJsValue(cbinfoValue.args[i]); + GET_HEAP_DATA_VIEW().setUint32(argv + i * 4, argVal, true); + } + if (i < argcValue) { + for (; i < argcValue; i++) { + GET_HEAP_DATA_VIEW().setUint32(argv + i * 4, 1, true); + } + } + } + if (argc) { + GET_HEAP_DATA_VIEW().setUint32(argc, cbinfoValue.args.length, true); + } + if (this_arg) { + this_arg >>>= 0; + const v = emnapiCtx.napiValueFromJsValue(cbinfoValue.thiz); + GET_HEAP_DATA_VIEW().setUint32(this_arg, v, true); + } + if (data) { + data >>>= 0; + GET_HEAP_DATA_VIEW().setUint32(data, cbinfoValue.data, true); + } + return envObject.clearLastError(); + } + /** @__sig ipppppp */ + function napi_call_function(env, recv, func, argc, argv, result) { + let i = 0; + let v; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!recv) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + argc >>>= 0; + argv >>>= 0; + result >>>= 0; + argc = argc >>> 0; + if (argc > 0) { + if (!argv) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + const v8recv = emnapiCtx.jsValueFromNapiValue(recv); + if (!func) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const v8func = emnapiCtx.jsValueFromNapiValue(func); + if (typeof v8func !== 'function') + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const args = []; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + for (; i < argc; i++) { + const argVal = GET_HEAP_DATA_VIEW().getUint32(argv + i * 4, true); + args.push(emnapiCtx.jsValueFromNapiValue(argVal)); + } + const ret = v8func.apply(v8recv, args); + if (result) { + // resolving v BEFORE the write matters: the store target is evaluated + // before the RHS, so an RHS running user JS could otherwise write + // through a stale heap view after a growth + v = emnapiCtx.napiValueFromJsValue(ret); + GET_HEAP_DATA_VIEW().setUint32(result, v, true); + } + return envObject.clearLastError(); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippppp */ + function napi_new_instance(env, constructor, argc, argv, result) { + let i; + let v; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!constructor) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + argc >>>= 0; + argv >>>= 0; + result >>>= 0; + argc = argc >>> 0; + if (argc > 0) { + if (!argv) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const Ctor = emnapiCtx.jsValueFromNapiValue(constructor); + if (typeof Ctor !== 'function') + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + let ret; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + if (emnapiCtx.features.Reflect) { + const argList = Array(argc); + for (i = 0; i < argc; i++) { + const argVal = GET_HEAP_DATA_VIEW().getUint32(argv + i * 4, true); + argList[i] = emnapiCtx.jsValueFromNapiValue(argVal); + } + ret = emnapiCtx.features.Reflect.construct(Ctor, argList, Ctor); + } + else { + const args = Array(argc + 1); + args[0] = undefined; + for (i = 0; i < argc; i++) { + const argVal = GET_HEAP_DATA_VIEW().getUint32(argv + i * 4, true); + args[i + 1] = emnapiCtx.jsValueFromNapiValue(argVal); + } + const BoundCtor = Ctor.bind.apply(Ctor, args); + ret = new BoundCtor(); + } + if (result) { + // see napi_call_function: resolve v before the write + v = emnapiCtx.napiValueFromJsValue(ret); + GET_HEAP_DATA_VIEW().setUint32(result, v, true); + } + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippp */ + function napi_get_new_target(env, cbinfo, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!cbinfo) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + result >>>= 0; + const cbinfoValue = emnapiCtx.getCallbackInfo(cbinfo); + const { thiz, fn } = cbinfoValue; + const value = thiz == null || thiz.constructor == null + ? 0 + : thiz instanceof fn + ? emnapiCtx.napiValueFromJsValue(thiz.constructor) + : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return envObject.clearLastError(); + } + + //#endregion src/function.ts + + var functionMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + _emnapi_create_function: _emnapi_create_function, + napi_call_function: napi_call_function, + napi_create_function: napi_create_function, + napi_get_cb_info: napi_get_cb_info, + napi_get_new_target: napi_get_new_target, + napi_new_instance: napi_new_instance + }); + + //#region src/life.ts + /** @__sig ipp */ + function napi_open_handle_scope(env, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const scope = emnapiCtx.openScope(envObject); + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, scope.id, true); + return envObject.clearLastError(); + } + /** @__sig ipp */ + function napi_close_handle_scope(env, scope) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!scope) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if ((envObject.openHandleScopes === 0)) { + return 13 /* napi_status.napi_handle_scope_mismatch */; + } + emnapiCtx.closeScope(envObject); + return envObject.clearLastError(); + } + /** @__sig ipp */ + function napi_open_escapable_handle_scope(env, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const scope = emnapiCtx.openScope(envObject); + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, scope.id, true); + return envObject.clearLastError(); + } + /** @__sig ipp */ + function napi_close_escapable_handle_scope(env, scope) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!scope) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if ((envObject.openHandleScopes === 0)) { + return 13 /* napi_status.napi_handle_scope_mismatch */; + } + emnapiCtx.closeScope(envObject); + return envObject.clearLastError(); + } + /** @__sig ipppp */ + function napi_escape_handle(env, scope, escapee, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!scope) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!escapee) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const scopeObject = emnapiCtx.getHandleScope(scope); + if (!scopeObject.escapeCalled()) { + escapee >>>= 0; + result >>>= 0; + const newHandle = scopeObject.escape(escapee); + const value = newHandle; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return envObject.clearLastError(); + } + return envObject.setLastError(12 /* napi_status.napi_escape_called_twice */); + } + /** @__sig ippip */ + function napi_create_reference(env, value, initial_refcount, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + const type = typeof jsValue; + if (envObject.moduleApiVersion < 10) { + if (!((type === 'object' && jsValue !== null) || type === 'function' || typeof jsValue === 'symbol')) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + } + const ref = emnapiCtx.createReference(envObject, value, initial_refcount >>> 0, 1 /* ReferenceOwnership.kUserland */); + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, ref.id, true); + return envObject.clearLastError(); + } + /** @__sig ipp */ + function napi_delete_reference(env, ref) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + const envObject = emnapiEnv; + if (!ref) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + emnapiCtx.getRef(ref).dispose(); + return envObject.clearLastError(); + } + /** @__sig ippp */ + function napi_reference_ref(env, ref, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!ref) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const count = emnapiCtx.getRef(ref).ref(); + if (result) { + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, count, true); + } + return envObject.clearLastError(); + } + /** @__sig ippp */ + function napi_reference_unref(env, ref, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!ref) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const reference = emnapiCtx.getRef(ref); + const refcount = reference.refcount(); + if (refcount === 0) { + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + const count = reference.unref(); + if (result) { + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, count, true); + } + return envObject.clearLastError(); + } + /** @__sig ippp */ + function napi_get_reference_value(env, ref, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!ref) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const reference = emnapiCtx.getRef(ref); + const id = reference.get(); + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, id, true); + return envObject.clearLastError(); + } + /** @__sig ippp */ + function napi_add_env_cleanup_hook(env, fun, arg) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + const envObject = emnapiEnv; + if (!fun) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + fun >>>= 0; + arg >>>= 0; + emnapiCtx.addCleanupHook(envObject, fun, arg); + return 0 /* napi_status.napi_ok */; + } + /** @__sig ippp */ + function napi_remove_env_cleanup_hook(env, fun, arg) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + const envObject = emnapiEnv; + if (!fun) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + fun >>>= 0; + arg >>>= 0; + emnapiCtx.removeCleanupHook(envObject, fun, arg); + return 0 /* napi_status.napi_ok */; + } + /** @__sig vp */ + function _emnapi_env_ref(env) { + const envObject = emnapiEnv; + envObject.ref(); + } + /** @__sig vp */ + function _emnapi_env_unref(env) { + const envObject = emnapiEnv; + envObject.unref(); + } + + //#endregion src/life.ts + + var lifeMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + _emnapi_env_ref: _emnapi_env_ref, + _emnapi_env_unref: _emnapi_env_unref, + napi_add_env_cleanup_hook: napi_add_env_cleanup_hook, + napi_close_escapable_handle_scope: napi_close_escapable_handle_scope, + napi_close_handle_scope: napi_close_handle_scope, + napi_create_reference: napi_create_reference, + napi_delete_reference: napi_delete_reference, + napi_escape_handle: napi_escape_handle, + napi_get_reference_value: napi_get_reference_value, + napi_open_escapable_handle_scope: napi_open_escapable_handle_scope, + napi_open_handle_scope: napi_open_handle_scope, + napi_reference_ref: napi_reference_ref, + napi_reference_unref: napi_reference_unref, + napi_remove_env_cleanup_hook: napi_remove_env_cleanup_hook + }); + + //#region src/miscellaneous.ts + /** @__sig ippi */ + function _emnapi_get_filename(env, buf, len) { + const envObject = emnapiEnv; + const filename = envObject.filename; + if (!buf) { + return emnapiString.lengthBytesUTF8(filename); + } + buf >>>= 0; + return emnapiString.stringToUTF8(filename, buf, len); + } + + //#endregion src/miscellaneous.ts + + var miscellaneousMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + _emnapi_get_filename: _emnapi_get_filename + }); + + //#region src/node.ts + /** @__sig vppdp */ + function _emnapi_node_emit_async_init(async_resource, async_resource_name, trigger_async_id, result) { + if (!emnapiNodeBinding) + return; + const resource = emnapiCtx.jsValueFromNapiValue(async_resource); + const resource_name = emnapiCtx.jsValueFromNapiValue(async_resource_name); + const asyncContext = emnapiNodeBinding.node.emitAsyncInit(resource, resource_name, trigger_async_id); + const asyncId = asyncContext.asyncId; + const triggerAsyncId = asyncContext.triggerAsyncId; + if (result) { + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setFloat64(result, asyncId, true); + GET_HEAP_DATA_VIEW().setFloat64(result + 8, triggerAsyncId, true); + } + } + /** @__sig vdd */ + function _emnapi_node_emit_async_destroy(async_id, trigger_async_id) { + if (!emnapiNodeBinding) + return; + emnapiNodeBinding.node.emitAsyncDestroy({ + asyncId: async_id, + triggerAsyncId: trigger_async_id + }); + } + /* vpddp export function _emnapi_node_open_callback_scope (async_resource: napi_value, async_id: double, trigger_async_id: double, result: Pointer): void { + if (!emnapiNodeBinding || !result) return + const resource = emnapiCtx.jsValueFromNapiValue(async_resource)! + // eslint-disable-next-line @typescript-eslint/no-unused-vars + const nativeCallbackScopePointer = emnapiNodeBinding.node.openCallbackScope(resource, { + asyncId: async_id, + triggerAsyncId: trigger_async_id + }) + + from64('result') + $_TODO_makeSetValue('result', 0, 'nativeCallbackScopePointer', 'i64') + } + + vp + export function _emnapi_node_close_callback_scope (scope: Pointer): void { + if (!emnapiNodeBinding || !scope) return + from64('scope') + const nativeCallbackScopePointer = $_TODO_makeGetValue('scope', 0, 'i64') + emnapiNodeBinding.node.closeCallbackScope(BigInt(nativeCallbackScopePointer)) + } */ + /** @__sig ipppppddp */ + function _emnapi_node_make_callback(env, async_resource, cb, argv, size, async_id, trigger_async_id, result) { + let i = 0; + let v; + if (!emnapiNodeBinding) + return; + const resource = emnapiCtx.jsValueFromNapiValue(async_resource); + const callback = emnapiCtx.jsValueFromNapiValue(cb); + argv >>>= 0; + size >>>= 0; + size = size >>> 0; + const arr = Array(size); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + for (; i < size; i++) { + const argVal = GET_HEAP_DATA_VIEW().getUint32(argv + i * 4, true); + arr[i] = emnapiCtx.jsValueFromNapiValue(argVal); + } + const ret = emnapiNodeBinding.node.makeCallback(resource, callback, arr, { + asyncId: async_id, + triggerAsyncId: trigger_async_id + }); + if (result) { + result >>>= 0; + v = emnapiCtx.napiValueFromJsValue(ret); + GET_HEAP_DATA_VIEW().setUint32(result, v, true); + } + } + /** @__sig ippp */ + function _emnapi_async_init_js(async_resource, async_resource_name, result) { + if (!emnapiNodeBinding) { + return 9 /* napi_status.napi_generic_failure */; + } + let resource; + if (async_resource) { + resource = Object(emnapiCtx.jsValueFromNapiValue(async_resource)); + } + const name = emnapiCtx.jsValueFromNapiValue(async_resource_name); + const ret = emnapiNodeBinding.napi.asyncInit(resource, name); + if (ret.status !== 0) + return ret.status; + let numberValue = ret.value; + if (!((numberValue >= (BigInt(-1) * (BigInt(1) << BigInt(63)))) && (numberValue < (BigInt(1) << BigInt(63))))) { + numberValue = numberValue & ((BigInt(1) << BigInt(64)) - BigInt(1)); + if (numberValue >= (BigInt(1) << BigInt(63))) { + numberValue = numberValue - (BigInt(1) << BigInt(64)); + } + } + const low = Number(numberValue & BigInt(0xffffffff)); + const high = Number(numberValue >> BigInt(32)); + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt32(result, low, true); + GET_HEAP_DATA_VIEW().setInt32(result + 4, high, true); + return 0 /* napi_status.napi_ok */; + } + /** @__sig ip */ + function _emnapi_async_destroy_js(async_context) { + if (!emnapiNodeBinding) { + return 9 /* napi_status.napi_generic_failure */; + } + async_context >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + const low = GET_HEAP_DATA_VIEW().getInt32(async_context, true); + const high = GET_HEAP_DATA_VIEW().getInt32(async_context + 4, true); + const pointer = BigInt(low >>> 0) | (BigInt(high) << BigInt(32)); + const ret = emnapiNodeBinding.napi.asyncDestroy(pointer); + if (ret.status !== 0) + return ret.status; + return 0 /* napi_status.napi_ok */; + } + // https://github.com/nodejs/node-addon-api/pull/1283 + /** @__sig ipppp */ + function napi_open_callback_scope(env, ignored, async_context_handle, result) { + throw new Error('napi_open_callback_scope has not been implemented yet'); + } + /** @__sig ipp */ + function napi_close_callback_scope(env, scope) { + throw new Error('napi_close_callback_scope has not been implemented yet'); + } + /** @__sig ippppppp */ + function napi_make_callback(env, async_context, recv, func, argc, argv, result) { + let i = 0; + let v; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!emnapiNodeBinding) { + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + if (!recv) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (argc > 0) { + if (!argv) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + const v8recv = Object(emnapiCtx.jsValueFromNapiValue(recv)); + const v8func = emnapiCtx.jsValueFromNapiValue(func); + if (typeof v8func !== 'function') { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + async_context >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + const low = GET_HEAP_DATA_VIEW().getInt32(async_context, true); + const high = GET_HEAP_DATA_VIEW().getInt32(async_context + 4, true); + const ctx = BigInt(low >>> 0) | (BigInt(high) << BigInt(32)); + argv >>>= 0; + argc >>>= 0; + argc = argc >>> 0; + const arr = Array(argc); + for (; i < argc; i++) { + const argVal = GET_HEAP_DATA_VIEW().getUint32(argv + i * 4, true); + arr[i] = emnapiCtx.jsValueFromNapiValue(argVal); + } + const ret = emnapiNodeBinding.napi.makeCallback(ctx, v8recv, v8func, arr); + if (ret.error) { + throw ret.error; + } + if (ret.status !== 0 /* napi_status.napi_ok */) + return envObject.setLastError(ret.status); + if (result) { + result >>>= 0; + // The makeCallback call into JS above may have grown wasm memory: + // resolve v before the write (the store target is evaluated before the + // RHS, so an RHS running user JS could write through a stale heap view) + v = emnapiCtx.napiValueFromJsValue(ret.value); + GET_HEAP_DATA_VIEW().setUint32(result, v, true); + } + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig vp */ + function _emnapi_env_check_gc_access(env) { + const envObject = emnapiEnv; + envObject.checkGCAccess(); + } + + //#endregion src/node.ts + + var nodeMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + _emnapi_async_destroy_js: _emnapi_async_destroy_js, + _emnapi_async_init_js: _emnapi_async_init_js, + _emnapi_env_check_gc_access: _emnapi_env_check_gc_access, + _emnapi_node_emit_async_destroy: _emnapi_node_emit_async_destroy, + _emnapi_node_emit_async_init: _emnapi_node_emit_async_init, + _emnapi_node_make_callback: _emnapi_node_make_callback, + napi_close_callback_scope: napi_close_callback_scope, + napi_make_callback: napi_make_callback, + napi_open_callback_scope: napi_open_callback_scope + }); + + //#region src/promise.ts + /** @__sig ippp */ + function napi_create_promise(env, deferred, promise) { + let deferredObjectId, value; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!deferred) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!promise) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const resolver = emnapiCtx.createResolver(); + deferredObjectId = emnapiCtx.isolate.createReference(resolver).id; + deferred >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(deferred, deferredObjectId, true); + value = emnapiCtx.napiValueFromJsValue(resolver.promise); + promise >>>= 0; + GET_HEAP_DATA_VIEW().setUint32(promise, value, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippp */ + function napi_resolve_deferred(env, deferred, resolution) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!deferred) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!resolution) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const deferredRef = emnapiCtx.isolate.getRef(deferred); + const resolver = deferredRef.deref(); + resolver.resolve(emnapiCtx.jsValueFromNapiValue(resolution)); + deferredRef.dispose(); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippp */ + function napi_reject_deferred(env, deferred, resolution) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!deferred) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!resolution) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const deferredRef = emnapiCtx.isolate.getRef(deferred); + const resolver = deferredRef.deref(); + resolver.reject(emnapiCtx.jsValueFromNapiValue(resolution)); + deferredRef.dispose(); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippp */ + function napi_is_promise(env, value, is_promise) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!is_promise) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const promise = emnapiCtx.jsValueFromNapiValue(value); + is_promise >>>= 0; + const r = promise instanceof Promise ? 1 : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(is_promise, r, true); + return envObject.clearLastError(); + } + + //#endregion src/promise.ts + + var promiseMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + napi_create_promise: napi_create_promise, + napi_is_promise: napi_is_promise, + napi_reject_deferred: napi_reject_deferred, + napi_resolve_deferred: napi_resolve_deferred + }); + + //#region src/property.ts + /** @__sig ippiiip */ + function napi_get_all_property_names(env, object, key_mode, key_filter, key_conversion, result) { + let value; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(object); + if (jsValue == null) { + throw new TypeError('Cannot convert undefined or null to object'); + } + const type = typeof jsValue; + let obj; + try { + obj = (type === 'object' && jsValue !== null) || type === 'function' ? jsValue : Object(jsValue); + } + catch (_) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + if (key_mode !== 0 /* napi_key_collection_mode.napi_key_include_prototypes */ && key_mode !== 1 /* napi_key_collection_mode.napi_key_own_only */) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + if (key_conversion !== 0 /* napi_key_conversion.napi_key_keep_numbers */ && key_conversion !== 1 /* napi_key_conversion.napi_key_numbers_to_strings */) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + const props = []; + let names; + let symbols; + let i; + let own = true; + const integerIndiceRegex = /^(0|[1-9][0-9]*)$/; + do { + names = Object.getOwnPropertyNames(obj); + symbols = Object.getOwnPropertySymbols(obj); + for (i = 0; i < names.length; i++) { + props.push({ + name: integerIndiceRegex.test(names[i]) ? Number(names[i]) : names[i], + desc: Object.getOwnPropertyDescriptor(obj, names[i]), + own + }); + } + for (i = 0; i < symbols.length; i++) { + props.push({ + name: symbols[i], + desc: Object.getOwnPropertyDescriptor(obj, symbols[i]), + own + }); + } + if (key_mode === 1 /* napi_key_collection_mode.napi_key_own_only */) { + break; + } + obj = Object.getPrototypeOf(obj); + own = false; + } while (obj); + const ret = []; + const addName = function (ret, name, key_filter, conversion_mode) { + if (ret.indexOf(name) !== -1) + return; + if (conversion_mode === 0 /* napi_key_conversion.napi_key_keep_numbers */) { + ret.push(name); + } + else if (conversion_mode === 1 /* napi_key_conversion.napi_key_numbers_to_strings */) { + const realName = typeof name === 'number' ? String(name) : name; + if (typeof realName === 'string') { + if (!(key_filter & 8 /* napi_key_filter.napi_key_skip_strings */)) { + ret.push(realName); + } + } + else { + ret.push(realName); + } + } + }; + for (i = 0; i < props.length; i++) { + const prop = props[i]; + const name = prop.name; + const desc = prop.desc; + if (key_filter === 0 /* napi_key_filter.napi_key_all_properties */) { + addName(ret, name, key_filter, key_conversion); + } + else { + if (key_filter & 8 /* napi_key_filter.napi_key_skip_strings */ && typeof name === 'string') { + continue; + } + if (key_filter & 16 /* napi_key_filter.napi_key_skip_symbols */ && typeof name === 'symbol') { + continue; + } + let shouldAdd = true; + switch (key_filter & 7) { + case 1 /* napi_key_filter.napi_key_writable */: { + shouldAdd = Boolean(desc.writable); + break; + } + case 2 /* napi_key_filter.napi_key_enumerable */: { + shouldAdd = Boolean(desc.enumerable); + break; + } + case (1 /* napi_key_filter.napi_key_writable */ | 2 /* napi_key_filter.napi_key_enumerable */): { + shouldAdd = Boolean(desc.writable && desc.enumerable); + break; + } + case 4 /* napi_key_filter.napi_key_configurable */: { + shouldAdd = Boolean(desc.configurable); + break; + } + case (4 /* napi_key_filter.napi_key_configurable */ | 1 /* napi_key_filter.napi_key_writable */): { + shouldAdd = Boolean(desc.configurable && desc.writable); + break; + } + case (4 /* napi_key_filter.napi_key_configurable */ | 2 /* napi_key_filter.napi_key_enumerable */): { + shouldAdd = Boolean(desc.configurable && desc.enumerable); + break; + } + case (4 /* napi_key_filter.napi_key_configurable */ | 2 /* napi_key_filter.napi_key_enumerable */ | 1 /* napi_key_filter.napi_key_writable */): { + shouldAdd = Boolean(desc.configurable && desc.enumerable && desc.writable); + break; + } + } + if (shouldAdd) { + addName(ret, name, key_filter, key_conversion); + } + } + } + result >>>= 0; + value = emnapiCtx.napiValueFromJsValue(ret); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippp */ + function napi_get_property_names(env, object, result) { + return napi_get_all_property_names(env, object, 0 /* napi_key_collection_mode.napi_key_include_prototypes */, 2 /* napi_key_filter.napi_key_enumerable */ | 16 /* napi_key_filter.napi_key_skip_symbols */, 1 /* napi_key_conversion.napi_key_numbers_to_strings */, result); + } + /** @__sig ipppp */ + function napi_set_property(env, object, key, value) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!key) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(object); + const type = typeof jsValue; + if (!((type === 'object' && jsValue !== null) || type === 'function')) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + jsValue[emnapiCtx.jsValueFromNapiValue(key)] = emnapiCtx.jsValueFromNapiValue(value); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipppp */ + function napi_has_property(env, object, key, result) { + let r; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!key) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(object); + if (jsValue == null) { + throw new TypeError('Cannot convert undefined or null to object'); + } + const type = typeof jsValue; + let v; + try { + v = (type === 'object' && jsValue !== null) || type === 'function' ? jsValue : Object(jsValue); + } + catch (_) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + result >>>= 0; + r = (emnapiCtx.jsValueFromNapiValue(key) in v) ? 1 : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(result, r, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipppp */ + function napi_get_property(env, object, key, result) { + let value; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!key) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(object); + if (jsValue == null) { + throw new TypeError('Cannot convert undefined or null to object'); + } + const type = typeof jsValue; + let v; + try { + v = (type === 'object' && jsValue !== null) || type === 'function' ? jsValue : Object(jsValue); + } + catch (_) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + result >>>= 0; + value = emnapiCtx.napiValueFromJsValue(v[emnapiCtx.jsValueFromNapiValue(key)]); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipppp */ + function napi_delete_property(env, object, key, result) { + let r; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!key) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(object); + const type = typeof jsValue; + if (!((type === 'object' && jsValue !== null) || type === 'function')) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + const propertyKey = emnapiCtx.jsValueFromNapiValue(key); + if (emnapiCtx.features.Reflect) { + r = emnapiCtx.features.Reflect.deleteProperty(jsValue, propertyKey); + } + else { + try { + r = delete jsValue[propertyKey]; + } + catch (_) { + r = false; + } + } + if (result) { + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(result, r ? 1 : 0, true); + } + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipppp */ + function napi_has_own_property(env, object, key, result) { + let r; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!key) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(object); + if (jsValue == null) { + throw new TypeError('Cannot convert undefined or null to object'); + } + const type = typeof jsValue; + let v; + try { + v = ((type === 'object' && jsValue !== null) || type !== 'function') ? jsValue : Object(jsValue); + } + catch (_) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + const prop = emnapiCtx.jsValueFromNapiValue(key); + if (typeof prop !== 'string' && typeof prop !== 'symbol') { + return envObject.setLastError(4 /* napi_status.napi_name_expected */); + } + r = Object.prototype.hasOwnProperty.call(v, emnapiCtx.jsValueFromNapiValue(key)); + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(result, r ? 1 : 0, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipppp */ + function napi_set_named_property(env, object, cname, value) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(object); + const type = typeof jsValue; + if (!(((type === 'object' && jsValue !== null) || type === 'function'))) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + if (!cname) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + cname >>>= 0; + emnapiCtx.jsValueFromNapiValue(object)[emnapiString.UTF8ToString(cname, -1)] = emnapiCtx.jsValueFromNapiValue(value); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipppp */ + function napi_has_named_property(env, object, utf8name, result) { + let r; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!utf8name) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + const jsValue = emnapiCtx.jsValueFromNapiValue(object); + if (jsValue == null) { + throw new TypeError('Cannot convert undefined or null to object'); + } + const type = typeof jsValue; + let v; + try { + v = ((type === 'object' && jsValue !== null) || type === 'function') ? jsValue : Object(jsValue); + } + catch (_) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + utf8name >>>= 0; + result >>>= 0; + r = emnapiString.UTF8ToString(utf8name, -1) in v; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(result, r ? 1 : 0, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipppp */ + function napi_get_named_property(env, object, utf8name, result) { + let value; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!utf8name) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + const jsValue = emnapiCtx.jsValueFromNapiValue(object); + if (jsValue == null) { + throw new TypeError('Cannot convert undefined or null to object'); + } + const type = typeof jsValue; + let v; + try { + v = ((type === 'object' && jsValue !== null) || type === 'function') ? jsValue : Object(jsValue); + } + catch (_) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + utf8name >>>= 0; + result >>>= 0; + value = emnapiCtx.napiValueFromJsValue(v[emnapiString.UTF8ToString(utf8name, -1)]); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippip */ + function napi_set_element(env, object, index, value) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(object); + const type = typeof jsValue; + if (!(((type === 'object' && jsValue !== null) || type === 'function'))) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + jsValue[index >>> 0] = emnapiCtx.jsValueFromNapiValue(value); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippip */ + function napi_has_element(env, object, index, result) { + let r; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(object); + if (jsValue == null) { + throw new TypeError('Cannot convert undefined or null to object'); + } + let v; + const type = typeof jsValue; + try { + v = ((type === 'object' && jsValue !== null) || type === 'function') ? jsValue : Object(jsValue); + } + catch (_) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + result >>>= 0; + r = ((index >>> 0) in v) ? 1 : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(result, r, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippip */ + function napi_get_element(env, object, index, result) { + let value; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(object); + if (jsValue == null) { + throw new TypeError('Cannot convert undefined or null to object'); + } + const type = typeof jsValue; + let v; + try { + v = ((type === 'object' && jsValue !== null) || type === 'function') ? jsValue : Object(jsValue); + } + catch (_) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + result >>>= 0; + value = emnapiCtx.napiValueFromJsValue(v[index >>> 0]); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippip */ + function napi_delete_element(env, object, index, result) { + let r; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(object); + const type = typeof jsValue; + if (!(((type === 'object' && jsValue !== null) || type === 'function'))) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + if (emnapiCtx.features.Reflect) { + r = emnapiCtx.features.Reflect.deleteProperty(jsValue, index >>> 0); + } + else { + try { + r = delete jsValue[index >>> 0]; + } + catch (_) { + r = false; + } + } + if (result) { + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(result, r ? 1 : 0, true); + } + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipppp */ + function napi_define_properties(env, object, property_count, properties) { + let propPtr, attributes; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + properties >>>= 0; + property_count >>>= 0; + property_count = property_count >>> 0; + if (property_count > 0) { + if (!properties) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const maybeObject = emnapiCtx.jsValueFromNapiValue(object); + const type = typeof maybeObject; + if (!((type === 'object' && maybeObject !== null) || type === 'function')) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + let propertyName; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + for (let i = 0; i < property_count; i++) { + propPtr = properties + (i * (4 * 8)); + const utf8Name = GET_HEAP_DATA_VIEW().getUint32(propPtr, true); + const name = GET_HEAP_DATA_VIEW().getUint32(propPtr + 4, true); + const method = GET_HEAP_DATA_VIEW().getUint32(propPtr + 8, true); + const getter = GET_HEAP_DATA_VIEW().getUint32(propPtr + 12, true); + const setter = GET_HEAP_DATA_VIEW().getUint32(propPtr + 16, true); + const value = GET_HEAP_DATA_VIEW().getUint32(propPtr + 20, true); + attributes = GET_HEAP_DATA_VIEW().getInt32(propPtr + 24, true); + attributes >>>= 0; + const data = GET_HEAP_DATA_VIEW().getUint32(propPtr + 28, true); + if (utf8Name) { + propertyName = emnapiString.UTF8ToString(utf8Name, -1); + } + else { + if (!name) { + return envObject.setLastError(4 /* napi_status.napi_name_expected */); + } + propertyName = emnapiCtx.jsValueFromNapiValue(name); + if (typeof propertyName !== 'string' && typeof propertyName !== 'symbol') { + return envObject.setLastError(4 /* napi_status.napi_name_expected */); + } + } + emnapiDefineProperty(envObject, maybeObject, propertyName, method, getter, setter, value, attributes, data); + } + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipp */ + function napi_object_freeze(env, object) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const maybeObject = emnapiCtx.jsValueFromNapiValue(object); + const type = typeof maybeObject; + if (!(((type === 'object' && maybeObject !== null) || type === 'function'))) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + Object.freeze(maybeObject); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipp */ + function napi_object_seal(env, object) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const maybeObject = emnapiCtx.jsValueFromNapiValue(object); + const type = typeof maybeObject; + if (!(((type === 'object' && maybeObject !== null) || type === 'function'))) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + Object.seal(maybeObject); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + + //#endregion src/property.ts + + var propertyMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + napi_define_properties: napi_define_properties, + napi_delete_element: napi_delete_element, + napi_delete_property: napi_delete_property, + napi_get_all_property_names: napi_get_all_property_names, + napi_get_element: napi_get_element, + napi_get_named_property: napi_get_named_property, + napi_get_property: napi_get_property, + napi_get_property_names: napi_get_property_names, + napi_has_element: napi_has_element, + napi_has_named_property: napi_has_named_property, + napi_has_own_property: napi_has_own_property, + napi_has_property: napi_has_property, + napi_object_freeze: napi_object_freeze, + napi_object_seal: napi_object_seal, + napi_set_element: napi_set_element, + napi_set_named_property: napi_set_named_property, + napi_set_property: napi_set_property + }); + + //#region src/script.ts + /** + * @__sig ippp + */ + function napi_run_script(env, script, result) { + let status; + let value; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!script) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const v8Script = emnapiCtx.jsValueFromNapiValue(script); + if (typeof v8Script !== 'string') { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + const g = emnapiCtx.jsValueFromNapiValue(6 /* Constant.GLOBAL */); + const ret = g.eval(v8Script); + result >>>= 0; + value = emnapiCtx.napiValueFromJsValue(ret); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, value, true); + status = (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + return status; + } + + //#endregion src/script.ts + + var scriptMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + napi_run_script: napi_run_script + }); + + //#region src/value-operation.ts + /** @__sig ippp */ + function napi_typeof(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const v = emnapiCtx.jsValueFromNapiValue(value); + const type = typeof v; + result >>>= 0; + let r; + if (type === 'number') { + r = 3 /* napi_valuetype.napi_number */; + } + else if (type === 'bigint') { + r = 9 /* napi_valuetype.napi_bigint */; + } + else if (type === 'string') { + r = 4 /* napi_valuetype.napi_string */; + } + else if (type === 'function') { + // This test has to come before IsObject because IsFunction + // implies IsObject + r = 7 /* napi_valuetype.napi_function */; + } + else if (emnapiCtx.isExternal(v)) { + // This test has to come before IsObject because IsExternal + // implies IsObject + r = 8 /* napi_valuetype.napi_external */; + } + else if (type === 'object' && v !== null) { + r = 6 /* napi_valuetype.napi_object */; + } + else if (type === 'boolean') { + r = 2 /* napi_valuetype.napi_boolean */; + } + else if (type === 'undefined') { + r = 0 /* napi_valuetype.napi_undefined */; + } + else if (type === 'symbol') { + r = 5 /* napi_valuetype.napi_symbol */; + } + else if (v === null) { + r = 1 /* napi_valuetype.napi_null */; + } + else { + // Should not get here unless V8 has added some new kind of value. + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt32(result, r, true); + return envObject.clearLastError(); + } + /** @__sig ippp */ + function napi_coerce_to_bool(env, value, result) { + let v; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + result >>>= 0; + v = jsValue ? 5 /* Constant.TRUE */ : 4 /* Constant.FALSE */; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, v, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippp */ + function napi_coerce_to_number(env, value, result) { + let v; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + if (typeof jsValue === 'bigint') { + throw new TypeError('Cannot convert a BigInt value to a number'); + } + result >>>= 0; + v = emnapiCtx.napiValueFromJsValue(Number(jsValue)); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, v, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippp */ + function napi_coerce_to_object(env, value, result) { + let v; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + if (jsValue == null) { + throw new TypeError('Cannot convert undefined or null to object'); + } + result >>>= 0; + v = emnapiCtx.napiValueFromJsValue(Object(jsValue)); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, v, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippp */ + function napi_coerce_to_string(env, value, result) { + let v; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + if (typeof jsValue === 'symbol') { + throw new TypeError('Cannot convert a Symbol value to a string'); + } + result >>>= 0; + v = emnapiCtx.napiValueFromJsValue(String(jsValue)); + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, v, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipppp */ + function napi_instanceof(env, object, constructor, result) { + let r; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!object) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!constructor) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(result, 0, true); + const ctor = emnapiCtx.jsValueFromNapiValue(constructor); + if (typeof ctor !== 'function') { + return envObject.setLastError(5 /* napi_status.napi_function_expected */); + } + const val = emnapiCtx.jsValueFromNapiValue(object); + const ret = val instanceof ctor; + r = ret ? 1 : 0; + GET_HEAP_DATA_VIEW().setInt8(result, r, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ippp */ + function napi_is_array(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + result >>>= 0; + const r = Array.isArray(jsValue) ? 1 : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(result, r, true); + return envObject.clearLastError(); + } + /** @__sig ippp */ + function napi_is_arraybuffer(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const h = emnapiCtx.jsValueFromNapiValue(value); + result >>>= 0; + const r = h instanceof ArrayBuffer ? 1 : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(result, r, true); + return envObject.clearLastError(); + } + /** @__sig ippp */ + function node_api_is_sharedarraybuffer(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const h = emnapiCtx.jsValueFromNapiValue(value); + result >>>= 0; + const r = ((typeof SharedArrayBuffer === 'function' && h instanceof SharedArrayBuffer) || + (Object.prototype.toString.call(h) === '[object SharedArrayBuffer]')) + ? 1 + : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(result, r, true); + return envObject.clearLastError(); + } + /** @__sig ippp */ + function napi_is_date(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const h = emnapiCtx.jsValueFromNapiValue(value); + result >>>= 0; + const r = h instanceof Date ? 1 : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(result, r, true); + return envObject.clearLastError(); + } + /** @__sig ippp */ + function napi_is_error(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const val = emnapiCtx.jsValueFromNapiValue(value); + result >>>= 0; + const r = (val instanceof Error) ? 1 : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(result, r, true); + return envObject.clearLastError(); + } + /** @__sig ippp */ + function napi_is_typedarray(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const h = emnapiCtx.jsValueFromNapiValue(value); + result >>>= 0; + const r = (ArrayBuffer.isView(h)) && !(h instanceof DataView) ? 1 : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(result, r, true); + return envObject.clearLastError(); + } + /** @__sig ippp */ + function napi_is_buffer(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const h = emnapiCtx.jsValueFromNapiValue(value); + result >>>= 0; + const Buffer = emnapiCtx.features.Buffer; + const r = (ArrayBuffer.isView(h) || (typeof Buffer === 'function' && Buffer.isBuffer(h))) ? 1 : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(result, r, true); + return envObject.clearLastError(); + } + /** @__sig ippp */ + function napi_is_dataview(env, value, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!value) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const h = emnapiCtx.jsValueFromNapiValue(value); + result >>>= 0; + const r = h instanceof DataView ? 1 : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(result, r, true); + return envObject.clearLastError(); + } + /** @__sig ipppp */ + function napi_strict_equals(env, lhs, rhs, result) { + let r; + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!lhs) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!rhs) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const lv = emnapiCtx.jsValueFromNapiValue(lhs); + const rv = emnapiCtx.jsValueFromNapiValue(rhs); + result >>>= 0; + r = (lv === rv) ? 1 : 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(result, r, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + /** @__sig ipp */ + function napi_detach_arraybuffer(env, arraybuffer) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!arraybuffer) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const value = emnapiCtx.jsValueFromNapiValue(arraybuffer); + if (!(value instanceof ArrayBuffer)) { + if (typeof SharedArrayBuffer === 'function' && (value instanceof SharedArrayBuffer)) { + return envObject.setLastError(20 /* napi_status.napi_detachable_arraybuffer_expected */); + } + return envObject.setLastError(19 /* napi_status.napi_arraybuffer_expected */); + } + try { + const MessageChannel = emnapiCtx.features.MessageChannel; + const messageChannel = new MessageChannel(); + messageChannel.port1.postMessage(value, [value]); + } + catch (_) { + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + return envObject.clearLastError(); + } + /** @__sig ippp */ + function napi_is_detached_arraybuffer(env, arraybuffer, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapiEnv; + envObject.checkGCAccess(); + if (!envObject.lastException.isEmpty()) + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + if (!envObject.canCallIntoJs()) + return envObject.setLastError(envObject.moduleApiVersion >= 10 ? 23 /* napi_status.napi_cannot_run_js */ : 10 /* napi_status.napi_pending_exception */); + envObject.clearLastError(); + try { + if (!arraybuffer) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const h = emnapiCtx.jsValueFromNapiValue(arraybuffer); + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + if (h instanceof ArrayBuffer && h.byteLength === 0) { + try { + // eslint-disable-next-line no-new + new Uint8Array(h); + } + catch (_) { + GET_HEAP_DATA_VIEW().setInt8(result, 1, true); + return (0 /* napi_status.napi_ok */); + } + } + GET_HEAP_DATA_VIEW().setInt8(result, 0, true); + return (0 /* napi_status.napi_ok */); + } + catch (err) { + envObject.lastException.resetTo(err); + return envObject.setLastError(10 /* napi_status.napi_pending_exception */); + } + } + + //#endregion src/value-operation.ts + + var valueOperationMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + napi_coerce_to_bool: napi_coerce_to_bool, + napi_coerce_to_number: napi_coerce_to_number, + napi_coerce_to_object: napi_coerce_to_object, + napi_coerce_to_string: napi_coerce_to_string, + napi_detach_arraybuffer: napi_detach_arraybuffer, + napi_instanceof: napi_instanceof, + napi_is_array: napi_is_array, + napi_is_arraybuffer: napi_is_arraybuffer, + napi_is_buffer: napi_is_buffer, + napi_is_dataview: napi_is_dataview, + napi_is_date: napi_is_date, + napi_is_detached_arraybuffer: napi_is_detached_arraybuffer, + napi_is_error: napi_is_error, + napi_is_typedarray: napi_is_typedarray, + napi_strict_equals: napi_strict_equals, + napi_typeof: napi_typeof, + node_api_is_sharedarraybuffer: node_api_is_sharedarraybuffer + }); + + //#region src/version.ts + /** @__sig ipp */ + function napi_get_version(env, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + const envObject = emnapiEnv; + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const NODE_API_SUPPORTED_VERSION_MAX = 10 /* Version.NODE_API_SUPPORTED_VERSION_MAX */; + var HEAP_DATA_VIEW = new DataView(wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, NODE_API_SUPPORTED_VERSION_MAX, true); + return envObject.clearLastError(); + } + + //#endregion src/version.ts + + var versionMod = /*#__PURE__*/Object.freeze({ + __proto__: null, + napi_get_version: napi_get_version + }); + + //#region src/core/index.ts + emnapiExternalMemory.init(); + emnapiExternalSAB.init(); + emnapiString.init(); + // emnapiTSFN.init() + PThread.init(); + napiModule.emnapi.syncMemory = $emnapiSyncMemory; + napiModule.emnapi.getMemoryAddress = $emnapiGetMemoryAddress; + napiModule.emnapi.acquireExternalSharedArrayBuffer = $emnapiAcquireExternalSharedArrayBuffer; + function addImports(mod) { + const keys = Object.keys(mod); + for (let i = 0; i < keys.length; ++i) { + const k = keys[i]; + if (k.indexOf('$') === 0) + continue; + if (k.indexOf('emnapi_') === 0) { + napiModule.imports.emnapi[k] = mod[k]; + } + else if (k.indexOf('_emnapi_') === 0 || k.indexOf('_v8_') === 0 || k === 'napi_set_last_error' || k === 'napi_clear_last_error') { + napiModule.imports.env[k] = mod[k]; + } + else { + napiModule.imports.napi[k] = mod[k]; + } + } + } + addImports(asyncMod); + addImports(memoryMod); + addImports(utilMod); + addImports(convert2cMod); + addImports(convert2napiMod); + addImports(createMod); + addImports(globalMod); + addImports(wrapMod); + addImports(envMod); + addImports(emnapiMod); + addImports(errorMod); + addImports(functionMod); + addImports(lifeMod); + addImports(miscellaneousMod); + addImports(nodeMod); + addImports(promiseMod); + addImports(propertyMod); + addImports(scriptMod); + addImports(valueOperationMod); + addImports(versionMod); + // napiModule.imports.napi.napi_create_threadsafe_function = napi_create_threadsafe_function + // napiModule.imports.napi.napi_get_threadsafe_function_context = napi_get_threadsafe_function_context + // napiModule.imports.napi.napi_call_threadsafe_function = napi_call_threadsafe_function + // napiModule.imports.napi.napi_acquire_threadsafe_function = napi_acquire_threadsafe_function + // napiModule.imports.napi.napi_release_threadsafe_function = napi_release_threadsafe_function + // napiModule.imports.napi.napi_unref_threadsafe_function = napi_unref_threadsafe_function + // napiModule.imports.napi.napi_ref_threadsafe_function = napi_ref_threadsafe_function + const pluginCtx = { + emnapiString + }; + Object.keys(initMod).forEach(k => { + Object.defineProperty(pluginCtx, k, { + get: () => initMod[k], + enumerable: true, + configurable: true + }); + }); + Object.keys(nodeMod).forEach(k => { + Object.defineProperty(pluginCtx, k, { + get: () => nodeMod[k], + enumerable: true, + configurable: true + }); + }); + Object.keys(utilMod).forEach(k => { + Object.defineProperty(pluginCtx, k, { + get: () => utilMod[k], + enumerable: true, + configurable: true + }); + }); + napiModule.plugins = (options.plugins ?? []).map((plugin) => { + if (typeof plugin === 'function') { + return plugin(pluginCtx); + } + if (typeof plugin === 'object' && plugin !== null) { + return plugin; + } + throw new TypeError('Invalid plugin'); + }); + napiModule.plugins.forEach((plugin) => { + if (typeof plugin.importObject === 'function') { + const importObject = plugin.importObject(napiModule.imports); + if (importObject) { + napiModule.imports = importObject; + } + } + }); + var index = napiModule; + + //#endregion src/core/index.ts + + return index; + +})(); + return napiModule; +} + +//#endregion src/emnapi/index.js + +//#region src/load.ts +function loadNapiModuleImpl(loadFn, userNapiModule, wasmInput, options) { + options = options ?? {}; + const getMemory = options.getMemory; + const getTable = options.getTable; + const beforeInit = options.beforeInit; + if (getMemory != null && typeof getMemory !== 'function') { + throw new TypeError('options.getMemory is not a function'); + } + if (getTable != null && typeof getTable !== 'function') { + throw new TypeError('options.getTable is not a function'); + } + if (beforeInit != null && typeof beforeInit !== 'function') { + throw new TypeError('options.beforeInit is not a function'); + } + let napiModule; + const isLoad = typeof userNapiModule === 'object' && userNapiModule !== null; + if (isLoad) { + if (userNapiModule.loaded) { + throw new Error('napiModule has already loaded'); + } + napiModule = userNapiModule; + } + else { + napiModule = createNapiModule(options); + } + const wasi = options.wasi; + let wasiThreads; + let importObject = { + env: napiModule.imports.env, + napi: napiModule.imports.napi, + emnapi: napiModule.imports.emnapi + }; + if (wasi) { + wasiThreads = new WASIThreads(napiModule.childThread + ? { + wasi, + childThread: true, + postMessage: napiModule.postMessage + } + : { + wasi, + threadManager: napiModule.PThread, + waitThreadStart: napiModule.waitThreadStart + }); + Object.assign(importObject, typeof wasi.getImportObject === 'function' + ? wasi.getImportObject() + : { wasi_snapshot_preview1: wasi.wasiImport }); + Object.assign(importObject, wasiThreads.getImportObject()); + } + const overwriteImports = options.overwriteImports; + if (typeof overwriteImports === 'function') { + const newImportObject = overwriteImports(importObject); + if (typeof newImportObject === 'object' && newImportObject !== null) { + importObject = newImportObject; + } + } + return loadFn(wasmInput, importObject, (err, source) => { + if (err) { + throw err; + } + const originalInstance = source.instance; + let instance = originalInstance; + const originalExports = originalInstance.exports; + const exportMemory = 'memory' in originalExports; + const importMemory = 'memory' in importObject.env; + const memory = getMemory + ? getMemory(originalExports) + : exportMemory + ? originalExports.memory + : importMemory + ? importObject.env.memory + : undefined; + if (!memory) { + throw new Error('memory is neither exported nor imported'); + } + const table = getTable ? getTable(originalExports) : originalExports.__indirect_function_table; + if (wasi && !exportMemory) { + const exports = Object.create(null); + Object.assign(exports, originalExports, { memory }); + instance = { exports }; + } + const module = source.module; + if (wasi) { + instance = wasiThreads.initialize(instance, module, memory); + } + else { + napiModule.PThread.setup(module, memory); + } + const emnapiInit = () => { + if (beforeInit) { + beforeInit({ + instance: originalInstance, + module + }); + } + napiModule.init({ + instance, + module, + memory, + table + }); + const ret = { + instance: originalInstance, + module, + usedInstance: instance + }; + if (!isLoad) { + ret.napiModule = napiModule; + } + return ret; + }; + if (napiModule.PThread.shouldPreloadWorkers()) { + const poolReady = napiModule.PThread.loadWasmModuleToAllWorkers(); + if (loadFn === loadCallback) { + return poolReady.then(emnapiInit); + } + else { + throw new Error('Synchronous loading is not supported with worker pool (reuseWorker.size > 0)'); + } + } + return emnapiInit(); + }); +} +function loadCallback(wasmInput, importObject, callback) { + return load(wasmInput, importObject).then((source) => { + return callback(null, source); + }, err => { + return callback(err); + }); +} +function loadSyncCallback(wasmInput, importObject, callback) { + let source; + try { + source = loadSync(wasmInput, importObject); + } + catch (err) { + return callback(err); + } + return callback(null, source); +} +function loadNapiModule(napiModule, wasmInput, options) { + if (typeof napiModule !== 'object' || napiModule === null) { + throw new TypeError('Invalid napiModule'); + } + return loadNapiModuleImpl(loadCallback, napiModule, wasmInput, options); +} +function loadNapiModuleSync(napiModule, wasmInput, options) { + if (typeof napiModule !== 'object' || napiModule === null) { + throw new TypeError('Invalid napiModule'); + } + return loadNapiModuleImpl(loadSyncCallback, napiModule, wasmInput, options); +} +function instantiateNapiModule(wasmInput, options) { + return loadNapiModuleImpl(loadCallback, undefined, wasmInput, options); +} +function instantiateNapiModuleSync(wasmInput, options) { + return loadNapiModuleImpl(loadSyncCallback, undefined, wasmInput, options); +} + +//#endregion src/load.ts + +//#region src/worker.ts +class MessageHandler extends ThreadMessageHandler { + constructor(options) { + if (typeof options.onLoad !== 'function') { + throw new TypeError('options.onLoad is not a function'); + } + const userOnError = options.onError; + super({ + ...options, + onError: (err, type) => { + const emnapi_thread_crashed = this.instance?.exports.emnapi_thread_crashed; + if (typeof emnapi_thread_crashed === 'function') { + emnapi_thread_crashed(); + } + if (typeof userOnError === 'function') { + userOnError(err, type); + } + else { + throw err; + } + } + }); + this.napiModule = undefined; + } + instantiate(data) { + const source = this.onLoad(data); + const then = source.then; + if (typeof then === 'function') { + return source.then((result) => { + this.napiModule = result.napiModule; + return result; + }); + } + this.napiModule = source.napiModule; + return source; + } + handle(e) { + super.handle(e); + if (e?.data?.__emnapi__) { + const type = e.data.__emnapi__.type; + const payload = e.data.__emnapi__.payload; + try { + if (type === 'async-worker-init') { + this.handleAfterLoad(e, () => { + this.napiModule.initWorker(payload.arg, payload.func); + }); + } + } + catch (err) { + this.onError(err, type); + } + } + } +} + +//#endregion src/worker.ts + +//#region src/index.ts +const version = "2.0.0-alpha.3"; + +//#endregion src/index.ts + +export { MessageHandler, createNapiModule, instantiateNapiModule, instantiateNapiModuleSync, loadNapiModule, loadNapiModuleSync, version }; diff --git a/client/node_modules/@emnapi/core/dist/plugins/async-work.d.ts b/client/node_modules/@emnapi/core/dist/plugins/async-work.d.ts new file mode 100644 index 0000000..0705f24 --- /dev/null +++ b/client/node_modules/@emnapi/core/dist/plugins/async-work.d.ts @@ -0,0 +1,5 @@ +import { PluginFactory } from '../emnapi-core' +export { PluginFactory, PluginContext, EmnapiPlugin } from '../emnapi-core' + +declare const _default: PluginFactory +export default _default \ No newline at end of file diff --git a/client/node_modules/@emnapi/core/dist/plugins/async-work.js b/client/node_modules/@emnapi/core/dist/plugins/async-work.js new file mode 100644 index 0000000..f8204b6 --- /dev/null +++ b/client/node_modules/@emnapi/core/dist/plugins/async-work.js @@ -0,0 +1,818 @@ +//#region src/emnapi/async-work.js +function asyncWork (emnapiPluginCtx) { + const { emnapiCtx, emnapiNodeBinding, emnapiAsyncWorkPoolSize } = emnapiPluginCtx; + var mod = (function (exports, emnapi_shared, emscripten_runtime) { + + //#region src/async-work.ts + /** + * @__deps $emnapiCtx + * @__deps $emnapiEnv + * @__deps $emnapiNodeBinding + * @__deps $emnapiAsyncWorkPoolSize + * @__postset + * ``` + * emnapiAWST.init(); + * ``` + */ + var emnapiAWST = { + idGen: {}, + values: [undefined], + queued: new Set(), + pending: [], + init: function () { + const idGen = { + nextId: 1, + list: [], + generate: function () { + let id; + if (idGen.list.length) { + id = idGen.list.shift(); + } + else { + id = idGen.nextId; + idGen.nextId++; + } + return id; + }, + reuse: function (id) { + idGen.list.push(id); + } + }; + emnapiAWST.idGen = idGen; + emnapiAWST.values = [undefined]; + emnapiAWST.queued = new Set(); + emnapiAWST.pending = []; + }, + create: function (env, resource, resourceName, execute, complete, data) { + let asyncId = 0; + let triggerAsyncId = 0; + if (emnapiNodeBinding) { + const asyncContext = emnapiNodeBinding.node.emitAsyncInit(resource, resourceName, -1); + asyncId = asyncContext.asyncId; + triggerAsyncId = asyncContext.triggerAsyncId; + } + const id = emnapiAWST.idGen.generate(); + emnapiAWST.values[id] = { + env, + id, + resource, + asyncId, + triggerAsyncId, + status: 0, + execute, + complete, + data + }; + return id; + }, + callComplete: function (work, status) { + const complete = work.complete; + const env = work.env; + const data = work.data; + const callback = () => { + if (!complete) + return; + const envObject = emnapi_shared.emnapiEnv; + const scope = emnapiCtx.openScope(envObject); + try { + envObject.callbackIntoModule(true, () => { + (emnapiPluginCtx.wasmTable.get(complete))(env, status, data); + }); + } + finally { + emnapiCtx.closeScope(envObject, scope); + } + }; + if (emnapiNodeBinding) { + emnapiNodeBinding.node.makeCallback(work.resource, callback, [], { + asyncId: work.asyncId, + triggerAsyncId: work.triggerAsyncId + }); + } + else { + callback(); + } + }, + queue: function (id) { + const work = emnapiAWST.values[id]; + if (!work) + return; + if (work.status === 0) { + work.status = 1; + if (emnapiAWST.queued.size >= (Math.abs(emnapiAsyncWorkPoolSize) || 4)) { + emnapiAWST.pending.push(id); + return; + } + emnapiAWST.queued.add(id); + const env = work.env; + const data = work.data; + const execute = work.execute; + work.status = 2; + emnapiCtx.features.setImmediate(() => { + (emnapiPluginCtx.wasmTable.get(execute))(env, data); + emnapiAWST.queued.delete(id); + work.status = 3; + emnapiCtx.features.setImmediate(() => { + emnapiAWST.callComplete(work, 0 /* napi_status.napi_ok */); + }); + if (emnapiAWST.pending.length > 0) { + const nextWorkId = emnapiAWST.pending.shift(); + emnapiAWST.values[nextWorkId].status = 0; + emnapiAWST.queue(nextWorkId); + } + }); + } + }, + cancel: function (id) { + const index = emnapiAWST.pending.indexOf(id); + if (index !== -1) { + const work = emnapiAWST.values[id]; + if (work && (work.status === 1)) { + work.status = 4; + emnapiAWST.pending.splice(index, 1); + emnapiCtx.features.setImmediate(() => { + emnapiAWST.callComplete(work, 11 /* napi_status.napi_cancelled */); + }); + return 0 /* napi_status.napi_ok */; + } + else { + return 9 /* napi_status.napi_generic_failure */; + } + } + return 9 /* napi_status.napi_generic_failure */; + }, + remove: function (id) { + const work = emnapiAWST.values[id]; + if (!work) + return; + if (emnapiNodeBinding) { + emnapiNodeBinding.node.emitAsyncDestroy({ + asyncId: work.asyncId, + triggerAsyncId: work.triggerAsyncId + }); + } + emnapiAWST.values[id] = undefined; + emnapiAWST.idGen.reuse(id); + } + }; + + //#endregion src/async-work.ts + + //#region src/macro.ts + + //#endregion src/macro.ts + + //#region src/core/async-work.ts + const { + // onCreateWorker, napiModule, singleThreadAsyncWork, _emnapi_async_work_pool_size, + // PThread, ENVIRONMENT_IS_NODE, ENVIRONMENT_IS_PTHREAD, wasmInstance, _free, wasmMemory, _malloc, + _emnapi_node_emit_async_init, _emnapi_node_emit_async_destroy, _emnapi_runtime_keepalive_pop, _emnapi_runtime_keepalive_push } = emnapiPluginCtx; + var emnapiAWMT = { + pool: [], + workerReady: null, + globalAddress: 0, + globalOffset: { + idle_threads: 0, + q: 1 * 4, + next: 1 * 4, + prev: 2 * 4, + mutex: 3 * 4, + cond: 4 * 4, + exit_message: 5 * 4, + end: 7 * 4 + }, + offset: { + /* napi_ref */ resource: 0, + /* double */ async_id: 8, + /* double */ trigger_async_id: 16, + /* napi_env */ env: 24, + /* int32_t */ status: 1 * 4 + 24, // 0 for pending, 1 for cancelled, 2 for completed + queue: 2 * 4 + 24, + queue_next: 2 * 4 + 24, + queue_prev: 3 * 4 + 24, + /* void* */ data: 4 * 4 + 24, + /* napi_async_execute_callback */ execute: 5 * 4 + 24, + /* napi_async_complete_callback */ complete: 6 * 4 + 24, + end: 7 * 4 + 24 + }, + /** + * When another thread grows the shared WebAssembly.Memory, this agent's + * cached `wasmMemory.buffer` may still have the old shorter length + * (V8 refreshes it lazily). If a pointer derived from shared memory lies + * beyond the cached length, `wasmMemory.grow(0)` forces the agent to + * observe the current memory size and refreshes the buffer. + */ + ensureBufferFor(end) { + let buffer = emscripten_runtime.wasmMemory.buffer; + if (end > buffer.byteLength) { + emscripten_runtime.wasmMemory.grow(0); + buffer = emscripten_runtime.wasmMemory.buffer; + } + return buffer; + }, + init() { + emnapiAWMT.pool = []; + emnapiAWMT.workerReady = null; + if (typeof emscripten_runtime.PThread !== 'undefined') { + emscripten_runtime.PThread.unusedWorkers.forEach(emnapiAWMT.addListener); + Object.values(emscripten_runtime.PThread.pthreads).forEach(emnapiAWMT.addListener); + const __original_getNewWorker = emscripten_runtime.PThread.getNewWorker; + emscripten_runtime.PThread.getNewWorker = function () { + const r = __original_getNewWorker.apply(this, arguments); + emnapiAWMT.addListener(r); + return r; + }; + } + }, + addListener(worker) { + if (!worker) + return false; + if (worker._emnapiAWMTListener) + return true; + const handler = function (e) { + const data = emscripten_runtime.ENVIRONMENT_IS_NODE ? e : e.data; + const __emnapi__ = data.__emnapi__; + if (__emnapi__) { + const type = __emnapi__.type; + const payload = __emnapi__.payload; + if (type === 'async-work-complete') { + emnapiAWMT.callComplete(payload.work, 0 /* napi_status.napi_ok */); + } + } + }; + const dispose = function () { + if (emscripten_runtime.ENVIRONMENT_IS_NODE) { + worker.off('message', handler); + } + else { + worker.removeEventListener('message', handler, false); + } + delete worker._emnapiAWMTListener; + }; + worker._emnapiAWMTListener = { handler, dispose }; + if (emscripten_runtime.ENVIRONMENT_IS_NODE) { + worker.on('message', handler); + } + else { + worker.addEventListener('message', handler, false); + } + return true; + }, + initGlobal() { + if (!emnapiAWMT.globalAddress) { + emnapiAWMT.globalAddress = emscripten_runtime._malloc(emnapiAWMT.globalOffset.end); + emnapiAWMT.globalAddress >>>= 0; + const size = emnapiAWMT.globalOffset.end; + const addr = emnapiAWMT.globalAddress; + new Uint8Array(emnapiAWMT.ensureBufferFor(addr + size), addr, size).fill(0); + emnapiAWMT.queueInit(emnapiAWMT.globalAddress + emnapiAWMT.globalOffset.q); + emnapiAWMT.queueInit(emnapiAWMT.globalAddress + emnapiAWMT.globalOffset.exit_message); + } + }, + terminateWorkers() { + emnapiAWMT.pool.forEach(w => { + w._emnapiAWMTListener?.dispose(); + w._emnapiTSFNListener?.dispose(); + w.terminate(); + }); + emnapiAWMT.pool.length = 0; + }, + initWorkers(n) { + if (emscripten_runtime.ENVIRONMENT_IS_PTHREAD) { + return emnapiAWMT.workerReady || (emnapiAWMT.workerReady = Promise.resolve()); + } + if (emnapiAWMT.workerReady) + return emnapiAWMT.workerReady; + if (!('emnapi_async_worker_create' in emscripten_runtime.wasmInstance.exports)) { + throw new TypeError('`emnapi_async_worker_create` is not exported, please try to add `--export=emnapi_async_worker_create` to linker flags'); + } + const emnapi_async_worker_create = emscripten_runtime.wasmInstance.exports.emnapi_async_worker_create; + const args = []; + emnapiAWMT.initGlobal(); + for (let i = 0; i < n; ++i) { + args.push(emnapi_async_worker_create(1, emnapiAWMT.globalAddress)); + } + const promises = args.map(index => { + if (index === 0) { + return Promise.reject(new Error('Failed to create async worker')); + } + let worker; + if (index < 0) { + worker = emnapiAWMT.pool[-index - 1]; + if (worker) + return worker.whenLoaded; + } + index >>>= 0; + const tidOffset = 20; + const view = new DataView(emnapiAWMT.ensureBufferFor(index + tidOffset + 4)); + const tid = view.getInt32(index + tidOffset, true); + worker = emscripten_runtime.PThread.pthreads[tid]; + return worker.whenLoaded; + }); + emnapiAWMT.workerReady = Promise.all(promises); + return emnapiAWMT.workerReady; + }, + getResource(work) { + emnapiAWMT.ensureBufferFor(work + emnapiAWMT.offset.resource + 4); + var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer)); + return GET_HEAP_DATA_VIEW().getUint32(work + emnapiAWMT.offset.resource, true); + }, + getExecute(work) { + emnapiAWMT.ensureBufferFor(work + emnapiAWMT.offset.execute + 4); + var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer)); + return GET_HEAP_DATA_VIEW().getUint32(work + emnapiAWMT.offset.execute, true); + }, + getComplete(work) { + emnapiAWMT.ensureBufferFor(work + emnapiAWMT.offset.complete + 4); + var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer)); + return GET_HEAP_DATA_VIEW().getUint32(work + emnapiAWMT.offset.complete, true); + }, + getEnv(work) { + emnapiAWMT.ensureBufferFor(work + emnapiAWMT.offset.env + 4); + var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer)); + return GET_HEAP_DATA_VIEW().getUint32(work + emnapiAWMT.offset.env, true); + }, + getData(work) { + emnapiAWMT.ensureBufferFor(work + emnapiAWMT.offset.data + 4); + var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer)); + return GET_HEAP_DATA_VIEW().getUint32(work + emnapiAWMT.offset.data, true); + }, + getMutex() { + const index = emnapiAWMT.globalAddress + emnapiAWMT.globalOffset.mutex; + const mutex = { + lock() { + const isBrowserMain = typeof window !== 'undefined' && typeof document !== 'undefined' && !emscripten_runtime.ENVIRONMENT_IS_NODE; + const i32a = new Int32Array(emnapiAWMT.ensureBufferFor(index + 4), index, 1); + if (isBrowserMain) { + while (true) { + const oldValue = Atomics.compareExchange(i32a, 0, 0, 10); + if (oldValue === 0) { + return; + } + } + } + else { + while (true) { + const oldValue = Atomics.compareExchange(i32a, 0, 0, 10); + if (oldValue === 0) { + return; + } + Atomics.wait(i32a, 0, 10); + } + } + }, + unlock() { + const i32a = new Int32Array(emnapiAWMT.ensureBufferFor(index + 4), index, 1); + const oldValue = Atomics.compareExchange(i32a, 0, 10, 0); + if (oldValue !== 10) { + throw new Error('Tried to unlock while not holding the mutex'); + } + Atomics.notify(i32a, 0, 1); + }, + execute(fn) { + mutex.lock(); + try { + return fn(); + } + finally { + mutex.unlock(); + } + } + }; + return mutex; + }, + getCond() { + const index = emnapiAWMT.globalAddress + emnapiAWMT.globalOffset.cond; + const mutex = emnapiAWMT.getMutex(); + const cond = { + wait() { + const i32a = new Int32Array(emnapiAWMT.ensureBufferFor(index + 4), index, 1); + const value = Atomics.load(i32a, 0); + mutex.unlock(); + Atomics.wait(i32a, 0, value); + mutex.lock(); + }, + signal() { + const i32a = new Int32Array(emnapiAWMT.ensureBufferFor(index + 4), index, 1); + Atomics.add(i32a, 0, 1); + Atomics.notify(i32a, 0, 1); + } + }; + return cond; + }, + queueInit(q) { + emnapiAWMT.ensureBufferFor(q + 4 + 4); + var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(q, q, true); + GET_HEAP_DATA_VIEW().setUint32(q + 4, q, true); + }, + queueInsertTail(h, q) { + emnapiAWMT.ensureBufferFor(h + 4 + 4); + emnapiAWMT.ensureBufferFor(q + 4 + 4); + var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(q, h, true); + const tempValue = GET_HEAP_DATA_VIEW().getUint32(h + 4, true); + GET_HEAP_DATA_VIEW().setUint32(q + 4, tempValue, true); + const qprev = GET_HEAP_DATA_VIEW().getUint32(q + 4, true); + GET_HEAP_DATA_VIEW().setUint32(qprev, q, true); + GET_HEAP_DATA_VIEW().setUint32(h + 4, q, true); + }, + queueRemove(q) { + emnapiAWMT.ensureBufferFor(q + 4 + 4); + var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer)); + const qprev = GET_HEAP_DATA_VIEW().getUint32(q + 4, true); + const qnext = GET_HEAP_DATA_VIEW().getUint32(q, true); + GET_HEAP_DATA_VIEW().setUint32(qprev, qnext, true); + GET_HEAP_DATA_VIEW().setUint32(qnext + 4, qprev, true); + }, + queueEmpty(q) { + emnapiAWMT.ensureBufferFor(q + 4); + var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer)); + // eslint-disable-next-line eqeqeq + return q == GET_HEAP_DATA_VIEW().getUint32(q, true); + }, + scheduleWork: function (work) { + if (!emnapiAWMT.workerReady?.ready) { + emnapiAWMT.initWorkers(emnapi_shared._emnapi_async_work_pool_size()).then(() => { + emnapiAWMT.workerReady.ready = true; + }).catch((err) => { + emnapiAWMT.workerReady = null; + throw err; + }); + } + _emnapi_runtime_keepalive_push(); + emnapiCtx.increaseWaitingRequestCounter(); + const statusBuffer = new Int32Array(emnapiAWMT.ensureBufferFor(work + emnapiAWMT.offset.status + 4), work + emnapiAWMT.offset.status, 1); + Atomics.store(statusBuffer, 0, 0 /* AsyncWorkStatus.Pending */); + const mutex = emnapiAWMT.getMutex(); + const cond = emnapiAWMT.getCond(); + mutex.lock(); + try { + emnapiAWMT.queueInsertTail(emnapiAWMT.globalAddress + emnapiAWMT.globalOffset.q, work + emnapiAWMT.offset.queue); + } + catch (err) { + _emnapi_runtime_keepalive_pop(); + emnapiCtx.decreaseWaitingRequestCounter(); + mutex.unlock(); + throw err; + } + emnapiAWMT.ensureBufferFor(emnapiAWMT.globalAddress + emnapiAWMT.globalOffset.idle_threads + 4); + var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer)); + if (GET_HEAP_DATA_VIEW().getUint32(emnapiAWMT.globalAddress + emnapiAWMT.globalOffset.idle_threads, true) > 0) { + cond.signal(); + } + mutex.unlock(); + }, + cancelWork(work) { + let cancelled = false; + emnapiAWMT.getMutex().execute(() => { + emnapiAWMT.ensureBufferFor(work + emnapiAWMT.offset.status + 4); + var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer)); + cancelled = !emnapiAWMT.queueEmpty(work + emnapiAWMT.offset.queue) && GET_HEAP_DATA_VIEW().getInt32(work + emnapiAWMT.offset.status, true) !== 2 /* AsyncWorkStatus.Completed */; + if (cancelled) { + emnapiAWMT.queueRemove(work + emnapiAWMT.offset.queue); + } + }); + if (!cancelled) { + return 9 /* napi_status.napi_generic_failure */; + } + if (Atomics.compareExchange(new Int32Array(emnapiAWMT.ensureBufferFor(work + emnapiAWMT.offset.status + 4), work + emnapiAWMT.offset.status, 1), 0, 0 /* AsyncWorkStatus.Pending */, 1 /* AsyncWorkStatus.Cancelled */) !== 0 /* AsyncWorkStatus.Pending */) { + return 9 /* napi_status.napi_generic_failure */; + } + emnapiCtx.features.setImmediate(() => { + emnapiAWMT.callComplete(work, 11 /* napi_status.napi_cancelled */); + }); + return 0 /* napi_status.napi_ok */; + }, + callComplete: function (work, status) { + _emnapi_runtime_keepalive_pop(); + emnapiCtx.decreaseWaitingRequestCounter(); + const complete = emnapiAWMT.getComplete(work); + const env = emnapiAWMT.getEnv(work); + const data = emnapiAWMT.getData(work); + const envObject = emnapi_shared.emnapiEnv; + const scope = emnapiCtx.openScope(envObject); + const callback = () => { + if (!complete) + return; + envObject.callbackIntoModule(true, () => { + (emnapiPluginCtx.wasmTable.get(complete))(env, status, data); + }); + }; + try { + if (emnapiNodeBinding) { + const resource = emnapiAWMT.getResource(work); + const resource_value = emnapiCtx.getRef(resource).get(); + const resourceObject = emnapiCtx.jsValueFromNapiValue(resource_value); + const view = new DataView(emnapiAWMT.ensureBufferFor(work + emnapiAWMT.offset.trigger_async_id + 8)); + const asyncId = view.getFloat64(work + emnapiAWMT.offset.async_id, true); + const triggerAsyncId = view.getFloat64(work + emnapiAWMT.offset.trigger_async_id, true); + emnapiNodeBinding.node.makeCallback(resourceObject, callback, [], { + asyncId, + triggerAsyncId + }); + } + else { + callback(); + } + } + finally { + emnapiCtx.closeScope(envObject, scope); + } + } + }; + emnapiAWST.init(); + emnapiAWMT.init(); + /** @__sig ippppppp */ + var napi_create_async_work = emnapi_shared.singleThreadAsyncWork + ? function (env, resource, resource_name, execute, complete, data, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapi_shared.emnapiEnv; + envObject.checkGCAccess(); + if (!execute) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + let resourceObject; + if (resource) { + resourceObject = Object(emnapiCtx.jsValueFromNapiValue(resource)); + } + else { + resourceObject = {}; + } + if (!resource_name) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const resourceName = String(emnapiCtx.jsValueFromNapiValue(resource_name)); + const id = emnapiAWST.create(env, resourceObject, resourceName, execute, complete, data); + result >>>= 0; + var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, id, true); + return envObject.clearLastError(); + } + : function (env, resource, resource_name, execute, complete, data, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapi_shared.emnapiEnv; + envObject.checkGCAccess(); + if (!execute) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + let resourceObject; + if (resource) { + resourceObject = Object(emnapiCtx.jsValueFromNapiValue(resource)); + } + else { + resourceObject = {}; + } + if (!resource_name) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + const sizeofAW = emnapiAWMT.offset.end; + let aw = emscripten_runtime._malloc(sizeofAW); + if (!aw) + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + aw >>>= 0; + new Uint8Array(emnapiAWMT.ensureBufferFor(aw + sizeofAW)).subarray(aw, aw + sizeofAW).fill(0); + const s = emnapiCtx.napiValueFromJsValue(resourceObject); + const resourceRef = emnapiCtx.createReference(envObject, s, 1, 1 /* ReferenceOwnership.kUserland */); + const resource_ = resourceRef.id; + var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(aw, resource_, true); + _emnapi_node_emit_async_init(s, resource_name, -1, aw + emnapiAWMT.offset.async_id); + GET_HEAP_DATA_VIEW().setUint32(aw + emnapiAWMT.offset.env, env, true); + GET_HEAP_DATA_VIEW().setUint32(aw + emnapiAWMT.offset.execute, execute, true); + GET_HEAP_DATA_VIEW().setUint32(aw + emnapiAWMT.offset.complete, complete, true); + GET_HEAP_DATA_VIEW().setUint32(aw + emnapiAWMT.offset.data, data, true); + emnapiAWMT.queueInit(aw + emnapiAWMT.offset.queue); + result >>>= 0; + GET_HEAP_DATA_VIEW().setUint32(result, aw, true); + return envObject.clearLastError(); + }; + /** @__sig ipp */ + var napi_delete_async_work = emnapi_shared.singleThreadAsyncWork + ? function (env, work) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapi_shared.emnapiEnv; + envObject.checkGCAccess(); + if (!work) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + work >>>= 0; + emnapiAWST.remove(work); + return envObject.clearLastError(); + } + : function (env, work) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapi_shared.emnapiEnv; + envObject.checkGCAccess(); + if (!work) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + work >>>= 0; + const resource = emnapiAWMT.getResource(work); + emnapiCtx.getRef(resource).dispose(); + if (emnapiNodeBinding) { + const view = new DataView(emnapiAWMT.ensureBufferFor(work + emnapiAWMT.offset.trigger_async_id + 8)); + const asyncId = view.getFloat64(work + emnapiAWMT.offset.async_id, true); + const triggerAsyncId = view.getFloat64(work + emnapiAWMT.offset.trigger_async_id, true); + _emnapi_node_emit_async_destroy(asyncId, triggerAsyncId); + } + emscripten_runtime._free(work); + return envObject.clearLastError(); + }; + /** @__sig ipp */ + var napi_queue_async_work = emnapi_shared.singleThreadAsyncWork + ? function (env, work) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + const envObject = emnapi_shared.emnapiEnv; + if (!work) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + work >>>= 0; + emnapiAWST.queue(work); + return envObject.clearLastError(); + } + : function (env, work) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + const envObject = emnapi_shared.emnapiEnv; + if (!work) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + work >>>= 0; + emnapiAWMT.scheduleWork(work); + return envObject.clearLastError(); + }; + /** @__sig ipp */ + var napi_cancel_async_work = emnapi_shared.singleThreadAsyncWork + ? function (env, work) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + const envObject = emnapi_shared.emnapiEnv; + if (!work) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + work >>>= 0; + const status = emnapiAWST.cancel(work); + if (status === 0 /* napi_status.napi_ok */) + return envObject.clearLastError(); + return envObject.setLastError(status); + } + : function (env, work) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + const envObject = emnapi_shared.emnapiEnv; + if (!work) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + work >>>= 0; + const status = emnapiAWMT.cancelWork(work); + if (status === 0 /* napi_status.napi_ok */) + return envObject.clearLastError(); + return envObject.setLastError(status); + }; + /** @__sig pp */ + function _emnapi_async_worker(globalAddress) { + globalAddress >>>= 0; + emnapiAWMT.globalAddress = globalAddress; + const mutex = emnapiAWMT.getMutex(); + const cond = emnapiAWMT.getCond(); + mutex.lock(); + const exitMessageAddr = globalAddress + emnapiAWMT.globalOffset.exit_message; + const idleThreadsAddr = globalAddress + emnapiAWMT.globalOffset.idle_threads; + const workerQueueAddr = globalAddress + emnapiAWMT.globalOffset.q; + var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer)); + for (;;) { + emnapiAWMT.ensureBufferFor(workerQueueAddr + 4); + while (emnapiAWMT.queueEmpty(workerQueueAddr)) { + Atomics.add(new Int32Array(emnapiAWMT.ensureBufferFor(idleThreadsAddr + 4), idleThreadsAddr, 1), 0, 1); + cond.wait(); + Atomics.sub(new Int32Array(emnapiAWMT.ensureBufferFor(idleThreadsAddr + 4), idleThreadsAddr, 1), 0, 1); + } + const q = GET_HEAP_DATA_VIEW().getUint32(workerQueueAddr, true); + if (q === exitMessageAddr) { + cond.signal(); + mutex.unlock(); + break; + } + const work = q - emnapiAWMT.offset.queue; + emnapiAWMT.queueRemove(q); + emnapiAWMT.queueInit(q); + mutex.unlock(); + const statusBuffer = new Int32Array(emnapiAWMT.ensureBufferFor(work + emnapiAWMT.offset.status + 4), work + emnapiAWMT.offset.status, 1); + if (Atomics.load(statusBuffer, 0) === 1 /* AsyncWorkStatus.Cancelled */) { + emscripten_runtime.abort('unreachable'); + } + const execute = emnapiAWMT.getExecute(work); + const env = emnapiAWMT.getEnv(work); + const data = emnapiAWMT.getData(work); + (emnapiPluginCtx.wasmTable.get(execute))(env, data); + Atomics.store(statusBuffer, 0, 2 /* AsyncWorkStatus.Completed */); + const postMessage = emnapi_shared.napiModule.postMessage; + postMessage({ + __emnapi__: { + type: 'async-work-complete', + payload: { work } + } + }); + mutex.lock(); + } + return 0; + } + /** @__sig ipp */ + function _emnapi_spawn_worker(f, globalAddress) { + if (typeof emnapi_shared.onCreateWorker !== 'function') { + throw new TypeError('`options.onCreateWorker` is not a function'); + } + const promises = []; + const args = []; + if (!('emnapi_async_worker_create' in emscripten_runtime.wasmInstance.exports)) { + throw new TypeError('`emnapi_async_worker_create` is not exported, please try to add `--export=emnapi_async_worker_create` to linker flags'); + } + args.push(emscripten_runtime.wasmInstance.exports.emnapi_async_worker_create(0, 0)); + const handleError = (e) => { + if ('message' in e && (e.message.indexOf('RuntimeError') !== -1 || e.message.indexOf('unreachable') !== -1)) { + emnapiAWMT.terminateWorkers(); + } + }; + let ret; + try { + const worker = emnapi_shared.onCreateWorker({ type: 'async-work', name: 'emnapi-async-worker' }); + const p = emscripten_runtime.PThread.loadWasmModuleToWorker(worker); + if (emscripten_runtime.ENVIRONMENT_IS_NODE) { + worker.on('error', handleError); + } + else { + worker.addEventListener('error', handleError, false); + } + emnapiAWMT.addListener(worker); + if (typeof emnapiPluginCtx.emnapiTSFN !== 'undefined') { + emnapiPluginCtx.emnapiTSFN.addListener(worker); + } + promises.push(p.then(() => { + if (typeof worker.unref === 'function') { + worker.unref(); + } + })); + ret = emnapiAWMT.pool.push(worker) - 1; + const arg = args[0]; + worker.threadBlockBase = arg; + worker.postMessage({ + __emnapi__: { + type: 'async-worker-init', + payload: { arg, func: [f, globalAddress] } + } + }); + } + catch (err) { + const arg = args[0]; + emscripten_runtime._free(arg); + throw err; + } + return ret; + } + function initWorker(startArg, func) { + if (emnapi_shared.napiModule.childThread) { + if (typeof emscripten_runtime.wasmInstance.exports.emnapi_async_worker_init !== 'function') { + throw new TypeError('`emnapi_async_worker_init` is not exported, please try to add `--export=emnapi_async_worker_init` to linker flags'); + } + emscripten_runtime.wasmInstance.exports.emnapi_async_worker_init(startArg); + (emnapiPluginCtx.wasmTable.get(func[0]))(func[1]); + } + else { + throw new Error('startThread is only available in child threads'); + } + } + emnapi_shared.napiModule.initWorker = initWorker; + + //#endregion src/core/async-work.ts + + exports._emnapi_async_worker = _emnapi_async_worker; + exports._emnapi_spawn_worker = _emnapi_spawn_worker; + exports.napi_cancel_async_work = napi_cancel_async_work; + exports.napi_create_async_work = napi_create_async_work; + exports.napi_delete_async_work = napi_delete_async_work; + exports.napi_queue_async_work = napi_queue_async_work; + + return exports; + +})({}, emnapiPluginCtx, emnapiPluginCtx); + return { + importObject: (original) => { + + Object.keys(mod).forEach(key => { + if (key.startsWith('napi_') || key.startsWith('node_api_')) { + original.napi[key] = mod[key]; + } else { + original.env[key] = mod[key]; + } + }); + } + }; +} + +//#endregion src/emnapi/async-work.js + +export { asyncWork as default }; diff --git a/client/node_modules/@emnapi/core/dist/plugins/index.d.ts b/client/node_modules/@emnapi/core/dist/plugins/index.d.ts new file mode 100644 index 0000000..d73f829 --- /dev/null +++ b/client/node_modules/@emnapi/core/dist/plugins/index.d.ts @@ -0,0 +1,4 @@ +export { PluginFactory, PluginContext, EmnapiPlugin } from '../emnapi-core' +export { default as v8 } from './v8' +export { default as asyncWork } from './async-work' +export { default as tsfn } from './threadsafe-function' diff --git a/client/node_modules/@emnapi/core/dist/plugins/index.js b/client/node_modules/@emnapi/core/dist/plugins/index.js new file mode 100644 index 0000000..a6170c6 --- /dev/null +++ b/client/node_modules/@emnapi/core/dist/plugins/index.js @@ -0,0 +1,3 @@ +export { default as v8 } from './v8.js' +export { default as asyncWork } from './async-work.js' +export { default as tsfn } from './threadsafe-function.js' diff --git a/client/node_modules/@emnapi/core/dist/plugins/threadsafe-function.d.ts b/client/node_modules/@emnapi/core/dist/plugins/threadsafe-function.d.ts new file mode 100644 index 0000000..4c1c980 --- /dev/null +++ b/client/node_modules/@emnapi/core/dist/plugins/threadsafe-function.d.ts @@ -0,0 +1,5 @@ +import { PluginFactory } from '../emnapi-core' +export { PluginFactory, PluginContext, EmnapiPlugin } from '../emnapi-core' + +declare const _default: PluginFactory +export default _default diff --git a/client/node_modules/@emnapi/core/dist/plugins/threadsafe-function.js b/client/node_modules/@emnapi/core/dist/plugins/threadsafe-function.js new file mode 100644 index 0000000..7943462 --- /dev/null +++ b/client/node_modules/@emnapi/core/dist/plugins/threadsafe-function.js @@ -0,0 +1,1010 @@ +//#region src/emnapi/threadsafe-function.js +function threadsafeFunction (emnapiPluginCtx) { + const { emnapiCtx, emnapiNodeBinding, _emnapi_node_emit_async_destroy: __emnapi_node_emit_async_destroy, _emnapi_node_emit_async_init: __emnapi_node_emit_async_init, _emnapi_runtime_keepalive_pop: __emnapi_runtime_keepalive_pop, _emnapi_runtime_keepalive_push: __emnapi_runtime_keepalive_push } = emnapiPluginCtx; + var mod = (function (exports, emnapi_shared, emscripten_runtime) { + + //#region src/macro.ts + + //#endregion src/macro.ts + + //#region src/threadsafe-function.ts + /* eslint-disable @stylistic/indent */ + /** + * @__deps malloc + * @__deps free + * @__deps $emnapiCtx + * @__deps $emnapiEnv + * @__deps $emnapiNodeBinding + * @__deps _emnapi_node_emit_async_destroy + * @__deps _emnapi_runtime_keepalive_pop + * @__postset + * ``` + * emnapiTSFN.init(); + * ``` + */ + const emnapiTSFN = { + _liveSet: {}, + offset: { + __size__: 0, + /* napi_ref */ resource: 0, + /* double */ async_id: 0, + /* double */ trigger_async_id: 0, + /* size_t */ queue_size: 0, + /* bool */ is_some: 0, + /* void* */ queue: 0, + // Reuse uv_async_t storage as JS-side wakeup state: pending event + scheduled drain. + async_pending: 0, + async_u_fd: 0, + /* size_t */ thread_count: 0, + /* int32_t */ state: 0, + /* atomic_uchar */ dispatch_state: 0, + /* void* */ context: 0, + /* size_t */ max_queue_size: 0, + /* napi_ref */ ref: 0, + /* napi_env */ env: 0, + /* void* */ finalize_data: 0, + /* napi_finalize */ finalize_cb: 0, + /* napi_threadsafe_function_call_js */ call_js_cb: 0, + /* bool */ handles_closing: 0, + /* bool */ async_ref: 0, + /* int32_t */ mutex: 0, + /* int32_t */ cond: 0, + }, + init() { + emnapiTSFN._liveSet = new Set(); + emnapiTSFN.offset.__size__ = 184 /* NapiTSFNOffset32.__size__ */; + emnapiTSFN.offset.resource = 0 /* NapiTSFNOffset32.async_resource_resource */; + emnapiTSFN.offset.async_id = 8 /* NapiTSFNOffset32.async_resource_async_context_async_id */; + emnapiTSFN.offset.trigger_async_id = 16 /* NapiTSFNOffset32.async_resource_async_context_trigger_async_id */; + emnapiTSFN.offset.queue_size = 60 /* NapiTSFNOffset32.queue_size */; + emnapiTSFN.offset.is_some = 24 /* NapiTSFNOffset32.async_resource_is_some */; + emnapiTSFN.offset.queue = 64 /* NapiTSFNOffset32.queue */; + emnapiTSFN.offset.async_pending = 132 /* NapiTSFNOffset32.async_pending */; + emnapiTSFN.offset.async_u_fd = 96 /* NapiTSFNOffset32.async_u_fd */; + emnapiTSFN.offset.thread_count = 136 /* NapiTSFNOffset32.thread_count */; + emnapiTSFN.offset.state = 140 /* NapiTSFNOffset32.state */; + emnapiTSFN.offset.dispatch_state = 144 /* NapiTSFNOffset32.dispatch_state */; + emnapiTSFN.offset.context = 148 /* NapiTSFNOffset32.context */; + emnapiTSFN.offset.max_queue_size = 152 /* NapiTSFNOffset32.max_queue_size */; + emnapiTSFN.offset.ref = 156 /* NapiTSFNOffset32.ref */; + emnapiTSFN.offset.env = 160 /* NapiTSFNOffset32.env */; + emnapiTSFN.offset.finalize_data = 164 /* NapiTSFNOffset32.finalize_data */; + emnapiTSFN.offset.finalize_cb = 168 /* NapiTSFNOffset32.finalize_cb */; + emnapiTSFN.offset.call_js_cb = 172 /* NapiTSFNOffset32.call_js_cb */; + emnapiTSFN.offset.handles_closing = 176 /* NapiTSFNOffset32.handles_closing */; + emnapiTSFN.offset.async_ref = 180 /* NapiTSFNOffset32.async_ref */; + emnapiTSFN.offset.mutex = 32 /* NapiTSFNOffset32.mutex */; + emnapiTSFN.offset.cond = 56 /* NapiTSFNOffset32.cond */; + emnapiTSFN.offset.mutex = emnapiTSFN.offset.mutex + 4; + if (typeof emscripten_runtime.PThread !== 'undefined') { + emscripten_runtime.PThread.unusedWorkers.forEach(emnapiTSFN.addListener); + Object.values(emscripten_runtime.PThread.pthreads).forEach(emnapiTSFN.addListener); + const __original_getNewWorker = emscripten_runtime.PThread.getNewWorker; + emscripten_runtime.PThread.getNewWorker = function () { + const r = __original_getNewWorker.apply(this, arguments); + emnapiTSFN.addListener(r); + return r; + }; + } + }, + addListener(worker) { + if (!worker) + return false; + if (worker._emnapiTSFNListener) + return true; + const handler = function (e) { + const data = emscripten_runtime.ENVIRONMENT_IS_NODE ? e : e.data; + const __emnapi__ = data.__emnapi__; + if (__emnapi__) { + const type = __emnapi__.type; + const payload = __emnapi__.payload; + if (type === 'tsfn-send') { + const pendng = payload.tsfn + emnapiTSFN.offset.async_pending; + if (Atomics.load(new Int32Array(emnapiTSFN.ensureBufferFor(pendng + 4)), pendng >>> 2) !== 0) { + emnapiTSFN.enqueue(payload.tsfn); + } + } + } + }; + const dispose = function () { + if (emscripten_runtime.ENVIRONMENT_IS_NODE) { + worker.off('message', handler); + } + else { + worker.removeEventListener('message', handler, false); + } + delete worker._emnapiTSFNListener; + }; + worker._emnapiTSFNListener = { handler, dispose }; + if (emscripten_runtime.ENVIRONMENT_IS_NODE) { + worker.on('message', handler); + } + else { + worker.addEventListener('message', handler, false); + } + return true; + }, + /** + * When another thread grows the shared WebAssembly.Memory, this agent's + * cached `wasmMemory.buffer` may still have the old shorter length + * (V8 refreshes it lazily). If a pointer derived from shared memory lies + * beyond the cached length, `wasmMemory.grow(0)` forces the agent to + * observe the current memory size and refreshes the buffer. + */ + ensureBufferFor(end) { + let buffer = emscripten_runtime.wasmMemory.buffer; + if (end > buffer.byteLength) { + emscripten_runtime.wasmMemory.grow(0); + buffer = emscripten_runtime.wasmMemory.buffer; + } + return buffer; + }, + initQueue(func) { + const size = 2 * 4; + let queue = emscripten_runtime._malloc(size); + if (!queue) + return false; + queue >>>= 0; + new Uint8Array(emnapiTSFN.ensureBufferFor(queue + size), queue, size).fill(0); + emnapiTSFN.storeSizeTypeValue(func + emnapiTSFN.offset.queue, queue, false); + return true; + }, + destroyQueue(func) { + const queue = emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.queue, false); + if (queue) { + let node = emnapiTSFN.loadSizeTypeValue(queue, false); + while (node !== 0) { + const next = emnapiTSFN.loadSizeTypeValue(node + 4, false); + emscripten_runtime._free(node); + node = next; + } + emscripten_runtime._free(queue); + } + }, + pushQueue(func, data) { + const queue = emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.queue, false); + const head = emnapiTSFN.loadSizeTypeValue(queue, false); + const tail = emnapiTSFN.loadSizeTypeValue(queue + 4, false); + const size = 2 * 4; + let node = emscripten_runtime._malloc(size); + if (!node) + throw new Error('OOM'); + node >>>= 0; + emnapiTSFN.storeSizeTypeValue(node, data, false); + emnapiTSFN.storeSizeTypeValue(node + 4, 0, false); + if (head === 0 && tail === 0) { + emnapiTSFN.storeSizeTypeValue(queue, node, false); + emnapiTSFN.storeSizeTypeValue(queue + 4, node, false); + } + else { + emnapiTSFN.storeSizeTypeValue(tail + 4, node, false); + emnapiTSFN.storeSizeTypeValue(queue + 4, node, false); + } + emnapiTSFN.addQueueSize(func); + }, + shiftQueue(func) { + const queue = emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.queue, false); + const head = emnapiTSFN.loadSizeTypeValue(queue, false); + if (head === 0) + return 0; + const node = head; + const next = emnapiTSFN.loadSizeTypeValue(head + 4, false); + emnapiTSFN.storeSizeTypeValue(queue, next, false); + if (next === 0) { + emnapiTSFN.storeSizeTypeValue(queue + 4, 0, false); + } + emnapiTSFN.storeSizeTypeValue(node + 4, 0, false); + const value = emnapiTSFN.loadSizeTypeValue(node, false); + emscripten_runtime._free(node); + emnapiTSFN.subQueueSize(func); + return value; + }, + push(func, data, mode) { + const mutex = emnapiTSFN.getMutex(func); + const cond = emnapiTSFN.getCond(func); + const waitCondition = () => { + const queueSize = emnapiTSFN.getQueueSize(func); + const maxSize = emnapiTSFN.getMaxQueueSize(func); + return queueSize >= maxSize && maxSize > 0 && emnapiTSFN.getState(func) === 0 /* State.kOpen */; + }; + const isBrowserMain = typeof window !== 'undefined' && typeof document !== 'undefined' && !emscripten_runtime.ENVIRONMENT_IS_NODE; + let shouldDelete = false; + const ret = mutex.execute(() => { + while (waitCondition()) { + if (mode === 0 /* napi_threadsafe_function_call_mode.napi_tsfn_nonblocking */) { + return 15 /* napi_status.napi_queue_full */; + } + /** + * Browser JS main thread can not use `Atomics.wait` + * + * Related: + * https://github.com/nodejs/node/pull/32689 + * https://github.com/nodejs/node/pull/33453 + */ + if (isBrowserMain) { + return 21 /* napi_status.napi_would_deadlock */; + } + cond.wait(); + } + if (emnapiTSFN.getState(func) === 0 /* State.kOpen */) { + emnapiTSFN.pushQueue(func, data); + emnapiTSFN.send(func); + return 0 /* napi_status.napi_ok */; + } + if (emnapiTSFN.getThreadCount(func) === 0) { + return 1 /* napi_status.napi_invalid_arg */; + } + emnapiTSFN.subThreadCount(func); + if (!(emnapiTSFN.getState(func) === 2 /* State.kClosed */ && emnapiTSFN.getThreadCount(func) === 0)) { + return 16 /* napi_status.napi_closing */; + } + shouldDelete = true; + return 16 /* napi_status.napi_closing */; + }); + if (shouldDelete) { + emnapiTSFN.destroy(func); + } + return ret; + }, + getMutex(func) { + const index = func + emnapiTSFN.offset.mutex; + const mutex = { + lock() { + const isBrowserMain = typeof window !== 'undefined' && typeof document !== 'undefined' && !emscripten_runtime.ENVIRONMENT_IS_NODE; + const i32a = new Int32Array(emnapiTSFN.ensureBufferFor(index + 4), index, 1); + if (isBrowserMain) { + while (true) { + const oldValue = Atomics.compareExchange(i32a, 0, 0, 10); + if (oldValue === 0) { + return; + } + } + } + else { + while (true) { + const oldValue = Atomics.compareExchange(i32a, 0, 0, 10); + if (oldValue === 0) { + return; + } + Atomics.wait(i32a, 0, 10); + } + } + }, + /* lockAsync () { + return new Promise(resolve => { + const again = (): void => { fn() } + const fn = (): void => { + const i32a = new Int32Array(emnapiTSFN.ensureBufferFor(index + 4), index, 1) + const oldValue = Atomics.compareExchange(i32a, 0, 0, 10) + if (oldValue === 0) { + resolve() + return + } + (Atomics as any).waitAsync(i32a, 0, 10).value.then(again) + } + fn() + }) + }, */ + unlock() { + const i32a = new Int32Array(emnapiTSFN.ensureBufferFor(index + 4), index, 1); + const oldValue = Atomics.compareExchange(i32a, 0, 10, 0); + if (oldValue !== 10) { + throw new Error('Tried to unlock while not holding the mutex'); + } + Atomics.notify(i32a, 0, 1); + }, + execute(fn) { + mutex.lock(); + try { + return fn(); + } + finally { + mutex.unlock(); + } + } /* , + executeAsync (fn: () => Promise): Promise { + return mutex.lockAsync().then(() => { + const r = fn() + mutex.unlock() + return r + }, (err) => { + mutex.unlock() + throw err + }) + } */ + }; + return mutex; + }, + getCond(func) { + const index = func + emnapiTSFN.offset.cond; + const mutex = emnapiTSFN.getMutex(func); + const cond = { + wait() { + const i32a = new Int32Array(emnapiTSFN.ensureBufferFor(index + 4), index, 1); + const value = Atomics.load(i32a, 0); + mutex.unlock(); + Atomics.wait(i32a, 0, value); + mutex.lock(); + }, + /* waitAsync () { + const i32a = new Int32Array(emnapiTSFN.ensureBufferFor(index + 4), index, 1) + const value = Atomics.load(i32a, 0) + mutex.unlock() + const lock = (): Promise => mutex.lockAsync() + try { + return (Atomics as any).waitAsync(i32a, 0, value).value.then(lock, lock) + } catch (err) { + return lock() + } + }, */ + signal() { + const i32a = new Int32Array(emnapiTSFN.ensureBufferFor(index + 4), index, 1); + Atomics.add(i32a, 0, 1); + Atomics.notify(i32a, 0, 1); + } + }; + return cond; + }, + getQueueSize(func) { + return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.queue_size, true); + }, + addQueueSize(func) { + const offset = emnapiTSFN.offset.queue_size; + let arr, index; + arr = new Uint32Array(emnapiTSFN.ensureBufferFor(func + offset + 4)); + index = (func + offset) >>> 2; + Atomics.add(arr, index, 1); + }, + subQueueSize(func) { + const offset = emnapiTSFN.offset.queue_size; + let arr, index; + arr = new Uint32Array(emnapiTSFN.ensureBufferFor(func + offset + 4)); + index = (func + offset) >>> 2; + Atomics.sub(arr, index, 1); + }, + getThreadCount(func) { + return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.thread_count, true); + }, + addThreadCount(func) { + const offset = emnapiTSFN.offset.thread_count; + let arr, index; + arr = new Uint32Array(emnapiTSFN.ensureBufferFor(func + offset + 4)); + index = (func + offset) >>> 2; + Atomics.add(arr, index, 1); + }, + subThreadCount(func) { + const offset = emnapiTSFN.offset.thread_count; + let arr, index; + arr = new Uint32Array(emnapiTSFN.ensureBufferFor(func + offset + 4)); + index = (func + offset) >>> 2; + Atomics.sub(arr, index, 1); + }, + getState(func) { + return Atomics.load(new Int32Array(emnapiTSFN.ensureBufferFor(func + emnapiTSFN.offset.state + 4)), (func + emnapiTSFN.offset.state) >>> 2); + }, + setState(func, value) { + Atomics.store(new Int32Array(emnapiTSFN.ensureBufferFor(func + emnapiTSFN.offset.state + 4)), (func + emnapiTSFN.offset.state) >>> 2, value); + }, + getHandlesClosing(func) { + return Atomics.load(new Int8Array(emnapiTSFN.ensureBufferFor(func + emnapiTSFN.offset.handles_closing + 1)), (func + emnapiTSFN.offset.handles_closing)); + }, + setHandlesClosing(func, value) { + Atomics.store(new Int8Array(emnapiTSFN.ensureBufferFor(func + emnapiTSFN.offset.handles_closing + 1)), (func + emnapiTSFN.offset.handles_closing), value); + }, + getDispatchState(func) { + return Atomics.load(new Uint32Array(emnapiTSFN.ensureBufferFor(func + emnapiTSFN.offset.dispatch_state + 4)), (func + emnapiTSFN.offset.dispatch_state) >>> 2); + }, + getContext(func) { + return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.context, false); + }, + getMaxQueueSize(func) { + return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.max_queue_size, true); + }, + getEnv(func) { + return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.env, false); + }, + getCallJSCb(func) { + return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.call_js_cb, false); + }, + getRef(func) { + return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.ref, false); + }, + getResource(func) { + return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.resource, false); + }, + getFinalizeCb(func) { + return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.finalize_cb, false); + }, + getFinalizeData(func) { + return emnapiTSFN.loadSizeTypeValue(func + emnapiTSFN.offset.finalize_data, false); + }, + loadSizeTypeValue(offset, unsigned) { + let ret; + let arr; + if (unsigned) { + arr = new Uint32Array(emnapiTSFN.ensureBufferFor(offset + 4)); + ret = Atomics.load(arr, offset >>> 2); + return ret; + } + else { + arr = new Int32Array(emnapiTSFN.ensureBufferFor(offset + 4)); + ret = Atomics.load(arr, offset >>> 2); + return ret; + } + }, + storeSizeTypeValue(offset, value, unsigned) { + let arr; + if (unsigned) { + arr = new Uint32Array(emnapiTSFN.ensureBufferFor(offset + 4)); + Atomics.store(arr, offset >>> 2, value); + return undefined; + } + else { + arr = new Int32Array(emnapiTSFN.ensureBufferFor(offset + 4)); + Atomics.store(arr, offset >>> 2, value >>> 0); + return undefined; + } + }, + releaseResources(func) { + if (emnapiTSFN.getState(func) !== 2 /* State.kClosed */) { + emnapiTSFN.setState(func, 2 /* State.kClosed */); + emnapiTSFN.getEnv(func); + const envObject = emnapi_shared.emnapiEnv; + const ref = emnapiTSFN.getRef(func); + if (ref) { + emnapiCtx.getRef(ref).dispose(); + } + const resource = emnapiTSFN.getResource(func); + emnapiCtx.getRef(resource).dispose(); + emnapiTSFN.ensureBufferFor(func + emnapiTSFN.offset.is_some + 1); + var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt8(func + emnapiTSFN.offset.is_some, 0, true); + emnapiCtx.removeCleanupHook(envObject, emnapiTSFN.cleanup, func); + envObject.unref(); + const asyncRefAddress = func + emnapiTSFN.offset.async_ref; + const asyncRefOffset = asyncRefAddress >>> 2; + const arr = new Uint32Array(emnapiTSFN.ensureBufferFor(asyncRefAddress + 4)); + if (Atomics.load(arr, asyncRefOffset) > 0) { + Atomics.store(arr, asyncRefOffset, 0); + __emnapi_runtime_keepalive_pop(); + emnapiCtx.decreaseWaitingRequestCounter(); + } + if (emnapiNodeBinding) { + const view = new DataView(emnapiTSFN.ensureBufferFor(func + emnapiTSFN.offset.trigger_async_id + 8)); + const asyncId = view.getFloat64(func + emnapiTSFN.offset.async_id, true); + const triggerAsyncId = view.getFloat64(func + emnapiTSFN.offset.trigger_async_id, true); + __emnapi_node_emit_async_destroy(asyncId, triggerAsyncId); + } + } + }, + destroy(func) { + emnapiTSFN._liveSet.delete(func); + emnapiTSFN.destroyQueue(func); + emnapiTSFN.releaseResources(func); + emscripten_runtime._free(func); + }, + emptyQueue(func) { + const drainQueue = []; + emnapiTSFN.getMutex(func).execute(() => { + while (emnapiTSFN.getQueueSize(func) > 0) { + drainQueue.push(emnapiTSFN.shiftQueue(func)); + } + }); + const callJsCb = emnapiTSFN.getCallJSCb(func); + const context = emnapiTSFN.getContext(func); + let data; + for (let i = 0; i < drainQueue.length; i++) { + data = drainQueue[i]; + if (callJsCb) { + (emnapiPluginCtx.wasmTable.get(callJsCb))(0, 0, context, data); + } + } + }, + maybeDelete(func) { + let shouldDelete = false; + emnapiTSFN.getMutex(func).execute(() => { + if (emnapiTSFN.getThreadCount(func) > 0) { + emnapiTSFN.releaseResources(func); + } + else { + shouldDelete = true; + } + }); + if (shouldDelete) { + emnapiTSFN.destroy(func); + } + }, + finalize(func) { + emnapiTSFN.getEnv(func); + const envObject = emnapi_shared.emnapiEnv; + emnapiCtx.openScope(envObject); + const finalize = emnapiTSFN.getFinalizeCb(func); + const data = emnapiTSFN.getFinalizeData(func); + const context = emnapiTSFN.getContext(func); + const f = () => { + envObject.callFinalizerInternal(0, finalize, data, context); + }; + try { + emnapiTSFN.emptyQueue(func); + if (finalize) { + if (emnapiNodeBinding) { + const resource = emnapiTSFN.getResource(func); + const resource_value = emnapiCtx.getRef(resource).get(); + const resourceObject = emnapiCtx.jsValueFromNapiValue(resource_value); + const view = new DataView(emnapiTSFN.ensureBufferFor(func + emnapiTSFN.offset.trigger_async_id + 8)); + const asyncId = view.getFloat64(func + emnapiTSFN.offset.async_id, true); + const triggerAsyncId = view.getFloat64(func + emnapiTSFN.offset.trigger_async_id, true); + emnapiNodeBinding.node.makeCallback(resourceObject, f, [], { + asyncId, + triggerAsyncId + }); + } + else { + f(); + } + } + emnapiTSFN.maybeDelete(func); + } + finally { + emnapiCtx.closeScope(envObject); + } + }, + cleanup(func) { + emnapiTSFN.closeHandlesAndMaybeDelete(func, 1); + }, + closeHandlesAndMaybeDelete(func, set_closing) { + emnapiTSFN.getEnv(func); + const envObject = emnapi_shared.emnapiEnv; + emnapiCtx.openScope(envObject); + try { + if (set_closing) { + emnapiTSFN.getMutex(func).execute(() => { + emnapiTSFN.setState(func, 1 /* State.kClosing */); + if (emnapiTSFN.getMaxQueueSize(func) > 0) { + emnapiTSFN.getCond(func).signal(); + } + }); + } + if (emnapiTSFN.getHandlesClosing(func)) { + return; + } + emnapiTSFN.setHandlesClosing(func, 1); + Atomics.store(new Int32Array(emnapiTSFN.ensureBufferFor(func + emnapiTSFN.offset.async_pending + 4)), (func + emnapiTSFN.offset.async_pending) >>> 2, 1); + emnapiCtx.features.setImmediate(() => { + emnapiTSFN.finalize(func); + }); + } + finally { + emnapiCtx.closeScope(envObject); + } + }, + dispatchOne(func) { + let data = 0; + let popped_value = false; + let has_more = false; + const mutex = emnapiTSFN.getMutex(func); + const cond = emnapiTSFN.getCond(func); + mutex.execute(() => { + if (emnapiTSFN.getState(func) === 0 /* State.kOpen */) { + let size = emnapiTSFN.getQueueSize(func); + if (size > 0) { + data = emnapiTSFN.shiftQueue(func); + popped_value = true; + const maxQueueSize = emnapiTSFN.getMaxQueueSize(func); + if (size === maxQueueSize && maxQueueSize > 0) { + cond.signal(); + } + size--; + } + if (size === 0) { + if (emnapiTSFN.getThreadCount(func) === 0) { + emnapiTSFN.setState(func, 1 /* State.kClosing */); + if (emnapiTSFN.getMaxQueueSize(func) > 0) { + cond.signal(); + } + emnapiTSFN.closeHandlesAndMaybeDelete(func, 0); + } + } + else { + has_more = true; + } + } + else { + emnapiTSFN.closeHandlesAndMaybeDelete(func, 0); + } + }); + if (popped_value) { + const env = emnapiTSFN.getEnv(func); + const envObject = emnapi_shared.emnapiEnv; + emnapiCtx.openScope(envObject); + const f = () => { + envObject.callbackIntoModule(false, () => { + const callJsCb = emnapiTSFN.getCallJSCb(func); + const ref = emnapiTSFN.getRef(func); + const js_callback = ref ? emnapiCtx.getRef(ref).get() : 0; + if (callJsCb) { + const context = emnapiTSFN.getContext(func); + (emnapiPluginCtx.wasmTable.get(callJsCb))(env, js_callback, context, data); + } + else { + const jsCallback = js_callback ? emnapiCtx.jsValueFromNapiValue(js_callback) : null; + if (typeof jsCallback === 'function') { + jsCallback(); + } + } + }); + }; + try { + if (emnapiNodeBinding) { + const resource = emnapiTSFN.getResource(func); + const resource_value = emnapiCtx.getRef(resource).get(); + const resourceObject = emnapiCtx.jsValueFromNapiValue(resource_value); + const view = new DataView(emnapiTSFN.ensureBufferFor(func + emnapiTSFN.offset.trigger_async_id + 8)); + emnapiNodeBinding.node.makeCallback(resourceObject, f, [], { + asyncId: view.getFloat64(func + emnapiTSFN.offset.async_id, true), + triggerAsyncId: view.getFloat64(func + emnapiTSFN.offset.trigger_async_id, true) + }); + } + else { + f(); + } + } + finally { + emnapiCtx.closeScope(envObject); + } + } + return has_more; + }, + dispatch(func) { + let has_more = true; + let iterations_left = 1000; + const dispatchStateAddress = func + emnapiTSFN.offset.dispatch_state; + const index = dispatchStateAddress >>> 2; + while (has_more && --iterations_left !== 0) { + Atomics.store(new Uint32Array(emnapiTSFN.ensureBufferFor(dispatchStateAddress + 4)), index, 1); + try { + has_more = emnapiTSFN.dispatchOne(func); + } + catch (err) { + // A throwing callback must not leave dispatch_state marked as + // dispatching, or every later send() would be swallowed. Re-arm + // the state and schedule another drain before rethrowing. + if (emnapiTSFN._liveSet.has(func)) { + Atomics.exchange(new Uint32Array(emnapiTSFN.ensureBufferFor(dispatchStateAddress + 4)), index, 0); + emnapiTSFN.send(func); + } + throw err; + } + if (Atomics.exchange(new Uint32Array(emnapiTSFN.ensureBufferFor(dispatchStateAddress + 4)), index, 0) !== 1) { + has_more = true; + } + } + if (has_more) { + emnapiTSFN.send(func); + } + }, + enqueue(func) { + // `pending` means a worker thread has requested a wakeup that has not + // been drained on the main thread yet. + const pending = func + emnapiTSFN.offset.async_pending; + // `scheduled` prevents queueing the same main-thread drain chain more than + // once while a previous wakeup is still in flight. + const scheduled = func + emnapiTSFN.offset.async_u_fd; + const end = Math.max(pending, scheduled) + 4; + const state = () => new Int32Array(emnapiTSFN.ensureBufferFor(end)); + if (Atomics.exchange(state(), scheduled >>> 2, 1) !== 0) { + return; + } + // Match uv_async_send-style coalescing in JS: the first turn represents + // the wakeup reaching the main thread, and the second turn performs the + // actual TSFN drain after nearby Send/Signal calls have had a chance to + // collapse into the shared AsyncProgressWorker state. + emnapiCtx.features.setImmediate(() => { + if (!emnapiTSFN._liveSet.has(func)) { + return; + } + if (Atomics.load(state(), pending >>> 2) === 0) { + Atomics.store(state(), scheduled >>> 2, 0); + return; + } + emnapiCtx.features.setImmediate(() => { + // After destroy(), the func address is freed. Skip the atomics + // on that address entirely to avoid use-after-free (JS-side + // lifecycle check must run before touching the state words). + if (!emnapiTSFN._liveSet.has(func)) { + return; + } + try { + // Consume the coalesced wakeup once, then let dispatch() observe any + // queue mutations through dispatch_state like the C implementation. + if (Atomics.exchange(state(), pending >>> 2, 0) === 0) { + return; + } + emnapiTSFN.dispatch(func); + } + finally { + // Allow a later wakeup to schedule a new drain chain. If another + // worker-thread send raced with this drain, enqueue one more turn. + if (emnapiTSFN._liveSet.has(func)) { + Atomics.store(state(), scheduled >>> 2, 0); + if (Atomics.load(state(), pending >>> 2) !== 0) { + emnapiTSFN.enqueue(func); + } + } + } + }); + }); + }, + send(func) { + const dispatchStateAddress = func + emnapiTSFN.offset.dispatch_state; + const current_state = Atomics.or(new Uint32Array(emnapiTSFN.ensureBufferFor(dispatchStateAddress + 4)), dispatchStateAddress >>> 2, 1 << 1); + if ((current_state & 1) === 1) { + return; + } + const pendng = func + emnapiTSFN.offset.async_pending; + // A wakeup is already pending, so this send only needs to leave the queued + // work in the TSFN queue and let the existing drain pick it up. + if (Atomics.load(new Int32Array(emnapiTSFN.ensureBufferFor(pendng + 4)), pendng >>> 2) !== 0) { + return; + } + if (Atomics.exchange(new Int32Array(emnapiTSFN.ensureBufferFor(pendng + 4)), pendng >>> 2, 1) === 0) { + if ((typeof emscripten_runtime.ENVIRONMENT_IS_PTHREAD !== 'undefined') && emscripten_runtime.ENVIRONMENT_IS_PTHREAD) { + // Worker threads only post a wakeup token. Main-thread draining is + // serialized by enqueue() once the message is received. + postMessage({ + __emnapi__: { + type: 'tsfn-send', + payload: { + tsfn: func + } + } + }); + } + else { + // On the main thread we can skip the cross-thread hop and schedule the + // coalesced drain chain directly. + emnapiTSFN.enqueue(func); + } + } + } + }; + emnapiTSFN.init(); + emnapiPluginCtx.emnapiTSFN = emnapiTSFN; + /** + * @__deps _emnapi_node_emit_async_init + * @__deps _emnapi_runtime_keepalive_push + * @__sig ippppppppppp + */ + function napi_create_threadsafe_function(env, func, async_resource, async_resource_name, max_queue_size, initial_thread_count, thread_finalize_data, thread_finalize_cb, context, call_js_cb, result) { + if (!env) + return 1 /* napi_status.napi_invalid_arg */; + // @ts-expect-error + const envObject = emnapi_shared.emnapiEnv; + envObject.checkGCAccess(); + if (!async_resource_name) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + max_queue_size >>>= 0; + initial_thread_count >>>= 0; + env >>>= 0; + thread_finalize_data >>>= 0; + thread_finalize_cb >>>= 0; + context >>>= 0; + call_js_cb >>>= 0; + max_queue_size = max_queue_size >>> 0; + initial_thread_count = initial_thread_count >>> 0; + if (initial_thread_count === 0) { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + if (!result) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + let ref = 0; + func >>>= 0; + if (!func) { + if (!call_js_cb) + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + else { + const funcValue = emnapiCtx.jsValueFromNapiValue(func); + if (typeof funcValue !== 'function') { + return envObject.setLastError(1 /* napi_status.napi_invalid_arg */); + } + ref = emnapiCtx.createReference(envObject, func, 1, 1 /* ReferenceOwnership.kUserland */).id; + } + let asyncResourceObject; + if (async_resource) { + asyncResourceObject = emnapiCtx.jsValueFromNapiValue(async_resource); + if (asyncResourceObject == null) { + return envObject.setLastError(2 /* napi_status.napi_object_expected */); + } + asyncResourceObject = Object(asyncResourceObject); + } + else { + asyncResourceObject = {}; + } + const resource = emnapiCtx.napiValueFromJsValue(asyncResourceObject); + let asyncResourceName = emnapiCtx.jsValueFromNapiValue(async_resource_name); + if (typeof asyncResourceName === 'symbol') { + return envObject.setLastError(3 /* napi_status.napi_string_expected */); + } + asyncResourceName = String(asyncResourceName); + const resource_name = emnapiCtx.napiValueFromJsValue(asyncResourceName); + // tsfn create + const sizeofTSFN = emnapiTSFN.offset.__size__; + let tsfn = emscripten_runtime._malloc(sizeofTSFN); + if (!tsfn) + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + tsfn >>>= 0; + new Uint8Array(emnapiTSFN.ensureBufferFor(tsfn + sizeofTSFN)).subarray(tsfn, tsfn + sizeofTSFN).fill(0); + const resourceRef = emnapiCtx.createReference(envObject, resource, 1, 1 /* ReferenceOwnership.kUserland */); + const resource_ = resourceRef.id; + var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(tsfn + emnapiTSFN.offset.resource, resource_, true); + if (!emnapiTSFN.initQueue(tsfn)) { + emscripten_runtime._free(tsfn); + resourceRef.dispose(); + return envObject.setLastError(9 /* napi_status.napi_generic_failure */); + } + __emnapi_node_emit_async_init(resource, resource_name, -1, tsfn + emnapiTSFN.offset.async_id); + GET_HEAP_DATA_VIEW().setInt8(tsfn + emnapiTSFN.offset.is_some, 1, true); + GET_HEAP_DATA_VIEW().setUint32(tsfn + emnapiTSFN.offset.thread_count, initial_thread_count, true); + GET_HEAP_DATA_VIEW().setUint32(tsfn + emnapiTSFN.offset.context, context, true); + GET_HEAP_DATA_VIEW().setUint32(tsfn + emnapiTSFN.offset.max_queue_size, max_queue_size, true); + GET_HEAP_DATA_VIEW().setUint32(tsfn + emnapiTSFN.offset.ref, ref, true); + GET_HEAP_DATA_VIEW().setUint32(tsfn + emnapiTSFN.offset.env, env, true); + GET_HEAP_DATA_VIEW().setUint32(tsfn + emnapiTSFN.offset.finalize_data, thread_finalize_data, true); + GET_HEAP_DATA_VIEW().setUint32(tsfn + emnapiTSFN.offset.finalize_cb, thread_finalize_cb, true); + GET_HEAP_DATA_VIEW().setUint32(tsfn + emnapiTSFN.offset.call_js_cb, call_js_cb, true); + emnapiCtx.addCleanupHook(envObject, emnapiTSFN.cleanup, tsfn); + emnapiTSFN._liveSet.add(tsfn); + envObject.ref(); + __emnapi_runtime_keepalive_push(); + emnapiCtx.increaseWaitingRequestCounter(); + GET_HEAP_DATA_VIEW().setUint32(tsfn + emnapiTSFN.offset.async_ref, 1, true); + result >>>= 0; + GET_HEAP_DATA_VIEW().setUint32(result, tsfn, true); + return envObject.clearLastError(); + } + /** @__sig ipp */ + function napi_get_threadsafe_function_context(func, result) { + if (!func || !result) { + emscripten_runtime.abort(); + return 1 /* napi_status.napi_invalid_arg */; + } + func >>>= 0; + result >>>= 0; + const context = emnapiTSFN.getContext(func); + var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(result, context, true); + return 0 /* napi_status.napi_ok */; + } + /** @__sig ippi */ + function napi_call_threadsafe_function(func, data, mode) { + if (!func) { + emscripten_runtime.abort(); + return 1 /* napi_status.napi_invalid_arg */; + } + func >>>= 0; + data >>>= 0; + return emnapiTSFN.push(func, data, mode); + } + /** @__sig ip */ + function napi_acquire_threadsafe_function(func) { + if (!func) { + emscripten_runtime.abort(); + return 1 /* napi_status.napi_invalid_arg */; + } + func >>>= 0; + const mutex = emnapiTSFN.getMutex(func); + return mutex.execute(() => { + if (emnapiTSFN.getState(func) === 0 /* State.kOpen */) { + emnapiTSFN.addThreadCount(func); + return 0 /* napi_status.napi_ok */; + } + return 16 /* napi_status.napi_closing */; + }); + } + /** @__sig ipi */ + function napi_release_threadsafe_function(func, mode) { + if (!func) { + emscripten_runtime.abort(); + return 1 /* napi_status.napi_invalid_arg */; + } + func >>>= 0; + const mutex = emnapiTSFN.getMutex(func); + const cond = emnapiTSFN.getCond(func); + let shouldDelete = false; + const ret = mutex.execute(() => { + if (emnapiTSFN.getThreadCount(func) === 0) { + return 1 /* napi_status.napi_invalid_arg */; + } + emnapiTSFN.subThreadCount(func); + if (emnapiTSFN.getThreadCount(func) === 0 || mode === 1 /* napi_threadsafe_function_release_mode.napi_tsfn_abort */) { + if (emnapiTSFN.getState(func) === 0 /* State.kOpen */) { + if (mode === 1 /* napi_threadsafe_function_release_mode.napi_tsfn_abort */) { + emnapiTSFN.setState(func, 1 /* State.kClosing */); + } + if (emnapiTSFN.getState(func) === 1 /* State.kClosing */ && emnapiTSFN.getMaxQueueSize(func) > 0) { + cond.signal(); + } + emnapiTSFN.send(func); + } + } + if (!(emnapiTSFN.getState(func) === 2 /* State.kClosed */ && emnapiTSFN.getThreadCount(func) === 0)) { + return 0 /* napi_status.napi_ok */; + } + shouldDelete = true; + return 0 /* napi_status.napi_ok */; + }); + if (shouldDelete) { + emnapiTSFN.destroy(func); + } + return ret; + } + /** + * @__deps _emnapi_runtime_keepalive_pop + * @__sig ipp + */ + function napi_unref_threadsafe_function(env, func) { + if (!func) { + emscripten_runtime.abort(); + return 1 /* napi_status.napi_invalid_arg */; + } + func >>>= 0; + const asyncRefAddress = func + emnapiTSFN.offset.async_ref; + const asyncRefOffset = asyncRefAddress >>> 2; + const arr = new Uint32Array(emnapiTSFN.ensureBufferFor(asyncRefAddress + 4)); + const currentValue = Atomics.load(arr, asyncRefOffset); + if (currentValue > 0) { + Atomics.store(arr, asyncRefOffset, currentValue - 1); + if (currentValue === 1) { + __emnapi_runtime_keepalive_pop(); + emnapiCtx.decreaseWaitingRequestCounter(); + } + } + return 0 /* napi_status.napi_ok */; + } + /** + * @__deps _emnapi_runtime_keepalive_push + * @__sig ipp + */ + function napi_ref_threadsafe_function(env, func) { + if (!func) { + emscripten_runtime.abort(); + return 1 /* napi_status.napi_invalid_arg */; + } + func >>>= 0; + const asyncRefAddress = func + emnapiTSFN.offset.async_ref; + const asyncRefOffset = asyncRefAddress >>> 2; + const arr = new Uint32Array(emnapiTSFN.ensureBufferFor(asyncRefAddress + 4)); + const currentValue = Atomics.load(arr, asyncRefOffset); + if (!currentValue) { + __emnapi_runtime_keepalive_push(); + emnapiCtx.increaseWaitingRequestCounter(); + } + Atomics.store(arr, asyncRefOffset, currentValue + 1); + return 0 /* napi_status.napi_ok */; + } + + //#endregion src/threadsafe-function.ts + + exports.napi_acquire_threadsafe_function = napi_acquire_threadsafe_function; + exports.napi_call_threadsafe_function = napi_call_threadsafe_function; + exports.napi_create_threadsafe_function = napi_create_threadsafe_function; + exports.napi_get_threadsafe_function_context = napi_get_threadsafe_function_context; + exports.napi_ref_threadsafe_function = napi_ref_threadsafe_function; + exports.napi_release_threadsafe_function = napi_release_threadsafe_function; + exports.napi_unref_threadsafe_function = napi_unref_threadsafe_function; + + return exports; + +})({}, emnapiPluginCtx, emnapiPluginCtx); + return { + importObject: (original) => { + Object.assign(original.napi, mod); + } + }; +} + +//#endregion src/emnapi/threadsafe-function.js + +export { threadsafeFunction as default }; diff --git a/client/node_modules/@emnapi/core/dist/plugins/v8.d.ts b/client/node_modules/@emnapi/core/dist/plugins/v8.d.ts new file mode 100644 index 0000000..4c1c980 --- /dev/null +++ b/client/node_modules/@emnapi/core/dist/plugins/v8.d.ts @@ -0,0 +1,5 @@ +import { PluginFactory } from '../emnapi-core' +export { PluginFactory, PluginContext, EmnapiPlugin } from '../emnapi-core' + +declare const _default: PluginFactory +export default _default diff --git a/client/node_modules/@emnapi/core/dist/plugins/v8.js b/client/node_modules/@emnapi/core/dist/plugins/v8.js new file mode 100644 index 0000000..b1c84dd --- /dev/null +++ b/client/node_modules/@emnapi/core/dist/plugins/v8.js @@ -0,0 +1,1446 @@ +//#region src/emnapi/v8.js +function v8 (emnapiPluginCtx) { + const { emnapiCtx, emnapiString } = emnapiPluginCtx; + var mod = (function (exports, emscripten_runtime) { + + //#region src/v8/array.ts + /** + * @__deps $emnapiCtx + * @__sig ppi + */ + function _v8_array_new(context, value) { + return emnapiCtx.napiValueFromJsValue(Array(value)); + } + /** + * @__deps $emnapiCtx + * @__sig ip + */ + function _v8_array_length(array) { + const arr = emnapiCtx.jsValueFromNapiValue(array); + return arr.length; + } + + //#endregion src/v8/array.ts + + //#region src/v8/boolean.ts + /** + * @__deps $emnapiCtx + * @__sig ip + */ + function _v8_boolean_value(value) { + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + return jsValue ? 1 : 0; + } + /** + * @__deps $emnapiCtx + * @__sig ppi + */ + function _v8_boolean_object_new(isolate, value) { + // eslint-disable-next-line no-new-wrappers + return emnapiCtx.napiValueFromJsValue(new Boolean(value)); + } + /** + * @__deps $emnapiCtx + * @__sig ip + */ + function _v8_boolean_object_value_of(self) { + const boolObj = emnapiCtx.jsValueFromNapiValue(self); + return boolObj.valueOf() ? 1 : 0; + } + + //#endregion src/v8/boolean.ts + + //#region src/v8/date.ts + /** + * @__deps $emnapiCtx + * @__sig ppd + */ + function _v8_date_new(context, value) { + return emnapiCtx.napiValueFromJsValue(new Date(value)); + } + + //#endregion src/v8/date.ts + + //#region src/v8/exception.ts + /** + * @__deps $emnapiCtx + * @__sig ppp + */ + function _v8_exception_error(message, options) { + return emnapiCtx.napiValueFromJsValue(new Error(emnapiCtx.jsValueFromNapiValue(message), + // @ts-ignore + emnapiCtx.jsValueFromNapiValue(options))); + } + /** + * @__deps $emnapiCtx + * @__sig ppp + */ + function _v8_exception_type_error(message, options) { + return emnapiCtx.napiValueFromJsValue(new TypeError(emnapiCtx.jsValueFromNapiValue(message), + // @ts-ignore + emnapiCtx.jsValueFromNapiValue(options))); + } + /** + * @__deps $emnapiCtx + * @__sig ppp + */ + function _v8_exception_range_error(message, options) { + return emnapiCtx.napiValueFromJsValue(new RangeError(emnapiCtx.jsValueFromNapiValue(message), + // @ts-ignore + emnapiCtx.jsValueFromNapiValue(options))); + } + /** + * @__deps $emnapiCtx + * @__sig ppp + */ + function _v8_exception_reference_error(message, options) { + return emnapiCtx.napiValueFromJsValue(new ReferenceError(emnapiCtx.jsValueFromNapiValue(message), + // @ts-ignore + emnapiCtx.jsValueFromNapiValue(options))); + } + /** + * @__deps $emnapiCtx + * @__sig ppp + */ + function _v8_exception_syntax_error(message, options) { + return emnapiCtx.napiValueFromJsValue(new SyntaxError(emnapiCtx.jsValueFromNapiValue(message), + // @ts-ignore + emnapiCtx.jsValueFromNapiValue(options))); + } + + //#endregion src/v8/exception.ts + + //#region src/v8/external.ts + /** + * @__deps $emnapiCtx + * @__sig ppp + */ + function _v8_external_new(isolate, data) { + const external = emnapiCtx.isolate.createExternal(data); + return emnapiCtx.napiValueFromJsValue(external); + } + /** + * @__deps $emnapiCtx + * @__sig pp + */ + function _v8_external_value(external) { + const obj = emnapiCtx.jsValueFromNapiValue(external); + return emnapiCtx.isolate.getExternalValue(obj); + } + + //#endregion src/v8/external.ts + + //#region src/v8/function.ts + /** + * @__deps $emnapiCtx + * @__sig vpp + */ + function _v8_function_set_name(fn, name) { + if (!emnapiCtx.features.setFunctionName) { + return; + } + const str = emnapiCtx.jsValueFromNapiValue(name); + const func = emnapiCtx.jsValueFromNapiValue(fn); + emnapiCtx.features.setFunctionName(func, str); + } + /** + * @__deps $emnapiCtx + * @__sig ppppp + */ + function _v8_function_new_instance(fn, ctx, argc, argv) { + if (emnapiCtx.isolate.hasPendingException()) + return 1; + const Ctor = emnapiCtx.jsValueFromNapiValue(fn); + argv >>>= 0; + let i; + let ret; + try { + var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer)); + if (emnapiCtx.features.Reflect) { + const argList = Array(argc); + for (i = 0; i < argc; i++) { + const argVal = GET_HEAP_DATA_VIEW().getUint32(argv + i * 4, true); + argList[i] = emnapiCtx.jsValueFromNapiValue(argVal); + } + ret = emnapiCtx.features.Reflect.construct(Ctor, argList, Ctor); + } + else { + const args = Array(argc + 1); + args[0] = undefined; + for (i = 0; i < argc; i++) { + const argVal = GET_HEAP_DATA_VIEW().getUint32(argv + i * 4, true); + args[i + 1] = emnapiCtx.jsValueFromNapiValue(argVal); + } + const BoundCtor = Ctor.bind.apply(Ctor, args); + ret = new BoundCtor(); + } + } + catch (err) { + emnapiCtx.isolate.throwException(err); + return 1; + } + return emnapiCtx.napiValueFromJsValue(ret); + } + /** + * @__deps $emnapiCtx + * @__sig ppppip + */ + function _v8_function_call(fn, ctx, recv, argc, argv) { + if (emnapiCtx.isolate.hasPendingException()) + return 1; + const func = emnapiCtx.jsValueFromNapiValue(fn); + const thisArg = emnapiCtx.jsValueFromNapiValue(recv); + argv >>>= 0; + let i; + let ret; + try { + const argList = Array(argc); + var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer)); + for (i = 0; i < argc; i++) { + const argVal = GET_HEAP_DATA_VIEW().getUint32(argv + i * 4, true); + argList[i] = emnapiCtx.jsValueFromNapiValue(argVal); + } + ret = func.apply(thisArg, argList); + } + catch (err) { + emnapiCtx.isolate.throwException(err); + return 1; + } + return emnapiCtx.napiValueFromJsValue(ret); + } + + //#endregion src/v8/function.ts + + //#region src/v8/handle_scope.ts + /** + * @__deps $emnapiCtx + * @__sig pp + */ + function _v8_open_handle_scope(_isolate) { + return emnapiCtx.isolate.openScope().id; + } + /** + * @__deps $emnapiCtx + * @__sig v + */ + function _v8_close_handle_scope() { + return emnapiCtx.isolate.closeScope(); + } + /** + * @__deps $emnapiCtx + * @__sig ppp + */ + function _v8_handle_scope_escape(scope, value) { + const scopeValue = emnapiCtx.getHandleScope(scope); + value >>>= 0; + return scopeValue.escape(value); + } + + //#endregion src/v8/handle_scope.ts + + //#region src/v8/internal.ts + /** + * @__deps $emnapiCtx + * @__sig pp + */ + function _v8_local_from_global_reference(ref) { + const reference = emnapiCtx.isolate.getRef(ref); + if (reference === undefined) + return 1; + const id = reference.slot(); + return id || 1; + } + /** + * @__deps $emnapiCtx + * @__sig ppp + */ + function _v8_globalize_reference(isolate, value) { + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + if (jsValue === undefined) + return 0; + return emnapiCtx.isolate.createReference(jsValue).id; + } + /** + * @__deps $emnapiCtx + * @__sig pp + */ + function _v8_copy_global_reference(from) { + const ref = emnapiCtx.isolate.getRef(from); + if (ref === undefined) + return 0; + return ref.copy().id; + } + /** + * @__deps $emnapiCtx + * @__sig vpp + */ + function _v8_move_global_reference(from, to) { + const refFrom = emnapiCtx.isolate.getRef(from); + const refTo = emnapiCtx.isolate.getRef(to); + if (refFrom === undefined || refTo === undefined) + return; + refFrom.move(refTo); + } + /** + * @__deps $emnapiCtx + * @__sig vp + */ + function _v8_dispose_global(ref) { + emnapiCtx.isolate.removeRef(ref); + } + /** + * @__deps $emnapiCtx + * @__sig vppppi + */ + function _v8_make_weak(ref, data, callback, weak_callback, type) { + const refValue = emnapiCtx.isolate.getRef(ref); + if (!refValue) + return; + callback >>>= 0; + refValue.setWeak(data, (data) => { + let field0 = 0; + let field1 = 0; + if (type === 1) { + const id = refValue.slot(); + if (id) { + const value = emnapiCtx.jsValueFromNapiValue(id); + field0 = emnapiCtx.isolate.getInternalField(value, 0); + field1 = emnapiCtx.isolate.getInternalField(value, 1); + if ((typeof field0 !== 'number' && typeof field0 !== 'bigint') || + (typeof field1 !== 'number' && typeof field1 !== 'bigint')) { + throw new Error('Internal field is not a number'); + } + } + } + (emnapiPluginCtx.wasmTable.get(callback))(weak_callback, data, type, field0, field1); + }); + } + /** + * @__deps $emnapiCtx + * @__sig pp + */ + function _v8_clear_weak(ref) { + const refValue = emnapiCtx.isolate.getRef(ref); + if (!refValue) + return 0; + refValue.clearWeak(); + return 0; + } + + //#endregion src/v8/internal.ts + + //#region src/v8/isolate.ts + /** + * @__sig p + */ + function _v8_isolate_get_current_context() { + return 6 /* Constant.GLOBAL */; + } + /** + * @__deps $emnapiCtx + * @__sig pp + */ + function _v8_isolate_throw_exception(error) { + emnapiCtx.isolate.throwException(emnapiCtx.jsValueFromNapiValue(error)); + return error; + } + + //#endregion src/v8/isolate.ts + + //#region src/v8/json.ts + /** + * @__deps $emnapiCtx + * @__sig ppp + */ + function _v8_json_parse(context, json_string) { + const jsonStringValue = emnapiCtx.jsValueFromNapiValue(json_string); + try { + const parsedValue = JSON.parse(jsonStringValue); + return emnapiCtx.napiValueFromJsValue(parsedValue); + } + catch (e) { + emnapiCtx.isolate.throwException(e); + return 0; + } + } + /** + * @__deps $emnapiCtx + * @__sig pppp + */ + function _v8_json_stringify(context, json_object, gap) { + const jsonStringValue = emnapiCtx.jsValueFromNapiValue(json_object); + try { + const str = JSON.stringify(jsonStringValue, null, emnapiCtx.jsValueFromNapiValue(gap)); + return emnapiCtx.napiValueFromJsValue(str); + } + catch (e) { + emnapiCtx.isolate.throwException(e); + return 0; + } + } + + //#endregion src/v8/json.ts + + //#region src/v8/number.ts + /** + * @__deps $emnapiCtx + * @__sig dp + */ + function _v8_number_value(value) { + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + return Number(jsValue); + } + /** + * @__deps $emnapiCtx + * @__sig vpp + */ + function _v8_integer_value(value, out) { + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + // Use BigInt if available, else fallback to Number + let v; + if (typeof jsValue === 'bigint') { + v = jsValue; + } + else { + v = Math.trunc(Number(jsValue)); + } + out >>>= 0; + var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setBigInt64(out, BigInt(v), true); + } + /** + * @__deps $emnapiCtx + * @__sig ip + */ + function _v8_uint32_value(value) { + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + return Number(jsValue) >>> 0; + } + /** + * @__deps $emnapiCtx + * @__sig ip + */ + function _v8_int32_value(value) { + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + return Number(jsValue) | 0; + } + /** + * @__deps $emnapiCtx + * @__sig ppd + */ + function _v8_number_new(isolate, value) { + return emnapiCtx.napiValueFromJsValue(value); + } + /** + * @__deps $emnapiCtx + * @__sig ppi + */ + function _v8_integer_new(isolate, value) { + return emnapiCtx.napiValueFromJsValue(value | 0); + } + /** + * @__deps $emnapiCtx + * @__sig ppi + */ + function _v8_integer_new_from_unsigned(isolate, value) { + return emnapiCtx.napiValueFromJsValue(value >>> 0); + } + /** + * @__deps $emnapiCtx + * @__sig ppd + */ + function _v8_number_object_new(isolate, value) { + // eslint-disable-next-line no-new-wrappers + return emnapiCtx.napiValueFromJsValue(new Number(value)); + } + + //#endregion src/v8/number.ts + + //#region src/v8/object.ts + /** + * @__deps $emnapiCtx + * @__sig ippppp + */ + function _v8_object_set(obj, context, key, value, success) { + let r = false; + try { + r = Reflect.set(emnapiCtx.jsValueFromNapiValue(obj), emnapiCtx.jsValueFromNapiValue(key), emnapiCtx.jsValueFromNapiValue(value)); + } + catch (_) { + return 10; + } + success >>>= 0; + if (success) { + const v = r ? 1 : 0; + var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt32(success, v, true); + } + return 0; + } + /** + * @__deps $emnapiCtx + * @__sig ip + */ + function _v8_object_internal_field_count(obj) { + const objValue = emnapiCtx.jsValueFromNapiValue(obj); + return emnapiCtx.isolate.getInternalFieldCount(objValue); + } + /** + * @__deps $emnapiCtx + * @__sig vpip + */ + function _v8_object_set_internal_field(obj, index, data) { + const objValue = emnapiCtx.jsValueFromNapiValue(obj); + const dataValue = emnapiCtx.jsValueFromNapiValue(data); + emnapiCtx.isolate.setInternalField(objValue, index, dataValue); + } + /** + * @__deps $emnapiCtx + * @__sig vpip + */ + function _v8_object_set_aligned_pointer_in_internal_field(obj, index, data) { + const objValue = emnapiCtx.jsValueFromNapiValue(obj); + emnapiCtx.isolate.setInternalField(objValue, index, data); + } + /** + * @__deps $emnapiCtx + * @__sig pip + */ + function _v8_object_get_internal_field(obj, index) { + const objValue = emnapiCtx.jsValueFromNapiValue(obj); + return emnapiCtx.isolate.napiValueFromJsValue(emnapiCtx.isolate.getInternalField(objValue, index)); + } + /** + * @__deps $emnapiCtx + * @__sig pip + */ + function _v8_object_get_aligned_pointer_in_internal_field(obj, index) { + const objValue = emnapiCtx.jsValueFromNapiValue(obj); + return emnapiCtx.isolate.getInternalField(objValue, index); + } + /** + * @__deps $emnapiCtx + * @__sig pppp + */ + function _v8_object_get_key(obj, context, key) { + const objValue = emnapiCtx.jsValueFromNapiValue(obj); + if (!objValue) + return 1; + return emnapiCtx.napiValueFromJsValue(objValue[emnapiCtx.jsValueFromNapiValue(key)]); + } + /** + * @__deps $emnapiCtx + * @__sig pppi + */ + function _v8_object_get_index(obj, context, index) { + const objValue = emnapiCtx.jsValueFromNapiValue(obj); + if (!objValue) + return 1; + return emnapiCtx.napiValueFromJsValue(objValue[index >>> 0]); + } + /** + * @__deps $emnapiCtx + * @__sig ppp + */ + function _v8_private_for_api(isolate, name) { + const n = emnapiCtx.isolate.getOrCreateGlobalPrivate(emnapiCtx.jsValueFromNapiValue(name)); + return emnapiCtx.napiValueFromJsValue(n); + } + /** + * @__deps $emnapiCtx + * @__sig ippppp + */ + function _v8_object_set_private(obj, context, key, value, success) { + if (emnapiCtx.isolate.hasPendingException()) + return 1; + const o = emnapiCtx.jsValueFromNapiValue(obj); + const k = emnapiCtx.jsValueFromNapiValue(key); + const v = emnapiCtx.jsValueFromNapiValue(value); + try { + emnapiCtx.isolate.setPrivate(o, k, v); + } + catch (err) { + emnapiCtx.isolate.throwException(err); + return 1; + } + success >>>= 0; + if (success) { + const vv = 1; + var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt32(success, vv, true); + } + return 0; + } + /** + * @__deps $emnapiCtx + * @__sig ipppp + */ + function _v8_object_has_private(obj, context, key, has) { + if (emnapiCtx.isolate.hasPendingException()) + return 1; + const o = emnapiCtx.jsValueFromNapiValue(obj); + const k = emnapiCtx.jsValueFromNapiValue(key); + let v; + try { + v = emnapiCtx.isolate.hasPrivate(o, k) ? 1 : 0; + } + catch (err) { + emnapiCtx.isolate.throwException(err); + return 1; + } + has >>>= 0; + if (has) { + var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt32(has, v, true); + } + return 0; + } + /** + * @__deps $emnapiCtx + * @__sig pppp + */ + function _v8_object_get_private(obj, context, key) { + if (emnapiCtx.isolate.hasPendingException()) + return 1; + const o = emnapiCtx.jsValueFromNapiValue(obj); + const k = emnapiCtx.jsValueFromNapiValue(key); + try { + const v = emnapiCtx.isolate.getPrivate(o, k); + return emnapiCtx.napiValueFromJsValue(v); + } + catch (err) { + emnapiCtx.isolate.throwException(err); + return 1; + } + } + /** + * @__deps $emnapiCtx + * @__sig ipppp + */ + function _v8_object_delete_private(obj, context, key, success) { + if (emnapiCtx.isolate.hasPendingException()) + return 1; + const o = emnapiCtx.jsValueFromNapiValue(obj); + const k = emnapiCtx.jsValueFromNapiValue(key); + let r; + try { + r = emnapiCtx.isolate.deletePrivate(o, k); + } + catch (err) { + emnapiCtx.isolate.throwException(err); + return 1; + } + success >>>= 0; + if (success) { + const vv = r ? 1 : 0; + var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setInt32(success, vv, true); + } + return 0; + } + /** + * @__deps $emnapiCtx + * @__sig pp + */ + function _v8_object_new(isolate) { + return emnapiCtx.napiValueFromJsValue({}); + } + + //#endregion src/v8/object.ts + + //#region src/v8/script.ts + /** + * @__deps $emnapiCtx + * @__sig pppii + */ + function _v8_script_compiler_compile_unbound_script(isolate, sourceString, options, reason) { + const str = emnapiCtx.jsValueFromNapiValue(sourceString); + if (!str) + return 1; + return emnapiCtx.napiValueFromJsValue(str); + } + /** + * @__deps $emnapiCtx + * @__sig pp + */ + function _v8_unbound_script_bind_to_current_context(unboundScript) { + const str = emnapiCtx.jsValueFromNapiValue(unboundScript); + if (!str) + return 1; + return emnapiCtx.napiValueFromJsValue(str); + } + /** + * @__deps $emnapiCtx + * @__sig ppp + */ + function _v8_script_run(script, context) { + if (emnapiCtx.isolate.hasPendingException()) + return 1; + const str = emnapiCtx.jsValueFromNapiValue(script); + const g = emnapiCtx.jsValueFromNapiValue(context); + let ret; + try { + ret = g.eval(str); + } + catch (err) { + emnapiCtx.isolate.throwException(err); + return 1; + } + return emnapiCtx.napiValueFromJsValue(ret); + } + + //#endregion src/v8/script.ts + + //#region src/v8/string.ts + /** + * @__deps $emnapiCtx + * @__deps $emnapiString + * @__sig pppii + */ + function _v8_string_new_from_utf8(isolate, data, type, length) { + data >>>= 0; + length >>>= 0; + const str = emnapiString.UTF8ToString(data, length); + return emnapiCtx.napiValueFromJsValue(str); + } + /** + * @__deps $emnapiCtx + * @__sig ppp + */ + function _v8_string_object_new(isolate, value) { + // eslint-disable-next-line no-new-wrappers + return emnapiCtx.napiValueFromJsValue(new String(emnapiCtx.jsValueFromNapiValue(value))); + } + /** + * @__deps $emnapiCtx + * @__sig pp + */ + function _v8_string_object_value_of(self) { + const strObj = emnapiCtx.jsValueFromNapiValue(self); + return emnapiCtx.napiValueFromJsValue(strObj.valueOf()); + } + /** + * @__deps $emnapiCtx + * @__deps $emnapiString + * @__sig pppii + */ + function _v8_string_new_from_one_byte(isolate, data, type, length) { + data >>>= 0; + length >>>= 0; + const str = emnapiString.encode(data, length === -1 || length === 4294967295, length >>> 0, (c) => String.fromCharCode(c)); + return emnapiCtx.napiValueFromJsValue(str); + } + /** + * @__deps $emnapiCtx + * @__deps $emnapiString + * @__sig pppii + */ + function _v8_string_new_from_two_byte(isolate, data, type, length) { + data >>>= 0; + length >>>= 0; + const str = emnapiString.UTF16ToString(data, length); + return emnapiCtx.napiValueFromJsValue(str); + } + /** + * @__deps $emnapiCtx + * @__deps $emnapiString + * @__sig pppi + */ + function _v8_string_new_external_one_byte(isolate, data, length) { + data >>>= 0; + length >>>= 0; + const str = emnapiString.encode(data, length === -1 || length === 4294967295, length >>> 0, (c) => String.fromCharCode(c)); + return emnapiCtx.napiValueFromJsValue(str); + } + /** + * @__deps $emnapiCtx + * @__deps $emnapiString + * @__sig pppi + */ + function _v8_string_new_external_two_byte(isolate, data, length) { + data >>>= 0; + length >>>= 0; + const str = emnapiString.UTF16ToString(data, length); + return emnapiCtx.napiValueFromJsValue(str); + } + /** + * @__deps $emnapiCtx + * @__sig pppi + */ + function _v8_regex_new(context, pattern, flags) { + pattern >>>= 0; + const str = emnapiCtx.jsValueFromNapiValue(pattern); + let f = ''; + if (flags & 1) + f += 'g'; + if (flags & 2) + f += 'i'; + if (flags & 4) + f += 'm'; + if (flags & 8) + f += 'y'; + if (flags & 16) + f += 'u'; + if (flags & 32) + f += 's'; + return emnapiCtx.napiValueFromJsValue(f ? new RegExp(str, f) : new RegExp(str)); + } + /** + * @__deps $emnapiCtx + * @__deps $emnapiString + * @__sig ipp + */ + function _v8_string_utf8_length(str, isolate) { + const jsValue = emnapiCtx.jsValueFromNapiValue(str); + if (jsValue === undefined) + return 0; + if (typeof jsValue !== 'string') + return 0; + return emnapiString.lengthBytesUTF8(jsValue); + } + /** + * @__deps $emnapiCtx + * @__sig ip + */ + function _v8_string_length(str) { + const jsValue = emnapiCtx.jsValueFromNapiValue(str); + if (jsValue === undefined) + return 0; + if (typeof jsValue !== 'string') + return 0; + return jsValue.length; + } + /** + * @__deps $emnapiCtx + * @__deps $emnapiString + * @__sig ipppipi + */ + function _v8_string_write_utf8(str, isolate, buffer, length, nchars_ref, options) { + buffer >>>= 0; + nchars_ref >>>= 0; + const jsValue = emnapiCtx.jsValueFromNapiValue(str); + var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer)); + if (jsValue === undefined || typeof jsValue !== 'string') { + if (nchars_ref) { + GET_HEAP_DATA_VIEW().setInt32(nchars_ref, 0, true); + } + return 0; + } + const written = emnapiString.stringToUTF8(jsValue, buffer, length); + if (nchars_ref) { + GET_HEAP_DATA_VIEW().setInt32(nchars_ref, written, true); + } + return written; + } + + //#endregion src/v8/string.ts + + //#region src/v8/template.ts + /** + * @__deps $emnapiCtx + * @__sig ippppp + */ + function _v8_get_cb_info(cbinfo, argc, argv, this_arg, data) { + if (!cbinfo) + return 1; + const cbinfoValue = emnapiCtx.getCallbackInfo(cbinfo); + argc >>>= 0; + argv >>>= 0; + var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer)); + if (argv) { + if (!argc) + return 1; + let argcValue = GET_HEAP_DATA_VIEW().getUint32(argc, true); + argcValue >>>= 0; + const len = cbinfoValue.args.length; + const arrlen = argcValue < len ? argcValue : len; + let i = 0; + for (; i < arrlen; i++) { + const argVal = emnapiCtx.napiValueFromJsValue(cbinfoValue.args[i]); + GET_HEAP_DATA_VIEW().setUint32(argv + i * 4, argVal, true); + } + if (i < argcValue) { + for (; i < argcValue; i++) { + GET_HEAP_DATA_VIEW().setUint32(argv + i * 4, 1, true); + } + } + } + if (argc) { + GET_HEAP_DATA_VIEW().setUint32(argc, cbinfoValue.args.length, true); + } + if (this_arg) { + this_arg >>>= 0; + const v = emnapiCtx.napiValueFromJsValue(cbinfoValue.thiz); + GET_HEAP_DATA_VIEW().setUint32(this_arg, v, true); + } + if (data) { + data >>>= 0; + const localData = emnapiCtx.napiValueFromJsValue(cbinfoValue.data); + GET_HEAP_DATA_VIEW().setUint32(data, localData, true); + } + return 0; + } + /** + * @__deps $emnapiCtx + * @__sig ppppppiiipiii + */ + function _v8_function_template_new(isolate, callback, cb, data, signature, length, behavior, side_effect_type, c_function, instance_type, allowed_receiver_instance_type_range_start, allowed_receiver_instance_type_range_end) { + const jsCb = (emnapiPluginCtx.wasmTable.get(callback)); + const tpl = emnapiCtx.isolate.createFunctionTemplate(jsCb, cb, emnapiCtx.jsValueFromNapiValue(data), emnapiCtx.jsValueFromNapiValue(signature)); + return emnapiCtx.napiValueFromJsValue(tpl); + } + /** + * @__deps $emnapiCtx + * @__sig pppppiii + */ + function _v8_function_new(context, callback, cb, data, length, behavior, side_effect_type) { + const jsCb = (emnapiPluginCtx.wasmTable.get(callback)); + const tpl = emnapiCtx.isolate.createFunctionTemplate(jsCb, cb, emnapiCtx.jsValueFromNapiValue(data), undefined); + const func = tpl.getFunction(); + return emnapiCtx.napiValueFromJsValue(func); + } + /** + * @__deps $emnapiCtx + * @__sig pp + */ + function _v8_cbinfo_holder(info) { + const cbinfoValue = emnapiCtx.getCallbackInfo(info); + const { holder } = cbinfoValue; + return emnapiCtx.napiValueFromJsValue(holder); + } + /** + * @__deps $emnapiCtx + * @__sig pp + */ + function _v8_cbinfo_new_target(info) { + const cbinfoValue = emnapiCtx.getCallbackInfo(info); + const { thiz, fn } = cbinfoValue; + const value = thiz == null || thiz.constructor == null + ? 0 + : thiz instanceof fn + ? emnapiCtx.napiValueFromJsValue(thiz.constructor) + : 0; + return value; + } + /** + * @__deps $emnapiCtx + * @__sig ppp + */ + function _v8_function_template_get_function(template, context) { + const tpl = emnapiCtx.jsValueFromNapiValue(template); + if (!tpl) + return 0; + return emnapiCtx.napiValueFromJsValue(tpl.getFunction()); + } + function _v8_function_template_set_class_name(template, name) { + const tpl = emnapiCtx.jsValueFromNapiValue(template); + const nameValue = emnapiCtx.jsValueFromNapiValue(name); + if (!tpl || nameValue == null) + return; + tpl.setClassName(nameValue); + } + /** + * @__deps $emnapiCtx + * @__sig ppp + */ + function _v8_object_template_new(isolate, constructor) { + const tpl = emnapiCtx.isolate.createObjectTemplate(emnapiCtx.jsValueFromNapiValue(constructor)); + return emnapiCtx.napiValueFromJsValue(tpl); + } + /** + * @__deps $emnapiCtx + * @__sig vpi + */ + function _v8_object_template_set_internal_field_count(tpl, value) { + const templateObject = emnapiCtx.jsValueFromNapiValue(tpl); + templateObject.setInternalFieldCount(value); + } + /** + * @__deps $emnapiCtx + * @__sig ppp + */ + function _v8_object_template_new_instance(obj_tpl, context) { + if (emnapiCtx.isolate.hasPendingException()) + return 1; + const objTemplate = emnapiCtx.jsValueFromNapiValue(obj_tpl); + return emnapiCtx.napiValueFromJsValue(objTemplate.newInstance(context)); + } + /** + * @__deps $emnapiCtx + * @__sig ppp + */ + function _v8_signature_new(isolate, receiver) { + const rcv = emnapiCtx.jsValueFromNapiValue(receiver); + const sig = emnapiCtx.isolate.createSignature(rcv); + return emnapiCtx.napiValueFromJsValue(sig); + } + /** + * @__deps $emnapiCtx + * @__sig vpppi + */ + function _v8_template_set(tpl, name, value, attr) { + const templateObject = emnapiCtx.jsValueFromNapiValue(tpl); + if (!templateObject) + return; + const nameValue = emnapiCtx.jsValueFromNapiValue(name); + const valueValue = emnapiCtx.jsValueFromNapiValue(value); + if (nameValue == null) + return; + templateObject.set(nameValue, valueValue, attr); + } + /** + * @__deps $emnapiCtx + * @__sig pp + */ + function _v8_function_template_instance_template(tpl) { + const templateObject = emnapiCtx.jsValueFromNapiValue(tpl); + if (!templateObject) + return 1; + return emnapiCtx.napiValueFromJsValue(templateObject.instanceTemplate()); + } + /** + * @__deps $emnapiCtx + * @__sig pp + */ + function _v8_function_template_prototype_template(tpl) { + const templateObject = emnapiCtx.jsValueFromNapiValue(tpl); + if (!templateObject) + return 1; + return emnapiCtx.napiValueFromJsValue(templateObject.prototypeTemplate()); + } + /** + * @__deps $emnapiCtx + * @__sig vpp + */ + function _v8_get_property_cb_info(cbinfo, args) { + if (!cbinfo) + return; + const cbinfoValue = emnapiCtx.getCallbackInfo(cbinfo); + args >>>= 0; + const thiz = emnapiCtx.napiValueFromJsValue(cbinfoValue.thiz); + const holder = emnapiCtx.napiValueFromJsValue(cbinfoValue.holder); + var HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer), GET_HEAP_DATA_VIEW = () => HEAP_DATA_VIEW.buffer === emnapiPluginCtx.wasmMemory.buffer ? HEAP_DATA_VIEW : (HEAP_DATA_VIEW = new DataView(emnapiPluginCtx.wasmMemory.buffer)); + GET_HEAP_DATA_VIEW().setUint32(args + 1 * 4, holder, true); + GET_HEAP_DATA_VIEW().setUint32(args + 6 * 4, thiz, true); + const localData = emnapiCtx.napiValueFromJsValue(cbinfoValue.data); + GET_HEAP_DATA_VIEW().setUint32(args + 5 * 4, localData, true); + } + /** + * @__deps $emnapiCtx + * @__sig vpppppppiii + */ + function _v8_object_template_set_accessor(tpl, name, getter_wrap, setter_wrap, getter, setter, data, attribute, getter_side_effect_type, setter_side_effect_type) { + const templateObject = emnapiCtx.jsValueFromNapiValue(tpl); + if (!templateObject) + return; + const nameValue = emnapiCtx.jsValueFromNapiValue(name); + getter_wrap >>>= 0; + setter_wrap >>>= 0; + const getterWrap = (emnapiPluginCtx.wasmTable.get(getter_wrap)); + const setterWrap = (emnapiPluginCtx.wasmTable.get(setter_wrap)); + templateObject.setAccessor(nameValue, getterWrap, setterWrap, getter, setter, emnapiCtx.jsValueFromNapiValue(data), attribute, getter_side_effect_type, setter_side_effect_type); + } + + //#endregion src/v8/template.ts + + //#region src/v8/try_catch.ts + /** + * @__deps $emnapiCtx + * @__sig vp + */ + function _v8_trycatch_construct(tc) { + emnapiCtx.isolate.pushTryCatch(tc); + } + /** + * @__deps $emnapiCtx + * @__sig vp + */ + function _v8_trycatch_destruct(tc) { + emnapiCtx.isolate.popTryCatch(tc); + } + /** + * @__deps $emnapiCtx + * @__sig ip + */ + function _v8_trycatch_has_caught(tc) { + const tryCatch = emnapiCtx.isolate.getTryCatch(tc); + if (!tryCatch) + return 0; + return Number(tryCatch.hasCaught()); + } + /** + * @__deps $emnapiCtx + * @__sig pp + */ + function _v8_trycatch_rethrow(tc) { + const tryCatch = emnapiCtx.isolate.getTryCatch(tc); + if (!tryCatch) + return 1; + const e = tryCatch.rethrow(emnapiCtx.isolate); + if (e === undefined) + return 1; + return emnapiCtx.napiValueFromJsValue(e); + } + /** + * @__deps $emnapiCtx + * @__sig pp + */ + function _v8_trycatch_exception(tc) { + const tryCatch = emnapiCtx.isolate.getTryCatch(tc); + if (!tryCatch || !tryCatch.hasCaught()) + return 1; + return emnapiCtx.napiValueFromJsValue(tryCatch.exception()); + } + /** + * @__deps $emnapiCtx + * @__sig vp + */ + function _v8_trycatch_reset(tc) { + const tryCatch = emnapiCtx.isolate.getTryCatch(tc); + if (!tryCatch) + return; + tryCatch.reset(); + } + + //#endregion src/v8/try_catch.ts + + //#region src/v8/value.ts + /** + * @__deps $emnapiCtx + * @__sig ipp + */ + function _v8_value_strict_equals(value, that) { + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + const jsThat = emnapiCtx.jsValueFromNapiValue(that); + return Object.is(jsValue, jsThat) ? 1 : 0; + } + /** + * @__deps $emnapiCtx + * @__sig ppp + */ + function _v8_value_to_boolean(value, isolate) { + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + const boolValue = Boolean(jsValue); + return emnapiCtx.napiValueFromJsValue(boolValue); + } + /** + * @__deps $emnapiCtx + * @__sig ppp + */ + function _v8_value_to_number(value, context) { + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + const numValue = Number(jsValue); + return emnapiCtx.napiValueFromJsValue(numValue); + } + /** + * @__deps $emnapiCtx + * @__sig ppp + */ + function _v8_value_to_string(value, context) { + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + const strValue = String(jsValue); + return emnapiCtx.napiValueFromJsValue(strValue); + } + /** + * @__deps $emnapiCtx + * @__sig ppp + */ + function _v8_value_to_object(value, context) { + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + if (jsValue === null || jsValue === undefined) + return 0; + const objValue = Object(jsValue); + return emnapiCtx.napiValueFromJsValue(objValue); + } + /** + * @__deps $emnapiCtx + * @__sig ppp + */ + function _v8_value_to_integer(value, context) { + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + const intValue = Math.trunc(Number(jsValue)); + return emnapiCtx.napiValueFromJsValue(intValue); + } + /** + * @__deps $emnapiCtx + * @__sig ppp + */ + function _v8_value_to_uint32(value, context) { + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + const uint32Value = Number(jsValue) >>> 0; + return emnapiCtx.napiValueFromJsValue(uint32Value); + } + /** + * @__deps $emnapiCtx + * @__sig ppp + */ + function _v8_value_to_int32(value, context) { + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + const int32Value = Number(jsValue) | 0; + return emnapiCtx.napiValueFromJsValue(int32Value); + } + /** + * @__deps $emnapiCtx + * @__sig ppp + */ + function _v8_value_to_array_index(value, context) { + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + // V8: ToArrayIndex returns uint32 if possible, else undefined + const n = Number(jsValue); + if (typeof n === 'number' && + isFinite(n) && + n >= 0 && + n <= 0xffffffff && + Math.floor(n) === n) { + return emnapiCtx.napiValueFromJsValue(n >>> 0); + } + return 0; + } + /** + * @__deps $emnapiCtx + * @__sig ip + */ + function _v8_value_is_function(value) { + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + if (jsValue == null) + return 0; + const isFunction = typeof jsValue === 'function'; + return isFunction ? 1 : 0; + } + /** + * @__deps $emnapiCtx + * @__sig ip + */ + function _v8_value_is_number(value) { + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + if (jsValue == null) + return 0; + const isFunction = typeof jsValue === 'number'; + return isFunction ? 1 : 0; + } + /** + * @__deps $emnapiCtx + * @__sig ip + */ + function _v8_value_is_undefined(value) { + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + const isUndefined = jsValue === undefined; + return isUndefined ? 1 : 0; + } + /** + * @__deps $emnapiCtx + * @__sig ip + */ + function _v8_value_is_null(value) { + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + const isUndefined = jsValue === null; + return isUndefined ? 1 : 0; + } + /** + * @__deps $emnapiCtx + * @__sig ip + */ + function _v8_value_is_true(value) { + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + if (jsValue == null) + return 0; + const isUndefined = jsValue === true; + return isUndefined ? 1 : 0; + } + /** + * @__deps $emnapiCtx + * @__sig ip + */ + function _v8_value_is_false(value) { + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + if (jsValue == null) + return 0; + const isUndefined = jsValue === false; + return isUndefined ? 1 : 0; + } + /** + * @__deps $emnapiCtx + * @__sig ip + */ + function _v8_value_is_string(value) { + const jsValue = emnapiCtx.jsValueFromNapiValue(value); + if (jsValue == null) + return 0; + const isFunction = typeof jsValue === 'string'; + return isFunction ? 1 : 0; + } + + //#endregion src/v8/value.ts + + //#region src/v8/node.ts + /** + * @__deps $emnapiCtx + * @__deps $emnapiString + * @__sig ppppi + */ + function _node_encode(isolate, buf, len, encoding) { + const autoLength = len === -1 || len === 4294967295; + buf >>>= 0; + len >>>= 0; + if (encoding === 1) { + return emnapiCtx.napiValueFromJsValue(emnapiString.UTF8ToString(buf, len)); + } + if (encoding === -1) { + return emnapiCtx.napiValueFromJsValue(emnapiString.UTF16ToString(buf, len)); + } + if (encoding === 2) { + const Buffer = emnapiCtx.features.Buffer; + if (typeof Buffer !== 'function') { + emnapiCtx.isolate.throwException(new Error('Buffer is not supported')); + return 1; + } + const buffer = Buffer.from(emscripten_runtime.wasmMemory.buffer, buf, len >>> 0); + return emnapiCtx.napiValueFromJsValue(buffer.toString('base64')); + } + if (encoding === 3) { + return emnapiCtx.napiValueFromJsValue(emnapiString.UTF16ToString(buf, len / 2)); + } + if (encoding === 4 || encoding === 0) { + return emnapiCtx.napiValueFromJsValue(emnapiString.encode(buf, autoLength, len >>> 0, (c) => String.fromCharCode(c))); + } + if (encoding === 5) { + return emnapiCtx.napiValueFromJsValue(emnapiString.encode(buf, autoLength, len >>> 0, (c) => c.toString(16).padStart(2, '0'))); + } + if (encoding === 6) { + const Buffer = emnapiCtx.features.Buffer; + if (typeof Buffer !== 'function') { + emnapiCtx.isolate.throwException(new Error('Buffer is not supported')); + return 1; + } + const buffer = Buffer.from(emscripten_runtime.wasmMemory.buffer, buf, len >>> 0); + return emnapiCtx.napiValueFromJsValue(buffer); + } + emnapiCtx.isolate.throwException(new Error(`Unsupported encoding: ${encoding}`)); + return 1; + } + + //#endregion src/v8/node.ts + + //#region src/v8/index.ts + + //#endregion src/v8/index.ts + + exports._node_encode = _node_encode; + exports._v8_array_length = _v8_array_length; + exports._v8_array_new = _v8_array_new; + exports._v8_boolean_object_new = _v8_boolean_object_new; + exports._v8_boolean_object_value_of = _v8_boolean_object_value_of; + exports._v8_boolean_value = _v8_boolean_value; + exports._v8_cbinfo_holder = _v8_cbinfo_holder; + exports._v8_cbinfo_new_target = _v8_cbinfo_new_target; + exports._v8_clear_weak = _v8_clear_weak; + exports._v8_close_handle_scope = _v8_close_handle_scope; + exports._v8_copy_global_reference = _v8_copy_global_reference; + exports._v8_date_new = _v8_date_new; + exports._v8_dispose_global = _v8_dispose_global; + exports._v8_exception_error = _v8_exception_error; + exports._v8_exception_range_error = _v8_exception_range_error; + exports._v8_exception_reference_error = _v8_exception_reference_error; + exports._v8_exception_syntax_error = _v8_exception_syntax_error; + exports._v8_exception_type_error = _v8_exception_type_error; + exports._v8_external_new = _v8_external_new; + exports._v8_external_value = _v8_external_value; + exports._v8_function_call = _v8_function_call; + exports._v8_function_new = _v8_function_new; + exports._v8_function_new_instance = _v8_function_new_instance; + exports._v8_function_set_name = _v8_function_set_name; + exports._v8_function_template_get_function = _v8_function_template_get_function; + exports._v8_function_template_instance_template = _v8_function_template_instance_template; + exports._v8_function_template_new = _v8_function_template_new; + exports._v8_function_template_prototype_template = _v8_function_template_prototype_template; + exports._v8_function_template_set_class_name = _v8_function_template_set_class_name; + exports._v8_get_cb_info = _v8_get_cb_info; + exports._v8_get_property_cb_info = _v8_get_property_cb_info; + exports._v8_globalize_reference = _v8_globalize_reference; + exports._v8_handle_scope_escape = _v8_handle_scope_escape; + exports._v8_int32_value = _v8_int32_value; + exports._v8_integer_new = _v8_integer_new; + exports._v8_integer_new_from_unsigned = _v8_integer_new_from_unsigned; + exports._v8_integer_value = _v8_integer_value; + exports._v8_isolate_get_current_context = _v8_isolate_get_current_context; + exports._v8_isolate_throw_exception = _v8_isolate_throw_exception; + exports._v8_json_parse = _v8_json_parse; + exports._v8_json_stringify = _v8_json_stringify; + exports._v8_local_from_global_reference = _v8_local_from_global_reference; + exports._v8_make_weak = _v8_make_weak; + exports._v8_move_global_reference = _v8_move_global_reference; + exports._v8_number_new = _v8_number_new; + exports._v8_number_object_new = _v8_number_object_new; + exports._v8_number_value = _v8_number_value; + exports._v8_object_delete_private = _v8_object_delete_private; + exports._v8_object_get_aligned_pointer_in_internal_field = _v8_object_get_aligned_pointer_in_internal_field; + exports._v8_object_get_index = _v8_object_get_index; + exports._v8_object_get_internal_field = _v8_object_get_internal_field; + exports._v8_object_get_key = _v8_object_get_key; + exports._v8_object_get_private = _v8_object_get_private; + exports._v8_object_has_private = _v8_object_has_private; + exports._v8_object_internal_field_count = _v8_object_internal_field_count; + exports._v8_object_new = _v8_object_new; + exports._v8_object_set = _v8_object_set; + exports._v8_object_set_aligned_pointer_in_internal_field = _v8_object_set_aligned_pointer_in_internal_field; + exports._v8_object_set_internal_field = _v8_object_set_internal_field; + exports._v8_object_set_private = _v8_object_set_private; + exports._v8_object_template_new = _v8_object_template_new; + exports._v8_object_template_new_instance = _v8_object_template_new_instance; + exports._v8_object_template_set_accessor = _v8_object_template_set_accessor; + exports._v8_object_template_set_internal_field_count = _v8_object_template_set_internal_field_count; + exports._v8_open_handle_scope = _v8_open_handle_scope; + exports._v8_private_for_api = _v8_private_for_api; + exports._v8_regex_new = _v8_regex_new; + exports._v8_script_compiler_compile_unbound_script = _v8_script_compiler_compile_unbound_script; + exports._v8_script_run = _v8_script_run; + exports._v8_signature_new = _v8_signature_new; + exports._v8_string_length = _v8_string_length; + exports._v8_string_new_external_one_byte = _v8_string_new_external_one_byte; + exports._v8_string_new_external_two_byte = _v8_string_new_external_two_byte; + exports._v8_string_new_from_one_byte = _v8_string_new_from_one_byte; + exports._v8_string_new_from_two_byte = _v8_string_new_from_two_byte; + exports._v8_string_new_from_utf8 = _v8_string_new_from_utf8; + exports._v8_string_object_new = _v8_string_object_new; + exports._v8_string_object_value_of = _v8_string_object_value_of; + exports._v8_string_utf8_length = _v8_string_utf8_length; + exports._v8_string_write_utf8 = _v8_string_write_utf8; + exports._v8_template_set = _v8_template_set; + exports._v8_trycatch_construct = _v8_trycatch_construct; + exports._v8_trycatch_destruct = _v8_trycatch_destruct; + exports._v8_trycatch_exception = _v8_trycatch_exception; + exports._v8_trycatch_has_caught = _v8_trycatch_has_caught; + exports._v8_trycatch_reset = _v8_trycatch_reset; + exports._v8_trycatch_rethrow = _v8_trycatch_rethrow; + exports._v8_uint32_value = _v8_uint32_value; + exports._v8_unbound_script_bind_to_current_context = _v8_unbound_script_bind_to_current_context; + exports._v8_value_is_false = _v8_value_is_false; + exports._v8_value_is_function = _v8_value_is_function; + exports._v8_value_is_null = _v8_value_is_null; + exports._v8_value_is_number = _v8_value_is_number; + exports._v8_value_is_string = _v8_value_is_string; + exports._v8_value_is_true = _v8_value_is_true; + exports._v8_value_is_undefined = _v8_value_is_undefined; + exports._v8_value_strict_equals = _v8_value_strict_equals; + exports._v8_value_to_array_index = _v8_value_to_array_index; + exports._v8_value_to_boolean = _v8_value_to_boolean; + exports._v8_value_to_int32 = _v8_value_to_int32; + exports._v8_value_to_integer = _v8_value_to_integer; + exports._v8_value_to_number = _v8_value_to_number; + exports._v8_value_to_object = _v8_value_to_object; + exports._v8_value_to_string = _v8_value_to_string; + exports._v8_value_to_uint32 = _v8_value_to_uint32; + + return exports; + +})({}, emnapiPluginCtx); + return { + importObject: (original) => { + Object.assign(original.env, mod); + } + }; +} + +//#endregion src/emnapi/v8.js + +export { v8 as default }; diff --git a/client/node_modules/@emnapi/core/package.json b/client/node_modules/@emnapi/core/package.json new file mode 100644 index 0000000..4700765 --- /dev/null +++ b/client/node_modules/@emnapi/core/package.json @@ -0,0 +1,39 @@ +{ + "name": "@emnapi/core", + "version": "2.0.0-alpha.3", + "description": "emnapi core", + "type": "module", + "main": "./dist/emnapi-core.js", + "module": "./dist/emnapi-core.js", + "types": "./dist/emnapi-core.d.ts", + "sideEffects": false, + "exports": { + ".": "./dist/emnapi-core.js", + "./plugins": "./dist/plugins/index.js", + "./plugins/index": "./dist/plugins/index.js", + "./plugins/v8": "./dist/plugins/v8.js", + "./plugins/async-work": "./dist/plugins/async-work.js", + "./plugins/threadsafe-function": "./dist/plugins/threadsafe-function.js", + "./package.json": "./package.json" + }, + "dependencies": { + "@emnapi/wasi-threads": "2.0.1", + "tslib": "^2.4.0" + }, + "scripts": { + "build": "node ./script/build.js && rollup -c" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/toyobayashi/emnapi.git" + }, + "author": "toyobayashi", + "license": "MIT", + "bugs": { + "url": "https://github.com/toyobayashi/emnapi/issues" + }, + "homepage": "https://github.com/toyobayashi/emnapi#readme", + "publishConfig": { + "access": "public" + } +} diff --git a/client/node_modules/@emnapi/core/rollup.config.js b/client/node_modules/@emnapi/core/rollup.config.js new file mode 100644 index 0000000..74187bc --- /dev/null +++ b/client/node_modules/@emnapi/core/rollup.config.js @@ -0,0 +1,60 @@ +import { defineConfig } from '@emnapi/shared' +import pkg from './package.json' with { type: 'json' } +import { join, dirname } from 'path' +import fs from 'fs' + +const plugins = [ + ['v8', 'v8', 'emnapiCorePluginsV8'], + ['asyncWork', 'async-work', 'emnapiCorePluginsAsyncWork'], + ['tsfn', 'threadsafe-function', 'emnapiCorePluginsThreadSafeFunction'] +] + +export default [ + ...defineConfig({ + outputName: 'emnapiCore', + outputFile: 'emnapi-core', + defines: { + __VERSION__: JSON.stringify(pkg.version) + }, + external: ['@emnapi/wasi-threads'], + plugins: [ + { + name: 'rollup-plugin-create-plugin-entry', + writeBundle (outputOptions) { + const distDir = dirname(outputOptions.file) + fs.mkdirSync(join(distDir, 'plugins'), { recursive: true }) + const entryFile = join(distDir, 'plugins', 'index.js') + const dtsEntryFile = join(distDir, 'plugins', 'index.d.ts') + let content = '' + for (const [name, file] of plugins) { + content += `export { default as ${name} } from './${file}.js'\n` + } + let dtsContent = "export { PluginFactory, PluginContext, EmnapiPlugin } from '../emnapi-core'\n" + for (const [name, file] of plugins) { + dtsContent += `export { default as ${name} } from './${file}'\n` + } + fs.writeFileSync(entryFile, content, 'utf8') + fs.writeFileSync(dtsEntryFile, dtsContent, 'utf8') + } + } + ] + }), + ...defineConfig({ + outputFile: 'emnapi-core.full', + defines: { + __VERSION__: JSON.stringify(pkg.version) + }, + }), + ...plugins.flatMap(([_, name, outputName]) => defineConfig({ + outputName, + outputFile: `plugins/${name}`, + dtsEntry: `dist/types/emnapi/${name}.d.ts`, + staticDtsContent: (code) => code.replace(/\.\/index/g, '../emnapi-core'), + input: join(import.meta.dirname, `src/emnapi/${name}.js`), + compilerOptions: { + declaration: false, + declarationMap: false, + declarationDir: undefined + } + })) +] diff --git a/client/node_modules/@emnapi/runtime/LICENSE b/client/node_modules/@emnapi/runtime/LICENSE new file mode 100644 index 0000000..05a5944 --- /dev/null +++ b/client/node_modules/@emnapi/runtime/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2021-present Toyobayashi + +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. diff --git a/client/node_modules/@emnapi/runtime/README.md b/client/node_modules/@emnapi/runtime/README.md new file mode 100644 index 0000000..c98dddc --- /dev/null +++ b/client/node_modules/@emnapi/runtime/README.md @@ -0,0 +1 @@ +See [https://github.com/toyobayashi/emnapi](https://github.com/toyobayashi/emnapi) diff --git a/client/node_modules/@emnapi/runtime/dist/emnapi.d.ts b/client/node_modules/@emnapi/runtime/dist/emnapi.d.ts new file mode 100644 index 0000000..eb587a1 --- /dev/null +++ b/client/node_modules/@emnapi/runtime/dist/emnapi.d.ts @@ -0,0 +1,828 @@ +/// + +export declare type Ptr = number | bigint + +export declare interface IBuffer extends Uint8Array { + toString (encoding?: string, start?: number, end?: number): string +} + +export declare interface BufferCtor { + readonly prototype: IBuffer + /** @deprecated */ + new (...args: any[]): IBuffer + from: { + (buffer: ArrayBufferLike): IBuffer + (buffer: ArrayBufferLike, byteOffset: number, length: number): IBuffer + } + alloc: (size: number) => IBuffer + isBuffer: (obj: unknown) => obj is IBuffer +} + +export declare const enum Constant { + HOLE, + EMPTY, + UNDEFINED, + NULL, + FALSE, + TRUE, + GLOBAL, + EMPTY_STRING, +} + +export declare const enum Version { + NODE_API_SUPPORTED_VERSION_MIN = 1, + NODE_API_DEFAULT_MODULE_API_VERSION = 8, + NODE_API_SUPPORTED_VERSION_MAX = 10, + NODE_MODULE_VERSION = 127, + NAPI_VERSION_EXPERIMENTAL = 2147483647 // INT_MAX +} +// eslint-disable-next-line @typescript-eslint/no-unused-vars +export declare type Pointer = number | bigint +// eslint-disable-next-line @typescript-eslint/no-unused-vars +export declare type PointerPointer = number +export declare type FunctionPointer any> = Pointer +export declare type Const = T + +export declare type void_p = Pointer +export declare type void_pp = Pointer +export declare type bool = number +export declare type char = number +export declare type char_p = Pointer +export declare type unsigned_char = number +export declare type const_char = Const +export declare type const_char_p = Pointer +export declare type char16_t = number +export declare type const_char16_t = number +export declare type char16_t_p = Pointer +export declare type const_char16_t_p = Pointer + +export declare type short = number +export declare type unsigned_short = number +export declare type int = number +export declare type unsigned_int = number +export declare type long = number +export declare type unsigned_long = number +export declare type long_long = bigint +export declare type unsigned_long_long = bigint +export declare type float = number +export declare type double = number +export declare type long_double = number +export declare type size_t = number + +export declare type int8_t = number +export declare type uint8_t = number +export declare type int16_t = number +export declare type uint16_t = number +export declare type int32_t = number +export declare type uint32_t = number +export declare type int64_t = bigint +export declare type uint64_t = bigint +export declare type napi_env = Pointer + +export declare type napi_value = Pointer +export declare type napi_ref = Pointer +export declare type napi_deferred = Pointer +export declare type napi_handle_scope = Pointer +export declare type napi_escapable_handle_scope = Pointer + +export declare type napi_addon_register_func = FunctionPointer<(env: napi_env, exports: napi_value) => napi_value> + +export declare type napi_callback_info = Pointer +export declare type napi_callback = FunctionPointer<(env: napi_env, info: napi_callback_info) => napi_value> + +export declare interface napi_extended_error_info { + error_message: const_char_p + engine_reserved: void_p + engine_error_code: uint32_t + error_code: napi_status +} + +export declare interface napi_property_descriptor { + // One of utf8name or name should be NULL. + utf8name: const_char_p + name: napi_value + + method: napi_callback + getter: napi_callback + setter: napi_callback + value: napi_value + /* napi_property_attributes */ + attributes: number + data: void_p +} + +export declare type napi_finalize = FunctionPointer<( + env: napi_env, + finalize_data: void_p, + finalize_hint: void_p +) => void> + +export declare interface node_module { + nm_version: int32_t + nm_flags: uint32_t + nm_filename: Pointer + nm_register_func: napi_addon_register_func + nm_modname: Pointer + nm_priv: Pointer + reserved: PointerPointer +} + +export declare interface napi_node_version { + major: uint32_t + minor: uint32_t + patch: uint32_t + release: const_char_p +} + +export declare interface emnapi_emscripten_version { + major: uint32_t + minor: uint32_t + patch: uint32_t +} + +export declare const enum napi_status { + napi_ok, + napi_invalid_arg, + napi_object_expected, + napi_string_expected, + napi_name_expected, + napi_function_expected, + napi_number_expected, + napi_boolean_expected, + napi_array_expected, + napi_generic_failure, + napi_pending_exception, + napi_cancelled, + napi_escape_called_twice, + napi_handle_scope_mismatch, + napi_callback_scope_mismatch, + napi_queue_full, + napi_closing, + napi_bigint_expected, + napi_date_expected, + napi_arraybuffer_expected, + napi_detachable_arraybuffer_expected, + napi_would_deadlock, // unused + napi_no_external_buffers_allowed, + napi_cannot_run_js +} + +export declare const enum napi_property_attributes { + napi_default = 0, + napi_writable = 1 << 0, + napi_enumerable = 1 << 1, + napi_configurable = 1 << 2, + + // Used with napi_define_class to distinguish static properties + // from instance properties. Ignored by napi_define_properties. + napi_static = 1 << 10, + + /// #ifdef NAPI_EXPERIMENTAL + // Default for class methods. + napi_default_method = napi_writable | napi_configurable, + + // Default for object properties, like in JS obj[prop]. + napi_default_jsproperty = napi_writable | napi_enumerable | napi_configurable + /// #endif // NAPI_EXPERIMENTAL +} + +export declare const enum napi_valuetype { + napi_undefined, + napi_null, + napi_boolean, + napi_number, + napi_string, + napi_symbol, + napi_object, + napi_function, + napi_external, + napi_bigint +} + +export declare const enum napi_typedarray_type { + napi_int8_array, + napi_uint8_array, + napi_uint8_clamped_array, + napi_int16_array, + napi_uint16_array, + napi_int32_array, + napi_uint32_array, + napi_float32_array, + napi_float64_array, + napi_bigint64_array, + napi_biguint64_array, + napi_float16_array, +} + +export declare const enum napi_key_collection_mode { + napi_key_include_prototypes, + napi_key_own_only +} + +export declare const enum napi_key_filter { + napi_key_all_properties = 0, + napi_key_writable = 1, + napi_key_enumerable = 1 << 1, + napi_key_configurable = 1 << 2, + napi_key_skip_strings = 1 << 3, + napi_key_skip_symbols = 1 << 4 +} + +export declare const enum napi_key_conversion { + napi_key_keep_numbers, + napi_key_numbers_to_strings +} + +export declare const enum emnapi_memory_view_type { + emnapi_int8_array, + emnapi_uint8_array, + emnapi_uint8_clamped_array, + emnapi_int16_array, + emnapi_uint16_array, + emnapi_int32_array, + emnapi_uint32_array, + emnapi_float32_array, + emnapi_float64_array, + emnapi_bigint64_array, + emnapi_biguint64_array, + emnapi_float16_array, + emnapi_data_view = -1, + emnapi_buffer = -2 +} + +export declare const enum napi_threadsafe_function_call_mode { + napi_tsfn_nonblocking, + napi_tsfn_blocking +} + +export declare const enum napi_threadsafe_function_release_mode { + napi_tsfn_release, + napi_tsfn_abort +} +export declare class ArrayStore extends BaseArrayStore { + protected _allocator: IdAllocator; + constructor(initialCapacity?: number); + insert(value: T): void; + alloc

(factory: (...args: P) => T, ...args: P): T; + dealloc(id: number | bigint): void; +} + +export declare class BaseArrayStore extends Disposable_2 implements ObjectAllocator { + protected _values: [undefined, ...(T | undefined)[]]; + constructor(initialCapacity?: number); + assign(id: number | bigint, value: T): T; + deref(id: number | bigint): R | undefined; + alloc

(factory: (...args: P) => T, ...args: P): T; + dealloc(id: number | bigint): void; + dispose(): void; +} + +export declare type CleanupHookCallbackFunction = number | ((arg: number) => void); + +export declare class Context { + private _isStopping; + private _canCallIntoJs; + private _suppressDestroy; + private envStore; + refStore: Map; + private readonly refCounter?; + private readonly cleanupQueue; + readonly features: Features; + readonly isolate: Isolate; + constructor(options?: ContextOptions); + getIsolate(): Isolate; + suppressDestroy(): void; + getRuntimeVersions(): { + version: string; + NODE_API_SUPPORTED_VERSION_MAX: Version; + NAPI_VERSION_EXPERIMENTAL: Version; + NODE_API_DEFAULT_MODULE_API_VERSION: Version; + NODE_MODULE_VERSION: Version; + }; + createNotSupportWeakRefError(api: string, message: string): NotSupportWeakRefError; + createNotSupportBufferError(api: string, message: string): NotSupportBufferError; + createReference(envObject: Env, handle_id: napi_value, initialRefcount: uint32_t, ownership: ReferenceOwnership): Reference; + createReferenceWithData(envObject: Env, handle_id: napi_value, initialRefcount: uint32_t, ownership: ReferenceOwnership, data: void_p): Reference; + createReferenceWithFinalizer(envObject: Env, handle_id: napi_value, initialRefcount: uint32_t, ownership: ReferenceOwnership, finalize_callback?: napi_finalize, finalize_data?: void_p, finalize_hint?: void_p): Reference; + createResolver(): Resolver; + adjustAmountOfExternalAllocatedMemory(changeInBytes: number | bigint): bigint; + createEnv(filename: string, moduleApiVersion: number, bridge: EnvNativeBridge, nodeBinding?: any): Env; + createFunction(envObject: Env, napiCallback: (env: napi_env, info: napi_callback_info) => void_p, data: number | bigint, name: string, dynamicExecution: boolean): Function; + createTrackedFinalizer(envObject: Env, finalize_callback: napi_finalize, finalize_data: void_p, finalize_hint: void_p): TrackedFinalizer; + getCurrentScope(): HandleScope; + openScope(envObject: Env): HandleScope; + closeScope(envObject: Env, scope?: HandleScope): void; + getEnv(env: napi_env): Env | undefined; + getRef(ref: napi_ref): Reference | undefined; + getHandleScope(scope: napi_handle_scope): HandleScope | undefined; + getCallbackInfo(info: napi_callback_info): ICallbackInfo; + napiValueFromJsValue(value: unknown): number | bigint; + jsValueFromNapiValue(napiValue: number | bigint): T | undefined; + createExternal(data: number | bigint): External_2; + getExternalValue(external: External_2): number | bigint; + isExternal(value: unknown): boolean; + addCleanupHook(envObject: Env, fn: CleanupHookCallbackFunction, arg: number): void; + removeCleanupHook(envObject: Env, fn: CleanupHookCallbackFunction, arg: number): void; + runCleanup(): void; + increaseWaitingRequestCounter(): void; + decreaseWaitingRequestCounter(): void; + setCanCallIntoJs(value: boolean): void; + setStopping(value: boolean): void; + canCallIntoJs(): boolean; + getDylinkMetadata(binary: WebAssembly.Module | Uint8Array): DylinkMetadata; + destroy(): void; +} + +export declare interface ContextOptions extends IsolateOptions { +} + +export declare class CountIdAllocator extends Disposable_2 implements IdAllocator { + next: number; + constructor(initialNext?: number); + aquire(): number; + release(_: number): void; + dispose(): void; +} + +export declare class CountIdReuseAllocator extends CountIdAllocator implements IdAllocator { + private _freeList; + aquire(): number; + release(id: number): void; + dispose(): void; +} + +export declare function createContext(options?: ContextOptions): Context; + +export declare function deletePrivate(obj: any, key: Private): boolean; + +declare abstract class Disposable_2 implements globalThis.Disposable { + abstract dispose(): void; + [Symbol.dispose](): void; +} +export { Disposable_2 as Disposable } + +export declare interface DylinkMetadata { + neededDynlibs: string[]; + tlsExports: Set; + weakImports: Set; + runtimePaths: string[]; + memorySize: number; + memoryAlign: number; + tableSize: number; + tableAlign: number; +} + +export declare class EmnapiError extends Error { + constructor(message?: string); +} + +export declare abstract class Env extends Disposable_2 { + id: number | bigint; + openHandleScopes: number; + instanceData: TrackedFinalizer | null; + lastException: Persistent; + refs: number; + reflist: RefTracker; + finalizing_reflist: RefTracker; + pendingFinalizers: RefTracker[]; + moduleApiVersion: number; + filename: string; + nodeBinding?: any; + inGcFinalizer: boolean; + bridge: EnvNativeBridge; + readonly ctx: Context; + private store; + constructor(ctx: Context, store: ArrayStore, bridge: EnvNativeBridge); + canCallIntoJs(): boolean; + terminatedOrTerminating(): boolean; + ref(): void; + unref(): void; + clearLastError(): napi_status; + setLastError(error_code: napi_status, engine_error_code?: uint32_t, engine_reserved?: number): napi_status; + callIntoModule(fn: (env: Env) => T, handleException?: (envObject: Env, value: any) => void): T; + abstract callFinalizer(cb: napi_finalize, data: void_p, hint: void_p): void; + invokeFinalizerFromGC(finalizer: RefTracker): void; + checkGCAccess(): void; + enqueueFinalizer(finalizer: RefTracker): void; + dequeueFinalizer(finalizer: RefTracker): void; + deleteMe(): void; + dispose(): void; + private readonly _bindingMap; + initObjectBinding(value: S): IReferenceBinding; + getObjectBinding(value: S): IReferenceBinding; + setInstanceData(data: number, finalize_cb: number, finalize_hint: number): void; + getInstanceData(): number | bigint; +} + +export declare interface EnvNativeBridge { + address: number; + deleteEnv: (ptr: number) => void; + setLastError: (env: napi_env, error_code: napi_status, engine_error_code: uint32_t, engine_reserved: number) => void; + makeDynCall_vppp: (cb: Ptr) => (a: Ptr, b: Ptr, c: Ptr) => void; + makeDynCall_vp: (cb: Ptr) => (a: Ptr) => void; + abort: (msg?: string) => never; + wasm64?: boolean; +} + +declare interface External_2 extends Record { +} + +declare const External_2: { + new (value: number | bigint): External_2; + prototype: null; +}; +export { External_2 as External } + +export declare interface Features { + makeDynamicFunction: ((...args: any[]) => Function) | undefined; + getGlobalThis: () => typeof globalThis; + setFunctionName: ((fn: Function, name: string) => void) | undefined; + Reflect: typeof Reflect | undefined; + finalizer: boolean; + weakSymbol: boolean; + BigInt: typeof BigInt | undefined; + MessageChannel: typeof MessageChannel | undefined; + Buffer: BufferCtor | undefined; + setImmediate: (callback: () => void) => any; + withResolvers: (this: PromiseConstructor) => Resolver; +} + +export declare class Finalizer { + envObject: Env; + private _finalizeCallback; + private _finalizeData; + private _finalizeHint; + private _makeDynCall_vppp; + constructor(envObject: Env, _finalizeCallback?: napi_finalize, _finalizeData?: void_p, _finalizeHint?: void_p); + copy(): Finalizer; + move(target: Finalizer): void; + callback(): napi_finalize; + data(): void_p; + hint(): void_p; + resetEnv(): void; + resetFinalizer(): void; + callFinalizer(): void; + dispose(): void; +} + +export declare class FunctionTemplate extends Template { + callback: (info: napi_callback_info, v8FunctionCallback: Ptr) => Ptr; + v8FunctionCallback: Ptr; + data: any; + className: string | undefined; + signature: Signature | undefined; + private _instanceTemplate; + private _prototypeTemplate; + private _cached; + constructor(ctx: Isolate, callback: (info: napi_callback_info, v8FunctionCallback: Ptr) => Ptr, v8FunctionCallback: Ptr, data: any, signature?: Signature); + setClassName(name: string): void; + instanceTemplate(): ObjectTemplate; + prototypeTemplate(): ObjectTemplate; + getFunction(): (...args: any[]) => any; +} + +export declare function getDefaultContext(): Context; + +export declare function getDylinkMetadata(binary: WebAssembly.Module | Uint8Array): DylinkMetadata; + +export declare function getExternalValue(external: External_2): number | bigint; + +export declare function getInternalField(instance: object, index: number): any; + +export declare function getPrivate(obj: any, key: Private): any; + +export declare class HandleScope extends Disposable_2 { + handleStore: HandleStore; + id: number | bigint; + parent: HandleScope | null; + child: HandleScope | null; + start: number; + end: number; + private _escapeCalled; + callbackInfo: ICallbackInfo; + static create(parentScope: HandleScope | null, handleStore: HandleStore, start?: number, end?: number): HandleScope; + constructor(parentScope: HandleScope | null, handleStore: HandleStore, start?: number, end?: number); + reuse(parentScope: HandleScope): void; + add(value: V): number; + addExternal(data: number | bigint): number; + dispose(): void; + escape(handle: number): number; + escapeCalled(): boolean; +} + +export declare class HandleStore extends BaseArrayStore { + static MIN_ID: 8; + private _allocator; + private _features; + readonly refValues: Map>; + private _erase; + private _deref; + constructor(features: Features); + isOutOfScope(id: number): boolean; + deepDeref(id: number | bigint): R | undefined; + push(value: S): number; + erase(start: number, end: number, weak: boolean): void; + swap(a: number, b: number): void; +} + +export declare function hasPrivate(obj: any, key: Private): boolean; + +export declare interface ICallbackInfo { + thiz: any; + holder: any; + data: void_p; + args: ArrayLike; + fn: Function; +} + +export declare interface IdAllocator extends Disposable_2 { + aquire(): number; + release(id: number): void; +} + +export declare interface IReferenceBinding { + wrapped: number; + tag: Uint32Array | null; +} + +export declare function isExternal(object: unknown): object is External_2; + +export declare class Isolate { + private _lastException; + private _globalThis; + private _scopeStore; + private _handleStore; + private _externalMemory; + globalHandleStore: PersistentStore; + readonly features: Features; + constructor(options?: IsolateOptions); + napiValueFromJsValue(value: unknown): number | bigint; + jsValueFromNapiValue(napiValue: number | bigint): T | undefined; + deleteRefSlotValue(id: number | bigint): void; + getRefSlotValue(id: number | bigint): PersistentValueType; + setRefSlotValue(id: number | bigint, ref: PersistentValueType): void; + createReference(...args: [T] | []): Persistent; + insertRef(persistent: Persistent): void; + getRef(ref: napi_ref): Persistent | undefined; + removeRef(ref: napi_ref, force?: boolean): void; + getTryCatch(address: number | bigint): TryCatch | undefined; + pushTryCatch(address: number | bigint): TryCatch; + popTryCatch(address: number | bigint): void; + setLastException(err: any): void; + throwException(err: any): any; + hasPendingException(): boolean; + getAndClearLastException(): any; + adjustAmountOfExternalAllocatedMemory(changeInBytes: number | bigint): bigint; + createSignature(template: FunctionTemplate): Signature; + createObjectTemplate(constructor: any): ObjectTemplate; + setInternalField(obj: any, index: number, value: any): void; + getInternalField(obj: any, index: number): any; + getInternalFieldCount(obj: any): number; + createFunctionTemplate(callback: (info: napi_callback_info, v8FunctionCallback: Ptr) => Ptr, v8FunctionCallback: Ptr, data: any, signature?: Signature): FunctionTemplate; + isScopeEmpty(): boolean; + getCurrentScope(): HandleScope; + openScope(): HandleScope; + closeScope(_scope?: HandleScope): void; + getHandleScope(scope: napi_handle_scope): HandleScope | undefined; + getCallbackInfo(info: napi_callback_info): ICallbackInfo; + createExternal(data: number | bigint): External_2; + getExternalValue(external: External_2): number | bigint; + isExternal(value: unknown): boolean; + createResolver(): Resolver; + createPrivate(name: string): Private; + getOrCreateGlobalPrivate(name: string): Private; + setPrivate(obj: any, key: Private, value: any): void; + getPrivate(obj: any, key: Private): any; + hasPrivate(obj: any, key: Private): boolean; + deletePrivate(obj: any, key: Private): boolean; +} + +export declare interface IsolateOptions { + features?: Partial; + onExternalMemoryChange?: (current: bigint, old: bigint, delta: bigint) => any; +} + +export declare function isReferenceType(v: any): v is object; + +export declare const NAPI_VERSION_EXPERIMENTAL = Version.NAPI_VERSION_EXPERIMENTAL; + +export declare const NODE_API_DEFAULT_MODULE_API_VERSION = Version.NODE_API_DEFAULT_MODULE_API_VERSION; + +export declare const NODE_API_SUPPORTED_VERSION_MAX = Version.NODE_API_SUPPORTED_VERSION_MAX; + +export declare const NODE_API_SUPPORTED_VERSION_MIN = Version.NODE_API_SUPPORTED_VERSION_MIN; + +export declare class NodeEnv extends Env { + destructing: boolean; + finalizationScheduled: boolean; + constructor(ctx: Context, store: ArrayStore, bridge: EnvNativeBridge); + deleteMe(): void; + canCallIntoJs(): boolean; + triggerFatalException(err: any): void; + callbackIntoModule(enforceUncaughtExceptionPolicy: boolean, fn: (env: Env) => T): T; + callFinalizer(cb: napi_finalize, data: void_p, hint: void_p): void; + callFinalizerInternal(forceUncaught: int, cb: napi_finalize, data: void_p, hint: void_p): void; + enqueueFinalizer(finalizer: RefTracker): void; + drainFinalizerQueue(): void; +} + +export declare class NotSupportBufferError extends EmnapiError { + constructor(api: string, message: string); +} + +export declare class NotSupportWeakRefError extends EmnapiError { + constructor(api: string, message: string); +} + +export declare interface ObjectAllocator extends Disposable_2 { + deref(id: number | bigint): R | undefined; + alloc

(factory: (...args: P) => T, ...args: P): T; + dealloc(id: number | bigint): void; +} + +export declare class ObjectTemplate extends Template { + Ctor: any; + internalFieldCount: number; + private _accessors; + constructor(ctx: Isolate, Ctor?: any); + setAccessor(name: string | symbol, getterWrap: (property: Ptr, info: Ptr, getter: Ptr) => Ptr, setterWrap: (property: Ptr, value: Ptr, info: Ptr, setter: Ptr) => Ptr, getter: Ptr, setter: Ptr, data: any, attribute: number, getterSideEffectType: number, setterSideEffectType: number): void; + setInternalFieldCount(value: number): void; + applyToInstance(instance: any): void; + newInstance(_context: any): any; +} + +export declare class Persistent extends Disposable_2 { + private _param; + private _callback; + private _isolate; + id: number; + private static readonly _registry; + constructor(isolate: Isolate, ...args: [T] | []); + dispose(): void; + copy(): Persistent; + move(to: Persistent): void; + slot(): number; + getSlot(): PersistentValueType; + setSlot(ref: PersistentValueType): void; + deleteSlot(): void; + setWeak

(param: P, callback: (param: P) => void): void; + clearWeak(): void; + reset(): void; + resetTo(value: T): void; + isEmpty(): boolean; + deref(): T | undefined; +} + +export declare class PersistentStore extends ArrayStore> { + private _recyleList; + constructor(initialCapacity?: number); + markUnused(id: number | bigint): void; + recycle(): void; +} + +export declare type PersistentValueType = StrongRef | WeakRef | undefined; + +export declare class Private { + private _name; + constructor(name: string); + name(): string; + static forApi(name: string): Private; +} + +export declare class Reference extends RefTracker { + private static weakCallback; + id: number; + envObject: Env | undefined; + private ctx; + private canBeWeak; + private _refcount; + private _ownership; + static create(ctx: Context, envObject: Env, handle_id: napi_value, initialRefcount: uint32_t, ownership: ReferenceOwnership, _unused1?: void_p, _unused2?: void_p, _unused3?: void_p): Reference; + constructor(ctx: Context, envObject: Env, handle_id: napi_value, initialRefcount: uint32_t, ownership: ReferenceOwnership); + getPersistent(): Persistent; + ref(): number; + unref(): number; + deref(): any; + get(): napi_value; + resetFinalizer(): void; + data(): void_p; + refcount(): number; + ownership(): ReferenceOwnership; + protected callUserFinalizer(): void; + protected invokeFinalizerFromGC(): void; + private _setWeak; + setWeakWithData(data: T, callback: (data: T) => void): void; + clearWeak(): void; + finalize(): void; + dispose(): void; +} + +export declare enum ReferenceOwnership { + kRuntime = 0, + kUserland = 1 +} + +export declare class ReferenceWithData extends Reference { + private _data; + static create(ctx: Context, envObject: Env, value: napi_value, initialRefcount: uint32_t, ownership: ReferenceOwnership, data: void_p): ReferenceWithData; + constructor(ctx: Context, envObject: Env, value: napi_value, initialRefcount: uint32_t, ownership: ReferenceOwnership, data: void_p); + data(): void_p; +} + +export declare class ReferenceWithFinalizer extends Reference { + private _finalizer; + static create(ctx: Context, envObject: Env, value: napi_value, initialRefcount: uint32_t, ownership: ReferenceOwnership, finalize_callback: napi_finalize, finalize_data: void_p, finalize_hint: void_p): ReferenceWithFinalizer; + constructor(ctx: Context, envObject: Env, value: napi_value, initialRefcount: uint32_t, ownership: ReferenceOwnership, finalize_callback: napi_finalize, finalize_data: void_p, finalize_hint: void_p); + resetFinalizer(): void; + data(): void_p; + protected callUserFinalizer(): void; + protected invokeFinalizerFromGC(): void; + dispose(): void; +} + +export declare class RefTracker extends Disposable_2 { + dispose(): void; + finalize(): void; + protected _next: RefTracker | null; + protected _prev: RefTracker | null; + link(list: RefTracker): void; + unlink(): void; + static finalizeAll(list: RefTracker): void; +} + +export declare interface Resolver { + promise: Promise; + resolve: (value: T | PromiseLike) => void; + reject: (reason?: any) => void; +} + +export declare interface ReusableStoreValue extends Disposable_2 { + reuse(...args: any[]): void; +} + +export declare class ScopeStore extends BaseArrayStore { + private readonly _rootScope; + currentScope: HandleScope; + constructor(); + openScope(handleStore: HandleStore): HandleScope; + closeScope(): void; + isEmpty(): boolean; +} + +export declare function setInternalField(instance: object, index: number, value: any): void; + +export declare function setPrivate(obj: any, key: Private, value: any): void; + +export declare class Signature { + receiver: FunctionTemplate | undefined; + constructor(receiver: FunctionTemplate | undefined); +} + +export declare class StrongRef extends Disposable_2 { + private _value; + constructor(value: T); + deref(): T; + dispose(): void; +} + +export declare class Template { + protected ctx: Isolate; + protected _properties: Map; + constructor(ctx: Isolate); + set(name: string | symbol, value: any, attr: number): void; + protected _addPropertiesToInstance(instance: any): void; +} + +export declare class TrackedFinalizer extends RefTracker { + private _finalizer; + static create(envObject: Env, finalize_callback: napi_finalize, finalize_data: void_p, finalize_hint: void_p): TrackedFinalizer; + private constructor(); + data(): void_p; + dispose(): void; + finalize(): void; +} + +export declare class TryCatch { + static top: TryCatch | null; + private static _map; + id: number | bigint; + private _exception; + private _caught; + private _next; + constructor(id: number | bigint); + static deref(id: number | bigint): TryCatch | undefined; + static pop(): void; + isEmpty(): boolean; + hasCaught(): boolean; + exception(): any; + rethrow(ctx: Isolate): any; + setError(err: any): void; + reset(): void; + extractException(): any; +} + +export declare const version: string; + +export { } diff --git a/client/node_modules/@emnapi/runtime/dist/emnapi.js b/client/node_modules/@emnapi/runtime/dist/emnapi.js new file mode 100644 index 0000000..71cf096 --- /dev/null +++ b/client/node_modules/@emnapi/runtime/dist/emnapi.js @@ -0,0 +1,2225 @@ +//#region src/util.ts +function detectFinalizer() { + return (typeof FinalizationRegistry !== 'undefined') && (typeof WeakRef !== 'undefined'); +} +const supportFinalizer = detectFinalizer(); +function detectFeatures(features) { + const supportNewFunction = (function () { + let f; + try { + f = new Function(); + } + catch (_) { + return false; + } + return typeof f === 'function'; + })(); + const canSetFunctionName = (function () { + try { + return Boolean(Object.getOwnPropertyDescriptor(Function.prototype, 'name')?.configurable); + } + catch (_) { + return false; + } + })(); + const weakSymbol = (function () { + try { + const sym = Symbol(); + new WeakRef(sym); + new WeakMap().set(sym, undefined); + } + catch (_) { + return false; + } + return true; + })(); + const _require = (function () { + let nativeRequire; + if (typeof __webpack_public_path__ !== 'undefined') { + nativeRequire = (function () { + return typeof __non_webpack_require__ !== 'undefined' ? __non_webpack_require__ : undefined; + })(); + } + else { + nativeRequire = (function () { + return typeof __webpack_public_path__ !== 'undefined' ? (typeof __non_webpack_require__ !== 'undefined' ? __non_webpack_require__ : undefined) : (typeof require !== 'undefined' ? require : undefined); + })(); + } + return nativeRequire; + })(); + function defaultGetGlobalThis() { + if (typeof globalThis !== 'undefined') + return globalThis; + let g = (function () { return this; })(); + if (!g && supportNewFunction) { + try { + g = new Function('return this')(); + } + catch (_) { } + } + if (!g) { + if (typeof __webpack_public_path__ === 'undefined') { + if (typeof global !== 'undefined') + return global; + } + if (typeof window !== 'undefined') + return window; + if (typeof self !== 'undefined') + return self; + } + throw new Error('Unable to get globalThis'); + } + function defaultWithResolvers() { + let ok; + let err; + const promise = new this((resolve, reject) => { + ok = resolve; + err = reject; + }); + return { promise, resolve: ok, reject: err }; + } + const getGlobalThis = features && 'getGlobalThis' in features + ? (features.getGlobalThis ?? defaultGetGlobalThis) + : defaultGetGlobalThis; + const withResolvers = (features && 'withResolvers' in features) + ? (features.withResolvers ?? defaultWithResolvers) + : typeof Promise.withResolvers === 'function' + ? Promise.withResolvers + : defaultWithResolvers; + const getBuiltinModule = getGlobalThis?.().process?.getBuiltinModule ?? _require; + const ret = { + makeDynamicFunction: (supportNewFunction + ? (...args) => (new Function(...args)) + : undefined), + setFunctionName: (canSetFunctionName + ? (f, name) => { Object.defineProperty(f, 'name', { value: name }); } + : undefined), + Reflect: typeof Reflect === 'object' ? Reflect : undefined, + finalizer: detectFinalizer(), + weakSymbol, + BigInt: typeof BigInt !== 'undefined' ? BigInt : undefined, + MessageChannel: typeof MessageChannel === 'function' + ? MessageChannel + : (function () { + try { + return getBuiltinModule('worker_threads').MessageChannel; + } + catch (_) { } + return undefined; + })(), + setImmediate: typeof setImmediate === 'function' + ? setImmediate.bind(getGlobalThis()) + : function (callback) { + if (typeof callback !== 'function') { + throw new TypeError('The "callback" argument must be of type function'); + } + if (ret.MessageChannel) { + let channel = new ret.MessageChannel(); + channel.port1.onmessage = function () { + channel.port1.onmessage = null; + channel = undefined; + callback(); + }; + channel.port2.postMessage(null); + } + else { + setTimeout(callback, 0); + } + }, + Buffer: typeof Buffer === 'function' + ? Buffer + : (function () { + try { + return getBuiltinModule('buffer').Buffer; + } + catch (_) { } + return undefined; + })(), + ...features, + getGlobalThis, + withResolvers + }; + return ret; +} +function isReferenceType(v) { + return (typeof v === 'object' && v !== null) || typeof v === 'function'; +} +function getDylinkMetadata(binary) { + let offset = 0; + let end = 0; + const decoder = new TextDecoder(); + function getU8() { + return binary[offset++]; + } + function getLEB() { + let ret = 0; + let mul = 1; + while (1) { + let byte = binary[offset++]; + ret += ((byte & 0x7f) * mul); + mul *= 0x80; + if (!(byte & 0x80)) + break; + } + return ret; + } + function getString() { + let len = getLEB(); + offset += len; + return decoder.decode(binary.subarray(offset - len, offset)); + } + function getStringList() { + let count = getLEB(); + let rtn = []; + while (count--) + rtn.push(getString()); + return rtn; + } + function failIf(condition, message) { + if (condition) + throw new Error(message); + } + if (binary instanceof WebAssembly.Module) { + const dylinkSection = WebAssembly.Module.customSections(binary, 'dylink.0'); + failIf(dylinkSection.length === 0, 'need dylink section'); + binary = new Uint8Array(dylinkSection[0]); + end = binary.length; + } + else { + var int32View = new Uint32Array(new Uint8Array(binary.subarray(0, 24)).buffer); + var magicNumberFound = int32View[0] === 0x6d736100 || int32View[0] === 0x0061736d; + failIf(!magicNumberFound, 'need to see wasm magic number'); + failIf(binary[8] !== 0, 'need the dylink section to be first'); + offset = 9; + var section_size = getLEB(); + end = offset + section_size; + var name = getString(); + failIf(name !== 'dylink.0'); + } + var customSection = { + neededDynlibs: [], + tlsExports: new Set(), + weakImports: new Set(), + runtimePaths: [], + memorySize: 0, + memoryAlign: 0, + tableSize: 0, + tableAlign: 0 + }; + var WASM_DYLINK_MEM_INFO = 0x1; + var WASM_DYLINK_NEEDED = 0x2; + var WASM_DYLINK_EXPORT_INFO = 0x3; + var WASM_DYLINK_IMPORT_INFO = 0x4; + var WASM_DYLINK_RUNTIME_PATH = 0x5; + var WASM_SYMBOL_TLS = 0x100; + var WASM_SYMBOL_BINDING_MASK = 0x3; + var WASM_SYMBOL_BINDING_WEAK = 0x1; + while (offset < end) { + var subsectionType = getU8(); + var subsectionSize = getLEB(); + if (subsectionType === WASM_DYLINK_MEM_INFO) { + customSection.memorySize = getLEB(); + customSection.memoryAlign = getLEB(); + customSection.tableSize = getLEB(); + customSection.tableAlign = getLEB(); + } + else if (subsectionType === WASM_DYLINK_NEEDED) { + customSection.neededDynlibs = getStringList(); + } + else if (subsectionType === WASM_DYLINK_EXPORT_INFO) { + let count = getLEB(); + while (count--) { + let symname = getString(); + let flags = getLEB(); + if (flags & WASM_SYMBOL_TLS) { + customSection.tlsExports.add(symname); + } + } + } + else if (subsectionType === WASM_DYLINK_IMPORT_INFO) { + let count = getLEB(); + while (count--) { + getString(); + let symname = getString(); + let flags = getLEB(); + if ((flags & WASM_SYMBOL_BINDING_MASK) === WASM_SYMBOL_BINDING_WEAK) { + customSection.weakImports.add(symname); + } + } + } + else if (subsectionType === WASM_DYLINK_RUNTIME_PATH) { + customSection.runtimePaths = getStringList(); + } + else { + console.error('unknown dylink.0 subsection:', subsectionType); + offset += subsectionSize; + } + } + var tableAlign = Math.pow(2, customSection.tableAlign); + failIf(tableAlign !== 1, `invalid tableAlign ${tableAlign}`); + failIf(offset !== end); + return customSection; +} +const version = "2.0.0-alpha.3"; +const NODE_API_SUPPORTED_VERSION_MIN = 1; +const NODE_API_SUPPORTED_VERSION_MAX = 10; +const NAPI_VERSION_EXPERIMENTAL = 2147483647; +const NODE_API_DEFAULT_MODULE_API_VERSION = 8; +const NODE_MODULE_VERSION = 127; + +//#endregion src/util.ts + +//#region src/Disaposable.ts +class Disposable { +} +if (typeof Symbol.dispose === 'symbol') { + Object.defineProperty(Disposable.prototype, Symbol.dispose, { + value() { + this.dispose(); + }, + writable: true, + enumerable: false, + configurable: true + }); +} + +//#endregion src/Disaposable.ts + +//#region src/RefTracker.ts +class RefTracker extends Disposable { + constructor() { + super(...arguments); + this._next = null; + this._prev = null; + } + dispose() { } + finalize() { } + link(list) { + this._prev = list; + this._next = list._next; + if (this._next !== null) { + this._next._prev = this; + } + list._next = this; + } + unlink() { + if (this._prev !== null) { + this._prev._next = this._next; + } + if (this._next !== null) { + this._next._prev = this._prev; + } + this._prev = null; + this._next = null; + } + static finalizeAll(list) { + while (list._next !== null) { + list._next.finalize(); + } + } +} + +//#endregion src/RefTracker.ts + +//#region src/Finalizer.ts +class Finalizer { + constructor(envObject, _finalizeCallback = 0, _finalizeData = 0, _finalizeHint = 0) { + this.envObject = envObject; + this._finalizeCallback = _finalizeCallback; + this._finalizeData = _finalizeData; + this._finalizeHint = _finalizeHint; + this._makeDynCall_vppp = envObject.bridge.makeDynCall_vppp; + } + copy() { + const newFina = Object.create(Finalizer.prototype); + newFina.envObject = this.envObject; + newFina._makeDynCall_vppp = this._makeDynCall_vppp; + newFina._finalizeCallback = this._finalizeCallback; + newFina._finalizeData = this._finalizeData; + newFina._finalizeHint = this._finalizeHint; + return newFina; + } + move(target) { + target._finalizeCallback = this._finalizeCallback; + target._finalizeData = this._finalizeData; + target._finalizeHint = this._finalizeHint; + target.envObject = this.envObject; + target._makeDynCall_vppp = this._makeDynCall_vppp; + this._finalizeCallback = 0; + this._finalizeData = 0; + this._finalizeHint = 0; + this.dispose(); + } + callback() { return this._finalizeCallback; } + data() { return this._finalizeData; } + hint() { return this._finalizeHint; } + resetEnv() { + this.envObject = undefined; + } + resetFinalizer() { + this._finalizeCallback = 0; + this._finalizeData = 0; + this._finalizeHint = 0; + } + callFinalizer() { + const finalize_callback = this._finalizeCallback; + const finalize_data = this._finalizeData; + const finalize_hint = this._finalizeHint; + this.resetFinalizer(); + if (!finalize_callback) + return; + const fini = Number(finalize_callback); + if (!this.envObject) { + this._makeDynCall_vppp(fini)(0, finalize_data, finalize_hint); + } + else { + this.envObject.callFinalizer(fini, finalize_data, finalize_hint); + } + } + dispose() { + this.envObject = undefined; + this._makeDynCall_vppp = undefined; + } +} + +//#endregion src/Finalizer.ts + +//#region src/TrackedFinalizer.ts +class TrackedFinalizer extends RefTracker { + static create(envObject, finalize_callback, finalize_data, finalize_hint) { + const finalizer = new TrackedFinalizer(envObject, finalize_callback, finalize_data, finalize_hint); + finalizer.link(envObject.finalizing_reflist); + return finalizer; + } + constructor(envObject, finalize_callback, finalize_data, finalize_hint) { + super(); + this._finalizer = new Finalizer(envObject, finalize_callback, finalize_data, finalize_hint); + } + data() { + return this._finalizer.data(); + } + dispose() { + if (!this._finalizer) + return; + this.unlink(); + this._finalizer.envObject.dequeueFinalizer(this); + this._finalizer.dispose(); + this._finalizer = undefined; + super.dispose(); + } + finalize() { + this.unlink(); + let error; + let caught = false; + try { + this._finalizer.callFinalizer(); + } + catch (err) { + caught = true; + error = err; + } + this.dispose(); + if (caught) { + throw error; + } + } +} + +//#endregion src/TrackedFinalizer.ts + +//#region src/Store.ts +class CountIdAllocator extends Disposable { + constructor(initialNext = 1) { + super(); + this.next = initialNext; + } + aquire() { + return this.next++; + } + release(_) { } + dispose() { } +} +class CountIdReuseAllocator extends CountIdAllocator { + constructor() { + super(...arguments); + this._freeList = []; + } + aquire() { + if (this._freeList.length) { + return this._freeList.shift(); + } + return super.aquire(); + } + release(id) { + this._freeList.push(id); + } + dispose() { + this._freeList.length = 0; + super.dispose(); + } +} +class BaseArrayStore extends Disposable { + constructor(initialCapacity = 1) { + super(); + this._values = Array(initialCapacity); + } + assign(id, value) { + this._values[id] = value; + return value; + } + deref(id) { + return this._values[id]; + } + alloc(factory, ...args) { + return factory(...args); + } + dealloc(id) { + this._values[id] = undefined; + } + dispose() { + this._values.forEach((_, i) => this.dealloc(i)); + } +} +class ArrayStore extends BaseArrayStore { + constructor(initialCapacity = 4) { + super(initialCapacity); + this._allocator = new CountIdReuseAllocator(1); + } + insert(value) { + const id = this._allocator.aquire(); + while (id >= this._values.length) { + const cap = this._values.length; + this._values.length = cap + (cap >> 1) + 16; + } + value.id = id; + this._values[id] = value; + } + alloc(factory, ...args) { + const value = factory(...args); + this.insert(value); + return value; + } + dealloc(id) { + this._allocator.release(id); + super.dealloc(id); + } +} + +//#endregion src/Store.ts + +//#region src/Persistent.ts +class PersistentStore extends ArrayStore { + constructor(initialCapacity = 4) { + super(initialCapacity); + this._recyleList = []; + } + markUnused(id) { + this._recyleList.push(id); + } + recycle() { + while (this._recyleList.length > 0) { + const id = this._recyleList.shift(); + const persistent = this.deref(id); + persistent.dispose(); + } + } +} +class StrongRef extends Disposable { + constructor(value) { + super(); + this._value = value; + } + deref() { + return this._value; + } + dispose() { + this._value = undefined; + } +} +class Persistent extends Disposable { + constructor(isolate, ...args) { + super(); + this.id = 0; + this._isolate = isolate; + isolate.insertRef(this); + this.setSlot(args.length === 0 ? undefined : new StrongRef(args[0])); + } + dispose() { + this.reset(); + this.deleteSlot(); + this._isolate.globalHandleStore.dealloc(this.id); + this._isolate = undefined; + this.id = 0; + } + copy() { + const target = new Persistent(this._isolate); + target._param = this._param; + target._callback = this._callback; + const ref = this.getSlot(); + if (ref instanceof StrongRef) { + target.setSlot(new StrongRef(ref.deref())); + } + else if (ref instanceof WeakRef) { + const value = ref.deref(); + if (value === undefined) { + target.setSlot(undefined); + } + else { + target.setSlot(new StrongRef(value)); + target.setWeak(this._param, this._callback); + } + } + else { + target.setSlot(undefined); + } + return target; + } + move(to) { + if (this === to) + return; + to.reset(); + to._param = this._param; + to._callback = this._callback; + to._isolate = this._isolate; + to.setSlot(this.getSlot()); + this.reset(); + this.setSlot(undefined); + } + slot() { + return 0x80000000 + this.id; + } + getSlot() { + return this._isolate.getRefSlotValue(this.slot()); + } + setSlot(ref) { + this._isolate.setRefSlotValue(this.slot(), ref); + } + deleteSlot() { + this._isolate.deleteRefSlotValue(this.slot()); + } + setWeak(param, callback) { + const ref = this.getSlot(); + if (!supportFinalizer || ref === undefined || ref instanceof WeakRef) + return; + const value = ref.deref(); + try { + Persistent._registry.register(value, this, this); + const weakRef = new WeakRef(value); + ref.dispose(); + this.setSlot(weakRef); + this._param = param; + this._callback = callback; + } + catch (err) { + if (typeof value === 'symbol') ; + else { + throw err; + } + } + } + clearWeak() { + const ref = this.getSlot(); + if (!supportFinalizer || ref === undefined) + return; + if (ref instanceof WeakRef) { + try { + Persistent._registry.unregister(this); + } + catch (_) { } + this._param = undefined; + this._callback = undefined; + const value = ref.deref(); + if (value === undefined) { + this.setSlot(value); + } + else { + this.setSlot(new StrongRef(value)); + } + } + } + reset() { + if (supportFinalizer) { + try { + Persistent._registry.unregister(this); + } + catch (_) { } + } + this._param = undefined; + this._callback = undefined; + const ref = this.getSlot(); + if (ref instanceof StrongRef) { + ref.dispose(); + } + this.setSlot(undefined); + } + resetTo(value) { + this.reset(); + this.setSlot(new StrongRef(value)); + } + isEmpty() { + return this.getSlot() === undefined; + } + deref() { + const ref = this.getSlot(); + if (ref === undefined) + return undefined; + return ref.deref(); + } +} +Persistent._registry = supportFinalizer + ? new FinalizationRegistry((value) => { + value.setSlot(undefined); + const callback = value._callback; + const param = value._param; + value._callback = undefined; + value._param = undefined; + if (typeof callback === 'function') { + callback(param); + } + }) + : undefined; + +//#endregion src/Persistent.ts + +//#region src/env.ts +function handleThrow(envObject, value) { + if (envObject.terminatedOrTerminating()) { + return; + } + throw value; +} +class Env extends Disposable { + constructor(ctx, store, bridge) { + super(); + this.openHandleScopes = 0; + this.instanceData = null; + this.refs = 1; + this.reflist = new RefTracker(); + this.finalizing_reflist = new RefTracker(); + this.pendingFinalizers = []; + this.inGcFinalizer = false; + this._bindingMap = new WeakMap(); + this.ctx = ctx; + this.store = store; + this.id = 0; + this.store.insert(this); + this.lastException = new Persistent(ctx.isolate); + this.bridge = bridge; + } + canCallIntoJs() { + return true; + } + terminatedOrTerminating() { + return !this.canCallIntoJs(); + } + ref() { + this.refs++; + } + unref() { + this.refs--; + if (this.refs === 0) { + this.dispose(); + } + } + clearLastError() { + this.bridge.setLastError(this.bridge.address, 0, 0, 0); + return 0; + } + setLastError(error_code, engine_error_code = 0, engine_reserved = 0) { + this.bridge.setLastError(this.bridge.address, error_code, engine_error_code, engine_reserved); + return error_code; + } + callIntoModule(fn, handleException = handleThrow) { + const openHandleScopesBefore = this.openHandleScopes; + this.clearLastError(); + const r = fn(this); + if (openHandleScopesBefore !== this.openHandleScopes) { + this.bridge.abort('open_handle_scopes != open_handle_scopes_before'); + } + if (!this.lastException.isEmpty()) { + const err = this.lastException.deref(); + this.lastException.reset(); + handleException(this, err); + } + return r; + } + invokeFinalizerFromGC(finalizer) { + if (this.moduleApiVersion !== NAPI_VERSION_EXPERIMENTAL) { + this.enqueueFinalizer(finalizer); + } + else { + const saved = this.inGcFinalizer; + this.inGcFinalizer = true; + try { + finalizer.finalize(); + } + finally { + this.inGcFinalizer = saved; + } + } + } + checkGCAccess() { + if (this.moduleApiVersion === NAPI_VERSION_EXPERIMENTAL && this.inGcFinalizer) { + this.bridge.abort('Finalizer is calling a function that may affect GC state.\n' + + 'The finalizers are run directly from GC and must not affect GC ' + + 'state.\n' + + 'Use `node_api_post_finalizer` from inside of the finalizer to work ' + + 'around this issue.\n' + + 'It schedules the call as a new task in the event loop.'); + } + } + enqueueFinalizer(finalizer) { + if (this.pendingFinalizers.indexOf(finalizer) === -1) { + this.pendingFinalizers.push(finalizer); + } + } + dequeueFinalizer(finalizer) { + const index = this.pendingFinalizers.indexOf(finalizer); + if (index !== -1) { + this.pendingFinalizers.splice(index, 1); + } + } + deleteMe() { + RefTracker.finalizeAll(this.finalizing_reflist); + RefTracker.finalizeAll(this.reflist); + this.lastException.reset(); + this.store.dealloc(this.id); + this.bridge.deleteEnv(this.bridge.address); + } + dispose() { + if (this.id === 0) + return; + this.deleteMe(); + this.finalizing_reflist.dispose(); + this.reflist.dispose(); + this.id = 0; + } + initObjectBinding(value) { + const binding = { + wrapped: 0, + tag: null + }; + this._bindingMap.set(value, binding); + return binding; + } + getObjectBinding(value) { + if (this._bindingMap.has(value)) { + return this._bindingMap.get(value); + } + return this.initObjectBinding(value); + } + setInstanceData(data, finalize_cb, finalize_hint) { + if (this.instanceData) { + this.instanceData.dispose(); + } + this.instanceData = TrackedFinalizer.create(this, finalize_cb, data, finalize_hint); + } + getInstanceData() { + return this.instanceData ? this.instanceData.data() : 0; + } +} +class NodeEnv extends Env { + constructor(ctx, store, bridge) { + super(ctx, store, bridge); + this.destructing = false; + this.finalizationScheduled = false; + this.bridge = bridge; + } + deleteMe() { + this.destructing = true; + this.drainFinalizerQueue(); + super.deleteMe(); + } + canCallIntoJs() { + return super.canCallIntoJs() && this.ctx.canCallIntoJs(); + } + triggerFatalException(err) { + if (this.nodeBinding) { + this.nodeBinding.napi.fatalException(err); + } + else { + if (typeof process === 'object' && process !== null && typeof process._fatalException === 'function') { + const handled = process._fatalException(err); + if (!handled) { + console.error(err); + process.exit(1); + } + } + else { + throw err; + } + } + } + callbackIntoModule(enforceUncaughtExceptionPolicy, fn) { + return this.callIntoModule(fn, (envObject, err) => { + if (envObject.terminatedOrTerminating()) { + return; + } + const hasProcess = typeof process === 'object' && process !== null; + const hasForceFlag = hasProcess ? Boolean(process.execArgv && (process.execArgv.indexOf('--force-node-api-uncaught-exceptions-policy') !== -1)) : false; + if (envObject.moduleApiVersion < 10 && !hasForceFlag && !enforceUncaughtExceptionPolicy) { + const warn = hasProcess && typeof process.emitWarning === 'function' + ? process.emitWarning + : function (warning, type, code) { + if (warning instanceof Error) { + console.warn(warning.toString()); + } + else { + const prefix = code ? `[${code}] ` : ''; + console.warn(`${prefix}${type || 'Warning'}: ${warning}`); + } + }; + warn('Uncaught Node-API callback exception detected, please run node with option --force-node-api-uncaught-exceptions-policy=true to handle those exceptions properly.', 'DeprecationWarning', 'DEP0168'); + return; + } + envObject.triggerFatalException(err); + }); + } + callFinalizer(cb, data, hint) { + this.callFinalizerInternal(1, cb, data, hint); + } + callFinalizerInternal(forceUncaught, cb, data, hint) { + const f = this.bridge.makeDynCall_vppp(cb); + const env = this.bridge.address; + const scope = this.ctx.openScope(this); + try { + this.callbackIntoModule(Boolean(forceUncaught), () => { f(env, data, hint); }); + } + finally { + this.ctx.closeScope(this, scope); + } + } + enqueueFinalizer(finalizer) { + super.enqueueFinalizer(finalizer); + if (!this.finalizationScheduled && !this.destructing) { + this.finalizationScheduled = true; + this.ref(); + this.ctx.features.setImmediate(() => { + this.finalizationScheduled = false; + this.unref(); + this.drainFinalizerQueue(); + }); + } + } + drainFinalizerQueue() { + while (this.pendingFinalizers.length > 0) { + const refTracker = this.pendingFinalizers.shift(); + refTracker.finalize(); + } + } +} + +//#endregion src/env.ts + +//#region src/errors.ts +class EmnapiError extends Error { + constructor(message) { + super(message); + const ErrorConstructor = new.target; + const proto = ErrorConstructor.prototype; + if (!(this instanceof EmnapiError)) { + const setPrototypeOf = Object.setPrototypeOf; + if (typeof setPrototypeOf === 'function') { + setPrototypeOf.call(Object, this, proto); + } + else { + this.__proto__ = proto; + } + if (typeof Error.captureStackTrace === 'function') { + Error.captureStackTrace(this, ErrorConstructor); + } + } + } +} +Object.defineProperty(EmnapiError.prototype, 'name', { + configurable: true, + writable: true, + value: 'EmnapiError' +}); +class NotSupportWeakRefError extends EmnapiError { + constructor(api, message) { + super(`${api}: The current runtime does not support "FinalizationRegistry" and "WeakRef".${message ? ` ${message}` : ''}`); + } +} +Object.defineProperty(NotSupportWeakRefError.prototype, 'name', { + configurable: true, + writable: true, + value: 'NotSupportWeakRefError' +}); +class NotSupportBufferError extends EmnapiError { + constructor(api, message) { + super(`${api}: The current runtime does not support "Buffer". Consider using buffer polyfill to make sure \`globalThis.Buffer\` is defined.${message ? ` ${message}` : ''}`); + } +} +Object.defineProperty(NotSupportBufferError.prototype, 'name', { + configurable: true, + writable: true, + value: 'NotSupportBufferError' +}); + +//#endregion src/errors.ts + +//#region src/Reference.ts +var ReferenceOwnership; +(function (ReferenceOwnership) { + ReferenceOwnership[ReferenceOwnership["kRuntime"] = 0] = "kRuntime"; + ReferenceOwnership[ReferenceOwnership["kUserland"] = 1] = "kUserland"; +})(ReferenceOwnership || (ReferenceOwnership = {})); +function canBeHeldWeakly(value) { + if (!value) + return false; + const type = typeof value; + return type === 'object' || type === 'function' || type === 'symbol'; +} +class Reference extends RefTracker { + static weakCallback(ref) { + const persistent = ref.getPersistent(); + persistent.reset(); + ref.invokeFinalizerFromGC(); + } + static create(ctx, envObject, handle_id, initialRefcount, ownership, _unused1, _unused2, _unused3) { + const ref = new Reference(ctx, envObject, handle_id, initialRefcount, ownership); + if (envObject) { + ref.link(envObject.reflist); + } + return ref; + } + constructor(ctx, envObject, handle_id, initialRefcount, ownership) { + super(); + this.envObject = envObject; + this._refcount = initialRefcount; + this._ownership = ownership; + const value = envObject ? envObject.ctx.jsValueFromNapiValue(handle_id) : handle_id; + this.canBeWeak = canBeHeldWeakly(value); + this.ctx = ctx; + this.id = new Persistent(ctx.isolate, value).id; + ctx.refStore.set(this.id, this); + if (initialRefcount === 0) { + this._setWeak(); + } + } + getPersistent() { + return this.ctx.isolate.getRef(this.id); + } + ref() { + const persistent = this.getPersistent(); + if (persistent.isEmpty()) { + return 0; + } + if (++this._refcount === 1 && this.canBeWeak) { + persistent.clearWeak(); + } + return this._refcount; + } + unref() { + const persistent = this.getPersistent(); + if (persistent.isEmpty() || this._refcount === 0) { + return 0; + } + if (--this._refcount === 0) { + this._setWeak(); + } + return this._refcount; + } + deref() { + const persistent = this.getPersistent(); + return persistent.deref(); + } + get() { + const persistent = this.getPersistent(); + if (persistent.isEmpty()) { + return 0; + } + return persistent.slot(); + } + resetFinalizer() { } + data() { return 0; } + refcount() { return this._refcount; } + ownership() { return this._ownership; } + callUserFinalizer() { } + invokeFinalizerFromGC() { + this.finalize(); + } + _setWeak() { + this.setWeakWithData(this, Reference.weakCallback); + } + setWeakWithData(data, callback) { + const persistent = this.getPersistent(); + if (this.canBeWeak) { + persistent.setWeak(data, callback); + } + else { + persistent.reset(); + } + } + clearWeak() { + const persistent = this.getPersistent(); + persistent.clearWeak(); + } + finalize() { + const persistent = this.getPersistent(); + persistent.reset(); + const deleteMe = this._ownership === ReferenceOwnership.kRuntime; + this.unlink(); + this.callUserFinalizer(); + if (deleteMe) { + this.dispose(); + } + } + dispose() { + if (this.id === 0) + return; + this.unlink(); + this.ctx.isolate.removeRef(this.id); + this.ctx.refStore.delete(this.id); + super.dispose(); + this.ctx = undefined; + this.envObject = undefined; + this.id = 0; + } +} +class ReferenceWithData extends Reference { + static create(ctx, envObject, value, initialRefcount, ownership, data) { + const reference = new ReferenceWithData(ctx, envObject, value, initialRefcount, ownership, data); + if (envObject) { + reference.link(envObject.reflist); + } + return reference; + } + constructor(ctx, envObject, value, initialRefcount, ownership, data) { + super(ctx, envObject, value, initialRefcount, ownership); + this._data = data; + } + data() { + return this._data; + } +} +class ReferenceWithFinalizer extends Reference { + static create(ctx, envObject, value, initialRefcount, ownership, finalize_callback, finalize_data, finalize_hint) { + if (!envObject) { + throw new TypeError('envObject is required for ReferenceWithFinalizer'); + } + const reference = new ReferenceWithFinalizer(ctx, envObject, value, initialRefcount, ownership, finalize_callback, finalize_data, finalize_hint); + reference.link(envObject.finalizing_reflist); + return reference; + } + constructor(ctx, envObject, value, initialRefcount, ownership, finalize_callback, finalize_data, finalize_hint) { + super(ctx, envObject, value, initialRefcount, ownership); + this._finalizer = new Finalizer(envObject, finalize_callback, finalize_data, finalize_hint); + } + resetFinalizer() { + this._finalizer.resetFinalizer(); + } + data() { + return this._finalizer.data(); + } + callUserFinalizer() { + this._finalizer.callFinalizer(); + } + invokeFinalizerFromGC() { + this._finalizer.envObject.invokeFinalizerFromGC(this); + } + dispose() { + if (!this._finalizer) + return; + this._finalizer.envObject.dequeueFinalizer(this); + this._finalizer.dispose(); + super.dispose(); + this._finalizer = undefined; + } +} + +//#endregion src/Reference.ts + +//#region src/Handle.ts +class HandleStore extends BaseArrayStore { + constructor(features) { + super(HandleStore.MIN_ID); + this._features = features; + this._allocator = new CountIdAllocator(HandleStore.MIN_ID); + this.refValues = new Map(); + this._values[2] = undefined; + this._values[3] = null; + this._values[4] = false; + this._values[5] = true; + this._values[6] = features.getGlobalThis(); + this._values[7] = ''; + const _erase = (start, end) => { + for (let i = start; i < end; ++i) { + this.dealloc(i); + } + }; + this._erase = this._features.finalizer + ? this._features.weakSymbol + ? (start, end, weak) => { + if (!weak) { + _erase(start, end); + } + else { + for (let i = start; i < end; ++i) { + const value = this._values[i]; + const type = typeof value; + if ((type === 'object' && value !== null) || (type === 'function') || (type === 'symbol' && Symbol.keyFor(value) === undefined)) { + this._values[i] = new WeakRef(value); + } + } + } + } + : (start, end, weak) => { + if (!weak) { + _erase(start, end); + } + else { + for (let i = start; i < end; ++i) { + const value = this._values[i]; + const type = typeof value; + if ((type === 'object' && value !== null) || (type === 'function')) { + this._values[i] = new WeakRef(value); + } + } + } + } + : _erase; + this._deref = this._features.finalizer + ? (id) => { + id = Number(id); + if (id < 0 || id > 0x7fffffff) { + const ref = this.refValues.get(id >>> 0); + if (ref === undefined) + return undefined; + return ref.deref(); + } + const value = this._values[id]; + if (value instanceof WeakRef && this.isOutOfScope(id)) { + return value.deref(); + } + return value; + } + : (id) => { + id = Number(id); + if (id < 0 || id > 0x7fffffff) { + const ref = this.refValues.get(id >>> 0); + if (ref === undefined) + return undefined; + return ref.deref(); + } + const value = this._values[id]; + return value; + }; + } + isOutOfScope(id) { + return id >= this._allocator.next; + } + deepDeref(id) { + return this._deref(id); + } + push(value) { + const next = this._allocator.aquire(); + this._values[next] = value; + return next; + } + erase(start, end, weak) { + this._allocator.next = start; + this._erase(start, end, weak); + } + swap(a, b) { + const values = this._values; + const h = values[a]; + values[a] = values[b]; + values[b] = h; + } +} +HandleStore.MIN_ID = 8; + +//#endregion src/Handle.ts + +//#region src/External.ts +const externalValue = new WeakMap(); +function isExternal(object) { + return externalValue.has(object); +} +const External = (() => { + function External(value) { + Object.setPrototypeOf(this, null); + externalValue.set(this, value); + } + External.prototype = null; + return External; +})(); +function getExternalValue(external) { + if (!isExternal(external)) { + throw new TypeError('not external'); + } + return externalValue.get(external); +} + +//#endregion src/External.ts + +//#region src/HandleScope.ts +class HandleScope extends Disposable { + static create(parentScope, handleStore, start = parentScope?.end ?? 1, end = start) { + return new HandleScope(parentScope, handleStore, start, end); + } + constructor(parentScope, handleStore, start = parentScope?.end ?? 1, end = start) { + super(); + this._escapeCalled = false; + this.handleStore = handleStore; + this.id = 0; + this.parent = parentScope; + this.child = null; + if (parentScope !== null) + parentScope.child = this; + this.start = start; + this.end = end; + this.callbackInfo = { + thiz: undefined, + holder: undefined, + data: 0, + args: undefined, + fn: undefined + }; + } + reuse(parentScope) { + this.start = this.end = parentScope.end; + this._escapeCalled = false; + } + add(value) { + const h = this.handleStore.push(value); + this.end = h + 1; + return h; + } + addExternal(data) { + return this.add(new External(data)); + } + dispose() { + const weak = this.callbackInfo.fn === undefined; + if (!weak) { + this.callbackInfo.data = 0; + this.callbackInfo.args = undefined; + this.callbackInfo.thiz = undefined; + this.callbackInfo.holder = undefined; + this.callbackInfo.fn = undefined; + } + if (this.start === this.end) + return; + this.handleStore.erase(this.start, this.end, weak); + } + escape(handle) { + if (handle < this.start || handle >= this.end) + return handle; + if (this._escapeCalled) + return 0; + this._escapeCalled = true; + if (handle < this.start || handle >= this.end) { + return 0; + } + const id = this.start; + this.handleStore.swap(handle, id); + this.start++; + this.parent.end++; + return id; + } + escapeCalled() { + return this._escapeCalled; + } +} + +//#endregion src/HandleScope.ts + +//#region src/ScopeStore.ts +class ScopeStore extends BaseArrayStore { + constructor() { + super(); + this._rootScope = new HandleScope(null, null, 1, HandleStore.MIN_ID); + this.currentScope = this._rootScope; + } + openScope(handleStore) { + const currentScope = this.currentScope; + let scope = currentScope.child; + if (scope) { + scope.reuse(currentScope); + } + else { + scope = new HandleScope(currentScope, handleStore); + const id = currentScope.id + 1; + scope.id = id; + this._values[id] = scope; + } + this.currentScope = scope; + return scope; + } + closeScope() { + const scope = this.currentScope; + this.currentScope = scope.parent; + scope.dispose(); + } + isEmpty() { + return this.currentScope === this._rootScope; + } +} + +//#endregion src/ScopeStore.ts + +//#region src/TryCatch.ts +class TryCatch { + constructor(id) { + this.id = 0; + this._exception = undefined; + this._caught = false; + this._next = null; + this.id = id; + this._next = TryCatch.top; + TryCatch.top = this; + TryCatch._map.set(id, this); + } + static deref(id) { + return this._map.get(id); + } + static pop() { + const top = TryCatch.top; + if (top) { + TryCatch._map.delete(top.id); + TryCatch.top = top._next; + top._next = null; + top.id = 0; + top._exception = undefined; + top._caught = false; + } + } + isEmpty() { + return !this._caught; + } + hasCaught() { + return this._caught; + } + exception() { + return this._exception; + } + rethrow(ctx) { + if (this._caught) { + const e = this.extractException(); + ctx.setLastException(e); + return e; + } + return undefined; + } + setError(err) { + this._caught = true; + this._exception = err; + } + reset() { + this._caught = false; + this._exception = undefined; + } + extractException() { + const e = this._exception; + this.reset(); + return e; + } +} +TryCatch.top = null; +TryCatch._map = new Map(); + +//#endregion src/TryCatch.ts + +//#region src/Template.ts +var PropertyAttribute; +(function (PropertyAttribute) { + PropertyAttribute[PropertyAttribute["None"] = 0] = "None"; + PropertyAttribute[PropertyAttribute["ReadOnly"] = 1] = "ReadOnly"; + PropertyAttribute[PropertyAttribute["DontEnum"] = 2] = "DontEnum"; + PropertyAttribute[PropertyAttribute["DontDelete"] = 4] = "DontDelete"; +})(PropertyAttribute || (PropertyAttribute = {})); +class Template { + constructor(ctx) { + this._properties = new Map(); + this.ctx = ctx; + } + set(name, value, attr) { + this._properties.set(name, [value, attr]); + } + _addPropertiesToInstance(instance) { + this._properties.forEach((property, name) => { + const [v, attr] = property; + if (v instanceof Template) { + if ('newInstance' in v) { + Object.defineProperty(instance, name, { + value: v.newInstance(6), + writable: !(attr & 1), + enumerable: !(attr & 2), + configurable: !(attr & 4) + }); + } + else if ('getFunction' in v) { + Object.defineProperty(instance, name, { + value: v.getFunction(), + writable: !(attr & 1), + enumerable: !(attr & 2), + configurable: !(attr & 4) + }); + } + } + else { + Object.defineProperty(instance, name, { + value: v, + writable: !(attr & 1), + enumerable: !(attr & 2), + configurable: !(attr & 4) + }); + } + }); + } +} + +//#endregion src/Template.ts + +//#region src/ObjectTemplate.ts +function findHolder(obj, _target) { + return obj; +} +const internalField = new WeakMap(); +function getInternalFieldCount(instance) { + return internalField.get(instance)?.length ?? 0; +} +function getInternalField(instance, index) { + return internalField.get(instance)?.[index]; +} +function setInternalField(instance, index, value) { + let fields = internalField.get(instance); + if (fields) { + fields[index] = value; + } + else { + fields = []; + fields[index] = value; + internalField.set(instance, fields); + } +} +class ObjectTemplate extends Template { + constructor(ctx, Ctor) { + super(ctx); + this.internalFieldCount = 0; + this._accessors = new Map(); + this.Ctor = Ctor ?? Object; + } + setAccessor(name, getterWrap, setterWrap, getter, setter, data, attribute, getterSideEffectType, setterSideEffectType) { + this._accessors.set(name, { + name, + getterWrap, + setterWrap, + getter, + setter, + data, + attribute, + getterSideEffectType, + setterSideEffectType + }); + } + setInternalFieldCount(value) { + this.internalFieldCount = value; + } + applyToInstance(instance) { + internalField.set(instance, Array(this.internalFieldCount)); + this._addPropertiesToInstance(instance); + const createAccessorWrapper = (type, data, cb) => { + const { ctx } = this; + function _(value) { + const scope = ctx.openScope(); + const callbackInfo = scope.callbackInfo; + let returnValue; + try { + callbackInfo.data = data; + callbackInfo.args = type === 'getter' ? [] : [value]; + callbackInfo.thiz = this; + callbackInfo.holder = findHolder(this, _) || this; + callbackInfo.fn = _; + const ret = cb(value); + returnValue = ret ? ctx.jsValueFromNapiValue(ret) : undefined; + } + catch (err) { + ctx.throwException(err); + } + ctx.closeScope(scope); + if (ctx.hasPendingException()) { + if (TryCatch.top) { + TryCatch.top.setError(ctx.getAndClearLastException()); + } + else { + throw ctx.getAndClearLastException(); + } + } + return returnValue; + } + return _; + }; + this._accessors.forEach((config, name) => { + const { ctx } = this; + const { getterWrap, setterWrap, getter, setter, data, attribute } = config; + Object.defineProperty(instance, name, { + get: getter + ? createAccessorWrapper('getter', data, () => { + return getterWrap(ctx.napiValueFromJsValue(name), ctx.getCurrentScope().id, getter); + }).bind(instance) + : undefined, + set: setter + ? createAccessorWrapper('setter', data, (value) => { + return setterWrap(ctx.napiValueFromJsValue(name), ctx.napiValueFromJsValue(value), ctx.getCurrentScope().id, setter); + }).bind(instance) + : undefined, + enumerable: !(attribute & 2), + configurable: !(attribute & 4) + }); + }); + } + newInstance(_context) { + const { ctx, Ctor } = this; + let instance; + try { + instance = new Ctor(); + } + catch (err) { + ctx.throwException(err); + } + this.applyToInstance(instance); + return instance; + } +} + +//#endregion src/ObjectTemplate.ts + +//#region src/FunctionTemplate.ts +class Signature { + constructor(receiver) { + this.receiver = receiver; + } +} +class FunctionTemplate extends Template { + constructor(ctx, callback, v8FunctionCallback, data, signature) { + super(ctx); + this.ctx = ctx; + this.callback = callback; + this.v8FunctionCallback = v8FunctionCallback; + this.data = data; + this.className = undefined; + this.signature = signature; + this._cached = [undefined]; + } + setClassName(name) { + this.className = name; + } + instanceTemplate() { + if (!this._instanceTemplate) { + this._instanceTemplate = new ObjectTemplate(this.ctx); + } + return this._instanceTemplate; + } + prototypeTemplate() { + if (!this._prototypeTemplate) { + this._prototypeTemplate = new ObjectTemplate(this.ctx); + } + return this._prototypeTemplate; + } + getFunction() { + if (this._cached[0]) { + return this._cached[0]; + } + const { ctx, callback, v8FunctionCallback, data, signature, _instanceTemplate } = this; + function _(...args) { + if (signature && signature.receiver) { + const f = signature.receiver.getFunction(); + if (!(this instanceof f)) { + throw new TypeError('Illegal invocation'); + } + } + const scope = ctx.openScope(); + const callbackInfo = scope.callbackInfo; + let returnValue; + try { + callbackInfo.data = data; + callbackInfo.args = args; + callbackInfo.thiz = this; + callbackInfo.holder = findHolder(this, _) || this; + callbackInfo.fn = _; + if (_instanceTemplate && this instanceof _) { + _instanceTemplate.applyToInstance(this); + } + const ret = callback(ctx.getCurrentScope().id, v8FunctionCallback); + returnValue = ret ? ctx.jsValueFromNapiValue(ret) : undefined; + } + catch (err) { + if (err !== 'unwind') { + ctx.throwException(err); + } + } + finally { + ctx.closeScope(scope); + } + if (ctx.hasPendingException()) { + if (TryCatch.top) { + TryCatch.top.setError(ctx.getAndClearLastException()); + } + else { + throw ctx.getAndClearLastException(); + } + } + return returnValue; + } + if (typeof this.className === 'string') { + this.ctx.features.setFunctionName?.(_, this.className); + } + if (this._prototypeTemplate) { + this._prototypeTemplate.applyToInstance(_.prototype); + } + this._addPropertiesToInstance(_); + this._cached[0] = _; + return _; + } +} + +//#endregion src/FunctionTemplate.ts + +//#region src/Private.ts +const globalPrivateRegistry = new Map(); +const map = new WeakMap(); +class Private { + constructor(name) { + this._name = name; + } + name() { + return this._name; + } + static forApi(name) { + let privateInstance = globalPrivateRegistry.get(name); + if (!privateInstance) { + privateInstance = new Private(name); + globalPrivateRegistry.set(name, privateInstance); + } + return privateInstance; + } +} +function setPrivate(obj, key, value) { + if (!(key instanceof Private)) { + throw new TypeError('Expected key to be an instance of Private'); + } + let m = map.get(key); + if (!m) { + m = new WeakMap(); + map.set(key, m); + } + m.set(obj, value); +} +function getPrivate(obj, key) { + if (!(key instanceof Private)) { + throw new TypeError('Expected key to be an instance of Private'); + } + const m = map.get(key); + if (!m) { + return undefined; + } + return m.get(obj); +} +function hasPrivate(obj, key) { + if (!(key instanceof Private)) { + throw new TypeError('Expected key to be an instance of Private'); + } + const m = map.get(key); + if (!m) { + return false; + } + return m.has(obj); +} +function deletePrivate(obj, key) { + if (!(key instanceof Private)) { + throw new TypeError('Expected key to be an instance of Private'); + } + const m = map.get(key); + if (!m || !m.has(obj)) { + return true; + } + return m.delete(obj); +} + +//#endregion src/Private.ts + +//#region src/ExternalMemory.ts +const kMaxReasonableBytes = BigInt(1) << BigInt(60); +const kMinReasonableBytes = -kMaxReasonableBytes; +class ExternalMemory { + constructor(onChange) { + this.total = BigInt(0); + this.onChange = onChange ?? null; + } + adjust(changeInBytes) { + changeInBytes = BigInt(changeInBytes); + if (!(kMinReasonableBytes <= changeInBytes && changeInBytes < kMaxReasonableBytes)) { + throw new RangeError(`changeInBytes ${changeInBytes} is out of reasonable range`); + } + const old = this.total; + this.total += changeInBytes; + const amount = this.total; + const onChange = this.onChange; + if (changeInBytes) { + onChange?.(amount, old, changeInBytes); + } + return amount; + } +} + +//#endregion src/ExternalMemory.ts + +//#region src/Isolate.ts +class Isolate { + constructor(options) { + this.features = detectFeatures(options?.features); + this._globalThis = this.features.getGlobalThis(); + this._scopeStore = new ScopeStore(); + this._handleStore = new HandleStore(this.features); + this.globalHandleStore = new PersistentStore(); + this._lastException = new Persistent(this); + this._externalMemory = new ExternalMemory(options?.onExternalMemoryChange); + } + napiValueFromJsValue(value) { + switch (value) { + case undefined: return 2; + case null: return 3; + case false: return 4; + case true: return 5; + case '': return 7; + case this._globalThis: return 6; + default: return this._scopeStore.currentScope.add(value); + } + } + jsValueFromNapiValue(napiValue) { + return this._handleStore.deepDeref(napiValue); + } + deleteRefSlotValue(id) { + this._handleStore.refValues.delete(Number(id)); + } + getRefSlotValue(id) { + return this._handleStore.refValues.get(Number(id)); + } + setRefSlotValue(id, ref) { + this._handleStore.refValues.set(Number(id), ref); + } + createReference(...args) { + return new Persistent(this, ...args); + } + insertRef(persistent) { + this.globalHandleStore.insert(persistent); + } + getRef(ref) { + return this.globalHandleStore.deref(ref); + } + removeRef(ref, force = false) { + if (force || this._scopeStore.isEmpty()) { + const persistent = this.globalHandleStore.deref(ref); + persistent?.dispose(); + } + else { + this.globalHandleStore.markUnused(ref); + } + } + getTryCatch(address) { + return TryCatch.deref(address); + } + pushTryCatch(address) { + const tryCatch = new TryCatch(address); + return tryCatch; + } + popTryCatch(address) { + if (address !== TryCatch.top?.id) { + throw new Error('TryCatch mismatch'); + } + return TryCatch.pop(); + } + setLastException(err) { + this._lastException.resetTo(err); + } + throwException(err) { + if (TryCatch.top) { + TryCatch.top.setError(err); + } + else { + this.setLastException(err); + } + return err; + } + hasPendingException() { + return !this._lastException.isEmpty(); + } + getAndClearLastException() { + const err = this._lastException.deref(); + this._lastException.reset(); + return err; + } + adjustAmountOfExternalAllocatedMemory(changeInBytes) { + return this._externalMemory.adjust(changeInBytes); + } + createSignature(template) { + return new Signature(template); + } + createObjectTemplate(constructor) { + return new ObjectTemplate(this, constructor); + } + setInternalField(obj, index, value) { + setInternalField(obj, index, value); + } + getInternalField(obj, index) { + return getInternalField(obj, index); + } + getInternalFieldCount(obj) { + return getInternalFieldCount(obj); + } + createFunctionTemplate(callback, v8FunctionCallback, data, signature) { + const functionTemplate = new FunctionTemplate(this, callback, v8FunctionCallback, data, signature); + return functionTemplate; + } + isScopeEmpty() { + return this._scopeStore.isEmpty(); + } + getCurrentScope() { + return this._scopeStore.currentScope; + } + openScope() { + return this._scopeStore.openScope(this._handleStore); + } + closeScope(_scope) { + this._scopeStore.closeScope(); + if (this.isScopeEmpty()) { + this.globalHandleStore.recycle(); + } + } + getHandleScope(scope) { + return this._scopeStore.deref(scope); + } + getCallbackInfo(info) { + return this._scopeStore.deref(info).callbackInfo; + } + createExternal(data) { + return new External(data); + } + getExternalValue(external) { + return getExternalValue(external); + } + isExternal(value) { + return isExternal(value); + } + createResolver() { + return this.features.withResolvers.call(Promise); + } + createPrivate(name) { + return new Private(name); + } + getOrCreateGlobalPrivate(name) { + return Private.forApi(name); + } + setPrivate(obj, key, value) { + return setPrivate(obj, key, value); + } + getPrivate(obj, key) { + return getPrivate(obj, key); + } + hasPrivate(obj, key) { + return hasPrivate(obj, key); + } + deletePrivate(obj, key) { + return deletePrivate(obj, key); + } +} + +//#endregion src/Isolate.ts + +//#region src/Context.ts +const callbackWrapper = (envObject, callback) => { + const napiValue = envObject.callIntoModule(callback); + return (!napiValue) ? undefined : envObject.ctx.jsValueFromNapiValue(napiValue); +}; +const withScope = (envObject, thiz, args, data, getFunction, wrapper, callback) => { + const scope = envObject.ctx.openScope(envObject); + const callbackInfo = scope.callbackInfo; + callbackInfo.data = data; + callbackInfo.args = args; + callbackInfo.thiz = thiz; + callbackInfo.fn = getFunction; + try { + return wrapper(envObject, callback); + } + catch (e) { + if (e !== 'unwind') { + throw e; + } + } + finally { + envObject.ctx.closeScope(envObject, scope); + } +}; +class CleanupHookCallback { + constructor(envObject, fn, arg, order) { + this.envObject = envObject; + this.fn = fn; + this.arg = arg; + this.order = order; + } +} +class CleanupQueue { + constructor() { + this._cleanupHooks = []; + this._cleanupHookCounter = 0; + } + empty() { + return this._cleanupHooks.length === 0; + } + add(envObject, fn, arg) { + if (this._cleanupHooks.filter((hook) => (hook.envObject === envObject && hook.fn === fn && hook.arg === arg)).length > 0) { + throw new Error('Can not add same fn and arg twice'); + } + this._cleanupHooks.push(new CleanupHookCallback(envObject, fn, arg, this._cleanupHookCounter++)); + } + remove(envObject, fn, arg) { + for (let i = 0; i < this._cleanupHooks.length; ++i) { + const hook = this._cleanupHooks[i]; + if (hook.envObject === envObject && hook.fn === fn && hook.arg === arg) { + this._cleanupHooks.splice(i, 1); + return; + } + } + } + drain() { + const hooks = this._cleanupHooks.slice(); + hooks.sort((a, b) => (b.order - a.order)); + for (let i = 0; i < hooks.length; ++i) { + const cb = hooks[i]; + if (typeof cb.fn === 'number') { + cb.envObject.bridge.makeDynCall_vp(cb.fn)(cb.arg); + } + else { + cb.fn(cb.arg); + } + this._cleanupHooks.splice(this._cleanupHooks.indexOf(cb), 1); + } + } + dispose() { + this._cleanupHooks.length = 0; + this._cleanupHookCounter = 0; + } +} +class NodejsWaitingRequestCounter { + constructor(MessageChannel) { + this.refHandle = new MessageChannel().port1; + this.count = 0; + } + increase() { + if (this.count === 0) { + if (this.refHandle.ref) { + this.refHandle.ref(); + } + } + this.count++; + } + decrease() { + if (this.count === 0) + return; + if (this.count === 1) { + if (this.refHandle.unref) { + this.refHandle.unref(); + } + } + this.count--; + } +} +class Context { + constructor(options) { + this._isStopping = false; + this._canCallIntoJs = true; + this._suppressDestroy = false; + this.envStore = new ArrayStore(); + this.refStore = new Map(); + this.isolate = new Isolate(options); + this.features = this.isolate.features; + this.cleanupQueue = new CleanupQueue(); + if (typeof process === 'object' && process !== null && typeof process.once === 'function' && this.features.MessageChannel) { + this.refCounter = new NodejsWaitingRequestCounter(this.features.MessageChannel); + process.once('beforeExit', () => { + if (!this._suppressDestroy) { + this.destroy(); + } + }); + } + } + getIsolate() { + return this.isolate; + } + suppressDestroy() { + this._suppressDestroy = true; + } + getRuntimeVersions() { + return { + version, + NODE_API_SUPPORTED_VERSION_MAX, + NAPI_VERSION_EXPERIMENTAL, + NODE_API_DEFAULT_MODULE_API_VERSION, + NODE_MODULE_VERSION + }; + } + createNotSupportWeakRefError(api, message) { + return new NotSupportWeakRefError(api, message); + } + createNotSupportBufferError(api, message) { + return new NotSupportBufferError(api, message); + } + createReference(envObject, handle_id, initialRefcount, ownership) { + return Reference.create(this, envObject, handle_id, initialRefcount, ownership); + } + createReferenceWithData(envObject, handle_id, initialRefcount, ownership, data) { + return ReferenceWithData.create(this, envObject, handle_id, initialRefcount, ownership, data); + } + createReferenceWithFinalizer(envObject, handle_id, initialRefcount, ownership, finalize_callback = 0, finalize_data = 0, finalize_hint = 0) { + return ReferenceWithFinalizer.create(this, envObject, handle_id, initialRefcount, ownership, finalize_callback, finalize_data, finalize_hint); + } + createResolver() { + return this.isolate.createResolver(); + } + adjustAmountOfExternalAllocatedMemory(changeInBytes) { + return this.isolate.adjustAmountOfExternalAllocatedMemory(changeInBytes); + } + createEnv(filename, moduleApiVersion, bridge, nodeBinding) { + moduleApiVersion = typeof moduleApiVersion !== 'number' ? NODE_API_DEFAULT_MODULE_API_VERSION : moduleApiVersion; + if (moduleApiVersion < NODE_API_DEFAULT_MODULE_API_VERSION) { + moduleApiVersion = NODE_API_DEFAULT_MODULE_API_VERSION; + } + else if (moduleApiVersion > NODE_API_SUPPORTED_VERSION_MAX && moduleApiVersion !== NAPI_VERSION_EXPERIMENTAL) { + const errorMessage = `${filename} requires Node-API version ${moduleApiVersion}, but this version of Node.js only supports version ${NODE_API_SUPPORTED_VERSION_MAX} add-ons.`; + throw new Error(errorMessage); + } + const env = new NodeEnv(this, this.envStore, { ...bridge }); + env.filename = filename; + env.moduleApiVersion = moduleApiVersion; + env.nodeBinding = nodeBinding; + this.addCleanupHook(env, () => { env.unref(); }, 0); + return env; + } + createFunction(envObject, napiCallback, data, name, dynamicExecution) { + if (envObject.ctx !== this) { + throw new Error(`The napi_env (${envObject.bridge.address}) is not created by this context`); + } + const callback = (envObject) => { + return napiCallback(envObject.bridge.address, envObject.ctx.getCurrentScope().id); + }; + let _; + const staticFunctionWrapper = (withScope, envObject, data, callbackWrapper, callback) => { + return function (...args) { + return withScope(envObject, this, args, data, _, callbackWrapper, callback); + }; + }; + let functionWrapper; + if (name && dynamicExecution && this.features.makeDynamicFunction) { + try { + functionWrapper = this.features.makeDynamicFunction('withScope', 'envObject', 'data', 'callbackWrapper', 'callback', 'return function ' + name + '(...args){' + + 'return withScope(envObject,this,args,data,' + name + ',callbackWrapper,callback)' + + '};'); + } + catch (_) { + functionWrapper = staticFunctionWrapper; + } + } + else { + functionWrapper = staticFunctionWrapper; + } + _ = functionWrapper(withScope, envObject, data, callbackWrapper, callback); + if (functionWrapper === staticFunctionWrapper && this.features.setFunctionName && name) { + this.features.setFunctionName(_, name); + } + return _; + } + createTrackedFinalizer(envObject, finalize_callback, finalize_data, finalize_hint) { + return TrackedFinalizer.create(envObject, finalize_callback, finalize_data, finalize_hint); + } + getCurrentScope() { + return this.isolate.getCurrentScope(); + } + openScope(envObject) { + const scope = this.isolate.openScope(); + envObject.openHandleScopes++; + return scope; + } + closeScope(envObject, scope) { + this.isolate.closeScope(scope); + envObject.openHandleScopes--; + } + getEnv(env) { + return this.envStore.deref(env); + } + getRef(ref) { + return this.refStore.get(Number(ref)); + } + getHandleScope(scope) { + return this.isolate.getHandleScope(scope); + } + getCallbackInfo(info) { + return this.isolate.getCallbackInfo(info); + } + napiValueFromJsValue(value) { + return this.isolate.napiValueFromJsValue(value); + } + jsValueFromNapiValue(napiValue) { + return this.isolate.jsValueFromNapiValue(napiValue); + } + createExternal(data) { + return this.isolate.createExternal(data); + } + getExternalValue(external) { + return this.isolate.getExternalValue(external); + } + isExternal(value) { + return this.isolate.isExternal(value); + } + addCleanupHook(envObject, fn, arg) { + this.cleanupQueue.add(envObject, fn, arg); + } + removeCleanupHook(envObject, fn, arg) { + this.cleanupQueue.remove(envObject, fn, arg); + } + runCleanup() { + while (!this.cleanupQueue.empty()) { + this.cleanupQueue.drain(); + } + } + increaseWaitingRequestCounter() { + this.refCounter?.increase(); + } + decreaseWaitingRequestCounter() { + this.refCounter?.decrease(); + } + setCanCallIntoJs(value) { + this._canCallIntoJs = value; + } + setStopping(value) { + this._isStopping = value; + } + canCallIntoJs() { + return this._canCallIntoJs && !this._isStopping; + } + getDylinkMetadata(binary) { + return getDylinkMetadata(binary); + } + destroy() { + this.setStopping(true); + this.setCanCallIntoJs(false); + this.runCleanup(); + } +} +let defaultContext; +function createContext(options) { + return new Context(options); +} +function getDefaultContext() { + if (!defaultContext) { + defaultContext = createContext(); + } + return defaultContext; +} + +//#endregion src/Context.ts + +export { ArrayStore, BaseArrayStore, Context, CountIdAllocator, CountIdReuseAllocator, Disposable, EmnapiError, Env, External, Finalizer, FunctionTemplate, HandleScope, HandleStore, Isolate, NAPI_VERSION_EXPERIMENTAL, NODE_API_DEFAULT_MODULE_API_VERSION, NODE_API_SUPPORTED_VERSION_MAX, NODE_API_SUPPORTED_VERSION_MIN, NodeEnv, NotSupportBufferError, NotSupportWeakRefError, ObjectTemplate, Persistent, PersistentStore, Private, RefTracker, Reference, ReferenceOwnership, ReferenceWithData, ReferenceWithFinalizer, ScopeStore, Signature, StrongRef, Template, TrackedFinalizer, TryCatch, createContext, deletePrivate, getDefaultContext, getDylinkMetadata, getExternalValue, getInternalField, getPrivate, hasPrivate, isExternal, isReferenceType, setInternalField, setPrivate, version }; +//# sourceMappingURL=emnapi.js.map diff --git a/client/node_modules/@emnapi/runtime/dist/emnapi.js.map b/client/node_modules/@emnapi/runtime/dist/emnapi.js.map new file mode 100644 index 0000000..f3c8482 --- /dev/null +++ b/client/node_modules/@emnapi/runtime/dist/emnapi.js.map @@ -0,0 +1 @@ +{"version":3,"file":"emnapi.js","sources":["../src/util.ts","../src/Disaposable.ts","../src/RefTracker.ts","../src/Finalizer.ts","../src/TrackedFinalizer.ts","../src/Store.ts","../src/Persistent.ts","../src/env.ts","../src/errors.ts","../src/Reference.ts","../src/Handle.ts","../src/External.ts","../src/HandleScope.ts","../src/ScopeStore.ts","../src/TryCatch.ts","../src/Template.ts","../src/ObjectTemplate.ts","../src/FunctionTemplate.ts","../src/Private.ts","../src/ExternalMemory.ts","../src/Isolate.ts","../src/Context.ts"],"sourcesContent":["declare const __webpack_public_path__: any\ndeclare const __non_webpack_require__: ((id: string) => any) | undefined\ndeclare const global: typeof globalThis\n\nexport function detectFinalizer () {\n return (typeof FinalizationRegistry !== 'undefined') && (typeof WeakRef !== 'undefined')\n}\n\nexport const supportFinalizer = /*#__PURE__*/ detectFinalizer()\n\nexport interface Resolver {\n promise: Promise\n resolve: (value: T | PromiseLike) => void\n reject: (reason?: any) => void\n}\n\nexport interface Features {\n makeDynamicFunction: ((...args: any[]) => Function) | undefined\n getGlobalThis: () => typeof globalThis\n setFunctionName: ((fn: Function, name: string) => void) | undefined\n Reflect: typeof Reflect | undefined\n finalizer: boolean\n weakSymbol: boolean\n BigInt: typeof BigInt | undefined\n MessageChannel: typeof MessageChannel | undefined\n Buffer: BufferCtor | undefined\n setImmediate: (callback: () => void) => any\n withResolvers: (this: PromiseConstructor) => Resolver\n}\n\nexport function detectFeatures (features?: Partial): Features {\n const supportNewFunction = (function () {\n let f: Function\n try {\n f = new Function()\n } catch (_) {\n return false\n }\n return typeof f === 'function'\n })()\n\n const canSetFunctionName = (function () {\n try {\n return Boolean(Object.getOwnPropertyDescriptor(Function.prototype, 'name')?.configurable)\n } catch (_) {\n return false\n }\n })()\n\n const weakSymbol = (function () {\n try {\n // eslint-disable-next-line symbol-description\n const sym = Symbol()\n // eslint-disable-next-line no-new\n new WeakRef(sym as any)\n new WeakMap().set(sym as any, undefined)\n } catch (_) {\n return false\n }\n return true\n })()\n\n const _require = (function () {\n let nativeRequire\n\n if (typeof __webpack_public_path__ !== 'undefined') {\n nativeRequire = (function () {\n return typeof __non_webpack_require__ !== 'undefined' ? __non_webpack_require__ : undefined\n })()\n } else {\n nativeRequire = (function () {\n return typeof __webpack_public_path__ !== 'undefined' ? (typeof __non_webpack_require__ !== 'undefined' ? __non_webpack_require__ : undefined) : (typeof require !== 'undefined' ? require : undefined)\n })()\n }\n\n return nativeRequire\n })()\n\n function defaultGetGlobalThis (): typeof globalThis {\n if (typeof globalThis !== 'undefined') return globalThis\n\n let g = (function (this: any) { return this })()\n if (!g && supportNewFunction) {\n try {\n g = new Function('return this')()\n } catch (_) {}\n }\n\n if (!g) {\n if (typeof __webpack_public_path__ === 'undefined') {\n if (typeof global !== 'undefined') return global\n }\n if (typeof window !== 'undefined') return window\n if (typeof self !== 'undefined') return self\n }\n\n throw new Error('Unable to get globalThis')\n }\n\n function defaultWithResolvers (this: PromiseConstructor) {\n let ok: (value: T | PromiseLike) => void\n let err: (reason?: any) => void\n const promise = new this((resolve, reject) => {\n ok = resolve\n err = reject\n })\n return { promise, resolve: ok!, reject: err! }\n }\n\n const getGlobalThis = features && 'getGlobalThis' in features\n ? (features.getGlobalThis ?? defaultGetGlobalThis)\n : defaultGetGlobalThis\n\n const withResolvers = (features && 'withResolvers' in features)\n ? (features.withResolvers ?? defaultWithResolvers)\n : typeof Promise.withResolvers === 'function'\n ? Promise.withResolvers\n : defaultWithResolvers\n\n const getBuiltinModule: (id: string) => any = getGlobalThis?.().process?.getBuiltinModule ?? _require\n\n const ret: Features = {\n makeDynamicFunction: (supportNewFunction\n ? (...args: any[]) => (new Function(...args))\n : undefined),\n setFunctionName: (canSetFunctionName\n ? (f: Function, name: string) => { Object.defineProperty(f, 'name', { value: name }) }\n : undefined),\n Reflect: typeof Reflect === 'object' ? Reflect : undefined,\n finalizer: detectFinalizer(),\n weakSymbol,\n BigInt: typeof BigInt !== 'undefined' ? BigInt : undefined,\n MessageChannel: typeof MessageChannel === 'function'\n ? MessageChannel\n : (function () {\n try {\n return getBuiltinModule('worker_threads').MessageChannel\n } catch (_) {}\n\n return undefined\n })(),\n\n setImmediate: typeof setImmediate === 'function'\n ? setImmediate.bind(getGlobalThis())\n : function (callback: () => void): void {\n if (typeof callback !== 'function') {\n throw new TypeError('The \"callback\" argument must be of type function')\n }\n if (ret.MessageChannel) {\n let channel = new ret.MessageChannel()\n channel.port1.onmessage = function () {\n channel.port1.onmessage = null\n channel = undefined!\n callback()\n }\n channel.port2.postMessage(null)\n } else {\n setTimeout(callback, 0)\n }\n },\n Buffer: typeof Buffer === 'function'\n ? Buffer\n : (function () {\n try {\n return getBuiltinModule('buffer').Buffer\n } catch (_) {}\n\n return undefined\n })(),\n ...features,\n getGlobalThis,\n withResolvers\n }\n\n return ret\n}\n\nexport function isReferenceType (v: any): v is object {\n return (typeof v === 'object' && v !== null) || typeof v === 'function'\n}\n\nexport interface DylinkMetadata {\n neededDynlibs: string[]\n tlsExports: Set\n weakImports: Set\n runtimePaths: string[]\n memorySize: number\n memoryAlign: number\n tableSize: number\n tableAlign: number\n}\n\nexport function getDylinkMetadata (binary: WebAssembly.Module | Uint8Array): DylinkMetadata {\n let offset = 0\n let end = 0\n const decoder = new TextDecoder()\n\n function getU8 () {\n return (binary as Uint8Array)[offset++]\n }\n\n function getLEB () {\n let ret = 0\n let mul = 1\n while (1) {\n let byte = (binary as Uint8Array)[offset++]\n ret += ((byte & 0x7f) * mul)\n mul *= 0x80\n if (!(byte & 0x80)) break\n }\n return ret\n }\n\n function getString () {\n let len = getLEB()\n offset += len\n return decoder.decode((binary as Uint8Array).subarray(offset - len, offset))\n }\n\n function getStringList () {\n let count = getLEB()\n let rtn = []\n while (count--) rtn.push(getString())\n return rtn\n }\n\n function failIf (condition: boolean, message?: string) {\n if (condition) throw new Error(message)\n }\n\n if (binary instanceof WebAssembly.Module) {\n const dylinkSection = WebAssembly.Module.customSections(binary, 'dylink.0')\n failIf(dylinkSection.length === 0, 'need dylink section')\n binary = new Uint8Array(dylinkSection[0])\n end = (binary as Uint8Array).length\n } else {\n var int32View = new Uint32Array(new Uint8Array(binary.subarray(0, 24)).buffer)\n var magicNumberFound = int32View[0] === 0x6d736100 || int32View[0] === 0x0061736d\n failIf(!magicNumberFound, 'need to see wasm magic number') // \\0asm\n // we should see the dylink custom section right after the magic number and wasm version\n failIf(binary[8] !== 0, 'need the dylink section to be first')\n offset = 9\n var section_size = getLEB() // section size\n end = offset + section_size\n var name = getString()\n failIf(name !== 'dylink.0')\n }\n\n var customSection: DylinkMetadata = {\n neededDynlibs: [],\n tlsExports: new Set(),\n weakImports: new Set(),\n runtimePaths: [],\n memorySize: 0,\n memoryAlign: 0,\n tableSize: 0,\n tableAlign: 0\n }\n var WASM_DYLINK_MEM_INFO = 0x1\n var WASM_DYLINK_NEEDED = 0x2\n var WASM_DYLINK_EXPORT_INFO = 0x3\n var WASM_DYLINK_IMPORT_INFO = 0x4\n var WASM_DYLINK_RUNTIME_PATH = 0x5\n var WASM_SYMBOL_TLS = 0x100\n var WASM_SYMBOL_BINDING_MASK = 0x3\n var WASM_SYMBOL_BINDING_WEAK = 0x1\n while (offset < end) {\n var subsectionType = getU8()\n var subsectionSize = getLEB()\n if (subsectionType === WASM_DYLINK_MEM_INFO) {\n customSection.memorySize = getLEB()\n customSection.memoryAlign = getLEB()\n customSection.tableSize = getLEB()\n customSection.tableAlign = getLEB()\n } else if (subsectionType === WASM_DYLINK_NEEDED) {\n customSection.neededDynlibs = getStringList()\n } else if (subsectionType === WASM_DYLINK_EXPORT_INFO) {\n let count = getLEB()\n while (count--) {\n let symname = getString()\n let flags = getLEB()\n if (flags & WASM_SYMBOL_TLS) {\n customSection.tlsExports.add(symname)\n }\n }\n } else if (subsectionType === WASM_DYLINK_IMPORT_INFO) {\n let count = getLEB()\n while (count--) {\n /* var modname = */ getString()\n let symname = getString()\n let flags = getLEB()\n if ((flags & WASM_SYMBOL_BINDING_MASK) === WASM_SYMBOL_BINDING_WEAK) {\n customSection.weakImports.add(symname)\n }\n }\n } else if (subsectionType === WASM_DYLINK_RUNTIME_PATH) {\n customSection.runtimePaths = getStringList()\n } else {\n console.error('unknown dylink.0 subsection:', subsectionType)\n // unknown subsection\n offset += subsectionSize\n }\n }\n\n var tableAlign = Math.pow(2, customSection.tableAlign)\n failIf(tableAlign !== 1, `invalid tableAlign ${tableAlign}`)\n failIf(offset !== end)\n\n return customSection\n}\n\n// Versions defined in runtime\ndeclare const __VERSION__: string\nexport const version = __VERSION__\nexport const NODE_API_SUPPORTED_VERSION_MIN = Version.NODE_API_SUPPORTED_VERSION_MIN\nexport const NODE_API_SUPPORTED_VERSION_MAX = Version.NODE_API_SUPPORTED_VERSION_MAX\nexport const NAPI_VERSION_EXPERIMENTAL = Version.NAPI_VERSION_EXPERIMENTAL\nexport const NODE_API_DEFAULT_MODULE_API_VERSION = Version.NODE_API_DEFAULT_MODULE_API_VERSION\nexport const NODE_MODULE_VERSION = Version.NODE_MODULE_VERSION\n","export abstract class Disposable implements globalThis.Disposable {\n /** @virtual */\n public abstract dispose (): void\n\n // @ts-expect-error\n public [Symbol.dispose] (): void\n}\n\nif (typeof Symbol.dispose === 'symbol') {\n Object.defineProperty(Disposable.prototype, Symbol.dispose, {\n value () {\n this.dispose()\n },\n writable: true,\n enumerable: false,\n configurable: true\n })\n}\n","import { Disposable } from './Disaposable'\n\nexport class RefTracker extends Disposable {\n /** @virtual */\n public dispose (): void {}\n\n /** @virtual */\n public finalize (): void {}\n\n protected _next: RefTracker | null = null\n protected _prev: RefTracker | null = null\n\n public link (list: RefTracker): void {\n this._prev = list\n this._next = list._next\n if (this._next !== null) {\n this._next._prev = this\n }\n list._next = this\n }\n\n public unlink (): void {\n if (this._prev !== null) {\n this._prev._next = this._next\n }\n if (this._next !== null) {\n this._next._prev = this._prev\n }\n this._prev = null\n this._next = null\n }\n\n public static finalizeAll (list: RefTracker): void {\n while (list._next !== null) {\n list._next.finalize()\n }\n }\n}\n","import type { Env } from './env'\n\nexport class Finalizer {\n private _makeDynCall_vppp: (cb: Ptr) => (a: Ptr, b: Ptr, c: Ptr) => void\n\n public constructor (\n public envObject: Env,\n private _finalizeCallback: napi_finalize = 0,\n private _finalizeData: void_p = 0,\n private _finalizeHint: void_p = 0\n ) {\n this._makeDynCall_vppp = envObject.bridge.makeDynCall_vppp\n }\n\n public copy (): Finalizer {\n const newFina: Finalizer = Object.create(Finalizer.prototype)\n newFina.envObject = this.envObject\n newFina._makeDynCall_vppp = this._makeDynCall_vppp\n newFina._finalizeCallback = this._finalizeCallback\n newFina._finalizeData = this._finalizeData\n newFina._finalizeHint = this._finalizeHint\n return newFina\n }\n\n public move (target: Finalizer): void {\n target._finalizeCallback = this._finalizeCallback\n target._finalizeData = this._finalizeData\n target._finalizeHint = this._finalizeHint\n target.envObject = this.envObject\n target._makeDynCall_vppp = this._makeDynCall_vppp\n\n this._finalizeCallback = 0\n this._finalizeData = 0\n this._finalizeHint = 0\n this.dispose()\n }\n\n public callback (): napi_finalize { return this._finalizeCallback }\n public data (): void_p { return this._finalizeData }\n public hint (): void_p { return this._finalizeHint }\n\n public resetEnv (): void {\n this.envObject = undefined!\n }\n\n public resetFinalizer (): void {\n this._finalizeCallback = 0\n this._finalizeData = 0\n this._finalizeHint = 0\n }\n\n public callFinalizer (): void {\n const finalize_callback = this._finalizeCallback\n const finalize_data = this._finalizeData\n const finalize_hint = this._finalizeHint\n this.resetFinalizer()\n\n if (!finalize_callback) return\n\n const fini = Number(finalize_callback)\n if (!this.envObject) {\n this._makeDynCall_vppp(fini)(0, finalize_data, finalize_hint)\n } else {\n this.envObject.callFinalizer(fini, finalize_data, finalize_hint)\n }\n }\n\n public dispose (): void {\n this.envObject = undefined!\n this._makeDynCall_vppp = undefined!\n }\n}\n","import type { Env } from './env'\nimport { Finalizer } from './Finalizer'\nimport { RefTracker } from './RefTracker'\n\nexport class TrackedFinalizer extends RefTracker {\n private _finalizer: Finalizer\n\n public static create (\n envObject: Env,\n finalize_callback: napi_finalize,\n finalize_data: void_p,\n finalize_hint: void_p\n ): TrackedFinalizer {\n const finalizer = new TrackedFinalizer(envObject, finalize_callback, finalize_data, finalize_hint)\n finalizer.link(envObject.finalizing_reflist)\n return finalizer\n }\n\n private constructor (\n envObject: Env,\n finalize_callback: napi_finalize,\n finalize_data: void_p,\n finalize_hint: void_p\n ) {\n super()\n this._finalizer = new Finalizer(envObject, finalize_callback, finalize_data, finalize_hint)\n }\n\n public data (): void_p {\n return this._finalizer.data()\n }\n\n public override dispose (): void {\n if (!this._finalizer) return\n this.unlink()\n this._finalizer.envObject.dequeueFinalizer(this)\n this._finalizer.dispose()\n this._finalizer = undefined!\n super.dispose()\n }\n\n public override finalize (): void {\n this.unlink()\n\n let error: any\n let caught = false\n\n try {\n this._finalizer.callFinalizer()\n } catch (err) {\n caught = true\n error = err\n }\n this.dispose()\n if (caught) {\n throw error\n }\n }\n}\n","import { Disposable } from './Disaposable'\n\nexport interface ReusableStoreValue extends Disposable {\n reuse (...args: any[]): void\n}\n\nexport interface IdAllocator extends Disposable {\n aquire (): number\n release (id: number): void\n}\n\nexport class CountIdAllocator extends Disposable implements IdAllocator {\n public next: number\n\n public constructor (initialNext = 1) {\n super()\n this.next = initialNext\n }\n\n /** @virtual */\n public aquire (): number {\n return this.next++\n }\n\n /** @virtual */\n public release (_: number): void {}\n\n /** @virtual */\n public dispose (): void {}\n}\n\nexport class CountIdReuseAllocator extends CountIdAllocator implements IdAllocator {\n private _freeList: number[] = []\n\n public override aquire (): number {\n if (this._freeList.length) {\n return this._freeList.shift()!\n }\n return super.aquire()\n }\n\n public override release (id: number): void {\n this._freeList.push(id)\n }\n\n public override dispose (): void {\n this._freeList.length = 0\n super.dispose()\n }\n}\n\nexport interface ObjectAllocator extends Disposable {\n deref (id: number | bigint): R | undefined\n alloc

(factory: (...args: P) => T, ...args: P): T\n dealloc (id: number | bigint): void\n}\n\nexport class BaseArrayStore extends Disposable implements ObjectAllocator {\n protected _values: [undefined, ...(T | undefined)[]]\n\n public constructor (initialCapacity = 1) {\n super()\n this._values = Array(initialCapacity) as [undefined, ...(T | undefined)[]]\n }\n\n /** @virtual */\n public assign (id: number | bigint, value: T): T {\n this._values[id as number] = value\n return value\n }\n\n /** @virtual */\n public deref (id: number | bigint): R | undefined {\n return this._values[id as number] as R\n }\n\n /** @virtual */\n public alloc

(factory: (...args: P) => T, ...args: P): T {\n return factory(...args)\n }\n\n /** @virtual */\n public dealloc (id: number | bigint): void {\n this._values[id as number] = undefined\n }\n\n /** @virtual */\n public dispose (): void {\n this._values.forEach((_, i) => this.dealloc(i))\n }\n}\n\nexport class ArrayStore extends BaseArrayStore {\n protected _allocator: IdAllocator\n\n public constructor (initialCapacity = 4) {\n super(initialCapacity)\n this._allocator = new CountIdReuseAllocator(1)\n }\n\n public insert (value: T): void {\n const id = this._allocator.aquire()\n while (id >= this._values.length) {\n const cap = this._values.length\n this._values.length = cap + (cap >> 1) + 16\n }\n value.id = id\n this._values[id as number] = value\n }\n\n /** @virtual */\n public override alloc

(factory: (...args: P) => T, ...args: P): T {\n const value = factory(...args)\n this.insert(value)\n return value\n }\n\n /** @virtual */\n public override dealloc (id: number | bigint): void {\n this._allocator.release(id as number)\n super.dealloc(id)\n }\n}\n","import { Disposable } from './Disaposable'\nimport type { Isolate } from './Isolate'\nimport { ArrayStore } from './Store'\nimport { supportFinalizer } from './util'\n\nexport class PersistentStore extends ArrayStore> {\n private _recyleList: (number | bigint)[] = []\n\n constructor (initialCapacity: number = 4) {\n super(initialCapacity)\n }\n\n public markUnused (id: number | bigint): void {\n this._recyleList.push(id)\n }\n\n public recycle () {\n while (this._recyleList.length > 0) {\n const id = this._recyleList.shift()!\n const persistent = this.deref(id)!\n persistent.dispose()\n }\n }\n}\n\nexport class StrongRef extends Disposable {\n private _value: T\n\n constructor (value: T) {\n super()\n this._value = value\n }\n\n deref (): T {\n return this._value\n }\n\n dispose (): void {\n this._value = undefined!\n }\n}\n\nexport type PersistentValueType = StrongRef | WeakRef | undefined\n\nexport class Persistent extends Disposable {\n private _param: any\n private _callback: ((param: any) => void) | undefined\n private _isolate: Isolate\n public id: number\n\n private static readonly _registry = supportFinalizer\n ? new FinalizationRegistry((value: Persistent) => {\n value.setSlot(undefined)\n const callback = value._callback\n const param = value._param\n value._callback = undefined\n value._param = undefined\n if (typeof callback === 'function') {\n callback(param)\n }\n })\n : undefined!\n\n constructor (isolate: Isolate, ...args: [T] | []) {\n super()\n this.id = 0\n this._isolate = isolate\n isolate.insertRef(this)\n this.setSlot(args.length === 0 ? undefined : new StrongRef(args[0]))\n }\n\n override dispose (): void {\n this.reset()\n this.deleteSlot()\n this._isolate.globalHandleStore.dealloc(this.id)\n this._isolate = undefined!\n this.id = 0\n }\n\n copy (): Persistent {\n const target = new Persistent(this._isolate)\n target._param = this._param\n target._callback = this._callback\n const ref = this.getSlot()\n if (ref instanceof StrongRef) {\n target.setSlot(new StrongRef(ref.deref()))\n } else if (ref instanceof WeakRef) {\n const value = ref.deref()\n if (value === undefined) {\n target.setSlot(undefined)\n } else {\n target.setSlot(new StrongRef(value))\n target.setWeak(this._param, this._callback!)\n }\n } else {\n target.setSlot(undefined)\n }\n\n return target\n }\n\n move (to: Persistent): void {\n if (this === to) return\n to.reset()\n to._param = this._param\n to._callback = this._callback\n to._isolate = this._isolate\n to.setSlot(this.getSlot())\n this.reset()\n this.setSlot(undefined)\n }\n\n slot (): number {\n return 0x80000000 + this.id\n }\n\n getSlot (): PersistentValueType {\n return this._isolate.getRefSlotValue(this.slot())\n }\n\n setSlot (ref: PersistentValueType): void {\n this._isolate.setRefSlotValue(this.slot(), ref)\n }\n\n deleteSlot (): void {\n this._isolate.deleteRefSlotValue(this.slot())\n }\n\n setWeak

~~+ + +~~

The Fastest Directory Crawler & Globber for NodeJS

+
+ + + + + + + + +
+
+ +⚡ **The Fastest:** Nothing similar (in the NodeJS world) beats `fdir` in speed. It can easily crawl a directory containing **1 million files in < 1 second.** + +💡 **Stupidly Easy:** `fdir` uses expressive Builder pattern to build the crawler increasing code readability. + +🤖 **Zero Dependencies\*:** `fdir` only uses NodeJS `fs` & `path` modules. + +🕺 **Astonishingly Small:** < 2KB in size gzipped & minified. + +🖮 **Hackable:** Extending `fdir` is extremely simple now that the new Builder API is here. Feel free to experiment around. + +_\* `picomatch` must be installed manually by the user to support globbing._ + +## 🚄 Quickstart + +### Installation + +You can install using `npm`: + +```sh +$ npm i fdir +``` + +or Yarn: + +```sh +$ yarn add fdir +``` + +### Usage + +```ts +import { fdir } from "fdir"; + +// create the builder +const api = new fdir().withFullPaths().crawl("path/to/dir"); + +// get all files in a directory synchronously +const files = api.sync(); + +// or asynchronously +api.withPromise().then((files) => { + // do something with the result here. +}); +``` + +## Documentation: + +Documentation for all methods is available [here](/documentation.md). + +## 📊 Benchmarks: + +Please check the benchmark against the latest version [here](/BENCHMARKS.md). + +## 🙏Used by: + +`fdir` is downloaded over 200k+ times a week by projects around the world. Here's a list of some notable projects using `fdir` in production: + +> Note: if you think your project should be here, feel free to open an issue. Notable is anything with a considerable amount of GitHub stars. + +1. [rollup/plugins](https://github.com/rollup/plugins) +2. [SuperchupuDev/tinyglobby](https://github.com/SuperchupuDev/tinyglobby) +3. [pulumi/pulumi](https://github.com/pulumi/pulumi) +4. [dotenvx/dotenvx](https://github.com/dotenvx/dotenvx) +5. [mdn/yari](https://github.com/mdn/yari) +6. [streetwriters/notesnook](https://github.com/streetwriters/notesnook) +7. [imba/imba](https://github.com/imba/imba) +8. [moroshko/react-scanner](https://github.com/moroshko/react-scanner) +9. [netlify/build](https://github.com/netlify/build) +10. [yassinedoghri/astro-i18next](https://github.com/yassinedoghri/astro-i18next) +11. [selfrefactor/rambda](https://github.com/selfrefactor/rambda) +12. [whyboris/Video-Hub-App](https://github.com/whyboris/Video-Hub-App) + +## 🦮 LICENSE + +Copyright © 2024 Abdullah Atta under MIT. [Read full text here.](https://github.com/thecodrr/fdir/raw/master/LICENSE) diff --git a/client/node_modules/fdir/dist/index.cjs b/client/node_modules/fdir/dist/index.cjs new file mode 100644 index 0000000..4868ffb --- /dev/null +++ b/client/node_modules/fdir/dist/index.cjs @@ -0,0 +1,588 @@ +//#region rolldown:runtime +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) { + key = keys[i]; + if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, { + get: ((k) => from[k]).bind(null, key), + enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable + }); + } + return to; +}; +var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { + value: mod, + enumerable: true +}) : target, mod)); + +//#endregion +const path = __toESM(require("path")); +const fs = __toESM(require("fs")); + +//#region src/utils.ts +function cleanPath(path$1) { + let normalized = (0, path.normalize)(path$1); + if (normalized.length > 1 && normalized[normalized.length - 1] === path.sep) normalized = normalized.substring(0, normalized.length - 1); + return normalized; +} +const SLASHES_REGEX = /[\\/]/g; +function convertSlashes(path$1, separator) { + return path$1.replace(SLASHES_REGEX, separator); +} +const WINDOWS_ROOT_DIR_REGEX = /^[a-z]:[\\/]$/i; +function isRootDirectory(path$1) { + return path$1 === "/" || WINDOWS_ROOT_DIR_REGEX.test(path$1); +} +function normalizePath(path$1, options) { + const { resolvePaths, normalizePath: normalizePath$1, pathSeparator } = options; + const pathNeedsCleaning = process.platform === "win32" && path$1.includes("/") || path$1.startsWith("."); + if (resolvePaths) path$1 = (0, path.resolve)(path$1); + if (normalizePath$1 || pathNeedsCleaning) path$1 = cleanPath(path$1); + if (path$1 === ".") return ""; + const needsSeperator = path$1[path$1.length - 1] !== pathSeparator; + return convertSlashes(needsSeperator ? path$1 + pathSeparator : path$1, pathSeparator); +} + +//#endregion +//#region src/api/functions/join-path.ts +function joinPathWithBasePath(filename, directoryPath) { + return directoryPath + filename; +} +function joinPathWithRelativePath(root, options) { + return function(filename, directoryPath) { + const sameRoot = directoryPath.startsWith(root); + if (sameRoot) return directoryPath.slice(root.length) + filename; + else return convertSlashes((0, path.relative)(root, directoryPath), options.pathSeparator) + options.pathSeparator + filename; + }; +} +function joinPath(filename) { + return filename; +} +function joinDirectoryPath(filename, directoryPath, separator) { + return directoryPath + filename + separator; +} +function build$7(root, options) { + const { relativePaths, includeBasePath } = options; + return relativePaths && root ? joinPathWithRelativePath(root, options) : includeBasePath ? joinPathWithBasePath : joinPath; +} + +//#endregion +//#region src/api/functions/push-directory.ts +function pushDirectoryWithRelativePath(root) { + return function(directoryPath, paths) { + paths.push(directoryPath.substring(root.length) || "."); + }; +} +function pushDirectoryFilterWithRelativePath(root) { + return function(directoryPath, paths, filters) { + const relativePath = directoryPath.substring(root.length) || "."; + if (filters.every((filter) => filter(relativePath, true))) paths.push(relativePath); + }; +} +const pushDirectory = (directoryPath, paths) => { + paths.push(directoryPath || "."); +}; +const pushDirectoryFilter = (directoryPath, paths, filters) => { + const path$1 = directoryPath || "."; + if (filters.every((filter) => filter(path$1, true))) paths.push(path$1); +}; +const empty$2 = () => {}; +function build$6(root, options) { + const { includeDirs, filters, relativePaths } = options; + if (!includeDirs) return empty$2; + if (relativePaths) return filters && filters.length ? pushDirectoryFilterWithRelativePath(root) : pushDirectoryWithRelativePath(root); + return filters && filters.length ? pushDirectoryFilter : pushDirectory; +} + +//#endregion +//#region src/api/functions/push-file.ts +const pushFileFilterAndCount = (filename, _paths, counts, filters) => { + if (filters.every((filter) => filter(filename, false))) counts.files++; +}; +const pushFileFilter = (filename, paths, _counts, filters) => { + if (filters.every((filter) => filter(filename, false))) paths.push(filename); +}; +const pushFileCount = (_filename, _paths, counts, _filters) => { + counts.files++; +}; +const pushFile = (filename, paths) => { + paths.push(filename); +}; +const empty$1 = () => {}; +function build$5(options) { + const { excludeFiles, filters, onlyCounts } = options; + if (excludeFiles) return empty$1; + if (filters && filters.length) return onlyCounts ? pushFileFilterAndCount : pushFileFilter; + else if (onlyCounts) return pushFileCount; + else return pushFile; +} + +//#endregion +//#region src/api/functions/get-array.ts +const getArray = (paths) => { + return paths; +}; +const getArrayGroup = () => { + return [""].slice(0, 0); +}; +function build$4(options) { + return options.group ? getArrayGroup : getArray; +} + +//#endregion +//#region src/api/functions/group-files.ts +const groupFiles = (groups, directory, files) => { + groups.push({ + directory, + files, + dir: directory + }); +}; +const empty = () => {}; +function build$3(options) { + return options.group ? groupFiles : empty; +} + +//#endregion +//#region src/api/functions/resolve-symlink.ts +const resolveSymlinksAsync = function(path$1, state, callback$1) { + const { queue, fs: fs$1, options: { suppressErrors } } = state; + queue.enqueue(); + fs$1.realpath(path$1, (error, resolvedPath) => { + if (error) return queue.dequeue(suppressErrors ? null : error, state); + fs$1.stat(resolvedPath, (error$1, stat) => { + if (error$1) return queue.dequeue(suppressErrors ? null : error$1, state); + if (stat.isDirectory() && isRecursive(path$1, resolvedPath, state)) return queue.dequeue(null, state); + callback$1(stat, resolvedPath); + queue.dequeue(null, state); + }); + }); +}; +const resolveSymlinks = function(path$1, state, callback$1) { + const { queue, fs: fs$1, options: { suppressErrors } } = state; + queue.enqueue(); + try { + const resolvedPath = fs$1.realpathSync(path$1); + const stat = fs$1.statSync(resolvedPath); + if (stat.isDirectory() && isRecursive(path$1, resolvedPath, state)) return; + callback$1(stat, resolvedPath); + } catch (e) { + if (!suppressErrors) throw e; + } +}; +function build$2(options, isSynchronous) { + if (!options.resolveSymlinks || options.excludeSymlinks) return null; + return isSynchronous ? resolveSymlinks : resolveSymlinksAsync; +} +function isRecursive(path$1, resolved, state) { + if (state.options.useRealPaths) return isRecursiveUsingRealPaths(resolved, state); + let parent = (0, path.dirname)(path$1); + let depth = 1; + while (parent !== state.root && depth < 2) { + const resolvedPath = state.symlinks.get(parent); + const isSameRoot = !!resolvedPath && (resolvedPath === resolved || resolvedPath.startsWith(resolved) || resolved.startsWith(resolvedPath)); + if (isSameRoot) depth++; + else parent = (0, path.dirname)(parent); + } + state.symlinks.set(path$1, resolved); + return depth > 1; +} +function isRecursiveUsingRealPaths(resolved, state) { + return state.visited.includes(resolved + state.options.pathSeparator); +} + +//#endregion +//#region src/api/functions/invoke-callback.ts +const onlyCountsSync = (state) => { + return state.counts; +}; +const groupsSync = (state) => { + return state.groups; +}; +const defaultSync = (state) => { + return state.paths; +}; +const limitFilesSync = (state) => { + return state.paths.slice(0, state.options.maxFiles); +}; +const onlyCountsAsync = (state, error, callback$1) => { + report(error, callback$1, state.counts, state.options.suppressErrors); + return null; +}; +const defaultAsync = (state, error, callback$1) => { + report(error, callback$1, state.paths, state.options.suppressErrors); + return null; +}; +const limitFilesAsync = (state, error, callback$1) => { + report(error, callback$1, state.paths.slice(0, state.options.maxFiles), state.options.suppressErrors); + return null; +}; +const groupsAsync = (state, error, callback$1) => { + report(error, callback$1, state.groups, state.options.suppressErrors); + return null; +}; +function report(error, callback$1, output, suppressErrors) { + if (error && !suppressErrors) callback$1(error, output); + else callback$1(null, output); +} +function build$1(options, isSynchronous) { + const { onlyCounts, group, maxFiles } = options; + if (onlyCounts) return isSynchronous ? onlyCountsSync : onlyCountsAsync; + else if (group) return isSynchronous ? groupsSync : groupsAsync; + else if (maxFiles) return isSynchronous ? limitFilesSync : limitFilesAsync; + else return isSynchronous ? defaultSync : defaultAsync; +} + +//#endregion +//#region src/api/functions/walk-directory.ts +const readdirOpts = { withFileTypes: true }; +const walkAsync = (state, crawlPath, directoryPath, currentDepth, callback$1) => { + state.queue.enqueue(); + if (currentDepth < 0) return state.queue.dequeue(null, state); + const { fs: fs$1 } = state; + state.visited.push(crawlPath); + state.counts.directories++; + fs$1.readdir(crawlPath || ".", readdirOpts, (error, entries = []) => { + callback$1(entries, directoryPath, currentDepth); + state.queue.dequeue(state.options.suppressErrors ? null : error, state); + }); +}; +const walkSync = (state, crawlPath, directoryPath, currentDepth, callback$1) => { + const { fs: fs$1 } = state; + if (currentDepth < 0) return; + state.visited.push(crawlPath); + state.counts.directories++; + let entries = []; + try { + entries = fs$1.readdirSync(crawlPath || ".", readdirOpts); + } catch (e) { + if (!state.options.suppressErrors) throw e; + } + callback$1(entries, directoryPath, currentDepth); +}; +function build(isSynchronous) { + return isSynchronous ? walkSync : walkAsync; +} + +//#endregion +//#region src/api/queue.ts +/** +* This is a custom stateless queue to track concurrent async fs calls. +* It increments a counter whenever a call is queued and decrements it +* as soon as it completes. When the counter hits 0, it calls onQueueEmpty. +*/ +var Queue = class { + count = 0; + constructor(onQueueEmpty) { + this.onQueueEmpty = onQueueEmpty; + } + enqueue() { + this.count++; + return this.count; + } + dequeue(error, output) { + if (this.onQueueEmpty && (--this.count <= 0 || error)) { + this.onQueueEmpty(error, output); + if (error) { + output.controller.abort(); + this.onQueueEmpty = void 0; + } + } + } +}; + +//#endregion +//#region src/api/counter.ts +var Counter = class { + _files = 0; + _directories = 0; + set files(num) { + this._files = num; + } + get files() { + return this._files; + } + set directories(num) { + this._directories = num; + } + get directories() { + return this._directories; + } + /** + * @deprecated use `directories` instead + */ + /* c8 ignore next 3 */ + get dirs() { + return this._directories; + } +}; + +//#endregion +//#region src/api/aborter.ts +/** +* AbortController is not supported on Node 14 so we use this until we can drop +* support for Node 14. +*/ +var Aborter = class { + aborted = false; + abort() { + this.aborted = true; + } +}; + +//#endregion +//#region src/api/walker.ts +var Walker = class { + root; + isSynchronous; + state; + joinPath; + pushDirectory; + pushFile; + getArray; + groupFiles; + resolveSymlink; + walkDirectory; + callbackInvoker; + constructor(root, options, callback$1) { + this.isSynchronous = !callback$1; + this.callbackInvoker = build$1(options, this.isSynchronous); + this.root = normalizePath(root, options); + this.state = { + root: isRootDirectory(this.root) ? this.root : this.root.slice(0, -1), + paths: [""].slice(0, 0), + groups: [], + counts: new Counter(), + options, + queue: new Queue((error, state) => this.callbackInvoker(state, error, callback$1)), + symlinks: /* @__PURE__ */ new Map(), + visited: [""].slice(0, 0), + controller: new Aborter(), + fs: options.fs || fs + }; + this.joinPath = build$7(this.root, options); + this.pushDirectory = build$6(this.root, options); + this.pushFile = build$5(options); + this.getArray = build$4(options); + this.groupFiles = build$3(options); + this.resolveSymlink = build$2(options, this.isSynchronous); + this.walkDirectory = build(this.isSynchronous); + } + start() { + this.pushDirectory(this.root, this.state.paths, this.state.options.filters); + this.walkDirectory(this.state, this.root, this.root, this.state.options.maxDepth, this.walk); + return this.isSynchronous ? this.callbackInvoker(this.state, null) : null; + } + walk = (entries, directoryPath, depth) => { + const { paths, options: { filters, resolveSymlinks: resolveSymlinks$1, excludeSymlinks, exclude, maxFiles, signal, useRealPaths, pathSeparator }, controller } = this.state; + if (controller.aborted || signal && signal.aborted || maxFiles && paths.length > maxFiles) return; + const files = this.getArray(this.state.paths); + for (let i = 0; i < entries.length; ++i) { + const entry = entries[i]; + if (entry.isFile() || entry.isSymbolicLink() && !resolveSymlinks$1 && !excludeSymlinks) { + const filename = this.joinPath(entry.name, directoryPath); + this.pushFile(filename, files, this.state.counts, filters); + } else if (entry.isDirectory()) { + let path$1 = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator); + if (exclude && exclude(entry.name, path$1)) continue; + this.pushDirectory(path$1, paths, filters); + this.walkDirectory(this.state, path$1, path$1, depth - 1, this.walk); + } else if (this.resolveSymlink && entry.isSymbolicLink()) { + let path$1 = joinPathWithBasePath(entry.name, directoryPath); + this.resolveSymlink(path$1, this.state, (stat, resolvedPath) => { + if (stat.isDirectory()) { + resolvedPath = normalizePath(resolvedPath, this.state.options); + if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path$1 + pathSeparator)) return; + this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path$1 + pathSeparator, depth - 1, this.walk); + } else { + resolvedPath = useRealPaths ? resolvedPath : path$1; + const filename = (0, path.basename)(resolvedPath); + const directoryPath$1 = normalizePath((0, path.dirname)(resolvedPath), this.state.options); + resolvedPath = this.joinPath(filename, directoryPath$1); + this.pushFile(resolvedPath, files, this.state.counts, filters); + } + }); + } + } + this.groupFiles(this.state.groups, directoryPath, files); + }; +}; + +//#endregion +//#region src/api/async.ts +function promise(root, options) { + return new Promise((resolve$1, reject) => { + callback(root, options, (err, output) => { + if (err) return reject(err); + resolve$1(output); + }); + }); +} +function callback(root, options, callback$1) { + let walker = new Walker(root, options, callback$1); + walker.start(); +} + +//#endregion +//#region src/api/sync.ts +function sync(root, options) { + const walker = new Walker(root, options); + return walker.start(); +} + +//#endregion +//#region src/builder/api-builder.ts +var APIBuilder = class { + constructor(root, options) { + this.root = root; + this.options = options; + } + withPromise() { + return promise(this.root, this.options); + } + withCallback(cb) { + callback(this.root, this.options, cb); + } + sync() { + return sync(this.root, this.options); + } +}; + +//#endregion +//#region src/builder/index.ts +let pm = null; +/* c8 ignore next 6 */ +try { + require.resolve("picomatch"); + pm = require("picomatch"); +} catch {} +var Builder = class { + globCache = {}; + options = { + maxDepth: Infinity, + suppressErrors: true, + pathSeparator: path.sep, + filters: [] + }; + globFunction; + constructor(options) { + this.options = { + ...this.options, + ...options + }; + this.globFunction = this.options.globFunction; + } + group() { + this.options.group = true; + return this; + } + withPathSeparator(separator) { + this.options.pathSeparator = separator; + return this; + } + withBasePath() { + this.options.includeBasePath = true; + return this; + } + withRelativePaths() { + this.options.relativePaths = true; + return this; + } + withDirs() { + this.options.includeDirs = true; + return this; + } + withMaxDepth(depth) { + this.options.maxDepth = depth; + return this; + } + withMaxFiles(limit) { + this.options.maxFiles = limit; + return this; + } + withFullPaths() { + this.options.resolvePaths = true; + this.options.includeBasePath = true; + return this; + } + withErrors() { + this.options.suppressErrors = false; + return this; + } + withSymlinks({ resolvePaths = true } = {}) { + this.options.resolveSymlinks = true; + this.options.useRealPaths = resolvePaths; + return this.withFullPaths(); + } + withAbortSignal(signal) { + this.options.signal = signal; + return this; + } + normalize() { + this.options.normalizePath = true; + return this; + } + filter(predicate) { + this.options.filters.push(predicate); + return this; + } + onlyDirs() { + this.options.excludeFiles = true; + this.options.includeDirs = true; + return this; + } + exclude(predicate) { + this.options.exclude = predicate; + return this; + } + onlyCounts() { + this.options.onlyCounts = true; + return this; + } + crawl(root) { + return new APIBuilder(root || ".", this.options); + } + withGlobFunction(fn) { + this.globFunction = fn; + return this; + } + /** + * @deprecated Pass options using the constructor instead: + * ```ts + * new fdir(options).crawl("/path/to/root"); + * ``` + * This method will be removed in v7.0 + */ + /* c8 ignore next 4 */ + crawlWithOptions(root, options) { + this.options = { + ...this.options, + ...options + }; + return new APIBuilder(root || ".", this.options); + } + glob(...patterns) { + if (this.globFunction) return this.globWithOptions(patterns); + return this.globWithOptions(patterns, ...[{ dot: true }]); + } + globWithOptions(patterns, ...options) { + const globFn = this.globFunction || pm; + /* c8 ignore next 5 */ + if (!globFn) throw new Error("Please specify a glob function to use glob matching."); + var isMatch = this.globCache[patterns.join("\0")]; + if (!isMatch) { + isMatch = globFn(patterns, ...options); + this.globCache[patterns.join("\0")] = isMatch; + } + this.options.filters.push((path$1) => isMatch(path$1)); + return this; + } +}; + +//#endregion +exports.fdir = Builder; \ No newline at end of file diff --git a/client/node_modules/fdir/dist/index.d.cts b/client/node_modules/fdir/dist/index.d.cts new file mode 100644 index 0000000..f448ef5 --- /dev/null +++ b/client/node_modules/fdir/dist/index.d.cts @@ -0,0 +1,155 @@ +/// +import * as nativeFs from "fs"; +import picomatch from "picomatch"; + +//#region src/api/aborter.d.ts +/** + * AbortController is not supported on Node 14 so we use this until we can drop + * support for Node 14. + */ +declare class Aborter { + aborted: boolean; + abort(): void; +} +//#endregion +//#region src/api/queue.d.ts +type OnQueueEmptyCallback = (error: Error | null, output: WalkerState) => void; +/** + * This is a custom stateless queue to track concurrent async fs calls. + * It increments a counter whenever a call is queued and decrements it + * as soon as it completes. When the counter hits 0, it calls onQueueEmpty. + */ +declare class Queue { + private onQueueEmpty?; + count: number; + constructor(onQueueEmpty?: OnQueueEmptyCallback | undefined); + enqueue(): number; + dequeue(error: Error | null, output: WalkerState): void; +} +//#endregion +//#region src/types.d.ts +type Counts = { + files: number; + directories: number; + /** + * @deprecated use `directories` instead. Will be removed in v7.0. + */ + dirs: number; +}; +type Group = { + directory: string; + files: string[]; + /** + * @deprecated use `directory` instead. Will be removed in v7.0. + */ + dir: string; +}; +type GroupOutput = Group[]; +type OnlyCountsOutput = Counts; +type PathsOutput = string[]; +type Output = OnlyCountsOutput | PathsOutput | GroupOutput; +type FSLike = { + readdir: typeof nativeFs.readdir; + readdirSync: typeof nativeFs.readdirSync; + realpath: typeof nativeFs.realpath; + realpathSync: typeof nativeFs.realpathSync; + stat: typeof nativeFs.stat; + statSync: typeof nativeFs.statSync; +}; +type WalkerState = { + root: string; + paths: string[]; + groups: Group[]; + counts: Counts; + options: Options; + queue: Queue; + controller: Aborter; + fs: FSLike; + symlinks: Map; + visited: string[]; +}; +type ResultCallback = (error: Error | null, output: TOutput) => void; +type FilterPredicate = (path: string, isDirectory: boolean) => boolean; +type ExcludePredicate = (dirName: string, dirPath: string) => boolean; +type PathSeparator = "/" | "\\"; +type Options = { + includeBasePath?: boolean; + includeDirs?: boolean; + normalizePath?: boolean; + maxDepth: number; + maxFiles?: number; + resolvePaths?: boolean; + suppressErrors: boolean; + group?: boolean; + onlyCounts?: boolean; + filters: FilterPredicate[]; + resolveSymlinks?: boolean; + useRealPaths?: boolean; + excludeFiles?: boolean; + excludeSymlinks?: boolean; + exclude?: ExcludePredicate; + relativePaths?: boolean; + pathSeparator: PathSeparator; + signal?: AbortSignal; + globFunction?: TGlobFunction; + fs?: FSLike; +}; +type GlobMatcher = (test: string) => boolean; +type GlobFunction = (glob: string | string[], ...params: unknown[]) => GlobMatcher; +type GlobParams = T extends ((globs: string | string[], ...params: infer TParams extends unknown[]) => GlobMatcher) ? TParams : []; +//#endregion +//#region src/builder/api-builder.d.ts +declare class APIBuilder { + private readonly root; + private readonly options; + constructor(root: string, options: Options); + withPromise(): Promise; + withCallback(cb: ResultCallback): void; + sync(): TReturnType; +} +//#endregion +//#region src/builder/index.d.ts +declare class Builder { + private readonly globCache; + private options; + private globFunction?; + constructor(options?: Partial>); + group(): Builder; + withPathSeparator(separator: "/" | "\\"): this; + withBasePath(): this; + withRelativePaths(): this; + withDirs(): this; + withMaxDepth(depth: number): this; + withMaxFiles(limit: number): this; + withFullPaths(): this; + withErrors(): this; + withSymlinks({ + resolvePaths + }?: { + resolvePaths?: boolean | undefined; + }): this; + withAbortSignal(signal: AbortSignal): this; + normalize(): this; + filter(predicate: FilterPredicate): this; + onlyDirs(): this; + exclude(predicate: ExcludePredicate): this; + onlyCounts(): Builder; + crawl(root?: string): APIBuilder; + withGlobFunction(fn: TFunc): Builder; + /** + * @deprecated Pass options using the constructor instead: + * ```ts + * new fdir(options).crawl("/path/to/root"); + * ``` + * This method will be removed in v7.0 + */ + crawlWithOptions(root: string, options: Partial>): APIBuilder; + glob(...patterns: string[]): Builder; + globWithOptions(patterns: string[]): Builder; + globWithOptions(patterns: string[], ...options: GlobParams): Builder; +} +//#endregion +//#region src/index.d.ts +type Fdir = typeof Builder; +//#endregion +export { Counts, ExcludePredicate, FSLike, Fdir, FilterPredicate, GlobFunction, GlobMatcher, GlobParams, Group, GroupOutput, OnlyCountsOutput, Options, Output, PathSeparator, PathsOutput, ResultCallback, WalkerState, Builder as fdir }; \ No newline at end of file diff --git a/client/node_modules/fdir/dist/index.d.mts b/client/node_modules/fdir/dist/index.d.mts new file mode 100644 index 0000000..f448ef5 --- /dev/null +++ b/client/node_modules/fdir/dist/index.d.mts @@ -0,0 +1,155 @@ +/// +import * as nativeFs from "fs"; +import picomatch from "picomatch"; + +//#region src/api/aborter.d.ts +/** + * AbortController is not supported on Node 14 so we use this until we can drop + * support for Node 14. + */ +declare class Aborter { + aborted: boolean; + abort(): void; +} +//#endregion +//#region src/api/queue.d.ts +type OnQueueEmptyCallback = (error: Error | null, output: WalkerState) => void; +/** + * This is a custom stateless queue to track concurrent async fs calls. + * It increments a counter whenever a call is queued and decrements it + * as soon as it completes. When the counter hits 0, it calls onQueueEmpty. + */ +declare class Queue { + private onQueueEmpty?; + count: number; + constructor(onQueueEmpty?: OnQueueEmptyCallback | undefined); + enqueue(): number; + dequeue(error: Error | null, output: WalkerState): void; +} +//#endregion +//#region src/types.d.ts +type Counts = { + files: number; + directories: number; + /** + * @deprecated use `directories` instead. Will be removed in v7.0. + */ + dirs: number; +}; +type Group = { + directory: string; + files: string[]; + /** + * @deprecated use `directory` instead. Will be removed in v7.0. + */ + dir: string; +}; +type GroupOutput = Group[]; +type OnlyCountsOutput = Counts; +type PathsOutput = string[]; +type Output = OnlyCountsOutput | PathsOutput | GroupOutput; +type FSLike = { + readdir: typeof nativeFs.readdir; + readdirSync: typeof nativeFs.readdirSync; + realpath: typeof nativeFs.realpath; + realpathSync: typeof nativeFs.realpathSync; + stat: typeof nativeFs.stat; + statSync: typeof nativeFs.statSync; +}; +type WalkerState = { + root: string; + paths: string[]; + groups: Group[]; + counts: Counts; + options: Options; + queue: Queue; + controller: Aborter; + fs: FSLike; + symlinks: Map; + visited: string[]; +}; +type ResultCallback = (error: Error | null, output: TOutput) => void; +type FilterPredicate = (path: string, isDirectory: boolean) => boolean; +type ExcludePredicate = (dirName: string, dirPath: string) => boolean; +type PathSeparator = "/" | "\\"; +type Options = { + includeBasePath?: boolean; + includeDirs?: boolean; + normalizePath?: boolean; + maxDepth: number; + maxFiles?: number; + resolvePaths?: boolean; + suppressErrors: boolean; + group?: boolean; + onlyCounts?: boolean; + filters: FilterPredicate[]; + resolveSymlinks?: boolean; + useRealPaths?: boolean; + excludeFiles?: boolean; + excludeSymlinks?: boolean; + exclude?: ExcludePredicate; + relativePaths?: boolean; + pathSeparator: PathSeparator; + signal?: AbortSignal; + globFunction?: TGlobFunction; + fs?: FSLike; +}; +type GlobMatcher = (test: string) => boolean; +type GlobFunction = (glob: string | string[], ...params: unknown[]) => GlobMatcher; +type GlobParams = T extends ((globs: string | string[], ...params: infer TParams extends unknown[]) => GlobMatcher) ? TParams : []; +//#endregion +//#region src/builder/api-builder.d.ts +declare class APIBuilder { + private readonly root; + private readonly options; + constructor(root: string, options: Options); + withPromise(): Promise; + withCallback(cb: ResultCallback): void; + sync(): TReturnType; +} +//#endregion +//#region src/builder/index.d.ts +declare class Builder { + private readonly globCache; + private options; + private globFunction?; + constructor(options?: Partial>); + group(): Builder; + withPathSeparator(separator: "/" | "\\"): this; + withBasePath(): this; + withRelativePaths(): this; + withDirs(): this; + withMaxDepth(depth: number): this; + withMaxFiles(limit: number): this; + withFullPaths(): this; + withErrors(): this; + withSymlinks({ + resolvePaths + }?: { + resolvePaths?: boolean | undefined; + }): this; + withAbortSignal(signal: AbortSignal): this; + normalize(): this; + filter(predicate: FilterPredicate): this; + onlyDirs(): this; + exclude(predicate: ExcludePredicate): this; + onlyCounts(): Builder; + crawl(root?: string): APIBuilder; + withGlobFunction(fn: TFunc): Builder; + /** + * @deprecated Pass options using the constructor instead: + * ```ts + * new fdir(options).crawl("/path/to/root"); + * ``` + * This method will be removed in v7.0 + */ + crawlWithOptions(root: string, options: Partial>): APIBuilder; + glob(...patterns: string[]): Builder; + globWithOptions(patterns: string[]): Builder; + globWithOptions(patterns: string[], ...options: GlobParams): Builder; +} +//#endregion +//#region src/index.d.ts +type Fdir = typeof Builder; +//#endregion +export { Counts, ExcludePredicate, FSLike, Fdir, FilterPredicate, GlobFunction, GlobMatcher, GlobParams, Group, GroupOutput, OnlyCountsOutput, Options, Output, PathSeparator, PathsOutput, ResultCallback, WalkerState, Builder as fdir }; \ No newline at end of file diff --git a/client/node_modules/fdir/dist/index.mjs b/client/node_modules/fdir/dist/index.mjs new file mode 100644 index 0000000..5c37e09 --- /dev/null +++ b/client/node_modules/fdir/dist/index.mjs @@ -0,0 +1,570 @@ +import { createRequire } from "module"; +import { basename, dirname, normalize, relative, resolve, sep } from "path"; +import * as nativeFs from "fs"; + +//#region rolldown:runtime +var __require = /* @__PURE__ */ createRequire(import.meta.url); + +//#endregion +//#region src/utils.ts +function cleanPath(path) { + let normalized = normalize(path); + if (normalized.length > 1 && normalized[normalized.length - 1] === sep) normalized = normalized.substring(0, normalized.length - 1); + return normalized; +} +const SLASHES_REGEX = /[\\/]/g; +function convertSlashes(path, separator) { + return path.replace(SLASHES_REGEX, separator); +} +const WINDOWS_ROOT_DIR_REGEX = /^[a-z]:[\\/]$/i; +function isRootDirectory(path) { + return path === "/" || WINDOWS_ROOT_DIR_REGEX.test(path); +} +function normalizePath(path, options) { + const { resolvePaths, normalizePath: normalizePath$1, pathSeparator } = options; + const pathNeedsCleaning = process.platform === "win32" && path.includes("/") || path.startsWith("."); + if (resolvePaths) path = resolve(path); + if (normalizePath$1 || pathNeedsCleaning) path = cleanPath(path); + if (path === ".") return ""; + const needsSeperator = path[path.length - 1] !== pathSeparator; + return convertSlashes(needsSeperator ? path + pathSeparator : path, pathSeparator); +} + +//#endregion +//#region src/api/functions/join-path.ts +function joinPathWithBasePath(filename, directoryPath) { + return directoryPath + filename; +} +function joinPathWithRelativePath(root, options) { + return function(filename, directoryPath) { + const sameRoot = directoryPath.startsWith(root); + if (sameRoot) return directoryPath.slice(root.length) + filename; + else return convertSlashes(relative(root, directoryPath), options.pathSeparator) + options.pathSeparator + filename; + }; +} +function joinPath(filename) { + return filename; +} +function joinDirectoryPath(filename, directoryPath, separator) { + return directoryPath + filename + separator; +} +function build$7(root, options) { + const { relativePaths, includeBasePath } = options; + return relativePaths && root ? joinPathWithRelativePath(root, options) : includeBasePath ? joinPathWithBasePath : joinPath; +} + +//#endregion +//#region src/api/functions/push-directory.ts +function pushDirectoryWithRelativePath(root) { + return function(directoryPath, paths) { + paths.push(directoryPath.substring(root.length) || "."); + }; +} +function pushDirectoryFilterWithRelativePath(root) { + return function(directoryPath, paths, filters) { + const relativePath = directoryPath.substring(root.length) || "."; + if (filters.every((filter) => filter(relativePath, true))) paths.push(relativePath); + }; +} +const pushDirectory = (directoryPath, paths) => { + paths.push(directoryPath || "."); +}; +const pushDirectoryFilter = (directoryPath, paths, filters) => { + const path = directoryPath || "."; + if (filters.every((filter) => filter(path, true))) paths.push(path); +}; +const empty$2 = () => {}; +function build$6(root, options) { + const { includeDirs, filters, relativePaths } = options; + if (!includeDirs) return empty$2; + if (relativePaths) return filters && filters.length ? pushDirectoryFilterWithRelativePath(root) : pushDirectoryWithRelativePath(root); + return filters && filters.length ? pushDirectoryFilter : pushDirectory; +} + +//#endregion +//#region src/api/functions/push-file.ts +const pushFileFilterAndCount = (filename, _paths, counts, filters) => { + if (filters.every((filter) => filter(filename, false))) counts.files++; +}; +const pushFileFilter = (filename, paths, _counts, filters) => { + if (filters.every((filter) => filter(filename, false))) paths.push(filename); +}; +const pushFileCount = (_filename, _paths, counts, _filters) => { + counts.files++; +}; +const pushFile = (filename, paths) => { + paths.push(filename); +}; +const empty$1 = () => {}; +function build$5(options) { + const { excludeFiles, filters, onlyCounts } = options; + if (excludeFiles) return empty$1; + if (filters && filters.length) return onlyCounts ? pushFileFilterAndCount : pushFileFilter; + else if (onlyCounts) return pushFileCount; + else return pushFile; +} + +//#endregion +//#region src/api/functions/get-array.ts +const getArray = (paths) => { + return paths; +}; +const getArrayGroup = () => { + return [""].slice(0, 0); +}; +function build$4(options) { + return options.group ? getArrayGroup : getArray; +} + +//#endregion +//#region src/api/functions/group-files.ts +const groupFiles = (groups, directory, files) => { + groups.push({ + directory, + files, + dir: directory + }); +}; +const empty = () => {}; +function build$3(options) { + return options.group ? groupFiles : empty; +} + +//#endregion +//#region src/api/functions/resolve-symlink.ts +const resolveSymlinksAsync = function(path, state, callback$1) { + const { queue, fs, options: { suppressErrors } } = state; + queue.enqueue(); + fs.realpath(path, (error, resolvedPath) => { + if (error) return queue.dequeue(suppressErrors ? null : error, state); + fs.stat(resolvedPath, (error$1, stat) => { + if (error$1) return queue.dequeue(suppressErrors ? null : error$1, state); + if (stat.isDirectory() && isRecursive(path, resolvedPath, state)) return queue.dequeue(null, state); + callback$1(stat, resolvedPath); + queue.dequeue(null, state); + }); + }); +}; +const resolveSymlinks = function(path, state, callback$1) { + const { queue, fs, options: { suppressErrors } } = state; + queue.enqueue(); + try { + const resolvedPath = fs.realpathSync(path); + const stat = fs.statSync(resolvedPath); + if (stat.isDirectory() && isRecursive(path, resolvedPath, state)) return; + callback$1(stat, resolvedPath); + } catch (e) { + if (!suppressErrors) throw e; + } +}; +function build$2(options, isSynchronous) { + if (!options.resolveSymlinks || options.excludeSymlinks) return null; + return isSynchronous ? resolveSymlinks : resolveSymlinksAsync; +} +function isRecursive(path, resolved, state) { + if (state.options.useRealPaths) return isRecursiveUsingRealPaths(resolved, state); + let parent = dirname(path); + let depth = 1; + while (parent !== state.root && depth < 2) { + const resolvedPath = state.symlinks.get(parent); + const isSameRoot = !!resolvedPath && (resolvedPath === resolved || resolvedPath.startsWith(resolved) || resolved.startsWith(resolvedPath)); + if (isSameRoot) depth++; + else parent = dirname(parent); + } + state.symlinks.set(path, resolved); + return depth > 1; +} +function isRecursiveUsingRealPaths(resolved, state) { + return state.visited.includes(resolved + state.options.pathSeparator); +} + +//#endregion +//#region src/api/functions/invoke-callback.ts +const onlyCountsSync = (state) => { + return state.counts; +}; +const groupsSync = (state) => { + return state.groups; +}; +const defaultSync = (state) => { + return state.paths; +}; +const limitFilesSync = (state) => { + return state.paths.slice(0, state.options.maxFiles); +}; +const onlyCountsAsync = (state, error, callback$1) => { + report(error, callback$1, state.counts, state.options.suppressErrors); + return null; +}; +const defaultAsync = (state, error, callback$1) => { + report(error, callback$1, state.paths, state.options.suppressErrors); + return null; +}; +const limitFilesAsync = (state, error, callback$1) => { + report(error, callback$1, state.paths.slice(0, state.options.maxFiles), state.options.suppressErrors); + return null; +}; +const groupsAsync = (state, error, callback$1) => { + report(error, callback$1, state.groups, state.options.suppressErrors); + return null; +}; +function report(error, callback$1, output, suppressErrors) { + if (error && !suppressErrors) callback$1(error, output); + else callback$1(null, output); +} +function build$1(options, isSynchronous) { + const { onlyCounts, group, maxFiles } = options; + if (onlyCounts) return isSynchronous ? onlyCountsSync : onlyCountsAsync; + else if (group) return isSynchronous ? groupsSync : groupsAsync; + else if (maxFiles) return isSynchronous ? limitFilesSync : limitFilesAsync; + else return isSynchronous ? defaultSync : defaultAsync; +} + +//#endregion +//#region src/api/functions/walk-directory.ts +const readdirOpts = { withFileTypes: true }; +const walkAsync = (state, crawlPath, directoryPath, currentDepth, callback$1) => { + state.queue.enqueue(); + if (currentDepth < 0) return state.queue.dequeue(null, state); + const { fs } = state; + state.visited.push(crawlPath); + state.counts.directories++; + fs.readdir(crawlPath || ".", readdirOpts, (error, entries = []) => { + callback$1(entries, directoryPath, currentDepth); + state.queue.dequeue(state.options.suppressErrors ? null : error, state); + }); +}; +const walkSync = (state, crawlPath, directoryPath, currentDepth, callback$1) => { + const { fs } = state; + if (currentDepth < 0) return; + state.visited.push(crawlPath); + state.counts.directories++; + let entries = []; + try { + entries = fs.readdirSync(crawlPath || ".", readdirOpts); + } catch (e) { + if (!state.options.suppressErrors) throw e; + } + callback$1(entries, directoryPath, currentDepth); +}; +function build(isSynchronous) { + return isSynchronous ? walkSync : walkAsync; +} + +//#endregion +//#region src/api/queue.ts +/** +* This is a custom stateless queue to track concurrent async fs calls. +* It increments a counter whenever a call is queued and decrements it +* as soon as it completes. When the counter hits 0, it calls onQueueEmpty. +*/ +var Queue = class { + count = 0; + constructor(onQueueEmpty) { + this.onQueueEmpty = onQueueEmpty; + } + enqueue() { + this.count++; + return this.count; + } + dequeue(error, output) { + if (this.onQueueEmpty && (--this.count <= 0 || error)) { + this.onQueueEmpty(error, output); + if (error) { + output.controller.abort(); + this.onQueueEmpty = void 0; + } + } + } +}; + +//#endregion +//#region src/api/counter.ts +var Counter = class { + _files = 0; + _directories = 0; + set files(num) { + this._files = num; + } + get files() { + return this._files; + } + set directories(num) { + this._directories = num; + } + get directories() { + return this._directories; + } + /** + * @deprecated use `directories` instead + */ + /* c8 ignore next 3 */ + get dirs() { + return this._directories; + } +}; + +//#endregion +//#region src/api/aborter.ts +/** +* AbortController is not supported on Node 14 so we use this until we can drop +* support for Node 14. +*/ +var Aborter = class { + aborted = false; + abort() { + this.aborted = true; + } +}; + +//#endregion +//#region src/api/walker.ts +var Walker = class { + root; + isSynchronous; + state; + joinPath; + pushDirectory; + pushFile; + getArray; + groupFiles; + resolveSymlink; + walkDirectory; + callbackInvoker; + constructor(root, options, callback$1) { + this.isSynchronous = !callback$1; + this.callbackInvoker = build$1(options, this.isSynchronous); + this.root = normalizePath(root, options); + this.state = { + root: isRootDirectory(this.root) ? this.root : this.root.slice(0, -1), + paths: [""].slice(0, 0), + groups: [], + counts: new Counter(), + options, + queue: new Queue((error, state) => this.callbackInvoker(state, error, callback$1)), + symlinks: /* @__PURE__ */ new Map(), + visited: [""].slice(0, 0), + controller: new Aborter(), + fs: options.fs || nativeFs + }; + this.joinPath = build$7(this.root, options); + this.pushDirectory = build$6(this.root, options); + this.pushFile = build$5(options); + this.getArray = build$4(options); + this.groupFiles = build$3(options); + this.resolveSymlink = build$2(options, this.isSynchronous); + this.walkDirectory = build(this.isSynchronous); + } + start() { + this.pushDirectory(this.root, this.state.paths, this.state.options.filters); + this.walkDirectory(this.state, this.root, this.root, this.state.options.maxDepth, this.walk); + return this.isSynchronous ? this.callbackInvoker(this.state, null) : null; + } + walk = (entries, directoryPath, depth) => { + const { paths, options: { filters, resolveSymlinks: resolveSymlinks$1, excludeSymlinks, exclude, maxFiles, signal, useRealPaths, pathSeparator }, controller } = this.state; + if (controller.aborted || signal && signal.aborted || maxFiles && paths.length > maxFiles) return; + const files = this.getArray(this.state.paths); + for (let i = 0; i < entries.length; ++i) { + const entry = entries[i]; + if (entry.isFile() || entry.isSymbolicLink() && !resolveSymlinks$1 && !excludeSymlinks) { + const filename = this.joinPath(entry.name, directoryPath); + this.pushFile(filename, files, this.state.counts, filters); + } else if (entry.isDirectory()) { + let path = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator); + if (exclude && exclude(entry.name, path)) continue; + this.pushDirectory(path, paths, filters); + this.walkDirectory(this.state, path, path, depth - 1, this.walk); + } else if (this.resolveSymlink && entry.isSymbolicLink()) { + let path = joinPathWithBasePath(entry.name, directoryPath); + this.resolveSymlink(path, this.state, (stat, resolvedPath) => { + if (stat.isDirectory()) { + resolvedPath = normalizePath(resolvedPath, this.state.options); + if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path + pathSeparator)) return; + this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path + pathSeparator, depth - 1, this.walk); + } else { + resolvedPath = useRealPaths ? resolvedPath : path; + const filename = basename(resolvedPath); + const directoryPath$1 = normalizePath(dirname(resolvedPath), this.state.options); + resolvedPath = this.joinPath(filename, directoryPath$1); + this.pushFile(resolvedPath, files, this.state.counts, filters); + } + }); + } + } + this.groupFiles(this.state.groups, directoryPath, files); + }; +}; + +//#endregion +//#region src/api/async.ts +function promise(root, options) { + return new Promise((resolve$1, reject) => { + callback(root, options, (err, output) => { + if (err) return reject(err); + resolve$1(output); + }); + }); +} +function callback(root, options, callback$1) { + let walker = new Walker(root, options, callback$1); + walker.start(); +} + +//#endregion +//#region src/api/sync.ts +function sync(root, options) { + const walker = new Walker(root, options); + return walker.start(); +} + +//#endregion +//#region src/builder/api-builder.ts +var APIBuilder = class { + constructor(root, options) { + this.root = root; + this.options = options; + } + withPromise() { + return promise(this.root, this.options); + } + withCallback(cb) { + callback(this.root, this.options, cb); + } + sync() { + return sync(this.root, this.options); + } +}; + +//#endregion +//#region src/builder/index.ts +let pm = null; +/* c8 ignore next 6 */ +try { + __require.resolve("picomatch"); + pm = __require("picomatch"); +} catch {} +var Builder = class { + globCache = {}; + options = { + maxDepth: Infinity, + suppressErrors: true, + pathSeparator: sep, + filters: [] + }; + globFunction; + constructor(options) { + this.options = { + ...this.options, + ...options + }; + this.globFunction = this.options.globFunction; + } + group() { + this.options.group = true; + return this; + } + withPathSeparator(separator) { + this.options.pathSeparator = separator; + return this; + } + withBasePath() { + this.options.includeBasePath = true; + return this; + } + withRelativePaths() { + this.options.relativePaths = true; + return this; + } + withDirs() { + this.options.includeDirs = true; + return this; + } + withMaxDepth(depth) { + this.options.maxDepth = depth; + return this; + } + withMaxFiles(limit) { + this.options.maxFiles = limit; + return this; + } + withFullPaths() { + this.options.resolvePaths = true; + this.options.includeBasePath = true; + return this; + } + withErrors() { + this.options.suppressErrors = false; + return this; + } + withSymlinks({ resolvePaths = true } = {}) { + this.options.resolveSymlinks = true; + this.options.useRealPaths = resolvePaths; + return this.withFullPaths(); + } + withAbortSignal(signal) { + this.options.signal = signal; + return this; + } + normalize() { + this.options.normalizePath = true; + return this; + } + filter(predicate) { + this.options.filters.push(predicate); + return this; + } + onlyDirs() { + this.options.excludeFiles = true; + this.options.includeDirs = true; + return this; + } + exclude(predicate) { + this.options.exclude = predicate; + return this; + } + onlyCounts() { + this.options.onlyCounts = true; + return this; + } + crawl(root) { + return new APIBuilder(root || ".", this.options); + } + withGlobFunction(fn) { + this.globFunction = fn; + return this; + } + /** + * @deprecated Pass options using the constructor instead: + * ```ts + * new fdir(options).crawl("/path/to/root"); + * ``` + * This method will be removed in v7.0 + */ + /* c8 ignore next 4 */ + crawlWithOptions(root, options) { + this.options = { + ...this.options, + ...options + }; + return new APIBuilder(root || ".", this.options); + } + glob(...patterns) { + if (this.globFunction) return this.globWithOptions(patterns); + return this.globWithOptions(patterns, ...[{ dot: true }]); + } + globWithOptions(patterns, ...options) { + const globFn = this.globFunction || pm; + /* c8 ignore next 5 */ + if (!globFn) throw new Error("Please specify a glob function to use glob matching."); + var isMatch = this.globCache[patterns.join("\0")]; + if (!isMatch) { + isMatch = globFn(patterns, ...options); + this.globCache[patterns.join("\0")] = isMatch; + } + this.options.filters.push((path) => isMatch(path)); + return this; + } +}; + +//#endregion +export { Builder as fdir }; \ No newline at end of file diff --git a/client/node_modules/fdir/package.json b/client/node_modules/fdir/package.json new file mode 100644 index 0000000..e229dff --- /dev/null +++ b/client/node_modules/fdir/package.json @@ -0,0 +1,103 @@ +{ + "name": "fdir", + "version": "6.5.0", + "description": "The fastest directory crawler & globbing alternative to glob, fast-glob, & tiny-glob. Crawls 1m files in < 1s", + "main": "./dist/index.cjs", + "types": "./dist/index.d.cts", + "type": "module", + "scripts": { + "prepublishOnly": "npm run test && npm run build", + "build": "tsdown", + "format": "prettier --write src __tests__ benchmarks", + "test": "vitest run __tests__/", + "test:coverage": "vitest run --coverage __tests__/", + "test:watch": "vitest __tests__/", + "bench": "ts-node benchmarks/benchmark.js", + "bench:glob": "ts-node benchmarks/glob-benchmark.ts", + "bench:fdir": "ts-node benchmarks/fdir-benchmark.ts", + "release": "./scripts/release.sh" + }, + "engines": { + "node": ">=12.0.0" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/thecodrr/fdir.git" + }, + "keywords": [ + "util", + "os", + "sys", + "fs", + "walk", + "crawler", + "directory", + "files", + "io", + "tiny-glob", + "glob", + "fast-glob", + "speed", + "javascript", + "nodejs" + ], + "author": "thecodrr ", + "license": "MIT", + "bugs": { + "url": "https://github.com/thecodrr/fdir/issues" + }, + "homepage": "https://github.com/thecodrr/fdir#readme", + "devDependencies": { + "@types/glob": "^8.1.0", + "@types/mock-fs": "^4.13.4", + "@types/node": "^20.9.4", + "@types/picomatch": "^4.0.0", + "@types/tap": "^15.0.11", + "@vitest/coverage-v8": "^0.34.6", + "all-files-in-tree": "^1.1.2", + "benny": "^3.7.1", + "csv-to-markdown-table": "^1.3.1", + "expect": "^29.7.0", + "fast-glob": "^3.3.2", + "fdir1": "npm:fdir@1.2.0", + "fdir2": "npm:fdir@2.1.0", + "fdir3": "npm:fdir@3.4.2", + "fdir4": "npm:fdir@4.1.0", + "fdir5": "npm:fdir@5.0.0", + "fs-readdir-recursive": "^1.1.0", + "get-all-files": "^4.1.0", + "glob": "^10.3.10", + "klaw-sync": "^6.0.0", + "mock-fs": "^5.2.0", + "picomatch": "^4.0.2", + "prettier": "^3.5.3", + "recur-readdir": "0.0.1", + "recursive-files": "^1.0.2", + "recursive-fs": "^2.1.0", + "recursive-readdir": "^2.2.3", + "rrdir": "^12.1.0", + "systeminformation": "^5.21.17", + "tiny-glob": "^0.2.9", + "ts-node": "^10.9.1", + "tsdown": "^0.12.5", + "typescript": "^5.3.2", + "vitest": "^0.34.6", + "walk-sync": "^3.0.0" + }, + "peerDependencies": { + "picomatch": "^3 || ^4" + }, + "peerDependenciesMeta": { + "picomatch": { + "optional": true + } + }, + "module": "./dist/index.mjs", + "exports": { + ".": { + "import": "./dist/index.mjs", + "require": "./dist/index.cjs" + }, + "./package.json": "./package.json" + } +} diff --git a/client/node_modules/lightningcss-linux-x64-gnu/LICENSE b/client/node_modules/lightningcss-linux-x64-gnu/LICENSE new file mode 100644 index 0000000..89fe5b2 --- /dev/null +++ b/client/node_modules/lightningcss-linux-x64-gnu/LICENSE @@ -0,0 +1,373 @@ + Mozilla Public License Version 2.0 +================================== + +1. Definitions +-------------- + +1.1. "Contributor" +means each individual or legal entity that creates, contributes to +the creation of, or owns Covered Software. + +1.2. "Contributor Version" +means the combination of the Contributions of others (if any) used +by a Contributor and that particular Contributor's Contribution. + +1.3. "Contribution" +means Covered Software of a particular Contributor. + +1.4. "Covered Software" +means Source Code Form to which the initial Contributor has attached +the notice in Exhibit A, the Executable Form of such Source Code +Form, and Modifications of such Source Code Form, in each case +including portions thereof. + +1.5. "Incompatible With Secondary Licenses" +means + +(a) that the initial Contributor has attached the notice described +in Exhibit B to the Covered Software; or + +(b) that the Covered Software was made available under the terms of +version 1.1 or earlier of the License, but not also under the +terms of a Secondary License. + +1.6. "Executable Form" +means any form of the work other than Source Code Form. + +1.7. "Larger Work" +means a work that combines Covered Software with other material, in +a separate file or files, that is not Covered Software. + +1.8. "License" +means this document. + +1.9. "Licensable" +means having the right to grant, to the maximum extent possible, +whether at the time of the initial grant or subsequently, any and +all of the rights conveyed by this License. + +1.10. "Modifications" +means any of the following: + +(a) any file in Source Code Form that results from an addition to, +deletion from, or modification of the contents of Covered +Software; or + +(b) any new file in Source Code Form that contains any Covered +Software. + +1.11. "Patent Claims" of a Contributor +means any patent claim(s), including without limitation, method, +process, and apparatus claims, in any patent Licensable by such +Contributor that would be infringed, but for the grant of the +License, by the making, using, selling, offering for sale, having +made, import, or transfer of either its Contributions or its +Contributor Version. + +1.12. "Secondary License" +means either the GNU General Public License, Version 2.0, the GNU +Lesser General Public License, Version 2.1, the GNU Affero General +Public License, Version 3.0, or any later versions of those +licenses. + +1.13. "Source Code Form" +means the form of the work preferred for making modifications. + +1.14. "You" (or "Your") +means an individual or a legal entity exercising rights under this +License. For legal entities, "You" includes any entity that +controls, is controlled by, or is under common control with You. For +purposes of this definition, "control" means (a) the power, direct +or indirect, to cause the direction or management of such entity, +whether by contract or otherwise, or (b) ownership of more than +fifty percent (50%) of the outstanding shares or beneficial +ownership of such entity. + +2. License Grants and Conditions +-------------------------------- + +2.1. Grants + +Each Contributor hereby grants You a world-wide, royalty-free, +non-exclusive license: + +(a) under intellectual property rights (other than patent or trademark) +Licensable by such Contributor to use, reproduce, make available, +modify, display, perform, distribute, and otherwise exploit its +Contributions, either on an unmodified basis, with Modifications, or +as part of a Larger Work; and + +(b) under Patent Claims of such Contributor to make, use, sell, offer +for sale, have made, import, and otherwise transfer either its +Contributions or its Contributor Version. + +2.2. Effective Date + +The licenses granted in Section 2.1 with respect to any Contribution +become effective for each Contribution on the date the Contributor first +distributes such Contribution. + +2.3. Limitations on Grant Scope + +The licenses granted in this Section 2 are the only rights granted under +this License. No additional rights or licenses will be implied from the +distribution or licensing of Covered Software under this License. +Notwithstanding Section 2.1(b) above, no patent license is granted by a +Contributor: + +(a) for any code that a Contributor has removed from Covered Software; +or + +(b) for infringements caused by: (i) Your and any other third party's +modifications of Covered Software, or (ii) the combination of its +Contributions with other software (except as part of its Contributor +Version); or + +(c) under Patent Claims infringed by Covered Software in the absence of +its Contributions. + +This License does not grant any rights in the trademarks, service marks, +or logos of any Contributor (except as may be necessary to comply with +the notice requirements in Section 3.4). + +2.4. Subsequent Licenses + +No Contributor makes additional grants as a result of Your choice to +distribute the Covered Software under a subsequent version of this +License (see Section 10.2) or under the terms of a Secondary License (if +permitted under the terms of Section 3.3). + +2.5. Representation + +Each Contributor represents that the Contributor believes its +Contributions are its original creation(s) or it has sufficient rights +to grant the rights to its Contributions conveyed by this License. + +2.6. Fair Use + +This License is not intended to limit any rights You have under +applicable copyright doctrines of fair use, fair dealing, or other +equivalents. + +2.7. Conditions + +Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted +in Section 2.1. + +3. Responsibilities +------------------- + +3.1. Distribution of Source Form + +All distribution of Covered Software in Source Code Form, including any +Modifications that You create or to which You contribute, must be under +the terms of this License. You must inform recipients that the Source +Code Form of the Covered Software is governed by the terms of this +License, and how they can obtain a copy of this License. You may not +attempt to alter or restrict the recipients' rights in the Source Code +Form. + +3.2. Distribution of Executable Form + +If You distribute Covered Software in Executable Form then: + +(a) such Covered Software must also be made available in Source Code +Form, as described in Section 3.1, and You must inform recipients of +the Executable Form how they can obtain a copy of such Source Code +Form by reasonable means in a timely manner, at a charge no more +than the cost of distribution to the recipient; and + +(b) You may distribute such Executable Form under the terms of this +License, or sublicense it under different terms, provided that the +license for the Executable Form does not attempt to limit or alter +the recipients' rights in the Source Code Form under this License. + +3.3. Distribution of a Larger Work + +You may create and distribute a Larger Work under terms of Your choice, +provided that You also comply with the requirements of this License for +the Covered Software. If the Larger Work is a combination of Covered +Software with a work governed by one or more Secondary Licenses, and the +Covered Software is not Incompatible With Secondary Licenses, this +License permits You to additionally distribute such Covered Software +under the terms of such Secondary License(s), so that the recipient of +the Larger Work may, at their option, further distribute the Covered +Software under the terms of either this License or such Secondary +License(s). + +3.4. Notices + +You may not remove or alter the substance of any license notices +(including copyright notices, patent notices, disclaimers of warranty, +or limitations of liability) contained within the Source Code Form of +the Covered Software, except that You may alter any license notices to +the extent required to remedy known factual inaccuracies. + +3.5. Application of Additional Terms + +You may choose to offer, and to charge a fee for, warranty, support, +indemnity or liability obligations to one or more recipients of Covered +Software. However, You may do so only on Your own behalf, and not on +behalf of any Contributor. You must make it absolutely clear that any +such warranty, support, indemnity, or liability obligation is offered by +You alone, and You hereby agree to indemnify every Contributor for any +liability incurred by such Contributor as a result of warranty, support, +indemnity or liability terms You offer. You may include additional +disclaimers of warranty and limitations of liability specific to any +jurisdiction. + +4. Inability to Comply Due to Statute or Regulation +--------------------------------------------------- + +If it is impossible for You to comply with any of the terms of this +License with respect to some or all of the Covered Software due to +statute, judicial order, or regulation then You must: (a) comply with +the terms of this License to the maximum extent possible; and (b) +describe the limitations and the code they affect. Such description must +be placed in a text file included with all distributions of the Covered +Software under this License. Except to the extent prohibited by statute +or regulation, such description must be sufficiently detailed for a +recipient of ordinary skill to be able to understand it. + +5. Termination +-------------- + +5.1. The rights granted under this License will terminate automatically +if You fail to comply with any of its terms. However, if You become +compliant, then the rights granted under this License from a particular +Contributor are reinstated (a) provisionally, unless and until such +Contributor explicitly and finally terminates Your grants, and (b) on an +ongoing basis, if such Contributor fails to notify You of the +non-compliance by some reasonable means prior to 60 days after You have +come back into compliance. Moreover, Your grants from a particular +Contributor are reinstated on an ongoing basis if such Contributor +notifies You of the non-compliance by some reasonable means, this is the +first time You have received notice of non-compliance with this License +from such Contributor, and You become compliant prior to 30 days after +Your receipt of the notice. + +5.2. If You initiate litigation against any entity by asserting a patent +infringement claim (excluding declaratory judgment actions, +counter-claims, and cross-claims) alleging that a Contributor Version +directly or indirectly infringes any patent, then the rights granted to +You by any and all Contributors for the Covered Software under Section +2.1 of this License shall terminate. + +5.3. In the event of termination under Sections 5.1 or 5.2 above, all +end user license agreements (excluding distributors and resellers) which +have been validly granted by You or Your distributors under this License +prior to termination shall survive termination. + +************************************************************************ +* * +* 6. Disclaimer of Warranty * +* ------------------------- * +* * +* Covered Software is provided under this License on an "as is" * +* basis, without warranty of any kind, either expressed, implied, or * +* statutory, including, without limitation, warranties that the * +* Covered Software is free of defects, merchantable, fit for a * +* particular purpose or non-infringing. The entire risk as to the * +* quality and performance of the Covered Software is with You. * +* Should any Covered Software prove defective in any respect, You * +* (not any Contributor) assume the cost of any necessary servicing, * +* repair, or correction. This disclaimer of warranty constitutes an * +* essential part of this License. No use of any Covered Software is * +* authorized under this License except under this disclaimer. * +* * +************************************************************************ + +************************************************************************ +* * +* 7. Limitation of Liability * +* -------------------------- * +* * +* Under no circumstances and under no legal theory, whether tort * +* (including negligence), contract, or otherwise, shall any * +* Contributor, or anyone who distributes Covered Software as * +* permitted above, be liable to You for any direct, indirect, * +* special, incidental, or consequential damages of any character * +* including, without limitation, damages for lost profits, loss of * +* goodwill, work stoppage, computer failure or malfunction, or any * +* and all other commercial damages or losses, even if such party * +* shall have been informed of the possibility of such damages. This * +* limitation of liability shall not apply to liability for death or * +* personal injury resulting from such party's negligence to the * +* extent applicable law prohibits such limitation. Some * +* jurisdictions do not allow the exclusion or limitation of * +* incidental or consequential damages, so this exclusion and * +* limitation may not apply to You. * +* * +************************************************************************ + +8. Litigation +------------- + +Any litigation relating to this License may be brought only in the +courts of a jurisdiction where the defendant maintains its principal +place of business and such litigation shall be governed by laws of that +jurisdiction, without reference to its conflict-of-law provisions. +Nothing in this Section shall prevent a party's ability to bring +cross-claims or counter-claims. + +9. Miscellaneous +---------------- + +This License represents the complete agreement concerning the subject +matter hereof. If any provision of this License is held to be +unenforceable, such provision shall be reformed only to the extent +necessary to make it enforceable. Any law or regulation which provides +that the language of a contract shall be construed against the drafter +shall not be used to construe this License against a Contributor. + +10. Versions of the License +--------------------------- + +10.1. New Versions + +Mozilla Foundation is the license steward. Except as provided in Section +10.3, no one other than the license steward has the right to modify or +publish new versions of this License. Each version will be given a +distinguishing version number. + +10.2. Effect of New Versions + +You may distribute the Covered Software under the terms of the version +of the License under which You originally received the Covered Software, +or under the terms of any subsequent version published by the license +steward. + +10.3. Modified Versions + +If you create software not governed by this License, and you want to +create a new license for such software, you may create and use a +modified version of this License if you rename the license and remove +any references to the name of the license steward (except to note that +such modified license differs from this License). + +10.4. Distributing Source Code Form that is Incompatible With Secondary +Licenses + +If You choose to distribute Source Code Form that is Incompatible With +Secondary Licenses under the terms of this version of the License, the +notice described in Exhibit B of this License must be attached. + +Exhibit A - Source Code Form License Notice +------------------------------------------- + +This Source Code Form is subject to the terms of the Mozilla Public +License, v. 2.0. If a copy of the MPL was not distributed with this +file, You can obtain one at https://mozilla.org/MPL/2.0/. + +If it is not possible or desirable to put the notice in a particular +file, then You may include the notice in a location (such as a LICENSE +file in a relevant directory) where a recipient would be likely to look +for such a notice. + +You may add additional accurate notices of copyright ownership. + +Exhibit B - "Incompatible With Secondary Licenses" Notice +--------------------------------------------------------- + +This Source Code Form is "Incompatible With Secondary Licenses", as +defined by the Mozilla Public License, v. 2.0. diff --git a/client/node_modules/lightningcss-linux-x64-gnu/README.md b/client/node_modules/lightningcss-linux-x64-gnu/README.md new file mode 100644 index 0000000..84f87d3 --- /dev/null +++ b/client/node_modules/lightningcss-linux-x64-gnu/README.md @@ -0,0 +1 @@ +This is the x86_64-unknown-linux-gnu build of lightningcss. See https://github.com/parcel-bundler/lightningcss for details. \ No newline at end of file diff --git a/client/node_modules/lightningcss-linux-x64-gnu/lightningcss.linux-x64-gnu.node b/client/node_modules/lightningcss-linux-x64-gnu/lightningcss.linux-x64-gnu.node new file mode 100644 index 0000000..4c3f078 Binary files /dev/null and b/client/node_modules/lightningcss-linux-x64-gnu/lightningcss.linux-x64-gnu.node differ diff --git a/client/node_modules/lightningcss-linux-x64-gnu/package.json b/client/node_modules/lightningcss-linux-x64-gnu/package.json new file mode 100644 index 0000000..0a21c91 --- /dev/null +++ b/client/node_modules/lightningcss-linux-x64-gnu/package.json @@ -0,0 +1,37 @@ +{ + "name": "lightningcss-linux-x64-gnu", + "version": "1.33.0", + "license": "MPL-2.0", + "description": "A CSS parser, transformer, and minifier written in Rust", + "main": "lightningcss.linux-x64-gnu.node", + "browserslist": "last 2 versions, not dead", + "publishConfig": { + "access": "public" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + }, + "repository": { + "type": "git", + "url": "https://github.com/parcel-bundler/lightningcss.git" + }, + "engines": { + "node": ">= 12.0.0" + }, + "files": [ + "lightningcss.linux-x64-gnu.node" + ], + "resolutions": { + "lightningcss": "link:." + }, + "os": [ + "linux" + ], + "cpu": [ + "x64" + ], + "libc": [ + "glibc" + ] +} diff --git a/client/node_modules/lightningcss/LICENSE b/client/node_modules/lightningcss/LICENSE new file mode 100644 index 0000000..89fe5b2 --- /dev/null +++ b/client/node_modules/lightningcss/LICENSE @@ -0,0 +1,373 @@ + Mozilla Public License Version 2.0 +================================== + +1. Definitions +-------------- + +1.1. "Contributor" +means each individual or legal entity that creates, contributes to +the creation of, or owns Covered Software. + +1.2. "Contributor Version" +means the combination of the Contributions of others (if any) used +by a Contributor and that particular Contributor's Contribution. + +1.3. "Contribution" +means Covered Software of a particular Contributor. + +1.4. "Covered Software" +means Source Code Form to which the initial Contributor has attached +the notice in Exhibit A, the Executable Form of such Source Code +Form, and Modifications of such Source Code Form, in each case +including portions thereof. + +1.5. "Incompatible With Secondary Licenses" +means + +(a) that the initial Contributor has attached the notice described +in Exhibit B to the Covered Software; or + +(b) that the Covered Software was made available under the terms of +version 1.1 or earlier of the License, but not also under the +terms of a Secondary License. + +1.6. "Executable Form" +means any form of the work other than Source Code Form. + +1.7. "Larger Work" +means a work that combines Covered Software with other material, in +a separate file or files, that is not Covered Software. + +1.8. "License" +means this document. + +1.9. "Licensable" +means having the right to grant, to the maximum extent possible, +whether at the time of the initial grant or subsequently, any and +all of the rights conveyed by this License. + +1.10. "Modifications" +means any of the following: + +(a) any file in Source Code Form that results from an addition to, +deletion from, or modification of the contents of Covered +Software; or + +(b) any new file in Source Code Form that contains any Covered +Software. + +1.11. "Patent Claims" of a Contributor +means any patent claim(s), including without limitation, method, +process, and apparatus claims, in any patent Licensable by such +Contributor that would be infringed, but for the grant of the +License, by the making, using, selling, offering for sale, having +made, import, or transfer of either its Contributions or its +Contributor Version. + +1.12. "Secondary License" +means either the GNU General Public License, Version 2.0, the GNU +Lesser General Public License, Version 2.1, the GNU Affero General +Public License, Version 3.0, or any later versions of those +licenses. + +1.13. "Source Code Form" +means the form of the work preferred for making modifications. + +1.14. "You" (or "Your") +means an individual or a legal entity exercising rights under this +License. For legal entities, "You" includes any entity that +controls, is controlled by, or is under common control with You. For +purposes of this definition, "control" means (a) the power, direct +or indirect, to cause the direction or management of such entity, +whether by contract or otherwise, or (b) ownership of more than +fifty percent (50%) of the outstanding shares or beneficial +ownership of such entity. + +2. License Grants and Conditions +-------------------------------- + +2.1. Grants + +Each Contributor hereby grants You a world-wide, royalty-free, +non-exclusive license: + +(a) under intellectual property rights (other than patent or trademark) +Licensable by such Contributor to use, reproduce, make available, +modify, display, perform, distribute, and otherwise exploit its +Contributions, either on an unmodified basis, with Modifications, or +as part of a Larger Work; and + +(b) under Patent Claims of such Contributor to make, use, sell, offer +for sale, have made, import, and otherwise transfer either its +Contributions or its Contributor Version. + +2.2. Effective Date + +The licenses granted in Section 2.1 with respect to any Contribution +become effective for each Contribution on the date the Contributor first +distributes such Contribution. + +2.3. Limitations on Grant Scope + +The licenses granted in this Section 2 are the only rights granted under +this License. No additional rights or licenses will be implied from the +distribution or licensing of Covered Software under this License. +Notwithstanding Section 2.1(b) above, no patent license is granted by a +Contributor: + +(a) for any code that a Contributor has removed from Covered Software; +or + +(b) for infringements caused by: (i) Your and any other third party's +modifications of Covered Software, or (ii) the combination of its +Contributions with other software (except as part of its Contributor +Version); or + +(c) under Patent Claims infringed by Covered Software in the absence of +its Contributions. + +This License does not grant any rights in the trademarks, service marks, +or logos of any Contributor (except as may be necessary to comply with +the notice requirements in Section 3.4). + +2.4. Subsequent Licenses + +No Contributor makes additional grants as a result of Your choice to +distribute the Covered Software under a subsequent version of this +License (see Section 10.2) or under the terms of a Secondary License (if +permitted under the terms of Section 3.3). + +2.5. Representation + +Each Contributor represents that the Contributor believes its +Contributions are its original creation(s) or it has sufficient rights +to grant the rights to its Contributions conveyed by this License. + +2.6. Fair Use + +This License is not intended to limit any rights You have under +applicable copyright doctrines of fair use, fair dealing, or other +equivalents. + +2.7. Conditions + +Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted +in Section 2.1. + +3. Responsibilities +------------------- + +3.1. Distribution of Source Form + +All distribution of Covered Software in Source Code Form, including any +Modifications that You create or to which You contribute, must be under +the terms of this License. You must inform recipients that the Source +Code Form of the Covered Software is governed by the terms of this +License, and how they can obtain a copy of this License. You may not +attempt to alter or restrict the recipients' rights in the Source Code +Form. + +3.2. Distribution of Executable Form + +If You distribute Covered Software in Executable Form then: + +(a) such Covered Software must also be made available in Source Code +Form, as described in Section 3.1, and You must inform recipients of +the Executable Form how they can obtain a copy of such Source Code +Form by reasonable means in a timely manner, at a charge no more +than the cost of distribution to the recipient; and + +(b) You may distribute such Executable Form under the terms of this +License, or sublicense it under different terms, provided that the +license for the Executable Form does not attempt to limit or alter +the recipients' rights in the Source Code Form under this License. + +3.3. Distribution of a Larger Work + +You may create and distribute a Larger Work under terms of Your choice, +provided that You also comply with the requirements of this License for +the Covered Software. If the Larger Work is a combination of Covered +Software with a work governed by one or more Secondary Licenses, and the +Covered Software is not Incompatible With Secondary Licenses, this +License permits You to additionally distribute such Covered Software +under the terms of such Secondary License(s), so that the recipient of +the Larger Work may, at their option, further distribute the Covered +Software under the terms of either this License or such Secondary +License(s). + +3.4. Notices + +You may not remove or alter the substance of any license notices +(including copyright notices, patent notices, disclaimers of warranty, +or limitations of liability) contained within the Source Code Form of +the Covered Software, except that You may alter any license notices to +the extent required to remedy known factual inaccuracies. + +3.5. Application of Additional Terms + +You may choose to offer, and to charge a fee for, warranty, support, +indemnity or liability obligations to one or more recipients of Covered +Software. However, You may do so only on Your own behalf, and not on +behalf of any Contributor. You must make it absolutely clear that any +such warranty, support, indemnity, or liability obligation is offered by +You alone, and You hereby agree to indemnify every Contributor for any +liability incurred by such Contributor as a result of warranty, support, +indemnity or liability terms You offer. You may include additional +disclaimers of warranty and limitations of liability specific to any +jurisdiction. + +4. Inability to Comply Due to Statute or Regulation +--------------------------------------------------- + +If it is impossible for You to comply with any of the terms of this +License with respect to some or all of the Covered Software due to +statute, judicial order, or regulation then You must: (a) comply with +the terms of this License to the maximum extent possible; and (b) +describe the limitations and the code they affect. Such description must +be placed in a text file included with all distributions of the Covered +Software under this License. Except to the extent prohibited by statute +or regulation, such description must be sufficiently detailed for a +recipient of ordinary skill to be able to understand it. + +5. Termination +-------------- + +5.1. The rights granted under this License will terminate automatically +if You fail to comply with any of its terms. However, if You become +compliant, then the rights granted under this License from a particular +Contributor are reinstated (a) provisionally, unless and until such +Contributor explicitly and finally terminates Your grants, and (b) on an +ongoing basis, if such Contributor fails to notify You of the +non-compliance by some reasonable means prior to 60 days after You have +come back into compliance. Moreover, Your grants from a particular +Contributor are reinstated on an ongoing basis if such Contributor +notifies You of the non-compliance by some reasonable means, this is the +first time You have received notice of non-compliance with this License +from such Contributor, and You become compliant prior to 30 days after +Your receipt of the notice. + +5.2. If You initiate litigation against any entity by asserting a patent +infringement claim (excluding declaratory judgment actions, +counter-claims, and cross-claims) alleging that a Contributor Version +directly or indirectly infringes any patent, then the rights granted to +You by any and all Contributors for the Covered Software under Section +2.1 of this License shall terminate. + +5.3. In the event of termination under Sections 5.1 or 5.2 above, all +end user license agreements (excluding distributors and resellers) which +have been validly granted by You or Your distributors under this License +prior to termination shall survive termination. + +************************************************************************ +* * +* 6. Disclaimer of Warranty * +* ------------------------- * +* * +* Covered Software is provided under this License on an "as is" * +* basis, without warranty of any kind, either expressed, implied, or * +* statutory, including, without limitation, warranties that the * +* Covered Software is free of defects, merchantable, fit for a * +* particular purpose or non-infringing. The entire risk as to the * +* quality and performance of the Covered Software is with You. * +* Should any Covered Software prove defective in any respect, You * +* (not any Contributor) assume the cost of any necessary servicing, * +* repair, or correction. This disclaimer of warranty constitutes an * +* essential part of this License. No use of any Covered Software is * +* authorized under this License except under this disclaimer. * +* * +************************************************************************ + +************************************************************************ +* * +* 7. Limitation of Liability * +* -------------------------- * +* * +* Under no circumstances and under no legal theory, whether tort * +* (including negligence), contract, or otherwise, shall any * +* Contributor, or anyone who distributes Covered Software as * +* permitted above, be liable to You for any direct, indirect, * +* special, incidental, or consequential damages of any character * +* including, without limitation, damages for lost profits, loss of * +* goodwill, work stoppage, computer failure or malfunction, or any * +* and all other commercial damages or losses, even if such party * +* shall have been informed of the possibility of such damages. This * +* limitation of liability shall not apply to liability for death or * +* personal injury resulting from such party's negligence to the * +* extent applicable law prohibits such limitation. Some * +* jurisdictions do not allow the exclusion or limitation of * +* incidental or consequential damages, so this exclusion and * +* limitation may not apply to You. * +* * +************************************************************************ + +8. Litigation +------------- + +Any litigation relating to this License may be brought only in the +courts of a jurisdiction where the defendant maintains its principal +place of business and such litigation shall be governed by laws of that +jurisdiction, without reference to its conflict-of-law provisions. +Nothing in this Section shall prevent a party's ability to bring +cross-claims or counter-claims. + +9. Miscellaneous +---------------- + +This License represents the complete agreement concerning the subject +matter hereof. If any provision of this License is held to be +unenforceable, such provision shall be reformed only to the extent +necessary to make it enforceable. Any law or regulation which provides +that the language of a contract shall be construed against the drafter +shall not be used to construe this License against a Contributor. + +10. Versions of the License +--------------------------- + +10.1. New Versions + +Mozilla Foundation is the license steward. Except as provided in Section +10.3, no one other than the license steward has the right to modify or +publish new versions of this License. Each version will be given a +distinguishing version number. + +10.2. Effect of New Versions + +You may distribute the Covered Software under the terms of the version +of the License under which You originally received the Covered Software, +or under the terms of any subsequent version published by the license +steward. + +10.3. Modified Versions + +If you create software not governed by this License, and you want to +create a new license for such software, you may create and use a +modified version of this License if you rename the license and remove +any references to the name of the license steward (except to note that +such modified license differs from this License). + +10.4. Distributing Source Code Form that is Incompatible With Secondary +Licenses + +If You choose to distribute Source Code Form that is Incompatible With +Secondary Licenses under the terms of this version of the License, the +notice described in Exhibit B of this License must be attached. + +Exhibit A - Source Code Form License Notice +------------------------------------------- + +This Source Code Form is subject to the terms of the Mozilla Public +License, v. 2.0. If a copy of the MPL was not distributed with this +file, You can obtain one at https://mozilla.org/MPL/2.0/. + +If it is not possible or desirable to put the notice in a particular +file, then You may include the notice in a location (such as a LICENSE +file in a relevant directory) where a recipient would be likely to look +for such a notice. + +You may add additional accurate notices of copyright ownership. + +Exhibit B - "Incompatible With Secondary Licenses" Notice +--------------------------------------------------------- + +This Source Code Form is "Incompatible With Secondary Licenses", as +defined by the Mozilla Public License, v. 2.0. diff --git a/client/node_modules/lightningcss/README.md b/client/node_modules/lightningcss/README.md new file mode 100644 index 0000000..f44d7b3 --- /dev/null +++ b/client/node_modules/lightningcss/README.md @@ -0,0 +1,105 @@ +# ⚡️ Lightning CSS + +An extremely fast CSS parser, transformer, and minifier written in Rust. Use it with [Parcel](https://parceljs.org), as a standalone library or CLI, or via a plugin with any other tool. + + + + +## Features + +- **Extremely fast** – Parsing and minifying large files is completed in milliseconds, often with significantly smaller output than other tools. See [benchmarks](#benchmarks) below. +- **Typed property values** – many other CSS parsers treat property values as an untyped series of tokens. This means that each transformer that wants to do something with these values must interpret them itself, leading to duplicate work and inconsistencies. Lightning CSS parses all values using the grammar from the CSS specification, and exposes a specific value type for each property. +- **Browser-grade parser** – Lightning CSS is built on the [cssparser](https://github.com/servo/rust-cssparser) and [selectors](https://github.com/servo/stylo/tree/main/selectors) crates created by Mozilla and used by Firefox and Servo. These provide a solid general purpose CSS-parsing foundation on top of which Lightning CSS implements support for all specific CSS rules and properties. +- **Minification** – One of the main purposes of Lightning CSS is to minify CSS to make it smaller. This includes many optimizations including: + - Combining longhand properties into shorthands where possible. + - Merging adjacent rules with the same selectors or declarations when it is safe to do so. + - Combining CSS transforms into a single matrix or vice versa when smaller. + - Removing vendor prefixes that are not needed, based on the provided browser targets. + - Reducing `calc()` expressions where possible. + - Converting colors to shorter hex notation where possible. + - Minifying gradients. + - Minifying CSS grid templates. + - Normalizing property value order. + - Removing default property sub-values which will be inferred by browsers. + - Many micro-optimizations, e.g. converting to shorter units, removing unnecessary quotation marks, etc. +- **Vendor prefixing** – Lightning CSS accepts a list of browser targets, and automatically adds (and removes) vendor prefixes. +- **Browserslist configuration** – Lightning CSS supports opt-in browserslist configuration discovery to resolve browser targets and integrate with your existing tools and config setup. +- **Syntax lowering** – Lightning CSS parses modern CSS syntax, and generates more compatible output where needed, based on browser targets. + - CSS Nesting + - Custom media queries (draft spec) + - Logical properties + * [Color Level 5](https://drafts.csswg.org/css-color-5/) + - `color-mix()` function + - Relative color syntax, e.g. `lab(from purple calc(l * .8) a b)` + - [Color Level 4](https://drafts.csswg.org/css-color-4/) + - `lab()`, `lch()`, `oklab()`, and `oklch()` colors + - `color()` function supporting predefined color spaces such as `display-p3` and `xyz` + - Space separated components in `rgb` and `hsl` functions + - Hex with alpha syntax + - `hwb()` color syntax + - Percent syntax for opacity + - `#rgba` and `#rrggbbaa` hex colors + - Selectors + - `:not` with multiple arguments + - `:lang` with multiple arguments + - `:dir` + - `:is` + - Double position gradient stops (e.g. `red 40% 80%`) + - `clamp()`, `round()`, `rem()`, and `mod()` math functions + - Alignment shorthands (e.g. `place-items`) + - Two-value `overflow` shorthand + - Media query range syntax (e.g. `@media (width <= 100px)` or `@media (100px < width < 500px)`) + - Multi-value `display` property (e.g. `inline flex`) + - `system-ui` font family fallbacks +- **CSS modules** – Lightning CSS supports compiling a subset of [CSS modules](https://github.com/css-modules/css-modules) features. + - Locally scoped class and id selectors + - Locally scoped custom identifiers, e.g. `@keyframes` names, grid lines/areas, `@counter-style` names, etc. + - Opt-in support for locally scoped CSS variables and other dashed identifiers. + - `:local()` and `:global()` selectors + - The `composes` property +- **Custom transforms** – The Lightning CSS visitor API can be used to implement custom transform plugins. + +## Documentation + +Lightning CSS can be used from [Parcel](https://parceljs.org), as a standalone library from JavaScript or Rust, using a standalone CLI, or wrapped as a plugin within any other tool. See the [Lightning CSS website](https://lightningcss.dev/docs.html) for documentation. + +## Benchmarks + + + + +``` +$ node bench.js bootstrap-4.css +cssnano: 544.809ms +159636 bytes + +esbuild: 17.199ms +160332 bytes + +lightningcss: 4.16ms +143091 bytes + + +$ node bench.js animate.css +cssnano: 283.105ms +71723 bytes + +esbuild: 11.858ms +72183 bytes + +lightningcss: 1.973ms +23666 bytes + + +$ node bench.js tailwind.css +cssnano: 2.198s +1925626 bytes + +esbuild: 107.668ms +1961642 bytes + +lightningcss: 43.368ms +1824130 bytes +``` + +For more benchmarks comparing more tools and input, see [here](http://goalsmashers.github.io/css-minification-benchmark/). Note that some of the tools shown perform unsafe optimizations that may change the behavior of the original CSS in favor of smaller file size. Lightning CSS does not do this – the output CSS should always behave identically to the input. Keep this in mind when comparing file sizes between tools. diff --git a/client/node_modules/lightningcss/node/ast.d.ts b/client/node_modules/lightningcss/node/ast.d.ts new file mode 100644 index 0000000..a57fe7f --- /dev/null +++ b/client/node_modules/lightningcss/node/ast.d.ts @@ -0,0 +1,9965 @@ +/* eslint-disable */ +/** + * This file was automatically generated by json-schema-to-typescript. + * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file, + * and run json-schema-to-typescript to regenerate this file. + */ + +export type String = string; +/** + * A CSS rule. + */ +export type Rule = | { + type: "media"; + value: MediaRule; + } +| { + type: "import"; + value: ImportRule; + } +| { + type: "style"; + value: StyleRule; + } +| { + type: "keyframes"; + value: KeyframesRule; + } +| { + type: "font-face"; + value: FontFaceRule; + } +| { + type: "font-palette-values"; + value: FontPaletteValuesRule; + } +| { + type: "font-feature-values"; + value: FontFeatureValuesRule; + } +| { + type: "page"; + value: PageRule; + } +| { + type: "supports"; + value: SupportsRule; + } +| { + type: "counter-style"; + value: CounterStyleRule; + } +| { + type: "namespace"; + value: NamespaceRule; + } +| { + type: "moz-document"; + value: MozDocumentRule; + } +| { + type: "nesting"; + value: NestingRule; + } +| { + type: "nested-declarations"; + value: NestedDeclarationsRule; + } +| { + type: "viewport"; + value: ViewportRule; + } +| { + type: "custom-media"; + value: CustomMediaRule; + } +| { + type: "layer-statement"; + value: LayerStatementRule; + } +| { + type: "layer-block"; + value: LayerBlockRule; + } +| { + type: "property"; + value: PropertyRule; + } +| { + type: "container"; + value: ContainerRule; + } +| { + type: "scope"; + value: ScopeRule; + } +| { + type: "starting-style"; + value: StartingStyleRule; + } +| { + type: "view-transition"; + value: ViewTransitionRule; + } +| { + type: "position-try"; + value: PositionTryRule; + } +| { + type: "ignored"; + } +| { + type: "unknown"; + value: UnknownAtRule; + } +| { + type: "custom"; + value: DefaultAtRule; + }; +/** + * Represents a media condition. + */ +export type MediaCondition = + | { + type: "feature"; + value: QueryFeatureFor_MediaFeatureId; + } + | { + type: "not"; + value: MediaCondition; + } + | { + /** + * The conditions for the operator. + */ + conditions: MediaCondition[]; + /** + * The operator for the conditions. + */ + operator: Operator; + type: "operation"; + } + | { + type: "unknown"; + value: TokenOrValue[]; + }; +/** + * A generic media feature or container feature. + */ +export type QueryFeatureFor_MediaFeatureId = + | { + /** + * The name of the feature. + */ + name: MediaFeatureNameFor_MediaFeatureId; + type: "plain"; + /** + * The feature value. + */ + value: MediaFeatureValue; + } + | { + /** + * The name of the feature. + */ + name: MediaFeatureNameFor_MediaFeatureId; + type: "boolean"; + } + | { + /** + * The name of the feature. + */ + name: MediaFeatureNameFor_MediaFeatureId; + /** + * A comparator. + */ + operator: MediaFeatureComparison; + type: "range"; + /** + * The feature value. + */ + value: MediaFeatureValue; + } + | { + /** + * The end value. + */ + end: MediaFeatureValue; + /** + * A comparator for the end value. + */ + endOperator: MediaFeatureComparison; + /** + * The name of the feature. + */ + name: MediaFeatureNameFor_MediaFeatureId; + /** + * A start value. + */ + start: MediaFeatureValue; + /** + * A comparator for the start value. + */ + startOperator: MediaFeatureComparison; + type: "interval"; + }; +/** + * A media feature name. + */ +export type MediaFeatureNameFor_MediaFeatureId = MediaFeatureId | String | String; +/** + * A media query feature identifier. + */ +export type MediaFeatureId = + | "width" + | "height" + | "aspect-ratio" + | "orientation" + | "overflow-block" + | "overflow-inline" + | "horizontal-viewport-segments" + | "vertical-viewport-segments" + | "display-mode" + | "resolution" + | "scan" + | "grid" + | "update" + | "environment-blending" + | "color" + | "color-index" + | "monochrome" + | "color-gamut" + | "dynamic-range" + | "inverted-colors" + | "pointer" + | "hover" + | "any-pointer" + | "any-hover" + | "nav-controls" + | "video-color-gamut" + | "video-dynamic-range" + | "scripting" + | "prefers-reduced-motion" + | "prefers-reduced-transparency" + | "prefers-contrast" + | "forced-colors" + | "prefers-color-scheme" + | "prefers-reduced-data" + | "device-width" + | "device-height" + | "device-aspect-ratio" + | "-webkit-device-pixel-ratio" + | "-moz-device-pixel-ratio"; +/** + * [media feature value](https://drafts.csswg.org/mediaqueries/#typedef-mf-value) within a media query. + * + * See [MediaFeature](MediaFeature). + */ +export type MediaFeatureValue = + | { + type: "length"; + value: Length; + } + | { + type: "number"; + value: number; + } + | { + type: "integer"; + value: number; + } + | { + type: "boolean"; + value: boolean; + } + | { + type: "resolution"; + value: Resolution; + } + | { + type: "ratio"; + value: Ratio; + } + | { + type: "ident"; + value: String; + } + | { + type: "env"; + value: EnvironmentVariable; + }; +/** + * A CSS [``](https://www.w3.org/TR/css-values-4/#lengths) value, with support for `calc()`. + */ +export type Length = + | { + type: "value"; + value: LengthValue; + } + | { + type: "calc"; + value: CalcFor_Length; + }; +export type LengthUnit = + | "px" + | "in" + | "cm" + | "mm" + | "q" + | "pt" + | "pc" + | "em" + | "rem" + | "ex" + | "rex" + | "ch" + | "rch" + | "cap" + | "rcap" + | "ic" + | "ric" + | "lh" + | "rlh" + | "vw" + | "lvw" + | "svw" + | "dvw" + | "cqw" + | "vh" + | "lvh" + | "svh" + | "dvh" + | "cqh" + | "vi" + | "svi" + | "lvi" + | "dvi" + | "cqi" + | "vb" + | "svb" + | "lvb" + | "dvb" + | "cqb" + | "vmin" + | "svmin" + | "lvmin" + | "dvmin" + | "cqmin" + | "vmax" + | "svmax" + | "lvmax" + | "dvmax" + | "cqmax"; +/** + * A mathematical expression used within the [`calc()`](https://www.w3.org/TR/css-values-4/#calc-func) function. + * + * This type supports generic value types. Values such as [Length](super::length::Length), [Percentage](super::percentage::Percentage), [Time](super::time::Time), and [Angle](super::angle::Angle) support `calc()` expressions. + */ +export type CalcFor_Length = + | { + type: "value"; + value: Length; + } + | { + type: "number"; + value: number; + } + | { + type: "sum"; + /** + * @minItems 2 + * @maxItems 2 + */ + value: [CalcFor_Length, CalcFor_Length]; + } + | { + type: "product"; + /** + * @minItems 2 + * @maxItems 2 + */ + value: [number, CalcFor_Length]; + } + | { + type: "function"; + value: MathFunctionFor_Length; + }; +/** + * A CSS [math function](https://www.w3.org/TR/css-values-4/#math-function). + * + * Math functions may be used in most properties and values that accept numeric values, including lengths, percentages, angles, times, etc. + */ +export type MathFunctionFor_Length = + | { + type: "calc"; + value: CalcFor_Length; + } + | { + type: "min"; + value: CalcFor_Length[]; + } + | { + type: "max"; + value: CalcFor_Length[]; + } + | { + type: "clamp"; + /** + * @minItems 3 + * @maxItems 3 + */ + value: [CalcFor_Length, CalcFor_Length, CalcFor_Length]; + } + | { + type: "round"; + /** + * @minItems 3 + * @maxItems 3 + */ + value: [RoundingStrategy, CalcFor_Length, CalcFor_Length]; + } + | { + type: "rem"; + /** + * @minItems 2 + * @maxItems 2 + */ + value: [CalcFor_Length, CalcFor_Length]; + } + | { + type: "mod"; + /** + * @minItems 2 + * @maxItems 2 + */ + value: [CalcFor_Length, CalcFor_Length]; + } + | { + type: "abs"; + value: CalcFor_Length; + } + | { + type: "sign"; + value: CalcFor_Length; + } + | { + type: "hypot"; + value: CalcFor_Length[]; + }; +/** + * A [rounding strategy](https://www.w3.org/TR/css-values-4/#typedef-rounding-strategy), as used in the `round()` function. + */ +export type RoundingStrategy = "nearest" | "up" | "down" | "to-zero"; +/** + * A CSS [``](https://www.w3.org/TR/css-values-4/#resolution) value. + */ +export type Resolution = + | { + type: "dpi"; + value: number; + } + | { + type: "dpcm"; + value: number; + } + | { + type: "dppx"; + value: number; + }; +/** + * A CSS [``](https://www.w3.org/TR/css-values-4/#ratios) value, representing the ratio of two numeric values. + * + * @minItems 2 + * @maxItems 2 + */ +export type Ratio = [number, number]; +/** + * A raw CSS token, or a parsed value. + */ +export type TokenOrValue = + | { + type: "token"; + value: Token; + } + | { + type: "color"; + value: CssColor; + } + | { + type: "unresolved-color"; + value: UnresolvedColor; + } + | { + type: "url"; + value: Url; + } + | { + type: "var"; + value: Variable; + } + | { + type: "env"; + value: EnvironmentVariable; + } + | { + type: "function"; + value: Function; + } + | { + type: "length"; + value: LengthValue; + } + | { + type: "angle"; + value: Angle; + } + | { + type: "time"; + value: Time; + } + | { + type: "resolution"; + value: Resolution; + } + | { + type: "dashed-ident"; + value: String; + } + | { + type: "animation-name"; + value: AnimationName; + }; +/** + * A raw CSS token. + */ +export type Token = + | { + type: "ident"; + value: String; + } + | { + type: "at-keyword"; + value: String; + } + | { + type: "hash"; + value: String; + } + | { + type: "id-hash"; + value: String; + } + | { + type: "string"; + value: String; + } + | { + type: "unquoted-url"; + value: String; + } + | { + type: "delim"; + value: string; + } + | { + type: "number"; + /** + * The value as a float + */ + value: number; + } + | { + type: "percentage"; + /** + * The value as a float, divided by 100 so that the nominal range is 0.0 to 1.0. + */ + value: number; + } + | { + type: "dimension"; + /** + * The unit, e.g. "px" in `12px` + */ + unit: String; + /** + * The value as a float + */ + value: number; + } + | { + type: "white-space"; + value: String; + } + | { + type: "comment"; + value: String; + } + | { + type: "colon"; + } + | { + type: "semicolon"; + } + | { + type: "comma"; + } + | { + type: "include-match"; + } + | { + type: "dash-match"; + } + | { + type: "prefix-match"; + } + | { + type: "suffix-match"; + } + | { + type: "substring-match"; + } + | { + type: "cdo"; + } + | { + type: "cdc"; + } + | { + type: "function"; + value: String; + } + | { + type: "parenthesis-block"; + } + | { + type: "square-bracket-block"; + } + | { + type: "curly-bracket-block"; + } + | { + type: "bad-url"; + value: String; + } + | { + type: "bad-string"; + value: String; + } + | { + type: "close-parenthesis"; + } + | { + type: "close-square-bracket"; + } + | { + type: "close-curly-bracket"; + }; +/** + * A CSS [``](https://www.w3.org/TR/css-color-4/#color-type) value. + * + * CSS supports many different color spaces to represent colors. The most common values are stored as RGBA using a single byte per component. Less common values are stored using a `Box` to reduce the amount of memory used per color. + * + * Each color space is represented as a struct that implements the `From` and `Into` traits for all other color spaces, so it is possible to convert between color spaces easily. In addition, colors support [interpolation](#method.interpolate) as in the `color-mix()` function. + */ +export type CssColor = CurrentColor | RGBColor | LABColor | PredefinedColor | FloatColor | LightDark | SystemColor; +export type CurrentColor = { + type: "currentcolor"; +}; +export type RGBColor = { + /** + * The alpha component. + */ + alpha: number; + /** + * The blue component. + */ + b: number; + /** + * The green component. + */ + g: number; + /** + * The red component. + */ + r: number; + type: "rgb"; +}; +/** + * A color in a LAB color space, including the `lab()`, `lch()`, `oklab()`, and `oklch()` functions. + */ +export type LABColor = + | { + /** + * The a component. + */ + a: number; + /** + * The alpha component. + */ + alpha: number; + /** + * The b component. + */ + b: number; + /** + * The lightness component. + */ + l: number; + type: "lab"; + } + | { + /** + * The alpha component. + */ + alpha: number; + /** + * The chroma component. + */ + c: number; + /** + * The hue component. + */ + h: number; + /** + * The lightness component. + */ + l: number; + type: "lch"; + } + | { + /** + * The a component. + */ + a: number; + /** + * The alpha component. + */ + alpha: number; + /** + * The b component. + */ + b: number; + /** + * The lightness component. + */ + l: number; + type: "oklab"; + } + | { + /** + * The alpha component. + */ + alpha: number; + /** + * The chroma component. + */ + c: number; + /** + * The hue component. + */ + h: number; + /** + * The lightness component. + */ + l: number; + type: "oklch"; + }; +/** + * A color in a predefined color space, e.g. `display-p3`. + */ +export type PredefinedColor = + | { + /** + * The alpha component. + */ + alpha: number; + /** + * The blue component. + */ + b: number; + /** + * The green component. + */ + g: number; + /** + * The red component. + */ + r: number; + type: "srgb"; + } + | { + /** + * The alpha component. + */ + alpha: number; + /** + * The blue component. + */ + b: number; + /** + * The green component. + */ + g: number; + /** + * The red component. + */ + r: number; + type: "srgb-linear"; + } + | { + /** + * The alpha component. + */ + alpha: number; + /** + * The blue component. + */ + b: number; + /** + * The green component. + */ + g: number; + /** + * The red component. + */ + r: number; + type: "display-p3"; + } + | { + /** + * The alpha component. + */ + alpha: number; + /** + * The blue component. + */ + b: number; + /** + * The green component. + */ + g: number; + /** + * The red component. + */ + r: number; + type: "a98-rgb"; + } + | { + /** + * The alpha component. + */ + alpha: number; + /** + * The blue component. + */ + b: number; + /** + * The green component. + */ + g: number; + /** + * The red component. + */ + r: number; + type: "prophoto-rgb"; + } + | { + /** + * The alpha component. + */ + alpha: number; + /** + * The blue component. + */ + b: number; + /** + * The green component. + */ + g: number; + /** + * The red component. + */ + r: number; + type: "rec2020"; + } + | { + /** + * The alpha component. + */ + alpha: number; + type: "xyz-d50"; + /** + * The x component. + */ + x: number; + /** + * The y component. + */ + y: number; + /** + * The z component. + */ + z: number; + } + | { + /** + * The alpha component. + */ + alpha: number; + type: "xyz-d65"; + /** + * The x component. + */ + x: number; + /** + * The y component. + */ + y: number; + /** + * The z component. + */ + z: number; + }; +/** + * A floating point representation of color types that are usually stored as RGBA. These are used when there are any `none` components, which are represented as NaN. + */ +export type FloatColor = + | { + /** + * The alpha component. + */ + alpha: number; + /** + * The blue component. + */ + b: number; + /** + * The green component. + */ + g: number; + /** + * The red component. + */ + r: number; + type: "rgb"; + } + | { + /** + * The alpha component. + */ + alpha: number; + /** + * The hue component. + */ + h: number; + /** + * The lightness component. + */ + l: number; + /** + * The saturation component. + */ + s: number; + type: "hsl"; + } + | { + /** + * The alpha component. + */ + alpha: number; + /** + * The blackness component. + */ + b: number; + /** + * The hue component. + */ + h: number; + type: "hwb"; + /** + * The whiteness component. + */ + w: number; + }; +export type LightDark = { + dark: CssColor; + light: CssColor; + type: "light-dark"; +}; +/** + * A CSS [system color](https://drafts.csswg.org/css-color/#css-system-colors) keyword. + */ +export type SystemColor = + | "accentcolor" + | "accentcolortext" + | "activetext" + | "buttonborder" + | "buttonface" + | "buttontext" + | "canvas" + | "canvastext" + | "field" + | "fieldtext" + | "graytext" + | "highlight" + | "highlighttext" + | "linktext" + | "mark" + | "marktext" + | "selecteditem" + | "selecteditemtext" + | "visitedtext" + | "activeborder" + | "activecaption" + | "appworkspace" + | "background" + | "buttonhighlight" + | "buttonshadow" + | "captiontext" + | "inactiveborder" + | "inactivecaption" + | "inactivecaptiontext" + | "infobackground" + | "infotext" + | "menu" + | "menutext" + | "scrollbar" + | "threeddarkshadow" + | "threedface" + | "threedhighlight" + | "threedlightshadow" + | "threedshadow" + | "window" + | "windowframe" + | "windowtext"; +/** + * A color value with an unresolved alpha value (e.g. a variable). These can be converted from the modern slash syntax to older comma syntax. This can only be done when the only unresolved component is the alpha since variables can resolve to multiple tokens. + */ +export type UnresolvedColor = + | { + /** + * The unresolved alpha component. + */ + alpha: TokenOrValue[]; + /** + * The blue component. + */ + b: number; + /** + * The green component. + */ + g: number; + /** + * The red component. + */ + r: number; + type: "rgb"; + } + | { + /** + * The unresolved alpha component. + */ + alpha: TokenOrValue[]; + /** + * The hue component. + */ + h: number; + /** + * The lightness component. + */ + l: number; + /** + * The saturation component. + */ + s: number; + type: "hsl"; + } + | { + /** + * The dark value. + */ + dark: TokenOrValue[]; + /** + * The light value. + */ + light: TokenOrValue[]; + type: "light-dark"; + }; +/** + * Defines where the class names referenced in the `composes` property are located. + * + * See [Composes](Composes). + */ +export type Specifier = + | { + type: "global"; + } + | { + type: "file"; + value: String; + } + | { + type: "source-index"; + value: number; + }; +/** + * A CSS [``](https://www.w3.org/TR/css-values-4/#angles) value. + * + * Angles may be explicit or computed by `calc()`, but are always stored and serialized as their computed value. + */ +export type Angle = + | { + type: "deg"; + value: number; + } + | { + type: "rad"; + value: number; + } + | { + type: "grad"; + value: number; + } + | { + type: "turn"; + value: number; + }; +/** + * A CSS [``](https://www.w3.org/TR/css-values-4/#time) value, in either seconds or milliseconds. + * + * Time values may be explicit or computed by `calc()`, but are always stored and serialized as their computed value. + */ +export type Time = + | { + type: "seconds"; + value: number; + } + | { + type: "milliseconds"; + value: number; + }; +/** + * A value for the [animation-name](https://drafts.csswg.org/css-animations/#animation-name) property. + */ +export type AnimationName = + | { + type: "none"; + } + | { + type: "ident"; + value: String; + } + | { + type: "string"; + value: String; + }; +/** + * A CSS environment variable name. + */ +export type EnvironmentVariableName = + | { + type: "ua"; + value: UAEnvironmentVariable; + } + | { + /** + * CSS modules extension: the filename where the variable is defined. Only enabled when the CSS modules `dashed_idents` option is turned on. + */ + from?: Specifier | null; + /** + * The referenced identifier. + */ + ident: String; + type: "custom"; + } + | { + type: "unknown"; + value: String; + }; +/** + * A UA-defined environment variable name. + */ +export type UAEnvironmentVariable = + | "safe-area-inset-top" + | "safe-area-inset-right" + | "safe-area-inset-bottom" + | "safe-area-inset-left" + | "viewport-segment-width" + | "viewport-segment-height" + | "viewport-segment-top" + | "viewport-segment-left" + | "viewport-segment-bottom" + | "viewport-segment-right"; +/** + * A [comparator](https://drafts.csswg.org/mediaqueries/#typedef-mf-comparison) within a media query. + */ +export type MediaFeatureComparison = "equal" | "greater-than" | "greater-than-equal" | "less-than" | "less-than-equal"; +/** + * A binary `and` or `or` operator. + */ +export type Operator = "and" | "or"; +export type MediaType = string; +/** + * A [media query qualifier](https://drafts.csswg.org/mediaqueries/#mq-prefix). + */ +export type Qualifier = "only" | "not"; +/** + * A [``](https://drafts.csswg.org/css-conditional-3/#typedef-supports-condition), as used in the `@supports` and `@import` rules. + */ +export type SupportsCondition = + | { + type: "not"; + value: SupportsCondition; + } + | { + type: "and"; + value: SupportsCondition[]; + } + | { + type: "or"; + value: SupportsCondition[]; + } + | { + /** + * The property id for the declaration. + */ + propertyId: PropertyId; + type: "declaration"; + /** + * The raw value of the declaration. + */ + value: String; + } + | { + type: "selector"; + value: String; + } + | { + type: "unknown"; + value: String; + }; +export type PropertyId = + | { + property: "background-color"; + } + | { + property: "background-image"; + } + | { + property: "background-position-x"; + } + | { + property: "background-position-y"; + } + | { + property: "background-position"; + } + | { + property: "background-size"; + } + | { + property: "background-repeat"; + } + | { + property: "background-attachment"; + } + | { + property: "background-clip"; + vendorPrefix: VendorPrefix; + } + | { + property: "background-origin"; + } + | { + property: "background"; + } + | { + property: "box-shadow"; + vendorPrefix: VendorPrefix; + } + | { + property: "opacity"; + } + | { + property: "color"; + } + | { + property: "display"; + } + | { + property: "visibility"; + } + | { + property: "width"; + } + | { + property: "height"; + } + | { + property: "min-width"; + } + | { + property: "min-height"; + } + | { + property: "max-width"; + } + | { + property: "max-height"; + } + | { + property: "block-size"; + } + | { + property: "inline-size"; + } + | { + property: "min-block-size"; + } + | { + property: "min-inline-size"; + } + | { + property: "max-block-size"; + } + | { + property: "max-inline-size"; + } + | { + property: "box-sizing"; + vendorPrefix: VendorPrefix; + } + | { + property: "aspect-ratio"; + } + | { + property: "overflow"; + } + | { + property: "overflow-x"; + } + | { + property: "overflow-y"; + } + | { + property: "text-overflow"; + vendorPrefix: VendorPrefix; + } + | { + property: "position"; + } + | { + property: "top"; + } + | { + property: "bottom"; + } + | { + property: "left"; + } + | { + property: "right"; + } + | { + property: "inset-block-start"; + } + | { + property: "inset-block-end"; + } + | { + property: "inset-inline-start"; + } + | { + property: "inset-inline-end"; + } + | { + property: "inset-block"; + } + | { + property: "inset-inline"; + } + | { + property: "inset"; + } + | { + property: "border-spacing"; + } + | { + property: "border-top-color"; + } + | { + property: "border-bottom-color"; + } + | { + property: "border-left-color"; + } + | { + property: "border-right-color"; + } + | { + property: "border-block-start-color"; + } + | { + property: "border-block-end-color"; + } + | { + property: "border-inline-start-color"; + } + | { + property: "border-inline-end-color"; + } + | { + property: "border-top-style"; + } + | { + property: "border-bottom-style"; + } + | { + property: "border-left-style"; + } + | { + property: "border-right-style"; + } + | { + property: "border-block-start-style"; + } + | { + property: "border-block-end-style"; + } + | { + property: "border-inline-start-style"; + } + | { + property: "border-inline-end-style"; + } + | { + property: "border-top-width"; + } + | { + property: "border-bottom-width"; + } + | { + property: "border-left-width"; + } + | { + property: "border-right-width"; + } + | { + property: "border-block-start-width"; + } + | { + property: "border-block-end-width"; + } + | { + property: "border-inline-start-width"; + } + | { + property: "border-inline-end-width"; + } + | { + property: "border-top-left-radius"; + vendorPrefix: VendorPrefix; + } + | { + property: "border-top-right-radius"; + vendorPrefix: VendorPrefix; + } + | { + property: "border-bottom-left-radius"; + vendorPrefix: VendorPrefix; + } + | { + property: "border-bottom-right-radius"; + vendorPrefix: VendorPrefix; + } + | { + property: "border-start-start-radius"; + } + | { + property: "border-start-end-radius"; + } + | { + property: "border-end-start-radius"; + } + | { + property: "border-end-end-radius"; + } + | { + property: "border-radius"; + vendorPrefix: VendorPrefix; + } + | { + property: "border-image-source"; + } + | { + property: "border-image-outset"; + } + | { + property: "border-image-repeat"; + } + | { + property: "border-image-width"; + } + | { + property: "border-image-slice"; + } + | { + property: "border-image"; + vendorPrefix: VendorPrefix; + } + | { + property: "border-color"; + } + | { + property: "border-style"; + } + | { + property: "border-width"; + } + | { + property: "border-block-color"; + } + | { + property: "border-block-style"; + } + | { + property: "border-block-width"; + } + | { + property: "border-inline-color"; + } + | { + property: "border-inline-style"; + } + | { + property: "border-inline-width"; + } + | { + property: "border"; + } + | { + property: "border-top"; + } + | { + property: "border-bottom"; + } + | { + property: "border-left"; + } + | { + property: "border-right"; + } + | { + property: "border-block"; + } + | { + property: "border-block-start"; + } + | { + property: "border-block-end"; + } + | { + property: "border-inline"; + } + | { + property: "border-inline-start"; + } + | { + property: "border-inline-end"; + } + | { + property: "outline"; + } + | { + property: "outline-color"; + } + | { + property: "outline-style"; + } + | { + property: "outline-width"; + } + | { + property: "flex-direction"; + vendorPrefix: VendorPrefix; + } + | { + property: "flex-wrap"; + vendorPrefix: VendorPrefix; + } + | { + property: "flex-flow"; + vendorPrefix: VendorPrefix; + } + | { + property: "flex-grow"; + vendorPrefix: VendorPrefix; + } + | { + property: "flex-shrink"; + vendorPrefix: VendorPrefix; + } + | { + property: "flex-basis"; + vendorPrefix: VendorPrefix; + } + | { + property: "flex"; + vendorPrefix: VendorPrefix; + } + | { + property: "order"; + vendorPrefix: VendorPrefix; + } + | { + property: "align-content"; + vendorPrefix: VendorPrefix; + } + | { + property: "justify-content"; + vendorPrefix: VendorPrefix; + } + | { + property: "place-content"; + } + | { + property: "align-self"; + vendorPrefix: VendorPrefix; + } + | { + property: "justify-self"; + } + | { + property: "place-self"; + } + | { + property: "align-items"; + vendorPrefix: VendorPrefix; + } + | { + property: "justify-items"; + } + | { + property: "place-items"; + } + | { + property: "row-gap"; + } + | { + property: "column-gap"; + } + | { + property: "gap"; + } + | { + property: "box-orient"; + vendorPrefix: VendorPrefix; + } + | { + property: "box-direction"; + vendorPrefix: VendorPrefix; + } + | { + property: "box-ordinal-group"; + vendorPrefix: VendorPrefix; + } + | { + property: "box-align"; + vendorPrefix: VendorPrefix; + } + | { + property: "box-flex"; + vendorPrefix: VendorPrefix; + } + | { + property: "box-flex-group"; + vendorPrefix: VendorPrefix; + } + | { + property: "box-pack"; + vendorPrefix: VendorPrefix; + } + | { + property: "box-lines"; + vendorPrefix: VendorPrefix; + } + | { + property: "flex-pack"; + vendorPrefix: VendorPrefix; + } + | { + property: "flex-order"; + vendorPrefix: VendorPrefix; + } + | { + property: "flex-align"; + vendorPrefix: VendorPrefix; + } + | { + property: "flex-item-align"; + vendorPrefix: VendorPrefix; + } + | { + property: "flex-line-pack"; + vendorPrefix: VendorPrefix; + } + | { + property: "flex-positive"; + vendorPrefix: VendorPrefix; + } + | { + property: "flex-negative"; + vendorPrefix: VendorPrefix; + } + | { + property: "flex-preferred-size"; + vendorPrefix: VendorPrefix; + } + | { + property: "grid-template-columns"; + } + | { + property: "grid-template-rows"; + } + | { + property: "grid-auto-columns"; + } + | { + property: "grid-auto-rows"; + } + | { + property: "grid-auto-flow"; + } + | { + property: "grid-template-areas"; + } + | { + property: "grid-template"; + } + | { + property: "grid"; + } + | { + property: "grid-row-start"; + } + | { + property: "grid-row-end"; + } + | { + property: "grid-column-start"; + } + | { + property: "grid-column-end"; + } + | { + property: "grid-row"; + } + | { + property: "grid-column"; + } + | { + property: "grid-area"; + } + | { + property: "margin-top"; + } + | { + property: "margin-bottom"; + } + | { + property: "margin-left"; + } + | { + property: "margin-right"; + } + | { + property: "margin-block-start"; + } + | { + property: "margin-block-end"; + } + | { + property: "margin-inline-start"; + } + | { + property: "margin-inline-end"; + } + | { + property: "margin-block"; + } + | { + property: "margin-inline"; + } + | { + property: "margin"; + } + | { + property: "padding-top"; + } + | { + property: "padding-bottom"; + } + | { + property: "padding-left"; + } + | { + property: "padding-right"; + } + | { + property: "padding-block-start"; + } + | { + property: "padding-block-end"; + } + | { + property: "padding-inline-start"; + } + | { + property: "padding-inline-end"; + } + | { + property: "padding-block"; + } + | { + property: "padding-inline"; + } + | { + property: "padding"; + } + | { + property: "scroll-margin-top"; + } + | { + property: "scroll-margin-bottom"; + } + | { + property: "scroll-margin-left"; + } + | { + property: "scroll-margin-right"; + } + | { + property: "scroll-margin-block-start"; + } + | { + property: "scroll-margin-block-end"; + } + | { + property: "scroll-margin-inline-start"; + } + | { + property: "scroll-margin-inline-end"; + } + | { + property: "scroll-margin-block"; + } + | { + property: "scroll-margin-inline"; + } + | { + property: "scroll-margin"; + } + | { + property: "scroll-padding-top"; + } + | { + property: "scroll-padding-bottom"; + } + | { + property: "scroll-padding-left"; + } + | { + property: "scroll-padding-right"; + } + | { + property: "scroll-padding-block-start"; + } + | { + property: "scroll-padding-block-end"; + } + | { + property: "scroll-padding-inline-start"; + } + | { + property: "scroll-padding-inline-end"; + } + | { + property: "scroll-padding-block"; + } + | { + property: "scroll-padding-inline"; + } + | { + property: "scroll-padding"; + } + | { + property: "font-weight"; + } + | { + property: "font-size"; + } + | { + property: "font-stretch"; + } + | { + property: "font-family"; + } + | { + property: "font-style"; + } + | { + property: "font-variant-caps"; + } + | { + property: "line-height"; + } + | { + property: "font"; + } + | { + property: "vertical-align"; + } + | { + property: "font-palette"; + } + | { + property: "transition-property"; + vendorPrefix: VendorPrefix; + } + | { + property: "transition-duration"; + vendorPrefix: VendorPrefix; + } + | { + property: "transition-delay"; + vendorPrefix: VendorPrefix; + } + | { + property: "transition-timing-function"; + vendorPrefix: VendorPrefix; + } + | { + property: "transition"; + vendorPrefix: VendorPrefix; + } + | { + property: "animation-name"; + vendorPrefix: VendorPrefix; + } + | { + property: "animation-duration"; + vendorPrefix: VendorPrefix; + } + | { + property: "animation-timing-function"; + vendorPrefix: VendorPrefix; + } + | { + property: "animation-iteration-count"; + vendorPrefix: VendorPrefix; + } + | { + property: "animation-direction"; + vendorPrefix: VendorPrefix; + } + | { + property: "animation-play-state"; + vendorPrefix: VendorPrefix; + } + | { + property: "animation-delay"; + vendorPrefix: VendorPrefix; + } + | { + property: "animation-fill-mode"; + vendorPrefix: VendorPrefix; + } + | { + property: "animation-composition"; + } + | { + property: "animation-timeline"; + } + | { + property: "animation-range-start"; + } + | { + property: "animation-range-end"; + } + | { + property: "animation-range"; + } + | { + property: "animation"; + vendorPrefix: VendorPrefix; + } + | { + property: "transform"; + vendorPrefix: VendorPrefix; + } + | { + property: "transform-origin"; + vendorPrefix: VendorPrefix; + } + | { + property: "transform-style"; + vendorPrefix: VendorPrefix; + } + | { + property: "transform-box"; + } + | { + property: "backface-visibility"; + vendorPrefix: VendorPrefix; + } + | { + property: "perspective"; + vendorPrefix: VendorPrefix; + } + | { + property: "perspective-origin"; + vendorPrefix: VendorPrefix; + } + | { + property: "translate"; + } + | { + property: "rotate"; + } + | { + property: "scale"; + } + | { + property: "text-transform"; + } + | { + property: "white-space"; + } + | { + property: "tab-size"; + vendorPrefix: VendorPrefix; + } + | { + property: "word-break"; + } + | { + property: "line-break"; + } + | { + property: "hyphens"; + vendorPrefix: VendorPrefix; + } + | { + property: "overflow-wrap"; + } + | { + property: "word-wrap"; + } + | { + property: "text-align"; + } + | { + property: "text-align-last"; + vendorPrefix: VendorPrefix; + } + | { + property: "text-justify"; + } + | { + property: "word-spacing"; + } + | { + property: "letter-spacing"; + } + | { + property: "text-indent"; + } + | { + property: "text-decoration-line"; + vendorPrefix: VendorPrefix; + } + | { + property: "text-decoration-style"; + vendorPrefix: VendorPrefix; + } + | { + property: "text-decoration-color"; + vendorPrefix: VendorPrefix; + } + | { + property: "text-decoration-thickness"; + } + | { + property: "text-decoration"; + vendorPrefix: VendorPrefix; + } + | { + property: "text-decoration-skip-ink"; + vendorPrefix: VendorPrefix; + } + | { + property: "text-emphasis-style"; + vendorPrefix: VendorPrefix; + } + | { + property: "text-emphasis-color"; + vendorPrefix: VendorPrefix; + } + | { + property: "text-emphasis"; + vendorPrefix: VendorPrefix; + } + | { + property: "text-emphasis-position"; + vendorPrefix: VendorPrefix; + } + | { + property: "text-shadow"; + } + | { + property: "text-size-adjust"; + vendorPrefix: VendorPrefix; + } + | { + property: "direction"; + } + | { + property: "unicode-bidi"; + } + | { + property: "box-decoration-break"; + vendorPrefix: VendorPrefix; + } + | { + property: "resize"; + } + | { + property: "cursor"; + } + | { + property: "caret-color"; + } + | { + property: "caret-shape"; + } + | { + property: "caret"; + } + | { + property: "user-select"; + vendorPrefix: VendorPrefix; + } + | { + property: "accent-color"; + } + | { + property: "appearance"; + vendorPrefix: VendorPrefix; + } + | { + property: "list-style-type"; + } + | { + property: "list-style-image"; + } + | { + property: "list-style-position"; + } + | { + property: "list-style"; + } + | { + property: "marker-side"; + } + | { + property: "composes"; + } + | { + property: "fill"; + } + | { + property: "fill-rule"; + } + | { + property: "fill-opacity"; + } + | { + property: "stroke"; + } + | { + property: "stroke-opacity"; + } + | { + property: "stroke-width"; + } + | { + property: "stroke-linecap"; + } + | { + property: "stroke-linejoin"; + } + | { + property: "stroke-miterlimit"; + } + | { + property: "stroke-dasharray"; + } + | { + property: "stroke-dashoffset"; + } + | { + property: "marker-start"; + } + | { + property: "marker-mid"; + } + | { + property: "marker-end"; + } + | { + property: "marker"; + } + | { + property: "color-interpolation"; + } + | { + property: "color-interpolation-filters"; + } + | { + property: "color-rendering"; + } + | { + property: "shape-rendering"; + } + | { + property: "text-rendering"; + } + | { + property: "image-rendering"; + } + | { + property: "clip-path"; + vendorPrefix: VendorPrefix; + } + | { + property: "clip-rule"; + } + | { + property: "mask-image"; + vendorPrefix: VendorPrefix; + } + | { + property: "mask-mode"; + } + | { + property: "mask-repeat"; + vendorPrefix: VendorPrefix; + } + | { + property: "mask-position-x"; + } + | { + property: "mask-position-y"; + } + | { + property: "mask-position"; + vendorPrefix: VendorPrefix; + } + | { + property: "mask-clip"; + vendorPrefix: VendorPrefix; + } + | { + property: "mask-origin"; + vendorPrefix: VendorPrefix; + } + | { + property: "mask-size"; + vendorPrefix: VendorPrefix; + } + | { + property: "mask-composite"; + } + | { + property: "mask-type"; + } + | { + property: "mask"; + vendorPrefix: VendorPrefix; + } + | { + property: "mask-border-source"; + } + | { + property: "mask-border-mode"; + } + | { + property: "mask-border-slice"; + } + | { + property: "mask-border-width"; + } + | { + property: "mask-border-outset"; + } + | { + property: "mask-border-repeat"; + } + | { + property: "mask-border"; + } + | { + property: "-webkit-mask-composite"; + } + | { + property: "mask-source-type"; + vendorPrefix: VendorPrefix; + } + | { + property: "mask-box-image"; + vendorPrefix: VendorPrefix; + } + | { + property: "mask-box-image-source"; + vendorPrefix: VendorPrefix; + } + | { + property: "mask-box-image-slice"; + vendorPrefix: VendorPrefix; + } + | { + property: "mask-box-image-width"; + vendorPrefix: VendorPrefix; + } + | { + property: "mask-box-image-outset"; + vendorPrefix: VendorPrefix; + } + | { + property: "mask-box-image-repeat"; + vendorPrefix: VendorPrefix; + } + | { + property: "filter"; + vendorPrefix: VendorPrefix; + } + | { + property: "backdrop-filter"; + vendorPrefix: VendorPrefix; + } + | { + property: "mix-blend-mode"; + } + | { + property: "z-index"; + } + | { + property: "container-type"; + } + | { + property: "container-name"; + } + | { + property: "container"; + } + | { + property: "view-transition-name"; + } + | { + property: "view-transition-class"; + } + | { + property: "view-transition-group"; + } + | { + property: "color-scheme"; + } + | { + property: "print-color-adjust"; + vendorPrefix: VendorPrefix; + } + | { + property: "all"; + } + | { + property: string; + }; +export type Prefix = "none" | "webkit" | "moz" | "ms" | "o"; +export type VendorPrefix = Prefix[]; +export type Declaration = + | { + property: "background-color"; + value: CssColor; + } + | { + property: "background-image"; + value: Image[]; + } + | { + property: "background-position-x"; + value: PositionComponentFor_HorizontalPositionKeyword[]; + } + | { + property: "background-position-y"; + value: PositionComponentFor_VerticalPositionKeyword[]; + } + | { + property: "background-position"; + value: BackgroundPosition[]; + } + | { + property: "background-size"; + value: BackgroundSize[]; + } + | { + property: "background-repeat"; + value: BackgroundRepeat[]; + } + | { + property: "background-attachment"; + value: BackgroundAttachment[]; + } + | { + property: "background-clip"; + value: BackgroundClip[]; + vendorPrefix: VendorPrefix; + } + | { + property: "background-origin"; + value: BackgroundOrigin[]; + } + | { + property: "background"; + value: Background[]; + } + | { + property: "box-shadow"; + value: BoxShadow[]; + vendorPrefix: VendorPrefix; + } + | { + property: "opacity"; + value: number; + } + | { + property: "color"; + value: CssColor; + } + | { + property: "display"; + value: Display; + } + | { + property: "visibility"; + value: Visibility; + } + | { + property: "width"; + value: Size; + } + | { + property: "height"; + value: Size; + } + | { + property: "min-width"; + value: Size; + } + | { + property: "min-height"; + value: Size; + } + | { + property: "max-width"; + value: MaxSize; + } + | { + property: "max-height"; + value: MaxSize; + } + | { + property: "block-size"; + value: Size; + } + | { + property: "inline-size"; + value: Size; + } + | { + property: "min-block-size"; + value: Size; + } + | { + property: "min-inline-size"; + value: Size; + } + | { + property: "max-block-size"; + value: MaxSize; + } + | { + property: "max-inline-size"; + value: MaxSize; + } + | { + property: "box-sizing"; + value: BoxSizing; + vendorPrefix: VendorPrefix; + } + | { + property: "aspect-ratio"; + value: AspectRatio; + } + | { + property: "overflow"; + value: Overflow; + } + | { + property: "overflow-x"; + value: OverflowKeyword; + } + | { + property: "overflow-y"; + value: OverflowKeyword; + } + | { + property: "text-overflow"; + value: TextOverflow; + vendorPrefix: VendorPrefix; + } + | { + property: "position"; + value: Position2; + } + | { + property: "top"; + value: LengthPercentageOrAuto; + } + | { + property: "bottom"; + value: LengthPercentageOrAuto; + } + | { + property: "left"; + value: LengthPercentageOrAuto; + } + | { + property: "right"; + value: LengthPercentageOrAuto; + } + | { + property: "inset-block-start"; + value: LengthPercentageOrAuto; + } + | { + property: "inset-block-end"; + value: LengthPercentageOrAuto; + } + | { + property: "inset-inline-start"; + value: LengthPercentageOrAuto; + } + | { + property: "inset-inline-end"; + value: LengthPercentageOrAuto; + } + | { + property: "inset-block"; + value: InsetBlock; + } + | { + property: "inset-inline"; + value: InsetInline; + } + | { + property: "inset"; + value: Inset; + } + | { + property: "border-spacing"; + value: Size2DFor_Length; + } + | { + property: "border-top-color"; + value: CssColor; + } + | { + property: "border-bottom-color"; + value: CssColor; + } + | { + property: "border-left-color"; + value: CssColor; + } + | { + property: "border-right-color"; + value: CssColor; + } + | { + property: "border-block-start-color"; + value: CssColor; + } + | { + property: "border-block-end-color"; + value: CssColor; + } + | { + property: "border-inline-start-color"; + value: CssColor; + } + | { + property: "border-inline-end-color"; + value: CssColor; + } + | { + property: "border-top-style"; + value: LineStyle; + } + | { + property: "border-bottom-style"; + value: LineStyle; + } + | { + property: "border-left-style"; + value: LineStyle; + } + | { + property: "border-right-style"; + value: LineStyle; + } + | { + property: "border-block-start-style"; + value: LineStyle; + } + | { + property: "border-block-end-style"; + value: LineStyle; + } + | { + property: "border-inline-start-style"; + value: LineStyle; + } + | { + property: "border-inline-end-style"; + value: LineStyle; + } + | { + property: "border-top-width"; + value: BorderSideWidth; + } + | { + property: "border-bottom-width"; + value: BorderSideWidth; + } + | { + property: "border-left-width"; + value: BorderSideWidth; + } + | { + property: "border-right-width"; + value: BorderSideWidth; + } + | { + property: "border-block-start-width"; + value: BorderSideWidth; + } + | { + property: "border-block-end-width"; + value: BorderSideWidth; + } + | { + property: "border-inline-start-width"; + value: BorderSideWidth; + } + | { + property: "border-inline-end-width"; + value: BorderSideWidth; + } + | { + property: "border-top-left-radius"; + value: Size2DFor_DimensionPercentageFor_LengthValue; + vendorPrefix: VendorPrefix; + } + | { + property: "border-top-right-radius"; + value: Size2DFor_DimensionPercentageFor_LengthValue; + vendorPrefix: VendorPrefix; + } + | { + property: "border-bottom-left-radius"; + value: Size2DFor_DimensionPercentageFor_LengthValue; + vendorPrefix: VendorPrefix; + } + | { + property: "border-bottom-right-radius"; + value: Size2DFor_DimensionPercentageFor_LengthValue; + vendorPrefix: VendorPrefix; + } + | { + property: "border-start-start-radius"; + value: Size2DFor_DimensionPercentageFor_LengthValue; + } + | { + property: "border-start-end-radius"; + value: Size2DFor_DimensionPercentageFor_LengthValue; + } + | { + property: "border-end-start-radius"; + value: Size2DFor_DimensionPercentageFor_LengthValue; + } + | { + property: "border-end-end-radius"; + value: Size2DFor_DimensionPercentageFor_LengthValue; + } + | { + property: "border-radius"; + value: BorderRadius; + vendorPrefix: VendorPrefix; + } + | { + property: "border-image-source"; + value: Image; + } + | { + property: "border-image-outset"; + value: RectFor_LengthOrNumber; + } + | { + property: "border-image-repeat"; + value: BorderImageRepeat; + } + | { + property: "border-image-width"; + value: RectFor_BorderImageSideWidth; + } + | { + property: "border-image-slice"; + value: BorderImageSlice; + } + | { + property: "border-image"; + value: BorderImage; + vendorPrefix: VendorPrefix; + } + | { + property: "border-color"; + value: BorderColor; + } + | { + property: "border-style"; + value: BorderStyle; + } + | { + property: "border-width"; + value: BorderWidth; + } + | { + property: "border-block-color"; + value: BorderBlockColor; + } + | { + property: "border-block-style"; + value: BorderBlockStyle; + } + | { + property: "border-block-width"; + value: BorderBlockWidth; + } + | { + property: "border-inline-color"; + value: BorderInlineColor; + } + | { + property: "border-inline-style"; + value: BorderInlineStyle; + } + | { + property: "border-inline-width"; + value: BorderInlineWidth; + } + | { + property: "border"; + value: GenericBorderFor_LineStyle; + } + | { + property: "border-top"; + value: GenericBorderFor_LineStyle; + } + | { + property: "border-bottom"; + value: GenericBorderFor_LineStyle; + } + | { + property: "border-left"; + value: GenericBorderFor_LineStyle; + } + | { + property: "border-right"; + value: GenericBorderFor_LineStyle; + } + | { + property: "border-block"; + value: GenericBorderFor_LineStyle; + } + | { + property: "border-block-start"; + value: GenericBorderFor_LineStyle; + } + | { + property: "border-block-end"; + value: GenericBorderFor_LineStyle; + } + | { + property: "border-inline"; + value: GenericBorderFor_LineStyle; + } + | { + property: "border-inline-start"; + value: GenericBorderFor_LineStyle; + } + | { + property: "border-inline-end"; + value: GenericBorderFor_LineStyle; + } + | { + property: "outline"; + value: GenericBorderFor_OutlineStyleAnd_11; + } + | { + property: "outline-color"; + value: CssColor; + } + | { + property: "outline-style"; + value: OutlineStyle; + } + | { + property: "outline-width"; + value: BorderSideWidth; + } + | { + property: "flex-direction"; + value: FlexDirection; + vendorPrefix: VendorPrefix; + } + | { + property: "flex-wrap"; + value: FlexWrap; + vendorPrefix: VendorPrefix; + } + | { + property: "flex-flow"; + value: FlexFlow; + vendorPrefix: VendorPrefix; + } + | { + property: "flex-grow"; + value: number; + vendorPrefix: VendorPrefix; + } + | { + property: "flex-shrink"; + value: number; + vendorPrefix: VendorPrefix; + } + | { + property: "flex-basis"; + value: LengthPercentageOrAuto; + vendorPrefix: VendorPrefix; + } + | { + property: "flex"; + value: Flex; + vendorPrefix: VendorPrefix; + } + | { + property: "order"; + value: number; + vendorPrefix: VendorPrefix; + } + | { + property: "align-content"; + value: AlignContent; + vendorPrefix: VendorPrefix; + } + | { + property: "justify-content"; + value: JustifyContent; + vendorPrefix: VendorPrefix; + } + | { + property: "place-content"; + value: PlaceContent; + } + | { + property: "align-self"; + value: AlignSelf; + vendorPrefix: VendorPrefix; + } + | { + property: "justify-self"; + value: JustifySelf; + } + | { + property: "place-self"; + value: PlaceSelf; + } + | { + property: "align-items"; + value: AlignItems; + vendorPrefix: VendorPrefix; + } + | { + property: "justify-items"; + value: JustifyItems; + } + | { + property: "place-items"; + value: PlaceItems; + } + | { + property: "row-gap"; + value: GapValue; + } + | { + property: "column-gap"; + value: GapValue; + } + | { + property: "gap"; + value: Gap; + } + | { + property: "box-orient"; + value: BoxOrient; + vendorPrefix: VendorPrefix; + } + | { + property: "box-direction"; + value: BoxDirection; + vendorPrefix: VendorPrefix; + } + | { + property: "box-ordinal-group"; + value: number; + vendorPrefix: VendorPrefix; + } + | { + property: "box-align"; + value: BoxAlign; + vendorPrefix: VendorPrefix; + } + | { + property: "box-flex"; + value: number; + vendorPrefix: VendorPrefix; + } + | { + property: "box-flex-group"; + value: number; + vendorPrefix: VendorPrefix; + } + | { + property: "box-pack"; + value: BoxPack; + vendorPrefix: VendorPrefix; + } + | { + property: "box-lines"; + value: BoxLines; + vendorPrefix: VendorPrefix; + } + | { + property: "flex-pack"; + value: FlexPack; + vendorPrefix: VendorPrefix; + } + | { + property: "flex-order"; + value: number; + vendorPrefix: VendorPrefix; + } + | { + property: "flex-align"; + value: BoxAlign; + vendorPrefix: VendorPrefix; + } + | { + property: "flex-item-align"; + value: FlexItemAlign; + vendorPrefix: VendorPrefix; + } + | { + property: "flex-line-pack"; + value: FlexLinePack; + vendorPrefix: VendorPrefix; + } + | { + property: "flex-positive"; + value: number; + vendorPrefix: VendorPrefix; + } + | { + property: "flex-negative"; + value: number; + vendorPrefix: VendorPrefix; + } + | { + property: "flex-preferred-size"; + value: LengthPercentageOrAuto; + vendorPrefix: VendorPrefix; + } + | { + property: "grid-template-columns"; + value: TrackSizing; + } + | { + property: "grid-template-rows"; + value: TrackSizing; + } + | { + property: "grid-auto-columns"; + value: TrackSize[]; + } + | { + property: "grid-auto-rows"; + value: TrackSize[]; + } + | { + property: "grid-auto-flow"; + value: GridAutoFlow; + } + | { + property: "grid-template-areas"; + value: GridTemplateAreas; + } + | { + property: "grid-template"; + value: GridTemplate; + } + | { + property: "grid"; + value: Grid; + } + | { + property: "grid-row-start"; + value: GridLine; + } + | { + property: "grid-row-end"; + value: GridLine; + } + | { + property: "grid-column-start"; + value: GridLine; + } + | { + property: "grid-column-end"; + value: GridLine; + } + | { + property: "grid-row"; + value: GridRow; + } + | { + property: "grid-column"; + value: GridColumn; + } + | { + property: "grid-area"; + value: GridArea; + } + | { + property: "margin-top"; + value: LengthPercentageOrAuto; + } + | { + property: "margin-bottom"; + value: LengthPercentageOrAuto; + } + | { + property: "margin-left"; + value: LengthPercentageOrAuto; + } + | { + property: "margin-right"; + value: LengthPercentageOrAuto; + } + | { + property: "margin-block-start"; + value: LengthPercentageOrAuto; + } + | { + property: "margin-block-end"; + value: LengthPercentageOrAuto; + } + | { + property: "margin-inline-start"; + value: LengthPercentageOrAuto; + } + | { + property: "margin-inline-end"; + value: LengthPercentageOrAuto; + } + | { + property: "margin-block"; + value: MarginBlock; + } + | { + property: "margin-inline"; + value: MarginInline; + } + | { + property: "margin"; + value: Margin; + } + | { + property: "padding-top"; + value: LengthPercentageOrAuto; + } + | { + property: "padding-bottom"; + value: LengthPercentageOrAuto; + } + | { + property: "padding-left"; + value: LengthPercentageOrAuto; + } + | { + property: "padding-right"; + value: LengthPercentageOrAuto; + } + | { + property: "padding-block-start"; + value: LengthPercentageOrAuto; + } + | { + property: "padding-block-end"; + value: LengthPercentageOrAuto; + } + | { + property: "padding-inline-start"; + value: LengthPercentageOrAuto; + } + | { + property: "padding-inline-end"; + value: LengthPercentageOrAuto; + } + | { + property: "padding-block"; + value: PaddingBlock; + } + | { + property: "padding-inline"; + value: PaddingInline; + } + | { + property: "padding"; + value: Padding; + } + | { + property: "scroll-margin-top"; + value: LengthPercentageOrAuto; + } + | { + property: "scroll-margin-bottom"; + value: LengthPercentageOrAuto; + } + | { + property: "scroll-margin-left"; + value: LengthPercentageOrAuto; + } + | { + property: "scroll-margin-right"; + value: LengthPercentageOrAuto; + } + | { + property: "scroll-margin-block-start"; + value: LengthPercentageOrAuto; + } + | { + property: "scroll-margin-block-end"; + value: LengthPercentageOrAuto; + } + | { + property: "scroll-margin-inline-start"; + value: LengthPercentageOrAuto; + } + | { + property: "scroll-margin-inline-end"; + value: LengthPercentageOrAuto; + } + | { + property: "scroll-margin-block"; + value: ScrollMarginBlock; + } + | { + property: "scroll-margin-inline"; + value: ScrollMarginInline; + } + | { + property: "scroll-margin"; + value: ScrollMargin; + } + | { + property: "scroll-padding-top"; + value: LengthPercentageOrAuto; + } + | { + property: "scroll-padding-bottom"; + value: LengthPercentageOrAuto; + } + | { + property: "scroll-padding-left"; + value: LengthPercentageOrAuto; + } + | { + property: "scroll-padding-right"; + value: LengthPercentageOrAuto; + } + | { + property: "scroll-padding-block-start"; + value: LengthPercentageOrAuto; + } + | { + property: "scroll-padding-block-end"; + value: LengthPercentageOrAuto; + } + | { + property: "scroll-padding-inline-start"; + value: LengthPercentageOrAuto; + } + | { + property: "scroll-padding-inline-end"; + value: LengthPercentageOrAuto; + } + | { + property: "scroll-padding-block"; + value: ScrollPaddingBlock; + } + | { + property: "scroll-padding-inline"; + value: ScrollPaddingInline; + } + | { + property: "scroll-padding"; + value: ScrollPadding; + } + | { + property: "font-weight"; + value: FontWeight; + } + | { + property: "font-size"; + value: FontSize; + } + | { + property: "font-stretch"; + value: FontStretch; + } + | { + property: "font-family"; + value: FontFamily[]; + } + | { + property: "font-style"; + value: FontStyle; + } + | { + property: "font-variant-caps"; + value: FontVariantCaps; + } + | { + property: "line-height"; + value: LineHeight; + } + | { + property: "font"; + value: Font; + } + | { + property: "vertical-align"; + value: VerticalAlign; + } + | { + property: "font-palette"; + value: DashedIdentReference; + } + | { + property: "transition-property"; + value: PropertyId[]; + vendorPrefix: VendorPrefix; + } + | { + property: "transition-duration"; + value: Time[]; + vendorPrefix: VendorPrefix; + } + | { + property: "transition-delay"; + value: Time[]; + vendorPrefix: VendorPrefix; + } + | { + property: "transition-timing-function"; + value: EasingFunction[]; + vendorPrefix: VendorPrefix; + } + | { + property: "transition"; + value: Transition[]; + vendorPrefix: VendorPrefix; + } + | { + property: "animation-name"; + value: AnimationName[]; + vendorPrefix: VendorPrefix; + } + | { + property: "animation-duration"; + value: Time[]; + vendorPrefix: VendorPrefix; + } + | { + property: "animation-timing-function"; + value: EasingFunction[]; + vendorPrefix: VendorPrefix; + } + | { + property: "animation-iteration-count"; + value: AnimationIterationCount[]; + vendorPrefix: VendorPrefix; + } + | { + property: "animation-direction"; + value: AnimationDirection[]; + vendorPrefix: VendorPrefix; + } + | { + property: "animation-play-state"; + value: AnimationPlayState[]; + vendorPrefix: VendorPrefix; + } + | { + property: "animation-delay"; + value: Time[]; + vendorPrefix: VendorPrefix; + } + | { + property: "animation-fill-mode"; + value: AnimationFillMode[]; + vendorPrefix: VendorPrefix; + } + | { + property: "animation-composition"; + value: AnimationComposition[]; + } + | { + property: "animation-timeline"; + value: AnimationTimeline[]; + } + | { + property: "animation-range-start"; + value: AnimationRangeStart[]; + } + | { + property: "animation-range-end"; + value: AnimationRangeEnd[]; + } + | { + property: "animation-range"; + value: AnimationRange[]; + } + | { + property: "animation"; + value: Animation[]; + vendorPrefix: VendorPrefix; + } + | { + property: "transform"; + value: Transform[]; + vendorPrefix: VendorPrefix; + } + | { + property: "transform-origin"; + value: Position; + vendorPrefix: VendorPrefix; + } + | { + property: "transform-style"; + value: TransformStyle; + vendorPrefix: VendorPrefix; + } + | { + property: "transform-box"; + value: TransformBox; + } + | { + property: "backface-visibility"; + value: BackfaceVisibility; + vendorPrefix: VendorPrefix; + } + | { + property: "perspective"; + value: Perspective; + vendorPrefix: VendorPrefix; + } + | { + property: "perspective-origin"; + value: Position; + vendorPrefix: VendorPrefix; + } + | { + property: "translate"; + value: Translate; + } + | { + property: "rotate"; + value: Rotate; + } + | { + property: "scale"; + value: Scale; + } + | { + property: "text-transform"; + value: TextTransform; + } + | { + property: "white-space"; + value: WhiteSpace; + } + | { + property: "tab-size"; + value: LengthOrNumber; + vendorPrefix: VendorPrefix; + } + | { + property: "word-break"; + value: WordBreak; + } + | { + property: "line-break"; + value: LineBreak; + } + | { + property: "hyphens"; + value: Hyphens; + vendorPrefix: VendorPrefix; + } + | { + property: "overflow-wrap"; + value: OverflowWrap; + } + | { + property: "word-wrap"; + value: OverflowWrap; + } + | { + property: "text-align"; + value: TextAlign; + } + | { + property: "text-align-last"; + value: TextAlignLast; + vendorPrefix: VendorPrefix; + } + | { + property: "text-justify"; + value: TextJustify; + } + | { + property: "word-spacing"; + value: Spacing; + } + | { + property: "letter-spacing"; + value: Spacing; + } + | { + property: "text-indent"; + value: TextIndent; + } + | { + property: "text-decoration-line"; + value: TextDecorationLine; + vendorPrefix: VendorPrefix; + } + | { + property: "text-decoration-style"; + value: TextDecorationStyle; + vendorPrefix: VendorPrefix; + } + | { + property: "text-decoration-color"; + value: CssColor; + vendorPrefix: VendorPrefix; + } + | { + property: "text-decoration-thickness"; + value: TextDecorationThickness; + } + | { + property: "text-decoration"; + value: TextDecoration; + vendorPrefix: VendorPrefix; + } + | { + property: "text-decoration-skip-ink"; + value: TextDecorationSkipInk; + vendorPrefix: VendorPrefix; + } + | { + property: "text-emphasis-style"; + value: TextEmphasisStyle; + vendorPrefix: VendorPrefix; + } + | { + property: "text-emphasis-color"; + value: CssColor; + vendorPrefix: VendorPrefix; + } + | { + property: "text-emphasis"; + value: TextEmphasis; + vendorPrefix: VendorPrefix; + } + | { + property: "text-emphasis-position"; + value: TextEmphasisPosition; + vendorPrefix: VendorPrefix; + } + | { + property: "text-shadow"; + value: TextShadow[]; + } + | { + property: "text-size-adjust"; + value: TextSizeAdjust; + vendorPrefix: VendorPrefix; + } + | { + property: "direction"; + value: Direction2; + } + | { + property: "unicode-bidi"; + value: UnicodeBidi; + } + | { + property: "box-decoration-break"; + value: BoxDecorationBreak; + vendorPrefix: VendorPrefix; + } + | { + property: "resize"; + value: Resize; + } + | { + property: "cursor"; + value: Cursor; + } + | { + property: "caret-color"; + value: ColorOrAuto; + } + | { + property: "caret-shape"; + value: CaretShape; + } + | { + property: "caret"; + value: Caret; + } + | { + property: "user-select"; + value: UserSelect; + vendorPrefix: VendorPrefix; + } + | { + property: "accent-color"; + value: ColorOrAuto; + } + | { + property: "appearance"; + value: Appearance; + vendorPrefix: VendorPrefix; + } + | { + property: "list-style-type"; + value: ListStyleType; + } + | { + property: "list-style-image"; + value: Image; + } + | { + property: "list-style-position"; + value: ListStylePosition; + } + | { + property: "list-style"; + value: ListStyle; + } + | { + property: "marker-side"; + value: MarkerSide; + } + | { + property: "composes"; + value: Composes; + } + | { + property: "fill"; + value: SVGPaint; + } + | { + property: "fill-rule"; + value: FillRule; + } + | { + property: "fill-opacity"; + value: number; + } + | { + property: "stroke"; + value: SVGPaint; + } + | { + property: "stroke-opacity"; + value: number; + } + | { + property: "stroke-width"; + value: DimensionPercentageFor_LengthValue; + } + | { + property: "stroke-linecap"; + value: StrokeLinecap; + } + | { + property: "stroke-linejoin"; + value: StrokeLinejoin; + } + | { + property: "stroke-miterlimit"; + value: number; + } + | { + property: "stroke-dasharray"; + value: StrokeDasharray; + } + | { + property: "stroke-dashoffset"; + value: DimensionPercentageFor_LengthValue; + } + | { + property: "marker-start"; + value: Marker; + } + | { + property: "marker-mid"; + value: Marker; + } + | { + property: "marker-end"; + value: Marker; + } + | { + property: "marker"; + value: Marker; + } + | { + property: "color-interpolation"; + value: ColorInterpolation; + } + | { + property: "color-interpolation-filters"; + value: ColorInterpolation; + } + | { + property: "color-rendering"; + value: ColorRendering; + } + | { + property: "shape-rendering"; + value: ShapeRendering; + } + | { + property: "text-rendering"; + value: TextRendering; + } + | { + property: "image-rendering"; + value: ImageRendering; + } + | { + property: "clip-path"; + value: ClipPath; + vendorPrefix: VendorPrefix; + } + | { + property: "clip-rule"; + value: FillRule; + } + | { + property: "mask-image"; + value: Image[]; + vendorPrefix: VendorPrefix; + } + | { + property: "mask-mode"; + value: MaskMode[]; + } + | { + property: "mask-repeat"; + value: BackgroundRepeat[]; + vendorPrefix: VendorPrefix; + } + | { + property: "mask-position-x"; + value: PositionComponentFor_HorizontalPositionKeyword[]; + } + | { + property: "mask-position-y"; + value: PositionComponentFor_VerticalPositionKeyword[]; + } + | { + property: "mask-position"; + value: Position[]; + vendorPrefix: VendorPrefix; + } + | { + property: "mask-clip"; + value: MaskClip[]; + vendorPrefix: VendorPrefix; + } + | { + property: "mask-origin"; + value: GeometryBox[]; + vendorPrefix: VendorPrefix; + } + | { + property: "mask-size"; + value: BackgroundSize[]; + vendorPrefix: VendorPrefix; + } + | { + property: "mask-composite"; + value: MaskComposite[]; + } + | { + property: "mask-type"; + value: MaskType; + } + | { + property: "mask"; + value: Mask[]; + vendorPrefix: VendorPrefix; + } + | { + property: "mask-border-source"; + value: Image; + } + | { + property: "mask-border-mode"; + value: MaskBorderMode; + } + | { + property: "mask-border-slice"; + value: BorderImageSlice; + } + | { + property: "mask-border-width"; + value: RectFor_BorderImageSideWidth; + } + | { + property: "mask-border-outset"; + value: RectFor_LengthOrNumber; + } + | { + property: "mask-border-repeat"; + value: BorderImageRepeat; + } + | { + property: "mask-border"; + value: MaskBorder; + } + | { + property: "-webkit-mask-composite"; + value: WebKitMaskComposite[]; + } + | { + property: "mask-source-type"; + value: WebKitMaskSourceType[]; + vendorPrefix: VendorPrefix; + } + | { + property: "mask-box-image"; + value: BorderImage; + vendorPrefix: VendorPrefix; + } + | { + property: "mask-box-image-source"; + value: Image; + vendorPrefix: VendorPrefix; + } + | { + property: "mask-box-image-slice"; + value: BorderImageSlice; + vendorPrefix: VendorPrefix; + } + | { + property: "mask-box-image-width"; + value: RectFor_BorderImageSideWidth; + vendorPrefix: VendorPrefix; + } + | { + property: "mask-box-image-outset"; + value: RectFor_LengthOrNumber; + vendorPrefix: VendorPrefix; + } + | { + property: "mask-box-image-repeat"; + value: BorderImageRepeat; + vendorPrefix: VendorPrefix; + } + | { + property: "filter"; + value: FilterList; + vendorPrefix: VendorPrefix; + } + | { + property: "backdrop-filter"; + value: FilterList; + vendorPrefix: VendorPrefix; + } + | { + property: "mix-blend-mode"; + value: BlendMode; + } + | { + property: "z-index"; + value: ZIndex; + } + | { + property: "container-type"; + value: ContainerType; + } + | { + property: "container-name"; + value: ContainerNameList; + } + | { + property: "container"; + value: Container; + } + | { + property: "view-transition-name"; + value: ViewTransitionName; + } + | { + property: "view-transition-class"; + value: NoneOrCustomIdentList; + } + | { + property: "view-transition-group"; + value: ViewTransitionGroup; + } + | { + property: "color-scheme"; + value: ColorScheme; + } + | { + property: "print-color-adjust"; + value: PrintColorAdjust; + vendorPrefix: VendorPrefix; + } + | { + property: "all"; + value: CSSWideKeyword; + } + | { + property: "unparsed"; + value: UnparsedProperty; + } + | { + property: "custom"; + value: CustomProperty; + }; +/** + * A CSS [``](https://www.w3.org/TR/css-images-3/#image-values) value. + */ +export type Image = + | { + type: "none"; + } + | { + type: "url"; + value: Url; + } + | { + type: "gradient"; + value: Gradient; + } + | { + type: "image-set"; + value: ImageSet; + }; +/** + * A CSS [``](https://www.w3.org/TR/css-images-3/#gradients) value. + */ +export type Gradient = + | { + /** + * The direction of the gradient. + */ + direction: LineDirection; + /** + * The color stops and transition hints for the gradient. + */ + items: GradientItemFor_DimensionPercentageFor_LengthValue[]; + type: "linear"; + /** + * The vendor prefixes for the gradient. + */ + vendorPrefix: VendorPrefix; + } + | { + /** + * The direction of the gradient. + */ + direction: LineDirection; + /** + * The color stops and transition hints for the gradient. + */ + items: GradientItemFor_DimensionPercentageFor_LengthValue[]; + type: "repeating-linear"; + /** + * The vendor prefixes for the gradient. + */ + vendorPrefix: VendorPrefix; + } + | { + /** + * The color stops and transition hints for the gradient. + */ + items: GradientItemFor_DimensionPercentageFor_LengthValue[]; + /** + * The position of the gradient. + */ + position: Position; + /** + * The shape of the gradient. + */ + shape: EndingShape; + type: "radial"; + /** + * The vendor prefixes for the gradient. + */ + vendorPrefix: VendorPrefix; + } + | { + /** + * The color stops and transition hints for the gradient. + */ + items: GradientItemFor_DimensionPercentageFor_LengthValue[]; + /** + * The position of the gradient. + */ + position: Position; + /** + * The shape of the gradient. + */ + shape: EndingShape; + type: "repeating-radial"; + /** + * The vendor prefixes for the gradient. + */ + vendorPrefix: VendorPrefix; + } + | { + /** + * The angle of the gradient. + */ + angle: Angle; + /** + * The color stops and transition hints for the gradient. + */ + items: GradientItemFor_DimensionPercentageFor_Angle[]; + /** + * The position of the gradient. + */ + position: Position; + type: "conic"; + } + | { + /** + * The angle of the gradient. + */ + angle: Angle; + /** + * The color stops and transition hints for the gradient. + */ + items: GradientItemFor_DimensionPercentageFor_Angle[]; + /** + * The position of the gradient. + */ + position: Position; + type: "repeating-conic"; + } + | ( + | { + type: "webkit-gradient"; + /** + * The starting point of the gradient. + */ + from: WebKitGradientPoint; + kind: "linear"; + /** + * The color stops in the gradient. + */ + stops: WebKitColorStop[]; + /** + * The ending point of the gradient. + */ + to: WebKitGradientPoint; + } + | { + type: "webkit-gradient"; + /** + * The starting point of the gradient. + */ + from: WebKitGradientPoint; + kind: "radial"; + /** + * The starting radius of the gradient. + */ + r0: number; + /** + * The ending radius of the gradient. + */ + r1: number; + /** + * The color stops in the gradient. + */ + stops: WebKitColorStop[]; + /** + * The ending point of the gradient. + */ + to: WebKitGradientPoint; + } + ); +/** + * The direction of a CSS `linear-gradient()`. + * + * See [LinearGradient](LinearGradient). + */ +export type LineDirection = + | { + type: "angle"; + value: Angle; + } + | { + type: "horizontal"; + value: HorizontalPositionKeyword; + } + | { + type: "vertical"; + value: VerticalPositionKeyword; + } + | { + /** + * A horizontal position keyword, e.g. `left` or `right. + */ + horizontal: HorizontalPositionKeyword; + type: "corner"; + /** + * A vertical posision keyword, e.g. `top` or `bottom`. + */ + vertical: VerticalPositionKeyword; + }; +/** + * A horizontal position keyword. + */ +export type HorizontalPositionKeyword = "left" | "right"; +/** + * A vertical position keyword. + */ +export type VerticalPositionKeyword = "top" | "bottom"; +/** + * Either a color stop or interpolation hint within a gradient. + * + * This type is generic, and items may be either a [LengthPercentage](super::length::LengthPercentage) or [Angle](super::angle::Angle) depending on what type of gradient it is within. + */ +export type GradientItemFor_DimensionPercentageFor_LengthValue = + | { + /** + * The color of the color stop. + */ + color: CssColor; + /** + * The position of the color stop. + */ + position?: DimensionPercentageFor_LengthValue | null; + type: "color-stop"; + } + | { + type: "hint"; + value: DimensionPercentageFor_LengthValue; + }; +/** + * A generic type that allows any kind of dimension and percentage to be used standalone or mixed within a `calc()` expression. + * + * + */ +export type DimensionPercentageFor_LengthValue = + | { + type: "dimension"; + value: LengthValue; + } + | { + type: "percentage"; + value: number; + } + | { + type: "calc"; + value: CalcFor_DimensionPercentageFor_LengthValue; + }; +/** + * A mathematical expression used within the [`calc()`](https://www.w3.org/TR/css-values-4/#calc-func) function. + * + * This type supports generic value types. Values such as [Length](super::length::Length), [Percentage](super::percentage::Percentage), [Time](super::time::Time), and [Angle](super::angle::Angle) support `calc()` expressions. + */ +export type CalcFor_DimensionPercentageFor_LengthValue = + | { + type: "value"; + value: DimensionPercentageFor_LengthValue; + } + | { + type: "number"; + value: number; + } + | { + type: "sum"; + /** + * @minItems 2 + * @maxItems 2 + */ + value: [CalcFor_DimensionPercentageFor_LengthValue, CalcFor_DimensionPercentageFor_LengthValue]; + } + | { + type: "product"; + /** + * @minItems 2 + * @maxItems 2 + */ + value: [number, CalcFor_DimensionPercentageFor_LengthValue]; + } + | { + type: "function"; + value: MathFunctionFor_DimensionPercentageFor_LengthValue; + }; +/** + * A CSS [math function](https://www.w3.org/TR/css-values-4/#math-function). + * + * Math functions may be used in most properties and values that accept numeric values, including lengths, percentages, angles, times, etc. + */ +export type MathFunctionFor_DimensionPercentageFor_LengthValue = + | { + type: "calc"; + value: CalcFor_DimensionPercentageFor_LengthValue; + } + | { + type: "min"; + value: CalcFor_DimensionPercentageFor_LengthValue[]; + } + | { + type: "max"; + value: CalcFor_DimensionPercentageFor_LengthValue[]; + } + | { + type: "clamp"; + /** + * @minItems 3 + * @maxItems 3 + */ + value: [ + CalcFor_DimensionPercentageFor_LengthValue, + CalcFor_DimensionPercentageFor_LengthValue, + CalcFor_DimensionPercentageFor_LengthValue + ]; + } + | { + type: "round"; + /** + * @minItems 3 + * @maxItems 3 + */ + value: [RoundingStrategy, CalcFor_DimensionPercentageFor_LengthValue, CalcFor_DimensionPercentageFor_LengthValue]; + } + | { + type: "rem"; + /** + * @minItems 2 + * @maxItems 2 + */ + value: [CalcFor_DimensionPercentageFor_LengthValue, CalcFor_DimensionPercentageFor_LengthValue]; + } + | { + type: "mod"; + /** + * @minItems 2 + * @maxItems 2 + */ + value: [CalcFor_DimensionPercentageFor_LengthValue, CalcFor_DimensionPercentageFor_LengthValue]; + } + | { + type: "abs"; + value: CalcFor_DimensionPercentageFor_LengthValue; + } + | { + type: "sign"; + value: CalcFor_DimensionPercentageFor_LengthValue; + } + | { + type: "hypot"; + value: CalcFor_DimensionPercentageFor_LengthValue[]; + }; +/** + * A component within a [Position](Position) value, representing a position along either the horizontal or vertical axis of a box. + * + * This type is generic over side keywords. + */ +export type PositionComponentFor_HorizontalPositionKeyword = + | { + type: "center"; + } + | { + type: "length"; + value: DimensionPercentageFor_LengthValue; + } + | { + /** + * Offset from the side. + */ + offset?: DimensionPercentageFor_LengthValue | null; + /** + * A side keyword. + */ + side: HorizontalPositionKeyword; + type: "side"; + }; +/** + * A component within a [Position](Position) value, representing a position along either the horizontal or vertical axis of a box. + * + * This type is generic over side keywords. + */ +export type PositionComponentFor_VerticalPositionKeyword = + | { + type: "center"; + } + | { + type: "length"; + value: DimensionPercentageFor_LengthValue; + } + | { + /** + * Offset from the side. + */ + offset?: DimensionPercentageFor_LengthValue | null; + /** + * A side keyword. + */ + side: VerticalPositionKeyword; + type: "side"; + }; +/** + * A `radial-gradient()` [ending shape](https://www.w3.org/TR/css-images-3/#valdef-radial-gradient-ending-shape). + * + * See [RadialGradient](RadialGradient). + */ +export type EndingShape = + | { + type: "ellipse"; + value: Ellipse; + } + | { + type: "circle"; + value: Circle; + }; +/** + * An ellipse ending shape for a `radial-gradient()`. + * + * See [RadialGradient](RadialGradient). + */ +export type Ellipse = + | { + type: "size"; + /** + * The x-radius of the ellipse. + */ + x: DimensionPercentageFor_LengthValue; + /** + * The y-radius of the ellipse. + */ + y: DimensionPercentageFor_LengthValue; + } + | { + type: "extent"; + value: ShapeExtent; + }; +/** + * A shape extent for a `radial-gradient()`. + * + * See [RadialGradient](RadialGradient). + */ +export type ShapeExtent = "closest-side" | "farthest-side" | "closest-corner" | "farthest-corner"; +/** + * A circle ending shape for a `radial-gradient()`. + * + * See [RadialGradient](RadialGradient). + */ +export type Circle = + | { + type: "radius"; + value: Length; + } + | { + type: "extent"; + value: ShapeExtent; + }; +/** + * Either a color stop or interpolation hint within a gradient. + * + * This type is generic, and items may be either a [LengthPercentage](super::length::LengthPercentage) or [Angle](super::angle::Angle) depending on what type of gradient it is within. + */ +export type GradientItemFor_DimensionPercentageFor_Angle = + | { + /** + * The color of the color stop. + */ + color: CssColor; + /** + * The position of the color stop. + */ + position?: DimensionPercentageFor_Angle | null; + type: "color-stop"; + } + | { + type: "hint"; + value: DimensionPercentageFor_Angle; + }; +/** + * A generic type that allows any kind of dimension and percentage to be used standalone or mixed within a `calc()` expression. + * + * + */ +export type DimensionPercentageFor_Angle = + | { + type: "dimension"; + value: Angle; + } + | { + type: "percentage"; + value: number; + } + | { + type: "calc"; + value: CalcFor_DimensionPercentageFor_Angle; + }; +/** + * A mathematical expression used within the [`calc()`](https://www.w3.org/TR/css-values-4/#calc-func) function. + * + * This type supports generic value types. Values such as [Length](super::length::Length), [Percentage](super::percentage::Percentage), [Time](super::time::Time), and [Angle](super::angle::Angle) support `calc()` expressions. + */ +export type CalcFor_DimensionPercentageFor_Angle = + | { + type: "value"; + value: DimensionPercentageFor_Angle; + } + | { + type: "number"; + value: number; + } + | { + type: "sum"; + /** + * @minItems 2 + * @maxItems 2 + */ + value: [CalcFor_DimensionPercentageFor_Angle, CalcFor_DimensionPercentageFor_Angle]; + } + | { + type: "product"; + /** + * @minItems 2 + * @maxItems 2 + */ + value: [number, CalcFor_DimensionPercentageFor_Angle]; + } + | { + type: "function"; + value: MathFunctionFor_DimensionPercentageFor_Angle; + }; +/** + * A CSS [math function](https://www.w3.org/TR/css-values-4/#math-function). + * + * Math functions may be used in most properties and values that accept numeric values, including lengths, percentages, angles, times, etc. + */ +export type MathFunctionFor_DimensionPercentageFor_Angle = + | { + type: "calc"; + value: CalcFor_DimensionPercentageFor_Angle; + } + | { + type: "min"; + value: CalcFor_DimensionPercentageFor_Angle[]; + } + | { + type: "max"; + value: CalcFor_DimensionPercentageFor_Angle[]; + } + | { + type: "clamp"; + /** + * @minItems 3 + * @maxItems 3 + */ + value: [ + CalcFor_DimensionPercentageFor_Angle, + CalcFor_DimensionPercentageFor_Angle, + CalcFor_DimensionPercentageFor_Angle + ]; + } + | { + type: "round"; + /** + * @minItems 3 + * @maxItems 3 + */ + value: [RoundingStrategy, CalcFor_DimensionPercentageFor_Angle, CalcFor_DimensionPercentageFor_Angle]; + } + | { + type: "rem"; + /** + * @minItems 2 + * @maxItems 2 + */ + value: [CalcFor_DimensionPercentageFor_Angle, CalcFor_DimensionPercentageFor_Angle]; + } + | { + type: "mod"; + /** + * @minItems 2 + * @maxItems 2 + */ + value: [CalcFor_DimensionPercentageFor_Angle, CalcFor_DimensionPercentageFor_Angle]; + } + | { + type: "abs"; + value: CalcFor_DimensionPercentageFor_Angle; + } + | { + type: "sign"; + value: CalcFor_DimensionPercentageFor_Angle; + } + | { + type: "hypot"; + value: CalcFor_DimensionPercentageFor_Angle[]; + }; +/** + * A keyword or number within a [WebKitGradientPoint](WebKitGradientPoint). + */ +export type WebKitGradientPointComponentFor_HorizontalPositionKeyword = + | { + type: "center"; + } + | { + type: "number"; + value: NumberOrPercentage; + } + | { + type: "side"; + value: HorizontalPositionKeyword; + }; +/** + * Either a `` or ``. + */ +export type NumberOrPercentage = + | { + type: "number"; + value: number; + } + | { + type: "percentage"; + value: number; + }; +/** + * A keyword or number within a [WebKitGradientPoint](WebKitGradientPoint). + */ +export type WebKitGradientPointComponentFor_VerticalPositionKeyword = + | { + type: "center"; + } + | { + type: "number"; + value: NumberOrPercentage; + } + | { + type: "side"; + value: VerticalPositionKeyword; + }; +/** + * A value for the [background-size](https://www.w3.org/TR/css-backgrounds-3/#background-size) property. + */ +export type BackgroundSize = + | { + /** + * The height of the background. + */ + height: LengthPercentageOrAuto; + type: "explicit"; + /** + * The width of the background. + */ + width: LengthPercentageOrAuto; + } + | { + type: "cover"; + } + | { + type: "contain"; + }; +/** + * Either a [``](https://www.w3.org/TR/css-values-4/#typedef-length-percentage), or the `auto` keyword. + */ +export type LengthPercentageOrAuto = + | { + type: "auto"; + } + | { + type: "length-percentage"; + value: DimensionPercentageFor_LengthValue; + }; +/** + * A [``](https://www.w3.org/TR/css-backgrounds-3/#typedef-repeat-style) value, used within the `background-repeat` property to represent how a background image is repeated in a single direction. + * + * See [BackgroundRepeat](BackgroundRepeat). + */ +export type BackgroundRepeatKeyword = "repeat" | "space" | "round" | "no-repeat"; +/** + * A value for the [background-attachment](https://www.w3.org/TR/css-backgrounds-3/#background-attachment) property. + */ +export type BackgroundAttachment = "scroll" | "fixed" | "local"; +/** + * A value for the [background-clip](https://drafts.csswg.org/css-backgrounds-4/#background-clip) property. + */ +export type BackgroundClip = "border-box" | "padding-box" | "content-box" | "border" | "text"; +/** + * A value for the [background-origin](https://www.w3.org/TR/css-backgrounds-3/#background-origin) property. + */ +export type BackgroundOrigin = "border-box" | "padding-box" | "content-box"; +/** + * A value for the [display](https://drafts.csswg.org/css-display-3/#the-display-properties) property. + */ +export type Display = + | { + type: "keyword"; + value: DisplayKeyword; + } + | { + /** + * The inside display value. + */ + inside: DisplayInside; + /** + * Whether this is a list item. + */ + isListItem: boolean; + /** + * The outside display value. + */ + outside: DisplayOutside; + type: "pair"; + }; +/** + * A `display` keyword. + * + * See [Display](Display). + */ +export type DisplayKeyword = + | "none" + | "contents" + | "table-row-group" + | "table-header-group" + | "table-footer-group" + | "table-row" + | "table-cell" + | "table-column-group" + | "table-column" + | "table-caption" + | "ruby-base" + | "ruby-text" + | "ruby-base-container" + | "ruby-text-container"; +/** + * A [``](https://drafts.csswg.org/css-display-3/#typedef-display-inside) value. + */ +export type DisplayInside = + | { + type: "flow"; + } + | { + type: "flow-root"; + } + | { + type: "table"; + } + | { + type: "flex"; + vendorPrefix: VendorPrefix; + } + | { + type: "box"; + vendorPrefix: VendorPrefix; + } + | { + type: "grid"; + } + | { + type: "ruby"; + }; +/** + * A [``](https://drafts.csswg.org/css-display-3/#typedef-display-outside) value. + */ +export type DisplayOutside = "block" | "inline" | "run-in"; +/** + * A value for the [visibility](https://drafts.csswg.org/css-display-3/#visibility) property. + */ +export type Visibility = "visible" | "hidden" | "collapse"; +/** + * A value for the [preferred size properties](https://drafts.csswg.org/css-sizing-3/#preferred-size-properties), i.e. `width` and `height. + */ +export type Size = + | { + type: "auto"; + } + | { + type: "length-percentage"; + value: DimensionPercentageFor_LengthValue; + } + | { + type: "min-content"; + vendorPrefix: VendorPrefix; + } + | { + type: "max-content"; + vendorPrefix: VendorPrefix; + } + | { + type: "fit-content"; + vendorPrefix: VendorPrefix; + } + | { + type: "fit-content-function"; + value: DimensionPercentageFor_LengthValue; + } + | { + type: "stretch"; + vendorPrefix: VendorPrefix; + } + | { + type: "contain"; + }; +/** + * A value for the [minimum](https://drafts.csswg.org/css-sizing-3/#min-size-properties) and [maximum](https://drafts.csswg.org/css-sizing-3/#max-size-properties) size properties, e.g. `min-width` and `max-height`. + */ +export type MaxSize = + | { + type: "none"; + } + | { + type: "length-percentage"; + value: DimensionPercentageFor_LengthValue; + } + | { + type: "min-content"; + vendorPrefix: VendorPrefix; + } + | { + type: "max-content"; + vendorPrefix: VendorPrefix; + } + | { + type: "fit-content"; + vendorPrefix: VendorPrefix; + } + | { + type: "fit-content-function"; + value: DimensionPercentageFor_LengthValue; + } + | { + type: "stretch"; + vendorPrefix: VendorPrefix; + } + | { + type: "contain"; + }; +/** + * A value for the [box-sizing](https://drafts.csswg.org/css-sizing-3/#box-sizing) property. + */ +export type BoxSizing = "content-box" | "border-box"; +/** + * An [overflow](https://www.w3.org/TR/css-overflow-3/#overflow-properties) keyword as used in the `overflow-x`, `overflow-y`, and `overflow` properties. + */ +export type OverflowKeyword = "visible" | "hidden" | "clip" | "scroll" | "auto"; +/** + * A value for the [text-overflow](https://www.w3.org/TR/css-overflow-3/#text-overflow) property. + */ +export type TextOverflow = "clip" | "ellipsis"; +/** + * A value for the [position](https://www.w3.org/TR/css-position-3/#position-property) property. + */ +export type Position2 = + | { + type: "static"; + } + | { + type: "relative"; + } + | { + type: "absolute"; + } + | { + type: "sticky"; + value: VendorPrefix; + } + | { + type: "fixed"; + }; +/** + * A generic value that represents a value with two components, e.g. a border radius. + * + * When serialized, only a single component will be written if both are equal. + * + * @minItems 2 + * @maxItems 2 + */ +export type Size2DFor_Length = [Length, Length]; +/** + * A [``](https://drafts.csswg.org/css-backgrounds/#typedef-line-style) value, used in the `border-style` property. + */ +export type LineStyle = + | "none" + | "hidden" + | "inset" + | "groove" + | "outset" + | "ridge" + | "dotted" + | "dashed" + | "solid" + | "double"; +/** + * A value for the [border-width](https://www.w3.org/TR/css-backgrounds-3/#border-width) property. + */ +export type BorderSideWidth = + | { + type: "thin"; + } + | { + type: "medium"; + } + | { + type: "thick"; + } + | { + type: "length"; + value: Length; + }; +/** + * A generic value that represents a value with two components, e.g. a border radius. + * + * When serialized, only a single component will be written if both are equal. + * + * @minItems 2 + * @maxItems 2 + */ +export type Size2DFor_DimensionPercentageFor_LengthValue = [ + DimensionPercentageFor_LengthValue, + DimensionPercentageFor_LengthValue +]; +/** + * A generic value that represents a value for four sides of a box, e.g. border-width, margin, padding, etc. + * + * When serialized, as few components as possible are written when there are duplicate values. + * + * @minItems 4 + * @maxItems 4 + */ +export type RectFor_LengthOrNumber = [LengthOrNumber, LengthOrNumber, LengthOrNumber, LengthOrNumber]; +/** + * Either a [``](https://www.w3.org/TR/css-values-4/#lengths) or a [``](https://www.w3.org/TR/css-values-4/#numbers). + */ +export type LengthOrNumber = + | { + type: "number"; + value: number; + } + | { + type: "length"; + value: Length; + }; +/** + * A single [border-image-repeat](https://www.w3.org/TR/css-backgrounds-3/#border-image-repeat) keyword. + */ +export type BorderImageRepeatKeyword = "stretch" | "repeat" | "round" | "space"; +/** + * A generic value that represents a value for four sides of a box, e.g. border-width, margin, padding, etc. + * + * When serialized, as few components as possible are written when there are duplicate values. + * + * @minItems 4 + * @maxItems 4 + */ +export type RectFor_BorderImageSideWidth = [ + BorderImageSideWidth, + BorderImageSideWidth, + BorderImageSideWidth, + BorderImageSideWidth +]; +/** + * A value for the [border-image-width](https://www.w3.org/TR/css-backgrounds-3/#border-image-width) property. + */ +export type BorderImageSideWidth = + | { + type: "number"; + value: number; + } + | { + type: "length-percentage"; + value: DimensionPercentageFor_LengthValue; + } + | { + type: "auto"; + }; +/** + * A generic value that represents a value for four sides of a box, e.g. border-width, margin, padding, etc. + * + * When serialized, as few components as possible are written when there are duplicate values. + * + * @minItems 4 + * @maxItems 4 + */ +export type RectFor_NumberOrPercentage = [ + NumberOrPercentage, + NumberOrPercentage, + NumberOrPercentage, + NumberOrPercentage +]; +/** + * A value for the [outline-style](https://drafts.csswg.org/css-ui/#outline-style) property. + */ +export type OutlineStyle = + | { + type: "auto"; + } + | { + type: "line-style"; + value: LineStyle; + }; +/** + * A value for the [flex-direction](https://www.w3.org/TR/2018/CR-css-flexbox-1-20181119/#propdef-flex-direction) property. + */ +export type FlexDirection = "row" | "row-reverse" | "column" | "column-reverse"; +/** + * A value for the [flex-wrap](https://www.w3.org/TR/2018/CR-css-flexbox-1-20181119/#flex-wrap-property) property. + */ +export type FlexWrap = "nowrap" | "wrap" | "wrap-reverse"; +/** + * A value for the [align-content](https://www.w3.org/TR/css-align-3/#propdef-align-content) property. + */ +export type AlignContent = + | { + type: "normal"; + } + | { + type: "baseline-position"; + value: BaselinePosition; + } + | { + type: "content-distribution"; + value: ContentDistribution; + } + | { + /** + * An overflow alignment mode. + */ + overflow?: OverflowPosition | null; + type: "content-position"; + /** + * A content position keyword. + */ + value: ContentPosition; + }; +/** + * A [``](https://www.w3.org/TR/css-align-3/#typedef-baseline-position) value, as used in the alignment properties. + */ +export type BaselinePosition = "first" | "last"; +/** + * A [``](https://www.w3.org/TR/css-align-3/#typedef-content-distribution) value. + */ +export type ContentDistribution = "space-between" | "space-around" | "space-evenly" | "stretch"; +/** + * An [``](https://www.w3.org/TR/css-align-3/#typedef-overflow-position) value. + */ +export type OverflowPosition = "safe" | "unsafe"; +/** + * A [``](https://www.w3.org/TR/css-align-3/#typedef-content-position) value. + */ +export type ContentPosition = "center" | "start" | "end" | "flex-start" | "flex-end"; +/** + * A value for the [justify-content](https://www.w3.org/TR/css-align-3/#propdef-justify-content) property. + */ +export type JustifyContent = + | { + type: "normal"; + } + | { + type: "content-distribution"; + value: ContentDistribution; + } + | { + /** + * An overflow alignment mode. + */ + overflow?: OverflowPosition | null; + type: "content-position"; + /** + * A content position keyword. + */ + value: ContentPosition; + } + | { + /** + * An overflow alignment mode. + */ + overflow?: OverflowPosition | null; + type: "left"; + } + | { + /** + * An overflow alignment mode. + */ + overflow?: OverflowPosition | null; + type: "right"; + }; +/** + * A value for the [align-self](https://www.w3.org/TR/css-align-3/#align-self-property) property. + */ +export type AlignSelf = + | { + type: "auto"; + } + | { + type: "normal"; + } + | { + type: "stretch"; + } + | { + type: "baseline-position"; + value: BaselinePosition; + } + | { + /** + * An overflow alignment mode. + */ + overflow?: OverflowPosition | null; + type: "self-position"; + /** + * A self position keyword. + */ + value: SelfPosition; + }; +/** + * A [``](https://www.w3.org/TR/css-align-3/#typedef-self-position) value. + */ +export type SelfPosition = "center" | "start" | "end" | "self-start" | "self-end" | "flex-start" | "flex-end"; +/** + * A value for the [justify-self](https://www.w3.org/TR/css-align-3/#justify-self-property) property. + */ +export type JustifySelf = + | { + type: "auto"; + } + | { + type: "normal"; + } + | { + type: "stretch"; + } + | { + type: "baseline-position"; + value: BaselinePosition; + } + | { + /** + * An overflow alignment mode. + */ + overflow?: OverflowPosition | null; + type: "self-position"; + /** + * A self position keyword. + */ + value: SelfPosition; + } + | { + /** + * An overflow alignment mode. + */ + overflow?: OverflowPosition | null; + type: "left"; + } + | { + /** + * An overflow alignment mode. + */ + overflow?: OverflowPosition | null; + type: "right"; + }; +/** + * A value for the [align-items](https://www.w3.org/TR/css-align-3/#align-items-property) property. + */ +export type AlignItems = + | { + type: "normal"; + } + | { + type: "stretch"; + } + | { + type: "baseline-position"; + value: BaselinePosition; + } + | { + /** + * An overflow alignment mode. + */ + overflow?: OverflowPosition | null; + type: "self-position"; + /** + * A self position keyword. + */ + value: SelfPosition; + }; +/** + * A value for the [justify-items](https://www.w3.org/TR/css-align-3/#justify-items-property) property. + */ +export type JustifyItems = + | { + type: "normal"; + } + | { + type: "stretch"; + } + | { + type: "baseline-position"; + value: BaselinePosition; + } + | { + /** + * An overflow alignment mode. + */ + overflow?: OverflowPosition | null; + type: "self-position"; + /** + * A self position keyword. + */ + value: SelfPosition; + } + | { + /** + * An overflow alignment mode. + */ + overflow?: OverflowPosition | null; + type: "left"; + } + | { + /** + * An overflow alignment mode. + */ + overflow?: OverflowPosition | null; + type: "right"; + } + | { + type: "legacy"; + value: LegacyJustify; + }; +/** + * A legacy justification keyword, as used in the `justify-items` property. + */ +export type LegacyJustify = "left" | "right" | "center"; +/** + * A [gap](https://www.w3.org/TR/css-align-3/#column-row-gap) value, as used in the `column-gap` and `row-gap` properties. + */ +export type GapValue = + | { + type: "normal"; + } + | { + type: "length-percentage"; + value: DimensionPercentageFor_LengthValue; + }; +/** + * A value for the legacy (prefixed) [box-orient](https://www.w3.org/TR/2009/WD-css3-flexbox-20090723/#orientation) property. Partially equivalent to `flex-direction` in the standard syntax. + */ +export type BoxOrient = "horizontal" | "vertical" | "inline-axis" | "block-axis"; +/** + * A value for the legacy (prefixed) [box-direction](https://www.w3.org/TR/2009/WD-css3-flexbox-20090723/#displayorder) property. Partially equivalent to the `flex-direction` property in the standard syntax. + */ +export type BoxDirection = "normal" | "reverse"; +/** + * A value for the legacy (prefixed) [box-align](https://www.w3.org/TR/2009/WD-css3-flexbox-20090723/#alignment) property. Equivalent to the `align-items` property in the standard syntax. + */ +export type BoxAlign = "start" | "end" | "center" | "baseline" | "stretch"; +/** + * A value for the legacy (prefixed) [box-pack](https://www.w3.org/TR/2009/WD-css3-flexbox-20090723/#packing) property. Equivalent to the `justify-content` property in the standard syntax. + */ +export type BoxPack = "start" | "end" | "center" | "justify"; +/** + * A value for the legacy (prefixed) [box-lines](https://www.w3.org/TR/2009/WD-css3-flexbox-20090723/#multiple) property. Equivalent to the `flex-wrap` property in the standard syntax. + */ +export type BoxLines = "single" | "multiple"; +/** + * A value for the legacy (prefixed) [flex-pack](https://www.w3.org/TR/2012/WD-css3-flexbox-20120322/#flex-pack) property. Equivalent to the `justify-content` property in the standard syntax. + */ +export type FlexPack = "start" | "end" | "center" | "justify" | "distribute"; +/** + * A value for the legacy (prefixed) [flex-item-align](https://www.w3.org/TR/2012/WD-css3-flexbox-20120322/#flex-align) property. Equivalent to the `align-self` property in the standard syntax. + */ +export type FlexItemAlign = "auto" | "start" | "end" | "center" | "baseline" | "stretch"; +/** + * A value for the legacy (prefixed) [flex-line-pack](https://www.w3.org/TR/2012/WD-css3-flexbox-20120322/#flex-line-pack) property. Equivalent to the `align-content` property in the standard syntax. + */ +export type FlexLinePack = "start" | "end" | "center" | "justify" | "distribute" | "stretch"; +/** + * A [track sizing](https://drafts.csswg.org/css-grid-2/#track-sizing) value for the `grid-template-rows` and `grid-template-columns` properties. + */ +export type TrackSizing = + | { + type: "none"; + } + | { + /** + * A list of grid track items. + */ + items: TrackListItem[]; + /** + * A list of line names. + */ + lineNames: String[][]; + type: "track-list"; + }; +/** + * Either a track size or `repeat()` function. + * + * See [TrackList](TrackList). + */ +export type TrackListItem = + | { + type: "track-size"; + value: TrackSize; + } + | { + type: "track-repeat"; + value: TrackRepeat; + }; +/** + * A [``](https://drafts.csswg.org/css-grid-2/#typedef-track-size) value, as used in the `grid-template-rows` and `grid-template-columns` properties. + * + * See [TrackListItem](TrackListItem). + */ +export type TrackSize = + | { + type: "track-breadth"; + value: TrackBreadth; + } + | { + /** + * The maximum value. + */ + max: TrackBreadth; + /** + * The minimum value. + */ + min: TrackBreadth; + type: "min-max"; + } + | { + type: "fit-content"; + value: DimensionPercentageFor_LengthValue; + }; +/** + * A [``](https://drafts.csswg.org/css-grid-2/#typedef-track-breadth) value. + * + * See [TrackSize](TrackSize). + */ +export type TrackBreadth = + | { + type: "length"; + value: DimensionPercentageFor_LengthValue; + } + | { + type: "flex"; + value: number; + } + | { + type: "min-content"; + } + | { + type: "max-content"; + } + | { + type: "auto"; + }; +/** + * A [``](https://drafts.csswg.org/css-grid-2/#typedef-track-repeat) value, used in the `repeat()` function. + * + * See [TrackRepeat](TrackRepeat). + */ +export type RepeatCount = + | { + type: "number"; + value: number; + } + | { + type: "auto-fill"; + } + | { + type: "auto-fit"; + }; +export type AutoFlowDirection = "row" | "column"; +/** + * A value for the [grid-template-areas](https://drafts.csswg.org/css-grid-2/#grid-template-areas-property) property. none | + + */ +export type GridTemplateAreas = + | { + type: "none"; + } + | { + /** + * A flattened list of grid area names. Unnamed areas specified by the `.` token are represented as `None`. + */ + areas: (string | null)[]; + /** + * The number of columns in the grid. + */ + columns: number; + type: "areas"; + }; +/** + * A [``](https://drafts.csswg.org/css-grid-2/#typedef-grid-row-start-grid-line) value, used in the `grid-row-start`, `grid-row-end`, `grid-column-start`, and `grid-column-end` properties. + */ +export type GridLine = + | { + type: "auto"; + } + | { + /** + * A grid area name. + */ + name: String; + type: "area"; + } + | { + /** + * A line number. + */ + index: number; + /** + * A line name to filter by. + */ + name?: String | null; + type: "line"; + } + | { + /** + * A line number. + */ + index: number; + /** + * A line name to filter by. + */ + name?: String | null; + type: "span"; + }; +/** + * A value for the [font-weight](https://www.w3.org/TR/css-fonts-4/#font-weight-prop) property. + */ +export type FontWeight = + | { + type: "absolute"; + value: AbsoluteFontWeight; + } + | { + type: "bolder"; + } + | { + type: "lighter"; + }; +/** + * An [absolute font weight](https://www.w3.org/TR/css-fonts-4/#font-weight-absolute-values), as used in the `font-weight` property. + * + * See [FontWeight](FontWeight). + */ +export type AbsoluteFontWeight = + | { + type: "weight"; + value: number; + } + | { + type: "normal"; + } + | { + type: "bold"; + }; +/** + * A value for the [font-size](https://www.w3.org/TR/css-fonts-4/#font-size-prop) property. + */ +export type FontSize = + | { + type: "length"; + value: DimensionPercentageFor_LengthValue; + } + | { + type: "absolute"; + value: AbsoluteFontSize; + } + | { + type: "relative"; + value: RelativeFontSize; + }; +/** + * An [absolute font size](https://www.w3.org/TR/css-fonts-3/#absolute-size-value), as used in the `font-size` property. + * + * See [FontSize](FontSize). + */ +export type AbsoluteFontSize = + | "xx-small" + | "x-small" + | "small" + | "medium" + | "large" + | "x-large" + | "xx-large" + | "xxx-large"; +/** + * A [relative font size](https://www.w3.org/TR/css-fonts-3/#relative-size-value), as used in the `font-size` property. + * + * See [FontSize](FontSize). + */ +export type RelativeFontSize = "smaller" | "larger"; +/** + * A value for the [font-stretch](https://www.w3.org/TR/css-fonts-4/#font-stretch-prop) property. + */ +export type FontStretch = + | { + type: "keyword"; + value: FontStretchKeyword; + } + | { + type: "percentage"; + value: number; + }; +/** + * A [font stretch keyword](https://www.w3.org/TR/css-fonts-4/#font-stretch-prop), as used in the `font-stretch` property. + * + * See [FontStretch](FontStretch). + */ +export type FontStretchKeyword = + | "normal" + | "ultra-condensed" + | "extra-condensed" + | "condensed" + | "semi-condensed" + | "semi-expanded" + | "expanded" + | "extra-expanded" + | "ultra-expanded"; +/** + * A value for the [font-family](https://www.w3.org/TR/css-fonts-4/#font-family-prop) property. + */ +export type FontFamily = GenericFontFamily | String; +/** + * A [generic font family](https://www.w3.org/TR/css-fonts-4/#generic-font-families) name, as used in the `font-family` property. + * + * See [FontFamily](FontFamily). + */ +export type GenericFontFamily = + | "serif" + | "sans-serif" + | "cursive" + | "fantasy" + | "monospace" + | "system-ui" + | "emoji" + | "math" + | "fangsong" + | "ui-serif" + | "ui-sans-serif" + | "ui-monospace" + | "ui-rounded" + | "initial" + | "inherit" + | "unset" + | "default" + | "revert" + | "revert-layer"; +/** + * A value for the [font-style](https://www.w3.org/TR/css-fonts-4/#font-style-prop) property. + */ +export type FontStyle = + | { + type: "normal"; + } + | { + type: "italic"; + } + | { + type: "oblique"; + value: Angle; + }; +/** + * A value for the [font-variant-caps](https://www.w3.org/TR/css-fonts-4/#font-variant-caps-prop) property. + */ +export type FontVariantCaps = + | "normal" + | "small-caps" + | "all-small-caps" + | "petite-caps" + | "all-petite-caps" + | "unicase" + | "titling-caps"; +/** + * A value for the [line-height](https://www.w3.org/TR/2020/WD-css-inline-3-20200827/#propdef-line-height) property. + */ +export type LineHeight = + | { + type: "normal"; + } + | { + type: "number"; + value: number; + } + | { + type: "length"; + value: DimensionPercentageFor_LengthValue; + }; +/** + * A value for the [vertical align](https://drafts.csswg.org/css2/#propdef-vertical-align) property. + */ +export type VerticalAlign = + | { + type: "keyword"; + value: VerticalAlignKeyword; + } + | { + type: "length"; + value: DimensionPercentageFor_LengthValue; + }; +/** + * A keyword for the [vertical align](https://drafts.csswg.org/css2/#propdef-vertical-align) property. + */ +export type VerticalAlignKeyword = + | "baseline" + | "sub" + | "super" + | "top" + | "text-top" + | "middle" + | "bottom" + | "text-bottom"; +/** + * A CSS [easing function](https://www.w3.org/TR/css-easing-1/#easing-functions). + */ +export type EasingFunction = + | { + type: "linear"; + } + | { + type: "ease"; + } + | { + type: "ease-in"; + } + | { + type: "ease-out"; + } + | { + type: "ease-in-out"; + } + | { + type: "cubic-bezier"; + /** + * The x-position of the first point in the curve. + */ + x1: number; + /** + * The x-position of the second point in the curve. + */ + x2: number; + /** + * The y-position of the first point in the curve. + */ + y1: number; + /** + * The y-position of the second point in the curve. + */ + y2: number; + } + | { + /** + * The number of intervals in the function. + */ + count: number; + /** + * The step position. + */ + position?: StepPosition; + type: "steps"; + }; +/** + * A [step position](https://www.w3.org/TR/css-easing-1/#step-position), used within the `steps()` function. + */ +export type StepPosition = + | { + type: "start"; + } + | { + type: "end"; + } + | { + type: "jump-none"; + } + | { + type: "jump-both"; + }; +/** + * A value for the [animation-iteration-count](https://drafts.csswg.org/css-animations/#animation-iteration-count) property. + */ +export type AnimationIterationCount = + | { + type: "number"; + value: number; + } + | { + type: "infinite"; + }; +/** + * A value for the [animation-direction](https://drafts.csswg.org/css-animations/#animation-direction) property. + */ +export type AnimationDirection = "normal" | "reverse" | "alternate" | "alternate-reverse"; +/** + * A value for the [animation-play-state](https://drafts.csswg.org/css-animations/#animation-play-state) property. + */ +export type AnimationPlayState = "running" | "paused"; +/** + * A value for the [animation-fill-mode](https://drafts.csswg.org/css-animations/#animation-fill-mode) property. + */ +export type AnimationFillMode = "none" | "forwards" | "backwards" | "both"; +/** + * A value for the [animation-composition](https://drafts.csswg.org/css-animations-2/#animation-composition) property. + */ +export type AnimationComposition = "replace" | "add" | "accumulate"; +/** + * A value for the [animation-timeline](https://drafts.csswg.org/css-animations-2/#animation-timeline) property. + */ +export type AnimationTimeline = + | { + type: "auto"; + } + | { + type: "none"; + } + | { + type: "dashed-ident"; + value: String; + } + | { + type: "scroll"; + value: ScrollTimeline; + } + | { + type: "view"; + value: ViewTimeline; + }; +/** + * A scroll axis, used in the `scroll()` function. + */ +export type ScrollAxis = "block" | "inline" | "x" | "y"; +/** + * A scroller, used in the `scroll()` function. + */ +export type Scroller = "root" | "nearest" | "self"; +/** + * A generic value that represents a value with two components, e.g. a border radius. + * + * When serialized, only a single component will be written if both are equal. + * + * @minItems 2 + * @maxItems 2 + */ +export type Size2DFor_LengthPercentageOrAuto = [LengthPercentageOrAuto, LengthPercentageOrAuto]; +/** + * A value for the [animation-range-start](https://drafts.csswg.org/scroll-animations/#animation-range-start) property. + */ +export type AnimationRangeStart = AnimationAttachmentRange; +/** + * A value for the [animation-range-start](https://drafts.csswg.org/scroll-animations/#animation-range-start) or [animation-range-end](https://drafts.csswg.org/scroll-animations/#animation-range-end) property. + */ +export type AnimationAttachmentRange = + "normal" | DimensionPercentageFor_LengthValue | { + /** + * The name of the timeline range. + */ + name: TimelineRangeName; + /** + * The offset from the start of the named timeline range. + */ + offset: DimensionPercentageFor_LengthValue; + }; +/** + * A [view progress timeline range](https://drafts.csswg.org/scroll-animations/#view-timelines-ranges) + */ +export type TimelineRangeName = "cover" | "contain" | "entry" | "exit" | "entry-crossing" | "exit-crossing"; +/** + * A value for the [animation-range-end](https://drafts.csswg.org/scroll-animations/#animation-range-end) property. + */ +export type AnimationRangeEnd = AnimationAttachmentRange; +/** + * An individual [transform function](https://www.w3.org/TR/2019/CR-css-transforms-1-20190214/#two-d-transform-functions). + */ +export type Transform = + | { + type: "translate"; + /** + * @minItems 2 + * @maxItems 2 + */ + value: [DimensionPercentageFor_LengthValue, DimensionPercentageFor_LengthValue]; + } + | { + type: "translateX"; + value: DimensionPercentageFor_LengthValue; + } + | { + type: "translateY"; + value: DimensionPercentageFor_LengthValue; + } + | { + type: "translateZ"; + value: Length; + } + | { + type: "translate3d"; + /** + * @minItems 3 + * @maxItems 3 + */ + value: [DimensionPercentageFor_LengthValue, DimensionPercentageFor_LengthValue, Length]; + } + | { + type: "scale"; + /** + * @minItems 2 + * @maxItems 2 + */ + value: [NumberOrPercentage, NumberOrPercentage]; + } + | { + type: "scaleX"; + value: NumberOrPercentage; + } + | { + type: "scaleY"; + value: NumberOrPercentage; + } + | { + type: "scaleZ"; + value: NumberOrPercentage; + } + | { + type: "scale3d"; + /** + * @minItems 3 + * @maxItems 3 + */ + value: [NumberOrPercentage, NumberOrPercentage, NumberOrPercentage]; + } + | { + type: "rotate"; + value: Angle; + } + | { + type: "rotateX"; + value: Angle; + } + | { + type: "rotateY"; + value: Angle; + } + | { + type: "rotateZ"; + value: Angle; + } + | { + type: "rotate3d"; + /** + * @minItems 4 + * @maxItems 4 + */ + value: [number, number, number, Angle]; + } + | { + type: "skew"; + /** + * @minItems 2 + * @maxItems 2 + */ + value: [Angle, Angle]; + } + | { + type: "skewX"; + value: Angle; + } + | { + type: "skewY"; + value: Angle; + } + | { + type: "perspective"; + value: Length; + } + | { + type: "matrix"; + value: MatrixForFloat; + } + | { + type: "matrix3d"; + value: Matrix3DForFloat; + }; +/** + * A value for the [transform-style](https://drafts.csswg.org/css-transforms-2/#transform-style-property) property. + */ +export type TransformStyle = "flat" | "preserve3d"; +/** + * A value for the [transform-box](https://drafts.csswg.org/css-transforms-1/#transform-box) property. + */ +export type TransformBox = "content-box" | "border-box" | "fill-box" | "stroke-box" | "view-box"; +/** + * A value for the [backface-visibility](https://drafts.csswg.org/css-transforms-2/#backface-visibility-property) property. + */ +export type BackfaceVisibility = "visible" | "hidden"; +/** + * A value for the [perspective](https://drafts.csswg.org/css-transforms-2/#perspective-property) property. + */ +export type Perspective = + | { + type: "none"; + } + | { + type: "length"; + value: Length; + }; +/** + * A value for the [translate](https://drafts.csswg.org/css-transforms-2/#propdef-translate) property. + */ +export type Translate = + | "none" + | { + /** + * The x translation. + */ + x: DimensionPercentageFor_LengthValue; + /** + * The y translation. + */ + y: DimensionPercentageFor_LengthValue; + /** + * The z translation. + */ + z: Length; + }; +/** + * A value for the [rotate](https://drafts.csswg.org/css-transforms-2/#propdef-rotate) property. + */ +export type Rotate = + | "none" + | { + xyz: { + /** + * The angle of rotation. + */ + angle: Angle; + /** + * Rotation around the x axis. + */ + x: number; + /** + * Rotation around the y axis. + */ + y: number; + /** + * Rotation around the z axis. + */ + z: number; + }; + }; +/** + * A value for the [scale](https://drafts.csswg.org/css-transforms-2/#propdef-scale) property. + */ +export type Scale = + | "none" + | { + /** + * Scale on the x axis. + */ + x: NumberOrPercentage; + /** + * Scale on the y axis. + */ + y: NumberOrPercentage; + /** + * Scale on the z axis. + */ + z: NumberOrPercentage; + }; +/** + * Defines how text case should be transformed in the [text-transform](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#text-transform-property) property. + */ +export type TextTransformCase = "none" | "uppercase" | "lowercase" | "capitalize"; +/** + * A value for the [white-space](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#white-space-property) property. + */ +export type WhiteSpace = "normal" | "pre" | "nowrap" | "pre-wrap" | "break-spaces" | "pre-line"; +/** + * A value for the [word-break](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#word-break-property) property. + */ +export type WordBreak = "normal" | "keep-all" | "break-all" | "break-word"; +/** + * A value for the [line-break](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#line-break-property) property. + */ +export type LineBreak = "auto" | "loose" | "normal" | "strict" | "anywhere"; +/** + * A value for the [hyphens](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#hyphenation) property. + */ +export type Hyphens = "none" | "manual" | "auto"; +/** + * A value for the [overflow-wrap](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#overflow-wrap-property) property. + */ +export type OverflowWrap = "normal" | "anywhere" | "break-word"; +/** + * A value for the [text-align](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#text-align-property) property. + */ +export type TextAlign = "start" | "end" | "left" | "right" | "center" | "justify" | "match-parent" | "justify-all"; +/** + * A value for the [text-align-last](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#text-align-last-property) property. + */ +export type TextAlignLast = "auto" | "start" | "end" | "left" | "right" | "center" | "justify" | "match-parent"; +/** + * A value for the [text-justify](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#text-justify-property) property. + */ +export type TextJustify = "auto" | "none" | "inter-word" | "inter-character"; +/** + * A value for the [word-spacing](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#word-spacing-property) and [letter-spacing](https://www.w3.org/TR/2021/CRD-css-text-3-20210422/#letter-spacing-property) properties. + */ +export type Spacing = + | { + type: "normal"; + } + | { + type: "length"; + value: Length; + }; +export type TextDecorationLine = ExclusiveTextDecorationLine | OtherTextDecorationLine[]; +export type ExclusiveTextDecorationLine = "none" | "spelling-error" | "grammar-error"; +export type OtherTextDecorationLine = "underline" | "overline" | "line-through" | "blink"; +/** + * A value for the [text-decoration-style](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-decoration-style-property) property. + */ +export type TextDecorationStyle = "solid" | "double" | "dotted" | "dashed" | "wavy"; +/** + * A value for the [text-decoration-thickness](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-decoration-width-property) property. + */ +export type TextDecorationThickness = + | { + type: "auto"; + } + | { + type: "from-font"; + } + | { + type: "length-percentage"; + value: DimensionPercentageFor_LengthValue; + }; +/** + * A value for the [text-decoration-skip-ink](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-decoration-skip-ink-property) property. + */ +export type TextDecorationSkipInk = "auto" | "none" | "all"; +/** + * A value for the [text-emphasis-style](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-emphasis-style-property) property. + */ +export type TextEmphasisStyle = + | { + type: "none"; + } + | { + /** + * The fill mode for the marks. + */ + fill: TextEmphasisFillMode; + /** + * The shape of the marks. + */ + shape?: TextEmphasisShape | null; + type: "keyword"; + } + | { + type: "string"; + value: String; + }; +/** + * A keyword for the [text-emphasis-style](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-emphasis-style-property) property. + * + * See [TextEmphasisStyle](TextEmphasisStyle). + */ +export type TextEmphasisFillMode = "filled" | "open"; +/** + * A text emphasis shape for the [text-emphasis-style](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-emphasis-style-property) property. + * + * See [TextEmphasisStyle](TextEmphasisStyle). + */ +export type TextEmphasisShape = "dot" | "circle" | "double-circle" | "triangle" | "sesame"; +/** + * A horizontal position keyword for the [text-emphasis-position](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-emphasis-position-property) property. + * + * See [TextEmphasisPosition](TextEmphasisPosition). + */ +export type TextEmphasisPositionHorizontal = "left" | "right"; +/** + * A vertical position keyword for the [text-emphasis-position](https://www.w3.org/TR/2020/WD-css-text-decor-4-20200506/#text-emphasis-position-property) property. + * + * See [TextEmphasisPosition](TextEmphasisPosition). + */ +export type TextEmphasisPositionVertical = "over" | "under"; +/** + * A value for the [text-size-adjust](https://w3c.github.io/csswg-drafts/css-size-adjust/#adjustment-control) property. + */ +export type TextSizeAdjust = + | { + type: "auto"; + } + | { + type: "none"; + } + | { + type: "percentage"; + value: number; + }; +/** + * A value for the [direction](https://drafts.csswg.org/css-writing-modes-3/#direction) property. + */ +export type Direction2 = "ltr" | "rtl"; +/** + * A value for the [unicode-bidi](https://drafts.csswg.org/css-writing-modes-3/#unicode-bidi) property. + */ +export type UnicodeBidi = "normal" | "embed" | "isolate" | "bidi-override" | "isolate-override" | "plaintext"; +/** + * A value for the [box-decoration-break](https://www.w3.org/TR/css-break-3/#break-decoration) property. + */ +export type BoxDecorationBreak = "slice" | "clone"; +/** + * A value for the [resize](https://www.w3.org/TR/2021/WD-css-ui-4-20210316/#resize) property. + */ +export type Resize = "none" | "both" | "horizontal" | "vertical" | "block" | "inline"; +/** + * A pre-defined [cursor](https://www.w3.org/TR/2021/WD-css-ui-4-20210316/#cursor) value, used in the `cursor` property. + * + * See [Cursor](Cursor). + */ +export type CursorKeyword = + | "auto" + | "default" + | "none" + | "context-menu" + | "help" + | "pointer" + | "progress" + | "wait" + | "cell" + | "crosshair" + | "text" + | "vertical-text" + | "alias" + | "copy" + | "move" + | "no-drop" + | "not-allowed" + | "grab" + | "grabbing" + | "e-resize" + | "n-resize" + | "ne-resize" + | "nw-resize" + | "s-resize" + | "se-resize" + | "sw-resize" + | "w-resize" + | "ew-resize" + | "ns-resize" + | "nesw-resize" + | "nwse-resize" + | "col-resize" + | "row-resize" + | "all-scroll" + | "zoom-in" + | "zoom-out"; +/** + * A value for the [caret-color](https://www.w3.org/TR/2021/WD-css-ui-4-20210316/#caret-color) property. + */ +export type ColorOrAuto = + | { + type: "auto"; + } + | { + type: "color"; + value: CssColor; + }; +/** + * A value for the [caret-shape](https://www.w3.org/TR/2021/WD-css-ui-4-20210316/#caret-shape) property. + */ +export type CaretShape = "auto" | "bar" | "block" | "underscore"; +/** + * A value for the [user-select](https://www.w3.org/TR/2021/WD-css-ui-4-20210316/#content-selection) property. + */ +export type UserSelect = "auto" | "text" | "none" | "contain" | "all"; +export type Appearance = string; +/** + * A value for the [list-style-type](https://www.w3.org/TR/2020/WD-css-lists-3-20201117/#text-markers) property. + */ +export type ListStyleType = + | { + type: "none"; + } + | { + type: "string"; + value: String; + } + | { + type: "counter-style"; + value: CounterStyle; + }; +/** + * A [counter-style](https://www.w3.org/TR/css-counter-styles-3/#typedef-counter-style) name. + */ +export type CounterStyle = + | { + type: "predefined"; + value: PredefinedCounterStyle; + } + | { + type: "name"; + value: String; + } + | { + /** + * The symbols. + */ + symbols: Symbol[]; + /** + * The counter system. + */ + system?: SymbolsType & string; + type: "symbols"; + }; +/** + * A [predefined counter](https://www.w3.org/TR/css-counter-styles-3/#predefined-counters) style. + */ +export type PredefinedCounterStyle = + | "decimal" + | "decimal-leading-zero" + | "arabic-indic" + | "armenian" + | "upper-armenian" + | "lower-armenian" + | "bengali" + | "cambodian" + | "khmer" + | "cjk-decimal" + | "devanagari" + | "georgian" + | "gujarati" + | "gurmukhi" + | "hebrew" + | "kannada" + | "lao" + | "malayalam" + | "mongolian" + | "myanmar" + | "oriya" + | "persian" + | "lower-roman" + | "upper-roman" + | "tamil" + | "telugu" + | "thai" + | "tibetan" + | "lower-alpha" + | "lower-latin" + | "upper-alpha" + | "upper-latin" + | "lower-greek" + | "hiragana" + | "hiragana-iroha" + | "katakana" + | "katakana-iroha" + | "disc" + | "circle" + | "square" + | "disclosure-open" + | "disclosure-closed" + | "cjk-earthly-branch" + | "cjk-heavenly-stem" + | "japanese-informal" + | "japanese-formal" + | "korean-hangul-formal" + | "korean-hanja-informal" + | "korean-hanja-formal" + | "simp-chinese-informal" + | "simp-chinese-formal" + | "trad-chinese-informal" + | "trad-chinese-formal" + | "ethiopic-numeric"; +/** + * A single [symbol](https://www.w3.org/TR/css-counter-styles-3/#funcdef-symbols) as used in the `symbols()` function. + * + * See [CounterStyle](CounterStyle). + */ +export type Symbol = + | { + type: "string"; + value: String; + } + | { + type: "image"; + value: Image; + }; +/** + * A [``](https://www.w3.org/TR/css-counter-styles-3/#typedef-symbols-type) value, as used in the `symbols()` function. + * + * See [CounterStyle](CounterStyle). + */ +export type SymbolsType = "cyclic" | "numeric" | "alphabetic" | "symbolic" | "fixed"; +/** + * A value for the [list-style-position](https://www.w3.org/TR/2020/WD-css-lists-3-20201117/#list-style-position-property) property. + */ +export type ListStylePosition = "inside" | "outside"; +/** + * A value for the [marker-side](https://www.w3.org/TR/2020/WD-css-lists-3-20201117/#marker-side) property. + */ +export type MarkerSide = "match-self" | "match-parent"; +/** + * An SVG [``](https://www.w3.org/TR/SVG2/painting.html#SpecifyingPaint) value used in the `fill` and `stroke` properties. + */ +export type SVGPaint = + | { + /** + * A fallback to be used used in case the paint server cannot be resolved. + */ + fallback?: SVGPaintFallback | null; + type: "url"; + /** + * The url of the paint server. + */ + url: Url; + } + | { + type: "color"; + value: CssColor; + } + | { + type: "context-fill"; + } + | { + type: "context-stroke"; + } + | { + type: "none"; + }; +/** + * A fallback for an SVG paint in case a paint server `url()` cannot be resolved. + * + * See [SVGPaint](SVGPaint). + */ +export type SVGPaintFallback = + | { + type: "none"; + } + | { + type: "color"; + value: CssColor; + }; +/** + * A [``](https://www.w3.org/TR/css-shapes-1/#typedef-fill-rule) used to determine the interior of a `polygon()` shape. + * + * See [Polygon](Polygon). + */ +export type FillRule = "nonzero" | "evenodd"; +/** + * A value for the [stroke-linecap](https://www.w3.org/TR/SVG2/painting.html#LineCaps) property. + */ +export type StrokeLinecap = "butt" | "round" | "square"; +/** + * A value for the [stroke-linejoin](https://www.w3.org/TR/SVG2/painting.html#LineJoin) property. + */ +export type StrokeLinejoin = "miter" | "miter-clip" | "round" | "bevel" | "arcs"; +/** + * A value for the [stroke-dasharray](https://www.w3.org/TR/SVG2/painting.html#StrokeDashing) property. + */ +export type StrokeDasharray = + | { + type: "none"; + } + | { + type: "values"; + value: DimensionPercentageFor_LengthValue[]; + }; +/** + * A value for the [marker](https://www.w3.org/TR/SVG2/painting.html#VertexMarkerProperties) properties. + */ +export type Marker = + | { + type: "none"; + } + | { + type: "url"; + value: Url; + }; +/** + * A value for the [color-interpolation](https://www.w3.org/TR/SVG2/painting.html#ColorInterpolation) property. + */ +export type ColorInterpolation = "auto" | "srgb" | "linearrgb"; +/** + * A value for the [color-rendering](https://www.w3.org/TR/SVG2/painting.html#ColorRendering) property. + */ +export type ColorRendering = "auto" | "optimizespeed" | "optimizequality"; +/** + * A value for the [shape-rendering](https://www.w3.org/TR/SVG2/painting.html#ShapeRendering) property. + */ +export type ShapeRendering = "auto" | "optimizespeed" | "crispedges" | "geometricprecision"; +/** + * A value for the [text-rendering](https://www.w3.org/TR/SVG2/painting.html#TextRendering) property. + */ +export type TextRendering = "auto" | "optimizespeed" | "optimizelegibility" | "geometricprecision"; +/** + * A value for the [image-rendering](https://www.w3.org/TR/SVG2/painting.html#ImageRendering) property. + */ +export type ImageRendering = "auto" | "optimizespeed" | "optimizequality"; +/** + * A value for the [clip-path](https://www.w3.org/TR/css-masking-1/#the-clip-path) property. + */ +export type ClipPath = + | { + type: "none"; + } + | { + type: "url"; + value: Url; + } + | { + /** + * A reference box that the shape is positioned according to. + */ + referenceBox: GeometryBox; + /** + * A basic shape. + */ + shape: BasicShape; + type: "shape"; + } + | { + type: "box"; + value: GeometryBox; + }; +/** + * A [``](https://www.w3.org/TR/css-masking-1/#typedef-geometry-box) value as used in the `mask-clip` and `clip-path` properties. + */ +export type GeometryBox = + | "border-box" + | "padding-box" + | "content-box" + | "margin-box" + | "fill-box" + | "stroke-box" + | "view-box"; +/** + * A CSS [``](https://www.w3.org/TR/css-shapes-1/#basic-shape-functions) value. + */ +export type BasicShape = + | { + type: "inset"; + value: InsetRect; + } + | { + type: "circle"; + value: Circle2; + } + | { + type: "ellipse"; + value: Ellipse2; + } + | { + type: "polygon"; + value: Polygon; + }; +/** + * A generic value that represents a value for four sides of a box, e.g. border-width, margin, padding, etc. + * + * When serialized, as few components as possible are written when there are duplicate values. + * + * @minItems 4 + * @maxItems 4 + */ +export type RectFor_DimensionPercentageFor_LengthValue = [ + DimensionPercentageFor_LengthValue, + DimensionPercentageFor_LengthValue, + DimensionPercentageFor_LengthValue, + DimensionPercentageFor_LengthValue +]; +/** + * A [``](https://www.w3.org/TR/css-shapes-1/#typedef-shape-radius) value that defines the radius of a `circle()` or `ellipse()` shape. + */ +export type ShapeRadius = + | { + type: "length-percentage"; + value: DimensionPercentageFor_LengthValue; + } + | { + type: "closest-side"; + } + | { + type: "farthest-side"; + }; +/** + * A value for the [mask-mode](https://www.w3.org/TR/css-masking-1/#the-mask-mode) property. + */ +export type MaskMode = "luminance" | "alpha" | "match-source"; +/** + * A value for the [mask-clip](https://www.w3.org/TR/css-masking-1/#the-mask-clip) property. + */ +export type MaskClip = + | { + type: "geometry-box"; + value: GeometryBox; + } + | { + type: "no-clip"; + }; +/** + * A value for the [mask-composite](https://www.w3.org/TR/css-masking-1/#the-mask-composite) property. + */ +export type MaskComposite = "add" | "subtract" | "intersect" | "exclude"; +/** + * A value for the [mask-type](https://www.w3.org/TR/css-masking-1/#the-mask-type) property. + */ +export type MaskType = "luminance" | "alpha"; +/** + * A value for the [mask-border-mode](https://www.w3.org/TR/css-masking-1/#the-mask-border-mode) property. + */ +export type MaskBorderMode = "luminance" | "alpha"; +/** + * A value for the [-webkit-mask-composite](https://developer.mozilla.org/en-US/docs/Web/CSS/-webkit-mask-composite) property. + * + * See also [MaskComposite](MaskComposite). + */ +export type WebKitMaskComposite = + | ("clear" | "copy" | "source-atop" | "destination-over" | "destination-in" | "destination-out" | "destination-atop") + | "source-over" + | "source-in" + | "source-out" + | "xor"; +/** + * A value for the [-webkit-mask-source-type](https://github.com/WebKit/WebKit/blob/6eece09a1c31e47489811edd003d1e36910e9fd3/Source/WebCore/css/CSSProperties.json#L6578-L6587) property. + * + * See also [MaskMode](MaskMode). + */ +export type WebKitMaskSourceType = "auto" | "luminance" | "alpha"; +/** + * A value for the [filter](https://drafts.fxtf.org/filter-effects-1/#FilterProperty) and [backdrop-filter](https://drafts.fxtf.org/filter-effects-2/#BackdropFilterProperty) properties. + */ +export type FilterList = + | { + type: "none"; + } + | { + type: "filters"; + value: Filter[]; + }; +/** + * A [filter](https://drafts.fxtf.org/filter-effects-1/#filter-functions) function. + */ +export type Filter = + | { + type: "blur"; + value: Length; + } + | { + type: "brightness"; + value: NumberOrPercentage; + } + | { + type: "contrast"; + value: NumberOrPercentage; + } + | { + type: "grayscale"; + value: NumberOrPercentage; + } + | { + type: "hue-rotate"; + value: Angle; + } + | { + type: "invert"; + value: NumberOrPercentage; + } + | { + type: "opacity"; + value: NumberOrPercentage; + } + | { + type: "saturate"; + value: NumberOrPercentage; + } + | { + type: "sepia"; + value: NumberOrPercentage; + } + | { + type: "drop-shadow"; + value: DropShadow; + } + | { + type: "url"; + value: Url; + }; +/** + * A [``](https://www.w3.org/TR/compositing-1/#ltblendmodegt) value. + */ +export type BlendMode = + | "normal" + | "multiply" + | "screen" + | "overlay" + | "darken" + | "lighten" + | "color-dodge" + | "color-burn" + | "hard-light" + | "soft-light" + | "difference" + | "exclusion" + | "hue" + | "saturation" + | "color" + | "luminosity" + | "plus-darker" + | "plus-lighter"; +/** + * A value for the [z-index](https://drafts.csswg.org/css2/#z-index) property. + */ +export type ZIndex = + | { + type: "auto"; + } + | { + type: "integer"; + value: number; + }; +/** + * A value for the [container-type](https://drafts.csswg.org/css-contain-3/#container-type) property. Establishes the element as a query container for the purpose of container queries. + */ +export type ContainerType = "normal" | "inline-size" | "size" | "scroll-state"; +/** + * A value for the [container-name](https://drafts.csswg.org/css-contain-3/#container-name) property. + */ +export type ContainerNameList = + | { + type: "none"; + } + | { + type: "names"; + value: String[]; + }; +/** + * A value for the [view-transition-name](https://drafts.csswg.org/css-view-transitions-1/#view-transition-name-prop) property. + */ +export type ViewTransitionName = + "none" | "auto" | String; +/** + * The `none` keyword, or a space-separated list of custom idents. + */ +export type NoneOrCustomIdentList = + "none" | String[]; +/** + * A value for the [view-transition-group](https://drafts.csswg.org/css-view-transitions-2/#view-transition-group-prop) property. + */ +export type ViewTransitionGroup = + "normal" | "contain" | "nearest" | String; +/** + * A value for the [print-color-adjust](https://drafts.csswg.org/css-color-adjust/#propdef-print-color-adjust) property. + */ +export type PrintColorAdjust = "economy" | "exact"; +/** + * A [CSS-wide keyword](https://drafts.csswg.org/css-cascade-5/#defaulting-keywords). + */ +export type CSSWideKeyword = "initial" | "inherit" | "unset" | "revert" | "revert-layer"; +/** + * A CSS custom property name. + */ +export type CustomPropertyName = String | String; +export type SelectorComponent = + | { + type: "combinator"; + value: Combinator; + } + | { + type: "universal"; + } + | ( + | { + type: "namespace"; + kind: "none"; + } + | { + type: "namespace"; + kind: "any"; + } + | { + type: "namespace"; + kind: "named"; + prefix: string; + } + ) + | { + name: string; + type: "type"; + } + | { + name: string; + type: "id"; + } + | { + name: string; + type: "class"; + } + | { + name: string; + namespace?: NamespaceConstraint | null; + operation?: AttrOperation | null; + type: "attribute"; + } + | ({ + type: "pseudo-class"; + } & (TSPseudoClass | PseudoClass)) + | ({ + type: "pseudo-element"; + } & (BuiltinPseudoElement | PseudoElement)) + | { + type: "nesting"; + }; +export type Combinator = + | ("child" | "descendant" | "next-sibling" | "later-sibling") + | "pseudo-element" + | "slot-assignment" + | "part" + | "deep-descendant" + | "deep"; +export type NamespaceConstraint = + | { + type: "any"; + } + | { + prefix: string; + type: "specific"; + url: string; + }; +export type ParsedCaseSensitivity = + | "explicit-case-sensitive" + | "ascii-case-insensitive" + | "case-sensitive" + | "ascii-case-insensitive-if-in-html-element-in-html-document"; +export type AttrSelectorOperator = "equal" | "includes" | "dash-match" | "prefix" | "substring" | "suffix"; +export type TSPseudoClass = + | { + kind: "not"; + selectors: Selector[]; + } + | { + kind: "first-child"; + } + | { + kind: "last-child"; + } + | { + kind: "only-child"; + } + | { + kind: "root"; + } + | { + kind: "empty"; + } + | { + kind: "scope"; + } + | { + a: number; + b: number; + kind: "nth-child"; + of?: Selector[] | null; + } + | { + a: number; + b: number; + kind: "nth-last-child"; + of?: Selector[] | null; + } + | { + a: number; + b: number; + kind: "nth-col"; + } + | { + a: number; + b: number; + kind: "nth-last-col"; + } + | { + a: number; + b: number; + kind: "nth-of-type"; + } + | { + a: number; + b: number; + kind: "nth-last-of-type"; + } + | { + kind: "first-of-type"; + } + | { + kind: "last-of-type"; + } + | { + kind: "only-of-type"; + } + | { + kind: "host"; + selectors?: Selector | null; + } + | { + kind: "where"; + selectors: Selector[]; + } + | { + kind: "is"; + selectors: Selector[]; + } + | { + kind: "any"; + selectors: Selector[]; + vendorPrefix: VendorPrefix; + } + | { + kind: "has"; + selectors: Selector[]; + }; +/** + * A pseudo class. + */ +export type PseudoClass = + | { + kind: "lang"; + /** + * A list of language codes. + */ + languages: String[]; + } + | { + /** + * A direction. + */ + direction: Direction; + kind: "dir"; + } + | { + kind: "hover"; + } + | { + kind: "active"; + } + | { + kind: "focus"; + } + | { + kind: "focus-visible"; + } + | { + kind: "focus-within"; + } + | { + kind: "current"; + } + | { + kind: "past"; + } + | { + kind: "future"; + } + | { + kind: "playing"; + } + | { + kind: "paused"; + } + | { + kind: "seeking"; + } + | { + kind: "buffering"; + } + | { + kind: "stalled"; + } + | { + kind: "muted"; + } + | { + kind: "volume-locked"; + } + | { + kind: "fullscreen"; + vendorPrefix: VendorPrefix; + } + | { + kind: "open"; + } + | { + kind: "closed"; + } + | { + kind: "modal"; + } + | { + kind: "picture-in-picture"; + } + | { + kind: "popover-open"; + } + | { + kind: "defined"; + } + | { + kind: "any-link"; + vendorPrefix: VendorPrefix; + } + | { + kind: "link"; + } + | { + kind: "local-link"; + } + | { + kind: "target"; + } + | { + kind: "target-current"; + } + | { + kind: "target-before"; + } + | { + kind: "target-after"; + } + | { + kind: "target-within"; + } + | { + kind: "visited"; + } + | { + kind: "enabled"; + } + | { + kind: "disabled"; + } + | { + kind: "read-only"; + vendorPrefix: VendorPrefix; + } + | { + kind: "read-write"; + vendorPrefix: VendorPrefix; + } + | { + kind: "placeholder-shown"; + vendorPrefix: VendorPrefix; + } + | { + kind: "default"; + } + | { + kind: "checked"; + } + | { + kind: "indeterminate"; + } + | { + kind: "blank"; + } + | { + kind: "valid"; + } + | { + kind: "invalid"; + } + | { + kind: "in-range"; + } + | { + kind: "out-of-range"; + } + | { + kind: "required"; + } + | { + kind: "optional"; + } + | { + kind: "user-valid"; + } + | { + kind: "user-invalid"; + } + | { + kind: "autofill"; + vendorPrefix: VendorPrefix; + } + | { + kind: "active-view-transition"; + } + | { + kind: "active-view-transition-type"; + /** + * A view transition type. + */ + type: String[]; + } + | { + kind: "state"; + /** + * The custom state identifier. + */ + state: String; + } + | { + kind: "local"; + /** + * A local selector. + */ + selector: Selector; + } + | { + kind: "global"; + /** + * A global selector. + */ + selector: Selector; + } + | { + kind: "webkit-scrollbar"; + value: WebKitScrollbarPseudoClass; + } + | { + kind: "custom"; + /** + * The pseudo class name. + */ + name: String; + } + | { + /** + * The arguments of the pseudo class function. + */ + arguments: TokenOrValue[]; + kind: "custom-function"; + /** + * The pseudo class name. + */ + name: String; + }; +/** + * The [:dir()](https://drafts.csswg.org/selectors-4/#the-dir-pseudo) pseudo class. + */ +export type Direction = "ltr" | "rtl"; +/** + * A [webkit scrollbar](https://webkit.org/blog/363/styling-scrollbars/) pseudo class. + */ +export type WebKitScrollbarPseudoClass = + | "horizontal" + | "vertical" + | "decrement" + | "increment" + | "start" + | "end" + | "double-button" + | "single-button" + | "no-button" + | "corner-present" + | "window-inactive"; +export type BuiltinPseudoElement = + | { + kind: "slotted"; + selector: Selector; + } + | { + kind: "part"; + names: string[]; + }; +/** + * A pseudo element. + */ +export type PseudoElement = + | { + kind: "after"; + } + | { + kind: "before"; + } + | { + kind: "first-line"; + } + | { + kind: "first-letter"; + } + | { + kind: "details-content"; + } + | { + kind: "target-text"; + } + | { + kind: "search-text"; + } + | { + kind: "selection"; + vendorPrefix: VendorPrefix; + } + | { + kind: "placeholder"; + vendorPrefix: VendorPrefix; + } + | { + kind: "highlight-function"; + /** + * A custom highlight name. + */ + name: String; + } + | { + kind: "marker"; + } + | { + kind: "backdrop"; + vendorPrefix: VendorPrefix; + } + | { + kind: "file-selector-button"; + vendorPrefix: VendorPrefix; + } + | { + kind: "webkit-scrollbar"; + value: WebKitScrollbarPseudoElement; + } + | { + kind: "cue"; + } + | { + kind: "cue-region"; + } + | { + kind: "cue-function"; + /** + * The selector argument. + */ + selector: Selector; + } + | { + kind: "cue-region-function"; + /** + * The selector argument. + */ + selector: Selector; + } + | { + kind: "view-transition"; + } + | { + kind: "view-transition-group"; + /** + * A part name selector. + */ + part: ViewTransitionPartSelector; + } + | { + kind: "view-transition-image-pair"; + /** + * A part name selector. + */ + part: ViewTransitionPartSelector; + } + | { + kind: "view-transition-old"; + /** + * A part name selector. + */ + part: ViewTransitionPartSelector; + } + | { + kind: "view-transition-new"; + /** + * A part name selector. + */ + part: ViewTransitionPartSelector; + } + | { + /** + * A form control identifier. + */ + identifier: String; + kind: "picker-function"; + } + | { + kind: "picker-icon"; + } + | { + kind: "checkmark"; + } + | { + kind: "grammar-error"; + } + | { + kind: "spelling-error"; + } + | { + kind: "custom"; + /** + * The name of the pseudo element. + */ + name: String; + } + | { + /** + * The arguments of the pseudo element function. + */ + arguments: TokenOrValue[]; + kind: "custom-function"; + /** + * The name of the pseudo element. + */ + name: String; + }; +/** + * A [webkit scrollbar](https://webkit.org/blog/363/styling-scrollbars/) pseudo element. + */ +export type WebKitScrollbarPseudoElement = + | "scrollbar" + | "button" + | "track" + | "track-piece" + | "thumb" + | "corner" + | "resizer"; +export type ViewTransitionPartName = string; +export type Selector = SelectorComponent[]; +export type SelectorList = Selector[]; +/** + * A [keyframe selector](https://drafts.csswg.org/css-animations/#typedef-keyframe-selector) within an `@keyframes` rule. + */ +export type KeyframeSelector = + | { + type: "percentage"; + value: number; + } + | { + type: "from"; + } + | { + type: "to"; + } + | { + type: "timeline-range-percentage"; + value: TimelineRangePercentage; + }; +/** + * KeyframesName + */ +export type KeyframesName = + | { + type: "ident"; + value: String; + } + | { + type: "custom"; + value: String; + }; +/** + * A property within an `@font-face` rule. + * + * See [FontFaceRule](FontFaceRule). + */ +export type FontFaceProperty = + | { + type: "source"; + value: Source[]; + } + | { + type: "font-family"; + value: FontFamily; + } + | { + type: "font-style"; + value: FontStyle2; + } + | { + type: "font-weight"; + value: Size2DFor_FontWeight; + } + | { + type: "font-stretch"; + value: Size2DFor_FontStretch; + } + | { + type: "unicode-range"; + value: UnicodeRange[]; + } + | { + type: "custom"; + value: CustomProperty; + }; +/** + * A value for the [src](https://drafts.csswg.org/css-fonts/#src-desc) property in an `@font-face` rule. + */ +export type Source = + | { + type: "url"; + value: UrlSource; + } + | { + type: "local"; + value: FontFamily; + }; +/** + * A font format keyword in the `format()` function of the the [src](https://drafts.csswg.org/css-fonts/#src-desc) property of an `@font-face` rule. + */ +export type FontFormat = + | { + type: "woff"; + } + | { + type: "woff2"; + } + | { + type: "truetype"; + } + | { + type: "opentype"; + } + | { + type: "embedded-opentype"; + } + | { + type: "collection"; + } + | { + type: "svg"; + } + | { + type: "string"; + value: String; + }; +/** + * A font format keyword in the `format()` function of the the [src](https://drafts.csswg.org/css-fonts/#src-desc) property of an `@font-face` rule. + */ +export type FontTechnology = + | "features-opentype" + | "features-aat" + | "features-graphite" + | "color-colrv0" + | "color-colrv1" + | "color-svg" + | "color-sbix" + | "color-cbdt" + | "variations" + | "palettes" + | "incremental"; +/** + * A value for the [font-style](https://w3c.github.io/csswg-drafts/css-fonts/#descdef-font-face-font-style) descriptor in an `@font-face` rule. + */ +export type FontStyle2 = + | { + type: "normal"; + } + | { + type: "italic"; + } + | { + type: "oblique"; + value: Size2DFor_Angle; + }; +/** + * A generic value that represents a value with two components, e.g. a border radius. + * + * When serialized, only a single component will be written if both are equal. + * + * @minItems 2 + * @maxItems 2 + */ +export type Size2DFor_Angle = [Angle, Angle]; +/** + * A generic value that represents a value with two components, e.g. a border radius. + * + * When serialized, only a single component will be written if both are equal. + * + * @minItems 2 + * @maxItems 2 + */ +export type Size2DFor_FontWeight = [FontWeight, FontWeight]; +/** + * A generic value that represents a value with two components, e.g. a border radius. + * + * When serialized, only a single component will be written if both are equal. + * + * @minItems 2 + * @maxItems 2 + */ +export type Size2DFor_FontStretch = [FontStretch, FontStretch]; +/** + * A property within an `@font-palette-values` rule. + * + * See [FontPaletteValuesRule](FontPaletteValuesRule). + */ +export type FontPaletteValuesProperty = + | { + type: "font-family"; + value: FontFamily; + } + | { + type: "base-palette"; + value: BasePalette; + } + | { + type: "override-colors"; + value: OverrideColors[]; + } + | { + type: "custom"; + value: CustomProperty; + }; +/** + * A value for the [base-palette](https://drafts.csswg.org/css-fonts-4/#base-palette-desc) property in an `@font-palette-values` rule. + */ +export type BasePalette = + | { + type: "light"; + } + | { + type: "dark"; + } + | { + type: "integer"; + value: number; + }; +/** + * The name of the `@font-feature-values` sub-rule. font-feature-value-type = <@stylistic> | <@historical-forms> | <@styleset> | <@character-variant> | <@swash> | <@ornaments> | <@annotation> + */ +export type FontFeatureSubruleType = + | "stylistic" + | "historical-forms" + | "styleset" + | "character-variant" + | "swash" + | "ornaments" + | "annotation"; +/** + * A [page margin box](https://www.w3.org/TR/css-page-3/#margin-boxes). + */ +export type PageMarginBox = + | "top-left-corner" + | "top-left" + | "top-center" + | "top-right" + | "top-right-corner" + | "left-top" + | "left-middle" + | "left-bottom" + | "right-top" + | "right-middle" + | "right-bottom" + | "bottom-left-corner" + | "bottom-left" + | "bottom-center" + | "bottom-right" + | "bottom-right-corner"; +/** + * A page pseudo class within an `@page` selector. + * + * See [PageSelector](PageSelector). + */ +export type PagePseudoClass = "left" | "right" | "first" | "last" | "blank"; +/** + * A parsed value for a [SyntaxComponent](SyntaxComponent). + */ +export type ParsedComponent = + | { + type: "length"; + value: Length; + } + | { + type: "number"; + value: number; + } + | { + type: "percentage"; + value: number; + } + | { + type: "length-percentage"; + value: DimensionPercentageFor_LengthValue; + } + | { + type: "string"; + value: String; + } + | { + type: "color"; + value: CssColor; + } + | { + type: "image"; + value: Image; + } + | { + type: "url"; + value: Url; + } + | { + type: "integer"; + value: number; + } + | { + type: "angle"; + value: Angle; + } + | { + type: "time"; + value: Time; + } + | { + type: "resolution"; + value: Resolution; + } + | { + type: "transform-function"; + value: Transform; + } + | { + type: "transform-list"; + value: Transform[]; + } + | { + type: "custom-ident"; + value: String; + } + | { + type: "literal"; + value: String; + } + | { + type: "repeated"; + value: { + /** + * The components to repeat. + */ + components: ParsedComponent[]; + /** + * A multiplier describing how the components repeat. + */ + multiplier: Multiplier; + }; + } + | { + type: "token-list"; + value: TokenOrValue[]; + }; +/** + * A [multiplier](https://drafts.css-houdini.org/css-properties-values-api/#multipliers) for a [SyntaxComponent](SyntaxComponent). Indicates whether and how the component may be repeated. + */ +export type Multiplier = + | { + type: "none"; + } + | { + type: "space"; + } + | { + type: "comma"; + }; +/** + * A CSS [syntax string](https://drafts.css-houdini.org/css-properties-values-api/#syntax-strings) used to define the grammar for a registered custom property. + */ +export type SyntaxString = + | { + type: "components"; + value: SyntaxComponent[]; + } + | { + type: "universal"; + }; +/** + * A [syntax component component name](https://drafts.css-houdini.org/css-properties-values-api/#supported-names). + */ +export type SyntaxComponentKind = + | { + type: "length"; + } + | { + type: "number"; + } + | { + type: "percentage"; + } + | { + type: "length-percentage"; + } + | { + type: "string"; + } + | { + type: "color"; + } + | { + type: "image"; + } + | { + type: "url"; + } + | { + type: "integer"; + } + | { + type: "angle"; + } + | { + type: "time"; + } + | { + type: "resolution"; + } + | { + type: "transform-function"; + } + | { + type: "transform-list"; + } + | { + type: "custom-ident"; + } + | { + type: "literal"; + value: string; + }; +/** + * Represents a container condition. + */ +export type ContainerCondition = | { + type: "feature"; + value: QueryFeatureFor_ContainerSizeFeatureId; + } +| { + type: "not"; + value: ContainerCondition; + } +| { + /** + * The conditions for the operator. + */ + conditions: ContainerCondition[]; + /** + * The operator for the conditions. + */ + operator: Operator; + type: "operation"; + } +| { + type: "style"; + value: StyleQuery; + } +| { + type: "scroll-state"; + value: ScrollStateQuery; + } +| { + type: "unknown"; + value: TokenOrValue[]; + }; +/** + * A generic media feature or container feature. + */ +export type QueryFeatureFor_ContainerSizeFeatureId = + | { + /** + * The name of the feature. + */ + name: MediaFeatureNameFor_ContainerSizeFeatureId; + type: "plain"; + /** + * The feature value. + */ + value: MediaFeatureValue; + } + | { + /** + * The name of the feature. + */ + name: MediaFeatureNameFor_ContainerSizeFeatureId; + type: "boolean"; + } + | { + /** + * The name of the feature. + */ + name: MediaFeatureNameFor_ContainerSizeFeatureId; + /** + * A comparator. + */ + operator: MediaFeatureComparison; + type: "range"; + /** + * The feature value. + */ + value: MediaFeatureValue; + } + | { + /** + * The end value. + */ + end: MediaFeatureValue; + /** + * A comparator for the end value. + */ + endOperator: MediaFeatureComparison; + /** + * The name of the feature. + */ + name: MediaFeatureNameFor_ContainerSizeFeatureId; + /** + * A start value. + */ + start: MediaFeatureValue; + /** + * A comparator for the start value. + */ + startOperator: MediaFeatureComparison; + type: "interval"; + }; +/** + * A media feature name. + */ +export type MediaFeatureNameFor_ContainerSizeFeatureId = ContainerSizeFeatureId | String | String; +/** + * A container query size feature identifier. + */ +export type ContainerSizeFeatureId = "width" | "height" | "inline-size" | "block-size" | "aspect-ratio" | "orientation"; +/** + * Represents a style query within a container condition. + */ +export type StyleQuery = | { + type: "declaration"; + value: D; + } +| { + type: "property"; + value: PropertyId; + } +| { + type: "not"; + value: StyleQuery; + } +| { + /** + * The conditions for the operator. + */ + conditions: StyleQuery[]; + /** + * The operator for the conditions. + */ + operator: Operator; + type: "operation"; + }; +/** + * Represents a scroll state query within a container condition. + */ +export type ScrollStateQuery = + | { + type: "feature"; + value: QueryFeatureFor_ScrollStateFeatureId; + } + | { + type: "not"; + value: ScrollStateQuery; + } + | { + /** + * The conditions for the operator. + */ + conditions: ScrollStateQuery[]; + /** + * The operator for the conditions. + */ + operator: Operator; + type: "operation"; + }; +/** + * A generic media feature or container feature. + */ +export type QueryFeatureFor_ScrollStateFeatureId = + | { + /** + * The name of the feature. + */ + name: MediaFeatureNameFor_ScrollStateFeatureId; + type: "plain"; + /** + * The feature value. + */ + value: MediaFeatureValue; + } + | { + /** + * The name of the feature. + */ + name: MediaFeatureNameFor_ScrollStateFeatureId; + type: "boolean"; + } + | { + /** + * The name of the feature. + */ + name: MediaFeatureNameFor_ScrollStateFeatureId; + /** + * A comparator. + */ + operator: MediaFeatureComparison; + type: "range"; + /** + * The feature value. + */ + value: MediaFeatureValue; + } + | { + /** + * The end value. + */ + end: MediaFeatureValue; + /** + * A comparator for the end value. + */ + endOperator: MediaFeatureComparison; + /** + * The name of the feature. + */ + name: MediaFeatureNameFor_ScrollStateFeatureId; + /** + * A start value. + */ + start: MediaFeatureValue; + /** + * A comparator for the start value. + */ + startOperator: MediaFeatureComparison; + type: "interval"; + }; +/** + * A media feature name. + */ +export type MediaFeatureNameFor_ScrollStateFeatureId = ScrollStateFeatureId | String | String; +/** + * A container query scroll state feature identifier. + */ +export type ScrollStateFeatureId = "stuck" | "snapped" | "scrollable" | "scrolled"; +/** + * A property within a `@view-transition` rule. + * + * See [ViewTransitionRule](ViewTransitionRule). + */ +export type ViewTransitionProperty = + | { + property: "navigation"; + value: Navigation; + } + | { + property: "types"; + value: NoneOrCustomIdentList; + } + | { + property: "custom"; + value: CustomProperty; + }; +/** + * A value for the [navigation](https://drafts.csswg.org/css-view-transitions-2/#view-transition-navigation-descriptor) property in a `@view-transition` rule. + */ +export type Navigation = "none" | "auto"; +export type DefaultAtRule = null; + +/** + * A CSS style sheet, representing a `.css` file or inline `' + * ) + * document.type //=> 'document' + * document.nodes.length //=> 2 + * ``` + */ +declare class Document_ extends Container { + nodes: Root[] + parent: undefined + type: 'document' + + constructor(defaults?: Document.DocumentProps) + + assign(overrides: Document.DocumentProps | object): this + clone(overrides?: Partial): this + cloneAfter(overrides?: Partial): this + cloneBefore(overrides?: Partial): this + + /** + * Returns a `Result` instance representing the document’s CSS roots. + * + * ```js + * const root1 = postcss.parse(css1, { from: 'a.css' }) + * const root2 = postcss.parse(css2, { from: 'b.css' }) + * const document = postcss.document() + * document.append(root1) + * document.append(root2) + * const result = document.toResult({ to: 'all.css', map: true }) + * ``` + * + * @param opts Options. + * @return Result with current document’s CSS. + */ + toResult(options?: ProcessOptions): Result +} + +declare class Document extends Document_ {} + +export = Document diff --git a/client/node_modules/postcss/lib/document.js b/client/node_modules/postcss/lib/document.js new file mode 100644 index 0000000..4468991 --- /dev/null +++ b/client/node_modules/postcss/lib/document.js @@ -0,0 +1,33 @@ +'use strict' + +let Container = require('./container') + +let LazyResult, Processor + +class Document extends Container { + constructor(defaults) { + // type needs to be passed to super, otherwise child roots won't be normalized correctly + super({ type: 'document', ...defaults }) + + if (!this.nodes) { + this.nodes = [] + } + } + + toResult(opts = {}) { + let lazy = new LazyResult(new Processor(), this, opts) + + return lazy.stringify() + } +} + +Document.registerLazyResult = dependant => { + LazyResult = dependant +} + +Document.registerProcessor = dependant => { + Processor = dependant +} + +module.exports = Document +Document.default = Document diff --git a/client/node_modules/postcss/lib/fromJSON.d.ts b/client/node_modules/postcss/lib/fromJSON.d.ts new file mode 100644 index 0000000..3a0c5b8 --- /dev/null +++ b/client/node_modules/postcss/lib/fromJSON.d.ts @@ -0,0 +1,9 @@ +import { JSONHydrator } from './postcss.js' + +interface FromJSON extends JSONHydrator { + default: FromJSON +} + +declare let fromJSON: FromJSON + +export = fromJSON diff --git a/client/node_modules/postcss/lib/fromJSON.js b/client/node_modules/postcss/lib/fromJSON.js new file mode 100644 index 0000000..c1a9509 --- /dev/null +++ b/client/node_modules/postcss/lib/fromJSON.js @@ -0,0 +1,107 @@ +'use strict' + +let AtRule = require('./at-rule') +let Comment = require('./comment') +let Declaration = require('./declaration') +let Input = require('./input') +let PreviousMap = require('./previous-map') +let Root = require('./root') +let Rule = require('./rule') + +function hydrateInputs(json, inputs) { + if (!json.inputs) return inputs + return json.inputs.map(input => { + let inputHydrated = { ...input, __proto__: Input.prototype } + if (inputHydrated.map) { + inputHydrated.map = { + ...inputHydrated.map, + __proto__: PreviousMap.prototype + } + } + return inputHydrated + }) +} + +function constructNode(json, inputs, children) { + let defaults = { ...json } + delete defaults.inputs + delete defaults.nodes + if (defaults.source) { + let { inputId, ...source } = defaults.source + defaults.source = source + if (inputId != null) { + defaults.source.input = inputs[inputId] + } + } + + let node + if (defaults.type === 'root') { + node = new Root(defaults) + } else if (defaults.type === 'decl') { + node = new Declaration(defaults) + } else if (defaults.type === 'rule') { + node = new Rule(defaults) + } else if (defaults.type === 'comment') { + node = new Comment(defaults) + } else if (defaults.type === 'atrule') { + node = new AtRule(defaults) + } else { + throw new Error('Unknown node type: ' + json.type) + } + + // Rehydrated children are attached after construction. Passing them + // through the container constructor would re-run insertion spacing + // normalization and overwrite each child's own `raws.before`. + if (children) { + node.nodes = children + for (let child of children) child.parent = node + } + + return node +} + +function fromJSON(json, inputs) { + if (Array.isArray(json)) return json.map(n => fromJSON(n)) + + // An explicit stack instead of recursive calls to survive deeply + // nested trees. Children are rehydrated before their parent node + // is constructed. + let result + let stack = [ + { childIndex: 0, children: [], inputs: hydrateInputs(json, inputs), json } + ] + + while (stack.length > 0) { + let frame = stack[stack.length - 1] + let jsonNodes = frame.json.nodes + + if (jsonNodes && frame.childIndex < jsonNodes.length) { + let childJson = jsonNodes[frame.childIndex] + frame.childIndex += 1 + stack.push({ + childIndex: 0, + children: [], + inputs: hydrateInputs(childJson, frame.inputs), + json: childJson + }) + continue + } + + stack.pop() + let node = constructNode( + frame.json, + frame.inputs, + jsonNodes ? frame.children : undefined + ) + if (stack.length > 0) { + stack[stack.length - 1].children.push(node) + } else { + result = node + } + } + + return result +} + +module.exports = fromJSON +fromJSON.default = fromJSON diff --git a/client/node_modules/postcss/lib/input.d.ts b/client/node_modules/postcss/lib/input.d.ts new file mode 100644 index 0000000..ca2d26b --- /dev/null +++ b/client/node_modules/postcss/lib/input.d.ts @@ -0,0 +1,226 @@ +import { CssSyntaxError, ProcessOptions } from './postcss.js' +import PreviousMap from './previous-map.js' + +declare namespace Input { + export interface FilePosition { + /** + * Column of inclusive start position in source file. + */ + column: number + + /** + * Column of exclusive end position in source file. + */ + endColumn?: number + + /** + * Line of exclusive end position in source file. + */ + endLine?: number + + /** + * Offset of exclusive end position in source file. + */ + endOffset?: number + + /** + * Absolute path to the source file. + */ + file?: string + + /** + * Line of inclusive start position in source file. + */ + line: number + + /** + * Offset of inclusive start position in source file. + */ + offset: number + + /** + * Source code. + */ + source?: string + + /** + * URL for the source file. + */ + url: string + } + + export { Input_ as default } +} + +/** + * Represents the source CSS. + * + * ```js + * const root = postcss.parse(css, { from: file }) + * const input = root.source.input + * ``` + */ +declare class Input_ { + /** + * Input CSS source. + * + * ```js + * const input = postcss.parse('a{}', { from: file }).input + * input.css //=> "a{}" + * ``` + */ + css: string + + /** + * Input source with support for non-CSS documents. + * + * ```js + * const input = postcss.parse('a{}', { from: file, document: '' }).input + * input.document //=> "" + * input.css //=> "a{}" + * ``` + */ + document: string + + /** + * The absolute path to the CSS source file defined + * with the `from` option. + * + * ```js + * const root = postcss.parse(css, { from: 'a.css' }) + * root.source.input.file //=> '/home/ai/a.css' + * ``` + */ + file?: string + + /** + * The flag to indicate whether or not the source code has Unicode BOM. + */ + hasBOM: boolean + + /** + * The unique ID of the CSS source. It will be created if `from` option + * is not provided (because PostCSS does not know the file path). + * + * ```js + * const root = postcss.parse(css) + * root.source.input.file //=> undefined + * root.source.input.id //=> "" + * ``` + */ + id?: string + + /** + * The input source map passed from a compilation step before PostCSS + * (for example, from Sass compiler). + * + * ```js + * root.source.input.map.consumer().sources //=> ['a.sass'] + * ``` + */ + map: PreviousMap + + /** + * The CSS source identifier. Contains `Input#file` if the user + * set the `from` option, or `Input#id` if they did not. + * + * ```js + * const root = postcss.parse(css, { from: 'a.css' }) + * root.source.input.from //=> "/home/ai/a.css" + * + * const root = postcss.parse(css) + * root.source.input.from //=> "" + * ``` + */ + get from(): string + + /** + * @param css Input CSS source. + * @param opts Process options. + */ + constructor(css: string, opts?: ProcessOptions) + + /** + * Returns `CssSyntaxError` with information about the error and its position. + */ + error( + message: string, + start: + | { + column: number + line: number + } + | { + offset: number + }, + end: + | { + column: number + line: number + } + | { + offset: number + }, + opts?: { plugin?: CssSyntaxError['plugin'] } + ): CssSyntaxError + error( + message: string, + line: number, + column: number, + opts?: { plugin?: CssSyntaxError['plugin'] } + ): CssSyntaxError + error( + message: string, + offset: number, + opts?: { plugin?: CssSyntaxError['plugin'] } + ): CssSyntaxError + + /** + * Converts source line and column to offset. + * + * @param line Source line. + * @param column Source column. + * @return Source offset. + */ + fromLineAndColumn(line: number, column: number): number + + /** + * Converts source offset to line and column. + * + * @param offset Source offset. + */ + fromOffset(offset: number): { col: number; line: number } | null + + /** + * Reads the input source map and returns a symbol position + * in the input source (e.g., in a Sass file that was compiled + * to CSS before being passed to PostCSS). Optionally takes an + * end position, exclusive. + * + * ```js + * root.source.input.origin(1, 1) //=> { file: 'a.css', line: 3, column: 1 } + * root.source.input.origin(1, 1, 1, 4) + * //=> { file: 'a.css', line: 3, column: 1, endLine: 3, endColumn: 4 } + * ``` + * + * @param line Line for inclusive start position in input CSS. + * @param column Column for inclusive start position in input CSS. + * @param endLine Line for exclusive end position in input CSS. + * @param endColumn Column for exclusive end position in input CSS. + * + * @return Position in input source. + */ + origin( + line: number, + column: number, + endLine?: number, + endColumn?: number + ): false | Input.FilePosition + + /** Converts this to a JSON-friendly object representation. */ + toJSON(): object +} + +declare class Input extends Input_ {} + +export = Input diff --git a/client/node_modules/postcss/lib/input.js b/client/node_modules/postcss/lib/input.js new file mode 100644 index 0000000..defe395 --- /dev/null +++ b/client/node_modules/postcss/lib/input.js @@ -0,0 +1,282 @@ +'use strict' + +let { nanoid } = require('nanoid/non-secure') +let { isAbsolute, resolve } = require('path') +let { SourceMapConsumer, SourceMapGenerator } = require('source-map-js') +let { fileURLToPath, pathToFileURL } = require('url') + +let CssSyntaxError = require('./css-syntax-error') +let PreviousMap = require('./previous-map') +let terminalHighlight = require('./terminal-highlight') + +let lineToIndexCache = Symbol('lineToIndexCache') + +let sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator) +let pathAvailable = Boolean(resolve && isAbsolute) + +function getLineToIndex(input) { + if (input[lineToIndexCache]) return input[lineToIndexCache] + let lines = input.css.split('\n') + let lineToIndex = new Array(lines.length) + let prevIndex = 0 + + for (let i = 0, l = lines.length; i < l; i++) { + lineToIndex[i] = prevIndex + prevIndex += lines[i].length + 1 + } + + input[lineToIndexCache] = lineToIndex + return lineToIndex +} + +class Input { + get from() { + return this.file || this.id + } + + constructor(css, opts = {}) { + if ( + css === null || + typeof css === 'undefined' || + (typeof css === 'object' && !css.toString) + ) { + throw new Error(`PostCSS received ${css} instead of CSS string`) + } + + this.css = css.toString() + + if (this.css[0] === '\uFEFF' || this.css[0] === '\uFFFE') { + this.hasBOM = true + this.css = this.css.slice(1) + } else { + this.hasBOM = false + } + + this.document = this.css + if (opts.document) this.document = opts.document.toString() + + if (opts.from) { + if ( + !pathAvailable || + /^\w+:\/\//.test(opts.from) || + isAbsolute(opts.from) + ) { + this.file = opts.from + } else { + this.file = resolve(opts.from) + } + } + + if (pathAvailable && sourceMapAvailable) { + let map = new PreviousMap(this.css, opts) + if (map.text) { + this.map = map + let file = map.consumer().file + if (!this.file && file) this.file = this.mapResolve(file) + } + } + + if (!this.file) { + this.id = '' + } + if (this.map) this.map.file = this.from + } + + error(message, line, column, opts = {}) { + let endColumn, endLine, endOffset, offset, result + + if (line && typeof line === 'object') { + let start = line + let end = column + if (typeof start.offset === 'number') { + offset = start.offset + let pos = this.fromOffset(offset) + line = pos.line + column = pos.col + } else { + line = start.line + column = start.column + offset = this.fromLineAndColumn(line, column) + } + if (typeof end.offset === 'number') { + endOffset = end.offset + let pos = this.fromOffset(endOffset) + endLine = pos.line + endColumn = pos.col + } else { + endLine = end.line + endColumn = end.column + endOffset = this.fromLineAndColumn(end.line, end.column) + } + } else if (!column) { + offset = line + let pos = this.fromOffset(offset) + line = pos.line + column = pos.col + } else { + offset = this.fromLineAndColumn(line, column) + } + + let origin = this.origin(line, column, endLine, endColumn) + if (origin) { + result = new CssSyntaxError( + message, + origin.endLine === undefined + ? origin.line + : { column: origin.column, line: origin.line }, + origin.endLine === undefined + ? origin.column + : { column: origin.endColumn, line: origin.endLine }, + origin.source, + origin.file, + opts.plugin + ) + } else { + result = new CssSyntaxError( + message, + endLine === undefined ? line : { column, line }, + endLine === undefined ? column : { column: endColumn, line: endLine }, + this.css, + this.file, + opts.plugin + ) + } + + result.input = { + column, + endColumn, + endLine, + endOffset, + line, + offset, + source: this.css + } + if (this.file) { + if (pathToFileURL) { + result.input.url = pathToFileURL(this.file).toString() + } + result.input.file = this.file + } + + return result + } + + fromLineAndColumn(line, column) { + let lineToIndex = getLineToIndex(this) + let index = lineToIndex[line - 1] + return index + column - 1 + } + + fromOffset(offset) { + let lineToIndex = getLineToIndex(this) + let lastLine = lineToIndex[lineToIndex.length - 1] + + let min = 0 + if (offset >= lastLine) { + min = lineToIndex.length - 1 + } else { + let max = lineToIndex.length - 2 + let mid + while (min < max) { + mid = min + ((max - min) >> 1) + if (offset < lineToIndex[mid]) { + max = mid - 1 + } else if (offset >= lineToIndex[mid + 1]) { + min = mid + 1 + } else { + min = mid + break + } + } + } + return { + col: offset - lineToIndex[min] + 1, + line: min + 1 + } + } + + mapResolve(file) { + if (/^\w+:\/\//.test(file)) { + return file + } + return resolve(this.map.consumer().sourceRoot || this.map.root || '.', file) + } + + origin(line, column, endLine, endColumn) { + if (!this.map) return false + let consumer = this.map.consumer() + + let from = consumer.originalPositionFor({ column: column - 1, line }) + if (!from.source) return false + + let to + if (typeof endLine === 'number') { + let toPosition = consumer.originalPositionFor({ + column: endColumn - 1, + line: endLine + }) + // The source map may not have a mapping that covers the end position + // (`originalPositionFor()` then returns `null` for `line`/`column` + // instead of omitting them). Treat that the same as not requesting + // an end position at all, so `endLine`/`endColumn` stay a consistent + // `undefined` pair instead of a mix of `null` and a bogus number. + if (toPosition.source) to = toPosition + } + + let fromUrl + + if (isAbsolute(from.source)) { + fromUrl = pathToFileURL(from.source) + } else { + fromUrl = new URL( + from.source, + this.map.consumer().sourceRoot || pathToFileURL(this.map.mapFile) + ) + } + + let result = { + column: from.column + 1, + endColumn: to && to.column + 1, + endLine: to && to.line, + line: from.line, + url: fromUrl.toString() + } + + if (fromUrl.protocol === 'file:') { + if (fileURLToPath) { + result.file = fileURLToPath(fromUrl) + } else { + /* c8 ignore next 2 */ + throw new Error(`file: protocol is not available in this PostCSS build`) + } + } + + let source = consumer.sourceContentFor(from.source) + if (source) result.source = source + + return result + } + + toJSON() { + let json = {} + for (let name of ['hasBOM', 'css', 'file', 'id']) { + if (this[name] != null) { + json[name] = this[name] + } + } + if (this.map) { + json.map = { ...this.map } + if (json.map.consumerCache) { + json.map.consumerCache = undefined + } + } + return json + } +} + +module.exports = Input +Input.default = Input + +if (terminalHighlight && terminalHighlight.registerInput) { + terminalHighlight.registerInput(Input) +} diff --git a/client/node_modules/postcss/lib/lazy-result.d.ts b/client/node_modules/postcss/lib/lazy-result.d.ts new file mode 100644 index 0000000..599a614 --- /dev/null +++ b/client/node_modules/postcss/lib/lazy-result.d.ts @@ -0,0 +1,189 @@ +import Document from './document.js' +import { SourceMap } from './postcss.js' +import Processor from './processor.js' +import Result, { Message, ResultOptions } from './result.js' +import Root from './root.js' +import Warning from './warning.js' + +declare namespace LazyResult { + export { LazyResult_ as default } +} + +/** + * A Promise proxy for the result of PostCSS transformations. + * + * A `LazyResult` instance is returned by `Processor#process`. + * + * ```js + * const lazy = postcss([autoprefixer]).process(css) + * ``` + */ +declare class LazyResult_ implements PromiseLike< + Result +> { + /** + * Processes input CSS through synchronous and asynchronous plugins + * and calls onRejected for each error thrown in any plugin. + * + * It implements standard Promise API. + * + * ```js + * postcss([autoprefixer]).process(css).then(result => { + * console.log(result.css) + * }).catch(error => { + * console.error(error) + * }) + * ``` + */ + catch: Promise>['catch'] + + /** + * Processes input CSS through synchronous and asynchronous plugins + * and calls onFinally on any error or when all plugins will finish work. + * + * It implements standard Promise API. + * + * ```js + * postcss([autoprefixer]).process(css).finally(() => { + * console.log('processing ended') + * }) + * ``` + */ + finally: Promise>['finally'] + + /** + * Processes input CSS through synchronous and asynchronous plugins + * and calls `onFulfilled` with a Result instance. If a plugin throws + * an error, the `onRejected` callback will be executed. + * + * It implements standard Promise API. + * + * ```js + * postcss([autoprefixer]).process(css, { from: cssPath }).then(result => { + * console.log(result.css) + * }) + * ``` + */ + then: Promise>['then'] + + /** + * An alias for the `css` property. Use it with syntaxes + * that generate non-CSS output. + * + * This property will only work with synchronous plugins. + * If the processor contains any asynchronous plugins + * it will throw an error. + * + * PostCSS runners should always use `LazyResult#then`. + */ + get content(): string + + /** + * Processes input CSS through synchronous plugins, converts `Root` + * to a CSS string and returns `Result#css`. + * + * This property will only work with synchronous plugins. + * If the processor contains any asynchronous plugins + * it will throw an error. + * + * PostCSS runners should always use `LazyResult#then`. + */ + get css(): string + + /** + * Processes input CSS through synchronous plugins + * and returns `Result#map`. + * + * This property will only work with synchronous plugins. + * If the processor contains any asynchronous plugins + * it will throw an error. + * + * PostCSS runners should always use `LazyResult#then`. + */ + get map(): SourceMap + + /** + * Processes input CSS through synchronous plugins + * and returns `Result#messages`. + * + * This property will only work with synchronous plugins. If the processor + * contains any asynchronous plugins it will throw an error. + * + * PostCSS runners should always use `LazyResult#then`. + */ + get messages(): Message[] + + /** + * Options from the `Processor#process` call. + */ + get opts(): ResultOptions + + /** + * Returns a `Processor` instance, which will be used + * for CSS transformations. + */ + get processor(): Processor + + /** + * Processes input CSS through synchronous plugins + * and returns `Result#root`. + * + * This property will only work with synchronous plugins. If the processor + * contains any asynchronous plugins it will throw an error. + * + * PostCSS runners should always use `LazyResult#then`. + */ + get root(): RootNode + + /** + * Returns the default string description of an object. + * Required to implement the Promise interface. + */ + get [Symbol.toStringTag](): string + + /** + * @param processor Processor used for this transformation. + * @param css CSS to parse and transform. + * @param opts Options from the `Processor#process` or `Root#toResult`. + */ + constructor(processor: Processor, css: string, opts: ResultOptions) + + /** + * Run plugin in async way and return `Result`. + * + * @return Result with output content. + */ + async(): Promise> + + /** + * Run plugin in sync way and return `Result`. + * + * @return Result with output content. + */ + sync(): Result + + /** + * Alias for the `LazyResult#css` property. + * + * ```js + * lazy + '' === lazy.css + * ``` + * + * @return Output CSS. + */ + toString(): string + + /** + * Processes input CSS through synchronous plugins + * and calls `Result#warnings`. + * + * @return Warnings from plugins. + */ + warnings(): Warning[] +} + +declare class LazyResult< + RootNode = Document | Root +> extends LazyResult_ {} + +export = LazyResult diff --git a/client/node_modules/postcss/lib/lazy-result.js b/client/node_modules/postcss/lib/lazy-result.js new file mode 100644 index 0000000..be695b2 --- /dev/null +++ b/client/node_modules/postcss/lib/lazy-result.js @@ -0,0 +1,626 @@ +'use strict' + +let Container = require('./container') +let Document = require('./document') +let MapGenerator = require('./map-generator') +let parse = require('./parse') +let Result = require('./result') +let Root = require('./root') +let stringify = require('./stringify') +let { isClean, my } = require('./symbols') +let warnOnce = require('./warn-once') + +const TYPE_TO_CLASS_NAME = { + atrule: 'AtRule', + comment: 'Comment', + decl: 'Declaration', + document: 'Document', + root: 'Root', + rule: 'Rule' +} + +const PLUGIN_PROPS = { + AtRule: true, + AtRuleExit: true, + Comment: true, + CommentExit: true, + Declaration: true, + DeclarationExit: true, + Document: true, + DocumentExit: true, + Once: true, + OnceExit: true, + postcssPlugin: true, + prepare: true, + Root: true, + RootExit: true, + Rule: true, + RuleExit: true +} + +const NOT_VISITORS = { + Once: true, + postcssPlugin: true, + prepare: true +} + +const CHILDREN = 0 + +function isPromise(obj) { + return typeof obj === 'object' && typeof obj.then === 'function' +} + +function getEvents(node) { + let key = false + let type = TYPE_TO_CLASS_NAME[node.type] + if (node.type === 'decl') { + key = node.prop.toLowerCase() + } else if (node.type === 'atrule') { + key = node.name.toLowerCase() + } + + if (key && node.append) { + return [ + type, + type + '-' + key, + CHILDREN, + type + 'Exit', + type + 'Exit-' + key + ] + } else if (key) { + return [type, type + '-' + key, type + 'Exit', type + 'Exit-' + key] + } else if (node.append) { + return [type, CHILDREN, type + 'Exit'] + } else { + return [type, type + 'Exit'] + } +} + +function toStack(node) { + let events + if (node.type === 'document') { + events = ['Document', CHILDREN, 'DocumentExit'] + } else if (node.type === 'root') { + events = ['Root', CHILDREN, 'RootExit'] + } else { + events = getEvents(node) + } + + return { + eventIndex: 0, + events, + iterator: 0, + node, + visitorIndex: 0, + visitors: [] + } +} + +function cleanMarks(node) { + let stack = [node] + while (stack.length > 0) { + let next = stack.pop() + next[isClean] = false + if (next.nodes) { + for (let i of next.nodes) stack.push(i) + } + } + return node +} + +let postcss = {} + +class LazyResult { + get content() { + return this.stringify().content + } + + get css() { + return this.stringify().css + } + + get map() { + return this.stringify().map + } + + get messages() { + return this.sync().messages + } + + get opts() { + return this.result.opts + } + + get processor() { + return this.result.processor + } + + get root() { + return this.sync().root + } + + get [Symbol.toStringTag]() { + return 'LazyResult' + } + + constructor(processor, css, opts) { + this.stringified = false + this.processed = false + + let root + if ( + typeof css === 'object' && + css !== null && + (css.type === 'root' || css.type === 'document') + ) { + root = cleanMarks(css) + } else if (css instanceof LazyResult || css instanceof Result) { + root = cleanMarks(css.root) + if (css.map) { + if (typeof opts.map === 'undefined') opts.map = {} + if (!opts.map.inline) opts.map.inline = false + opts.map.prev = css.map + } + } else { + let parser = parse + if (opts.syntax) parser = opts.syntax.parse + if (opts.parser) parser = opts.parser + if (parser.parse) parser = parser.parse + + try { + root = parser(css, opts) + } catch (error) { + this.processed = true + this.error = error + } + + if (root && !root[my]) { + /* c8 ignore next 2 */ + Container.rebuild(root) + } + } + + this.result = new Result(processor, root, opts) + this.helpers = { ...postcss, postcss, result: this.result } + this.plugins = this.processor.plugins.map(plugin => { + if (typeof plugin === 'object' && plugin.prepare) { + return { ...plugin, ...plugin.prepare(this.result) } + } else { + return plugin + } + }) + } + + async() { + if (this.error) return Promise.reject(this.error) + if (this.processed) return Promise.resolve(this.result) + if (!this.processing) { + this.processing = this.runAsync() + } + return this.processing + } + + catch(onRejected) { + return this.async().catch(onRejected) + } + + finally(onFinally) { + return this.async().then(onFinally, onFinally) + } + + getAsyncError() { + throw new Error('Use process(css).then(cb) to work with async plugins') + } + + handleError(error, node) { + let plugin = this.result.lastPlugin + try { + if (node) node.addToError(error) + this.error = error + if (error.name === 'CssSyntaxError' && !error.plugin) { + error.plugin = plugin.postcssPlugin + error.setMessage() + } else if (plugin.postcssVersion) { + if (process.env.NODE_ENV !== 'production') { + let pluginName = plugin.postcssPlugin + let pluginVer = plugin.postcssVersion + let runtimeVer = this.result.processor.version + let a = pluginVer.split('.') + let b = runtimeVer.split('.') + + if (a[0] !== b[0] || parseInt(a[1]) > parseInt(b[1])) { + // eslint-disable-next-line no-console + console.error( + 'Unknown error from PostCSS plugin. Your current PostCSS ' + + 'version is ' + + runtimeVer + + ', but ' + + pluginName + + ' uses ' + + pluginVer + + '. Perhaps this is the source of the error below.' + ) + } + } + } + } catch (err) { + /* c8 ignore next 3 */ + // eslint-disable-next-line no-console + if (console && console.error) console.error(err) + } + return error + } + + prepareVisitors() { + this.listeners = {} + let add = (plugin, type, cb) => { + if (!this.listeners[type]) this.listeners[type] = [] + this.listeners[type].push([plugin, cb]) + } + for (let plugin of this.plugins) { + if (typeof plugin === 'object') { + for (let event in plugin) { + if (!PLUGIN_PROPS[event] && /^[A-Z]/.test(event)) { + throw new Error( + `Unknown event ${event} in ${plugin.postcssPlugin}. ` + + `Try to update PostCSS (${this.processor.version} now).` + ) + } + if (!NOT_VISITORS[event]) { + if (typeof plugin[event] === 'object') { + for (let filter in plugin[event]) { + if (filter === '*') { + add(plugin, event, plugin[event][filter]) + } else { + add( + plugin, + event + '-' + filter.toLowerCase(), + plugin[event][filter] + ) + } + } + } else if (typeof plugin[event] === 'function') { + add(plugin, event, plugin[event]) + } + } + } + } + } + this.hasListener = Object.keys(this.listeners).length > 0 + } + + async runAsync() { + this.plugin = 0 + for (let i = 0; i < this.plugins.length; i++) { + let plugin = this.plugins[i] + let promise = this.runOnRoot(plugin) + if (isPromise(promise)) { + try { + await promise + } catch (error) { + throw this.handleError(error) + } + } + } + + this.prepareVisitors() + if (this.hasListener) { + let root = this.result.root + while (!root[isClean]) { + root[isClean] = true + let stack = [toStack(root)] + while (stack.length > 0) { + let promise = this.visitTick(stack) + if (isPromise(promise)) { + try { + await promise + } catch (e) { + let node = stack[stack.length - 1].node + throw this.handleError(e, node) + } + } + } + } + + if (this.listeners.OnceExit) { + for (let [plugin, visitor] of this.listeners.OnceExit) { + this.result.lastPlugin = plugin + try { + if (root.type === 'document') { + let roots = root.nodes.map(subRoot => + visitor(subRoot, this.helpers) + ) + + await Promise.all(roots) + } else { + await visitor(root, this.helpers) + } + } catch (e) { + throw this.handleError(e) + } + } + } + } + + this.processed = true + return this.stringify() + } + + runOnRoot(plugin) { + this.result.lastPlugin = plugin + try { + if (typeof plugin === 'object' && plugin.Once) { + if (this.result.root.type === 'document') { + let roots = this.result.root.nodes.map(root => + plugin.Once(root, this.helpers) + ) + + if (isPromise(roots[0])) { + return Promise.all(roots) + } + + return roots + } + + return plugin.Once(this.result.root, this.helpers) + } else if (typeof plugin === 'function') { + return plugin(this.result.root, this.result) + } + } catch (error) { + throw this.handleError(error) + } + } + + stringify() { + if (this.error) throw this.error + if (this.stringified) return this.result + this.stringified = true + + this.sync() + + let opts = this.result.opts + let str = stringify + if (opts.syntax) str = opts.syntax.stringify + if (opts.stringifier) str = opts.stringifier + if (str.stringify) str = str.stringify + + let rootSource = this.result.root.source + if ( + opts.map === undefined && + !(rootSource && rootSource.input && rootSource.input.map) + ) { + let result = '' + str(this.result.root, i => { + result += i + }) + this.result.css = result + return this.result + } + + let map = new MapGenerator(str, this.result.root, this.result.opts) + let data = map.generate() + this.result.css = data[0] + this.result.map = data[1] + + return this.result + } + + sync() { + if (this.error) throw this.error + if (this.processed) return this.result + this.processed = true + + if (this.processing) { + throw this.getAsyncError() + } + + for (let plugin of this.plugins) { + let promise = this.runOnRoot(plugin) + if (isPromise(promise)) { + throw this.getAsyncError() + } + } + + this.prepareVisitors() + if (this.hasListener) { + let root = this.result.root + while (!root[isClean]) { + root[isClean] = true + this.walkSync(root) + } + if (this.listeners.OnceExit) { + if (root.type === 'document') { + for (let subRoot of root.nodes) { + this.visitSync(this.listeners.OnceExit, subRoot) + } + } else { + this.visitSync(this.listeners.OnceExit, root) + } + } + } + + return this.result + } + + then(onFulfilled, onRejected) { + if (process.env.NODE_ENV !== 'production') { + if (!('from' in this.opts)) { + warnOnce( + 'Without `from` option PostCSS could generate wrong source map ' + + 'and will not find Browserslist config. Set it to CSS file path ' + + 'or to `undefined` to prevent this warning.' + ) + } + } + return this.async().then(onFulfilled, onRejected) + } + + toString() { + return this.css + } + + visitSync(visitors, node) { + for (let [plugin, visitor] of visitors) { + this.result.lastPlugin = plugin + let promise + try { + promise = visitor(node, this.helpers) + } catch (e) { + throw this.handleError(e, node.proxyOf) + } + if (node.type !== 'root' && node.type !== 'document' && !node.parent) { + return true + } + if (isPromise(promise)) { + throw this.getAsyncError() + } + } + } + + visitTick(stack) { + let visit = stack[stack.length - 1] + let { node, visitors } = visit + + if (node.type !== 'root' && node.type !== 'document' && !node.parent) { + stack.pop() + return + } + + if (visitors.length > 0 && visit.visitorIndex < visitors.length) { + let [plugin, visitor] = visitors[visit.visitorIndex] + visit.visitorIndex += 1 + if (visit.visitorIndex === visitors.length) { + visit.visitors = [] + visit.visitorIndex = 0 + } + this.result.lastPlugin = plugin + try { + return visitor(node.toProxy(), this.helpers) + } catch (e) { + throw this.handleError(e, node) + } + } + + if (visit.iterator !== 0) { + let iterator = visit.iterator + // Advance past the child we just finished visiting. Like + // `Container#each`, the index is incremented only after a child has + // been fully processed, so a node inserted right after the current + // child is not skipped by the `existIndex < index` adjustment in + // `Container#insertAfter()` (which would fire exit events too early). + if (visit.descending) { + visit.descending = false + node.indexes[iterator] += 1 + } + let child + while ((child = node.nodes[node.indexes[iterator]])) { + if (!child[isClean]) { + child[isClean] = true + visit.descending = true + stack.push(toStack(child)) + return + } + node.indexes[iterator] += 1 + } + visit.iterator = 0 + delete node.indexes[iterator] + } + + let events = visit.events + while (visit.eventIndex < events.length) { + let event = events[visit.eventIndex] + visit.eventIndex += 1 + if (event === CHILDREN) { + if (node.nodes && node.nodes.length) { + node[isClean] = true + visit.iterator = node.getIterator() + } + return + } else if (this.listeners[event]) { + visit.visitors = this.listeners[event] + return + } + } + stack.pop() + } + + walkSync(node) { + // An explicit stack like in async `visitTick()` to survive deeply + // nested trees. Unlike `visitTick()`, nodes are marked clean only + // on entering, so a node dirtied by its own visitors is revisited + // on the next pass. + node[isClean] = true + let stack = [{ eventIndex: 0, events: getEvents(node), iterator: 0, node }] + + while (stack.length > 0) { + let visit = stack[stack.length - 1] + let visitNode = visit.node + + if (visit.iterator !== 0) { + let iterator = visit.iterator + // Advance past the child we just finished visiting. Like + // `Container#each`, the index is incremented only after a child has + // been fully processed. Incrementing before (as this loop used to) + // makes a node inserted right after the current child get skipped by + // the `existIndex < index` adjustment in `Container#insertAfter()`, + // which fires exit events before those new siblings are visited. + if (visit.descending) { + visit.descending = false + visitNode.indexes[iterator] += 1 + } + let child + let descended = false + while ((child = visitNode.nodes[visitNode.indexes[iterator]])) { + if (!child[isClean]) { + child[isClean] = true + visit.descending = true + stack.push({ + eventIndex: 0, + events: getEvents(child), + iterator: 0, + node: child + }) + descended = true + break + } + visitNode.indexes[iterator] += 1 + } + if (descended) continue + visit.iterator = 0 + delete visitNode.indexes[iterator] + } + + if (visit.eventIndex < visit.events.length) { + let event = visit.events[visit.eventIndex] + visit.eventIndex += 1 + if (event === CHILDREN) { + if (visitNode.nodes && visitNode.nodes.length) { + visit.iterator = visitNode.getIterator() + } + } else { + let visitors = this.listeners[event] + if (visitors) { + if (this.visitSync(visitors, visitNode.toProxy())) stack.pop() + } + } + continue + } + + stack.pop() + } + } + + warnings() { + return this.sync().warnings() + } +} + +LazyResult.registerPostcss = dependant => { + postcss = dependant +} + +module.exports = LazyResult +LazyResult.default = LazyResult + +Root.registerLazyResult(LazyResult) +Document.registerLazyResult(LazyResult) diff --git a/client/node_modules/postcss/lib/list.d.ts b/client/node_modules/postcss/lib/list.d.ts new file mode 100644 index 0000000..119624e --- /dev/null +++ b/client/node_modules/postcss/lib/list.d.ts @@ -0,0 +1,60 @@ +declare namespace list { + type List = { + /** + * Safely splits comma-separated values (such as those for `transition-*` + * and `background` properties). + * + * ```js + * Once (root, { list }) { + * list.comma('black, linear-gradient(white, black)') + * //=> ['black', 'linear-gradient(white, black)'] + * } + * ``` + * + * @param str Comma-separated values. + * @return Split values. + */ + comma(str: string): string[] + + default: List + + /** + * Safely splits space-separated values (such as those for `background`, + * `border-radius`, and other shorthand properties). + * + * ```js + * Once (root, { list }) { + * list.space('1px calc(10% + 1px)') //=> ['1px', 'calc(10% + 1px)'] + * } + * ``` + * + * @param str Space-separated values. + * @return Split values. + */ + space(str: string): string[] + + /** + * Safely splits values. + * + * ```js + * Once (root, { list }) { + * list.split('1px calc(10% + 1px)', [' ', '\n', '\t']) //=> ['1px', 'calc(10% + 1px)'] + * } + * ``` + * + * @param string separated values. + * @param separators array of separators. + * @param last boolean indicator. + * @return Split values. + */ + split( + string: string, + separators: readonly string[], + last: boolean + ): string[] + } +} + +declare let list: list.List + +export = list diff --git a/client/node_modules/postcss/lib/list.js b/client/node_modules/postcss/lib/list.js new file mode 100644 index 0000000..f1f46ee --- /dev/null +++ b/client/node_modules/postcss/lib/list.js @@ -0,0 +1,59 @@ +'use strict' + +let list = { + comma(string) { + return list.split(string, [','], true) + }, + + space(string) { + let spaces = [' ', '\n', '\t'] + return list.split(string, spaces) + }, + + split(string, separators, last) { + if (!string) return [] + let array = [] + let current = '' + let split = false + + let func = 0 + let inQuote = false + let prevQuote = '' + let escape = false + + for (let letter of string) { + if (escape) { + escape = false + } else if (letter === '\\') { + escape = true + } else if (inQuote) { + if (letter === prevQuote) { + inQuote = false + } + } else if (letter === '"' || letter === "'") { + inQuote = true + prevQuote = letter + } else if (letter === '(') { + func += 1 + } else if (letter === ')') { + if (func > 0) func -= 1 + } else if (func === 0) { + if (separators.includes(letter)) split = true + } + + if (split) { + if (current !== '') array.push(current.trim()) + current = '' + split = false + } else { + current += letter + } + } + + if (last || current !== '') array.push(current.trim()) + return array + } +} + +module.exports = list +list.default = list diff --git a/client/node_modules/postcss/lib/map-generator.js b/client/node_modules/postcss/lib/map-generator.js new file mode 100644 index 0000000..df880ac --- /dev/null +++ b/client/node_modules/postcss/lib/map-generator.js @@ -0,0 +1,376 @@ +'use strict' + +let { dirname, relative, resolve, sep } = require('path') +let { SourceMapConsumer, SourceMapGenerator } = require('source-map-js') +let { pathToFileURL } = require('url') + +let Input = require('./input') + +let sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator) +let pathAvailable = Boolean(dirname && resolve && relative && sep) + +class MapGenerator { + constructor(stringify, root, opts, cssString) { + this.stringify = stringify + this.mapOpts = opts.map || {} + this.root = root + this.opts = opts + this.css = cssString + this.originalCSS = cssString + this.usesFileUrls = !this.mapOpts.from && this.mapOpts.absolute + + this.memoizedFileURLs = new Map() + this.memoizedPaths = new Map() + this.memoizedURLs = new Map() + } + + addAnnotation() { + let content + + if (this.isInline()) { + content = + 'data:application/json;base64,' + this.toBase64(this.map.toString()) + } else if (typeof this.mapOpts.annotation === 'string') { + content = this.mapOpts.annotation + } else if (typeof this.mapOpts.annotation === 'function') { + content = this.mapOpts.annotation(this.opts.to, this.root) + } else { + content = this.outputFile() + '.map' + } + let eol = '\n' + if (this.css.includes('\r\n')) eol = '\r\n' + + this.css += eol + '/*# sourceMappingURL=' + content + ' */' + } + + applyPrevMaps() { + for (let prev of this.previous()) { + let from = this.toUrl(this.path(prev.file)) + let root = prev.root || dirname(prev.file) + let map + + if (this.mapOpts.sourcesContent === false) { + map = new SourceMapConsumer(prev.text) + if (map.sourcesContent) { + map.sourcesContent = null + } + } else { + map = prev.consumer() + } + + this.map.applySourceMap(map, from, this.toUrl(this.path(root))) + } + } + + clearAnnotation() { + if (this.mapOpts.annotation === false) return + + if (this.root) { + let node + for (let i = this.root.nodes.length - 1; i >= 0; i--) { + node = this.root.nodes[i] + if (node.type !== 'comment') continue + if (node.text.startsWith('# sourceMappingURL=')) { + this.root.removeChild(i) + } + } + } else if (this.css) { + let startIndex + while ((startIndex = this.css.lastIndexOf('/*#')) !== -1) { + let endIndex = this.css.indexOf('*/', startIndex + 3) + if (endIndex === -1) break + while (startIndex > 0 && this.css[startIndex - 1] === '\n') { + startIndex-- + } + this.css = this.css.slice(0, startIndex) + this.css.slice(endIndex + 2) + } + } + } + + generate() { + this.clearAnnotation() + if (pathAvailable && sourceMapAvailable && this.isMap()) { + return this.generateMap() + } else { + let result = '' + this.stringify(this.root, i => { + result += i + }) + return [result] + } + } + + generateMap() { + if (this.root) { + this.generateString() + } else if (this.previous().length === 1) { + let prev = this.previous()[0].consumer() + prev.file = this.outputFile() + this.map = SourceMapGenerator.fromSourceMap(prev, { + ignoreInvalidMapping: true + }) + } else { + this.map = new SourceMapGenerator({ + file: this.outputFile(), + ignoreInvalidMapping: true + }) + this.map.addMapping({ + generated: { column: 0, line: 1 }, + original: { column: 0, line: 1 }, + source: this.opts.from + ? this.toUrl(this.path(this.opts.from)) + : '' + }) + } + + if (this.isSourcesContent()) this.setSourcesContent() + if (this.root && this.previous().length > 0) this.applyPrevMaps() + if (this.isAnnotation()) this.addAnnotation() + + if (this.isInline()) { + return [this.css] + } else { + return [this.css, this.map] + } + } + + generateString() { + this.css = '' + this.map = new SourceMapGenerator({ + file: this.outputFile(), + ignoreInvalidMapping: true + }) + + let line = 1 + let column = 1 + + let noSource = '' + let mapping = { + generated: { column: 0, line: 0 }, + original: { column: 0, line: 0 }, + source: '' + } + + let last, lines + this.stringify(this.root, (str, node, type) => { + this.css += str + + if (node && type !== 'end') { + mapping.generated.line = line + mapping.generated.column = column - 1 + if (node.source && node.source.start) { + mapping.source = this.sourcePath(node) + mapping.original.line = node.source.start.line + mapping.original.column = node.source.start.column - 1 + this.map.addMapping(mapping) + } else { + mapping.source = noSource + mapping.original.line = 1 + mapping.original.column = 0 + this.map.addMapping(mapping) + } + } + + lines = str.match(/\n/g) + if (lines) { + line += lines.length + last = str.lastIndexOf('\n') + column = str.length - last + } else { + column += str.length + } + + if (node && type !== 'start') { + let p = node.parent || { raws: {} } + let childless = + node.type === 'decl' || (node.type === 'atrule' && !node.nodes) + if (!childless || node !== p.last || p.raws.semicolon) { + if (node.source && node.source.end) { + mapping.source = this.sourcePath(node) + mapping.original.line = node.source.end.line + mapping.original.column = node.source.end.column - 1 + mapping.generated.line = line + mapping.generated.column = column - 2 + this.map.addMapping(mapping) + } else { + mapping.source = noSource + mapping.original.line = 1 + mapping.original.column = 0 + mapping.generated.line = line + mapping.generated.column = column - 1 + this.map.addMapping(mapping) + } + } + } + }) + } + + isAnnotation() { + if (this.isInline()) { + return true + } + if (typeof this.mapOpts.annotation !== 'undefined') { + return this.mapOpts.annotation + } + if (this.previous().length) { + return this.previous().some(i => i.annotation) + } + return true + } + + isInline() { + if (typeof this.mapOpts.inline !== 'undefined') { + return this.mapOpts.inline + } + + let annotation = this.mapOpts.annotation + if (typeof annotation !== 'undefined' && annotation !== true) { + return false + } + + if (this.previous().length) { + return this.previous().some(i => i.inline) + } + return true + } + + isMap() { + if (typeof this.opts.map !== 'undefined') { + return !!this.opts.map + } + return this.previous().length > 0 + } + + isSourcesContent() { + if (typeof this.mapOpts.sourcesContent !== 'undefined') { + return this.mapOpts.sourcesContent + } + if (this.previous().length) { + return this.previous().some(i => i.withContent()) + } + return true + } + + outputFile() { + if (this.opts.to) { + return this.path(this.opts.to) + } else if (this.opts.from) { + return this.path(this.opts.from) + } else { + return 'to.css' + } + } + + path(file) { + if (this.mapOpts.absolute) return file + if (file.charCodeAt(0) === 60 /* `<` */) return file + if (/^\w+:\/\//.test(file)) return file + let cached = this.memoizedPaths.get(file) + if (cached) return cached + + let from = this.opts.to ? dirname(this.opts.to) : '.' + + if (typeof this.mapOpts.annotation === 'string') { + from = dirname(resolve(from, this.mapOpts.annotation)) + } + + let path = relative(from, file) + this.memoizedPaths.set(file, path) + + return path + } + + previous() { + if (!this.previousMaps) { + this.previousMaps = [] + if (this.root) { + this.root.walk(node => { + if (node.source && node.source.input.map) { + let map = node.source.input.map + if (!this.previousMaps.includes(map)) { + this.previousMaps.push(map) + } + } + }) + } else { + let input = new Input(this.originalCSS, this.opts) + if (input.map) this.previousMaps.push(input.map) + } + } + + return this.previousMaps + } + + setSourcesContent() { + let already = {} + if (this.root) { + this.root.walk(node => { + if (node.source) { + let from = node.source.input.from + if (from && !already[from]) { + already[from] = true + let fromUrl = this.usesFileUrls + ? this.toFileUrl(from) + : this.toUrl(this.path(from)) + this.map.setSourceContent(fromUrl, node.source.input.css) + } + } + }) + } else if (this.css) { + let from = this.opts.from + ? this.toUrl(this.path(this.opts.from)) + : '' + this.map.setSourceContent(from, this.css) + } + } + + sourcePath(node) { + if (this.mapOpts.from) { + return this.toUrl(this.mapOpts.from) + } else if (this.usesFileUrls) { + return this.toFileUrl(node.source.input.from) + } else { + return this.toUrl(this.path(node.source.input.from)) + } + } + + toBase64(str) { + if (Buffer) { + return Buffer.from(str).toString('base64') + } else { + return window.btoa(unescape(encodeURIComponent(str))) + } + } + + toFileUrl(path) { + let cached = this.memoizedFileURLs.get(path) + if (cached) return cached + + if (pathToFileURL) { + let fileURL = pathToFileURL(path).toString() + this.memoizedFileURLs.set(path, fileURL) + + return fileURL + } else { + throw new Error( + '`map.absolute` option is not available in this PostCSS build' + ) + } + } + + toUrl(path) { + let cached = this.memoizedURLs.get(path) + if (cached) return cached + + if (sep === '\\') { + path = path.replace(/\\/g, '/') + } + + let url = encodeURI(path).replace(/[#?]/g, encodeURIComponent) + this.memoizedURLs.set(path, url) + + return url + } +} + +module.exports = MapGenerator diff --git a/client/node_modules/postcss/lib/no-work-result.d.ts b/client/node_modules/postcss/lib/no-work-result.d.ts new file mode 100644 index 0000000..fa9d284 --- /dev/null +++ b/client/node_modules/postcss/lib/no-work-result.d.ts @@ -0,0 +1,45 @@ +import LazyResult from './lazy-result.js' +import { SourceMap } from './postcss.js' +import Processor from './processor.js' +import Result, { Message, ResultOptions } from './result.js' +import Root from './root.js' +import Warning from './warning.js' + +declare namespace NoWorkResult { + export { NoWorkResult_ as default } +} + +/** + * A Promise proxy for the result of PostCSS transformations. + * This lazy result instance doesn't parse css unless `NoWorkResult#root` or `Result#root` + * are accessed. See the example below for details. + * A `NoWork` instance is returned by `Processor#process` ONLY when no plugins defined. + * + * ```js + * const noWorkResult = postcss().process(css) // No plugins are defined. + * // CSS is not parsed + * let root = noWorkResult.root // now css is parsed because we accessed the root + * ``` + */ +declare class NoWorkResult_ implements LazyResult { + catch: Promise>['catch'] + finally: Promise>['finally'] + then: Promise>['then'] + get content(): string + get css(): string + get map(): SourceMap + get messages(): Message[] + get opts(): ResultOptions + get processor(): Processor + get root(): Root + get [Symbol.toStringTag](): string + constructor(processor: Processor, css: string, opts: ResultOptions) + async(): Promise> + sync(): Result + toString(): string + warnings(): Warning[] +} + +declare class NoWorkResult extends NoWorkResult_ {} + +export = NoWorkResult diff --git a/client/node_modules/postcss/lib/no-work-result.js b/client/node_modules/postcss/lib/no-work-result.js new file mode 100644 index 0000000..7ec1a74 --- /dev/null +++ b/client/node_modules/postcss/lib/no-work-result.js @@ -0,0 +1,137 @@ +'use strict' + +let MapGenerator = require('./map-generator') +let parse = require('./parse') +let Result = require('./result') +let stringify = require('./stringify') +let warnOnce = require('./warn-once') + +class NoWorkResult { + get content() { + return this.result.css + } + + get css() { + return this.result.css + } + + get map() { + return this.result.map + } + + get messages() { + return [] + } + + get opts() { + return this.result.opts + } + + get processor() { + return this.result.processor + } + + get root() { + if (this._root) { + return this._root + } + + let root + let parser = parse + + try { + root = parser(this._css, this._opts) + } catch (error) { + this.error = error + } + + if (this.error) { + throw this.error + } else { + this._root = root + return root + } + } + + get [Symbol.toStringTag]() { + return 'NoWorkResult' + } + + constructor(processor, css, opts) { + css = css.toString() + this.stringified = false + + this._processor = processor + this._css = css + this._opts = opts + this._map = undefined + + let str = stringify + this.result = new Result(this._processor, undefined, this._opts) + this.result.css = css + + let self = this + Object.defineProperty(this.result, 'root', { + get() { + return self.root + } + }) + + let map = new MapGenerator(str, undefined, this._opts, css) + if (map.isMap()) { + let [generatedCSS, generatedMap] = map.generate() + if (generatedCSS) { + this.result.css = generatedCSS + } + if (generatedMap) { + this.result.map = generatedMap + } + } else { + map.clearAnnotation() + this.result.css = map.css + } + } + + async() { + if (this.error) return Promise.reject(this.error) + return Promise.resolve(this.result) + } + + catch(onRejected) { + return this.async().catch(onRejected) + } + + finally(onFinally) { + return this.async().then(onFinally, onFinally) + } + + sync() { + if (this.error) throw this.error + return this.result + } + + then(onFulfilled, onRejected) { + if (process.env.NODE_ENV !== 'production') { + if (!('from' in this._opts)) { + warnOnce( + 'Without `from` option PostCSS could generate wrong source map ' + + 'and will not find Browserslist config. Set it to CSS file path ' + + 'or to `undefined` to prevent this warning.' + ) + } + } + + return this.async().then(onFulfilled, onRejected) + } + + toString() { + return this._css + } + + warnings() { + return [] + } +} + +module.exports = NoWorkResult +NoWorkResult.default = NoWorkResult diff --git a/client/node_modules/postcss/lib/node.d.ts b/client/node_modules/postcss/lib/node.d.ts new file mode 100644 index 0000000..e93ce5b --- /dev/null +++ b/client/node_modules/postcss/lib/node.d.ts @@ -0,0 +1,555 @@ +import AtRule = require('./at-rule.js') +import { AtRuleProps } from './at-rule.js' +import Comment, { CommentProps } from './comment.js' +import Container, { NewChild } from './container.js' +import CssSyntaxError from './css-syntax-error.js' +import Declaration, { DeclarationProps } from './declaration.js' +import Document from './document.js' +import Input from './input.js' +import { Stringifier, Syntax } from './postcss.js' +import Result from './result.js' +import Root from './root.js' +import Rule, { RuleProps } from './rule.js' +import Warning, { WarningOptions } from './warning.js' + +declare namespace Node { + export type ChildNode = AtRule.default | Comment | Declaration | Rule + + export type AnyNode = + | AtRule.default + | Comment + | Declaration + | Document + | Root + | Rule + + export type ChildProps = + | AtRuleProps + | CommentProps + | DeclarationProps + | RuleProps + + export interface Position { + /** + * Source column in file. It starts from 1. + */ + column: number + + /** + * Source line in file. It starts from 1. + */ + line: number + + /** + * Source offset in file. It starts from 0. + */ + offset: number + } + + export interface Range { + /** + * End position, exclusive. + */ + end: Position + + /** + * Start position, inclusive. + */ + start: Position + } + + /** + * Source represents an interface for the {@link Node.source} property. + */ + export interface Source { + /** + * The inclusive ending position for the source + * code of a node. + * + * However, `end.offset` of a non `Root` node is the exclusive position. + * See https://github.com/postcss/postcss/pull/1879 for details. + * + * ```js + * const root = postcss.parse('a { color: black }') + * const a = root.first + * const color = a.first + * + * // The offset of `Root` node is the inclusive position + * css.source.end // { line: 1, column: 19, offset: 18 } + * + * // The offset of non `Root` node is the exclusive position + * a.source.end // { line: 1, column: 18, offset: 18 } + * color.source.end // { line: 1, column: 16, offset: 16 } + * ``` + */ + end?: Position + + /** + * The source file from where a node has originated. + */ + input: Input + + /** + * The inclusive starting position for the source + * code of a node. + */ + start?: Position + } + + /** + * Interface represents an interface for an object received + * as parameter by Node class constructor. + */ + export interface NodeProps { + source?: Source + } + + export interface NodeErrorOptions { + /** + * An ending index inside a node's string that should be highlighted as + * source of error. + */ + endIndex?: number + /** + * An index inside a node's string that should be highlighted as source + * of error. + */ + index?: number + /** + * Plugin name that created this error. PostCSS will set it automatically. + */ + plugin?: string + /** + * A word inside a node's string, that should be highlighted as source + * of error. + */ + word?: string + } + + class Node extends Node_ {} + export { Node as default } +} + +/** + * It represents an abstract class that handles common + * methods for other CSS abstract syntax tree nodes. + * + * Any node that represents CSS selector or value should + * not extend the `Node` class. + */ +declare abstract class Node_ { + /** + * It represents parent of the current node. + * + * ```js + * root.nodes[0].parent === root //=> true + * ``` + */ + parent: Container | Document | undefined + + /** + * It represents unnecessary whitespace and characters present + * in the css source code. + * + * Information to generate byte-to-byte equal node string as it was + * in the origin input. + * + * The properties of the raws object are decided by parser, + * the default parser uses the following properties: + * + * * `before`: the space symbols before the node. It also stores `*` + * and `_` symbols before the declaration (IE hack). + * * `after`: the space symbols after the last child of the node + * to the end of the node. + * * `between`: the symbols between the property and value + * for declarations, selector and `{` for rules, or last parameter + * and `{` for at-rules. + * * `semicolon`: contains true if the last child has + * an (optional) semicolon. + * * `afterName`: the space between the at-rule name and its parameters. + * * `left`: the space symbols between `/*` and the comment’s text. + * * `right`: the space symbols between the comment’s text + * and */. + * - `important`: the content of the important statement, + * if it is not just `!important`. + * + * PostCSS filters out the comments inside selectors, declaration values + * and at-rule parameters but it stores the origin content in raws. + * + * ```js + * const root = postcss.parse('a {\n color:black\n}') + * root.first.first.raws //=> { before: '\n ', between: ':' } + * ``` + */ + raws: any + + /** + * It represents information related to origin of a node and is required + * for generating source maps. + * + * The nodes that are created manually using the public APIs + * provided by PostCSS will have `source` undefined and + * will be absent in the source map. + * + * For this reason, the plugin developer should consider + * duplicating nodes as the duplicate node will have the + * same source as the original node by default or assign + * source to a node created manually. + * + * ```js + * decl.source.input.from //=> '/home/ai/source.css' + * decl.source.start //=> { line: 10, column: 2 } + * decl.source.end //=> { line: 10, column: 12 } + * ``` + * + * ```js + * // Incorrect method, source not specified! + * const prefixed = postcss.decl({ + * prop: '-moz-' + decl.prop, + * value: decl.value + * }) + * + * // Correct method, source is inherited when duplicating. + * const prefixed = decl.clone({ + * prop: '-moz-' + decl.prop + * }) + * ``` + * + * ```js + * if (atrule.name === 'add-link') { + * const rule = postcss.rule({ + * selector: 'a', + * source: atrule.source + * }) + * + * atrule.parent.insertBefore(atrule, rule) + * } + * ``` + */ + source?: Node.Source + + /** + * It represents type of a node in + * an abstract syntax tree. + * + * A type of node helps in identification of a node + * and perform operation based on it's type. + * + * ```js + * const declaration = new Declaration({ + * prop: 'color', + * value: 'black' + * }) + * + * declaration.type //=> 'decl' + * ``` + */ + type: string + + constructor(defaults?: object) + + /** + * Insert new node after current node to current node’s parent. + * + * Just alias for `node.parent.insertAfter(node, add)`. + * + * ```js + * decl.after('color: black') + * ``` + * + * @param newNode New node. + * @return This node for methods chain. + */ + after( + newNode: Node | Node.ChildProps | readonly Node[] | string | undefined + ): this + + /** + * It assigns properties to an existing node instance. + * + * ```js + * decl.assign({ prop: 'word-wrap', value: 'break-word' }) + * ``` + * + * @param overrides New properties to override the node. + * + * @return `this` for method chaining. + */ + assign(overrides: object): this + + /** + * Insert new node before current node to current node’s parent. + * + * Just alias for `node.parent.insertBefore(node, add)`. + * + * ```js + * decl.before('content: ""') + * ``` + * + * @param newNode New node. + * @return This node for methods chain. + */ + before( + newNode: Node | Node.ChildProps | readonly Node[] | string | undefined + ): this + + /** + * Clear the code style properties for the node and its children. + * + * ```js + * node.raws.before //=> ' ' + * node.cleanRaws() + * node.raws.before //=> undefined + * ``` + * + * @param keepBetween Keep the `raws.between` symbols. + */ + cleanRaws(keepBetween?: boolean): void + + /** + * It creates clone of an existing node, which includes all the properties + * and their values, that includes `raws` but not `type`. + * + * ```js + * decl.raws.before //=> "\n " + * const cloned = decl.clone({ prop: '-moz-' + decl.prop }) + * cloned.raws.before //=> "\n " + * cloned.toString() //=> -moz-transform: scale(0) + * ``` + * + * @param overrides New properties to override in the clone. + * + * @return Duplicate of the node instance. + */ + clone(overrides?: object): this + + /** + * Shortcut to clone the node and insert the resulting cloned node + * after the current node. + * + * @param overrides New properties to override in the clone. + * @return New node. + */ + cloneAfter(overrides?: object): this + + /** + * Shortcut to clone the node and insert the resulting cloned node + * before the current node. + * + * ```js + * decl.cloneBefore({ prop: '-moz-' + decl.prop }) + * ``` + * + * @param overrides Mew properties to override in the clone. + * + * @return New node + */ + cloneBefore(overrides?: object): this + + /** + * It creates an instance of the class `CssSyntaxError` and parameters passed + * to this method are assigned to the error instance. + * + * The error instance will have description for the + * error, original position of the node in the + * source, showing line and column number. + * + * If any previous map is present, it would be used + * to get original position of the source. + * + * The Previous Map here is referred to the source map + * generated by previous compilation, example: Less, + * Stylus and Sass. + * + * This method returns the error instance instead of + * throwing it. + * + * ```js + * if (!variables[name]) { + * throw decl.error(`Unknown variable ${name}`, { word: name }) + * // CssSyntaxError: postcss-vars:a.sass:4:3: Unknown variable $black + * // color: $black + * // a + * // ^ + * // background: white + * } + * ``` + * + * @param message Description for the error instance. + * @param options Options for the error instance. + * + * @return Error instance is returned. + */ + error(message: string, options?: Node.NodeErrorOptions): CssSyntaxError + + /** + * Returns the next child of the node’s parent. + * Returns `undefined` if the current node is the last child. + * + * ```js + * if (comment.text === 'delete next') { + * const next = comment.next() + * if (next) { + * next.remove() + * } + * } + * ``` + * + * @return Next node. + */ + next(): Node.ChildNode | undefined + + /** + * Get the position for a word or an index inside the node. + * + * @param opts Options. + * @return Position. + */ + positionBy(opts?: Pick): Node.Position + + /** + * Convert string index to line/column. + * + * @param index The symbol number in the node’s string. + * @return Symbol position in file. + */ + positionInside(index: number): Node.Position + + /** + * Returns the previous child of the node’s parent. + * Returns `undefined` if the current node is the first child. + * + * ```js + * const annotation = decl.prev() + * if (annotation.type === 'comment') { + * readAnnotation(annotation.text) + * } + * ``` + * + * @return Previous node. + */ + prev(): Node.ChildNode | undefined + + /** + * Get the range for a word or start and end index inside the node. + * The start index is inclusive; the end index is exclusive. + * + * @param opts Options. + * @return Range. + */ + rangeBy( + opts?: Pick + ): Node.Range + + /** + * Returns a `raws` value. If the node is missing + * the code style property (because the node was manually built or cloned), + * PostCSS will try to autodetect the code style property by looking + * at other nodes in the tree. + * + * ```js + * const root = postcss.parse('a { background: white }') + * root.nodes[0].append({ prop: 'color', value: 'black' }) + * root.nodes[0].nodes[1].raws.before //=> undefined + * root.nodes[0].nodes[1].raw('before') //=> ' ' + * ``` + * + * @param prop Name of code style property. + * @param defaultType Name of default value, it can be missed + * if the value is the same as prop. + * @return {string} Code style value. + */ + raw(prop: string, defaultType?: string): string + + /** + * It removes the node from its parent and deletes its parent property. + * + * ```js + * if (decl.prop.match(/^-webkit-/)) { + * decl.remove() + * } + * ``` + * + * @return `this` for method chaining. + */ + remove(): this + + /** + * Inserts node(s) before the current node and removes the current node. + * + * ```js + * AtRule: { + * mixin: atrule => { + * atrule.replaceWith(mixinRules[atrule.params]) + * } + * } + * ``` + * + * @param nodes Mode(s) to replace current one. + * @return Current node to methods chain. + */ + replaceWith(...nodes: NewChild[]): this + + /** + * Finds the Root instance of the node’s tree. + * + * ```js + * root.nodes[0].nodes[0].root() === root + * ``` + * + * @return Root parent. + */ + root(): Root + + /** + * Fix circular links on `JSON.stringify()`. + * + * @return Cleaned object. + */ + toJSON(): object + + /** + * It compiles the node to browser readable cascading style sheets string + * depending on it's type. + * + * ```js + * new Rule({ selector: 'a' }).toString() //=> "a {}" + * ``` + * + * @param stringifier A syntax to use in string generation. + * @return CSS string of this node. + */ + toString(stringifier?: Stringifier | Syntax): string + + /** + * It is a wrapper for {@link Result#warn}, providing convenient + * way of generating warnings. + * + * ```js + * Declaration: { + * bad: (decl, { result }) => { + * decl.warn(result, 'Deprecated property: bad') + * } + * } + * ``` + * + * @param result The `Result` instance that will receive the warning. + * @param message Description for the warning. + * @param options Options for the warning. + * + * @return `Warning` instance is returned + */ + warn(result: Result, message: string, options?: WarningOptions): Warning + + /** + * If this node isn't already dirty, marks it and its ancestors as such. This + * indicates to the LazyResult processor that the {@link Root} has been + * modified by the current plugin and may need to be processed again by other + * plugins. + */ + protected markDirty(): void +} + +declare class Node extends Node_ {} + +export = Node diff --git a/client/node_modules/postcss/lib/node.js b/client/node_modules/postcss/lib/node.js new file mode 100644 index 0000000..a298d36 --- /dev/null +++ b/client/node_modules/postcss/lib/node.js @@ -0,0 +1,494 @@ +'use strict' + +let CssSyntaxError = require('./css-syntax-error') +let Stringifier = require('./stringifier') +let stringify = require('./stringify') +let { isClean, my } = require('./symbols') + +function cloneNode(obj, parent) { + let cloned = new obj.constructor() + // An explicit stack instead of recursive calls to survive deeply + // nested trees. Each entry is [source, its clone, clone's parent]. + let stack = [[obj, cloned, parent]] + + while (stack.length > 0) { + let [source, target, targetParent] = stack.pop() + for (let i in source) { + if (!Object.prototype.hasOwnProperty.call(source, i)) { + /* c8 ignore next 2 */ + continue + } + if (i === 'proxyCache') continue + let value = source[i] + let type = typeof value + + if (i === 'parent' && type === 'object') { + if (targetParent) target[i] = targetParent + } else if (i === 'source') { + target[i] = value + } else if (Array.isArray(value)) { + let children = [] + target[i] = children + for (let j of value) { + let childClone = new j.constructor() + children.push(childClone) + stack.push([j, childClone, target]) + } + } else { + if (type === 'object' && value !== null) { + let valueClone = new value.constructor() + stack.push([value, valueClone, undefined]) + value = valueClone + } + target[i] = value + } + } + } + + return cloned +} + +function sourceOffset(inputCSS, position) { + // Not all custom syntaxes support `offset` in `source.start` and `source.end` + if (position && typeof position.offset !== 'undefined') { + return position.offset + } + + let column = 1 + let line = 1 + let offset = 0 + + for (let i = 0; i < inputCSS.length; i++) { + if (line === position.line && column === position.column) { + offset = i + break + } + + if (inputCSS[i] === '\n') { + column = 1 + line += 1 + } else { + column += 1 + } + } + + return offset +} + +class Node { + get proxyOf() { + return this + } + + constructor(defaults = {}) { + this.raws = {} + this[isClean] = false + this[my] = true + + for (let name of Object.keys(defaults)) { + if (name === '__proto__') continue + if (name === 'nodes') { + this.nodes = [] + for (let node of defaults[name]) { + // Clone only nodes that already belong to another tree, so passing a + // freshly created (parent-less) node adopts that instance instead of + // a copy and keeps the caller's reference usable. See #1987. + if (typeof node.clone === 'function' && node.parent) { + this.append(node.clone()) + } else { + this.append(node) + } + } + } else { + this[name] = defaults[name] + } + } + } + + addToError(error) { + error.postcssNode = this + if (error.stack && this.source && /\n\s{4}at /.test(error.stack)) { + let s = this.source + error.stack = error.stack.replace( + /\n\s{4}at /, + `$&${s.input.from}:${s.start.line}:${s.start.column}$&` + ) + } + return error + } + + after(add) { + this.parent.insertAfter(this, add) + return this + } + + assign(overrides = {}) { + for (let name in overrides) { + this[name] = overrides[name] + } + return this + } + + before(add) { + this.parent.insertBefore(this, add) + return this + } + + cleanRaws(keepBetween) { + delete this.raws.before + delete this.raws.after + if (!keepBetween) delete this.raws.between + } + + clone(overrides = {}) { + let cloned = cloneNode(this) + for (let name in overrides) { + cloned[name] = overrides[name] + } + return cloned + } + + cloneAfter(overrides = {}) { + let cloned = this.clone(overrides) + this.parent.insertAfter(this, cloned) + return cloned + } + + cloneBefore(overrides = {}) { + let cloned = this.clone(overrides) + this.parent.insertBefore(this, cloned) + return cloned + } + + error(message, opts = {}) { + if (this.source) { + let { end, start } = this.rangeBy(opts) + return this.source.input.error( + message, + { column: start.column, line: start.line }, + { column: end.column, line: end.line }, + opts + ) + } + return new CssSyntaxError(message) + } + + getProxyProcessor() { + return { + get(node, prop) { + if (prop === 'proxyOf') { + return node + } else if (prop === 'root') { + return () => node.root().toProxy() + } else { + return node[prop] + } + }, + + set(node, prop, value) { + if (node[prop] === value) return true + node[prop] = value + if ( + prop === 'prop' || + prop === 'value' || + prop === 'name' || + prop === 'params' || + prop === 'important' || + /* c8 ignore next */ + prop === 'text' + ) { + node.markDirty() + } + return true + } + } + } + + /* c8 ignore next 3 */ + markClean() { + this[isClean] = true + } + + markDirty() { + if (this[isClean]) { + this[isClean] = false + let next = this + while ((next = next.parent)) { + next[isClean] = false + } + } + } + + next() { + if (!this.parent) return undefined + let index = this.parent.index(this) + return this.parent.nodes[index + 1] + } + + positionBy(opts = {}) { + let inputString = + 'document' in this.source.input + ? this.source.input.document + : this.source.input.css + let pos = { + column: this.source.start.column, + line: this.source.start.line, + offset: sourceOffset(inputString, this.source.start) + } + if (opts.index) { + pos = this.positionInside(opts.index) + } else if (opts.word) { + let stringRepresentation = inputString.slice( + sourceOffset(inputString, this.source.start), + sourceOffset(inputString, this.source.end) + ) + let index = stringRepresentation.indexOf(opts.word) + if (index !== -1) pos = this.positionInside(index) + } + return pos + } + + positionInside(index) { + let column = this.source.start.column + let line = this.source.start.line + let inputString = + 'document' in this.source.input + ? this.source.input.document + : this.source.input.css + let offset = sourceOffset(inputString, this.source.start) + let end = offset + index + + for (let i = offset; i < end; i++) { + if (inputString[i] === '\n') { + column = 1 + line += 1 + } else { + column += 1 + } + } + + return { column, line, offset: end } + } + + prev() { + if (!this.parent) return undefined + let index = this.parent.index(this) + return this.parent.nodes[index - 1] + } + + rangeBy(opts = {}) { + let inputString = + 'document' in this.source.input + ? this.source.input.document + : this.source.input.css + let start = { + column: this.source.start.column, + line: this.source.start.line, + offset: sourceOffset(inputString, this.source.start) + } + let end = this.source.end + ? { + column: this.source.end.column + 1, + line: this.source.end.line, + offset: + typeof this.source.end.offset === 'number' + ? // `source.end.offset` is exclusive, so we don't need to add 1 + this.source.end.offset + : // Since line/column in this.source.end is inclusive, + // the `sourceOffset(... , this.source.end)` returns an inclusive offset. + // So, we add 1 to convert it to exclusive. + sourceOffset(inputString, this.source.end) + 1 + } + : { + column: start.column + 1, + line: start.line, + offset: start.offset + 1 + } + + if (opts.word) { + let stringRepresentation = inputString.slice( + sourceOffset(inputString, this.source.start), + sourceOffset(inputString, this.source.end) + ) + let index = stringRepresentation.indexOf(opts.word) + if (index !== -1) { + start = this.positionInside(index) + end = this.positionInside(index + opts.word.length) + } + } else { + if (opts.start) { + start = { + column: opts.start.column, + line: opts.start.line, + offset: sourceOffset(inputString, opts.start) + } + } else if (typeof opts.index === 'number') { + start = this.positionInside(opts.index) + } + + if (opts.end) { + end = { + column: opts.end.column, + line: opts.end.line, + offset: sourceOffset(inputString, opts.end) + } + } else if (typeof opts.endIndex === 'number') { + end = this.positionInside(opts.endIndex) + } else if (typeof opts.index === 'number') { + end = this.positionInside(opts.index + 1) + } + } + + if ( + end.line < start.line || + (end.line === start.line && end.column <= start.column) + ) { + end = { + column: start.column + 1, + line: start.line, + offset: start.offset + 1 + } + } + + return { end, start } + } + + raw(prop, defaultType) { + let str = new Stringifier() + return str.raw(this, prop, defaultType) + } + + remove() { + if (this.parent) { + this.parent.removeChild(this) + } + this.parent = undefined + return this + } + + replaceWith(...nodes) { + if (this.parent) { + let bookmark = this + let foundSelf = false + for (let node of nodes) { + if (node === this) { + foundSelf = true + } else if (foundSelf) { + this.parent.insertAfter(bookmark, node) + bookmark = node + } else { + this.parent.insertBefore(bookmark, node) + } + } + + if (!foundSelf) { + this.remove() + } + } + + return this + } + + root() { + let result = this + while (result.parent && result.parent.type !== 'document') { + result = result.parent + } + return result + } + + toJSON(_, inputs) { + let emitInputs = inputs == null + inputs = inputs || new Map() + + // A worklist instead of recursive `toJSON()` calls to survive deeply + // nested trees. Each entry converts one node and writes the result + // into the already converted parent by [holder, key]. + let holderOfRoot = [] + let queue = [[this, holderOfRoot, 0]] + + for (let step = 0; step < queue.length; step++) { + let [node, holder, key] = queue[step] + let fixed = {} + holder[key] = fixed + + for (let name in node) { + if (!Object.prototype.hasOwnProperty.call(node, name)) { + /* c8 ignore next 2 */ + continue + } + if (name === 'parent' || name === 'proxyCache') continue + let value = node[name] + + if (Array.isArray(value)) { + let fixedArray = [] + fixed[name] = fixedArray + for (let i = 0; i < value.length; i++) { + let item = value[i] + if (typeof item === 'object' && item.toJSON) { + if (item.toJSON === Node.prototype.toJSON) { + queue.push([item, fixedArray, i]) + } else { + fixedArray[i] = item.toJSON(null, inputs) + } + } else { + fixedArray[i] = item + } + } + } else if (typeof value === 'object' && value.toJSON) { + if (value.toJSON === Node.prototype.toJSON) { + queue.push([value, fixed, name]) + } else { + fixed[name] = value.toJSON(null, inputs) + } + } else if (name === 'source') { + if (value == null) continue + let inputId = inputs.get(value.input) + if (inputId == null) { + inputId = inputs.size + inputs.set(value.input, inputId) + } + fixed[name] = { + end: value.end, + inputId, + start: value.start + } + } else { + fixed[name] = value + } + } + } + + let fixed = holderOfRoot[0] + if (emitInputs) { + fixed.inputs = [...inputs.keys()].map(input => input.toJSON()) + } + + return fixed + } + + toProxy() { + if (!this.proxyCache) { + this.proxyCache = new Proxy(this, this.getProxyProcessor()) + } + return this.proxyCache + } + + toString(stringifier = stringify) { + if (stringifier.stringify) stringifier = stringifier.stringify + let result = '' + stringifier(this, i => { + result += i + }) + return result + } + + warn(result, text, opts = {}) { + let data = { node: this } + for (let i in opts) data[i] = opts[i] + return result.warn(text, data) + } +} + +module.exports = Node +Node.default = Node diff --git a/client/node_modules/postcss/lib/parse.d.ts b/client/node_modules/postcss/lib/parse.d.ts new file mode 100644 index 0000000..ffe35b4 --- /dev/null +++ b/client/node_modules/postcss/lib/parse.d.ts @@ -0,0 +1,9 @@ +import { Parser } from './postcss.js' + +interface Parse extends Parser { + default: Parse +} + +declare let parse: Parse + +export = parse diff --git a/client/node_modules/postcss/lib/parse.js b/client/node_modules/postcss/lib/parse.js new file mode 100644 index 0000000..00a1037 --- /dev/null +++ b/client/node_modules/postcss/lib/parse.js @@ -0,0 +1,42 @@ +'use strict' + +let Container = require('./container') +let Input = require('./input') +let Parser = require('./parser') + +function parse(css, opts) { + let input = new Input(css, opts) + let parser = new Parser(input) + try { + parser.parse() + } catch (e) { + if (process.env.NODE_ENV !== 'production') { + if (e.name === 'CssSyntaxError' && opts && opts.from) { + if (/\.scss$/i.test(opts.from)) { + e.message += + '\nYou tried to parse SCSS with ' + + 'the standard CSS parser; ' + + 'try again with the postcss-scss parser' + } else if (/\.sass/i.test(opts.from)) { + e.message += + '\nYou tried to parse Sass with ' + + 'the standard CSS parser; ' + + 'try again with the postcss-sass parser' + } else if (/\.less$/i.test(opts.from)) { + e.message += + '\nYou tried to parse Less with ' + + 'the standard CSS parser; ' + + 'try again with the postcss-less parser' + } + } + } + throw e + } + + return parser.root +} + +module.exports = parse +parse.default = parse + +Container.registerParse(parse) diff --git a/client/node_modules/postcss/lib/parser.js b/client/node_modules/postcss/lib/parser.js new file mode 100644 index 0000000..2a16584 --- /dev/null +++ b/client/node_modules/postcss/lib/parser.js @@ -0,0 +1,618 @@ +'use strict' + +let AtRule = require('./at-rule') +let Comment = require('./comment') +let Declaration = require('./declaration') +let Root = require('./root') +let Rule = require('./rule') +let tokenizer = require('./tokenize') + +const SAFE_COMMENT_NEIGHBOR = { + empty: true, + space: true +} + +function findLastWithPosition(tokens) { + for (let i = tokens.length - 1; i >= 0; i--) { + let token = tokens[i] + let pos = token[3] || token[2] + if (pos) return pos + } +} + +function tokensToString(tokens, from, to) { + let result = '' + for (let i = from; i < to; i++) result += tokens[i][1] + return result +} + +class Parser { + constructor(input) { + this.input = input + + this.root = new Root() + this.current = this.root + this.spaces = '' + this.semicolon = false + + this.createTokenizer() + this.root.source = { input, start: { column: 1, line: 1, offset: 0 } } + } + + atrule(token) { + let node = new AtRule() + node.name = token[1].slice(1) + if (node.name === '') { + this.unnamedAtrule(node, token) + } + this.init(node, token[2]) + + let type + let prev + let shift + let last = false + let open = false + let params = [] + let brackets = [] + + while (!this.tokenizer.endOfFile()) { + token = this.tokenizer.nextToken() + type = token[0] + + if (type === '(' || type === '[') { + brackets.push(type === '(' ? ')' : ']') + } else if (type === '{' && brackets.length > 0) { + brackets.push('}') + } else if (type === brackets[brackets.length - 1]) { + brackets.pop() + } + + if (brackets.length === 0) { + if (type === ';') { + node.source.end = this.getPosition(token[2]) + node.source.end.offset++ + this.semicolon = true + break + } else if (type === '{') { + open = true + break + } else if (type === '}') { + if (params.length > 0) { + shift = params.length - 1 + prev = params[shift] + while (prev && prev[0] === 'space') { + prev = params[--shift] + } + if (prev) { + node.source.end = this.getPosition(prev[3] || prev[2]) + node.source.end.offset++ + } + } + this.end(token) + break + } else { + params.push(token) + } + } else { + params.push(token) + } + + if (this.tokenizer.endOfFile()) { + last = true + break + } + } + + node.raws.between = this.spacesAndCommentsFromEnd(params) + if (params.length) { + node.raws.afterName = this.spacesAndCommentsFromStart(params) + this.raw(node, 'params', params) + if (last) { + token = params[params.length - 1] + node.source.end = this.getPosition(token[3] || token[2]) + node.source.end.offset++ + this.spaces = node.raws.between + node.raws.between = '' + } + } else { + node.raws.afterName = '' + node.params = '' + } + + if (open) { + node.nodes = [] + this.current = node + } + } + + checkMissedSemicolon(tokens) { + let colon = this.colon(tokens) + if (colon === false) return + + let founded = 0 + let token + for (let j = colon - 1; j >= 0; j--) { + token = tokens[j] + if (token[0] !== 'space') { + founded += 1 + if (founded === 2) break + } + } + // If the token is a word, e.g. `!important`, `red` or any other valid + // property's value. Then we need to return the colon after that word + // token. [3] is the "end" colon of that word. And because we need it + // after that one we do +1 to get the next one. + throw this.input.error( + 'Missed semicolon', + token[0] === 'word' ? token[3] + 1 : token[2] + ) + } + + colon(tokens) { + let brackets = 0 + let prev, token, type + for (let [i, element] of tokens.entries()) { + token = element + type = token[0] + + if (type === '(') { + brackets += 1 + } + if (type === ')') { + brackets -= 1 + } + if (brackets === 0 && type === ':') { + if (!prev) { + this.doubleColon(token) + } else if (prev[0] === 'word' && prev[1] === 'progid') { + continue + } else { + return i + } + } + + prev = token + } + return false + } + + comment(token) { + let node = new Comment() + this.init(node, token[2]) + node.source.end = this.getPosition(token[3] || token[2]) + node.source.end.offset++ + + let text = token[1].slice(2, -2) + if (!text.trim()) { + node.text = '' + node.raws.left = text + node.raws.right = '' + } else { + let match = text.match(/^(\s*)([^]*\S)(\s*)$/) + node.text = match[2] + node.raws.left = match[1] + node.raws.right = match[3] + } + } + + createTokenizer() { + this.tokenizer = tokenizer(this.input) + } + + decl(tokens, customProperty) { + let node = new Declaration() + this.init(node, tokens[0][2]) + + let last = tokens[tokens.length - 1] + if (last[0] === ';') { + this.semicolon = true + tokens.pop() + } + + node.source.end = this.getPosition( + last[3] || last[2] || findLastWithPosition(tokens) + ) + node.source.end.offset++ + + let start = 0 + while (tokens[start][0] !== 'word') { + if (start === tokens.length - 1) this.unknownWord([tokens[start]]) + start++ + } + node.raws.before += tokensToString(tokens, 0, start) + node.source.start = this.getPosition(tokens[start][2]) + + let propStart = start + while (start < tokens.length) { + let type = tokens[start][0] + if (type === ':' || type === 'space' || type === 'comment') { + break + } + start++ + } + node.prop = tokensToString(tokens, propStart, start) + + let betweenStart = start + let token + while (start < tokens.length) { + token = tokens[start] + start++ + if (token[0] === ':') break + if (token[0] === 'word' && /\w/.test(token[1])) { + this.unknownWord([token]) + } + } + node.raws.between = tokensToString(tokens, betweenStart, start) + + if (node.prop[0] === '_' || node.prop[0] === '*') { + node.raws.before += node.prop[0] + node.prop = node.prop.slice(1) + } + + let firstSpacesStart = start + while (start < tokens.length) { + let next = tokens[start][0] + if (next !== 'space' && next !== 'comment') break + start++ + } + let firstSpaces = tokens.slice(firstSpacesStart, start) + + tokens = tokens.slice(start) + + this.precheckMissedSemicolon(tokens) + + for (let i = tokens.length - 1; i >= 0; i--) { + token = tokens[i] + if (token[1].toLowerCase() === '!important') { + node.important = true + let string = this.stringFrom(tokens, i) + string = this.spacesFromEnd(tokens) + string + if (string !== ' !important') node.raws.important = string + break + } else if (token[1].toLowerCase() === 'important') { + let cache = tokens.slice(0) + let str = '' + for (let j = i; j > 0; j--) { + let type = cache[j][0] + if (str.trim().startsWith('!') && type !== 'space') { + break + } + str = cache.pop()[1] + str + } + if (str.trim().startsWith('!')) { + node.important = true + node.raws.important = str + tokens = cache + } + } + + if (token[0] !== 'space' && token[0] !== 'comment') { + break + } + } + + let hasWord = tokens.some(i => i[0] !== 'space' && i[0] !== 'comment') + + if (hasWord) { + node.raws.between += firstSpaces.map(i => i[1]).join('') + firstSpaces = [] + } + this.raw(node, 'value', firstSpaces.concat(tokens), customProperty) + + if (node.value.includes(':') && !customProperty) { + this.checkMissedSemicolon(tokens) + } + } + + doubleColon(token) { + throw this.input.error( + 'Double colon', + { offset: token[2] }, + { offset: token[2] + token[1].length } + ) + } + + emptyRule(token) { + let node = new Rule() + this.init(node, token[2]) + node.selector = '' + node.raws.between = '' + this.current = node + } + + end(token) { + if (this.current.nodes && this.current.nodes.length) { + this.current.raws.semicolon = this.semicolon + } + this.semicolon = false + + this.current.raws.after = (this.current.raws.after || '') + this.spaces + this.spaces = '' + + if (this.current.parent) { + this.current.source.end = this.getPosition(token[2]) + this.current.source.end.offset++ + this.current = this.current.parent + } else { + this.unexpectedClose(token) + } + } + + endFile() { + if (this.current.parent) this.unclosedBlock() + if (this.current.nodes && this.current.nodes.length) { + this.current.raws.semicolon = this.semicolon + } + this.current.raws.after = (this.current.raws.after || '') + this.spaces + this.root.source.end = this.getPosition(this.tokenizer.position()) + } + + freeSemicolon(token) { + this.spaces += token[1] + if (this.current.nodes) { + let prev = this.current.nodes[this.current.nodes.length - 1] + if (prev && prev.type === 'rule' && !prev.raws.ownSemicolon) { + prev.raws.ownSemicolon = this.spaces + this.spaces = '' + prev.source.end = this.getPosition(token[2]) + prev.source.end.offset += prev.raws.ownSemicolon.length + } + } + } + + // Helpers + + getPosition(offset) { + let pos = this.input.fromOffset(offset) + return { + column: pos.col, + line: pos.line, + offset + } + } + + init(node, offset) { + this.current.push(node) + node.source = { + input: this.input, + start: this.getPosition(offset) + } + node.raws.before = this.spaces + this.spaces = '' + if (node.type !== 'comment') this.semicolon = false + } + + other(start) { + let end = false + let type = null + let colon = false + let bracket = null + let brackets = [] + let customProperty = start[1].startsWith('--') + + let tokens = [] + let token = start + while (token) { + type = token[0] + tokens.push(token) + + if (type === '(' || type === '[') { + if (!bracket) bracket = token + brackets.push(type === '(' ? ')' : ']') + } else if (customProperty && colon && type === '{') { + if (!bracket) bracket = token + brackets.push('}') + } else if (brackets.length === 0) { + if (type === ';') { + if (colon) { + this.decl(tokens, customProperty) + return + } else { + break + } + } else if (type === '{') { + this.rule(tokens) + return + } else if (type === '}') { + this.tokenizer.back(tokens.pop()) + end = true + break + } else if (type === ':') { + colon = true + } + } else if (type === brackets[brackets.length - 1]) { + brackets.pop() + if (brackets.length === 0) bracket = null + } + + token = this.tokenizer.nextToken() + } + + if (this.tokenizer.endOfFile()) end = true + if (brackets.length > 0) this.unclosedBracket(bracket) + + if (end && colon) { + if (!customProperty) { + while (tokens.length) { + token = tokens[tokens.length - 1][0] + if (token !== 'space' && token !== 'comment') break + this.tokenizer.back(tokens.pop()) + } + } + this.decl(tokens, customProperty) + } else { + this.unknownWord(tokens) + } + } + + parse() { + let token + while (!this.tokenizer.endOfFile()) { + token = this.tokenizer.nextToken() + + switch (token[0]) { + case 'space': + this.spaces += token[1] + break + + case ';': + this.freeSemicolon(token) + break + + case '}': + this.end(token) + break + + case 'comment': + this.comment(token) + break + + case 'at-word': + this.atrule(token) + break + + case '{': + this.emptyRule(token) + break + + default: + this.other(token) + break + } + } + this.endFile() + } + + precheckMissedSemicolon(/* tokens */) { + // Hook for Safe Parser + } + + raw(node, prop, tokens, customProperty) { + let token, type + let length = tokens.length + let value = '' + let clean = true + let next, prev + + for (let i = 0; i < length; i += 1) { + token = tokens[i] + type = token[0] + if (type === 'space' && i === length - 1 && !customProperty) { + clean = false + } else if (type === 'comment') { + prev = tokens[i - 1] ? tokens[i - 1][0] : 'empty' + next = tokens[i + 1] ? tokens[i + 1][0] : 'empty' + if (!SAFE_COMMENT_NEIGHBOR[prev] && !SAFE_COMMENT_NEIGHBOR[next]) { + if (value.slice(-1) === ',') { + clean = false + } else { + value += token[1] + } + } else { + clean = false + } + } else { + value += token[1] + } + } + if (!clean) { + let raw = tokens.reduce((all, i) => all + i[1], '') + node.raws[prop] = { raw, value } + } + node[prop] = value + } + + rule(tokens) { + tokens.pop() + + let node = new Rule() + this.init(node, tokens[0][2]) + + node.raws.between = this.spacesAndCommentsFromEnd(tokens) + this.raw(node, 'selector', tokens) + this.current = node + } + + spacesAndCommentsFromEnd(tokens) { + let lastTokenType + let spaces = '' + while (tokens.length) { + lastTokenType = tokens[tokens.length - 1][0] + if (lastTokenType !== 'space' && lastTokenType !== 'comment') break + spaces = tokens.pop()[1] + spaces + } + return spaces + } + + // Errors + + spacesAndCommentsFromStart(tokens) { + let next + let spaces = '' + while (tokens.length) { + next = tokens[0][0] + if (next !== 'space' && next !== 'comment') break + spaces += tokens.shift()[1] + } + return spaces + } + + spacesFromEnd(tokens) { + let lastTokenType + let spaces = '' + while (tokens.length) { + lastTokenType = tokens[tokens.length - 1][0] + if (lastTokenType !== 'space') break + spaces = tokens.pop()[1] + spaces + } + return spaces + } + + stringFrom(tokens, from) { + let result = '' + for (let i = from; i < tokens.length; i++) { + result += tokens[i][1] + } + tokens.splice(from, tokens.length - from) + return result + } + + unclosedBlock() { + let pos = this.current.source.start + throw this.input.error('Unclosed block', pos.line, pos.column) + } + + unclosedBracket(bracket) { + throw this.input.error( + 'Unclosed bracket', + { offset: bracket[2] }, + { offset: bracket[2] + 1 } + ) + } + + unexpectedClose(token) { + throw this.input.error( + 'Unexpected }', + { offset: token[2] }, + { offset: token[2] + 1 } + ) + } + + unknownWord(tokens) { + throw this.input.error( + 'Unknown word ' + tokens[0][1], + { offset: tokens[0][2] }, + { offset: tokens[0][2] + tokens[0][1].length } + ) + } + + unnamedAtrule(node, token) { + throw this.input.error( + 'At-rule without name', + { offset: token[2] }, + { offset: token[2] + token[1].length } + ) + } +} + +module.exports = Parser diff --git a/client/node_modules/postcss/lib/postcss.d.mts b/client/node_modules/postcss/lib/postcss.d.mts new file mode 100644 index 0000000..eaec868 --- /dev/null +++ b/client/node_modules/postcss/lib/postcss.d.mts @@ -0,0 +1,66 @@ +export { + // Type-only exports + AcceptedPlugin, + AnyNode, + atRule, + AtRule, + AtRuleProps, + Builder, + ChildNode, + ChildProps, + comment, + Comment, + CommentProps, + Container, + ContainerProps, + CssSyntaxError, + decl, + Declaration, + DeclarationProps, + // postcss function / namespace + default, + document, + Document, + DocumentProps, + FilePosition, + fromJSON, + Helpers, + Input, + JSONHydrator, + // This is a class, but it’s not re-exported. That’s why it’s exported as type-only here. + type LazyResult, + list, + Message, + Node, + NodeErrorOptions, + NodeProps, + OldPlugin, + parse, + Parser, + // @ts-expect-error This value exists, but it’s untyped. + plugin, + Plugin, + PluginCreator, + Position, + Postcss, + ProcessOptions, + Processor, + Result, + root, + Root, + RootProps, + rule, + Rule, + RuleProps, + Source, + SourceMap, + SourceMapOptions, + Stringifier, + // Value exports from postcss.mjs + stringify, + Syntax, + TransformCallback, + Transformer, + Warning, + WarningOptions +} from './postcss.js' diff --git a/client/node_modules/postcss/lib/postcss.d.ts b/client/node_modules/postcss/lib/postcss.d.ts new file mode 100644 index 0000000..41bf40f --- /dev/null +++ b/client/node_modules/postcss/lib/postcss.d.ts @@ -0,0 +1,464 @@ +import { RawSourceMap, SourceMapGenerator } from 'source-map-js' + +import AtRule, { AtRuleProps } from './at-rule.js' +import Comment, { CommentProps } from './comment.js' +import Container, { ContainerProps, NewChild } from './container.js' +import CssSyntaxError from './css-syntax-error.js' +import Declaration, { DeclarationProps } from './declaration.js' +import Document, { DocumentProps } from './document.js' +import Input, { FilePosition } from './input.js' +import LazyResult from './lazy-result.js' +import list from './list.js' +import Node, { + AnyNode, + ChildNode, + ChildProps, + NodeErrorOptions, + NodeProps, + Position, + Source +} from './node.js' +import Processor from './processor.js' +import Result, { Message } from './result.js' +import Root, { RootProps } from './root.js' +import Rule, { RuleProps } from './rule.js' +import Warning, { WarningOptions } from './warning.js' + +type DocumentProcessor = ( + document: Document, + helper: postcss.Helpers +) => Promise | void +type RootProcessor = ( + root: Root, + helper: postcss.Helpers +) => Promise | void +type DeclarationProcessor = ( + decl: Declaration, + helper: postcss.Helpers +) => Promise | void +type RuleProcessor = ( + rule: Rule, + helper: postcss.Helpers +) => Promise | void +type AtRuleProcessor = ( + atRule: AtRule, + helper: postcss.Helpers +) => Promise | void +type CommentProcessor = ( + comment: Comment, + helper: postcss.Helpers +) => Promise | void + +interface Processors { + /** + * Will be called on all`AtRule` nodes. + * + * Will be called again on node or children changes. + */ + AtRule?: { [name: string]: AtRuleProcessor } | AtRuleProcessor + + /** + * Will be called on all `AtRule` nodes, when all children will be processed. + * + * Will be called again on node or children changes. + */ + AtRuleExit?: { [name: string]: AtRuleProcessor } | AtRuleProcessor + + /** + * Will be called on all `Comment` nodes. + * + * Will be called again on node or children changes. + */ + Comment?: CommentProcessor + + /** + * Will be called on all `Comment` nodes after listeners + * for `Comment` event. + * + * Will be called again on node or children changes. + */ + CommentExit?: CommentProcessor + + /** + * Will be called on all `Declaration` nodes after listeners + * for `Declaration` event. + * + * Will be called again on node or children changes. + */ + Declaration?: { [prop: string]: DeclarationProcessor } | DeclarationProcessor + + /** + * Will be called on all `Declaration` nodes. + * + * Will be called again on node or children changes. + */ + DeclarationExit?: + | { [prop: string]: DeclarationProcessor } + | DeclarationProcessor + + /** + * Will be called on `Document` node. + * + * Will be called again on children changes. + */ + Document?: DocumentProcessor + + /** + * Will be called on `Document` node, when all children will be processed. + * + * Will be called again on children changes. + */ + DocumentExit?: DocumentProcessor + + /** + * Will be called on `Root` node once. + */ + Once?: RootProcessor + + /** + * Will be called on `Root` node once, when all children will be processed. + */ + OnceExit?: RootProcessor + + /** + * Will be called on `Root` node. + * + * Will be called again on children changes. + */ + Root?: RootProcessor + + /** + * Will be called on `Root` node, when all children will be processed. + * + * Will be called again on children changes. + */ + RootExit?: RootProcessor + + /** + * Will be called on all `Rule` nodes. + * + * Will be called again on node or children changes. + */ + Rule?: RuleProcessor + + /** + * Will be called on all `Rule` nodes, when all children will be processed. + * + * Will be called again on node or children changes. + */ + RuleExit?: RuleProcessor +} + +declare namespace postcss { + export { + AnyNode, + AtRule, + AtRuleProps, + ChildNode, + ChildProps, + Comment, + CommentProps, + Container, + ContainerProps, + CssSyntaxError, + Declaration, + DeclarationProps, + Document, + DocumentProps, + FilePosition, + Input, + LazyResult, + list, + Message, + NewChild, + Node, + NodeErrorOptions, + NodeProps, + Position, + Processor, + Result, + Root, + RootProps, + Rule, + RuleProps, + Source, + Warning, + WarningOptions + } + + export type SourceMap = { + toJSON(): RawSourceMap + } & SourceMapGenerator + + export type Helpers = { postcss: Postcss; result: Result } & Postcss + + export interface Plugin extends Processors { + postcssPlugin: string + prepare?: (result: Result) => Processors + } + + export interface PluginCreator { + (opts?: PluginOptions): Plugin | Processor + postcss: true + } + + export interface Transformer extends TransformCallback { + postcssPlugin: string + postcssVersion: string + } + + export interface TransformCallback { + (root: Root, result: Result): Promise | void + } + + export interface OldPlugin extends Transformer { + (opts?: T): Transformer + postcss: Transformer + } + + export type AcceptedPlugin = + | { + postcss: Processor | TransformCallback + } + | OldPlugin + | Plugin + | PluginCreator + | Processor + | TransformCallback + + export interface Parser { + ( + css: { toString(): string } | string, + opts?: Pick + ): RootNode + } + + export interface Builder { + (part: string, node?: AnyNode, type?: 'end' | 'start'): void + } + + export interface Stringifier { + (node: AnyNode, builder: Builder): void + } + + export interface JSONHydrator { + (data: object): Node + (data: object[]): Node[] + } + + export interface Syntax { + /** + * Function to generate AST by string. + */ + parse?: Parser + + /** + * Class to generate string by AST. + */ + stringify?: Stringifier + } + + export interface SourceMapOptions { + /** + * Use absolute path in generated source map. + */ + absolute?: boolean + + /** + * Indicates that PostCSS should add annotation comments to the CSS. + * By default, PostCSS will always add a comment with a path + * to the source map. PostCSS will not add annotations to CSS files + * that do not contain any comments. + * + * By default, PostCSS presumes that you want to save the source map as + * `opts.to + '.map'` and will use this path in the annotation comment. + * A different path can be set by providing a string value for annotation. + * + * If you have set `inline: true`, annotation cannot be disabled. + */ + annotation?: ((file: string, root: Root) => string) | boolean | string + + /** + * Override `from` in map’s sources. + */ + from?: string + + /** + * Indicates that the source map should be embedded in the output CSS + * as a Base64-encoded comment. By default, it is `true`. + * But if all previous maps are external, not inline, PostCSS will not embed + * the map even if you do not set this option. + * + * If you have an inline source map, the result.map property will be empty, + * as the source map will be contained within the text of `result.css`. + */ + inline?: boolean + + /** + * Source map content from a previous processing step (e.g., Sass). + * + * PostCSS will try to read the previous source map + * automatically (based on comments within the source CSS), but you can use + * this option to identify it manually. + * + * If desired, you can omit the previous map with prev: `false`. + */ + prev?: ((file: string) => string) | boolean | object | string + + /** + * Indicates that PostCSS should set the origin content (e.g., Sass source) + * of the source map. By default, it is true. But if all previous maps do not + * contain sources content, PostCSS will also leave it out even if you + * do not set this option. + */ + sourcesContent?: boolean + } + + export interface ProcessOptions { + /** + * Input file if it is not simple CSS file, but HTML with + + `; +} +//#endregion +//#region src/node/server/transformRequest.ts +const ERR_LOAD_URL = "ERR_LOAD_URL"; +const ERR_LOAD_PUBLIC_URL = "ERR_LOAD_PUBLIC_URL"; +const ERR_DENIED_ID = "ERR_DENIED_ID"; +const debugLoad = createDebugger("vite:load"); +const debugTransform = createDebugger("vite:transform"); +const debugCache$1 = createDebugger("vite:cache"); +function transformRequest(environment, url, options) { + if (environment._closing && environment.config.dev.recoverable) throwClosedServerError(); + const timestamp = monotonicDateNow(); + url = removeTimestampQuery(url); + const pending = environment._pendingRequests.get(url); + if (pending) return environment.moduleGraph.getModuleByUrl(url).then((module) => { + if (!module || pending.timestamp > module.lastInvalidationTimestamp) return pending.request; + else { + pending.abort(); + return transformRequest(environment, url, options); + } + }); + const request = doTransform(environment, url, options, timestamp); + let cleared = false; + const clearCache = () => { + if (!cleared) { + environment._pendingRequests.delete(url); + cleared = true; + } + }; + environment._pendingRequests.set(url, { + request, + timestamp, + abort: clearCache + }); + return request.finally(clearCache); +} +async function doTransform(environment, url, options, timestamp) { + const { pluginContainer } = environment; + let module = await environment.moduleGraph.getModuleByUrl(url); + if (module) { + const cached = await getCachedTransformResult(environment, url, module, timestamp); + if (cached) return cached; + } + const resolved = module ? void 0 : await pluginContainer.resolveId(url, void 0) ?? void 0; + const id = module?.id ?? resolved?.id ?? url; + module ??= environment.moduleGraph.getModuleById(id); + if (module) { + await environment.moduleGraph._ensureEntryFromUrl(url, void 0, resolved); + const cached = await getCachedTransformResult(environment, url, module, timestamp); + if (cached) return cached; + } + const result = loadAndTransform(environment, id, url, options, timestamp, module, resolved); + const { depsOptimizer } = environment; + if (!depsOptimizer?.isOptimizedDepFile(id)) environment._registerRequestProcessing(id, () => result); + return result; +} +async function getCachedTransformResult(environment, url, module, timestamp) { + const prettyUrl = debugCache$1 ? prettifyUrl(url, environment.config.root) : ""; + const softInvalidatedTransformResult = await handleModuleSoftInvalidation(environment, module, timestamp); + if (softInvalidatedTransformResult) { + debugCache$1?.(`[memory-hmr] ${prettyUrl}`); + return softInvalidatedTransformResult; + } + const cached = module.transformResult; + if (cached) { + debugCache$1?.(`[memory] ${prettyUrl}`); + return cached; + } +} +async function loadAndTransform(environment, id, url, options, timestamp, mod, resolved) { + const { config, pluginContainer, logger } = environment; + const prettyUrl = debugLoad || debugTransform ? prettifyUrl(url, config.root) : ""; + const moduleGraph = environment.moduleGraph; + if (!options.skipFsCheck && id[0] !== "\0" && isServerAccessDeniedForTransform(config, id)) { + const err = /* @__PURE__ */ new Error(`Denied ID ${id}`); + err.code = ERR_DENIED_ID; + err.id = id; + throw err; + } + let code = null; + let map = null; + let moduleType; + const loadStart = debugLoad ? performance$1.now() : 0; + const loadResult = await pluginContainer.load(id); + if (loadResult == null) { + const file = cleanUrl(id); + if (options.skipFsCheck || isFileLoadingAllowed(environment.getTopLevelConfig(), slash(file))) { + try { + code = await fsp.readFile(file, "utf-8"); + debugLoad?.(`${timeFrom(loadStart)} [fs] ${prettyUrl}`); + } catch (e) { + if (e.code !== "ENOENT" && e.code !== "EISDIR") throw e; + } + if (code != null && environment.pluginContainer.watcher) ensureWatchedFile(environment.pluginContainer.watcher, file, config.root); + } + if (code) try { + const extracted = extractSourcemapFromFile(code, file, logger); + if (extracted) { + code = extracted.code; + map = extracted.map; + } + } catch (e) { + logger.warn(`Failed to load source map for ${file}.\n${e}`, { timestamp: true }); + } + } else { + debugLoad?.(`${timeFrom(loadStart)} [plugin] ${prettyUrl}`); + if (isObject$1(loadResult)) { + code = loadResult.code; + map = loadResult.map; + moduleType = loadResult.moduleType; + } else code = loadResult; + } + if (code == null) { + const isPublicFile = checkPublicFile(url, environment.getTopLevelConfig()); + let publicDirName = path.relative(config.root, config.publicDir); + if (publicDirName[0] !== ".") publicDirName = "/" + publicDirName; + const msg = isPublicFile ? `This file is in ${publicDirName} and will be copied as-is during build without going through the plugin transforms, and therefore should not be imported from source code. It can only be referenced via HTML tags.` : `Does the file exist?`; + const importerMod = moduleGraph.idToModuleMap.get(id)?.importers.values().next().value; + const importer = importerMod?.file || importerMod?.url; + const err = /* @__PURE__ */ new Error(`Failed to load url ${url} (resolved id: ${id})${importer ? ` in ${importer}` : ""}. ${msg}`); + err.code = isPublicFile ? ERR_LOAD_PUBLIC_URL : ERR_LOAD_URL; + throw err; + } + if (moduleType === void 0) { + const guessedModuleType = getModuleTypeFromId(id); + if (guessedModuleType && guessedModuleType !== "js") moduleType = guessedModuleType; + } + if (environment._closing && environment.config.dev.recoverable) throwClosedServerError(); + mod ??= await moduleGraph._ensureEntryFromUrl(url, void 0, resolved); + const transformStart = debugTransform ? performance$1.now() : 0; + const transformResult = await pluginContainer.transform(code, id, { + inMap: map, + moduleType + }); + const originalCode = code; + if (transformResult.code === originalCode) debugTransform?.(timeFrom(transformStart) + import_picocolors.default.dim(` [skipped] ${prettyUrl}`)); + else { + debugTransform?.(`${timeFrom(transformStart)} ${prettyUrl}`); + code = transformResult.code; + map = transformResult.map; + } + let normalizedMap; + if (typeof map === "string") normalizedMap = JSON.parse(map); + else if (map) normalizedMap = map; + else normalizedMap = null; + if (normalizedMap && "version" in normalizedMap && mod.file) { + if (normalizedMap.mappings) await injectSourcesContent(normalizedMap, mod.file, logger); + const sourcemapPath = `${mod.file}.map`; + applySourcemapIgnoreList(normalizedMap, sourcemapPath, config.server.sourcemapIgnoreList, logger); + if (path.isAbsolute(mod.file)) { + let modDirname; + for (let sourcesIndex = 0; sourcesIndex < normalizedMap.sources.length; ++sourcesIndex) { + const sourcePath = normalizedMap.sources[sourcesIndex]; + if (sourcePath) { + if (path.isAbsolute(sourcePath)) { + modDirname ??= path.dirname(mod.file); + normalizedMap.sources[sourcesIndex] = path.relative(modDirname, sourcePath); + } + } + } + } + } + if (environment._closing && environment.config.dev.recoverable) throwClosedServerError(); + const topLevelConfig = environment.getTopLevelConfig(); + const result = environment.config.dev.moduleRunnerTransform ? await ssrTransform(code, normalizedMap, url, originalCode, { json: { stringify: topLevelConfig.json.stringify === true && topLevelConfig.json.namedExports !== true } }) : { + code, + map: normalizedMap, + etag: (0, import_etag.default)(code, { weak: true }) + }; + if (timestamp > mod.lastInvalidationTimestamp) moduleGraph.updateModuleTransformResult(mod, result); + return result; +} +/** +* When a module is soft-invalidated, we can preserve its previous `transformResult` and +* return similar code to before: +* +* - Client: We need to transform the import specifiers with new timestamps +* - SSR: We don't need to change anything as `ssrLoadModule` controls it +*/ +async function handleModuleSoftInvalidation(environment, mod, timestamp) { + const transformResult = mod.invalidationState; + mod.invalidationState = void 0; + if (!transformResult || transformResult === "HARD_INVALIDATED") return; + if (mod.transformResult) throw new Error(`Internal server error: Soft-invalidated module "${mod.url}" should not have existing transform result`); + let result; + if (transformResult.ssr) result = transformResult; + else { + await init; + const source = transformResult.code; + const s = new MagicString(source); + const [imports] = parse$2(source, mod.id || void 0); + for (const imp of imports) { + let rawUrl = source.slice(imp.s, imp.e); + if (rawUrl === "import.meta") continue; + const hasQuotes = rawUrl[0] === "\"" || rawUrl[0] === "'"; + if (hasQuotes) rawUrl = rawUrl.slice(1, -1); + const urlWithoutTimestamp = removeTimestampQuery(rawUrl); + const hmrUrl = unwrapId(stripBase(removeImportQuery(urlWithoutTimestamp), environment.config.base)); + for (const importedMod of mod.importedModules) { + if (importedMod.url !== hmrUrl) continue; + if (importedMod.lastHMRTimestamp > 0) { + const replacedUrl = injectQuery(urlWithoutTimestamp, `t=${importedMod.lastHMRTimestamp}`); + const start = hasQuotes ? imp.s + 1 : imp.s; + const end = hasQuotes ? imp.e - 1 : imp.e; + s.overwrite(start, end, replacedUrl); + } + if (imp.d === -1 && environment.config.dev.preTransformRequests) environment.warmupRequest(hmrUrl); + break; + } + } + const code = s.toString(); + result = { + ...transformResult, + code, + etag: (0, import_etag.default)(code, { weak: true }) + }; + } + if (timestamp > mod.lastInvalidationTimestamp) environment.moduleGraph.updateModuleTransformResult(mod, result); + return result; +} +const defaultModuleTypes = { + js: "js", + mjs: "js", + cjs: "js", + jsx: "jsx", + ts: "ts", + mts: "ts", + cts: "ts", + tsx: "tsx", + json: "json", + txt: "text", + css: "css" +}; +function getModuleTypeFromId(id) { + let pos = -1; + while ((pos = id.indexOf(".", pos + 1)) >= 0) { + const ext = id.slice(pos + 1); + const moduleType = defaultModuleTypes[ext]; + if (moduleType) return moduleType; + } +} +//#endregion +//#region ../../node_modules/.pnpm/strip-literal@3.1.0/node_modules/strip-literal/dist/index.mjs +var import_js_tokens = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => { + var HashbangComment; + var Identifier; + var JSXIdentifier; + var JSXPunctuator; + var JSXString; + var JSXText; + var KeywordsWithExpressionAfter; + var KeywordsWithNoLineTerminatorAfter; + var LineTerminatorSequence; + var MultiLineComment; + var Newline; + var NumericLiteral; + var Punctuator; + var RegularExpressionLiteral = /\/(?![*\/])(?:\[(?:[^\]\\\n\r\u2028\u2029]+|\\.)*\]?|[^\/[\\\n\r\u2028\u2029]+|\\.)*(\/[$_\u200C\u200D\p{ID_Continue}]*|\\)?/uy; + var SingleLineComment; + var StringLiteral; + var Template; + var TokensNotPrecedingObjectLiteral; + var TokensPrecedingExpression; + var WhiteSpace; + Punctuator = /--|\+\+|=>|\.{3}|\??\.(?!\d)|(?:&&|\|\||\?\?|[+\-%&|^]|\*{1,2}|<{1,2}|>{1,3}|!=?|={1,2}|\/(?![\/*]))=?|[?~,:;[\](){}]/y; + Identifier = /(\x23?)(?=[$_\p{ID_Start}\\])(?:[$_\u200C\u200D\p{ID_Continue}]+|\\u[\da-fA-F]{4}|\\u\{[\da-fA-F]+\})+/uy; + StringLiteral = /(['"])(?:[^'"\\\n\r]+|(?!\1)['"]|\\(?:\r\n|[^]))*(\1)?/y; + NumericLiteral = /(?:0[xX][\da-fA-F](?:_?[\da-fA-F])*|0[oO][0-7](?:_?[0-7])*|0[bB][01](?:_?[01])*)n?|0n|[1-9](?:_?\d)*n|(?:(?:0(?!\d)|0\d*[89]\d*|[1-9](?:_?\d)*)(?:\.(?:\d(?:_?\d)*)?)?|\.\d(?:_?\d)*)(?:[eE][+-]?\d(?:_?\d)*)?|0[0-7]+/y; + Template = /[`}](?:[^`\\$]+|\\[^]|\$(?!\{))*(`|\$\{)?/y; + WhiteSpace = /[\t\v\f\ufeff\p{Zs}]+/uy; + LineTerminatorSequence = /\r?\n|[\r\u2028\u2029]/y; + MultiLineComment = /\/\*(?:[^*]+|\*(?!\/))*(\*\/)?/y; + SingleLineComment = /\/\/.*/y; + HashbangComment = /^#!.*/; + JSXPunctuator = /[<>.:={}]|\/(?![\/*])/y; + JSXIdentifier = /[$_\p{ID_Start}][$_\u200C\u200D\p{ID_Continue}-]*/uy; + JSXString = /(['"])(?:[^'"]+|(?!\1)['"])*(\1)?/y; + JSXText = /[^<>{}]+/y; + TokensPrecedingExpression = /^(?:[\/+-]|\.{3}|\?(?:InterpolationIn(?:JSX|Template)|NoLineTerminatorHere|NonExpressionParenEnd|UnaryIncDec))?$|[{}([,;<>=*%&|^!~?:]$/; + TokensNotPrecedingObjectLiteral = /^(?:=>|[;\]){}]|else|\?(?:NoLineTerminatorHere|NonExpressionParenEnd))?$/; + KeywordsWithExpressionAfter = /^(?:await|case|default|delete|do|else|instanceof|new|return|throw|typeof|void|yield)$/; + KeywordsWithNoLineTerminatorAfter = /^(?:return|throw|yield)$/; + Newline = RegExp(LineTerminatorSequence.source); + module.exports = function* (input, { jsx = false } = {}) { + var braces, firstCodePoint, isExpression, lastIndex, lastSignificantToken, length, match, mode, nextLastIndex, nextLastSignificantToken, parenNesting, postfixIncDec, punctuator, stack; + ({length} = input); + lastIndex = 0; + lastSignificantToken = ""; + stack = [{ tag: "JS" }]; + braces = []; + parenNesting = 0; + postfixIncDec = false; + if (match = HashbangComment.exec(input)) { + yield { + type: "HashbangComment", + value: match[0] + }; + lastIndex = match[0].length; + } + while (lastIndex < length) { + mode = stack[stack.length - 1]; + switch (mode.tag) { + case "JS": + case "JSNonExpressionParen": + case "InterpolationInTemplate": + case "InterpolationInJSX": + if (input[lastIndex] === "/" && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken))) { + RegularExpressionLiteral.lastIndex = lastIndex; + if (match = RegularExpressionLiteral.exec(input)) { + lastIndex = RegularExpressionLiteral.lastIndex; + lastSignificantToken = match[0]; + postfixIncDec = true; + yield { + type: "RegularExpressionLiteral", + value: match[0], + closed: match[1] !== void 0 && match[1] !== "\\" + }; + continue; + } + } + Punctuator.lastIndex = lastIndex; + if (match = Punctuator.exec(input)) { + punctuator = match[0]; + nextLastIndex = Punctuator.lastIndex; + nextLastSignificantToken = punctuator; + switch (punctuator) { + case "(": + if (lastSignificantToken === "?NonExpressionParenKeyword") stack.push({ + tag: "JSNonExpressionParen", + nesting: parenNesting + }); + parenNesting++; + postfixIncDec = false; + break; + case ")": + parenNesting--; + postfixIncDec = true; + if (mode.tag === "JSNonExpressionParen" && parenNesting === mode.nesting) { + stack.pop(); + nextLastSignificantToken = "?NonExpressionParenEnd"; + postfixIncDec = false; + } + break; + case "{": + Punctuator.lastIndex = 0; + isExpression = !TokensNotPrecedingObjectLiteral.test(lastSignificantToken) && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken)); + braces.push(isExpression); + postfixIncDec = false; + break; + case "}": + switch (mode.tag) { + case "InterpolationInTemplate": + if (braces.length === mode.nesting) { + Template.lastIndex = lastIndex; + match = Template.exec(input); + lastIndex = Template.lastIndex; + lastSignificantToken = match[0]; + if (match[1] === "${") { + lastSignificantToken = "?InterpolationInTemplate"; + postfixIncDec = false; + yield { + type: "TemplateMiddle", + value: match[0] + }; + } else { + stack.pop(); + postfixIncDec = true; + yield { + type: "TemplateTail", + value: match[0], + closed: match[1] === "`" + }; + } + continue; + } + break; + case "InterpolationInJSX": if (braces.length === mode.nesting) { + stack.pop(); + lastIndex += 1; + lastSignificantToken = "}"; + yield { + type: "JSXPunctuator", + value: "}" + }; + continue; + } + } + postfixIncDec = braces.pop(); + nextLastSignificantToken = postfixIncDec ? "?ExpressionBraceEnd" : "}"; + break; + case "]": + postfixIncDec = true; + break; + case "++": + case "--": + nextLastSignificantToken = postfixIncDec ? "?PostfixIncDec" : "?UnaryIncDec"; + break; + case "<": + if (jsx && (TokensPrecedingExpression.test(lastSignificantToken) || KeywordsWithExpressionAfter.test(lastSignificantToken))) { + stack.push({ tag: "JSXTag" }); + lastIndex += 1; + lastSignificantToken = "<"; + yield { + type: "JSXPunctuator", + value: punctuator + }; + continue; + } + postfixIncDec = false; + break; + default: postfixIncDec = false; + } + lastIndex = nextLastIndex; + lastSignificantToken = nextLastSignificantToken; + yield { + type: "Punctuator", + value: punctuator + }; + continue; + } + Identifier.lastIndex = lastIndex; + if (match = Identifier.exec(input)) { + lastIndex = Identifier.lastIndex; + nextLastSignificantToken = match[0]; + switch (match[0]) { + case "for": + case "if": + case "while": + case "with": if (lastSignificantToken !== "." && lastSignificantToken !== "?.") nextLastSignificantToken = "?NonExpressionParenKeyword"; + } + lastSignificantToken = nextLastSignificantToken; + postfixIncDec = !KeywordsWithExpressionAfter.test(match[0]); + yield { + type: match[1] === "#" ? "PrivateIdentifier" : "IdentifierName", + value: match[0] + }; + continue; + } + StringLiteral.lastIndex = lastIndex; + if (match = StringLiteral.exec(input)) { + lastIndex = StringLiteral.lastIndex; + lastSignificantToken = match[0]; + postfixIncDec = true; + yield { + type: "StringLiteral", + value: match[0], + closed: match[2] !== void 0 + }; + continue; + } + NumericLiteral.lastIndex = lastIndex; + if (match = NumericLiteral.exec(input)) { + lastIndex = NumericLiteral.lastIndex; + lastSignificantToken = match[0]; + postfixIncDec = true; + yield { + type: "NumericLiteral", + value: match[0] + }; + continue; + } + Template.lastIndex = lastIndex; + if (match = Template.exec(input)) { + lastIndex = Template.lastIndex; + lastSignificantToken = match[0]; + if (match[1] === "${") { + lastSignificantToken = "?InterpolationInTemplate"; + stack.push({ + tag: "InterpolationInTemplate", + nesting: braces.length + }); + postfixIncDec = false; + yield { + type: "TemplateHead", + value: match[0] + }; + } else { + postfixIncDec = true; + yield { + type: "NoSubstitutionTemplate", + value: match[0], + closed: match[1] === "`" + }; + } + continue; + } + break; + case "JSXTag": + case "JSXTagEnd": + JSXPunctuator.lastIndex = lastIndex; + if (match = JSXPunctuator.exec(input)) { + lastIndex = JSXPunctuator.lastIndex; + nextLastSignificantToken = match[0]; + switch (match[0]) { + case "<": + stack.push({ tag: "JSXTag" }); + break; + case ">": + stack.pop(); + if (lastSignificantToken === "/" || mode.tag === "JSXTagEnd") { + nextLastSignificantToken = "?JSX"; + postfixIncDec = true; + } else stack.push({ tag: "JSXChildren" }); + break; + case "{": + stack.push({ + tag: "InterpolationInJSX", + nesting: braces.length + }); + nextLastSignificantToken = "?InterpolationInJSX"; + postfixIncDec = false; + break; + case "/": if (lastSignificantToken === "<") { + stack.pop(); + if (stack[stack.length - 1].tag === "JSXChildren") stack.pop(); + stack.push({ tag: "JSXTagEnd" }); + } + } + lastSignificantToken = nextLastSignificantToken; + yield { + type: "JSXPunctuator", + value: match[0] + }; + continue; + } + JSXIdentifier.lastIndex = lastIndex; + if (match = JSXIdentifier.exec(input)) { + lastIndex = JSXIdentifier.lastIndex; + lastSignificantToken = match[0]; + yield { + type: "JSXIdentifier", + value: match[0] + }; + continue; + } + JSXString.lastIndex = lastIndex; + if (match = JSXString.exec(input)) { + lastIndex = JSXString.lastIndex; + lastSignificantToken = match[0]; + yield { + type: "JSXString", + value: match[0], + closed: match[2] !== void 0 + }; + continue; + } + break; + case "JSXChildren": + JSXText.lastIndex = lastIndex; + if (match = JSXText.exec(input)) { + lastIndex = JSXText.lastIndex; + lastSignificantToken = match[0]; + yield { + type: "JSXText", + value: match[0] + }; + continue; + } + switch (input[lastIndex]) { + case "<": + stack.push({ tag: "JSXTag" }); + lastIndex++; + lastSignificantToken = "<"; + yield { + type: "JSXPunctuator", + value: "<" + }; + continue; + case "{": + stack.push({ + tag: "InterpolationInJSX", + nesting: braces.length + }); + lastIndex++; + lastSignificantToken = "?InterpolationInJSX"; + postfixIncDec = false; + yield { + type: "JSXPunctuator", + value: "{" + }; + continue; + } + } + WhiteSpace.lastIndex = lastIndex; + if (match = WhiteSpace.exec(input)) { + lastIndex = WhiteSpace.lastIndex; + yield { + type: "WhiteSpace", + value: match[0] + }; + continue; + } + LineTerminatorSequence.lastIndex = lastIndex; + if (match = LineTerminatorSequence.exec(input)) { + lastIndex = LineTerminatorSequence.lastIndex; + postfixIncDec = false; + if (KeywordsWithNoLineTerminatorAfter.test(lastSignificantToken)) lastSignificantToken = "?NoLineTerminatorHere"; + yield { + type: "LineTerminatorSequence", + value: match[0] + }; + continue; + } + MultiLineComment.lastIndex = lastIndex; + if (match = MultiLineComment.exec(input)) { + lastIndex = MultiLineComment.lastIndex; + if (Newline.test(match[0])) { + postfixIncDec = false; + if (KeywordsWithNoLineTerminatorAfter.test(lastSignificantToken)) lastSignificantToken = "?NoLineTerminatorHere"; + } + yield { + type: "MultiLineComment", + value: match[0], + closed: match[1] !== void 0 + }; + continue; + } + SingleLineComment.lastIndex = lastIndex; + if (match = SingleLineComment.exec(input)) { + lastIndex = SingleLineComment.lastIndex; + postfixIncDec = false; + yield { + type: "SingleLineComment", + value: match[0] + }; + continue; + } + firstCodePoint = String.fromCodePoint(input.codePointAt(lastIndex)); + lastIndex += firstCodePoint.length; + lastSignificantToken = firstCodePoint; + postfixIncDec = false; + yield { + type: mode.tag.startsWith("JSX") ? "JSXInvalid" : "Invalid", + value: firstCodePoint + }; + } + }; +})))(), 1); +const FILL_COMMENT = " "; +function stripLiteralFromToken(token, fillChar, filter) { + if (token.type === "SingleLineComment") return FILL_COMMENT.repeat(token.value.length); + if (token.type === "MultiLineComment") return token.value.replace(/[^\n]/g, FILL_COMMENT); + if (token.type === "StringLiteral") { + if (!token.closed) return token.value; + const body = token.value.slice(1, -1); + if (filter(body)) return token.value[0] + fillChar.repeat(body.length) + token.value[token.value.length - 1]; + } + if (token.type === "NoSubstitutionTemplate") { + const body = token.value.slice(1, -1); + if (filter(body)) return `\`${body.replace(/[^\n]/g, fillChar)}\``; + } + if (token.type === "RegularExpressionLiteral") { + const body = token.value; + if (filter(body)) return body.replace(/\/(.*)\/(\w?)$/g, (_, $1, $2) => `/${fillChar.repeat($1.length)}/${$2}`); + } + if (token.type === "TemplateHead") { + const body = token.value.slice(1, -2); + if (filter(body)) return `\`${body.replace(/[^\n]/g, fillChar)}\${`; + } + if (token.type === "TemplateTail") { + const body = token.value.slice(0, -2); + if (filter(body)) return `}${body.replace(/[^\n]/g, fillChar)}\``; + } + if (token.type === "TemplateMiddle") { + const body = token.value.slice(1, -2); + if (filter(body)) return `}${body.replace(/[^\n]/g, fillChar)}\${`; + } + return token.value; +} +function optionsWithDefaults(options) { + return { + fillChar: options?.fillChar ?? " ", + filter: options?.filter ?? (() => true) + }; +} +function stripLiteral(code, options) { + let result = ""; + const _options = optionsWithDefaults(options); + for (const token of (0, import_js_tokens.default)(code, { jsx: false })) result += stripLiteralFromToken(token, _options.fillChar, _options.filter); + return result; +} +//#endregion +//#region src/node/environment.ts +/** +* Creates a function that hides the complexities of a WeakMap with an initial value +* to implement object metadata. Used by plugins to implement cross hooks per +* environment metadata +* +* @experimental +*/ +function perEnvironmentState(initial) { + const stateMap = /* @__PURE__ */ new WeakMap(); + return function(context) { + const { environment } = context; + if (!stateMap.has(environment)) stateMap.set(environment, initial(environment)); + return stateMap.get(environment); + }; +} +//#endregion +//#region src/node/assetSource.ts +const ALLOWED_META_NAME = [ + "msapplication-tileimage", + "msapplication-square70x70logo", + "msapplication-square150x150logo", + "msapplication-wide310x150logo", + "msapplication-square310x310logo", + "msapplication-config", + "twitter:image" +]; +const ALLOWED_META_PROPERTY = [ + "og:image", + "og:image:url", + "og:image:secure_url", + "og:audio", + "og:audio:secure_url", + "og:video", + "og:video:secure_url" +]; +const DEFAULT_HTML_ASSET_SOURCES = { + audio: { srcAttributes: ["src"] }, + embed: { srcAttributes: ["src"] }, + img: { + srcAttributes: ["src"], + srcsetAttributes: ["srcset"] + }, + image: { srcAttributes: ["href", "xlink:href"] }, + input: { srcAttributes: ["src"] }, + link: { + srcAttributes: ["href"], + srcsetAttributes: ["imagesrcset"] + }, + object: { srcAttributes: ["data"] }, + source: { + srcAttributes: ["src"], + srcsetAttributes: ["srcset"] + }, + track: { srcAttributes: ["src"] }, + use: { srcAttributes: ["href", "xlink:href"] }, + video: { srcAttributes: ["src", "poster"] }, + meta: { + srcAttributes: ["content"], + filter({ attributes }) { + if (attributes.name && ALLOWED_META_NAME.includes(attributes.name.trim().toLowerCase())) return true; + if (attributes.property && ALLOWED_META_PROPERTY.includes(attributes.property.trim().toLowerCase())) return true; + return false; + } + } +}; +/** +* Given a HTML node, find all attributes that references an asset to be processed +*/ +function getNodeAssetAttributes(node, additionalAssetSources) { + const defaults = DEFAULT_HTML_ASSET_SOURCES[node.nodeName]; + const additional = additionalAssetSources?.[node.nodeName]; + if (!defaults && !additional) return []; + const attributes = {}; + for (const attr of node.attrs) attributes[getAttrKey(attr)] = attr.value; + if ("vite-ignore" in attributes) return [{ + type: "remove", + key: "vite-ignore", + value: "", + attributes, + location: node.sourceCodeLocation.attrs["vite-ignore"] + }]; + const actions = []; + function handleAttributeKey(key, type, filter) { + const value = attributes[key]; + if (!value) return; + if (filter && !filter({ + key, + value, + attributes + })) return; + actions.push({ + type, + key, + value, + attributes, + location: node.sourceCodeLocation.attrs[key] + }); + } + if (defaults) { + defaults.srcAttributes?.forEach((key) => handleAttributeKey(key, "src", defaults.filter)); + defaults.srcsetAttributes?.forEach((key) => handleAttributeKey(key, "srcset", defaults.filter)); + } + if (additional) { + additional.srcAttributes?.forEach((key) => handleAttributeKey(key, "src", additional.filter)); + additional.srcsetAttributes?.forEach((key) => handleAttributeKey(key, "srcset", additional.filter)); + } + return actions; +} +function getAttrKey(attr) { + return attr.prefix === void 0 ? attr.name : `${attr.prefix}:${attr.name}`; +} +//#endregion +//#region src/node/plugins/asset.ts +const assetUrlRE = /__VITE_ASSET__([\w$]+)__(?:\$_(.*?)__)?/g; +const jsSourceMapRE = /\.[cm]?js\.map$/; +const noInlineRE = /[?&]no-inline\b/; +const inlineRE$3 = /[?&]inline\b/; +const assetCache = /* @__PURE__ */ new WeakMap(); +/** a set of referenceId for entry CSS assets for each environment */ +const cssEntriesMap = /* @__PURE__ */ new WeakMap(); +function registerCustomMime() { + mimes.ico = "image/x-icon"; + mimes.cur = "image/x-icon"; + mimes.flac = "audio/flac"; + mimes.eot = "application/vnd.ms-fontobject"; +} +function renderAssetUrlInJS(pluginContext, chunk, opts, code) { + const { environment } = pluginContext; + const toRelativeRuntime = createToImportMetaURLBasedRelativeRuntime(opts.format, environment.config.isWorker); + let match; + let s; + assetUrlRE.lastIndex = 0; + while (match = assetUrlRE.exec(code)) { + s ||= new MagicString(code); + const [full, referenceId, postfix = ""] = match; + const file = pluginContext.getFileName(referenceId); + chunk.viteMetadata.importedAssets.add(cleanUrl(file)); + const replacement = toOutputFilePathInJS(environment, file + postfix, "asset", chunk.fileName, "js", toRelativeRuntime); + const replacementString = typeof replacement === "string" ? JSON.stringify(encodeURIPath(replacement)).slice(1, -1) : `"+${replacement.runtime}+"`; + s.update(match.index, match.index + full.length, replacementString); + } + const publicAssetUrlMap = publicAssetUrlCache.get(environment.getTopLevelConfig()); + publicAssetUrlRE.lastIndex = 0; + while (match = publicAssetUrlRE.exec(code)) { + s ||= new MagicString(code); + const [full, hash] = match; + const replacement = toOutputFilePathInJS(environment, publicAssetUrlMap.get(hash).slice(1), "public", chunk.fileName, "js", toRelativeRuntime); + const replacementString = typeof replacement === "string" ? JSON.stringify(encodeURIPath(replacement)).slice(1, -1) : `"+${replacement.runtime}+"`; + s.update(match.index, match.index + full.length, replacementString); + } + return s; +} +/** +* Also supports loading plain strings with import text from './foo.txt?raw' +*/ +function assetPlugin(config) { + registerCustomMime(); + return { + name: "vite:asset", + perEnvironmentStartEndDuringDev: true, + buildStart() { + assetCache.set(this.environment, /* @__PURE__ */ new Map()); + cssEntriesMap.set(this.environment, /* @__PURE__ */ new Map()); + }, + resolveId: { + filter: { id: [ + urlRE$1, + DEFAULT_ASSETS_RE, + ...makeIdFiltersToMatchWithQuery(config.rawAssetsInclude).map((v) => typeof v === "string" ? pm.makeRe(v, { dot: true }) : v) + ] }, + handler(id) { + if (!config.assetsInclude(cleanUrl(id)) && !urlRE$1.test(id)) return; + if (checkPublicFile(id, config)) return id; + } + }, + load: { + filter: { id: { + include: [ + rawRE$1, + urlRE$1, + DEFAULT_ASSETS_RE, + ...makeIdFiltersToMatchWithQuery(config.rawAssetsInclude) + ], + exclude: /^\0/ + } }, + async handler(id) { + if (rawRE$1.test(id)) { + const file = checkPublicFile(id, config) || cleanUrl(id); + this.addWatchFile(file); + return { + code: `export default ${JSON.stringify(await fsp.readFile(file, "utf-8"))}`, + map: { mappings: "" }, + moduleType: "js" + }; + } + if (!urlRE$1.test(id) && !config.assetsInclude(cleanUrl(id))) return; + id = removeUrlQuery(id); + let url = await fileToUrl$1(this, id); + if (!url.startsWith("data:") && this.environment.mode === "dev") { + const mod = this.environment.moduleGraph.getModuleById(id); + if (mod && mod.lastHMRTimestamp > 0) url = injectQuery(url, `t=${mod.lastHMRTimestamp}`); + } + return { + code: `export default ${JSON.stringify(encodeURIPath(url))}`, + moduleSideEffects: config.command === "build" && this.getModuleInfo(id)?.isEntry ? "no-treeshake" : false, + meta: config.command === "build" ? { "vite:asset": true } : void 0, + moduleType: "js" + }; + } + }, + ...config.command === "build" ? { renderChunk(code, chunk, opts) { + const s = renderAssetUrlInJS(this, chunk, opts, code); + if (s) return { + code: s.toString(), + map: this.environment.config.build.sourcemap ? s.generateMap({ hires: "boundary" }) : null + }; + else return null; + } } : {}, + generateBundle(_, bundle) { + let importedFiles; + for (const file in bundle) { + const chunk = bundle[file]; + if (chunk.type === "chunk" && chunk.isEntry && chunk.moduleIds.length === 1 && config.assetsInclude(chunk.moduleIds[0]) && this.getModuleInfo(chunk.moduleIds[0])?.meta["vite:asset"]) { + if (!importedFiles) { + importedFiles = /* @__PURE__ */ new Set(); + for (const file in bundle) { + const chunk = bundle[file]; + if (chunk.type === "chunk") { + for (const importedFile of chunk.imports) importedFiles.add(importedFile); + for (const importedFile of chunk.dynamicImports) importedFiles.add(importedFile); + } + } + } + if (!importedFiles.has(file)) delete bundle[file]; + } + } + if (config.command === "build" && !this.environment.config.build.emitAssets) { + for (const file in bundle) if (bundle[file].type === "asset" && !file.endsWith("ssr-manifest.json") && !jsSourceMapRE.test(file)) delete bundle[file]; + } + }, + watchChange(id) { + assetCache.get(this.environment)?.delete(normalizePath(id)); + } + }; +} +async function fileToUrl$1(pluginContext, id, asFileUrl = false) { + const { environment } = pluginContext; + if (!environment.config.isBundled) return fileToDevUrl(environment, id, asFileUrl); + else return fileToBuiltUrl(pluginContext, id); +} +async function fileToDevUrl(environment, id, asFileUrl = false) { + const config = environment.getTopLevelConfig(); + const publicFile = checkPublicFile(id, config); + if (inlineRE$3.test(id)) { + const file = publicFile || cleanUrl(id); + return assetToDataURL(environment, file, await fsp.readFile(file)); + } + const cleanedId = cleanUrl(id); + if (cleanedId.endsWith(".svg")) { + const file = publicFile || cleanedId; + const content = await fsp.readFile(file); + if (shouldInline(environment, file, id, content, void 0, void 0)) return assetToDataURL(environment, file, content); + } + if (asFileUrl) return pathToFileURL(cleanedId).href; + let rtn; + if (publicFile) rtn = id; + else if (id.startsWith(withTrailingSlash(config.root))) rtn = "/" + path.posix.relative(config.root, id); + else rtn = path.posix.join(FS_PREFIX, id); + return joinUrlSegments(joinUrlSegments(config.server.origin ?? "", config.decodedBase), removeLeadingSlash(rtn)); +} +function getPublicAssetFilename(hash, config) { + return publicAssetUrlCache.get(config)?.get(hash); +} +const publicAssetUrlCache = /* @__PURE__ */ new WeakMap(); +const publicAssetUrlRE = /__VITE_PUBLIC_ASSET__([a-z\d]{8})__/g; +function publicFileToBuiltUrl(url, config) { + if (config.command !== "build") return joinUrlSegments(config.decodedBase, url); + const hash = getHash(url); + let cache = publicAssetUrlCache.get(config); + if (!cache) { + cache = /* @__PURE__ */ new Map(); + publicAssetUrlCache.set(config, cache); + } + if (!cache.get(hash)) cache.set(hash, url); + return `__VITE_PUBLIC_ASSET__${hash}__`; +} +const GIT_LFS_PREFIX = Buffer$1.from("version https://git-lfs.github.com"); +function isGitLfsPlaceholder(content) { + if (content.length < GIT_LFS_PREFIX.length) return false; + return GIT_LFS_PREFIX.compare(content, 0, GIT_LFS_PREFIX.length) === 0; +} +/** +* Register an asset to be emitted as part of the bundle (if necessary) +* and returns the resolved public URL +*/ +async function fileToBuiltUrl(pluginContext, id, skipPublicCheck = false, forceInline) { + const environment = pluginContext.environment; + const topLevelConfig = environment.getTopLevelConfig(); + if (!skipPublicCheck) { + const publicFile = checkPublicFile(id, topLevelConfig); + if (publicFile) if (inlineRE$3.test(id)) id = publicFile; + else return publicFileToBuiltUrl(id, topLevelConfig); + } + const cache = assetCache.get(environment); + const cached = cache.get(id); + if (cached) return cached; + let { file, postfix } = splitFileAndPostfix(id); + const content = await fsp.readFile(file); + let url; + if (shouldInline(environment, file, id, content, pluginContext, forceInline)) url = assetToDataURL(environment, file, content); + else { + const originalFileName = normalizePath(path.relative(environment.config.root, file)); + const referenceId = pluginContext.emitFile({ + type: "asset", + name: path.basename(file), + originalFileName, + source: content + }); + if (environment.config.command === "build" && noInlineRE.test(postfix)) postfix = postfix.replace(noInlineRE, "").replace(/^&/, "?"); + if (environment.config.command === "serve" && environment.config.isBundled) url = toOutputFilePathInJSForBundledDev(environment, pluginContext.getFileName(referenceId)); + else url = `__VITE_ASSET__${referenceId}__${postfix ? `$_${postfix}__` : ``}`; + } + cache.set(id, url); + return url; +} +function toOutputFilePathInJSForBundledDev(environment, filename) { + const outputUrl = toOutputFilePathInJS(environment, filename, "asset", "assets/dummy.js", "js", () => { + throw new Error("unreachable"); + }); + if (typeof outputUrl === "object") throw new Error("unreachable"); + return outputUrl; +} +async function urlToBuiltUrl(pluginContext, url, importer, forceInline) { + const topLevelConfig = pluginContext.environment.getTopLevelConfig(); + if (checkPublicFile(url, topLevelConfig)) return publicFileToBuiltUrl(url, topLevelConfig); + return fileToBuiltUrl(pluginContext, normalizePath(url[0] === "/" ? path.join(topLevelConfig.root, url) : path.join(path.dirname(importer), url)), true, forceInline); +} +function shouldInline(environment, file, id, content, buildPluginContext, forceInline) { + if (noInlineRE.test(id)) return false; + if (inlineRE$3.test(id)) return true; + if (buildPluginContext) { + if (environment.config.build.lib) return true; + if (buildPluginContext.getModuleInfo(id)?.isEntry) return false; + } + if (forceInline !== void 0) return forceInline; + if (file.endsWith(".html")) return false; + if (file.endsWith(".svg") && id.includes("#")) return false; + let limit; + const { assetsInlineLimit } = environment.config.build; + if (typeof assetsInlineLimit === "function") { + const userShouldInline = assetsInlineLimit(file, content); + if (userShouldInline != null) return userShouldInline; + limit = DEFAULT_ASSETS_INLINE_LIMIT; + } else limit = Number(assetsInlineLimit); + return content.length < limit && !isGitLfsPlaceholder(content); +} +function assetToDataURL(environment, file, content) { + if (environment.config.build.lib && isGitLfsPlaceholder(content)) environment.logger.warn(import_picocolors.default.yellow(`Inlined file ${file} was not downloaded via Git LFS`)); + if (file.endsWith(".svg")) return svgToDataURL(content); + else return `data:${lookup(file) ?? "application/octet-stream"};base64,${content.toString("base64")}`; +} +const nestedQuotesRE = /"[^"']*'[^"]*"|'[^'"]*"[^']*'/; +function svgToDataURL(content) { + const stringContent = content.toString(); + if (stringContent.includes("\s+<").replaceAll("\"", "'").replaceAll("%", "%25").replaceAll("#", "%23").replaceAll("<", "%3c").replaceAll(">", "%3e").replaceAll(/\s+/g, "%20"); +} +//#endregion +//#region ../../node_modules/.pnpm/lilconfig@3.1.3/node_modules/lilconfig/src/index.js +var require_src$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const path$2 = __require("path"); + const fs$1 = __require("fs"); + const os$1 = __require("os"); + const url = __require("url"); + const fsReadFileAsync = fs$1.promises.readFile; + /** @type {(name: string, sync: boolean) => string[]} */ + function getDefaultSearchPlaces(name, sync) { + return [ + "package.json", + `.${name}rc.json`, + `.${name}rc.js`, + `.${name}rc.cjs`, + ...sync ? [] : [`.${name}rc.mjs`], + `.config/${name}rc`, + `.config/${name}rc.json`, + `.config/${name}rc.js`, + `.config/${name}rc.cjs`, + ...sync ? [] : [`.config/${name}rc.mjs`], + `${name}.config.js`, + `${name}.config.cjs`, + ...sync ? [] : [`${name}.config.mjs`] + ]; + } + /** + * @type {(p: string) => string} + * + * see #17 + * On *nix, if cwd is not under homedir, + * the last path will be '', ('/build' -> '') + * but it should be '/' actually. + * And on Windows, this will never happen. ('C:\build' -> 'C:') + */ + function parentDir(p) { + return path$2.dirname(p) || path$2.sep; + } + /** @type {import('./index').LoaderSync} */ + const jsonLoader = (_, content) => JSON.parse(content); + const requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require; + /** @type {import('./index').LoadersSync} */ + const defaultLoadersSync = Object.freeze({ + ".js": requireFunc, + ".json": requireFunc, + ".cjs": requireFunc, + noExt: jsonLoader + }); + module.exports.defaultLoadersSync = defaultLoadersSync; + /** @type {import('./index').Loader} */ + const dynamicImport = async (id) => { + try { + return (await import( + /* webpackIgnore: true */ + url.pathToFileURL(id).href +)).default; + } catch (e) { + try { + return requireFunc(id); + } catch (requireE) { + if (requireE.code === "ERR_REQUIRE_ESM" || requireE instanceof SyntaxError && requireE.toString().includes("Cannot use import statement outside a module")) throw e; + throw requireE; + } + } + }; + /** @type {import('./index').Loaders} */ + const defaultLoaders = Object.freeze({ + ".js": dynamicImport, + ".mjs": dynamicImport, + ".cjs": dynamicImport, + ".json": jsonLoader, + noExt: jsonLoader + }); + module.exports.defaultLoaders = defaultLoaders; + /** + * @param {string} name + * @param {import('./index').Options | import('./index').OptionsSync} options + * @param {boolean} sync + * @returns {Required} + */ + function getOptions(name, options, sync) { + /** @type {Required} */ + const conf = { + stopDir: os$1.homedir(), + searchPlaces: getDefaultSearchPlaces(name, sync), + ignoreEmptySearchPlaces: true, + cache: true, + transform: (x) => x, + packageProp: [name], + ...options, + loaders: { + ...sync ? defaultLoadersSync : defaultLoaders, + ...options.loaders + } + }; + conf.searchPlaces.forEach((place) => { + const key = path$2.extname(place) || "noExt"; + const loader = conf.loaders[key]; + if (!loader) throw new Error(`Missing loader for extension "${place}"`); + if (typeof loader !== "function") throw new Error(`Loader for extension "${place}" is not a function: Received ${typeof loader}.`); + }); + return conf; + } + /** @type {(props: string | string[], obj: Record) => unknown} */ + function getPackageProp(props, obj) { + if (typeof props === "string" && props in obj) return obj[props]; + return (Array.isArray(props) ? props : props.split(".")).reduce((acc, prop) => acc === void 0 ? acc : acc[prop], obj) || null; + } + /** @param {string} filepath */ + function validateFilePath(filepath) { + if (!filepath) throw new Error("load must pass a non-empty string"); + } + /** @type {(loader: import('./index').Loader, ext: string) => void} */ + function validateLoader(loader, ext) { + if (!loader) throw new Error(`No loader specified for extension "${ext}"`); + if (typeof loader !== "function") throw new Error("loader is not a function"); + } + /** @type {(enableCache: boolean) => (c: Map, filepath: string, res: T) => T} */ + const makeEmplace = (enableCache) => (c, filepath, res) => { + if (enableCache) c.set(filepath, res); + return res; + }; + /** @type {import('./index').lilconfig} */ + module.exports.lilconfig = function lilconfig(name, options) { + const { ignoreEmptySearchPlaces, loaders, packageProp, searchPlaces, stopDir, transform, cache } = getOptions(name, options ?? {}, false); + const searchCache = /* @__PURE__ */ new Map(); + const loadCache = /* @__PURE__ */ new Map(); + const emplace = makeEmplace(cache); + return { + async search(searchFrom = process.cwd()) { + /** @type {import('./index').LilconfigResult} */ + const result = { + config: null, + filepath: "" + }; + /** @type {Set} */ + const visited = /* @__PURE__ */ new Set(); + let dir = searchFrom; + dirLoop: while (true) { + if (cache) { + const r = searchCache.get(dir); + if (r !== void 0) { + for (const p of visited) searchCache.set(p, r); + return r; + } + visited.add(dir); + } + for (const searchPlace of searchPlaces) { + const filepath = path$2.join(dir, searchPlace); + try { + await fs$1.promises.access(filepath); + } catch { + continue; + } + const content = String(await fsReadFileAsync(filepath)); + const loaderKey = path$2.extname(searchPlace) || "noExt"; + const loader = loaders[loaderKey]; + if (searchPlace === "package.json") { + const pkg = await loader(filepath, content); + const maybeConfig = getPackageProp(packageProp, pkg); + if (maybeConfig != null) { + result.config = maybeConfig; + result.filepath = filepath; + break dirLoop; + } + continue; + } + const isEmpty = content.trim() === ""; + if (isEmpty && ignoreEmptySearchPlaces) continue; + if (isEmpty) { + result.isEmpty = true; + result.config = void 0; + } else { + validateLoader(loader, loaderKey); + result.config = await loader(filepath, content); + } + result.filepath = filepath; + break dirLoop; + } + if (dir === stopDir || dir === parentDir(dir)) break dirLoop; + dir = parentDir(dir); + } + const transformed = result.filepath === "" && result.config === null ? transform(null) : transform(result); + if (cache) for (const p of visited) searchCache.set(p, transformed); + return transformed; + }, + async load(filepath) { + validateFilePath(filepath); + const absPath = path$2.resolve(process.cwd(), filepath); + if (cache && loadCache.has(absPath)) return loadCache.get(absPath); + const { base, ext } = path$2.parse(absPath); + const loaderKey = ext || "noExt"; + const loader = loaders[loaderKey]; + validateLoader(loader, loaderKey); + const content = String(await fsReadFileAsync(absPath)); + if (base === "package.json") { + const pkg = await loader(absPath, content); + return emplace(loadCache, absPath, transform({ + config: getPackageProp(packageProp, pkg), + filepath: absPath + })); + } + /** @type {import('./index').LilconfigResult} */ + const result = { + config: null, + filepath: absPath + }; + const isEmpty = content.trim() === ""; + if (isEmpty && ignoreEmptySearchPlaces) return emplace(loadCache, absPath, transform({ + config: void 0, + filepath: absPath, + isEmpty: true + })); + result.config = isEmpty ? void 0 : await loader(absPath, content); + return emplace(loadCache, absPath, transform(isEmpty ? { + ...result, + isEmpty, + config: void 0 + } : result)); + }, + clearLoadCache() { + if (cache) loadCache.clear(); + }, + clearSearchCache() { + if (cache) searchCache.clear(); + }, + clearCaches() { + if (cache) { + loadCache.clear(); + searchCache.clear(); + } + } + }; + }; + /** @type {import('./index').lilconfigSync} */ + module.exports.lilconfigSync = function lilconfigSync(name, options) { + const { ignoreEmptySearchPlaces, loaders, packageProp, searchPlaces, stopDir, transform, cache } = getOptions(name, options ?? {}, true); + const searchCache = /* @__PURE__ */ new Map(); + const loadCache = /* @__PURE__ */ new Map(); + const emplace = makeEmplace(cache); + return { + search(searchFrom = process.cwd()) { + /** @type {import('./index').LilconfigResult} */ + const result = { + config: null, + filepath: "" + }; + /** @type {Set} */ + const visited = /* @__PURE__ */ new Set(); + let dir = searchFrom; + dirLoop: while (true) { + if (cache) { + const r = searchCache.get(dir); + if (r !== void 0) { + for (const p of visited) searchCache.set(p, r); + return r; + } + visited.add(dir); + } + for (const searchPlace of searchPlaces) { + const filepath = path$2.join(dir, searchPlace); + try { + fs$1.accessSync(filepath); + } catch { + continue; + } + const loaderKey = path$2.extname(searchPlace) || "noExt"; + const loader = loaders[loaderKey]; + const content = String(fs$1.readFileSync(filepath)); + if (searchPlace === "package.json") { + const pkg = loader(filepath, content); + const maybeConfig = getPackageProp(packageProp, pkg); + if (maybeConfig != null) { + result.config = maybeConfig; + result.filepath = filepath; + break dirLoop; + } + continue; + } + const isEmpty = content.trim() === ""; + if (isEmpty && ignoreEmptySearchPlaces) continue; + if (isEmpty) { + result.isEmpty = true; + result.config = void 0; + } else { + validateLoader(loader, loaderKey); + result.config = loader(filepath, content); + } + result.filepath = filepath; + break dirLoop; + } + if (dir === stopDir || dir === parentDir(dir)) break dirLoop; + dir = parentDir(dir); + } + const transformed = result.filepath === "" && result.config === null ? transform(null) : transform(result); + if (cache) for (const p of visited) searchCache.set(p, transformed); + return transformed; + }, + load(filepath) { + validateFilePath(filepath); + const absPath = path$2.resolve(process.cwd(), filepath); + if (cache && loadCache.has(absPath)) return loadCache.get(absPath); + const { base, ext } = path$2.parse(absPath); + const loaderKey = ext || "noExt"; + const loader = loaders[loaderKey]; + validateLoader(loader, loaderKey); + const content = String(fs$1.readFileSync(absPath)); + if (base === "package.json") { + const pkg = loader(absPath, content); + return transform({ + config: getPackageProp(packageProp, pkg), + filepath: absPath + }); + } + const result = { + config: null, + filepath: absPath + }; + const isEmpty = content.trim() === ""; + if (isEmpty && ignoreEmptySearchPlaces) return emplace(loadCache, absPath, transform({ + filepath: absPath, + config: void 0, + isEmpty: true + })); + result.config = isEmpty ? void 0 : loader(absPath, content); + return emplace(loadCache, absPath, transform(isEmpty ? { + ...result, + isEmpty, + config: void 0 + } : result)); + }, + clearLoadCache() { + if (cache) loadCache.clear(); + }, + clearSearchCache() { + if (cache) searchCache.clear(); + }, + clearCaches() { + if (cache) { + loadCache.clear(); + searchCache.clear(); + } + } + }; + }; +})); +//#endregion +//#region ../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.7.0_postcss@8.5.23_tsx@4.23.1_yaml@2.9.0/node_modules/postcss-load-config/src/req.js +var require_req = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const { createRequire: createRequire$1 } = __require("node:module"); + const { fileURLToPath: fileURLToPath$1, pathToFileURL: pathToFileURL$1 } = __require("node:url"); + const TS_EXT_RE = /\.[mc]?ts$/; + let tsx; + let jiti; + let importError = []; + /** + * @param {string} name + * @param {string} rootFile + * @returns {Promise} + */ + async function req(name, rootFile = fileURLToPath$1(import.meta.url)) { + let url = createRequire$1(rootFile).resolve(name); + try { + return (await import(`${pathToFileURL$1(url)}?t=${Date.now()}`)).default; + } catch (err) { + if (!TS_EXT_RE.test(url)) + /* c8 ignore start */ + throw err; + } + if (tsx === void 0) try { + tsx = await import("tsx/cjs/api"); + } catch (error) { + importError.push(error); + } + if (tsx) { + let loaded = tsx.require(name, rootFile); + return loaded && "__esModule" in loaded ? loaded.default : loaded; + } + if (jiti === void 0) try { + jiti = (await import("jiti")).default; + } catch (error) { + importError.push(error); + } + if (jiti) return jiti(rootFile, { interopDefault: true })(name); + throw new Error(`'tsx' or 'jiti' is required for the TypeScript configuration files. Make sure it is installed\nError: ${importError.map((error) => error.message).join("\n")}`); + } + module.exports = req; +})); +//#endregion +//#region ../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.7.0_postcss@8.5.23_tsx@4.23.1_yaml@2.9.0/node_modules/postcss-load-config/src/options.js +var require_options = /* @__PURE__ */ __commonJSMin(((exports, module) => { + const req = require_req(); + /** + * Load Options + * + * @private + * @method options + * + * @param {Object} config PostCSS Config + * + * @return {Promise