From d4926709f3033c71b6e43ea176e1bf0120f0fb69 Mon Sep 17 00:00:00 2001 From: Djuri Baars Date: Tue, 25 Jun 2024 01:10:40 +0200 Subject: [PATCH] Initial commit --- .gitignore | 24 + README.md | 3 + index.html | 23 + package.json | 28 + public/index.html | 25 + src/Widget.vue | 143 ++ src/components/BTClock.vue | 57 + src/dev.ts | 20 + src/js/btclock_datahandler.js | 3014 +++++++++++++++++++++++++++++++ src/js/btclock_datahandler.wasm | Bin 0 -> 70292 bytes src/main.ts | 17 + src/styles/main.scss | 125 ++ src/vite-env.d.ts | 1 + src/ws_connection.ts | 65 + tsconfig.app.json | 27 + tsconfig.json | 11 + tsconfig.node.json | 13 + vite.config.ts | 36 + yarn.lock | 791 ++++++++ 19 files changed, 4423 insertions(+) create mode 100644 .gitignore create mode 100644 README.md create mode 100644 index.html create mode 100644 package.json create mode 100644 public/index.html create mode 100644 src/Widget.vue create mode 100644 src/components/BTClock.vue create mode 100644 src/dev.ts create mode 100644 src/js/btclock_datahandler.js create mode 100755 src/js/btclock_datahandler.wasm create mode 100644 src/main.ts create mode 100644 src/styles/main.scss create mode 100644 src/vite-env.d.ts create mode 100644 src/ws_connection.ts create mode 100644 tsconfig.app.json create mode 100644 tsconfig.json create mode 100644 tsconfig.node.json create mode 100644 vite.config.ts create mode 100644 yarn.lock diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..a547bf3 --- /dev/null +++ b/.gitignore @@ -0,0 +1,24 @@ +# Logs +logs +*.log +npm-debug.log* +yarn-debug.log* +yarn-error.log* +pnpm-debug.log* +lerna-debug.log* + +node_modules +dist +dist-ssr +*.local + +# Editor directories and files +.vscode/* +!.vscode/extensions.json +.idea +.DS_Store +*.suo +*.ntvs* +*.njsproj +*.sln +*.sw? diff --git a/README.md b/README.md new file mode 100644 index 0000000..1a9e0a9 --- /dev/null +++ b/README.md @@ -0,0 +1,3 @@ +# BTClock Vue Widget + +git \ No newline at end of file diff --git a/index.html b/index.html new file mode 100644 index 0000000..8f38e61 --- /dev/null +++ b/index.html @@ -0,0 +1,23 @@ + + + + + + + Vite + Vue + TS + + + + + +
+ + + + diff --git a/package.json b/package.json new file mode 100644 index 0000000..4cbfc10 --- /dev/null +++ b/package.json @@ -0,0 +1,28 @@ +{ + "name": "btclock-widget", + "private": true, + "version": "0.0.0", + "type": "module", + "scripts": { + "dev": "vite", + "build": "vue-tsc -b && vite build", + "preview": "vite preview" + }, + "dependencies": { + "@fontsource/antonio": "^5.0.20", + "@fontsource/oswald": "^5.0.20", + "bootstrap": "^5.3.3", + "events": "^3.3.0", + "vite-plugin-static-copy": "^1.0.5", + "vue": "^3.4.29" + }, + "devDependencies": { + "@types/node": "^20.14.8", + "@vitejs/plugin-vue": "^5.0.5", + "sass": "^1.77.6", + "typescript": "^5.2.2", + "vite": "^5.3.1", + "vite-plugin-environment": "^1.1.3", + "vue-tsc": "^2.0.21" + } +} diff --git a/public/index.html b/public/index.html new file mode 100644 index 0000000..300a00b --- /dev/null +++ b/public/index.html @@ -0,0 +1,25 @@ + + + + + + + + Widget test + + + + + + + + + + + + + + \ No newline at end of file diff --git a/src/Widget.vue b/src/Widget.vue new file mode 100644 index 0000000..68175f3 --- /dev/null +++ b/src/Widget.vue @@ -0,0 +1,143 @@ + + + + + + \ No newline at end of file diff --git a/src/components/BTClock.vue b/src/components/BTClock.vue new file mode 100644 index 0000000..8fe5322 --- /dev/null +++ b/src/components/BTClock.vue @@ -0,0 +1,57 @@ + + + \ No newline at end of file diff --git a/src/dev.ts b/src/dev.ts new file mode 100644 index 0000000..0580d93 --- /dev/null +++ b/src/dev.ts @@ -0,0 +1,20 @@ +import { createApp } from 'vue'; +import Widget from './Widget.vue'; +import './styles/main.scss'; // Import global styles + +const mountDevWidget = () => { + const devRoot = document.getElementById('dev-root'); + if (devRoot) { + const app = createApp(Widget); + app.provide('Module', Module); + app.mount(devRoot); + } +}; + +mountDevWidget(); + +if (import.meta.hot) { + import.meta.hot.accept('./components/Widget.vue', () => { + mountDevWidget(); + }); +} diff --git a/src/js/btclock_datahandler.js b/src/js/btclock_datahandler.js new file mode 100644 index 0000000..ed01a4d --- /dev/null +++ b/src/js/btclock_datahandler.js @@ -0,0 +1,3014 @@ +// include: shell.js +// The Module object: Our interface to the outside world. We import +// and export values on it. There are various ways Module can be used: +// 1. Not defined. We create it here +// 2. A function parameter, function(moduleArg) => Promise +// 3. pre-run appended it, var Module = {}; ..generated code.. +// 4. External script tag defines var Module. +// We need to check if Module already exists (e.g. case 3 above). +// Substitution will be replaced with actual code on later stage of the build, +// this way Closure Compiler will not mangle it (e.g. case 4. above). +// Note that if you want to run closure, and also to use Module +// after the generated code, you will need to define var Module = {}; +// before the code. Then that object will be used in the code, and you +// can continue to use Module afterwards as well. +var Module = typeof Module != 'undefined' ? Module : {}; + +// Determine the runtime environment we are in. You can customize this by +// setting the ENVIRONMENT setting at compile time (see settings.js). + +// Attempt to auto-detect the environment +var ENVIRONMENT_IS_WEB = typeof window == 'object'; +var ENVIRONMENT_IS_WORKER = typeof importScripts == 'function'; +// N.b. Electron.js environment is simultaneously a NODE-environment, but +// also a web environment. +var ENVIRONMENT_IS_NODE = typeof process == 'object' && typeof process.versions == 'object' && typeof process.versions.node == 'string'; +var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER; + +if (Module['ENVIRONMENT']) { + throw new Error('Module.ENVIRONMENT has been deprecated. To force the environment, use the ENVIRONMENT compile-time option (for example, -sENVIRONMENT=web or -sENVIRONMENT=node)'); +} + +if (ENVIRONMENT_IS_NODE) { + // `require()` is no-op in an ESM module, use `createRequire()` to construct + // the require()` function. This is only necessary for multi-environment + // builds, `-sENVIRONMENT=node` emits a static import declaration instead. + // TODO: Swap all `require()`'s with `import()`'s? + +} + +// --pre-jses are emitted after the Module integration code, so that they can +// refer to Module (if they choose; they can also define Module) + + +// Sometimes an existing Module object exists with properties +// meant to overwrite the default module functionality. Here +// we collect those properties and reapply _after_ we configure +// the current environment's defaults to avoid having to be so +// defensive during initialization. +var moduleOverrides = Object.assign({}, Module); + +var arguments_ = []; +var thisProgram = './this.program'; +var quit_ = (status, toThrow) => { + throw toThrow; +}; + +// `/` should be present at the end if `scriptDirectory` is not empty +var scriptDirectory = ''; +function locateFile(path) { + if (Module['locateFile']) { + return Module['locateFile'](path, scriptDirectory); + } + return scriptDirectory + path; +} + +// Hooks that are implemented differently in different runtime environments. +var read_, + readAsync, + readBinary; + +if (ENVIRONMENT_IS_NODE) { + if (typeof process == 'undefined' || !process.release || process.release.name !== 'node') throw new Error('not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)'); + + var nodeVersion = process.versions.node; + var numericVersion = nodeVersion.split('.').slice(0, 3); + numericVersion = (numericVersion[0] * 10000) + (numericVersion[1] * 100) + (numericVersion[2].split('-')[0] * 1); + var minVersion = 160000; + if (numericVersion < 160000) { + throw new Error('This emscripten-generated code requires node v16.0.0 (detected v' + nodeVersion + ')'); + } + + // These modules will usually be used on Node.js. Load them eagerly to avoid + // the complexity of lazy-loading. + var fs = require('fs'); + var nodePath = require('path'); + + scriptDirectory = __dirname + '/'; + +// include: node_shell_read.js +read_ = (filename, binary) => { + // We need to re-wrap `file://` strings to URLs. Normalizing isn't + // necessary in that case, the path should already be absolute. + filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename); + return fs.readFileSync(filename, binary ? undefined : 'utf8'); +}; + +readBinary = (filename) => { + var ret = read_(filename, true); + if (!ret.buffer) { + ret = new Uint8Array(ret); + } + assert(ret.buffer); + return ret; +}; + +readAsync = (filename, onload, onerror, binary = true) => { + // See the comment in the `read_` function. + filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename); + fs.readFile(filename, binary ? undefined : 'utf8', (err, data) => { + if (err) onerror(err); + else onload(binary ? data.buffer : data); + }); +}; +// end include: node_shell_read.js + if (!Module['thisProgram'] && process.argv.length > 1) { + thisProgram = process.argv[1].replace(/\\/g, '/'); + } + + arguments_ = process.argv.slice(2); + + if (typeof module != 'undefined') { + module['exports'] = Module; + } + + process.on('uncaughtException', (ex) => { + // suppress ExitStatus exceptions from showing an error + if (ex !== 'unwind' && !(ex instanceof ExitStatus) && !(ex.context instanceof ExitStatus)) { + throw ex; + } + }); + + quit_ = (status, toThrow) => { + process.exitCode = status; + throw toThrow; + }; + +} else +if (ENVIRONMENT_IS_SHELL) { + + if ((typeof process == 'object' && typeof require === 'function') || typeof window == 'object' || typeof importScripts == 'function') throw new Error('not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)'); + +} else + +// Note that this includes Node.js workers when relevant (pthreads is enabled). +// Node.js workers are detected as a combination of ENVIRONMENT_IS_WORKER and +// ENVIRONMENT_IS_NODE. +if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) { + if (ENVIRONMENT_IS_WORKER) { // Check worker, not web, since window could be polyfilled + scriptDirectory = self.location.href; + } else if (typeof document != 'undefined' && document.currentScript) { // web + scriptDirectory = document.currentScript.src; + } + // blob urls look like blob:http://site.com/etc/etc and we cannot infer anything from them. + // otherwise, slice off the final part of the url to find the script directory. + // if scriptDirectory does not contain a slash, lastIndexOf will return -1, + // and scriptDirectory will correctly be replaced with an empty string. + // If scriptDirectory contains a query (starting with ?) or a fragment (starting with #), + // they are removed because they could contain a slash. + if (scriptDirectory.startsWith('blob:')) { + scriptDirectory = ''; + } else { + scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, '').lastIndexOf('/')+1); + } + + if (!(typeof window == 'object' || typeof importScripts == 'function')) throw new Error('not compiled for this environment (did you build to HTML and try to run it not on the web, or set ENVIRONMENT to something - like node - and run it someplace else - like on the web?)'); + + { +// include: web_or_worker_shell_read.js +read_ = (url) => { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, false); + xhr.send(null); + return xhr.responseText; + } + + if (ENVIRONMENT_IS_WORKER) { + readBinary = (url) => { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, false); + xhr.responseType = 'arraybuffer'; + xhr.send(null); + return new Uint8Array(/** @type{!ArrayBuffer} */(xhr.response)); + }; + } + + readAsync = (url, onload, onerror) => { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, true); + xhr.responseType = 'arraybuffer'; + xhr.onload = () => { + if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0 + onload(xhr.response); + return; + } + onerror(); + }; + xhr.onerror = onerror; + xhr.send(null); + } + +// end include: web_or_worker_shell_read.js + } +} else +{ + throw new Error('environment detection error'); +} + +var out = Module['print'] || console.log.bind(console); +var err = Module['printErr'] || console.error.bind(console); + +// Merge back in the overrides +Object.assign(Module, moduleOverrides); +// Free the object hierarchy contained in the overrides, this lets the GC +// reclaim data used. +moduleOverrides = null; +checkIncomingModuleAPI(); + +// Emit code to handle expected values on the Module object. This applies Module.x +// to the proper local x. This has two benefits: first, we only emit it if it is +// expected to arrive, and second, by using a local everywhere else that can be +// minified. + +if (Module['arguments']) arguments_ = Module['arguments'];legacyModuleProp('arguments', 'arguments_'); + +if (Module['thisProgram']) thisProgram = Module['thisProgram'];legacyModuleProp('thisProgram', 'thisProgram'); + +if (Module['quit']) quit_ = Module['quit'];legacyModuleProp('quit', 'quit_'); + +// perform assertions in shell.js after we set up out() and err(), as otherwise if an assertion fails it cannot print the message +// Assertions on removed incoming Module JS APIs. +assert(typeof Module['memoryInitializerPrefixURL'] == 'undefined', 'Module.memoryInitializerPrefixURL option was removed, use Module.locateFile instead'); +assert(typeof Module['pthreadMainPrefixURL'] == 'undefined', 'Module.pthreadMainPrefixURL option was removed, use Module.locateFile instead'); +assert(typeof Module['cdInitializerPrefixURL'] == 'undefined', 'Module.cdInitializerPrefixURL option was removed, use Module.locateFile instead'); +assert(typeof Module['filePackagePrefixURL'] == 'undefined', 'Module.filePackagePrefixURL option was removed, use Module.locateFile instead'); +assert(typeof Module['read'] == 'undefined', 'Module.read option was removed (modify read_ in JS)'); +assert(typeof Module['readAsync'] == 'undefined', 'Module.readAsync option was removed (modify readAsync in JS)'); +assert(typeof Module['readBinary'] == 'undefined', 'Module.readBinary option was removed (modify readBinary in JS)'); +assert(typeof Module['setWindowTitle'] == 'undefined', 'Module.setWindowTitle option was removed (modify emscripten_set_window_title in JS)'); +assert(typeof Module['TOTAL_MEMORY'] == 'undefined', 'Module.TOTAL_MEMORY has been renamed Module.INITIAL_MEMORY'); +legacyModuleProp('asm', 'wasmExports'); +legacyModuleProp('read', 'read_'); +legacyModuleProp('readAsync', 'readAsync'); +legacyModuleProp('readBinary', 'readBinary'); +legacyModuleProp('setWindowTitle', 'setWindowTitle'); +var IDBFS = 'IDBFS is no longer included by default; build with -lidbfs.js'; +var PROXYFS = 'PROXYFS is no longer included by default; build with -lproxyfs.js'; +var WORKERFS = 'WORKERFS is no longer included by default; build with -lworkerfs.js'; +var FETCHFS = 'FETCHFS is no longer included by default; build with -lfetchfs.js'; +var ICASEFS = 'ICASEFS is no longer included by default; build with -licasefs.js'; +var JSFILEFS = 'JSFILEFS is no longer included by default; build with -ljsfilefs.js'; +var OPFS = 'OPFS is no longer included by default; build with -lopfs.js'; + +var NODEFS = 'NODEFS is no longer included by default; build with -lnodefs.js'; + +assert(!ENVIRONMENT_IS_SHELL, 'shell environment detected but not enabled at build time. Add `shell` to `-sENVIRONMENT` to enable.'); + +// end include: shell.js + +// include: preamble.js +// === Preamble library stuff === + +// Documentation for the public APIs defined in this file must be updated in: +// site/source/docs/api_reference/preamble.js.rst +// A prebuilt local version of the documentation is available at: +// site/build/text/docs/api_reference/preamble.js.txt +// You can also build docs locally as HTML or other formats in site/ +// An online HTML version (which may be of a different version of Emscripten) +// is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html + +var wasmBinary; +if (Module['wasmBinary']) wasmBinary = Module['wasmBinary'];legacyModuleProp('wasmBinary', 'wasmBinary'); + +if (typeof WebAssembly != 'object') { + err('no native wasm support detected'); +} + +// Wasm globals + +var wasmMemory; + +//======================================== +// Runtime essentials +//======================================== + +// whether we are quitting the application. no code should run after this. +// set in exit() and abort() +var ABORT = false; + +// set by exit() and abort(). Passed to 'onExit' handler. +// NOTE: This is also used as the process return code code in shell environments +// but only when noExitRuntime is false. +var EXITSTATUS; + +// In STRICT mode, we only define assert() when ASSERTIONS is set. i.e. we +// don't define it at all in release modes. This matches the behaviour of +// MINIMAL_RUNTIME. +// TODO(sbc): Make this the default even without STRICT enabled. +/** @type {function(*, string=)} */ +function assert(condition, text) { + if (!condition) { + abort('Assertion failed' + (text ? ': ' + text : '')); + } +} + +// We used to include malloc/free by default in the past. Show a helpful error in +// builds with assertions. + +// Memory management + +var HEAP, +/** @type {!Int8Array} */ + HEAP8, +/** @type {!Uint8Array} */ + HEAPU8, +/** @type {!Int16Array} */ + HEAP16, +/** @type {!Uint16Array} */ + HEAPU16, +/** @type {!Int32Array} */ + HEAP32, +/** @type {!Uint32Array} */ + HEAPU32, +/** @type {!Float32Array} */ + HEAPF32, +/** @type {!Float64Array} */ + HEAPF64; + +// include: runtime_shared.js +function updateMemoryViews() { + var b = wasmMemory.buffer; + Module['HEAP8'] = HEAP8 = new Int8Array(b); + Module['HEAP16'] = HEAP16 = new Int16Array(b); + Module['HEAPU8'] = HEAPU8 = new Uint8Array(b); + Module['HEAPU16'] = HEAPU16 = new Uint16Array(b); + Module['HEAP32'] = HEAP32 = new Int32Array(b); + Module['HEAPU32'] = HEAPU32 = new Uint32Array(b); + Module['HEAPF32'] = HEAPF32 = new Float32Array(b); + Module['HEAPF64'] = HEAPF64 = new Float64Array(b); +} +// end include: runtime_shared.js +assert(!Module['STACK_SIZE'], 'STACK_SIZE can no longer be set at runtime. Use -sSTACK_SIZE at link time') + +assert(typeof Int32Array != 'undefined' && typeof Float64Array !== 'undefined' && Int32Array.prototype.subarray != undefined && Int32Array.prototype.set != undefined, + 'JS engine does not provide full typed array support'); + +// If memory is defined in wasm, the user can't provide it, or set INITIAL_MEMORY +assert(!Module['wasmMemory'], 'Use of `wasmMemory` detected. Use -sIMPORTED_MEMORY to define wasmMemory externally'); +assert(!Module['INITIAL_MEMORY'], 'Detected runtime INITIAL_MEMORY setting. Use -sIMPORTED_MEMORY to define wasmMemory dynamically'); + +// include: runtime_stack_check.js +// Initializes the stack cookie. Called at the startup of main and at the startup of each thread in pthreads mode. +function writeStackCookie() { + var max = _emscripten_stack_get_end(); + assert((max & 3) == 0); + // If the stack ends at address zero we write our cookies 4 bytes into the + // stack. This prevents interference with SAFE_HEAP and ASAN which also + // monitor writes to address zero. + if (max == 0) { + max += 4; + } + // The stack grow downwards towards _emscripten_stack_get_end. + // We write cookies to the final two words in the stack and detect if they are + // ever overwritten. + HEAPU32[((max)>>2)] = 0x02135467; + HEAPU32[(((max)+(4))>>2)] = 0x89BACDFE; + // Also test the global address 0 for integrity. + HEAPU32[((0)>>2)] = 1668509029; +} + +function checkStackCookie() { + if (ABORT) return; + var max = _emscripten_stack_get_end(); + // See writeStackCookie(). + if (max == 0) { + max += 4; + } + var cookie1 = HEAPU32[((max)>>2)]; + var cookie2 = HEAPU32[(((max)+(4))>>2)]; + if (cookie1 != 0x02135467 || cookie2 != 0x89BACDFE) { + abort(`Stack overflow! Stack cookie has been overwritten at ${ptrToString(max)}, expected hex dwords 0x89BACDFE and 0x2135467, but received ${ptrToString(cookie2)} ${ptrToString(cookie1)}`); + } + // Also test the global address 0 for integrity. + if (HEAPU32[((0)>>2)] != 0x63736d65 /* 'emsc' */) { + abort('Runtime error: The application has corrupted its heap memory area (address zero)!'); + } +} +// end include: runtime_stack_check.js +// include: runtime_assertions.js +// Endianness check +(function() { + var h16 = new Int16Array(1); + var h8 = new Int8Array(h16.buffer); + h16[0] = 0x6373; + if (h8[0] !== 0x73 || h8[1] !== 0x63) throw 'Runtime error: expected the system to be little-endian! (Run with -sSUPPORT_BIG_ENDIAN to bypass)'; +})(); + +// end include: runtime_assertions.js +var __ATPRERUN__ = []; // functions called before the runtime is initialized +var __ATINIT__ = []; // functions called during startup +var __ATEXIT__ = []; // functions called during shutdown +var __ATPOSTRUN__ = []; // functions called after the main() is called + +var runtimeInitialized = false; + +function preRun() { + if (Module['preRun']) { + if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']]; + while (Module['preRun'].length) { + addOnPreRun(Module['preRun'].shift()); + } + } + callRuntimeCallbacks(__ATPRERUN__); +} + +function initRuntime() { + assert(!runtimeInitialized); + runtimeInitialized = true; + + checkStackCookie(); + + + callRuntimeCallbacks(__ATINIT__); +} + +function postRun() { + checkStackCookie(); + + if (Module['postRun']) { + if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']]; + while (Module['postRun'].length) { + addOnPostRun(Module['postRun'].shift()); + } + } + + callRuntimeCallbacks(__ATPOSTRUN__); +} + +function addOnPreRun(cb) { + __ATPRERUN__.unshift(cb); +} + +function addOnInit(cb) { + __ATINIT__.unshift(cb); +} + +function addOnExit(cb) { +} + +function addOnPostRun(cb) { + __ATPOSTRUN__.unshift(cb); +} + +// include: runtime_math.js +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul + +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/fround + +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32 + +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc + +assert(Math.imul, 'This browser does not support Math.imul(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill'); +assert(Math.fround, 'This browser does not support Math.fround(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill'); +assert(Math.clz32, 'This browser does not support Math.clz32(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill'); +assert(Math.trunc, 'This browser does not support Math.trunc(), build with LEGACY_VM_SUPPORT or POLYFILL_OLD_MATH_FUNCTIONS to add in a polyfill'); +// end include: runtime_math.js +// A counter of dependencies for calling run(). If we need to +// do asynchronous work before running, increment this and +// decrement it. Incrementing must happen in a place like +// Module.preRun (used by emcc to add file preloading). +// Note that you can add dependencies in preRun, even though +// it happens right before run - run will be postponed until +// the dependencies are met. +var runDependencies = 0; +var runDependencyWatcher = null; +var dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled +var runDependencyTracking = {}; + +function getUniqueRunDependency(id) { + var orig = id; + while (1) { + if (!runDependencyTracking[id]) return id; + id = orig + Math.random(); + } +} + +function addRunDependency(id) { + runDependencies++; + + Module['monitorRunDependencies']?.(runDependencies); + + if (id) { + assert(!runDependencyTracking[id]); + runDependencyTracking[id] = 1; + if (runDependencyWatcher === null && typeof setInterval != 'undefined') { + // Check for missing dependencies every few seconds + runDependencyWatcher = setInterval(() => { + if (ABORT) { + clearInterval(runDependencyWatcher); + runDependencyWatcher = null; + return; + } + var shown = false; + for (var dep in runDependencyTracking) { + if (!shown) { + shown = true; + err('still waiting on run dependencies:'); + } + err(`dependency: ${dep}`); + } + if (shown) { + err('(end of list)'); + } + }, 10000); + } + } else { + err('warning: run dependency added without ID'); + } +} + +function removeRunDependency(id) { + runDependencies--; + + Module['monitorRunDependencies']?.(runDependencies); + + if (id) { + assert(runDependencyTracking[id]); + delete runDependencyTracking[id]; + } else { + err('warning: run dependency removed without ID'); + } + if (runDependencies == 0) { + if (runDependencyWatcher !== null) { + clearInterval(runDependencyWatcher); + runDependencyWatcher = null; + } + if (dependenciesFulfilled) { + var callback = dependenciesFulfilled; + dependenciesFulfilled = null; + callback(); // can add another dependenciesFulfilled + } + } +} + +/** @param {string|number=} what */ +function abort(what) { + Module['onAbort']?.(what); + + what = 'Aborted(' + what + ')'; + // TODO(sbc): Should we remove printing and leave it up to whoever + // catches the exception? + err(what); + + ABORT = true; + EXITSTATUS = 1; + + // Use a wasm runtime error, because a JS error might be seen as a foreign + // exception, which means we'd run destructors on it. We need the error to + // simply make the program stop. + // FIXME This approach does not work in Wasm EH because it currently does not assume + // all RuntimeErrors are from traps; it decides whether a RuntimeError is from + // a trap or not based on a hidden field within the object. So at the moment + // we don't have a way of throwing a wasm trap from JS. TODO Make a JS API that + // allows this in the wasm spec. + + // Suppress closure compiler warning here. Closure compiler's builtin extern + // definition for WebAssembly.RuntimeError claims it takes no arguments even + // though it can. + // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure gets fixed. + /** @suppress {checkTypes} */ + var e = new WebAssembly.RuntimeError(what); + + // Throw the error whether or not MODULARIZE is set because abort is used + // in code paths apart from instantiation where an exception is expected + // to be thrown when abort is called. + throw e; +} + +// include: memoryprofiler.js +// end include: memoryprofiler.js +// show errors on likely calls to FS when it was not included +var FS = { + error() { + abort('Filesystem support (FS) was not included. The problem is that you are using files from JS, but files were not used from C/C++, so filesystem support was not auto-included. You can force-include filesystem support with -sFORCE_FILESYSTEM'); + }, + init() { FS.error() }, + createDataFile() { FS.error() }, + createPreloadedFile() { FS.error() }, + createLazyFile() { FS.error() }, + open() { FS.error() }, + mkdev() { FS.error() }, + registerDevice() { FS.error() }, + analyzePath() { FS.error() }, + + ErrnoError() { FS.error() }, +}; +Module['FS_createDataFile'] = FS.createDataFile; +Module['FS_createPreloadedFile'] = FS.createPreloadedFile; + +// include: URIUtils.js +// Prefix of data URIs emitted by SINGLE_FILE and related options. +var dataURIPrefix = 'data:application/octet-stream;base64,'; + +/** + * Indicates whether filename is a base64 data URI. + * @noinline + */ +var isDataURI = (filename) => filename.startsWith(dataURIPrefix); + +/** + * Indicates whether filename is delivered via file protocol (as opposed to http/https) + * @noinline + */ +var isFileURI = (filename) => filename.startsWith('file://'); +// end include: URIUtils.js +function createExportWrapper(name, nargs) { + return (...args) => { + assert(runtimeInitialized, `native function \`${name}\` called before runtime initialization`); + var f = wasmExports[name]; + assert(f, `exported native function \`${name}\` not found`); + // Only assert for too many arguments. Too few can be valid since the missing arguments will be zero filled. + assert(args.length <= nargs, `native function \`${name}\` called with ${args.length} args but expects ${nargs}`); + return f(...args); + }; +} + +// include: runtime_exceptions.js +// end include: runtime_exceptions.js +function findWasmBinary() { + var f = 'btclock_datahandler.wasm'; + if (!isDataURI(f)) { + return locateFile(f); + } + return f; +} + +var wasmBinaryFile; + +function getBinarySync(file) { + if (file == wasmBinaryFile && wasmBinary) { + return new Uint8Array(wasmBinary); + } + if (readBinary) { + return readBinary(file); + } + throw 'both async and sync fetching of the wasm failed'; +} + +function getBinaryPromise(binaryFile) { + // If we don't have the binary yet, try to load it asynchronously. + // Fetch has some additional restrictions over XHR, like it can't be used on a file:// url. + // See https://github.com/github/fetch/pull/92#issuecomment-140665932 + // Cordova or Electron apps are typically loaded from a file:// url. + // So use fetch if it is available and the url is not a file, otherwise fall back to XHR. + if (!wasmBinary + && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) { + if (typeof fetch == 'function' + && !isFileURI(binaryFile) + ) { + return fetch(binaryFile, { credentials: 'same-origin' }).then((response) => { + if (!response['ok']) { + throw `failed to load wasm binary file at '${binaryFile}'`; + } + return response['arrayBuffer'](); + }).catch(() => getBinarySync(binaryFile)); + } + else if (readAsync) { + // fetch is not available or url is file => try XHR (readAsync uses XHR internally) + return new Promise((resolve, reject) => { + readAsync(binaryFile, (response) => resolve(new Uint8Array(/** @type{!ArrayBuffer} */(response))), reject) + }); + } + } + + // Otherwise, getBinarySync should be able to get it synchronously + return Promise.resolve().then(() => getBinarySync(binaryFile)); +} + +function instantiateArrayBuffer(binaryFile, imports, receiver) { + return getBinaryPromise(binaryFile).then((binary) => { + return WebAssembly.instantiate(binary, imports); + }).then(receiver, (reason) => { + err(`failed to asynchronously prepare wasm: ${reason}`); + + // Warn on some common problems. + if (isFileURI(wasmBinaryFile)) { + err(`warning: Loading from a file URI (${wasmBinaryFile}) is not supported in most browsers. See https://emscripten.org/docs/getting_started/FAQ.html#how-do-i-run-a-local-webserver-for-testing-why-does-my-program-stall-in-downloading-or-preparing`); + } + abort(reason); + }); +} + +function instantiateAsync(binary, binaryFile, imports, callback) { + if (!binary && + typeof WebAssembly.instantiateStreaming == 'function' && + !isDataURI(binaryFile) && + // Don't use streaming for file:// delivered objects in a webview, fetch them synchronously. + !isFileURI(binaryFile) && + // Avoid instantiateStreaming() on Node.js environment for now, as while + // Node.js v18.1.0 implements it, it does not have a full fetch() + // implementation yet. + // + // Reference: + // https://github.com/emscripten-core/emscripten/pull/16917 + !ENVIRONMENT_IS_NODE && + typeof fetch == 'function') { + return fetch(binaryFile, { credentials: 'same-origin' }).then((response) => { + // Suppress closure warning here since the upstream definition for + // instantiateStreaming only allows Promise rather than + // an actual Response. + // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure is fixed. + /** @suppress {checkTypes} */ + var result = WebAssembly.instantiateStreaming(response, imports); + + return result.then( + callback, + function(reason) { + // We expect the most common failure cause to be a bad MIME type for the binary, + // in which case falling back to ArrayBuffer instantiation should work. + err(`wasm streaming compile failed: ${reason}`); + err('falling back to ArrayBuffer instantiation'); + return instantiateArrayBuffer(binaryFile, imports, callback); + }); + }); + } + return instantiateArrayBuffer(binaryFile, imports, callback); +} + +function getWasmImports() { + // prepare imports + return { + 'env': wasmImports, + 'wasi_snapshot_preview1': wasmImports, + } +} + +// Create the wasm instance. +// Receives the wasm imports, returns the exports. +function createWasm() { + var info = getWasmImports(); + // Load the wasm module and create an instance of using native support in the JS engine. + // handle a generated wasm instance, receiving its exports and + // performing other necessary setup + /** @param {WebAssembly.Module=} module*/ + function receiveInstance(instance, module) { + wasmExports = instance.exports; + + + + wasmMemory = wasmExports['memory']; + + assert(wasmMemory, 'memory not found in wasm exports'); + updateMemoryViews(); + + wasmTable = wasmExports['__indirect_function_table']; + + assert(wasmTable, 'table not found in wasm exports'); + + addOnInit(wasmExports['__wasm_call_ctors']); + + removeRunDependency('wasm-instantiate'); + return wasmExports; + } + // wait for the pthread pool (if any) + addRunDependency('wasm-instantiate'); + + // Prefer streaming instantiation if available. + // Async compilation can be confusing when an error on the page overwrites Module + // (for example, if the order of elements is wrong, and the one defining Module is + // later), so we save Module and check it later. + var trueModule = Module; + function receiveInstantiationResult(result) { + // 'result' is a ResultObject object which has both the module and instance. + // receiveInstance() will swap in the exports (to Module.asm) so they can be called + assert(Module === trueModule, 'the Module object should not be replaced during async compilation - perhaps the order of HTML elements is wrong?'); + trueModule = null; + // TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line. + // When the regression is fixed, can restore the above PTHREADS-enabled path. + receiveInstance(result['instance']); + } + + // User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback + // to manually instantiate the Wasm module themselves. This allows pages to + // run the instantiation parallel to any other async startup actions they are + // performing. + // Also pthreads and wasm workers initialize the wasm instance through this + // path. + if (Module['instantiateWasm']) { + try { + return Module['instantiateWasm'](info, receiveInstance); + } catch(e) { + err(`Module.instantiateWasm callback failed with error: ${e}`); + return false; + } + } + + if (!wasmBinaryFile) wasmBinaryFile = findWasmBinary(); + + instantiateAsync(wasmBinary, wasmBinaryFile, info, receiveInstantiationResult); + return {}; // no exports yet; we'll fill them in later +} + +// Globals used by JS i64 conversions (see makeSetValue) +var tempDouble; +var tempI64; + +// include: runtime_debug.js +function legacyModuleProp(prop, newName, incoming=true) { + if (!Object.getOwnPropertyDescriptor(Module, prop)) { + Object.defineProperty(Module, prop, { + configurable: true, + get() { + let extra = incoming ? ' (the initial value can be provided on Module, but after startup the value is only looked for on a local variable of that name)' : ''; + abort(`\`Module.${prop}\` has been replaced by \`${newName}\`` + extra); + + } + }); + } +} + +function ignoredModuleProp(prop) { + if (Object.getOwnPropertyDescriptor(Module, prop)) { + abort(`\`Module.${prop}\` was supplied but \`${prop}\` not included in INCOMING_MODULE_JS_API`); + } +} + +// forcing the filesystem exports a few things by default +function isExportedByForceFilesystem(name) { + return name === 'FS_createPath' || + name === 'FS_createDataFile' || + name === 'FS_createPreloadedFile' || + name === 'FS_unlink' || + name === 'addRunDependency' || + // The old FS has some functionality that WasmFS lacks. + name === 'FS_createLazyFile' || + name === 'FS_createDevice' || + name === 'removeRunDependency'; +} + +function missingGlobal(sym, msg) { + if (typeof globalThis != 'undefined') { + Object.defineProperty(globalThis, sym, { + configurable: true, + get() { + warnOnce(`\`${sym}\` is not longer defined by emscripten. ${msg}`); + return undefined; + } + }); + } +} + +missingGlobal('buffer', 'Please use HEAP8.buffer or wasmMemory.buffer'); +missingGlobal('asm', 'Please use wasmExports instead'); + +function missingLibrarySymbol(sym) { + if (typeof globalThis != 'undefined' && !Object.getOwnPropertyDescriptor(globalThis, sym)) { + Object.defineProperty(globalThis, sym, { + configurable: true, + get() { + // Can't `abort()` here because it would break code that does runtime + // checks. e.g. `if (typeof SDL === 'undefined')`. + var msg = `\`${sym}\` is a library symbol and not included by default; add it to your library.js __deps or to DEFAULT_LIBRARY_FUNCS_TO_INCLUDE on the command line`; + // DEFAULT_LIBRARY_FUNCS_TO_INCLUDE requires the name as it appears in + // library.js, which means $name for a JS name with no prefix, or name + // for a JS name like _name. + var librarySymbol = sym; + if (!librarySymbol.startsWith('_')) { + librarySymbol = '$' + sym; + } + msg += ` (e.g. -sDEFAULT_LIBRARY_FUNCS_TO_INCLUDE='${librarySymbol}')`; + if (isExportedByForceFilesystem(sym)) { + msg += '. Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you'; + } + warnOnce(msg); + return undefined; + } + }); + } + // Any symbol that is not included from the JS library is also (by definition) + // not exported on the Module object. + unexportedRuntimeSymbol(sym); +} + +function unexportedRuntimeSymbol(sym) { + if (!Object.getOwnPropertyDescriptor(Module, sym)) { + Object.defineProperty(Module, sym, { + configurable: true, + get() { + var msg = `'${sym}' was not exported. add it to EXPORTED_RUNTIME_METHODS (see the Emscripten FAQ)`; + if (isExportedByForceFilesystem(sym)) { + msg += '. Alternatively, forcing filesystem support (-sFORCE_FILESYSTEM) can export this for you'; + } + abort(msg); + } + }); + } +} + +// Used by XXXXX_DEBUG settings to output debug messages. +function dbg(...args) { + // TODO(sbc): Make this configurable somehow. Its not always convenient for + // logging to show up as warnings. + console.warn(...args); +} +// end include: runtime_debug.js +// === Body === +// end include: preamble.js + + + /** @constructor */ + function ExitStatus(status) { + this.name = 'ExitStatus'; + this.message = `Program terminated with exit(${status})`; + this.status = status; + } + + var callRuntimeCallbacks = (callbacks) => { + while (callbacks.length > 0) { + // Pass the module as the first argument. + callbacks.shift()(Module); + } + }; + + + /** + * @param {number} ptr + * @param {string} type + */ + function getValue(ptr, type = 'i8') { + if (type.endsWith('*')) type = '*'; + switch (type) { + case 'i1': return HEAP8[ptr]; + case 'i8': return HEAP8[ptr]; + case 'i16': return HEAP16[((ptr)>>1)]; + case 'i32': return HEAP32[((ptr)>>2)]; + case 'i64': abort('to do getValue(i64) use WASM_BIGINT'); + case 'float': return HEAPF32[((ptr)>>2)]; + case 'double': return HEAPF64[((ptr)>>3)]; + case '*': return HEAPU32[((ptr)>>2)]; + default: abort(`invalid type for getValue: ${type}`); + } + } + + var noExitRuntime = Module['noExitRuntime'] || true; + + var ptrToString = (ptr) => { + assert(typeof ptr === 'number'); + // With CAN_ADDRESS_2GB or MEMORY64, pointers are already unsigned. + ptr >>>= 0; + return '0x' + ptr.toString(16).padStart(8, '0'); + }; + + + /** + * @param {number} ptr + * @param {number} value + * @param {string} type + */ + function setValue(ptr, value, type = 'i8') { + if (type.endsWith('*')) type = '*'; + switch (type) { + case 'i1': HEAP8[ptr] = value; break; + case 'i8': HEAP8[ptr] = value; break; + case 'i16': HEAP16[((ptr)>>1)] = value; break; + case 'i32': HEAP32[((ptr)>>2)] = value; break; + case 'i64': abort('to do setValue(i64) use WASM_BIGINT'); + case 'float': HEAPF32[((ptr)>>2)] = value; break; + case 'double': HEAPF64[((ptr)>>3)] = value; break; + case '*': HEAPU32[((ptr)>>2)] = value; break; + default: abort(`invalid type for setValue: ${type}`); + } + } + + var stackRestore = (val) => __emscripten_stack_restore(val); + + var stackSave = () => _emscripten_stack_get_current(); + + var warnOnce = (text) => { + warnOnce.shown ||= {}; + if (!warnOnce.shown[text]) { + warnOnce.shown[text] = 1; + if (ENVIRONMENT_IS_NODE) text = 'warning: ' + text; + err(text); + } + }; + + var UTF8Decoder = typeof TextDecoder != 'undefined' ? new TextDecoder('utf8') : undefined; + + /** + * Given a pointer 'idx' to a null-terminated UTF8-encoded string in the given + * array that contains uint8 values, returns a copy of that string as a + * Javascript String object. + * heapOrArray is either a regular array, or a JavaScript typed array view. + * @param {number} idx + * @param {number=} maxBytesToRead + * @return {string} + */ + var UTF8ArrayToString = (heapOrArray, idx, maxBytesToRead) => { + var endIdx = idx + maxBytesToRead; + var endPtr = idx; + // TextDecoder needs to know the byte length in advance, it doesn't stop on + // null terminator by itself. Also, use the length info to avoid running tiny + // strings through TextDecoder, since .subarray() allocates garbage. + // (As a tiny code save trick, compare endPtr against endIdx using a negation, + // so that undefined means Infinity) + while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr; + + if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) { + return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr)); + } + var str = ''; + // If building with TextDecoder, we have already computed the string length + // above, so test loop end condition against that + while (idx < endPtr) { + // For UTF8 byte structure, see: + // http://en.wikipedia.org/wiki/UTF-8#Description + // https://www.ietf.org/rfc/rfc2279.txt + // https://tools.ietf.org/html/rfc3629 + var u0 = heapOrArray[idx++]; + if (!(u0 & 0x80)) { str += String.fromCharCode(u0); continue; } + var u1 = heapOrArray[idx++] & 63; + if ((u0 & 0xE0) == 0xC0) { str += String.fromCharCode(((u0 & 31) << 6) | u1); continue; } + var u2 = heapOrArray[idx++] & 63; + if ((u0 & 0xF0) == 0xE0) { + u0 = ((u0 & 15) << 12) | (u1 << 6) | u2; + } else { + if ((u0 & 0xF8) != 0xF0) warnOnce('Invalid UTF-8 leading byte ' + ptrToString(u0) + ' encountered when deserializing a UTF-8 string in wasm memory to a JS string!'); + u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[idx++] & 63); + } + + if (u0 < 0x10000) { + str += String.fromCharCode(u0); + } else { + var ch = u0 - 0x10000; + str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF)); + } + } + return str; + }; + + /** + * Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the + * emscripten HEAP, returns a copy of that string as a Javascript String object. + * + * @param {number} ptr + * @param {number=} maxBytesToRead - An optional length that specifies the + * maximum number of bytes to read. You can omit this parameter to scan the + * string until the first 0 byte. If maxBytesToRead is passed, and the string + * at [ptr, ptr+maxBytesToReadr[ contains a null byte in the middle, then the + * string will cut short at that byte index (i.e. maxBytesToRead will not + * produce a string of exact length [ptr, ptr+maxBytesToRead[) N.B. mixing + * frequent uses of UTF8ToString() with and without maxBytesToRead may throw + * JS JIT optimizations off, so it is worth to consider consistently using one + * @return {string} + */ + var UTF8ToString = (ptr, maxBytesToRead) => { + assert(typeof ptr == 'number', `UTF8ToString expects a number (got ${typeof ptr})`); + return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : ''; + }; + var ___assert_fail = (condition, filename, line, func) => { + abort(`Assertion failed: ${UTF8ToString(condition)}, at: ` + [filename ? UTF8ToString(filename) : 'unknown filename', line, func ? UTF8ToString(func) : 'unknown function']); + }; + + var __abort_js = () => { + abort('native code called abort()'); + }; + + var __embind_register_bigint = (primitiveType, name, size, minRange, maxRange) => {}; + + var embind_init_charCodes = () => { + var codes = new Array(256); + for (var i = 0; i < 256; ++i) { + codes[i] = String.fromCharCode(i); + } + embind_charCodes = codes; + }; + var embind_charCodes; + var readLatin1String = (ptr) => { + var ret = ""; + var c = ptr; + while (HEAPU8[c]) { + ret += embind_charCodes[HEAPU8[c++]]; + } + return ret; + }; + + var awaitingDependencies = { + }; + + var registeredTypes = { + }; + + var typeDependencies = { + }; + + var BindingError; + var throwBindingError = (message) => { throw new BindingError(message); }; + + + + + var InternalError; + var throwInternalError = (message) => { throw new InternalError(message); }; + var whenDependentTypesAreResolved = (myTypes, dependentTypes, getTypeConverters) => { + myTypes.forEach(function(type) { + typeDependencies[type] = dependentTypes; + }); + + function onComplete(typeConverters) { + var myTypeConverters = getTypeConverters(typeConverters); + if (myTypeConverters.length !== myTypes.length) { + throwInternalError('Mismatched type converter count'); + } + for (var i = 0; i < myTypes.length; ++i) { + registerType(myTypes[i], myTypeConverters[i]); + } + } + + var typeConverters = new Array(dependentTypes.length); + var unregisteredTypes = []; + var registered = 0; + dependentTypes.forEach((dt, i) => { + if (registeredTypes.hasOwnProperty(dt)) { + typeConverters[i] = registeredTypes[dt]; + } else { + unregisteredTypes.push(dt); + if (!awaitingDependencies.hasOwnProperty(dt)) { + awaitingDependencies[dt] = []; + } + awaitingDependencies[dt].push(() => { + typeConverters[i] = registeredTypes[dt]; + ++registered; + if (registered === unregisteredTypes.length) { + onComplete(typeConverters); + } + }); + } + }); + if (0 === unregisteredTypes.length) { + onComplete(typeConverters); + } + }; + /** @param {Object=} options */ + function sharedRegisterType(rawType, registeredInstance, options = {}) { + var name = registeredInstance.name; + if (!rawType) { + throwBindingError(`type "${name}" must have a positive integer typeid pointer`); + } + if (registeredTypes.hasOwnProperty(rawType)) { + if (options.ignoreDuplicateRegistrations) { + return; + } else { + throwBindingError(`Cannot register type '${name}' twice`); + } + } + + registeredTypes[rawType] = registeredInstance; + delete typeDependencies[rawType]; + + if (awaitingDependencies.hasOwnProperty(rawType)) { + var callbacks = awaitingDependencies[rawType]; + delete awaitingDependencies[rawType]; + callbacks.forEach((cb) => cb()); + } + } + /** @param {Object=} options */ + function registerType(rawType, registeredInstance, options = {}) { + if (!('argPackAdvance' in registeredInstance)) { + throw new TypeError('registerType registeredInstance requires argPackAdvance'); + } + return sharedRegisterType(rawType, registeredInstance, options); + } + + var GenericWireTypeSize = 8; + /** @suppress {globalThis} */ + var __embind_register_bool = (rawType, name, trueValue, falseValue) => { + name = readLatin1String(name); + registerType(rawType, { + name, + 'fromWireType': function(wt) { + // ambiguous emscripten ABI: sometimes return values are + // true or false, and sometimes integers (0 or 1) + return !!wt; + }, + 'toWireType': function(destructors, o) { + return o ? trueValue : falseValue; + }, + 'argPackAdvance': GenericWireTypeSize, + 'readValueFromPointer': function(pointer) { + return this['fromWireType'](HEAPU8[pointer]); + }, + destructorFunction: null, // This type does not need a destructor + }); + }; + + + var emval_freelist = []; + + var emval_handles = []; + var __emval_decref = (handle) => { + if (handle > 9 && 0 === --emval_handles[handle + 1]) { + assert(emval_handles[handle] !== undefined, `Decref for unallocated handle.`); + emval_handles[handle] = undefined; + emval_freelist.push(handle); + } + }; + + + + + + var count_emval_handles = () => { + return emval_handles.length / 2 - 5 - emval_freelist.length; + }; + + var init_emval = () => { + // reserve 0 and some special values. These never get de-allocated. + emval_handles.push( + 0, 1, + undefined, 1, + null, 1, + true, 1, + false, 1, + ); + assert(emval_handles.length === 5 * 2); + Module['count_emval_handles'] = count_emval_handles; + }; + var Emval = { + toValue:(handle) => { + if (!handle) { + throwBindingError('Cannot use deleted val. handle = ' + handle); + } + // handle 2 is supposed to be `undefined`. + assert(handle === 2 || emval_handles[handle] !== undefined && handle % 2 === 0, `invalid handle: ${handle}`); + return emval_handles[handle]; + }, + toHandle:(value) => { + switch (value) { + case undefined: return 2; + case null: return 4; + case true: return 6; + case false: return 8; + default:{ + const handle = emval_freelist.pop() || emval_handles.length; + emval_handles[handle] = value; + emval_handles[handle + 1] = 1; + return handle; + } + } + }, + }; + + /** @suppress {globalThis} */ + function readPointer(pointer) { + return this['fromWireType'](HEAPU32[((pointer)>>2)]); + } + + var EmValType = { + name: 'emscripten::val', + 'fromWireType': (handle) => { + var rv = Emval.toValue(handle); + __emval_decref(handle); + return rv; + }, + 'toWireType': (destructors, value) => Emval.toHandle(value), + 'argPackAdvance': GenericWireTypeSize, + 'readValueFromPointer': readPointer, + destructorFunction: null, // This type does not need a destructor + + // TODO: do we need a deleteObject here? write a test where + // emval is passed into JS via an interface + }; + var __embind_register_emval = (rawType) => registerType(rawType, EmValType); + + var embindRepr = (v) => { + if (v === null) { + return 'null'; + } + var t = typeof v; + if (t === 'object' || t === 'array' || t === 'function') { + return v.toString(); + } else { + return '' + v; + } + }; + + var floatReadValueFromPointer = (name, width) => { + switch (width) { + case 4: return function(pointer) { + return this['fromWireType'](HEAPF32[((pointer)>>2)]); + }; + case 8: return function(pointer) { + return this['fromWireType'](HEAPF64[((pointer)>>3)]); + }; + default: + throw new TypeError(`invalid float width (${width}): ${name}`); + } + }; + + + var __embind_register_float = (rawType, name, size) => { + name = readLatin1String(name); + registerType(rawType, { + name, + 'fromWireType': (value) => value, + 'toWireType': (destructors, value) => { + if (typeof value != "number" && typeof value != "boolean") { + throw new TypeError(`Cannot convert ${embindRepr(value)} to ${this.name}`); + } + // The VM will perform JS to Wasm value conversion, according to the spec: + // https://www.w3.org/TR/wasm-js-api-1/#towebassemblyvalue + return value; + }, + 'argPackAdvance': GenericWireTypeSize, + 'readValueFromPointer': floatReadValueFromPointer(name, size), + destructorFunction: null, // This type does not need a destructor + }); + }; + + var createNamedFunction = (name, body) => Object.defineProperty(body, 'name', { + value: name + }); + + var runDestructors = (destructors) => { + while (destructors.length) { + var ptr = destructors.pop(); + var del = destructors.pop(); + del(ptr); + } + }; + + + function usesDestructorStack(argTypes) { + // Skip return value at index 0 - it's not deleted here. + for (var i = 1; i < argTypes.length; ++i) { + // The type does not define a destructor function - must use dynamic stack + if (argTypes[i] !== null && argTypes[i].destructorFunction === undefined) { + return true; + } + } + return false; + } + + function newFunc(constructor, argumentList) { + if (!(constructor instanceof Function)) { + throw new TypeError(`new_ called with constructor type ${typeof(constructor)} which is not a function`); + } + /* + * Previously, the following line was just: + * function dummy() {}; + * Unfortunately, Chrome was preserving 'dummy' as the object's name, even + * though at creation, the 'dummy' has the correct constructor name. Thus, + * objects created with IMVU.new would show up in the debugger as 'dummy', + * which isn't very helpful. Using IMVU.createNamedFunction addresses the + * issue. Doubly-unfortunately, there's no way to write a test for this + * behavior. -NRD 2013.02.22 + */ + var dummy = createNamedFunction(constructor.name || 'unknownFunctionName', function(){}); + dummy.prototype = constructor.prototype; + var obj = new dummy; + + var r = constructor.apply(obj, argumentList); + return (r instanceof Object) ? r : obj; + } + + function createJsInvoker(argTypes, isClassMethodFunc, returns, isAsync) { + var needsDestructorStack = usesDestructorStack(argTypes); + var argCount = argTypes.length; + var argsList = ""; + var argsListWired = ""; + for (var i = 0; i < argCount - 2; ++i) { + argsList += (i!==0?", ":"")+"arg"+i; + argsListWired += (i!==0?", ":"")+"arg"+i+"Wired"; + } + + var invokerFnBody = ` + return function (${argsList}) { + if (arguments.length !== ${argCount - 2}) { + throwBindingError('function ' + humanName + ' called with ' + arguments.length + ' arguments, expected ${argCount - 2}'); + }`; + + if (needsDestructorStack) { + invokerFnBody += "var destructors = [];\n"; + } + + var dtorStack = needsDestructorStack ? "destructors" : "null"; + var args1 = ["humanName", "throwBindingError", "invoker", "fn", "runDestructors", "retType", "classParam"]; + + if (isClassMethodFunc) { + invokerFnBody += "var thisWired = classParam['toWireType']("+dtorStack+", this);\n"; + } + + for (var i = 0; i < argCount - 2; ++i) { + invokerFnBody += "var arg"+i+"Wired = argType"+i+"['toWireType']("+dtorStack+", arg"+i+");\n"; + args1.push("argType"+i); + } + + if (isClassMethodFunc) { + argsListWired = "thisWired" + (argsListWired.length > 0 ? ", " : "") + argsListWired; + } + + invokerFnBody += + (returns || isAsync ? "var rv = ":"") + "invoker(fn"+(argsListWired.length>0?", ":"")+argsListWired+");\n"; + + var returnVal = returns ? "rv" : ""; + + if (needsDestructorStack) { + invokerFnBody += "runDestructors(destructors);\n"; + } else { + for (var i = isClassMethodFunc?1:2; i < argTypes.length; ++i) { // Skip return value at index 0 - it's not deleted here. Also skip class type if not a method. + var paramName = (i === 1 ? "thisWired" : ("arg"+(i - 2)+"Wired")); + if (argTypes[i].destructorFunction !== null) { + invokerFnBody += `${paramName}_dtor(${paramName});\n`; + args1.push(`${paramName}_dtor`); + } + } + } + + if (returns) { + invokerFnBody += "var ret = retType['fromWireType'](rv);\n" + + "return ret;\n"; + } else { + } + + invokerFnBody += "}\n"; + + invokerFnBody = `if (arguments.length !== ${args1.length}){ throw new Error(humanName + "Expected ${args1.length} closure arguments " + arguments.length + " given."); }\n${invokerFnBody}`; + return [args1, invokerFnBody]; + } + function craftInvokerFunction(humanName, argTypes, classType, cppInvokerFunc, cppTargetFunc, /** boolean= */ isAsync) { + // humanName: a human-readable string name for the function to be generated. + // argTypes: An array that contains the embind type objects for all types in the function signature. + // argTypes[0] is the type object for the function return value. + // argTypes[1] is the type object for function this object/class type, or null if not crafting an invoker for a class method. + // argTypes[2...] are the actual function parameters. + // classType: The embind type object for the class to be bound, or null if this is not a method of a class. + // cppInvokerFunc: JS Function object to the C++-side function that interops into C++ code. + // cppTargetFunc: Function pointer (an integer to FUNCTION_TABLE) to the target C++ function the cppInvokerFunc will end up calling. + // isAsync: Optional. If true, returns an async function. Async bindings are only supported with JSPI. + var argCount = argTypes.length; + + if (argCount < 2) { + throwBindingError("argTypes array size mismatch! Must at least get return value and 'this' types!"); + } + + assert(!isAsync, 'Async bindings are only supported with JSPI.'); + + var isClassMethodFunc = (argTypes[1] !== null && classType !== null); + + // Free functions with signature "void function()" do not need an invoker that marshalls between wire types. + // TODO: This omits argument count check - enable only at -O3 or similar. + // if (ENABLE_UNSAFE_OPTS && argCount == 2 && argTypes[0].name == "void" && !isClassMethodFunc) { + // return FUNCTION_TABLE[fn]; + // } + + // Determine if we need to use a dynamic stack to store the destructors for the function parameters. + // TODO: Remove this completely once all function invokers are being dynamically generated. + var needsDestructorStack = usesDestructorStack(argTypes); + + var returns = (argTypes[0].name !== "void"); + + // Builld the arguments that will be passed into the closure around the invoker + // function. + var closureArgs = [humanName, throwBindingError, cppInvokerFunc, cppTargetFunc, runDestructors, argTypes[0], argTypes[1]]; + for (var i = 0; i < argCount - 2; ++i) { + closureArgs.push(argTypes[i+2]); + } + if (!needsDestructorStack) { + for (var i = isClassMethodFunc?1:2; i < argTypes.length; ++i) { // Skip return value at index 0 - it's not deleted here. Also skip class type if not a method. + if (argTypes[i].destructorFunction !== null) { + closureArgs.push(argTypes[i].destructorFunction); + } + } + } + + let [args, invokerFnBody] = createJsInvoker(argTypes, isClassMethodFunc, returns, isAsync); + args.push(invokerFnBody); + var invokerFn = newFunc(Function, args)(...closureArgs); + return createNamedFunction(humanName, invokerFn); + } + + var ensureOverloadTable = (proto, methodName, humanName) => { + if (undefined === proto[methodName].overloadTable) { + var prevFunc = proto[methodName]; + // Inject an overload resolver function that routes to the appropriate overload based on the number of arguments. + proto[methodName] = function(...args) { + // TODO This check can be removed in -O3 level "unsafe" optimizations. + if (!proto[methodName].overloadTable.hasOwnProperty(args.length)) { + throwBindingError(`Function '${humanName}' called with an invalid number of arguments (${args.length}) - expects one of (${proto[methodName].overloadTable})!`); + } + return proto[methodName].overloadTable[args.length].apply(this, args); + }; + // Move the previous function into the overload table. + proto[methodName].overloadTable = []; + proto[methodName].overloadTable[prevFunc.argCount] = prevFunc; + } + }; + + /** @param {number=} numArguments */ + var exposePublicSymbol = (name, value, numArguments) => { + if (Module.hasOwnProperty(name)) { + if (undefined === numArguments || (undefined !== Module[name].overloadTable && undefined !== Module[name].overloadTable[numArguments])) { + throwBindingError(`Cannot register public name '${name}' twice`); + } + + // We are exposing a function with the same name as an existing function. Create an overload table and a function selector + // that routes between the two. + ensureOverloadTable(Module, name, name); + if (Module.hasOwnProperty(numArguments)) { + throwBindingError(`Cannot register multiple overloads of a function with the same number of arguments (${numArguments})!`); + } + // Add the new function into the overload table. + Module[name].overloadTable[numArguments] = value; + } + else { + Module[name] = value; + if (undefined !== numArguments) { + Module[name].numArguments = numArguments; + } + } + }; + + var heap32VectorToArray = (count, firstElement) => { + var array = []; + for (var i = 0; i < count; i++) { + // TODO(https://github.com/emscripten-core/emscripten/issues/17310): + // Find a way to hoist the `>> 2` or `>> 3` out of this loop. + array.push(HEAPU32[(((firstElement)+(i * 4))>>2)]); + } + return array; + }; + + + /** @param {number=} numArguments */ + var replacePublicSymbol = (name, value, numArguments) => { + if (!Module.hasOwnProperty(name)) { + throwInternalError('Replacing nonexistent public symbol'); + } + // If there's an overload table for this symbol, replace the symbol in the overload table instead. + if (undefined !== Module[name].overloadTable && undefined !== numArguments) { + Module[name].overloadTable[numArguments] = value; + } + else { + Module[name] = value; + Module[name].argCount = numArguments; + } + }; + + + + var dynCallLegacy = (sig, ptr, args) => { + sig = sig.replace(/p/g, 'i') + assert(('dynCall_' + sig) in Module, `bad function pointer type - dynCall function not found for sig '${sig}'`); + if (args?.length) { + // j (64-bit integer) must be passed in as two numbers [low 32, high 32]. + assert(args.length === sig.substring(1).replace(/j/g, '--').length); + } else { + assert(sig.length == 1); + } + var f = Module['dynCall_' + sig]; + return f(ptr, ...args); + }; + + var wasmTableMirror = []; + + /** @type {WebAssembly.Table} */ + var wasmTable; + var getWasmTableEntry = (funcPtr) => { + var func = wasmTableMirror[funcPtr]; + if (!func) { + if (funcPtr >= wasmTableMirror.length) wasmTableMirror.length = funcPtr + 1; + wasmTableMirror[funcPtr] = func = wasmTable.get(funcPtr); + } + assert(wasmTable.get(funcPtr) == func, 'JavaScript-side Wasm function table mirror is out of date!'); + return func; + }; + + var dynCall = (sig, ptr, args = []) => { + // Without WASM_BIGINT support we cannot directly call function with i64 as + // part of their signature, so we rely on the dynCall functions generated by + // wasm-emscripten-finalize + if (sig.includes('j')) { + return dynCallLegacy(sig, ptr, args); + } + assert(getWasmTableEntry(ptr), `missing table entry in dynCall: ${ptr}`); + var rtn = getWasmTableEntry(ptr)(...args); + return rtn; + }; + var getDynCaller = (sig, ptr) => { + assert(sig.includes('j') || sig.includes('p'), 'getDynCaller should only be called with i64 sigs') + return (...args) => dynCall(sig, ptr, args); + }; + + + var embind__requireFunction = (signature, rawFunction) => { + signature = readLatin1String(signature); + + function makeDynCaller() { + if (signature.includes('j')) { + return getDynCaller(signature, rawFunction); + } + return getWasmTableEntry(rawFunction); + } + + var fp = makeDynCaller(); + if (typeof fp != "function") { + throwBindingError(`unknown function pointer with signature ${signature}: ${rawFunction}`); + } + return fp; + }; + + + + var extendError = (baseErrorType, errorName) => { + var errorClass = createNamedFunction(errorName, function(message) { + this.name = errorName; + this.message = message; + + var stack = (new Error(message)).stack; + if (stack !== undefined) { + this.stack = this.toString() + '\n' + + stack.replace(/^Error(:[^\n]*)?\n/, ''); + } + }); + errorClass.prototype = Object.create(baseErrorType.prototype); + errorClass.prototype.constructor = errorClass; + errorClass.prototype.toString = function() { + if (this.message === undefined) { + return this.name; + } else { + return `${this.name}: ${this.message}`; + } + }; + + return errorClass; + }; + var UnboundTypeError; + + + + var getTypeName = (type) => { + var ptr = ___getTypeName(type); + var rv = readLatin1String(ptr); + _free(ptr); + return rv; + }; + var throwUnboundTypeError = (message, types) => { + var unboundTypes = []; + var seen = {}; + function visit(type) { + if (seen[type]) { + return; + } + if (registeredTypes[type]) { + return; + } + if (typeDependencies[type]) { + typeDependencies[type].forEach(visit); + return; + } + unboundTypes.push(type); + seen[type] = true; + } + types.forEach(visit); + + throw new UnboundTypeError(`${message}: ` + unboundTypes.map(getTypeName).join([', '])); + }; + + + var getFunctionName = (signature) => { + signature = signature.trim(); + const argsIndex = signature.indexOf("("); + if (argsIndex !== -1) { + assert(signature[signature.length - 1] == ")", "Parentheses for argument names should match."); + return signature.substr(0, argsIndex); + } else { + return signature; + } + }; + var __embind_register_function = (name, argCount, rawArgTypesAddr, signature, rawInvoker, fn, isAsync) => { + var argTypes = heap32VectorToArray(argCount, rawArgTypesAddr); + name = readLatin1String(name); + name = getFunctionName(name); + + rawInvoker = embind__requireFunction(signature, rawInvoker); + + exposePublicSymbol(name, function() { + throwUnboundTypeError(`Cannot call ${name} due to unbound types`, argTypes); + }, argCount - 1); + + whenDependentTypesAreResolved([], argTypes, (argTypes) => { + var invokerArgsArray = [argTypes[0] /* return value */, null /* no class 'this'*/].concat(argTypes.slice(1) /* actual params */); + replacePublicSymbol(name, craftInvokerFunction(name, invokerArgsArray, null /* no class 'this'*/, rawInvoker, fn, isAsync), argCount - 1); + return []; + }); + }; + + + var integerReadValueFromPointer = (name, width, signed) => { + // integers are quite common, so generate very specialized functions + switch (width) { + case 1: return signed ? + (pointer) => HEAP8[pointer] : + (pointer) => HEAPU8[pointer]; + case 2: return signed ? + (pointer) => HEAP16[((pointer)>>1)] : + (pointer) => HEAPU16[((pointer)>>1)] + case 4: return signed ? + (pointer) => HEAP32[((pointer)>>2)] : + (pointer) => HEAPU32[((pointer)>>2)] + default: + throw new TypeError(`invalid integer width (${width}): ${name}`); + } + }; + + + /** @suppress {globalThis} */ + var __embind_register_integer = (primitiveType, name, size, minRange, maxRange) => { + name = readLatin1String(name); + // LLVM doesn't have signed and unsigned 32-bit types, so u32 literals come + // out as 'i32 -1'. Always treat those as max u32. + if (maxRange === -1) { + maxRange = 4294967295; + } + + var fromWireType = (value) => value; + + if (minRange === 0) { + var bitshift = 32 - 8*size; + fromWireType = (value) => (value << bitshift) >>> bitshift; + } + + var isUnsignedType = (name.includes('unsigned')); + var checkAssertions = (value, toTypeName) => { + if (typeof value != "number" && typeof value != "boolean") { + throw new TypeError(`Cannot convert "${embindRepr(value)}" to ${toTypeName}`); + } + if (value < minRange || value > maxRange) { + throw new TypeError(`Passing a number "${embindRepr(value)}" from JS side to C/C++ side to an argument of type "${name}", which is outside the valid range [${minRange}, ${maxRange}]!`); + } + } + var toWireType; + if (isUnsignedType) { + toWireType = function(destructors, value) { + checkAssertions(value, this.name); + return value >>> 0; + } + } else { + toWireType = function(destructors, value) { + checkAssertions(value, this.name); + // The VM will perform JS to Wasm value conversion, according to the spec: + // https://www.w3.org/TR/wasm-js-api-1/#towebassemblyvalue + return value; + } + } + registerType(primitiveType, { + name, + 'fromWireType': fromWireType, + 'toWireType': toWireType, + 'argPackAdvance': GenericWireTypeSize, + 'readValueFromPointer': integerReadValueFromPointer(name, size, minRange !== 0), + destructorFunction: null, // This type does not need a destructor + }); + }; + + + var __embind_register_memory_view = (rawType, dataTypeIndex, name) => { + var typeMapping = [ + Int8Array, + Uint8Array, + Int16Array, + Uint16Array, + Int32Array, + Uint32Array, + Float32Array, + Float64Array, + ]; + + var TA = typeMapping[dataTypeIndex]; + + function decodeMemoryView(handle) { + var size = HEAPU32[((handle)>>2)]; + var data = HEAPU32[(((handle)+(4))>>2)]; + return new TA(HEAP8.buffer, data, size); + } + + name = readLatin1String(name); + registerType(rawType, { + name, + 'fromWireType': decodeMemoryView, + 'argPackAdvance': GenericWireTypeSize, + 'readValueFromPointer': decodeMemoryView, + }, { + ignoreDuplicateRegistrations: true, + }); + }; + + + + + + var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => { + assert(typeof str === 'string', `stringToUTF8Array expects a string (got ${typeof str})`); + // Parameter maxBytesToWrite is not optional. Negative values, 0, null, + // undefined and false each don't write out any bytes. + if (!(maxBytesToWrite > 0)) + return 0; + + var startIdx = outIdx; + var endIdx = outIdx + maxBytesToWrite - 1; // -1 for string null terminator. + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code + // unit, not a Unicode code point of the character! So decode + // UTF16->UTF32->UTF8. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description + // and https://www.ietf.org/rfc/rfc2279.txt + // and https://tools.ietf.org/html/rfc3629 + var u = str.charCodeAt(i); // possibly a lead surrogate + if (u >= 0xD800 && u <= 0xDFFF) { + var u1 = str.charCodeAt(++i); + u = 0x10000 + ((u & 0x3FF) << 10) | (u1 & 0x3FF); + } + if (u <= 0x7F) { + if (outIdx >= endIdx) break; + heap[outIdx++] = u; + } else if (u <= 0x7FF) { + if (outIdx + 1 >= endIdx) break; + heap[outIdx++] = 0xC0 | (u >> 6); + heap[outIdx++] = 0x80 | (u & 63); + } else if (u <= 0xFFFF) { + if (outIdx + 2 >= endIdx) break; + heap[outIdx++] = 0xE0 | (u >> 12); + heap[outIdx++] = 0x80 | ((u >> 6) & 63); + heap[outIdx++] = 0x80 | (u & 63); + } else { + if (outIdx + 3 >= endIdx) break; + if (u > 0x10FFFF) warnOnce('Invalid Unicode code point ' + ptrToString(u) + ' encountered when serializing a JS string to a UTF-8 string in wasm memory! (Valid unicode code points should be in range 0-0x10FFFF).'); + heap[outIdx++] = 0xF0 | (u >> 18); + heap[outIdx++] = 0x80 | ((u >> 12) & 63); + heap[outIdx++] = 0x80 | ((u >> 6) & 63); + heap[outIdx++] = 0x80 | (u & 63); + } + } + // Null-terminate the pointer to the buffer. + heap[outIdx] = 0; + return outIdx - startIdx; + }; + var stringToUTF8 = (str, outPtr, maxBytesToWrite) => { + assert(typeof maxBytesToWrite == 'number', 'stringToUTF8(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!'); + return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite); + }; + + var lengthBytesUTF8 = (str) => { + var len = 0; + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code + // unit, not a Unicode code point of the character! So decode + // UTF16->UTF32->UTF8. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + var c = str.charCodeAt(i); // possibly a lead surrogate + if (c <= 0x7F) { + len++; + } else if (c <= 0x7FF) { + len += 2; + } else if (c >= 0xD800 && c <= 0xDFFF) { + len += 4; ++i; + } else { + len += 3; + } + } + return len; + }; + + + + var __embind_register_std_string = (rawType, name) => { + name = readLatin1String(name); + var stdStringIsUTF8 + //process only std::string bindings with UTF8 support, in contrast to e.g. std::basic_string + = (name === "std::string"); + + registerType(rawType, { + name, + // For some method names we use string keys here since they are part of + // the public/external API and/or used by the runtime-generated code. + 'fromWireType'(value) { + var length = HEAPU32[((value)>>2)]; + var payload = value + 4; + + var str; + if (stdStringIsUTF8) { + var decodeStartPtr = payload; + // Looping here to support possible embedded '0' bytes + for (var i = 0; i <= length; ++i) { + var currentBytePtr = payload + i; + if (i == length || HEAPU8[currentBytePtr] == 0) { + var maxRead = currentBytePtr - decodeStartPtr; + var stringSegment = UTF8ToString(decodeStartPtr, maxRead); + if (str === undefined) { + str = stringSegment; + } else { + str += String.fromCharCode(0); + str += stringSegment; + } + decodeStartPtr = currentBytePtr + 1; + } + } + } else { + var a = new Array(length); + for (var i = 0; i < length; ++i) { + a[i] = String.fromCharCode(HEAPU8[payload + i]); + } + str = a.join(''); + } + + _free(value); + + return str; + }, + 'toWireType'(destructors, value) { + if (value instanceof ArrayBuffer) { + value = new Uint8Array(value); + } + + var length; + var valueIsOfTypeString = (typeof value == 'string'); + + if (!(valueIsOfTypeString || value instanceof Uint8Array || value instanceof Uint8ClampedArray || value instanceof Int8Array)) { + throwBindingError('Cannot pass non-string to std::string'); + } + if (stdStringIsUTF8 && valueIsOfTypeString) { + length = lengthBytesUTF8(value); + } else { + length = value.length; + } + + // assumes POINTER_SIZE alignment + var base = _malloc(4 + length + 1); + var ptr = base + 4; + HEAPU32[((base)>>2)] = length; + if (stdStringIsUTF8 && valueIsOfTypeString) { + stringToUTF8(value, ptr, length + 1); + } else { + if (valueIsOfTypeString) { + for (var i = 0; i < length; ++i) { + var charCode = value.charCodeAt(i); + if (charCode > 255) { + _free(ptr); + throwBindingError('String has UTF-16 code units that do not fit in 8 bits'); + } + HEAPU8[ptr + i] = charCode; + } + } else { + for (var i = 0; i < length; ++i) { + HEAPU8[ptr + i] = value[i]; + } + } + } + + if (destructors !== null) { + destructors.push(_free, base); + } + return base; + }, + 'argPackAdvance': GenericWireTypeSize, + 'readValueFromPointer': readPointer, + destructorFunction(ptr) { + _free(ptr); + }, + }); + }; + + + + + var UTF16Decoder = typeof TextDecoder != 'undefined' ? new TextDecoder('utf-16le') : undefined;; + var UTF16ToString = (ptr, maxBytesToRead) => { + assert(ptr % 2 == 0, 'Pointer passed to UTF16ToString must be aligned to two bytes!'); + var endPtr = ptr; + // TextDecoder needs to know the byte length in advance, it doesn't stop on + // null terminator by itself. + // Also, use the length info to avoid running tiny strings through + // TextDecoder, since .subarray() allocates garbage. + var idx = endPtr >> 1; + var maxIdx = idx + maxBytesToRead / 2; + // If maxBytesToRead is not passed explicitly, it will be undefined, and this + // will always evaluate to true. This saves on code size. + while (!(idx >= maxIdx) && HEAPU16[idx]) ++idx; + endPtr = idx << 1; + + if (endPtr - ptr > 32 && UTF16Decoder) + return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr)); + + // Fallback: decode without UTF16Decoder + var str = ''; + + // If maxBytesToRead is not passed explicitly, it will be undefined, and the + // for-loop's condition will always evaluate to true. The loop is then + // terminated on the first null char. + for (var i = 0; !(i >= maxBytesToRead / 2); ++i) { + var codeUnit = HEAP16[(((ptr)+(i*2))>>1)]; + if (codeUnit == 0) break; + // fromCharCode constructs a character from a UTF-16 code unit, so we can + // pass the UTF16 string right through. + str += String.fromCharCode(codeUnit); + } + + return str; + }; + + var stringToUTF16 = (str, outPtr, maxBytesToWrite) => { + assert(outPtr % 2 == 0, 'Pointer passed to stringToUTF16 must be aligned to two bytes!'); + assert(typeof maxBytesToWrite == 'number', 'stringToUTF16(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!'); + // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed. + maxBytesToWrite ??= 0x7FFFFFFF; + if (maxBytesToWrite < 2) return 0; + maxBytesToWrite -= 2; // Null terminator. + var startPtr = outPtr; + var numCharsToWrite = (maxBytesToWrite < str.length*2) ? (maxBytesToWrite / 2) : str.length; + for (var i = 0; i < numCharsToWrite; ++i) { + // charCodeAt returns a UTF-16 encoded code unit, so it can be directly written to the HEAP. + var codeUnit = str.charCodeAt(i); // possibly a lead surrogate + HEAP16[((outPtr)>>1)] = codeUnit; + outPtr += 2; + } + // Null-terminate the pointer to the HEAP. + HEAP16[((outPtr)>>1)] = 0; + return outPtr - startPtr; + }; + + var lengthBytesUTF16 = (str) => { + return str.length*2; + }; + + var UTF32ToString = (ptr, maxBytesToRead) => { + assert(ptr % 4 == 0, 'Pointer passed to UTF32ToString must be aligned to four bytes!'); + var i = 0; + + var str = ''; + // If maxBytesToRead is not passed explicitly, it will be undefined, and this + // will always evaluate to true. This saves on code size. + while (!(i >= maxBytesToRead / 4)) { + var utf32 = HEAP32[(((ptr)+(i*4))>>2)]; + if (utf32 == 0) break; + ++i; + // Gotcha: fromCharCode constructs a character from a UTF-16 encoded code (pair), not from a Unicode code point! So encode the code point to UTF-16 for constructing. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + if (utf32 >= 0x10000) { + var ch = utf32 - 0x10000; + str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF)); + } else { + str += String.fromCharCode(utf32); + } + } + return str; + }; + + var stringToUTF32 = (str, outPtr, maxBytesToWrite) => { + assert(outPtr % 4 == 0, 'Pointer passed to stringToUTF32 must be aligned to four bytes!'); + assert(typeof maxBytesToWrite == 'number', 'stringToUTF32(str, outPtr, maxBytesToWrite) is missing the third parameter that specifies the length of the output buffer!'); + // Backwards compatibility: if max bytes is not specified, assume unsafe unbounded write is allowed. + maxBytesToWrite ??= 0x7FFFFFFF; + if (maxBytesToWrite < 4) return 0; + var startPtr = outPtr; + var endPtr = startPtr + maxBytesToWrite - 4; + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + var codeUnit = str.charCodeAt(i); // possibly a lead surrogate + if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) { + var trailSurrogate = str.charCodeAt(++i); + codeUnit = 0x10000 + ((codeUnit & 0x3FF) << 10) | (trailSurrogate & 0x3FF); + } + HEAP32[((outPtr)>>2)] = codeUnit; + outPtr += 4; + if (outPtr + 4 > endPtr) break; + } + // Null-terminate the pointer to the HEAP. + HEAP32[((outPtr)>>2)] = 0; + return outPtr - startPtr; + }; + + var lengthBytesUTF32 = (str) => { + var len = 0; + for (var i = 0; i < str.length; ++i) { + // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code unit, not a Unicode code point of the character! We must decode the string to UTF-32 to the heap. + // See http://unicode.org/faq/utf_bom.html#utf16-3 + var codeUnit = str.charCodeAt(i); + if (codeUnit >= 0xD800 && codeUnit <= 0xDFFF) ++i; // possibly a lead surrogate, so skip over the tail surrogate. + len += 4; + } + + return len; + }; + var __embind_register_std_wstring = (rawType, charSize, name) => { + name = readLatin1String(name); + var decodeString, encodeString, readCharAt, lengthBytesUTF; + if (charSize === 2) { + decodeString = UTF16ToString; + encodeString = stringToUTF16; + lengthBytesUTF = lengthBytesUTF16; + readCharAt = (pointer) => HEAPU16[((pointer)>>1)]; + } else if (charSize === 4) { + decodeString = UTF32ToString; + encodeString = stringToUTF32; + lengthBytesUTF = lengthBytesUTF32; + readCharAt = (pointer) => HEAPU32[((pointer)>>2)]; + } + registerType(rawType, { + name, + 'fromWireType': (value) => { + // Code mostly taken from _embind_register_std_string fromWireType + var length = HEAPU32[((value)>>2)]; + var str; + + var decodeStartPtr = value + 4; + // Looping here to support possible embedded '0' bytes + for (var i = 0; i <= length; ++i) { + var currentBytePtr = value + 4 + i * charSize; + if (i == length || readCharAt(currentBytePtr) == 0) { + var maxReadBytes = currentBytePtr - decodeStartPtr; + var stringSegment = decodeString(decodeStartPtr, maxReadBytes); + if (str === undefined) { + str = stringSegment; + } else { + str += String.fromCharCode(0); + str += stringSegment; + } + decodeStartPtr = currentBytePtr + charSize; + } + } + + _free(value); + + return str; + }, + 'toWireType': (destructors, value) => { + if (!(typeof value == 'string')) { + throwBindingError(`Cannot pass non-string to C++ string type ${name}`); + } + + // assumes POINTER_SIZE alignment + var length = lengthBytesUTF(value); + var ptr = _malloc(4 + length + charSize); + HEAPU32[((ptr)>>2)] = length / charSize; + + encodeString(value, ptr + 4, length + charSize); + + if (destructors !== null) { + destructors.push(_free, ptr); + } + return ptr; + }, + 'argPackAdvance': GenericWireTypeSize, + 'readValueFromPointer': readPointer, + destructorFunction(ptr) { + _free(ptr); + } + }); + }; + + + var __embind_register_void = (rawType, name) => { + name = readLatin1String(name); + registerType(rawType, { + isVoid: true, // void return values can be optimized out sometimes + name, + 'argPackAdvance': 0, + 'fromWireType': () => undefined, + // TODO: assert if anything else is given? + 'toWireType': (destructors, o) => undefined, + }); + }; + + var __emscripten_memcpy_js = (dest, src, num) => HEAPU8.copyWithin(dest, src, src + num); + + var emval_symbols = { + }; + + var getStringOrSymbol = (address) => { + var symbol = emval_symbols[address]; + if (symbol === undefined) { + return readLatin1String(address); + } + return symbol; + }; + + var emval_methodCallers = []; + + var __emval_call_method = (caller, objHandle, methodName, destructorsRef, args) => { + caller = emval_methodCallers[caller]; + objHandle = Emval.toValue(objHandle); + methodName = getStringOrSymbol(methodName); + return caller(objHandle, objHandle[methodName], destructorsRef, args); + }; + + + var emval_addMethodCaller = (caller) => { + var id = emval_methodCallers.length; + emval_methodCallers.push(caller); + return id; + }; + + + + var requireRegisteredType = (rawType, humanName) => { + var impl = registeredTypes[rawType]; + if (undefined === impl) { + throwBindingError(`${humanName} has unknown type ${getTypeName(rawType)}`); + } + return impl; + }; + var emval_lookupTypes = (argCount, argTypes) => { + var a = new Array(argCount); + for (var i = 0; i < argCount; ++i) { + a[i] = requireRegisteredType(HEAPU32[(((argTypes)+(i * 4))>>2)], + "parameter " + i); + } + return a; + }; + + + var reflectConstruct = Reflect.construct; + + var emval_returnValue = (returnType, destructorsRef, handle) => { + var destructors = []; + var result = returnType['toWireType'](destructors, handle); + if (destructors.length) { + // void, primitives and any other types w/o destructors don't need to allocate a handle + HEAPU32[((destructorsRef)>>2)] = Emval.toHandle(destructors); + } + return result; + }; + + var __emval_get_method_caller = (argCount, argTypes, kind) => { + var types = emval_lookupTypes(argCount, argTypes); + var retType = types.shift(); + argCount--; // remove the shifted off return type + + var functionBody = + `return function (obj, func, destructorsRef, args) {\n`; + + var offset = 0; + var argsList = []; // 'obj?, arg0, arg1, arg2, ... , argN' + if (kind === /* FUNCTION */ 0) { + argsList.push("obj"); + } + var params = ["retType"]; + var args = [retType]; + for (var i = 0; i < argCount; ++i) { + argsList.push("arg" + i); + params.push("argType" + i); + args.push(types[i]); + functionBody += + ` var arg${i} = argType${i}.readValueFromPointer(args${offset ? "+" + offset : ""});\n`; + offset += types[i]['argPackAdvance']; + } + var invoker = kind === /* CONSTRUCTOR */ 1 ? 'new func' : 'func.call'; + functionBody += + ` var rv = ${invoker}(${argsList.join(", ")});\n`; + if (!retType.isVoid) { + params.push("emval_returnValue"); + args.push(emval_returnValue); + functionBody += + " return emval_returnValue(retType, destructorsRef, rv);\n"; + } + functionBody += + "};\n"; + + params.push(functionBody); + var invokerFunction = newFunc(Function, params)(...args); + var functionName = `methodCaller<(${types.map(t => t.name).join(', ')}) => ${retType.name}>`; + return emval_addMethodCaller(createNamedFunction(functionName, invokerFunction)); + }; + + var __emval_new_array = () => Emval.toHandle([]); + + + + var __emval_run_destructors = (handle) => { + var destructors = Emval.toValue(handle); + runDestructors(destructors); + __emval_decref(handle); + }; + + var __emval_set_property = (handle, key, value) => { + handle = Emval.toValue(handle); + key = Emval.toValue(key); + value = Emval.toValue(value); + handle[key] = value; + }; + + + var __emval_take_value = (type, arg) => { + type = requireRegisteredType(type, '_emval_take_value'); + var v = type['readValueFromPointer'](arg); + return Emval.toHandle(v); + }; + + var getHeapMax = () => + HEAPU8.length; + + var abortOnCannotGrowMemory = (requestedSize) => { + abort(`Cannot enlarge memory arrays to size ${requestedSize} bytes (OOM). Either (1) compile with -sINITIAL_MEMORY=X with X higher than the current value ${HEAP8.length}, (2) compile with -sALLOW_MEMORY_GROWTH which allows increasing the size at runtime, or (3) if you want malloc to return NULL (0) instead of this abort, compile with -sABORTING_MALLOC=0`); + }; + var _emscripten_resize_heap = (requestedSize) => { + var oldSize = HEAPU8.length; + // With CAN_ADDRESS_2GB or MEMORY64, pointers are already unsigned. + requestedSize >>>= 0; + abortOnCannotGrowMemory(requestedSize); + }; + + var SYSCALLS = { + varargs:undefined, + getStr(ptr) { + var ret = UTF8ToString(ptr); + return ret; + }, + }; + var _fd_close = (fd) => { + abort('fd_close called without SYSCALLS_REQUIRE_FILESYSTEM'); + }; + + var convertI32PairToI53Checked = (lo, hi) => { + assert(lo == (lo >>> 0) || lo == (lo|0)); // lo should either be a i32 or a u32 + assert(hi === (hi|0)); // hi should be a i32 + return ((hi + 0x200000) >>> 0 < 0x400001 - !!lo) ? (lo >>> 0) + hi * 4294967296 : NaN; + }; + function _fd_seek(fd,offset_low, offset_high,whence,newOffset) { + var offset = convertI32PairToI53Checked(offset_low, offset_high); + + + return 70; + ; + } + + var printCharBuffers = [null,[],[]]; + + var printChar = (stream, curr) => { + var buffer = printCharBuffers[stream]; + assert(buffer); + if (curr === 0 || curr === 10) { + (stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0)); + buffer.length = 0; + } else { + buffer.push(curr); + } + }; + + var flush_NO_FILESYSTEM = () => { + // flush anything remaining in the buffers during shutdown + _fflush(0); + if (printCharBuffers[1].length) printChar(1, 10); + if (printCharBuffers[2].length) printChar(2, 10); + }; + + + var _fd_write = (fd, iov, iovcnt, pnum) => { + // hack to support printf in SYSCALLS_REQUIRE_FILESYSTEM=0 + var num = 0; + for (var i = 0; i < iovcnt; i++) { + var ptr = HEAPU32[((iov)>>2)]; + var len = HEAPU32[(((iov)+(4))>>2)]; + iov += 8; + for (var j = 0; j < len; j++) { + printChar(fd, HEAPU8[ptr+j]); + } + num += len; + } + HEAPU32[((pnum)>>2)] = num; + return 0; + }; + + var getCFunc = (ident) => { + var func = Module['_' + ident]; // closure exported function + assert(func, 'Cannot call unknown function ' + ident + ', make sure it is exported'); + return func; + }; + + var writeArrayToMemory = (array, buffer) => { + assert(array.length >= 0, 'writeArrayToMemory array must have a length (should be an array or typed array)') + HEAP8.set(array, buffer); + }; + + + + var stackAlloc = (sz) => __emscripten_stack_alloc(sz); + var stringToUTF8OnStack = (str) => { + var size = lengthBytesUTF8(str) + 1; + var ret = stackAlloc(size); + stringToUTF8(str, ret, size); + return ret; + }; + + + + + + /** + * @param {string|null=} returnType + * @param {Array=} argTypes + * @param {Arguments|Array=} args + * @param {Object=} opts + */ + var ccall = (ident, returnType, argTypes, args, opts) => { + // For fast lookup of conversion functions + var toC = { + 'string': (str) => { + var ret = 0; + if (str !== null && str !== undefined && str !== 0) { // null string + // at most 4 bytes per UTF-8 code point, +1 for the trailing '\0' + ret = stringToUTF8OnStack(str); + } + return ret; + }, + 'array': (arr) => { + var ret = stackAlloc(arr.length); + writeArrayToMemory(arr, ret); + return ret; + } + }; + + function convertReturnValue(ret) { + if (returnType === 'string') { + + return UTF8ToString(ret); + } + if (returnType === 'boolean') return Boolean(ret); + return ret; + } + + var func = getCFunc(ident); + var cArgs = []; + var stack = 0; + assert(returnType !== 'array', 'Return type should not be "array".'); + if (args) { + for (var i = 0; i < args.length; i++) { + var converter = toC[argTypes[i]]; + if (converter) { + if (stack === 0) stack = stackSave(); + cArgs[i] = converter(args[i]); + } else { + cArgs[i] = args[i]; + } + } + } + var ret = func(...cArgs); + function onDone(ret) { + if (stack !== 0) stackRestore(stack); + return convertReturnValue(ret); + } + + ret = onDone(ret); + return ret; + }; +embind_init_charCodes(); +BindingError = Module['BindingError'] = class BindingError extends Error { constructor(message) { super(message); this.name = 'BindingError'; }}; +InternalError = Module['InternalError'] = class InternalError extends Error { constructor(message) { super(message); this.name = 'InternalError'; }}; +init_emval();; +UnboundTypeError = Module['UnboundTypeError'] = extendError(Error, 'UnboundTypeError');; +function checkIncomingModuleAPI() { + ignoredModuleProp('fetchSettings'); +} +var wasmImports = { + /** @export */ + __assert_fail: ___assert_fail, + /** @export */ + _abort_js: __abort_js, + /** @export */ + _embind_register_bigint: __embind_register_bigint, + /** @export */ + _embind_register_bool: __embind_register_bool, + /** @export */ + _embind_register_emval: __embind_register_emval, + /** @export */ + _embind_register_float: __embind_register_float, + /** @export */ + _embind_register_function: __embind_register_function, + /** @export */ + _embind_register_integer: __embind_register_integer, + /** @export */ + _embind_register_memory_view: __embind_register_memory_view, + /** @export */ + _embind_register_std_string: __embind_register_std_string, + /** @export */ + _embind_register_std_wstring: __embind_register_std_wstring, + /** @export */ + _embind_register_void: __embind_register_void, + /** @export */ + _emscripten_memcpy_js: __emscripten_memcpy_js, + /** @export */ + _emval_call_method: __emval_call_method, + /** @export */ + _emval_decref: __emval_decref, + /** @export */ + _emval_get_method_caller: __emval_get_method_caller, + /** @export */ + _emval_new_array: __emval_new_array, + /** @export */ + _emval_run_destructors: __emval_run_destructors, + /** @export */ + _emval_set_property: __emval_set_property, + /** @export */ + _emval_take_value: __emval_take_value, + /** @export */ + emscripten_resize_heap: _emscripten_resize_heap, + /** @export */ + fd_close: _fd_close, + /** @export */ + fd_seek: _fd_seek, + /** @export */ + fd_write: _fd_write +}; +var wasmExports = createWasm(); +var ___wasm_call_ctors = createExportWrapper('__wasm_call_ctors', 0); +var ___getTypeName = createExportWrapper('__getTypeName', 1); +var _malloc = createExportWrapper('malloc', 1); +var _fflush = createExportWrapper('fflush', 1); +var _free = createExportWrapper('free', 1); +var _emscripten_stack_init = () => (_emscripten_stack_init = wasmExports['emscripten_stack_init'])(); +var _emscripten_stack_get_free = () => (_emscripten_stack_get_free = wasmExports['emscripten_stack_get_free'])(); +var _emscripten_stack_get_base = () => (_emscripten_stack_get_base = wasmExports['emscripten_stack_get_base'])(); +var _emscripten_stack_get_end = () => (_emscripten_stack_get_end = wasmExports['emscripten_stack_get_end'])(); +var __emscripten_stack_restore = (a0) => (__emscripten_stack_restore = wasmExports['_emscripten_stack_restore'])(a0); +var __emscripten_stack_alloc = (a0) => (__emscripten_stack_alloc = wasmExports['_emscripten_stack_alloc'])(a0); +var _emscripten_stack_get_current = () => (_emscripten_stack_get_current = wasmExports['emscripten_stack_get_current'])(); +var ___cxa_is_pointer_type = createExportWrapper('__cxa_is_pointer_type', 1); +var dynCall_jiji = Module['dynCall_jiji'] = createExportWrapper('dynCall_jiji', 5); + + +// include: postamble.js +// === Auto-generated postamble setup entry stuff === + +Module['ccall'] = ccall; +var missingLibrarySymbols = [ + 'writeI53ToI64', + 'writeI53ToI64Clamped', + 'writeI53ToI64Signaling', + 'writeI53ToU64Clamped', + 'writeI53ToU64Signaling', + 'readI53FromI64', + 'readI53FromU64', + 'convertI32PairToI53', + 'convertU32PairToI53', + 'getTempRet0', + 'setTempRet0', + 'zeroMemory', + 'exitJS', + 'growMemory', + 'isLeapYear', + 'ydayFromDate', + 'arraySum', + 'addDays', + 'inetPton4', + 'inetNtop4', + 'inetPton6', + 'inetNtop6', + 'readSockaddr', + 'writeSockaddr', + 'initRandomFill', + 'randomFill', + 'emscriptenLog', + 'readEmAsmArgs', + 'jstoi_q', + 'getExecutableName', + 'listenOnce', + 'autoResumeAudioContext', + 'handleException', + 'keepRuntimeAlive', + 'runtimeKeepalivePush', + 'runtimeKeepalivePop', + 'callUserCallback', + 'maybeExit', + 'asmjsMangle', + 'asyncLoad', + 'alignMemory', + 'mmapAlloc', + 'HandleAllocator', + 'getNativeTypeSize', + 'STACK_SIZE', + 'STACK_ALIGN', + 'POINTER_SIZE', + 'ASSERTIONS', + 'cwrap', + 'uleb128Encode', + 'sigToWasmTypes', + 'generateFuncType', + 'convertJsFunctionToWasm', + 'getEmptyTableSlot', + 'updateTableMap', + 'getFunctionAddress', + 'addFunction', + 'removeFunction', + 'reallyNegative', + 'unSign', + 'strLen', + 'reSign', + 'formatString', + 'intArrayFromString', + 'intArrayToString', + 'AsciiToString', + 'stringToAscii', + 'stringToNewUTF8', + 'registerKeyEventCallback', + 'maybeCStringToJsString', + 'findEventTarget', + 'getBoundingClientRect', + 'fillMouseEventData', + 'registerMouseEventCallback', + 'registerWheelEventCallback', + 'registerUiEventCallback', + 'registerFocusEventCallback', + 'fillDeviceOrientationEventData', + 'registerDeviceOrientationEventCallback', + 'fillDeviceMotionEventData', + 'registerDeviceMotionEventCallback', + 'screenOrientation', + 'fillOrientationChangeEventData', + 'registerOrientationChangeEventCallback', + 'fillFullscreenChangeEventData', + 'registerFullscreenChangeEventCallback', + 'JSEvents_requestFullscreen', + 'JSEvents_resizeCanvasForFullscreen', + 'registerRestoreOldStyle', + 'hideEverythingExceptGivenElement', + 'restoreHiddenElements', + 'setLetterbox', + 'softFullscreenResizeWebGLRenderTarget', + 'doRequestFullscreen', + 'fillPointerlockChangeEventData', + 'registerPointerlockChangeEventCallback', + 'registerPointerlockErrorEventCallback', + 'requestPointerLock', + 'fillVisibilityChangeEventData', + 'registerVisibilityChangeEventCallback', + 'registerTouchEventCallback', + 'fillGamepadEventData', + 'registerGamepadEventCallback', + 'registerBeforeUnloadEventCallback', + 'fillBatteryEventData', + 'battery', + 'registerBatteryEventCallback', + 'setCanvasElementSize', + 'getCanvasElementSize', + 'jsStackTrace', + 'getCallstack', + 'convertPCtoSourceLocation', + 'getEnvStrings', + 'checkWasiClock', + 'wasiRightsToMuslOFlags', + 'wasiOFlagsToMuslOFlags', + 'createDyncallWrapper', + 'safeSetTimeout', + 'setImmediateWrapped', + 'clearImmediateWrapped', + 'polyfillSetImmediate', + 'getPromise', + 'makePromise', + 'idsToPromises', + 'makePromiseCallback', + 'ExceptionInfo', + 'findMatchingCatch', + 'Browser_asyncPrepareDataCounter', + 'setMainLoop', + 'getSocketFromFD', + 'getSocketAddress', + 'FS_createPreloadedFile', + 'FS_modeStringToFlags', + 'FS_getMode', + 'FS_stdin_getChar', + 'FS_createDataFile', + 'FS_unlink', + 'FS_mkdirTree', + '_setNetworkCallback', + 'heapObjectForWebGLType', + 'toTypedArrayIndex', + 'webgl_enable_ANGLE_instanced_arrays', + 'webgl_enable_OES_vertex_array_object', + 'webgl_enable_WEBGL_draw_buffers', + 'webgl_enable_WEBGL_multi_draw', + 'emscriptenWebGLGet', + 'computeUnpackAlignedImageSize', + 'colorChannelsInGlTextureFormat', + 'emscriptenWebGLGetTexPixelData', + 'emscriptenWebGLGetUniform', + 'webglGetUniformLocation', + 'webglPrepareUniformLocationsBeforeFirstUse', + 'webglGetLeftBracePos', + 'emscriptenWebGLGetVertexAttrib', + '__glGetActiveAttribOrUniform', + 'writeGLArray', + 'registerWebGlEventCallback', + 'runAndAbortIfError', + 'ALLOC_NORMAL', + 'ALLOC_STACK', + 'allocate', + 'writeStringToMemory', + 'writeAsciiToMemory', + 'setErrNo', + 'demangle', + 'stackTrace', + 'getFunctionArgsName', + 'createJsInvokerSignature', + 'init_embind', + 'getBasestPointer', + 'registerInheritedInstance', + 'unregisterInheritedInstance', + 'getInheritedInstance', + 'getInheritedInstanceCount', + 'getLiveInheritedInstances', + 'enumReadValueFromPointer', + 'genericPointerToWireType', + 'constNoSmartPtrRawPointerToWireType', + 'nonConstNoSmartPtrRawPointerToWireType', + 'init_RegisteredPointer', + 'RegisteredPointer', + 'RegisteredPointer_fromWireType', + 'runDestructor', + 'releaseClassHandle', + 'detachFinalizer', + 'attachFinalizer', + 'makeClassHandle', + 'init_ClassHandle', + 'ClassHandle', + 'throwInstanceAlreadyDeleted', + 'flushPendingDeletes', + 'setDelayFunction', + 'RegisteredClass', + 'shallowCopyInternalPointer', + 'downcastPointer', + 'upcastPointer', + 'validateThis', + 'char_0', + 'char_9', + 'makeLegalFunctionName', + 'emval_get_global', +]; +missingLibrarySymbols.forEach(missingLibrarySymbol) + +var unexportedSymbols = [ + 'run', + 'addOnPreRun', + 'addOnInit', + 'addOnPreMain', + 'addOnExit', + 'addOnPostRun', + 'addRunDependency', + 'removeRunDependency', + 'FS_createFolder', + 'FS_createPath', + 'FS_createLazyFile', + 'FS_createLink', + 'FS_createDevice', + 'FS_readFile', + 'out', + 'err', + 'callMain', + 'abort', + 'wasmMemory', + 'wasmExports', + 'writeStackCookie', + 'checkStackCookie', + 'convertI32PairToI53Checked', + 'stackSave', + 'stackRestore', + 'stackAlloc', + 'ptrToString', + 'getHeapMax', + 'abortOnCannotGrowMemory', + 'ENV', + 'MONTH_DAYS_REGULAR', + 'MONTH_DAYS_LEAP', + 'MONTH_DAYS_REGULAR_CUMULATIVE', + 'MONTH_DAYS_LEAP_CUMULATIVE', + 'ERRNO_CODES', + 'ERRNO_MESSAGES', + 'DNS', + 'Protocols', + 'Sockets', + 'timers', + 'warnOnce', + 'readEmAsmArgsArray', + 'jstoi_s', + 'dynCallLegacy', + 'getDynCaller', + 'dynCall', + 'wasmTable', + 'noExitRuntime', + 'getCFunc', + 'freeTableIndexes', + 'functionsInTableMap', + 'setValue', + 'getValue', + 'PATH', + 'PATH_FS', + 'UTF8Decoder', + 'UTF8ArrayToString', + 'UTF8ToString', + 'stringToUTF8Array', + 'stringToUTF8', + 'lengthBytesUTF8', + 'UTF16Decoder', + 'UTF16ToString', + 'stringToUTF16', + 'lengthBytesUTF16', + 'UTF32ToString', + 'stringToUTF32', + 'lengthBytesUTF32', + 'stringToUTF8OnStack', + 'writeArrayToMemory', + 'JSEvents', + 'specialHTMLTargets', + 'findCanvasEventTarget', + 'currentFullscreenStrategy', + 'restoreOldWindowedStyle', + 'UNWIND_CACHE', + 'ExitStatus', + 'flush_NO_FILESYSTEM', + 'promiseMap', + 'uncaughtExceptionCount', + 'exceptionLast', + 'exceptionCaught', + 'Browser', + 'getPreloadedImageData__data', + 'wget', + 'SYSCALLS', + 'preloadPlugins', + 'FS_stdin_getChar_buffer', + 'FS', + 'MEMFS', + 'TTY', + 'PIPEFS', + 'SOCKFS', + 'tempFixedLengthArray', + 'miniTempWebGLFloatBuffers', + 'miniTempWebGLIntBuffers', + 'GL', + 'AL', + 'GLUT', + 'EGL', + 'GLEW', + 'IDBStore', + 'SDL', + 'SDL_gfx', + 'allocateUTF8', + 'allocateUTF8OnStack', + 'InternalError', + 'BindingError', + 'throwInternalError', + 'throwBindingError', + 'registeredTypes', + 'awaitingDependencies', + 'typeDependencies', + 'tupleRegistrations', + 'structRegistrations', + 'sharedRegisterType', + 'whenDependentTypesAreResolved', + 'embind_charCodes', + 'embind_init_charCodes', + 'readLatin1String', + 'getTypeName', + 'getFunctionName', + 'heap32VectorToArray', + 'requireRegisteredType', + 'usesDestructorStack', + 'createJsInvoker', + 'UnboundTypeError', + 'PureVirtualError', + 'GenericWireTypeSize', + 'EmValType', + 'throwUnboundTypeError', + 'ensureOverloadTable', + 'exposePublicSymbol', + 'replacePublicSymbol', + 'extendError', + 'createNamedFunction', + 'embindRepr', + 'registeredInstances', + 'registeredPointers', + 'registerType', + 'integerReadValueFromPointer', + 'floatReadValueFromPointer', + 'readPointer', + 'runDestructors', + 'newFunc', + 'craftInvokerFunction', + 'embind__requireFunction', + 'finalizationRegistry', + 'detachFinalizer_deps', + 'deletionQueue', + 'delayFunction', + 'emval_freelist', + 'emval_handles', + 'emval_symbols', + 'init_emval', + 'count_emval_handles', + 'getStringOrSymbol', + 'Emval', + 'emval_returnValue', + 'emval_lookupTypes', + 'emval_methodCallers', + 'emval_addMethodCaller', + 'reflectConstruct', +]; +unexportedSymbols.forEach(unexportedRuntimeSymbol); + + + +var calledRun; + +dependenciesFulfilled = function runCaller() { + // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false) + if (!calledRun) run(); + if (!calledRun) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled +}; + +function stackCheckInit() { + // This is normally called automatically during __wasm_call_ctors but need to + // get these values before even running any of the ctors so we call it redundantly + // here. + _emscripten_stack_init(); + // TODO(sbc): Move writeStackCookie to native to to avoid this. + writeStackCookie(); +} + +function run() { + + if (runDependencies > 0) { + return; + } + + stackCheckInit(); + + preRun(); + + // a preRun added a dependency, run will be called later + if (runDependencies > 0) { + return; + } + + function doRun() { + // run may have just been called through dependencies being fulfilled just in this very frame, + // or while the async setStatus time below was happening + if (calledRun) return; + calledRun = true; + Module['calledRun'] = true; + + if (ABORT) return; + + initRuntime(); + + if (Module['onRuntimeInitialized']) Module['onRuntimeInitialized'](); + + assert(!Module['_main'], 'compiled without a main, but one is present. if you added it from JS, use Module["onRuntimeInitialized"]'); + + postRun(); + } + + if (Module['setStatus']) { + Module['setStatus']('Running...'); + setTimeout(function() { + setTimeout(function() { + Module['setStatus'](''); + }, 1); + doRun(); + }, 1); + } else + { + doRun(); + } + checkStackCookie(); +} + +function checkUnflushedContent() { + // Compiler settings do not allow exiting the runtime, so flushing + // the streams is not possible. but in ASSERTIONS mode we check + // if there was something to flush, and if so tell the user they + // should request that the runtime be exitable. + // Normally we would not even include flush() at all, but in ASSERTIONS + // builds we do so just for this check, and here we see if there is any + // content to flush, that is, we check if there would have been + // something a non-ASSERTIONS build would have not seen. + // How we flush the streams depends on whether we are in SYSCALLS_REQUIRE_FILESYSTEM=0 + // mode (which has its own special function for this; otherwise, all + // the code is inside libc) + var oldOut = out; + var oldErr = err; + var has = false; + out = err = (x) => { + has = true; + } + try { // it doesn't matter if it fails + flush_NO_FILESYSTEM(); + } catch(e) {} + out = oldOut; + err = oldErr; + if (has) { + warnOnce('stdio streams had content in them that was not flushed. you should set EXIT_RUNTIME to 1 (see the Emscripten FAQ), or make sure to emit a newline when you printf etc.'); + warnOnce('(this may also be due to not including full filesystem support - try building with -sFORCE_FILESYSTEM)'); + } +} + +if (Module['preInit']) { + if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']]; + while (Module['preInit'].length > 0) { + Module['preInit'].pop()(); + } +} + +run(); + +// end include: postamble.js + diff --git a/src/js/btclock_datahandler.wasm b/src/js/btclock_datahandler.wasm new file mode 100755 index 0000000000000000000000000000000000000000..689fb7f7c549592bc23030430d7109822bd85b72 GIT binary patch literal 70292 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 h6}^x>A=&nj^Vp$G?(Gk_)5 { + const widgetContainer = document.createElement('div'); + widgetContainer.id = 'btclock-widget'; + document.body.appendChild(widgetContainer); + + const app = createApp(Widget); + app.provide('Module', Module); + + app.mount('#btclock-widget'); + }; + + // Export the mount function to be used when the script is included + (window as any).mountWidget = mountWidget; \ No newline at end of file diff --git a/src/styles/main.scss b/src/styles/main.scss new file mode 100644 index 0000000..e035e08 --- /dev/null +++ b/src/styles/main.scss @@ -0,0 +1,125 @@ +@import "@fontsource/oswald/latin-400"; + +@import "../node_modules/bootstrap/scss/functions"; +@import "../node_modules/bootstrap/scss/variables"; +@import "../node_modules/bootstrap/scss/mixins"; +@import "../node_modules/bootstrap/scss/maps"; + +@import "../node_modules/bootstrap/scss/root"; +@import "../node_modules/bootstrap/scss/reboot"; + +.btclock { + border: 1px solid darkgray; + background: #000; + border-radius: 5px; + padding: 10px; + margin: 10px; + display: flex; + flex-direction: row; + flex-wrap: nowrap; + justify-content: space-between; + align-items: center; + align-content: stretch; +} + +.btclock * { + font-family: "Oswald", sans-serif; +} + +.btclock>div { + padding: 5px; +} + +.digit { + font-size: 4rem; + padding-left: 10px !important; + padding-right: 10px !important; +} + +.splitText div:first-child::after { + display: block; + content: ""; + margin-top: 0px; + border-bottom: 2px solid; + padding-top: 3px; + margin-bottom: 3px; +} + +.digit, +.splitText, +.mediumText { + border: 2px solid gold; + border-radius: 8px; + min-width: 41.25px; + margin: 5px; + text-align: center; + color: #fff; +} + +.digit { + font-size: 2.5rem; + padding-left: 5px !important; + padding-right: 5px !important; + +} + +.splitText { + font-size: 0.625rem; + padding-top: 16px !important; + padding-bottom: 16px !important; + + text-align: center; +} + +.mediumText { + font-size: 1.0rem; + padding-left: 5px; + padding-right: 5px; + padding-top: 23px !important; + padding-bottom: 23px !important; +} + +@keyframes backgroundAnimation { + 0% { + background-color: black; + } + + 50% { + background-color: #fdf4dc; + } + + 100% { + background-color: black; + } +} + +.widget-container { + display: flex; + flex-direction: column; + flex-wrap: wrap; + justify-content: flex-start; + align-items: stretch; + align-content: stretch; + margin: 0 auto; + + .btclock { + margin: 0; + max-width: 100%; + } + + .animate { + animation: backgroundAnimation 1s 1; + } +} + +.close-button { + position: absolute; + right: 0; + color: #fff; + background: transparent; + border: none; + + *:hover { + color: #fff; + } +} \ No newline at end of file diff --git a/src/vite-env.d.ts b/src/vite-env.d.ts new file mode 100644 index 0000000..11f02fe --- /dev/null +++ b/src/vite-env.d.ts @@ -0,0 +1 @@ +/// diff --git a/src/ws_connection.ts b/src/ws_connection.ts new file mode 100644 index 0000000..d94f2ee --- /dev/null +++ b/src/ws_connection.ts @@ -0,0 +1,65 @@ +import { EventEmitter } from "events"; + +export class WsConnection extends EventEmitter { + private instance: WebSocket | null = null; +// protected url!: String; + + constructor(protected url: string) { + super(); + } + + open() { + this.instance = new WebSocket(this.url); + + if (!this.instance) + return; + + this.instance.onopen = ((event) => { + this.onOpen(); + }); + + this.instance.onmessage = ((event) => { + this.onMessage(event.data); + }); + + + this.instance.onerror = ((event) => { + this.onError(event); + }); + + this.instance.onclose = ((event) => { + console.log(event.code); + this.onClose(); + this.reconnect(); + }); + } + + send(data: string) { + this.instance?.send(data); + } + + reconnect() { + this.instance = null; + setTimeout(() => { + this.open(); + }, 1000); + + this.emit('reconnect'); + } + + private onOpen() { + this.emit('open'); + } + + private onError(event) { + this.emit('error', event); + } + + private onMessage(data) { + this.emit('message', data); + } + + private onClose() { + this.emit('close'); + } +} \ No newline at end of file diff --git a/tsconfig.app.json b/tsconfig.app.json new file mode 100644 index 0000000..b8e9723 --- /dev/null +++ b/tsconfig.app.json @@ -0,0 +1,27 @@ +{ + "compilerOptions": { + "composite": true, + "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo", + "target": "ES2020", + "useDefineForClassFields": true, + "module": "ESNext", + "lib": ["ES2020", "DOM", "DOM.Iterable"], + "skipLibCheck": true, + + /* Bundler mode */ + "moduleResolution": "bundler", + "allowImportingTsExtensions": true, + "resolveJsonModule": true, + "isolatedModules": true, + "moduleDetection": "force", + "noEmit": true, + "jsx": "preserve", + + /* Linting */ + "strict": true, + "noUnusedLocals": true, + "noUnusedParameters": true, + "noFallthroughCasesInSwitch": true + }, + "include": ["src/**/*.ts", "src/**/*.tsx", "src/**/*.vue"] +} diff --git a/tsconfig.json b/tsconfig.json new file mode 100644 index 0000000..ea9d0cd --- /dev/null +++ b/tsconfig.json @@ -0,0 +1,11 @@ +{ + "files": [], + "references": [ + { + "path": "./tsconfig.app.json" + }, + { + "path": "./tsconfig.node.json" + } + ] +} diff --git a/tsconfig.node.json b/tsconfig.node.json new file mode 100644 index 0000000..3afdd6e --- /dev/null +++ b/tsconfig.node.json @@ -0,0 +1,13 @@ +{ + "compilerOptions": { + "composite": true, + "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo", + "skipLibCheck": true, + "module": "ESNext", + "moduleResolution": "bundler", + "allowSyntheticDefaultImports": true, + "strict": true, + "noEmit": true + }, + "include": ["vite.config.ts"] +} diff --git a/vite.config.ts b/vite.config.ts new file mode 100644 index 0000000..afd3c6d --- /dev/null +++ b/vite.config.ts @@ -0,0 +1,36 @@ +import { defineConfig } from 'vite' +import vue from '@vitejs/plugin-vue' +import path from 'path'; +import { viteStaticCopy } from 'vite-plugin-static-copy' +import EnvironmentPlugin from 'vite-plugin-environment'; + +// https://vitejs.dev/config/ +export default defineConfig({ + plugins: [vue(), viteStaticCopy({ + targets: [ + { + src: 'src/js/*', + dest: 'js' + } + ], + + }), EnvironmentPlugin({ + // Add your environment variables here + NODE_ENV: 'production' + })], + build: { + lib: { + entry: path.resolve(__dirname, 'src/main.ts'), + name: 'BTClockWidget', + fileName: (format) => `btclock-widget.${format}.js`, + }, + rollupOptions: { + external: ['vue'], + output: { + globals: { + vue: 'Vue' + } + } + } + } +}) diff --git a/yarn.lock b/yarn.lock new file mode 100644 index 0000000..67be2b7 --- /dev/null +++ b/yarn.lock @@ -0,0 +1,791 @@ +# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY. +# yarn lockfile v1 + + +"@babel/parser@^7.24.7": + version "7.24.7" + resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.24.7.tgz#9a5226f92f0c5c8ead550b750f5608e766c8ce85" + integrity sha512-9uUYRm6OqQrCqQdG1iCBwBPZgN8ciDBro2nIOFaiRz1/BCxaI7CNvQbDHvsArAC7Tw9Hda/B3U+6ui9u4HWXPw== + +"@esbuild/aix-ppc64@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz#c7184a326533fcdf1b8ee0733e21c713b975575f" + integrity sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ== + +"@esbuild/android-arm64@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz#09d9b4357780da9ea3a7dfb833a1f1ff439b4052" + integrity sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A== + +"@esbuild/android-arm@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/android-arm/-/android-arm-0.21.5.tgz#9b04384fb771926dfa6d7ad04324ecb2ab9b2e28" + integrity sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg== + +"@esbuild/android-x64@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/android-x64/-/android-x64-0.21.5.tgz#29918ec2db754cedcb6c1b04de8cd6547af6461e" + integrity sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA== + +"@esbuild/darwin-arm64@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz#e495b539660e51690f3928af50a76fb0a6ccff2a" + integrity sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ== + +"@esbuild/darwin-x64@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz#c13838fa57372839abdddc91d71542ceea2e1e22" + integrity sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw== + +"@esbuild/freebsd-arm64@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz#646b989aa20bf89fd071dd5dbfad69a3542e550e" + integrity sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g== + +"@esbuild/freebsd-x64@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz#aa615cfc80af954d3458906e38ca22c18cf5c261" + integrity sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ== + +"@esbuild/linux-arm64@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz#70ac6fa14f5cb7e1f7f887bcffb680ad09922b5b" + integrity sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q== + +"@esbuild/linux-arm@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz#fc6fd11a8aca56c1f6f3894f2bea0479f8f626b9" + integrity sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA== + +"@esbuild/linux-ia32@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz#3271f53b3f93e3d093d518d1649d6d68d346ede2" + integrity sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg== + +"@esbuild/linux-loong64@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz#ed62e04238c57026aea831c5a130b73c0f9f26df" + integrity sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg== + +"@esbuild/linux-mips64el@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz#e79b8eb48bf3b106fadec1ac8240fb97b4e64cbe" + integrity sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg== + +"@esbuild/linux-ppc64@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz#5f2203860a143b9919d383ef7573521fb154c3e4" + integrity sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w== + +"@esbuild/linux-riscv64@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz#07bcafd99322d5af62f618cb9e6a9b7f4bb825dc" + integrity sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA== + +"@esbuild/linux-s390x@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz#b7ccf686751d6a3e44b8627ababc8be3ef62d8de" + integrity sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A== + +"@esbuild/linux-x64@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz#6d8f0c768e070e64309af8004bb94e68ab2bb3b0" + integrity sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ== + +"@esbuild/netbsd-x64@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz#bbe430f60d378ecb88decb219c602667387a6047" + integrity sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg== + +"@esbuild/openbsd-x64@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz#99d1cf2937279560d2104821f5ccce220cb2af70" + integrity sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow== + +"@esbuild/sunos-x64@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz#08741512c10d529566baba837b4fe052c8f3487b" + integrity sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg== + +"@esbuild/win32-arm64@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz#675b7385398411240735016144ab2e99a60fc75d" + integrity sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A== + +"@esbuild/win32-ia32@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz#1bfc3ce98aa6ca9a0969e4d2af72144c59c1193b" + integrity sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA== + +"@esbuild/win32-x64@0.21.5": + version "0.21.5" + resolved "https://registry.yarnpkg.com/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz#acad351d582d157bb145535db2a6ff53dd514b5c" + integrity sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw== + +"@fontsource/antonio@^5.0.20": + version "5.0.20" + resolved "https://registry.yarnpkg.com/@fontsource/antonio/-/antonio-5.0.20.tgz#602451a54acfbe39c5c26c0f1100d6deeb170ed4" + integrity sha512-57Vtqyt1eIJOM8UtmDR913VCOjV6nOVNhYjBcOvL+Ym3EpCMCXqKobidAI6BOR1V+GHuSgcQYRKMMqlSLYpT1g== + +"@fontsource/oswald@^5.0.20": + version "5.0.20" + resolved "https://registry.yarnpkg.com/@fontsource/oswald/-/oswald-5.0.20.tgz#223ab7e7fdede4d9df22434f5a1f346d7997dc75" + integrity sha512-4oWDUT8j4XrDb/TJGlHwtGsWiVTNChnAUaU8/oYuF4pisO7PDElT+gk1rbNSAJCQ++3CnrJXrrr931O0cPcwpw== + +"@jridgewell/sourcemap-codec@^1.4.15": + version "1.4.15" + resolved "https://registry.yarnpkg.com/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz#d7c6e6755c78567a951e04ab52ef0fd26de59f32" + integrity sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg== + +"@nodelib/fs.scandir@2.1.5": + version "2.1.5" + resolved "https://registry.yarnpkg.com/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz#7619c2eb21b25483f6d167548b4cfd5a7488c3d5" + integrity sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g== + dependencies: + "@nodelib/fs.stat" "2.0.5" + run-parallel "^1.1.9" + +"@nodelib/fs.stat@2.0.5", "@nodelib/fs.stat@^2.0.2": + version "2.0.5" + resolved "https://registry.yarnpkg.com/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz#5bd262af94e9d25bd1e71b05deed44876a222e8b" + integrity sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A== + +"@nodelib/fs.walk@^1.2.3": + version "1.2.8" + resolved "https://registry.yarnpkg.com/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz#e95737e8bb6746ddedf69c556953494f196fe69a" + integrity sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg== + dependencies: + "@nodelib/fs.scandir" "2.1.5" + fastq "^1.6.0" + +"@rollup/rollup-android-arm-eabi@4.18.0": + version "4.18.0" + resolved "https://registry.yarnpkg.com/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.18.0.tgz#bbd0e616b2078cd2d68afc9824d1fadb2f2ffd27" + integrity sha512-Tya6xypR10giZV1XzxmH5wr25VcZSncG0pZIjfePT0OVBvqNEurzValetGNarVrGiq66EBVAFn15iYX4w6FKgQ== + +"@rollup/rollup-android-arm64@4.18.0": + version "4.18.0" + resolved "https://registry.yarnpkg.com/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.18.0.tgz#97255ef6384c5f73f4800c0de91f5f6518e21203" + integrity sha512-avCea0RAP03lTsDhEyfy+hpfr85KfyTctMADqHVhLAF3MlIkq83CP8UfAHUssgXTYd+6er6PaAhx/QGv4L1EiA== + +"@rollup/rollup-darwin-arm64@4.18.0": + version "4.18.0" + resolved "https://registry.yarnpkg.com/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.18.0.tgz#b6dd74e117510dfe94541646067b0545b42ff096" + integrity sha512-IWfdwU7KDSm07Ty0PuA/W2JYoZ4iTj3TUQjkVsO/6U+4I1jN5lcR71ZEvRh52sDOERdnNhhHU57UITXz5jC1/w== + +"@rollup/rollup-darwin-x64@4.18.0": + version "4.18.0" + resolved "https://registry.yarnpkg.com/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.18.0.tgz#e07d76de1cec987673e7f3d48ccb8e106d42c05c" + integrity sha512-n2LMsUz7Ynu7DoQrSQkBf8iNrjOGyPLrdSg802vk6XT3FtsgX6JbE8IHRvposskFm9SNxzkLYGSq9QdpLYpRNA== + +"@rollup/rollup-linux-arm-gnueabihf@4.18.0": + version "4.18.0" + resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.18.0.tgz#9f1a6d218b560c9d75185af4b8bb42f9f24736b8" + integrity sha512-C/zbRYRXFjWvz9Z4haRxcTdnkPt1BtCkz+7RtBSuNmKzMzp3ZxdM28Mpccn6pt28/UWUCTXa+b0Mx1k3g6NOMA== + +"@rollup/rollup-linux-arm-musleabihf@4.18.0": + version "4.18.0" + resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.18.0.tgz#53618b92e6ffb642c7b620e6e528446511330549" + integrity sha512-l3m9ewPgjQSXrUMHg93vt0hYCGnrMOcUpTz6FLtbwljo2HluS4zTXFy2571YQbisTnfTKPZ01u/ukJdQTLGh9A== + +"@rollup/rollup-linux-arm64-gnu@4.18.0": + version "4.18.0" + resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.18.0.tgz#99a7ba5e719d4f053761a698f7b52291cefba577" + integrity sha512-rJ5D47d8WD7J+7STKdCUAgmQk49xuFrRi9pZkWoRD1UeSMakbcepWXPF8ycChBoAqs1pb2wzvbY6Q33WmN2ftw== + +"@rollup/rollup-linux-arm64-musl@4.18.0": + version "4.18.0" + resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.18.0.tgz#f53db99a45d9bc00ce94db8a35efa7c3c144a58c" + integrity sha512-be6Yx37b24ZwxQ+wOQXXLZqpq4jTckJhtGlWGZs68TgdKXJgw54lUUoFYrg6Zs/kjzAQwEwYbp8JxZVzZLRepQ== + +"@rollup/rollup-linux-powerpc64le-gnu@4.18.0": + version "4.18.0" + resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-powerpc64le-gnu/-/rollup-linux-powerpc64le-gnu-4.18.0.tgz#cbb0837408fe081ce3435cf3730e090febafc9bf" + integrity sha512-hNVMQK+qrA9Todu9+wqrXOHxFiD5YmdEi3paj6vP02Kx1hjd2LLYR2eaN7DsEshg09+9uzWi2W18MJDlG0cxJA== + +"@rollup/rollup-linux-riscv64-gnu@4.18.0": + version "4.18.0" + resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.18.0.tgz#8ed09c1d1262ada4c38d791a28ae0fea28b80cc9" + integrity sha512-ROCM7i+m1NfdrsmvwSzoxp9HFtmKGHEqu5NNDiZWQtXLA8S5HBCkVvKAxJ8U+CVctHwV2Gb5VUaK7UAkzhDjlg== + +"@rollup/rollup-linux-s390x-gnu@4.18.0": + version "4.18.0" + resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.18.0.tgz#938138d3c8e0c96f022252a28441dcfb17afd7ec" + integrity sha512-0UyyRHyDN42QL+NbqevXIIUnKA47A+45WyasO+y2bGJ1mhQrfrtXUpTxCOrfxCR4esV3/RLYyucGVPiUsO8xjg== + +"@rollup/rollup-linux-x64-gnu@4.18.0": + version "4.18.0" + resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.18.0.tgz#1a7481137a54740bee1ded4ae5752450f155d942" + integrity sha512-xuglR2rBVHA5UsI8h8UbX4VJ470PtGCf5Vpswh7p2ukaqBGFTnsfzxUBetoWBWymHMxbIG0Cmx7Y9qDZzr648w== + +"@rollup/rollup-linux-x64-musl@4.18.0": + version "4.18.0" + resolved "https://registry.yarnpkg.com/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.18.0.tgz#f1186afc601ac4f4fc25fac4ca15ecbee3a1874d" + integrity sha512-LKaqQL9osY/ir2geuLVvRRs+utWUNilzdE90TpyoX0eNqPzWjRm14oMEE+YLve4k/NAqCdPkGYDaDF5Sw+xBfg== + +"@rollup/rollup-win32-arm64-msvc@4.18.0": + version "4.18.0" + resolved "https://registry.yarnpkg.com/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.18.0.tgz#ed6603e93636a96203c6915be4117245c1bd2daf" + integrity sha512-7J6TkZQFGo9qBKH0pk2cEVSRhJbL6MtfWxth7Y5YmZs57Pi+4x6c2dStAUvaQkHQLnEQv1jzBUW43GvZW8OFqA== + +"@rollup/rollup-win32-ia32-msvc@4.18.0": + version "4.18.0" + resolved "https://registry.yarnpkg.com/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.18.0.tgz#14e0b404b1c25ebe6157a15edb9c46959ba74c54" + integrity sha512-Txjh+IxBPbkUB9+SXZMpv+b/vnTEtFyfWZgJ6iyCmt2tdx0OF5WhFowLmnh8ENGNpfUlUZkdI//4IEmhwPieNg== + +"@rollup/rollup-win32-x64-msvc@4.18.0": + version "4.18.0" + resolved "https://registry.yarnpkg.com/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.18.0.tgz#5d694d345ce36b6ecf657349e03eb87297e68da4" + integrity sha512-UOo5FdvOL0+eIVTgS4tIdbW+TtnBLWg1YBCcU2KWM7nuNwRz9bksDX1bekJJCpu25N1DVWaCwnT39dVQxzqS8g== + +"@types/estree@1.0.5": + version "1.0.5" + resolved "https://registry.yarnpkg.com/@types/estree/-/estree-1.0.5.tgz#a6ce3e556e00fd9895dd872dd172ad0d4bd687f4" + integrity sha512-/kYRxGDLWzHOB7q+wtSUQlFrtcdUccpfy+X+9iMBpHK8QLLhx2wIPYuS5DYtR9Wa/YlZAbIovy7qVdB1Aq6Lyw== + +"@types/node@^20.14.8": + version "20.14.8" + resolved "https://registry.yarnpkg.com/@types/node/-/node-20.14.8.tgz#45c26a2a5de26c3534a9504530ddb3b27ce031ac" + integrity sha512-DO+2/jZinXfROG7j7WKFn/3C6nFwxy2lLpgLjEXJz+0XKphZlTLJ14mo8Vfg8X5BWN6XjyESXq+LcYdT7tR3bA== + dependencies: + undici-types "~5.26.4" + +"@vitejs/plugin-vue@^5.0.5": + version "5.0.5" + resolved "https://registry.yarnpkg.com/@vitejs/plugin-vue/-/plugin-vue-5.0.5.tgz#e3dc11e427d4b818b7e3202766ad156e3d5e2eaa" + integrity sha512-LOjm7XeIimLBZyzinBQ6OSm3UBCNVCpLkxGC0oWmm2YPzVZoxMsdvNVimLTBzpAnR9hl/yn1SHGuRfe6/Td9rQ== + +"@volar/language-core@2.3.4", "@volar/language-core@~2.3.1": + version "2.3.4" + resolved "https://registry.yarnpkg.com/@volar/language-core/-/language-core-2.3.4.tgz#51de0263039a567a12a1eea90e02e59cdbf5de3b" + integrity sha512-wXBhY11qG6pCDAqDnbBRFIDSIwbqkWI7no+lj5+L7IlA7HRIjRP7YQLGzT0LF4lS6eHkMSsclXqy9DwYJasZTQ== + dependencies: + "@volar/source-map" "2.3.4" + +"@volar/source-map@2.3.4": + version "2.3.4" + resolved "https://registry.yarnpkg.com/@volar/source-map/-/source-map-2.3.4.tgz#1d285610134fe565ca59a54e5a99c12befc70c93" + integrity sha512-C+t63nwcblqLIVTYXaVi/+gC8NukDaDIQI72J3R7aXGvtgaVB16c+J8Iz7/VfOy7kjYv7lf5GhBny6ACw9fTGQ== + +"@volar/typescript@~2.3.1": + version "2.3.4" + resolved "https://registry.yarnpkg.com/@volar/typescript/-/typescript-2.3.4.tgz#bfa2834c79bd0b9a38cdfdf220fea0afa8ed64b0" + integrity sha512-acCvt7dZECyKcvO5geNybmrqOsu9u8n5XP1rfiYsOLYGPxvHRav9BVmEdRyZ3vvY6mNyQ1wLL5Hday4IShe17w== + dependencies: + "@volar/language-core" "2.3.4" + path-browserify "^1.0.1" + vscode-uri "^3.0.8" + +"@vue/compiler-core@3.4.30": + version "3.4.30" + resolved "https://registry.yarnpkg.com/@vue/compiler-core/-/compiler-core-3.4.30.tgz#a554978f68199a0f254ad5159e9665370c8c1250" + integrity sha512-ZL8y4Xxdh8O6PSwfdZ1IpQ24PjTAieOz3jXb/MDTfDtANcKBMxg1KLm6OX2jofsaQGYfIVzd3BAG22i56/cF1w== + dependencies: + "@babel/parser" "^7.24.7" + "@vue/shared" "3.4.30" + entities "^4.5.0" + estree-walker "^2.0.2" + source-map-js "^1.2.0" + +"@vue/compiler-dom@3.4.30", "@vue/compiler-dom@^3.4.0": + version "3.4.30" + resolved "https://registry.yarnpkg.com/@vue/compiler-dom/-/compiler-dom-3.4.30.tgz#5af9a5f6f0752f7882d4eba0795e4d00525006dc" + integrity sha512-+16Sd8lYr5j/owCbr9dowcNfrHd+pz+w2/b5Lt26Oz/kB90C9yNbxQ3bYOvt7rI2bxk0nqda39hVcwDFw85c2Q== + dependencies: + "@vue/compiler-core" "3.4.30" + "@vue/shared" "3.4.30" + +"@vue/compiler-sfc@3.4.30": + version "3.4.30" + resolved "https://registry.yarnpkg.com/@vue/compiler-sfc/-/compiler-sfc-3.4.30.tgz#6a3cc86c20349f8c1976c968a8c80dd7cfef2430" + integrity sha512-8vElKklHn/UY8+FgUFlQrYAPbtiSB2zcgeRKW7HkpSRn/JjMRmZvuOtwDx036D1aqKNSTtXkWRfqx53Qb+HmMg== + dependencies: + "@babel/parser" "^7.24.7" + "@vue/compiler-core" "3.4.30" + "@vue/compiler-dom" "3.4.30" + "@vue/compiler-ssr" "3.4.30" + "@vue/shared" "3.4.30" + estree-walker "^2.0.2" + magic-string "^0.30.10" + postcss "^8.4.38" + source-map-js "^1.2.0" + +"@vue/compiler-ssr@3.4.30": + version "3.4.30" + resolved "https://registry.yarnpkg.com/@vue/compiler-ssr/-/compiler-ssr-3.4.30.tgz#7938b51f17d62b883d2a61ae42ec4f8398115b1d" + integrity sha512-ZJ56YZGXJDd6jky4mmM0rNaNP6kIbQu9LTKZDhcpddGe/3QIalB1WHHmZ6iZfFNyj5mSypTa4+qDJa5VIuxMSg== + dependencies: + "@vue/compiler-dom" "3.4.30" + "@vue/shared" "3.4.30" + +"@vue/language-core@2.0.22": + version "2.0.22" + resolved "https://registry.yarnpkg.com/@vue/language-core/-/language-core-2.0.22.tgz#2f8164ecc83f85f27301521d0a6ce37cc59bb23a" + integrity sha512-dNTAAtEOuMiz7N1s5tKpypnVVCtawxVSF5BukD0ELcYSw+DSbrSlYYSw8GuwvurodCeYFSHsmslE+c2sYDNoiA== + dependencies: + "@volar/language-core" "~2.3.1" + "@vue/compiler-dom" "^3.4.0" + "@vue/shared" "^3.4.0" + computeds "^0.0.1" + minimatch "^9.0.3" + muggle-string "^0.4.1" + path-browserify "^1.0.1" + vue-template-compiler "^2.7.14" + +"@vue/reactivity@3.4.30": + version "3.4.30" + resolved "https://registry.yarnpkg.com/@vue/reactivity/-/reactivity-3.4.30.tgz#6849e293eab7feed7d307446feaf1e3d759d5c45" + integrity sha512-bVJurnCe3LS0JII8PPoAA63Zd2MBzcKrEzwdQl92eHCcxtIbxD2fhNwJpa+KkM3Y/A4T5FUnmdhgKwOf6BfbcA== + dependencies: + "@vue/shared" "3.4.30" + +"@vue/runtime-core@3.4.30": + version "3.4.30" + resolved "https://registry.yarnpkg.com/@vue/runtime-core/-/runtime-core-3.4.30.tgz#6db949b273af0b988b4f13fecb034f9c9439c41e" + integrity sha512-qaFEbnNpGz+tlnkaualomogzN8vBLkgzK55uuWjYXbYn039eOBZrWxyXWq/7qh9Bz2FPifZqGjVDl/FXiq9L2g== + dependencies: + "@vue/reactivity" "3.4.30" + "@vue/shared" "3.4.30" + +"@vue/runtime-dom@3.4.30": + version "3.4.30" + resolved "https://registry.yarnpkg.com/@vue/runtime-dom/-/runtime-dom-3.4.30.tgz#49f399adc300a000419cb57a20b4481c98f523a4" + integrity sha512-tV6B4YiZRj5QsaJgw2THCy5C1H+2UeywO9tqgWEc21tn85qHEERndHN/CxlyXvSBFrpmlexCIdnqPuR9RM9thw== + dependencies: + "@vue/reactivity" "3.4.30" + "@vue/runtime-core" "3.4.30" + "@vue/shared" "3.4.30" + csstype "^3.1.3" + +"@vue/server-renderer@3.4.30": + version "3.4.30" + resolved "https://registry.yarnpkg.com/@vue/server-renderer/-/server-renderer-3.4.30.tgz#41f117cec12b5fbb9d7c741f59e7a0b515e9b607" + integrity sha512-TBD3eqR1DeDc0cMrXS/vEs/PWzq1uXxnvjoqQuDGFIEHFIwuDTX/KWAQKIBjyMWLFHEeTDGYVsYci85z2UbTDg== + dependencies: + "@vue/compiler-ssr" "3.4.30" + "@vue/shared" "3.4.30" + +"@vue/shared@3.4.30", "@vue/shared@^3.4.0": + version "3.4.30" + resolved "https://registry.yarnpkg.com/@vue/shared/-/shared-3.4.30.tgz#72acfe8df65139dcf298e965fb2ab1cff419e400" + integrity sha512-CLg+f8RQCHQnKvuHY9adMsMaQOcqclh6Z5V9TaoMgy0ut0tz848joZ7/CYFFyF/yZ5i2yaw7Fn498C+CNZVHIg== + +anymatch@~3.1.2: + version "3.1.3" + resolved "https://registry.yarnpkg.com/anymatch/-/anymatch-3.1.3.tgz#790c58b19ba1720a84205b57c618d5ad8524973e" + integrity sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw== + dependencies: + normalize-path "^3.0.0" + picomatch "^2.0.4" + +balanced-match@^1.0.0: + version "1.0.2" + resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.2.tgz#e83e3a7e3f300b34cb9d87f615fa0cbf357690ee" + integrity sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw== + +binary-extensions@^2.0.0: + version "2.3.0" + resolved "https://registry.yarnpkg.com/binary-extensions/-/binary-extensions-2.3.0.tgz#f6e14a97858d327252200242d4ccfe522c445522" + integrity sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw== + +bootstrap@^5.3.3: + version "5.3.3" + resolved "https://registry.yarnpkg.com/bootstrap/-/bootstrap-5.3.3.tgz#de35e1a765c897ac940021900fcbb831602bac38" + integrity sha512-8HLCdWgyoMguSO9o+aH+iuZ+aht+mzW0u3HIMzVu7Srrpv7EBBxTnrFlSCskwdY1+EOFQSm7uMJhNQHkdPcmjg== + +brace-expansion@^2.0.1: + version "2.0.1" + resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-2.0.1.tgz#1edc459e0f0c548486ecf9fc99f2221364b9a0ae" + integrity sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA== + dependencies: + balanced-match "^1.0.0" + +braces@^3.0.3, braces@~3.0.2: + version "3.0.3" + resolved "https://registry.yarnpkg.com/braces/-/braces-3.0.3.tgz#490332f40919452272d55a8480adc0c441358789" + integrity sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA== + dependencies: + fill-range "^7.1.1" + +"chokidar@>=3.0.0 <4.0.0", chokidar@^3.5.3: + version "3.6.0" + resolved "https://registry.yarnpkg.com/chokidar/-/chokidar-3.6.0.tgz#197c6cc669ef2a8dc5e7b4d97ee4e092c3eb0d5b" + integrity sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw== + dependencies: + anymatch "~3.1.2" + braces "~3.0.2" + glob-parent "~5.1.2" + is-binary-path "~2.1.0" + is-glob "~4.0.1" + normalize-path "~3.0.0" + readdirp "~3.6.0" + optionalDependencies: + fsevents "~2.3.2" + +computeds@^0.0.1: + version "0.0.1" + resolved "https://registry.yarnpkg.com/computeds/-/computeds-0.0.1.tgz#215b08a4ba3e08a11ff6eee5d6d8d7166a97ce2e" + integrity sha512-7CEBgcMjVmitjYo5q8JTJVra6X5mQ20uTThdK+0kR7UEaDrAWEQcRiBtWJzga4eRpP6afNwwLsX2SET2JhVB1Q== + +csstype@^3.1.3: + version "3.1.3" + resolved "https://registry.yarnpkg.com/csstype/-/csstype-3.1.3.tgz#d80ff294d114fb0e6ac500fbf85b60137d7eff81" + integrity sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw== + +de-indent@^1.0.2: + version "1.0.2" + resolved "https://registry.yarnpkg.com/de-indent/-/de-indent-1.0.2.tgz#b2038e846dc33baa5796128d0804b455b8c1e21d" + integrity sha512-e/1zu3xH5MQryN2zdVaF0OrdNLUbvWxzMbi+iNA6Bky7l1RoP8a2fIbRocyHclXt/arDrrR6lL3TqFD9pMQTsg== + +entities@^4.5.0: + version "4.5.0" + resolved "https://registry.yarnpkg.com/entities/-/entities-4.5.0.tgz#5d268ea5e7113ec74c4d033b79ea5a35a488fb48" + integrity sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw== + +esbuild@^0.21.3: + version "0.21.5" + resolved "https://registry.yarnpkg.com/esbuild/-/esbuild-0.21.5.tgz#9ca301b120922959b766360d8ac830da0d02997d" + integrity sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw== + optionalDependencies: + "@esbuild/aix-ppc64" "0.21.5" + "@esbuild/android-arm" "0.21.5" + "@esbuild/android-arm64" "0.21.5" + "@esbuild/android-x64" "0.21.5" + "@esbuild/darwin-arm64" "0.21.5" + "@esbuild/darwin-x64" "0.21.5" + "@esbuild/freebsd-arm64" "0.21.5" + "@esbuild/freebsd-x64" "0.21.5" + "@esbuild/linux-arm" "0.21.5" + "@esbuild/linux-arm64" "0.21.5" + "@esbuild/linux-ia32" "0.21.5" + "@esbuild/linux-loong64" "0.21.5" + "@esbuild/linux-mips64el" "0.21.5" + "@esbuild/linux-ppc64" "0.21.5" + "@esbuild/linux-riscv64" "0.21.5" + "@esbuild/linux-s390x" "0.21.5" + "@esbuild/linux-x64" "0.21.5" + "@esbuild/netbsd-x64" "0.21.5" + "@esbuild/openbsd-x64" "0.21.5" + "@esbuild/sunos-x64" "0.21.5" + "@esbuild/win32-arm64" "0.21.5" + "@esbuild/win32-ia32" "0.21.5" + "@esbuild/win32-x64" "0.21.5" + +estree-walker@^2.0.2: + version "2.0.2" + resolved "https://registry.yarnpkg.com/estree-walker/-/estree-walker-2.0.2.tgz#52f010178c2a4c117a7757cfe942adb7d2da4cac" + integrity sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w== + +events@^3.3.0: + version "3.3.0" + resolved "https://registry.yarnpkg.com/events/-/events-3.3.0.tgz#31a95ad0a924e2d2c419a813aeb2c4e878ea7400" + integrity sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q== + +fast-glob@^3.2.11: + version "3.3.2" + resolved "https://registry.yarnpkg.com/fast-glob/-/fast-glob-3.3.2.tgz#a904501e57cfdd2ffcded45e99a54fef55e46129" + integrity sha512-oX2ruAFQwf/Orj8m737Y5adxDQO0LAB7/S5MnxCdTNDd4p6BsyIVsv9JQsATbTSq8KHRpLwIHbVlUNatxd+1Ow== + dependencies: + "@nodelib/fs.stat" "^2.0.2" + "@nodelib/fs.walk" "^1.2.3" + glob-parent "^5.1.2" + merge2 "^1.3.0" + micromatch "^4.0.4" + +fastq@^1.6.0: + version "1.17.1" + resolved "https://registry.yarnpkg.com/fastq/-/fastq-1.17.1.tgz#2a523f07a4e7b1e81a42b91b8bf2254107753b47" + integrity sha512-sRVD3lWVIXWg6By68ZN7vho9a1pQcN/WBFaAAsDDFzlJjvoGx0P8z7V1t72grFJfJhu3YPZBuu25f7Kaw2jN1w== + dependencies: + reusify "^1.0.4" + +fill-range@^7.1.1: + version "7.1.1" + resolved "https://registry.yarnpkg.com/fill-range/-/fill-range-7.1.1.tgz#44265d3cac07e3ea7dc247516380643754a05292" + integrity sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg== + dependencies: + to-regex-range "^5.0.1" + +fs-extra@^11.1.0: + version "11.2.0" + resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-11.2.0.tgz#e70e17dfad64232287d01929399e0ea7c86b0e5b" + integrity sha512-PmDi3uwK5nFuXh7XDTlVnS17xJS7vW36is2+w3xcv8SVxiB4NyATf4ctkVY5bkSjX0Y4nbvZCq1/EjtEyr9ktw== + dependencies: + graceful-fs "^4.2.0" + jsonfile "^6.0.1" + universalify "^2.0.0" + +fsevents@~2.3.2, fsevents@~2.3.3: + version "2.3.3" + resolved "https://registry.yarnpkg.com/fsevents/-/fsevents-2.3.3.tgz#cac6407785d03675a2a5e1a5305c697b347d90d6" + integrity sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw== + +glob-parent@^5.1.2, glob-parent@~5.1.2: + version "5.1.2" + resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-5.1.2.tgz#869832c58034fe68a4093c17dc15e8340d8401c4" + integrity sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow== + dependencies: + is-glob "^4.0.1" + +graceful-fs@^4.1.6, graceful-fs@^4.2.0: + version "4.2.11" + resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.11.tgz#4183e4e8bf08bb6e05bbb2f7d2e0c8f712ca40e3" + integrity sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ== + +he@^1.2.0: + version "1.2.0" + resolved "https://registry.yarnpkg.com/he/-/he-1.2.0.tgz#84ae65fa7eafb165fddb61566ae14baf05664f0f" + integrity sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw== + +immutable@^4.0.0: + version "4.3.6" + resolved "https://registry.yarnpkg.com/immutable/-/immutable-4.3.6.tgz#6a05f7858213238e587fb83586ffa3b4b27f0447" + integrity sha512-Ju0+lEMyzMVZarkTn/gqRpdqd5dOPaz1mCZ0SH3JV6iFw81PldE/PEB1hWVEA288HPt4WXW8O7AWxB10M+03QQ== + +is-binary-path@~2.1.0: + version "2.1.0" + resolved "https://registry.yarnpkg.com/is-binary-path/-/is-binary-path-2.1.0.tgz#ea1f7f3b80f064236e83470f86c09c254fb45b09" + integrity sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw== + dependencies: + binary-extensions "^2.0.0" + +is-extglob@^2.1.1: + version "2.1.1" + resolved "https://registry.yarnpkg.com/is-extglob/-/is-extglob-2.1.1.tgz#a88c02535791f02ed37c76a1b9ea9773c833f8c2" + integrity sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ== + +is-glob@^4.0.1, is-glob@~4.0.1: + version "4.0.3" + resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-4.0.3.tgz#64f61e42cbbb2eec2071a9dac0b28ba1e65d5084" + integrity sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg== + dependencies: + is-extglob "^2.1.1" + +is-number@^7.0.0: + version "7.0.0" + resolved "https://registry.yarnpkg.com/is-number/-/is-number-7.0.0.tgz#7535345b896734d5f80c4d06c50955527a14f12b" + integrity sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng== + +jsonfile@^6.0.1: + version "6.1.0" + resolved "https://registry.yarnpkg.com/jsonfile/-/jsonfile-6.1.0.tgz#bc55b2634793c679ec6403094eb13698a6ec0aae" + integrity sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ== + dependencies: + universalify "^2.0.0" + optionalDependencies: + graceful-fs "^4.1.6" + +magic-string@^0.30.10: + version "0.30.10" + resolved "https://registry.yarnpkg.com/magic-string/-/magic-string-0.30.10.tgz#123d9c41a0cb5640c892b041d4cfb3bd0aa4b39e" + integrity sha512-iIRwTIf0QKV3UAnYK4PU8uiEc4SRh5jX0mwpIwETPpHdhVM4f53RSwS/vXvN1JhGX+Cs7B8qIq3d6AH49O5fAQ== + dependencies: + "@jridgewell/sourcemap-codec" "^1.4.15" + +merge2@^1.3.0: + version "1.4.1" + resolved "https://registry.yarnpkg.com/merge2/-/merge2-1.4.1.tgz#4368892f885e907455a6fd7dc55c0c9d404990ae" + integrity sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg== + +micromatch@^4.0.4: + version "4.0.7" + resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-4.0.7.tgz#33e8190d9fe474a9895525f5618eee136d46c2e5" + integrity sha512-LPP/3KorzCwBxfeUuZmaR6bG2kdeHSbe0P2tY3FLRU4vYrjYz5hI4QZwV0njUx3jeuKe67YukQ1LSPZBKDqO/Q== + dependencies: + braces "^3.0.3" + picomatch "^2.3.1" + +minimatch@^9.0.3: + version "9.0.4" + resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-9.0.4.tgz#8e49c731d1749cbec05050ee5145147b32496a51" + integrity sha512-KqWh+VchfxcMNRAJjj2tnsSJdNbHsVgnkBhTNrW7AjVo6OvLtxw8zfT9oLw1JSohlFzJ8jCoTgaoXvJ+kHt6fw== + dependencies: + brace-expansion "^2.0.1" + +muggle-string@^0.4.1: + version "0.4.1" + resolved "https://registry.yarnpkg.com/muggle-string/-/muggle-string-0.4.1.tgz#3b366bd43b32f809dc20659534dd30e7c8a0d328" + integrity sha512-VNTrAak/KhO2i8dqqnqnAHOa3cYBwXEZe9h+D5h/1ZqFSTEFHdM65lR7RoIqq3tBBYavsOXV84NoHXZ0AkPyqQ== + +nanoid@^3.3.7: + version "3.3.7" + resolved "https://registry.yarnpkg.com/nanoid/-/nanoid-3.3.7.tgz#d0c301a691bc8d54efa0a2226ccf3fe2fd656bd8" + integrity sha512-eSRppjcPIatRIMC1U6UngP8XFcz8MQWGQdt1MTBQ7NaAmvXDfvNxbvWV3x2y6CdEUciCSsDHDQZbhYaB8QEo2g== + +normalize-path@^3.0.0, normalize-path@~3.0.0: + version "3.0.0" + resolved "https://registry.yarnpkg.com/normalize-path/-/normalize-path-3.0.0.tgz#0dcd69ff23a1c9b11fd0978316644a0388216a65" + integrity sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA== + +path-browserify@^1.0.1: + version "1.0.1" + resolved "https://registry.yarnpkg.com/path-browserify/-/path-browserify-1.0.1.tgz#d98454a9c3753d5790860f16f68867b9e46be1fd" + integrity sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g== + +picocolors@^1.0.0: + version "1.0.1" + resolved "https://registry.yarnpkg.com/picocolors/-/picocolors-1.0.1.tgz#a8ad579b571952f0e5d25892de5445bcfe25aaa1" + integrity sha512-anP1Z8qwhkbmu7MFP5iTt+wQKXgwzf7zTyGlcdzabySa9vd0Xt392U0rVmz9poOaBj0uHJKyyo9/upk0HrEQew== + +picomatch@^2.0.4, picomatch@^2.2.1, picomatch@^2.3.1: + version "2.3.1" + resolved "https://registry.yarnpkg.com/picomatch/-/picomatch-2.3.1.tgz#3ba3833733646d9d3e4995946c1365a67fb07a42" + integrity sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA== + +postcss@^8.4.38: + version "8.4.38" + resolved "https://registry.yarnpkg.com/postcss/-/postcss-8.4.38.tgz#b387d533baf2054288e337066d81c6bee9db9e0e" + integrity sha512-Wglpdk03BSfXkHoQa3b/oulrotAkwrlLDRSOb9D0bN86FdRyE9lppSp33aHNPgBa0JKCoB+drFLZkQoRRYae5A== + dependencies: + nanoid "^3.3.7" + picocolors "^1.0.0" + source-map-js "^1.2.0" + +queue-microtask@^1.2.2: + version "1.2.3" + resolved "https://registry.yarnpkg.com/queue-microtask/-/queue-microtask-1.2.3.tgz#4929228bbc724dfac43e0efb058caf7b6cfb6243" + integrity sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A== + +readdirp@~3.6.0: + version "3.6.0" + resolved "https://registry.yarnpkg.com/readdirp/-/readdirp-3.6.0.tgz#74a370bd857116e245b29cc97340cd431a02a6c7" + integrity sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA== + dependencies: + picomatch "^2.2.1" + +reusify@^1.0.4: + version "1.0.4" + resolved "https://registry.yarnpkg.com/reusify/-/reusify-1.0.4.tgz#90da382b1e126efc02146e90845a88db12925d76" + integrity sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw== + +rollup@^4.13.0: + version "4.18.0" + resolved "https://registry.yarnpkg.com/rollup/-/rollup-4.18.0.tgz#497f60f0c5308e4602cf41136339fbf87d5f5dda" + integrity sha512-QmJz14PX3rzbJCN1SG4Xe/bAAX2a6NpCP8ab2vfu2GiUr8AQcr2nCV/oEO3yneFarB67zk8ShlIyWb2LGTb3Sg== + dependencies: + "@types/estree" "1.0.5" + optionalDependencies: + "@rollup/rollup-android-arm-eabi" "4.18.0" + "@rollup/rollup-android-arm64" "4.18.0" + "@rollup/rollup-darwin-arm64" "4.18.0" + "@rollup/rollup-darwin-x64" "4.18.0" + "@rollup/rollup-linux-arm-gnueabihf" "4.18.0" + "@rollup/rollup-linux-arm-musleabihf" "4.18.0" + "@rollup/rollup-linux-arm64-gnu" "4.18.0" + "@rollup/rollup-linux-arm64-musl" "4.18.0" + "@rollup/rollup-linux-powerpc64le-gnu" "4.18.0" + "@rollup/rollup-linux-riscv64-gnu" "4.18.0" + "@rollup/rollup-linux-s390x-gnu" "4.18.0" + "@rollup/rollup-linux-x64-gnu" "4.18.0" + "@rollup/rollup-linux-x64-musl" "4.18.0" + "@rollup/rollup-win32-arm64-msvc" "4.18.0" + "@rollup/rollup-win32-ia32-msvc" "4.18.0" + "@rollup/rollup-win32-x64-msvc" "4.18.0" + fsevents "~2.3.2" + +run-parallel@^1.1.9: + version "1.2.0" + resolved "https://registry.yarnpkg.com/run-parallel/-/run-parallel-1.2.0.tgz#66d1368da7bdf921eb9d95bd1a9229e7f21a43ee" + integrity sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA== + dependencies: + queue-microtask "^1.2.2" + +sass@^1.77.6: + version "1.77.6" + resolved "https://registry.yarnpkg.com/sass/-/sass-1.77.6.tgz#898845c1348078c2e6d1b64f9ee06b3f8bd489e4" + integrity sha512-ByXE1oLD79GVq9Ht1PeHWCPMPB8XHpBuz1r85oByKHjZY6qV6rWnQovQzXJXuQ/XyE1Oj3iPk3lo28uzaRA2/Q== + dependencies: + chokidar ">=3.0.0 <4.0.0" + immutable "^4.0.0" + source-map-js ">=0.6.2 <2.0.0" + +semver@^7.5.4: + version "7.6.2" + resolved "https://registry.yarnpkg.com/semver/-/semver-7.6.2.tgz#1e3b34759f896e8f14d6134732ce798aeb0c6e13" + integrity sha512-FNAIBWCx9qcRhoHcgcJ0gvU7SN1lYU2ZXuSfl04bSC5OpvDHFyJCjdNHomPXxjQlCBU67YW64PzY7/VIEH7F2w== + +"source-map-js@>=0.6.2 <2.0.0", source-map-js@^1.2.0: + version "1.2.0" + resolved "https://registry.yarnpkg.com/source-map-js/-/source-map-js-1.2.0.tgz#16b809c162517b5b8c3e7dcd315a2a5c2612b2af" + integrity sha512-itJW8lvSA0TXEphiRoawsCksnlf8SyvmFzIhltqAHluXd88pkCd+cXJVHTDwdCr0IzwptSm035IHQktUu1QUMg== + +to-regex-range@^5.0.1: + version "5.0.1" + resolved "https://registry.yarnpkg.com/to-regex-range/-/to-regex-range-5.0.1.tgz#1648c44aae7c8d988a326018ed72f5b4dd0392e4" + integrity sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ== + dependencies: + is-number "^7.0.0" + +typescript@^5.2.2: + version "5.5.2" + resolved "https://registry.yarnpkg.com/typescript/-/typescript-5.5.2.tgz#c26f023cb0054e657ce04f72583ea2d85f8d0507" + integrity sha512-NcRtPEOsPFFWjobJEtfihkLCZCXZt/os3zf8nTxjVH3RvTSxjrCamJpbExGvYOF+tFHc3pA65qpdwPbzjohhew== + +undici-types@~5.26.4: + version "5.26.5" + resolved "https://registry.yarnpkg.com/undici-types/-/undici-types-5.26.5.tgz#bcd539893d00b56e964fd2657a4866b221a65617" + integrity sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA== + +universalify@^2.0.0: + version "2.0.1" + resolved "https://registry.yarnpkg.com/universalify/-/universalify-2.0.1.tgz#168efc2180964e6386d061e094df61afe239b18d" + integrity sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw== + +vite-plugin-environment@^1.1.3: + version "1.1.3" + resolved "https://registry.yarnpkg.com/vite-plugin-environment/-/vite-plugin-environment-1.1.3.tgz#d01a04abb2f69730a4866c9c9db51d3dab74645b" + integrity sha512-9LBhB0lx+2lXVBEWxFZC+WO7PKEyE/ykJ7EPWCq95NEcCpblxamTbs5Dm3DLBGzwODpJMEnzQywJU8fw6XGGGA== + +vite-plugin-static-copy@^1.0.5: + version "1.0.5" + resolved "https://registry.yarnpkg.com/vite-plugin-static-copy/-/vite-plugin-static-copy-1.0.5.tgz#6f695b9c02af09860cb8d40ee243167b6823e4a6" + integrity sha512-02k0Rox+buYdEOfeilKZSgs1gXfPf9RjVztZEIYZgVIxjsVZi6AXssjzdi+qW6zYt00d3bq+tpP2voVXN2fKLw== + dependencies: + chokidar "^3.5.3" + fast-glob "^3.2.11" + fs-extra "^11.1.0" + picocolors "^1.0.0" + +vite@^5.3.1: + version "5.3.1" + resolved "https://registry.yarnpkg.com/vite/-/vite-5.3.1.tgz#bb2ca6b5fd7483249d3e86b25026e27ba8a663e6" + integrity sha512-XBmSKRLXLxiaPYamLv3/hnP/KXDai1NDexN0FpkTaZXTfycHvkRHoenpgl/fvuK/kPbB6xAgoyiryAhQNxYmAQ== + dependencies: + esbuild "^0.21.3" + postcss "^8.4.38" + rollup "^4.13.0" + optionalDependencies: + fsevents "~2.3.3" + +vscode-uri@^3.0.8: + version "3.0.8" + resolved "https://registry.yarnpkg.com/vscode-uri/-/vscode-uri-3.0.8.tgz#1770938d3e72588659a172d0fd4642780083ff9f" + integrity sha512-AyFQ0EVmsOZOlAnxoFOGOq1SQDWAB7C6aqMGS23svWAllfOaxbuFvcT8D1i8z3Gyn8fraVeZNNmN6e9bxxXkKw== + +vue-template-compiler@^2.7.14: + version "2.7.16" + resolved "https://registry.yarnpkg.com/vue-template-compiler/-/vue-template-compiler-2.7.16.tgz#c81b2d47753264c77ac03b9966a46637482bb03b" + integrity sha512-AYbUWAJHLGGQM7+cNTELw+KsOG9nl2CnSv467WobS5Cv9uk3wFcnr1Etsz2sEIHEZvw1U+o9mRlEO6QbZvUPGQ== + dependencies: + de-indent "^1.0.2" + he "^1.2.0" + +vue-tsc@^2.0.21: + version "2.0.22" + resolved "https://registry.yarnpkg.com/vue-tsc/-/vue-tsc-2.0.22.tgz#ddfef6b3a016d1b986008a3b8702f7e667db128c" + integrity sha512-lMBIwPBO0sxCcmvu45yt1b035AaQ8/XSXQDk8m75y4j0jSXY/y/XzfEtssQ9JMS47lDaR10O3/926oCs8OeGUw== + dependencies: + "@volar/typescript" "~2.3.1" + "@vue/language-core" "2.0.22" + semver "^7.5.4" + +vue@^3.4.29: + version "3.4.30" + resolved "https://registry.yarnpkg.com/vue/-/vue-3.4.30.tgz#02c75c63a21e305c38a937866d8ee2269b62bbb4" + integrity sha512-NcxtKCwkdf1zPsr7Y8+QlDBCGqxvjLXF2EX+yi76rV5rrz90Y6gK1cq0olIhdWGgrlhs9ElHuhi9t3+W5sG5Xw== + dependencies: + "@vue/compiler-dom" "3.4.30" + "@vue/compiler-sfc" "3.4.30" + "@vue/runtime-dom" "3.4.30" + "@vue/server-renderer" "3.4.30" + "@vue/shared" "3.4.30"